list-toolkit 1.0.2 → 2.1.0

package/cjs/cache/cache-lfu.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CacheLFU = void 0;
+var _metaUtils = require("../meta-utils.js");
+var _minHeap = _interopRequireDefault(require("../heap/min-heap.js"));
+var _cacheLru = _interopRequireDefault(require("./cache-lru.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Evicts the least frequently used items.
+
+class CacheLFU extends _cacheLru.default {
+  constructor(capacity = 10) {
+    super(capacity);
+    this.heap = new _minHeap.default({
+      less: (a, b) => a.value.counter < b.value.counter
+    });
+  }
+  use(key) {
+    const node = this.dict.get(key);
+    if (node) ++node.value.counter;
+    return node;
+  }
+  update(node, value) {
+    node.value.counter = 1;
+    node.value.value = value;
+    return this;
+  }
+  addNew(key, value) {
+    this.list.pushFront({
+      key,
+      value,
+      counter: 1
+    });
+    const node = this.list.front;
+    this.dict.set(key, node);
+    this.heap.push(node);
+    return node;
+  }
+  evictAndReplace(key, value) {
+    const node = this.heap.top;
+    this.dict.delete(node.value.key);
+    node.value = {
+      key,
+      value,
+      counter: 1
+    };
+    this.dict.set(key, node);
+    this.heap.updateTop();
+    return node;
+  }
+  remove(key) {
+    const node = this.dict.get(key);
+    if (node) {
+      this.dict.delete(key);
+      this.list.removeNode(node);
+      this.heap.remove(node);
+    }
+    return this;
+  }
+  clear() {
+    super.clear();
+    this.heap.clear();
+    return this;
+  }
+  resetCounters(initialValue = 1) {
+    for (const item of this.heap) {
+      item.counter = initialValue;
+    }
+    return this;
+  }
+}
+exports.CacheLFU = CacheLFU;
+(0, _metaUtils.addAlias)(CacheLFU.prototype, 'remove', 'delete');
+var _default = exports.default = CacheLFU;

package/cjs/cache/cache-lru.js

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CacheLRU = void 0;
+var _valueList = _interopRequireDefault(require("../value-list.js"));
+var _metaUtils = require("../meta-utils.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// The base cache class. Evicts the least recently used items.
+// Based on doubly linked value lists.
+
+class CacheLRU {
+  constructor(capacity = 10) {
+    this.capacity = capacity;
+    this.list = new _valueList.default();
+    this.dict = new Map();
+  }
+  get isEmpty() {
+    return !this.dict.size;
+  }
+  get size() {
+    return this.dict.size;
+  }
+  has(key) {
+    return this.dict.has(key);
+  }
+  find(key) {
+    const node = this.use(key);
+    return node ? node.value.value : undefined;
+  }
+  remove(key) {
+    const node = this.dict.get(key);
+    if (node) {
+      this.dict.delete(key);
+      this.list.removeNode(node);
+    }
+    return this;
+  }
+  register(key, value) {
+    const node = this.use(key);
+    if (node) {
+      this.update(node, value);
+      return this;
+    }
+    if (this.dict.size >= this.capacity) {
+      this.evictAndReplace(key, value);
+      return this;
+    }
+    this.addNew(key, value);
+    return this;
+  }
+  use(key) {
+    const node = this.dict.get(key);
+    if (node) this.list.moveToFront(node);
+    return node;
+  }
+  update(node, value) {
+    node.value.value = value;
+    return this;
+  }
+  addNew(key, value) {
+    this.list.pushFront({
+      key,
+      value
+    });
+    const node = this.list.front;
+    this.dict.set(key, node);
+    return node;
+  }
+  evictAndReplace(key, value) {
+    const node = this.list.back;
+    this.list.moveToFront(node);
+    this.dict.delete(node.value.key);
+    this.dict.set(key, node);
+    node.value = {
+      key,
+      value
+    };
+    return node;
+  }
+  clear() {
+    this.dict.clear();
+    this.list.clear();
+    return this;
+  }
+  [Symbol.iterator]() {
+    return this.list[Symbol.iterator]();
+  }
+  getReverseIterator() {
+    return this.list.getReverseIterator();
+  }
+}
+exports.CacheLRU = CacheLRU;
+(0, _metaUtils.addAliases)(CacheLRU.prototype, {
+  register: 'add, set',
+  remove: 'delete',
+  find: 'get'
+});
+var _default = exports.default = CacheLRU;

package/cjs/cache/cache-random.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CacheRandom = void 0;
+var _metaUtils = require("../meta-utils.js");
+var _minHeap = _interopRequireDefault(require("../heap/min-heap.js"));
+var _cacheLru = _interopRequireDefault(require("./cache-lru.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Evicts items randomly.
+
+class CacheRandom extends _cacheLru.default {
+  constructor(capacity = 10) {
+    super(capacity);
+    this.heap = new _minHeap.default({
+      less: (a, b) => a.value.id > b.value.id
+    });
+    this.nextId = 0;
+  }
+  use(key) {
+    return this.dict.get(key);
+  }
+  update(node, value) {
+    node.value.value = value;
+    return this;
+  }
+  addNew(key, value) {
+    this.list.pushFront({
+      key,
+      value,
+      id: this.nextId++
+    });
+    const node = this.list.front;
+    this.dict.set(key, node);
+    this.heap.push(node);
+    return node;
+  }
+  evictAndReplace(key, value) {
+    const index = Math.floor(this.heap.length * Math.random());
+    const node = this.heap.array[index],
+      isDecreased = value > node.value.value;
+    this.dict.delete(node.value.key);
+    this.dict.set(key, node);
+    node.value.key = key;
+    node.value.value = value;
+    this.heap.updateByIndex(index, isDecreased);
+    return node;
+  }
+  remove(key) {
+    const node = this.dict.get(key);
+    if (node) {
+      this.dict.delete(key);
+      this.list.removeNode(node);
+      this.heap.remove(node);
+    }
+    return this;
+  }
+  clear() {
+    super.clear();
+    this.heap.clear();
+    this.nextId = 0;
+    return this;
+  }
+  resetIds() {
+    this.nextId = 0;
+    for (const item of this.heap) {
+      item.id = this.nextId++;
+    }
+    const array = this.heap.array;
+    this.heap.clear().merge(array);
+    return this;
+  }
+}
+exports.CacheRandom = CacheRandom;
+(0, _metaUtils.addAlias)(CacheRandom.prototype, 'remove', 'delete');
+var _default = exports.default = CacheRandom;

package/cjs/cache/decorator.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCache = exports.default = exports.decorateMethod = exports.decorateFn = exports.decorate = void 0;
+const decorateFn = (fn, cache) => {
+  if (typeof fn !== 'function') throw new TypeError('Not a function');
+  const wrapped = function (...args) {
+    const key = args[0],
+      cache = wrapped.cache;
+    if (cache.has(key)) return cache.get(key);
+    const result = wrapped.fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+  wrapped.fn = fn;
+  wrapped.cache = cache;
+  return wrapped;
+};
+exports.decorateFn = decorateFn;
+const decorate = (object, key, cache) => {
+  const descriptor = Object.getOwnPropertyDescriptor(object, key);
+  if (!descriptor) throw new Error('Missing property: ' + key);
+  const newDescriptor = {
+      ...descriptor
+    },
+    wrapped = decorateFn(descriptor.value, cache);
+  newDescriptor.value = wrapped;
+  Object.defineProperty(object, key, newDescriptor);
+  return wrapped;
+};
+exports.decorate = decorate;
+const decorateMethod = (object, key, cache) => {
+  const fn = object[key],
+    wrapped = decorateFn(fn, cache);
+  object[key] = wrapped;
+  return wrapped;
+};
+exports.decorateMethod = decorateMethod;
+const getCache = (object, key) => {
+  const descriptor = Object.getOwnPropertyDescriptor(object, key);
+  if (!descriptor) throw new Error('Missing property: ' + key);
+  return descriptor.value.cache;
+};
+exports.getCache = getCache;
+var _default = exports.default = decorate;

package/cjs/cache.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  cacheDecorator: true
+};
+exports.default = exports.cacheDecorator = void 0;
+var _cacheLru = _interopRequireWildcard(require("./cache/cache-lru.js"));
+Object.keys(_cacheLru).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _cacheLru[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cacheLru[key];
+    }
+  });
+});
+var _decorator = _interopRequireDefault(require("./cache/decorator.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const cacheDecorator = (object, key, cache = new _cacheLru.default()) => (0, _decorator.default)(object, key, cache);
+exports.cacheDecorator = cacheDecorator;
+var _default = exports.default = _cacheLru.default;

package/cjs/ext-list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _ext = _interopRequireWildcard(require("./list/ext.js"));
+Object.keys(_ext).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ext[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ext[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = _ext.default;

package/cjs/ext-slist.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _ext = _interopRequireWildcard(require("./slist/ext.js"));
+Object.keys(_ext).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ext[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ext[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = _ext.default;

package/cjs/ext-value-list.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _extValue = _interopRequireWildcard(require("./list/ext-value.js"));
+Object.keys(_extValue).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _extValue[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _extValue[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = _extValue.default;

package/cjs/ext-value-slist.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _extValue = _interopRequireWildcard(require("./slist/ext-value.js"));
+Object.keys(_extValue).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _extValue[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _extValue[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = _extValue.default;

package/cjs/{MinHeap.js → heap/min-heap.js}

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.MinHeap = void 0;
-var _utils = require("./utils.js");
+var _metaUtils = require("../meta-utils.js");
 // the following functions are inlined:
 
 // const left = i => (i << 1) + 1;
@@ -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;
@@ -47,7 +40,11 @@ const down = (array, i, less = defaultLess, n = array.length) => {
 };
 class MinHeap {
   constructor(options, ...args) {
-    (0, _utils.copyOptions)(this, MinHeap.defaults, options);
+    (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);
   }
@@ -60,9 +57,8 @@ class MinHeap {
   get top() {
     return this.array[0];
   }
-  clear() {
-    this.array = [];
-    return this;
+  peek() {
+    return this.array[0];
   }
   pop() {
     // return MinHeap.pop(this.array, this.less); // inlined
@@ -79,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;
@@ -121,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;
@@ -148,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;
@@ -170,11 +145,36 @@ class MinHeap {
     // return MinHeap.has(this.array, value, this.equal); // inlined
     return this.array.findIndex(element => this.equal(element, value)) >= 0;
   }
+  findIndex(value) {
+    return this.array.findIndex(element => this.equal(element, value));
+  }
   remove(value) {
-    return MinHeap.remove(this.array, value, this.less, this.equal);
+    MinHeap.remove(this.array, value, this.less, this.equal);
+    return this;
+  }
+  removeByIndex(index) {
+    MinHeap.removeByIndex(this.array, index, this.less);
+    return this;
   }
   replace(value, newValue) {
-    return MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+    MinHeap.replace(this.array, value, newValue, this.less, this.equal);
+    return this;
+  }
+  replaceByIndex(index, newValue) {
+    MinHeap.replaceByIndex(this.array, index, newValue, this.less);
+    return this;
+  }
+  updateTop() {
+    down(this.array, 0, this.less);
+    return this;
+  }
+  updateByIndex(index, isDecreased) {
+    MinHeap.updateByIndex(this.array, index, isDecreased, this.less);
+    return this;
+  }
+  clear() {
+    this.array = [];
+    return this;
   }
   releaseSorted() {
     MinHeap.sort(this.array, this.less);
@@ -206,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;
@@ -244,10 +237,7 @@ class MinHeap {
   }
   static pushPop(heapArray, item, less = MinHeap.defaults.less) {
     if (!heapArray.length || less(item, heapArray[0])) return item;
-    const top = heapArray[0];
-    heapArray[0] = item;
-    down(heapArray, 0, less);
-    return top;
+    return MinHeap.replaceTop(heapArray, item, less);
   }
   static replaceTop(heapArray, item, less = MinHeap.defaults.less) {
     const top = heapArray[0];
@@ -261,39 +251,34 @@ class MinHeap {
   static findIndex(heapArray, item, equal = MinHeap.defaults.equal) {
     return heapArray.findIndex(element => equal(element, item));
   }
-  static removeByIndex(heapArray, index, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+  static removeByIndex(heapArray, index, less = MinHeap.defaults.less) {
     if (index < 0 || index >= heapArray.length) return this;
     const last = heapArray.length - 1;
     if (index !== last) {
-      const item = heapArray[index];
-      heapArray[index] = heapArray.pop();
-      if (less(heapArray[index], item)) up(heapArray, index, less);else down(heapArray, index, less);
-    } else heapArray.pop();
-    return this;
+      const item = heapArray[index],
+        newItem = heapArray[index] = heapArray.pop();
+      return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
+    }
+    heapArray.pop();
+    return heapArray;
   }
   static remove(heapArray, item, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
     const index = heapArray.findIndex(element => equal(element, item));
-    if (index < 0) return this;
-    const last = heapArray.length - 1;
-    if (index !== last) {
-      heapArray[index] = heapArray.pop();
-      if (less(heapArray[index], item)) up(heapArray, index, less);else down(heapArray, index, less);
-    } else heapArray.pop();
-    return this;
+    return MinHeap.removeByIndex(heapArray, index, less);
   }
-  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
+  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less) {
     if (index < 0 || index >= heapArray.length) return this;
     const item = heapArray[index];
     heapArray[index] = newItem;
-    if (less(newItem, item)) up(heapArray, index, less);else down(heapArray, index, less);
-    return this;
+    return MinHeap.updateByIndex(heapArray, index, less(newItem, item), less);
   }
   static replace(heapArray, item, newItem, less = MinHeap.defaults.less, equal = MinHeap.defaults.equal) {
     const index = heapArray.findIndex(element => equal(element, item));
-    if (index < 0) return this;
-    heapArray[index] = newItem;
-    if (less(newItem, item)) up(heapArray, index, less);else down(heapArray, index, less);
-    return this;
+    return MinHeap.replaceByIndex(heapArray, index, newItem, less);
+  }
+  static updateByIndex(heapArray, index, isDecreased, less = MinHeap.defaults.less) {
+    if (index < 0 || index >= heapArray.length) return this;
+    return (isDecreased ? up : down)(heapArray, index, less);
   }
   static sort(heapArray, less = MinHeap.defaults.less) {
     if (heapArray.length <= 1) return heapArray;
@@ -307,6 +292,7 @@ class MinHeap {
 exports.MinHeap = MinHeap;
 MinHeap.defaults = {
   less: defaultLess,
-  equal: defaultEqual
+  equal: defaultEqual,
+  compare: null
 };
 var _default = exports.default = MinHeap;