list-toolkit 2.2.5 → 2.3.0

package/cjs/ext-value-slist.js

@@ -1,21 +0,0 @@
-'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 _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-var _default = exports.default = _extValue.default;

package/cjs/heap/basics.js

@@ -1,63 +0,0 @@
-'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

@@ -1,124 +0,0 @@
-'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

@@ -1,294 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.MinHeap = void 0;
-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 up = (array, i, less = defaultLess) => {
-  for (let p = i - 1 >> 1; i > 0; i = p, p = i - 1 >> 1) {
-    const iValue = array[i],
-      pValue = array[p];
-    if (!less(iValue, pValue)) break;
-    array[i] = pValue;
-    array[p] = iValue;
-  }
-  return array;
-};
-const down = (array, i, less = defaultLess, n = array.length) => {
-  for (;;) {
-    const l = (i << 1) + 1;
-    if (l >= n) break;
-    const r = l + 1,
-      c = r < n && less(array[r], array[l]) ? r : l,
-      iValue = array[i],
-      cValue = array[c];
-    if (!less(cValue, iValue)) break;
-    array[i] = cValue;
-    array[c] = iValue;
-    i = c;
-  }
-  return array;
-};
-class MinHeap extends _basics.default {
-  constructor(options, ...args) {
-    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 = [];
-    if (args.length) this.merge(...args);
-  }
-  get length() {
-    return this.array.length;
-  }
-  get isEmpty() {
-    return !this.array.length;
-  }
-  get top() {
-    return this.array[0];
-  }
-  peek() {
-    return this.array[0];
-  }
-  pop() {
-    // return MinHeap.pop(this.array, this.less); // inlined
-    switch (this.array.length) {
-      case 0:
-        return;
-      case 1:
-        return this.array.pop();
-    }
-    const top = this.array[0];
-    this.array[0] = this.array.pop();
-    // down(this.array, 0, this.less); // inlined
-    const n = this.array.length;
-    for (let i = 0;;) {
-      const l = (i << 1) + 1;
-      if (l >= n) break;
-      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];
-      if (!this.less(cValue, iValue)) break;
-      this.array[i] = cValue;
-      this.array[c] = iValue;
-      i = c;
-    }
-    return top;
-  }
-  push(value) {
-    // MinHeap.push(this.array, value, this.less); // inlined
-    let i = this.array.length;
-    this.array.push(value);
-    // up(this.array, i, this.less); // inlined
-    for (let p = i - 1 >> 1; i > 0; i = p, p = i - 1 >> 1) {
-      const iValue = this.array[i],
-        pValue = this.array[p];
-      if (!this.less(iValue, pValue)) break;
-      this.array[i] = pValue;
-      this.array[p] = iValue;
-    }
-    return this;
-  }
-  pushPop(value) {
-    // return MinHeap.pushPop(this.array, value, this.less); // inlined
-    if (!this.array.length || this.less(value, this.array[0])) return value;
-    const top = this.array[0];
-    this.array[0] = value;
-    // down(this.array, 0, this.less); // inlined
-    const n = this.array.length;
-    for (let i = 0;;) {
-      const l = (i << 1) + 1;
-      if (l >= n) break;
-      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];
-      if (!this.less(cValue, iValue)) break;
-      this.array[i] = cValue;
-      this.array[c] = iValue;
-      i = c;
-    }
-    return top;
-  }
-  replaceTop(value) {
-    // return MinHeap.replaceTop(this.array, value, this.less); // inlined
-    const top = this.array[0];
-    this.array[0] = value;
-    // down(this.array, 0, this.less); // inlined
-    const n = this.array.length;
-    for (let i = 0;;) {
-      const l = (i << 1) + 1;
-      if (l >= n) break;
-      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];
-      if (!this.less(cValue, iValue)) break;
-      this.array[i] = cValue;
-      this.array[c] = iValue;
-      i = c;
-    }
-    return top;
-  }
-  has(value) {
-    // 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) {
-    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) {
-    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);
-    const array = this.array;
-    this.array = [];
-    return array;
-  }
-  merge(...args) {
-    if (!args.length) return this;
-    this.array = MinHeap.build(this.array.concat(...args.map(item => {
-      if (item instanceof MinHeap) return item.array;
-      if (!item) return [];
-      return item;
-    })), this.less);
-    return this;
-  }
-  clone() {
-    const heap = new MinHeap(this);
-    heap.array = this.array.slice(0);
-    return heap;
-  }
-  static build(array, less = MinHeap.defaults.less) {
-    if (array.length <= 1) return array;
-    for (let n = array.length, j = (n >> 1) - 1; j >= 0; --j) {
-      // down(array, j, less, n); // inlined
-      for (let i = j;;) {
-        const l = (i << 1) + 1;
-        if (l >= n) break;
-        const r = l + 1,
-          c = r < n && less(array[r], array[l]) ? r : l,
-          iValue = array[i],
-          cValue = array[c];
-        if (!less(cValue, iValue)) break;
-        array[i] = cValue;
-        array[c] = iValue;
-        i = c;
-      }
-    }
-    return array;
-  }
-  static pop(heapArray, less = MinHeap.defaults.less) {
-    switch (heapArray.length) {
-      case 0:
-        return;
-      case 1:
-        return heapArray.pop();
-    }
-    const top = heapArray[0];
-    heapArray[0] = heapArray.pop();
-    down(heapArray, 0, less);
-    return top;
-  }
-  static push(heapArray, item, less = MinHeap.defaults.less) {
-    const i = heapArray.length;
-    heapArray.push(item);
-    return up(heapArray, i, less);
-  }
-  static pushPop(heapArray, item, less = MinHeap.defaults.less) {
-    if (!heapArray.length || less(item, heapArray[0])) return item;
-    return MinHeap.replaceTop(heapArray, item, less);
-  }
-  static replaceTop(heapArray, item, less = MinHeap.defaults.less) {
-    const top = heapArray[0];
-    heapArray[0] = item;
-    down(heapArray, 0, less);
-    return top;
-  }
-  static has(heapArray, item, equal = MinHeap.defaults.equal) {
-    return heapArray.findIndex(element => equal(element, item)) >= 0;
-  }
-  static findIndex(heapArray, item, equal = MinHeap.defaults.equal) {
-    return heapArray.findIndex(element => equal(element, item));
-  }
-  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],
-        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));
-    return MinHeap.removeByIndex(heapArray, index, less);
-  }
-  static replaceByIndex(heapArray, index, newItem, less = MinHeap.defaults.less) {
-    if (index < 0 || index >= heapArray.length) return this;
-    const item = heapArray[index];
-    heapArray[index] = newItem;
-    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));
-    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;
-    for (let n = heapArray.length - 1; n; --n) {
-      [heapArray[0], heapArray[n]] = [heapArray[n], heapArray[0]];
-      down(heapArray, 0, less, n);
-    }
-    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;
-var _default = exports.default = MinHeap;

package/cjs/heap/skew-heap.js

@@ -1,114 +0,0 @@
-'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/heap.js

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