list-toolkit 2.1.0 → 2.2.0

package/README.md

@@ -15,7 +15,7 @@ The toolkit provides the following data structures with a full set of efficientl
   * Value-based lists, where a list serves as a container for external objects, and node-based lists, where a list uses custom properties on external objects to link them around.
   * Hosted lists, which use a special head node to manage nodes, and headless lists, which point to an external list without including any headers.
 * Heaps:
-  * Min-heap to support priority queues.
+  * Priority queues: min heap, leftist heap, skew heap.
 * Various list-based data structures:
   * Caches with various eviction algorithms: least recently used (LRU), least frequently used (LFU), first in first out (FIFO), and random.
     * A decorator is provided to decorate functions, methods, and getters with a cache of your choice.
@@ -101,7 +101,7 @@ const john = new Person('John'),
 
 const people = List.from([john, jane, jim, jill]);
 
-// iterator over the list manually:
+// iterate over the list manually:
 for (let node = people.front; node !== people; node = node[people.nextName]) {
   console.log(node.name); // John, Jane, Jim, Jill
 }
@@ -146,6 +146,8 @@ BSD 3-Clause "New" or "Revised" License. See the LICENSE file for details.
 
 ## Release History
 
+* 2.2.0 *Added leftist and skew heaps.*
+* 2.1.1 *Allowed functions to be used as nodes. Updated deps.*
 * 2.1.0 *Added splay tree. Updated deps.*
 * 2.0.0 *New major release.*
 * 1.0.1 *Fixed exports. Added more methods to `MinHeap`.*

package/cjs/heap/basics.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.HeapBase = void 0;
+var _metaUtils = require("../meta-utils.js");
+const defaultLess = (a, b) => a < b;
+const defaultEqual = (a, b) => a === b;
+class HeapBase {
+  constructor(options) {
+    (0, _metaUtils.copyOptions)(this, HeapBase.defaults, options);
+  }
+
+  // main methods
+  get isEmpty() {
+    throw new Error('Not implemented');
+  }
+  get top() {
+    throw new Error('Not implemented');
+  }
+  peek() {
+    return this.top;
+  }
+  pop() {
+    throw new Error('Not implemented');
+  }
+  push() {
+    throw new Error('Not implemented');
+  }
+  clear() {
+    throw new Error('Not implemented');
+  }
+
+  // performance methods
+  pushPop(value) {
+    this.push(value);
+    return this.pop();
+  }
+  replaceTop(value) {
+    const z = this.pop();
+    this.push(value);
+    return z;
+  }
+
+  // helper methods
+  merge(...args) {
+    throw new Error('Not implemented');
+  }
+  clone() {
+    throw new Error('Not implemented');
+  }
+  make(...args) {
+    return new this.constructor(this, ...args);
+  }
+}
+exports.HeapBase = HeapBase;
+HeapBase.defaults = {
+  less: defaultLess,
+  equal: defaultEqual,
+  compare: null
+};
+var _default = exports.default = HeapBase;

package/cjs/heap/leftist-heap.js

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.LeftistHeapNode = exports.LeftistHeap = void 0;
+var _basics = _interopRequireDefault(require("./basics.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const defaultLess = (a, b) => a < b;
+const merge = (a, b, less) => {
+  if (!a) return b;
+  if (!b) return a;
+  if (less(b.value, a.value)) [a, b] = [b, a]; // swap
+
+  a.right = merge(a.right, b, less);
+  if (!a.left) {
+    [a.left, a.right] = [a.right, a.left]; // swap
+    a.s = 1;
+    return a;
+  }
+  if (a.left.s < a.right.s) {
+    [a.left, a.right] = [a.right, a.left]; // swap
+  }
+  a.s = a.right.s + 1;
+  return a;
+};
+class LeftistHeapNode {
+  constructor(value) {
+    this.value = value;
+    this.right = this.left = null;
+    this.s = 1;
+  }
+  clear() {
+    this.left = this.right = null;
+    this.s = 1;
+  }
+  clone() {
+    const node = new LeftistHeapNode(this.value);
+    node.left = this.left && this.left.clone();
+    node.right = this.right && this.right.clone();
+    return node;
+  }
+}
+exports.LeftistHeapNode = LeftistHeapNode;
+class LeftistHeap extends _basics.default {
+  constructor(options, ...args) {
+    super(options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+    }
+    this.root = null;
+    this.size = 0;
+    if (args.length) this.merge(...args);
+  }
+  get isEmpty() {
+    return !this.root;
+  }
+  get length() {
+    return this.size;
+  }
+  get top() {
+    return this.root ? this.root.value : undefined;
+  }
+  peek() {
+    return this.root ? this.root.value : undefined;
+  }
+  push(value) {
+    this.root = merge(this.root, new LeftistHeapNode(value), this.less);
+    ++this.size;
+    return this;
+  }
+  pop() {
+    if (!this.root) return;
+    const z = this.root;
+    this.root = merge(this.root.left, this.root.right, this.less);
+    --this.size;
+    return z.value;
+  }
+  pushPop(value) {
+    if (!this.root || this.less(value, this.root.value)) return value;
+    const z = this.root;
+    this.root = merge(z.left, new LeftistHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  replaceTop(value) {
+    if (!this.root) {
+      this.root = new LeftistHeapNode(value);
+      this.size = 1;
+      return; // undefined
+    }
+    const z = this.root;
+    this.root = merge(z.left, new LeftistHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  clear() {
+    this.root = null;
+    this.size = 0;
+    return this;
+  }
+  merge(...args) {
+    for (const other of args) {
+      this.root = merge(this.root, other.root, this.less);
+      this.size += other.size;
+      other.root = null;
+      other.size = 0;
+    }
+    return this;
+  }
+  clone() {
+    const heap = new LeftistHeap(this);
+    heap.root = this.root && this.root.clone();
+    heap.size = this.size;
+    return heap;
+  }
+  static from(array, options = _basics.default.defaults) {
+    const heap = new LeftistHeap(options);
+    for (const value of array) heap.push(value);
+    return heap;
+  }
+}
+exports.LeftistHeap = LeftistHeap;
+var _default = exports.default = LeftistHeap;

package/cjs/heap/min-heap.js

@@ -4,15 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.MinHeap = void 0;
-var _metaUtils = require("../meta-utils.js");
+var _basics = _interopRequireDefault(require("./basics.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // the following functions are inlined:
 
 // const left = i => (i << 1) + 1;
 // const right = i => (i + 1) << 1;
 // const parent = i => (i - 1) >> 1;
 
-const defaultLess = (a, b) => a < b;
-const defaultEqual = (a, b) => a === b;
 const up = (array, i, less = defaultLess) => {
   for (let p = i - 1 >> 1; i > 0; i = p, p = i - 1 >> 1) {
     const iValue = array[i],
@@ -38,15 +37,15 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   }
   return array;
 };
-class MinHeap {
+class MinHeap extends _basics.default {
   constructor(options, ...args) {
-    (0, _metaUtils.copyOptions)(this, MinHeap.defaults, options);
+    super(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);
+    if (args.length) this.merge(...args);
   }
   get length() {
     return this.array.length;
@@ -191,9 +190,6 @@ class MinHeap {
     })), this.less);
     return this;
   }
-  make(...args) {
-    return new MinHeap(this, ...args);
-  }
   clone() {
     const heap = new MinHeap(this);
     heap.array = this.array.slice(0);
@@ -288,11 +284,11 @@ class MinHeap {
     }
     return heapArray;
   }
+  static from(array, options = MinHeap.defaults) {
+    const heap = new MinHeap(options);
+    heap.array = MinHeap.build(array, heap.less);
+    return heap;
+  }
 }
 exports.MinHeap = MinHeap;
-MinHeap.defaults = {
-  less: defaultLess,
-  equal: defaultEqual,
-  compare: null
-};
 var _default = exports.default = MinHeap;

package/cjs/heap/skew-heap.js

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SkewHeapNode = exports.SkewHeap = void 0;
+var _basics = _interopRequireDefault(require("./basics.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const merge = (a, b, less) => {
+  if (!a) return b;
+  if (!b) return a;
+  if (less(b.value, a.value)) [a, b] = [b, a]; // swap
+
+  const temp = a.right;
+  a.right = a.left;
+  a.left = merge(b, temp, less);
+  return a;
+};
+class SkewHeapNode {
+  constructor(value) {
+    this.value = value;
+    this.right = this.left = null;
+  }
+  clear() {
+    this.left = this.right = null;
+  }
+  clone() {
+    const node = new SkewHeapNode(this.value);
+    node.left = this.left && this.left.clone();
+    node.right = this.right && this.right.clone();
+    return node;
+  }
+}
+exports.SkewHeapNode = SkewHeapNode;
+class SkewHeap extends _basics.default {
+  constructor(options, ...args) {
+    super(options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+    }
+    this.root = null;
+    this.size = 0;
+    if (args.length) this.merge(...args);
+  }
+  get isEmpty() {
+    return !this.root;
+  }
+  get length() {
+    return this.size;
+  }
+  get top() {
+    return this.root ? this.root.value : undefined;
+  }
+  peek() {
+    return this.root ? this.root.value : undefined;
+  }
+  push(value) {
+    this.root = merge(this.root, new SkewHeapNode(value), this.less);
+    ++this.size;
+    return this;
+  }
+  pop() {
+    if (!this.root) return;
+    const z = this.root;
+    this.root = merge(this.root.left, this.root.right, this.less);
+    --this.size;
+    return z.value;
+  }
+  pushPop(value) {
+    if (!this.root || this.less(value, this.root.value)) return value;
+    const z = this.root;
+    this.root = merge(z.left, new SkewHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  replaceTop(value) {
+    if (!this.root) {
+      this.root = new SkewHeapNode(value);
+      this.size = 1;
+      return; // undefined
+    }
+    const z = this.root;
+    this.root = merge(z.left, new SkewHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  clear() {
+    this.root = null;
+    this.size = 0;
+    return this;
+  }
+  merge(...args) {
+    for (const other of args) {
+      this.root = merge(this.root, other.root, this.less);
+      this.size += other.size;
+      other.root = null;
+      other.size = 0;
+    }
+    return this;
+  }
+  clone() {
+    const heap = new SkewHeap(this);
+    heap.root = this.root && this.root.clone();
+    heap.size = this.size;
+    return heap;
+  }
+  static from(array, options = _basics.default.defaults) {
+    const heap = new SkewHeap(options);
+    for (const value of array) heap.push(value);
+    return heap;
+  }
+}
+exports.SkewHeap = SkewHeap;
+var _default = exports.default = SkewHeap;

package/cjs/list/nodes.js

@@ -36,9 +36,9 @@ class HeadNode extends Node {
   isNodeLike(node) {
     if (!node) return false;
     const next = node[this.nextName];
-    if (!next || typeof next != 'object') return false;
+    if (!next || _metaUtils.canHaveProps[typeof next] !== 1) return false;
     const prev = node[this.prevName];
-    return prev && typeof prev == 'object';
+    return prev && _metaUtils.canHaveProps[typeof prev] === 1;
   }
   isCompatibleNames({
     nextName,

package/cjs/meta-utils.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toSnakeCase = exports.toPascalCase = exports.toKebabCase = exports.toCamelCase = exports.toAllCapsSnakeCase = exports.normalizeIterator = exports.mapIterator = exports.fromSnakeCase = exports.fromSetter = exports.fromPascalCase = exports.fromKebabCase = exports.fromGetter = exports.fromCamelCase = exports.fromAccessors = exports.defaultDescriptor = exports.copyOptions = exports.copyDescriptors = exports.capitalize = exports.augmentIterator = exports.addGetters = exports.addDescriptors = exports.addDescriptor = exports.addAliases = exports.addAlias = exports.addAccessor = void 0;
+exports.toSnakeCase = exports.toPascalCase = exports.toKebabCase = exports.toCamelCase = exports.toAllCapsSnakeCase = exports.normalizeIterator = exports.mapIterator = exports.fromSnakeCase = exports.fromSetter = exports.fromPascalCase = exports.fromKebabCase = exports.fromGetter = exports.fromCamelCase = exports.fromAccessors = exports.defaultDescriptor = exports.copyOptions = exports.copyDescriptors = exports.capitalize = exports.canHaveProps = exports.augmentIterator = exports.addGetters = exports.addDescriptors = exports.addDescriptor = exports.addAliases = exports.addAlias = exports.addAccessor = void 0;
 const capitalize = name => name ? name[0].toUpperCase() + name.substring(1).toLowerCase() : name;
 exports.capitalize = capitalize;
 const toCamelCase = names => names.map((name, index) => index ? capitalize(name) : name.toLowerCase()).join('');
@@ -150,6 +150,10 @@ const mapIterator = (iterator, callbackFn) => {
   };
 };
 exports.mapIterator = mapIterator;
+const canHaveProps = exports.canHaveProps = {
+  object: 1,
+  function: 1
+};
 const copyOptions = (target, pattern, ...sources) => {
   target = target || {};
   const keys = Object.keys(pattern);
@@ -157,7 +161,7 @@ const copyOptions = (target, pattern, ...sources) => {
     target[key] = pattern[key];
   }
   for (const source of sources) {
-    if (!source || typeof source !== 'object') continue;
+    if (!source || canHaveProps[typeof source] !== 1) continue;
     for (const key of keys) {
       if (key in source) target[key] = source[key];
     }

package/cjs/slist/nodes.js

@@ -36,7 +36,7 @@ class HeadNode extends Node {
   isNodeLike(node) {
     if (!node) return false;
     const next = node[this.nextName];
-    return next && typeof next == 'object';
+    return next && _metaUtils.canHaveProps[typeof next] === 1;
   }
   isCompatibleNames({
     nextName

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "list-toolkit",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "List-based data structures to organize your objects.",
   "type": "module",
   "exports": {
@@ -10,10 +10,14 @@
     }
   },
   "scripts": {
-    "test": "tape6 --flags FO",
     "prepare-dist": "node scripts/prepare-dist.js",
     "build": "babel src --out-dir cjs",
-    "prepublishOnly": "npm run prepare-dist && npm run build"
+    "prepublishOnly": "npm run prepare-dist && npm run build",
+    "test": "tape6 --flags FO",
+    "test:bun": "tape6-bun --flags FO",
+    "test:deno-original": "tape6-deno --flags FO",
+    "test:deno": "deno run -A `tape6-runner main` --flags FO",
+    "start": "tape6-server --trace"
   },
   "repository": {
     "type": "git",
@@ -27,16 +31,18 @@
     "data structures"
   ],
   "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (http://www.lazutkin.com/)",
+  "funding": "https://github.com/sponsors/uhop",
   "license": "BSD-3-Clause",
   "bugs": {
     "url": "https://github.com/uhop/list-toolkit/issues"
   },
   "homepage": "https://github.com/uhop/list-toolkit#readme",
   "devDependencies": {
-    "@babel/cli": "^7.24.8",
+    "@babel/cli": "^7.25.6",
     "@babel/core": "^7.25.2",
     "@babel/preset-env": "^7.25.4",
-    "tape-six": "^0.9.6"
+    "nano-benchmark": "^1.0.3",
+    "tape-six": "^0.12.2"
   },
   "files": [
     "/src",
@@ -57,6 +63,12 @@
   "tape6": {
     "tests": [
       "/tests/test-*.*js"
-    ]
+    ],
+    "importmap": {
+      "imports": {
+        "tape-six": "/node_modules/tape-six/index.js",
+        "list-toolkit/": "/src/"
+      }
+    }
   }
 }

package/src/heap/basics.js

@@ -0,0 +1,58 @@
+'use strict';
+
+import {copyOptions} from '../meta-utils.js';
+
+const defaultLess = (a, b) => a < b;
+const defaultEqual = (a, b) => a === b;
+
+export class HeapBase {
+  constructor(options) {
+    copyOptions(this, HeapBase.defaults, options);
+  }
+
+  // main methods
+  get isEmpty() {
+    throw new Error('Not implemented');
+  }
+  get top() {
+    throw new Error('Not implemented');
+  }
+  peek() {
+    return this.top;
+  }
+  pop() {
+    throw new Error('Not implemented');
+  }
+  push() {
+    throw new Error('Not implemented');
+  }
+  clear() {
+    throw new Error('Not implemented');
+  }
+
+  // performance methods
+  pushPop(value) {
+    this.push(value);
+    return this.pop();
+  }
+  replaceTop(value) {
+    const z = this.pop();
+    this.push(value);
+    return z;
+  }
+
+  // helper methods
+  merge(...args) {
+    throw new Error('Not implemented');
+  }
+  clone() {
+    throw new Error('Not implemented');
+  }
+  make(...args) {
+    return new this.constructor(this, ...args);
+  }
+}
+
+HeapBase.defaults = {less: defaultLess, equal: defaultEqual, compare: null};
+
+export default HeapBase;

package/src/heap/leftist-heap.js

@@ -0,0 +1,125 @@
+'use strict';
+
+import HeapBase from './basics.js';
+
+const defaultLess = (a, b) => a < b;
+
+const merge = (a, b, less) => {
+  if (!a) return b;
+  if (!b) return a;
+  if (less(b.value, a.value)) [a, b] = [b, a]; // swap
+
+  a.right = merge(a.right, b, less);
+
+  if (!a.left) {
+    [a.left, a.right] = [a.right, a.left]; // swap
+    a.s = 1;
+    return a;
+  }
+
+  if (a.left.s < a.right.s) {
+    [a.left, a.right] = [a.right, a.left]; // swap
+  }
+  a.s = a.right.s + 1;
+  return a;
+};
+
+export class LeftistHeapNode {
+  constructor(value) {
+    this.value = value;
+    this.right = this.left = null;
+    this.s = 1;
+  }
+  clear() {
+    this.left = this.right = null;
+    this.s = 1;
+  }
+  clone() {
+    const node = new LeftistHeapNode(this.value);
+    node.left = this.left && this.left.clone();
+    node.right = this.right && this.right.clone();
+    return node;
+  }
+}
+
+export class LeftistHeap extends HeapBase {
+  constructor(options, ...args) {
+    super(options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+    }
+    this.root = null;
+    this.size = 0;
+    if (args.length) this.merge(...args);
+  }
+  get isEmpty() {
+    return !this.root;
+  }
+  get length() {
+    return this.size;
+  }
+  get top() {
+    return this.root ? this.root.value : undefined;
+  }
+  peek() {
+    return this.root ? this.root.value : undefined;
+  }
+  push(value) {
+    this.root = merge(this.root, new LeftistHeapNode(value), this.less);
+    ++this.size;
+    return this;
+  }
+  pop() {
+    if (!this.root) return;
+    const z = this.root;
+    this.root = merge(this.root.left, this.root.right, this.less);
+    --this.size;
+    return z.value;
+  }
+  pushPop(value) {
+    if (!this.root || this.less(value, this.root.value)) return value;
+    const z = this.root;
+    this.root = merge(z.left, new LeftistHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  replaceTop(value) {
+    if (!this.root) {
+      this.root = new LeftistHeapNode(value);
+      this.size = 1;
+      return; // undefined
+    }
+    const z = this.root;
+    this.root = merge(z.left, new LeftistHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  clear() {
+    this.root = null;
+    this.size = 0;
+    return this;
+  }
+  merge(...args) {
+    for (const other of args) {
+      this.root = merge(this.root, other.root, this.less);
+      this.size += other.size;
+      other.root = null;
+      other.size = 0;
+    }
+    return this;
+  }
+  clone() {
+    const heap = new LeftistHeap(this);
+    heap.root = this.root && this.root.clone();
+    heap.size = this.size;
+    return heap;
+  }
+
+  static from(array, options = HeapBase.defaults) {
+    const heap = new LeftistHeap(options);
+    for (const value of array) heap.push(value);
+    return heap;
+  }
+}
+
+export default LeftistHeap;

package/src/heap/min-heap.js

@@ -1,6 +1,6 @@
 'use strict';
 
-import {copyOptions} from '../meta-utils.js';
+import HeapBase from './basics.js';
 
 // the following functions are inlined:
 
@@ -8,9 +8,6 @@ import {copyOptions} from '../meta-utils.js';
 // const right = i => (i + 1) << 1;
 // const parent = i => (i - 1) >> 1;
 
-const defaultLess = (a, b) => a < b;
-const defaultEqual = (a, b) => a === b;
-
 const up = (array, i, less = defaultLess) => {
   for (let p = (i - 1) >> 1; i > 0; i = p, p = (i - 1) >> 1) {
     const iValue = array[i],
@@ -38,15 +35,15 @@ const down = (array, i, less = defaultLess, n = array.length) => {
   return array;
 };
 
-export class MinHeap {
+export class MinHeap extends HeapBase {
   constructor(options, ...args) {
-    copyOptions(this, MinHeap.defaults, options);
+    super(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);
+    if (args.length) this.merge(...args);
   }
 
   get length() {
@@ -216,10 +213,6 @@ export class MinHeap {
     return this;
   }
 
-  make(...args) {
-    return new MinHeap(this, ...args);
-  }
-
   clone() {
     const heap = new MinHeap(this);
     heap.array = this.array.slice(0);
@@ -327,8 +320,12 @@ export class MinHeap {
     }
     return heapArray;
   }
-}
 
-MinHeap.defaults = {less: defaultLess, equal: defaultEqual, compare: null};
+  static from(array, options = MinHeap.defaults) {
+    const heap = new MinHeap(options);
+    heap.array = MinHeap.build(array, heap.less);
+    return heap;
+  }
+}
 
 export default MinHeap;

package/src/heap/skew-heap.js

@@ -0,0 +1,113 @@
+'use strict';
+
+import HeapBase from './basics.js';
+
+const merge = (a, b, less) => {
+  if (!a) return b;
+  if (!b) return a;
+  if (less(b.value, a.value)) [a, b] = [b, a]; // swap
+
+  const temp = a.right;
+  a.right = a.left;
+  a.left = merge(b, temp, less);
+
+  return a;
+};
+
+export class SkewHeapNode {
+  constructor(value) {
+    this.value = value;
+    this.right = this.left = null;
+  }
+  clear() {
+    this.left = this.right = null;
+  }
+  clone() {
+    const node = new SkewHeapNode(this.value);
+    node.left = this.left && this.left.clone();
+    node.right = this.right && this.right.clone();
+    return node;
+  }
+}
+
+export class SkewHeap extends HeapBase {
+  constructor(options, ...args) {
+    super(options);
+    if (typeof this.compare == 'function') {
+      this.less = (a, b) => this.compare(a, b) < 0;
+    }
+    this.root = null;
+    this.size = 0;
+    if (args.length) this.merge(...args);
+  }
+  get isEmpty() {
+    return !this.root;
+  }
+  get length() {
+    return this.size;
+  }
+  get top() {
+    return this.root ? this.root.value : undefined;
+  }
+  peek() {
+    return this.root ? this.root.value : undefined;
+  }
+  push(value) {
+    this.root = merge(this.root, new SkewHeapNode(value), this.less);
+    ++this.size;
+    return this;
+  }
+  pop() {
+    if (!this.root) return;
+    const z = this.root;
+    this.root = merge(this.root.left, this.root.right, this.less);
+    --this.size;
+    return z.value;
+  }
+  pushPop(value) {
+    if (!this.root || this.less(value, this.root.value)) return value;
+    const z = this.root;
+    this.root = merge(z.left, new SkewHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  replaceTop(value) {
+    if (!this.root) {
+      this.root = new SkewHeapNode(value);
+      this.size = 1;
+      return; // undefined
+    }
+    const z = this.root;
+    this.root = merge(z.left, new SkewHeapNode(value), this.less);
+    this.root = merge(this.root, z.right, this.less);
+    return z.value;
+  }
+  clear() {
+    this.root = null;
+    this.size = 0;
+    return this;
+  }
+  merge(...args) {
+    for (const other of args) {
+      this.root = merge(this.root, other.root, this.less);
+      this.size += other.size;
+      other.root = null;
+      other.size = 0;
+    }
+    return this;
+  }
+  clone() {
+    const heap = new SkewHeap(this);
+    heap.root = this.root && this.root.clone();
+    heap.size = this.size;
+    return heap;
+  }
+
+  static from(array, options = HeapBase.defaults) {
+    const heap = new SkewHeap(options);
+    for (const value of array) heap.push(value);
+    return heap;
+  }
+}
+
+export default SkewHeap;

package/src/list/nodes.js

@@ -1,7 +1,7 @@
 'use strict';
 
 import {isRangeLike, normalizeNode, normalizeRange} from '../list-helpers.js';
-import {addAlias, copyDescriptors} from '../meta-utils.js';
+import {addAlias, copyDescriptors, canHaveProps} from '../meta-utils.js';
 
 export const isNodeLike = ({nextName, prevName}, node) => node && node[prevName] && node[nextName];
 export const isStandAlone = ({nextName, prevName}, node) => node && node[prevName] === node && node[nextName] === node;
@@ -22,9 +22,9 @@ export class HeadNode extends Node {
   isNodeLike(node) {
     if (!node) return false;
     const next = node[this.nextName];
-    if (!next || typeof next != 'object') return false;
+    if (!next || canHaveProps[typeof next] !== 1) return false;
     const prev = node[this.prevName];
-    return prev && typeof prev == 'object';
+    return prev && canHaveProps[typeof prev] === 1;
   }
 
   isCompatibleNames({nextName, prevName}) {

package/src/meta-utils.js

@@ -131,6 +131,8 @@ export const mapIterator = (iterator, callbackFn) => {
   };
 };
 
+export const canHaveProps = {object: 1, function: 1};
+
 export const copyOptions = (target, pattern, ...sources) => {
   target = target || {};
   const keys = Object.keys(pattern);
@@ -138,7 +140,7 @@ export const copyOptions = (target, pattern, ...sources) => {
     target[key] = pattern[key];
   }
   for (const source of sources) {
-    if (!source || typeof source !== 'object') continue;
+    if (!source || canHaveProps[typeof source] !== 1) continue;
     for (const key of keys) {
       if (key in source) target[key] = source[key];
     }

package/src/slist/nodes.js

@@ -1,7 +1,7 @@
 'use strict';
 
 import {isRangeLike, normalizeNode, normalizeRange, normalizePtrRange} from '../list-helpers.js';
-import {addAlias, copyDescriptors} from '../meta-utils.js';
+import {addAlias, copyDescriptors, canHaveProps} from '../meta-utils.js';
 
 export const isNodeLike = ({nextName}, node) => node && node[nextName];
 export const isStandAlone = ({nextName}, node) => node && node[nextName] === node;
@@ -25,7 +25,7 @@ export class HeadNode extends Node {
   isNodeLike(node) {
     if (!node) return false;
     const next = node[this.nextName];
-    return next && typeof next == 'object';
+    return next && canHaveProps[typeof next] === 1;
   }
   isCompatibleNames({nextName}) {
     return this.nextName === nextName;