priority-queue-typed 2.1.2 → 2.2.1

package/dist/cjs/index.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/data-structures/base/iterable-element-base.ts
-var _IterableElementBase = class _IterableElementBase {
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
   /**
    * Create a new iterable base.
    *
@@ -17,19 +18,19 @@ var _IterableElementBase = class _IterableElementBase {
    * Time O(1), Space O(1).
    */
   constructor(options) {
-    /**
-     * The converter used to transform a raw element (`R`) into a public element (`E`).
-     *
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    __publicField(this, "_toElementFn");
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === "function") this._toElementFn = toElementFn;
       else if (toElementFn) throw new TypeError("toElementFn must be a function type");
     }
   }
+  /**
+   * The converter used to transform a raw element (`R`) into a public element (`E`).
+   *
+   * @remarks
+   * Time O(1), Space O(1).
+   */
+  _toElementFn;
   /**
    * Exposes the current `toElementFn`, if configured.
    *
@@ -224,11 +225,13 @@ var _IterableElementBase = class _IterableElementBase {
     console.log(this.toVisual());
   }
 };
-__name(_IterableElementBase, "IterableElementBase");
-var IterableElementBase = _IterableElementBase;
 
 // src/data-structures/heap/heap.ts
-var _Heap = class _Heap extends IterableElementBase {
+var Heap = class _Heap extends IterableElementBase {
+  static {
+    __name(this, "Heap");
+  }
+  _equals = Object.is;
   /**
    * Create a Heap and optionally bulk-insert elements.
    * @remarks Time O(N), Space O(N)
@@ -238,23 +241,13 @@ var _Heap = class _Heap extends IterableElementBase {
    */
   constructor(elements = [], options) {
     super(options);
-    __publicField(this, "_equals", Object.is);
-    __publicField(this, "_elements", []);
-    __publicField(this, "_DEFAULT_COMPARATOR", /* @__PURE__ */ __name((a, b) => {
-      if (typeof a === "object" || typeof b === "object") {
-        throw TypeError("When comparing object types, define a custom comparator in options.");
-      }
-      if (a > b) return 1;
-      if (a < b) return -1;
-      return 0;
-    }, "_DEFAULT_COMPARATOR"));
-    __publicField(this, "_comparator", this._DEFAULT_COMPARATOR);
     if (options) {
       const { comparator } = options;
       if (comparator) this._comparator = comparator;
     }
     this.addMany(elements);
   }
+  _elements = [];
   /**
    * Get the backing array of the heap.
    * @remarks Time O(1), Space O(1)
@@ -277,8 +270,7 @@ var _Heap = class _Heap extends IterableElementBase {
    * @returns Last element or undefined.
    */
   get leaf() {
-    var _a;
-    return (_a = this.elements[this.size - 1]) != null ? _a : void 0;
+    return this.elements[this.size - 1] ?? void 0;
   }
   /**
    * Create a heap of the same class from an iterable.
@@ -551,7 +543,7 @@ var _Heap = class _Heap extends IterableElementBase {
    * @returns A new heap with mapped elements.
    */
   map(callback, options, thisArg) {
-    const { comparator, toElementFn, ...rest } = options != null ? options : {};
+    const { comparator, toElementFn, ...rest } = options ?? {};
     if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
     const out = this._createLike([], { ...rest, comparator, toElementFn });
     let i = 0;
@@ -577,6 +569,15 @@ var _Heap = class _Heap extends IterableElementBase {
     }
     return out;
   }
+  _DEFAULT_COMPARATOR = /* @__PURE__ */ __name((a, b) => {
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError("When comparing object types, define a custom comparator in options.");
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  }, "_DEFAULT_COMPARATOR");
+  _comparator = this._DEFAULT_COMPARATOR;
   /**
   * Get the comparator used to order elements.
   * @remarks Time O(1), Space O(1)
@@ -630,7 +631,7 @@ var _Heap = class _Heap extends IterableElementBase {
    */
   _createInstance(options) {
     const Ctor = this.constructor;
-    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options != null ? options : {} });
+    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options ?? {} });
     return next;
   }
   /**
@@ -658,25 +659,27 @@ var _Heap = class _Heap extends IterableElementBase {
     return this._createLike([], options);
   }
 };
-__name(_Heap, "Heap");
-var Heap = _Heap;
-var _FibonacciHeapNode = class _FibonacciHeapNode {
+var FibonacciHeapNode = class {
+  static {
+    __name(this, "FibonacciHeapNode");
+  }
+  element;
+  degree;
+  left;
+  right;
+  child;
+  parent;
+  marked;
   constructor(element, degree = 0) {
-    __publicField(this, "element");
-    __publicField(this, "degree");
-    __publicField(this, "left");
-    __publicField(this, "right");
-    __publicField(this, "child");
-    __publicField(this, "parent");
-    __publicField(this, "marked");
     this.element = element;
     this.degree = degree;
     this.marked = false;
   }
 };
-__name(_FibonacciHeapNode, "FibonacciHeapNode");
-var FibonacciHeapNode = _FibonacciHeapNode;
-var _FibonacciHeap = class _FibonacciHeap {
+var FibonacciHeap = class {
+  static {
+    __name(this, "FibonacciHeap");
+  }
   /**
    * Create a FibonacciHeap.
    * @remarks Time O(1), Space O(1)
@@ -684,14 +687,11 @@ var _FibonacciHeap = class _FibonacciHeap {
    * @returns New FibonacciHeap instance.
    */
   constructor(comparator) {
-    __publicField(this, "_root");
-    __publicField(this, "_size", 0);
-    __publicField(this, "_min");
-    __publicField(this, "_comparator");
     this.clear();
     this._comparator = comparator || this._defaultComparator;
     if (typeof this.comparator !== "function") throw new Error("FibonacciHeap: comparator must be a function.");
   }
+  _root;
   /**
    * Get the circular root list head.
    * @remarks Time O(1), Space O(1)
@@ -700,9 +700,11 @@ var _FibonacciHeap = class _FibonacciHeap {
   get root() {
     return this._root;
   }
+  _size = 0;
   get size() {
     return this._size;
   }
+  _min;
   /**
    * Get the current minimum node.
    * @remarks Time O(1), Space O(1)
@@ -711,6 +713,7 @@ var _FibonacciHeap = class _FibonacciHeap {
   get min() {
     return this._min;
   }
+  _comparator;
   get comparator() {
     return this._comparator;
   }
@@ -887,11 +890,12 @@ var _FibonacciHeap = class _FibonacciHeap {
     }
   }
 };
-__name(_FibonacciHeap, "FibonacciHeap");
-var FibonacciHeap = _FibonacciHeap;
 
 // src/data-structures/heap/max-heap.ts
-var _MaxHeap = class _MaxHeap extends Heap {
+var MaxHeap = class extends Heap {
+  static {
+    __name(this, "MaxHeap");
+  }
   /**
    * Create a max-heap. For objects, supply a custom comparator.
    * @param elements Optional initial elements.
@@ -913,11 +917,12 @@ var _MaxHeap = class _MaxHeap extends Heap {
     });
   }
 };
-__name(_MaxHeap, "MaxHeap");
-var MaxHeap = _MaxHeap;
 
 // src/data-structures/heap/min-heap.ts
-var _MinHeap = class _MinHeap extends Heap {
+var MinHeap = class extends Heap {
+  static {
+    __name(this, "MinHeap");
+  }
   /**
    * Create a min-heap.
    * @param elements Optional initial elements.
@@ -927,20 +932,22 @@ var _MinHeap = class _MinHeap extends Heap {
     super(elements, options);
   }
 };
-__name(_MinHeap, "MinHeap");
-var MinHeap = _MinHeap;
 
 // src/data-structures/priority-queue/priority-queue.ts
-var _PriorityQueue = class _PriorityQueue extends Heap {
+var PriorityQueue = class extends Heap {
+  static {
+    __name(this, "PriorityQueue");
+  }
   constructor(elements = [], options) {
     super(elements, options);
   }
 };
-__name(_PriorityQueue, "PriorityQueue");
-var PriorityQueue = _PriorityQueue;
 
 // src/data-structures/priority-queue/min-priority-queue.ts
-var _MinPriorityQueue = class _MinPriorityQueue extends PriorityQueue {
+var MinPriorityQueue = class extends PriorityQueue {
+  static {
+    __name(this, "MinPriorityQueue");
+  }
   /**
    * Creates a min-priority queue.
    * @param elements Optional initial elements to insert.
@@ -951,11 +958,12 @@ var _MinPriorityQueue = class _MinPriorityQueue extends PriorityQueue {
     super(elements, options);
   }
 };
-__name(_MinPriorityQueue, "MinPriorityQueue");
-var MinPriorityQueue = _MinPriorityQueue;
 
 // src/data-structures/priority-queue/max-priority-queue.ts
-var _MaxPriorityQueue = class _MaxPriorityQueue extends PriorityQueue {
+var MaxPriorityQueue = class extends PriorityQueue {
+  static {
+    __name(this, "MaxPriorityQueue");
+  }
   /**
    * Creates a max-priority queue.
    * @param elements Optional initial elements to insert.
@@ -979,8 +987,6 @@ var _MaxPriorityQueue = class _MaxPriorityQueue extends PriorityQueue {
     });
   }
 };
-__name(_MaxPriorityQueue, "MaxPriorityQueue");
-var MaxPriorityQueue = _MaxPriorityQueue;
 
 // src/utils/utils.ts
 function isPrimitiveComparable(value) {
@@ -1022,7 +1028,7 @@ var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
   DFSOperation2[DFSOperation2["PROCESS"] = 1] = "PROCESS";
   return DFSOperation2;
 })(DFSOperation || {});
-var _Range = class _Range {
+var Range = class {
   constructor(low, high, includeLow = true, includeHigh = true) {
     this.low = low;
     this.high = high;
@@ -1031,6 +1037,9 @@ var _Range = class _Range {
     if (!(isComparable(low) && isComparable(high))) throw new RangeError("low or high is not comparable");
     if (low > high) throw new RangeError("low must be less than or equal to high");
   }
+  static {
+    __name(this, "Range");
+  }
   // Determine whether a key is within the range
   isInRange(key, comparator) {
     const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
@@ -1038,8 +1047,6 @@ var _Range = class _Range {
     return lowCheck && highCheck;
   }
 };
-__name(_Range, "Range");
-var Range = _Range;
 /**
  * data-structure-typed
  *