red-black-tree-typed 2.1.2 → 2.2.0

package/dist/cjs/index.cjs

@@ -1,9 +1,7 @@
 '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/utils/utils.ts
 function isPrimitiveComparable(value) {
@@ -62,7 +60,10 @@ function makeTrampoline(fn) {
 __name(makeTrampoline, "makeTrampoline");
 
 // src/data-structures/base/iterable-element-base.ts
-var _IterableElementBase = class _IterableElementBase {
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
   /**
    * Create a new iterable base.
    *
@@ -73,19 +74,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.
    *
@@ -280,11 +281,12 @@ var _IterableElementBase = class _IterableElementBase {
     console.log(this.toVisual());
   }
 };
-__name(_IterableElementBase, "IterableElementBase");
-var IterableElementBase = _IterableElementBase;
 
 // src/data-structures/base/linear-base.ts
-var _LinearBase = class _LinearBase extends IterableElementBase {
+var LinearBase = class _LinearBase extends IterableElementBase {
+  static {
+    __name(this, "LinearBase");
+  }
   /**
    * Construct a linear container with runtime options.
    * @param options - `{ maxLen?, ... }` bounds/behavior options.
@@ -292,12 +294,12 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
    */
   constructor(options) {
     super(options);
-    __publicField(this, "_maxLen", -1);
     if (options) {
       const { maxLen } = options;
       if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
     }
   }
+  _maxLen = -1;
   /**
    * Upper bound for length (if positive), or `-1` when unbounded.
    * @returns Maximum allowed length.
@@ -430,7 +432,7 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
     return array;
   }
   reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue != null ? initialValue : 0;
+    let accumulator = initialValue ?? 0;
     for (let i = this.length - 1; i >= 0; i--) {
       accumulator = callbackfn(accumulator, this.at(i), i, this);
     }
@@ -472,11 +474,12 @@ var _LinearBase = class _LinearBase extends IterableElementBase {
     return this;
   }
 };
-__name(_LinearBase, "LinearBase");
-var LinearBase = _LinearBase;
 
 // src/data-structures/queue/queue.ts
-var _Queue = class _Queue extends LinearBase {
+var Queue = class _Queue extends LinearBase {
+  static {
+    __name(this, "Queue");
+  }
   /**
    * Create a Queue and optionally bulk-insert elements.
    * @remarks Time O(N), Space O(N)
@@ -486,15 +489,13 @@ var _Queue = class _Queue extends LinearBase {
    */
   constructor(elements = [], options) {
     super(options);
-    __publicField(this, "_elements", []);
-    __publicField(this, "_offset", 0);
-    __publicField(this, "_autoCompactRatio", 0.5);
     if (options) {
       const { autoCompactRatio = 0.5 } = options;
       this._autoCompactRatio = autoCompactRatio;
     }
     this.pushMany(elements);
   }
+  _elements = [];
   /**
    * Get the underlying array buffer.
    * @remarks Time O(1), Space O(1)
@@ -503,6 +504,7 @@ var _Queue = class _Queue extends LinearBase {
   get elements() {
     return this._elements;
   }
+  _offset = 0;
   /**
    * Get the current start offset into the array.
    * @remarks Time O(1), Space O(1)
@@ -511,6 +513,7 @@ var _Queue = class _Queue extends LinearBase {
   get offset() {
     return this._offset;
   }
+  _autoCompactRatio = 0.5;
   /**
    * Get the compaction threshold (offset/size).
    * @remarks Time O(1), Space O(1)
@@ -755,11 +758,10 @@ var _Queue = class _Queue extends LinearBase {
    * @returns A new Queue with mapped elements.
    */
   map(callback, options, thisArg) {
-    var _a, _b;
     const out = new this.constructor([], {
-      toElementFn: options == null ? void 0 : options.toElementFn,
-      maxLen: (_a = options == null ? void 0 : options.maxLen) != null ? _a : this._maxLen,
-      autoCompactRatio: (_b = options == null ? void 0 : options.autoCompactRatio) != null ? _b : this._autoCompactRatio
+      toElementFn: options?.toElementFn,
+      maxLen: options?.maxLen ?? this._maxLen,
+      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
     });
     let index = 0;
     for (const v of this)
@@ -774,14 +776,13 @@ var _Queue = class _Queue extends LinearBase {
    * @returns A new queue with mapped elements (same element type).
    */
   mapSame(callback, thisArg) {
-    var _a;
     const Ctor = this.constructor;
     const out = new Ctor([], {
       toElementFn: this.toElementFn,
       maxLen: this._maxLen,
       autoCompactRatio: this._autoCompactRatio
     });
-    (_a = out._setAutoCompactRatio) == null ? void 0 : _a.call(out, this._autoCompactRatio);
+    out._setAutoCompactRatio?.(this._autoCompactRatio);
     let index = 0;
     for (const v of this) {
       const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
@@ -841,11 +842,12 @@ var _Queue = class _Queue extends LinearBase {
     return new Ctor(elements, options);
   }
 };
-__name(_Queue, "Queue");
-var Queue = _Queue;
 
 // src/data-structures/base/iterable-entry-base.ts
-var _IterableEntryBase = class _IterableEntryBase {
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
   /**
    * Default iterator yielding `[key, value]` entries.
    * @returns Iterator of `[K, V]`.
@@ -1014,8 +1016,6 @@ var _IterableEntryBase = class _IterableEntryBase {
     console.log(this.toVisual());
   }
 };
-__name(_IterableEntryBase, "IterableEntryBase");
-var IterableEntryBase = _IterableEntryBase;
 
 // src/common/index.ts
 var DFSOperation = /* @__PURE__ */ ((DFSOperation2) => {
@@ -1023,7 +1023,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;
@@ -1032,6 +1032,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;
@@ -1039,11 +1042,15 @@ var _Range = class _Range {
     return lowCheck && highCheck;
   }
 };
-__name(_Range, "Range");
-var Range = _Range;
 
 // src/data-structures/binary-tree/binary-tree.ts
-var _BinaryTreeNode = class _BinaryTreeNode {
+var BinaryTreeNode = class {
+  static {
+    __name(this, "BinaryTreeNode");
+  }
+  key;
+  value;
+  parent = void 0;
   /**
    * Creates an instance of BinaryTreeNode.
    * @remarks Time O(1), Space O(1)
@@ -1052,17 +1059,10 @@ var _BinaryTreeNode = class _BinaryTreeNode {
    * @param [value] - The value associated with the key.
    */
   constructor(key, value) {
-    __publicField(this, "key");
-    __publicField(this, "value");
-    __publicField(this, "parent");
-    __publicField(this, "_left");
-    __publicField(this, "_right");
-    __publicField(this, "_height", 0);
-    __publicField(this, "_color", "BLACK");
-    __publicField(this, "_count", 1);
     this.key = key;
     this.value = value;
   }
+  _left = void 0;
   /**
    * Gets the left child of the node.
    * @remarks Time O(1), Space O(1)
@@ -1084,6 +1084,7 @@ var _BinaryTreeNode = class _BinaryTreeNode {
     }
     this._left = v;
   }
+  _right = void 0;
   /**
    * Gets the right child of the node.
    * @remarks Time O(1), Space O(1)
@@ -1105,6 +1106,7 @@ var _BinaryTreeNode = class _BinaryTreeNode {
     }
     this._right = v;
   }
+  _height = 0;
   /**
    * Gets the height of the node (used in self-balancing trees).
    * @remarks Time O(1), Space O(1)
@@ -1123,6 +1125,7 @@ var _BinaryTreeNode = class _BinaryTreeNode {
   set height(value) {
     this._height = value;
   }
+  _color = "BLACK";
   /**
    * Gets the color of the node (used in Red-Black trees).
    * @remarks Time O(1), Space O(1)
@@ -1141,6 +1144,7 @@ var _BinaryTreeNode = class _BinaryTreeNode {
   set color(value) {
     this._color = value;
   }
+  _count = 1;
   /**
    * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
    * @remarks Time O(1), Space O(1)
@@ -1177,9 +1181,11 @@ var _BinaryTreeNode = class _BinaryTreeNode {
     return "MAL_NODE";
   }
 };
-__name(_BinaryTreeNode, "BinaryTreeNode");
-var BinaryTreeNode = _BinaryTreeNode;
-var _BinaryTree = class _BinaryTree extends IterableEntryBase {
+var BinaryTree = class extends IterableEntryBase {
+  static {
+    __name(this, "BinaryTree");
+  }
+  iterationType = "ITERATIVE";
   /**
    * Creates an instance of BinaryTree.
    * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `add` operation). Space O(N) for storing the nodes.
@@ -1189,22 +1195,6 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super();
-    __publicField(this, "iterationType", "ITERATIVE");
-    __publicField(this, "_isMapMode", true);
-    __publicField(this, "_isDuplicate", false);
-    __publicField(this, "_store", /* @__PURE__ */ new Map());
-    __publicField(this, "_root");
-    __publicField(this, "_size", 0);
-    __publicField(this, "_NIL", new BinaryTreeNode(NaN));
-    __publicField(this, "_toEntryFn");
-    /**
-     * (Protected) Default callback function, returns the node's key.
-     * @remarks Time O(1)
-     *
-     * @param node - The node.
-     * @returns The node's key or undefined.
-     */
-    __publicField(this, "_DEFAULT_NODE_CALLBACK", /* @__PURE__ */ __name((node) => node ? node.key : void 0, "_DEFAULT_NODE_CALLBACK"));
     if (options) {
       const { iterationType, toEntryFn, isMapMode, isDuplicate } = options;
       if (iterationType) this.iterationType = iterationType;
@@ -1215,6 +1205,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     }
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
+  _isMapMode = true;
   /**
    * Gets whether the tree is in Map mode.
    * @remarks In Map mode (default), values are stored in an external Map, and nodes only hold keys. If false, values are stored directly on the nodes. Time O(1)
@@ -1224,6 +1215,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
   get isMapMode() {
     return this._isMapMode;
   }
+  _isDuplicate = false;
   /**
    * Gets whether the tree allows duplicate keys.
    * @remarks Time O(1)
@@ -1233,6 +1225,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
   get isDuplicate() {
     return this._isDuplicate;
   }
+  _store = /* @__PURE__ */ new Map();
   /**
    * Gets the external value store (used in Map mode).
    * @remarks Time O(1)
@@ -1242,6 +1235,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
   get store() {
     return this._store;
   }
+  _root;
   /**
    * Gets the root node of the tree.
    * @remarks Time O(1)
@@ -1251,6 +1245,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
   get root() {
     return this._root;
   }
+  _size = 0;
   /**
    * Gets the number of nodes in the tree.
    * @remarks Time O(1)
@@ -1260,6 +1255,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
   get size() {
     return this._size;
   }
+  _NIL = new BinaryTreeNode(NaN);
   /**
    * Gets the sentinel NIL node (used in self-balancing trees like Red-Black Tree).
    * @remarks Time O(1)
@@ -1269,6 +1265,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
   get NIL() {
     return this._NIL;
   }
+  _toEntryFn;
   /**
    * Gets the function used to convert raw data objects (R) into [key, value] entries.
    * @remarks Time O(1)
@@ -1428,7 +1425,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     if (newNode === void 0) return false;
     if (!this._root) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+      if (this._isMapMode) this._setValue(newNode?.key, newValue);
       this._size = 1;
       return true;
     }
@@ -1460,7 +1457,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
       } else if (potentialParent.right === void 0) {
         potentialParent.right = newNode;
       }
-      if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+      if (this._isMapMode) this._setValue(newNode?.key, newValue);
       this._size++;
       return true;
     }
@@ -1525,7 +1522,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     if (!this._root) return deletedResult;
     const curr = this.getNode(keyNodeOrEntry);
     if (!curr) return deletedResult;
-    const parent = curr == null ? void 0 : curr.parent;
+    const parent = curr?.parent;
     let needBalanced;
     let orgCurrent = curr;
     if (!curr.left && !curr.right && !parent) {
@@ -1630,13 +1627,12 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
    * @returns The associated value, or undefined.
    */
   get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    var _a;
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
       if (key === null || key === void 0) return;
       return this._store.get(key);
     }
-    return (_a = this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)) == null ? void 0 : _a.value;
+    return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
   }
   has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
     return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
@@ -1724,7 +1720,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     let distEnsured = this.ensureNode(dist);
     const beginRootEnsured = this.ensureNode(startNode);
     let depth = 0;
-    while (distEnsured == null ? void 0 : distEnsured.parent) {
+    while (distEnsured?.parent) {
       if (distEnsured === beginRootEnsured) {
         return depth;
       }
@@ -2286,10 +2282,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
       const dfs = /* @__PURE__ */ __name((node) => {
         if (!shouldVisitRoot(node)) return;
         const visitLeft = /* @__PURE__ */ __name(() => {
-          if (shouldVisitLeft(node) && (node == null ? void 0 : node.left) !== void 0) dfs(node == null ? void 0 : node.left);
+          if (shouldVisitLeft(node) && node?.left !== void 0) dfs(node?.left);
         }, "visitLeft");
         const visitRight = /* @__PURE__ */ __name(() => {
-          if (shouldVisitRight(node) && (node == null ? void 0 : node.right) !== void 0) dfs(node == null ? void 0 : node.right);
+          if (shouldVisitRight(node) && node?.right !== void 0) dfs(node?.right);
         }, "visitRight");
         switch (pattern) {
           case "IN":
@@ -2322,12 +2318,10 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     } else {
       const stack = [{ opt: 0 /* VISIT */, node: startNode }];
       const pushLeft = /* @__PURE__ */ __name((cur) => {
-        var _a;
-        if (shouldVisitLeft(cur.node)) stack.push({ opt: 0 /* VISIT */, node: (_a = cur.node) == null ? void 0 : _a.left });
+        if (shouldVisitLeft(cur.node)) stack.push({ opt: 0 /* VISIT */, node: cur.node?.left });
       }, "pushLeft");
       const pushRight = /* @__PURE__ */ __name((cur) => {
-        var _a;
-        if (shouldVisitRight(cur.node)) stack.push({ opt: 0 /* VISIT */, node: (_a = cur.node) == null ? void 0 : _a.right });
+        if (shouldVisitRight(cur.node)) stack.push({ opt: 0 /* VISIT */, node: cur.node?.right });
       }, "pushRight");
       const pushRoot = /* @__PURE__ */ __name((cur) => {
         if (shouldVisitRoot(cur.node)) stack.push({ opt: 1 /* PROCESS */, node: cur.node });
@@ -2399,6 +2393,14 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
       }
     }
   }
+  /**
+   * (Protected) Default callback function, returns the node's key.
+   * @remarks Time O(1)
+   *
+   * @param node - The node.
+   * @returns The node's key or undefined.
+   */
+  _DEFAULT_NODE_CALLBACK = /* @__PURE__ */ __name((node) => node ? node.key : void 0, "_DEFAULT_NODE_CALLBACK");
   /**
    * (Protected) Snapshots the current tree's configuration options.
    * @remarks Time O(1)
@@ -2424,7 +2426,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
    */
   _createInstance(options) {
     const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options != null ? options : {} });
+    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
   }
   /**
    * (Protected) Creates a new instance of the same tree constructor, potentially with different generic types.
@@ -2437,7 +2439,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
    */
   _createLike(iter = [], options) {
     const Ctor = this.constructor;
-    return new Ctor(iter, { ...this._snapshotOptions(), ...options != null ? options : {} });
+    return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
   }
   /**
    * (Protected) Converts a key, node, or entry into a standardized [node, value] tuple.
@@ -2455,7 +2457,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
       const [key, entryValue] = keyNodeOrEntry;
       if (key === void 0) return [void 0, void 0];
       else if (key === null) return [null, void 0];
-      const finalValue = value != null ? value : entryValue;
+      const finalValue = value ?? entryValue;
       return [this.createNode(key, finalValue), finalValue];
     }
     return [this.createNode(keyNodeOrEntry, value), value];
@@ -2662,11 +2664,15 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     this._store.clear();
   }
 };
-__name(_BinaryTree, "BinaryTree");
-var BinaryTree = _BinaryTree;
 
 // src/data-structures/binary-tree/bst.ts
-var _BSTNode = class _BSTNode extends BinaryTreeNode {
+var BSTNode = class {
+  static {
+    __name(this, "BSTNode");
+  }
+  key;
+  value;
+  parent = void 0;
   /**
    * Creates an instance of BSTNode.
    * @remarks Time O(1), Space O(1)
@@ -2675,11 +2681,10 @@ var _BSTNode = class _BSTNode extends BinaryTreeNode {
    * @param [value] - The value associated with the key.
    */
   constructor(key, value) {
-    super(key, value);
-    __publicField(this, "parent");
-    __publicField(this, "_left");
-    __publicField(this, "_right");
+    this.key = key;
+    this.value = value;
   }
+  _left = void 0;
   /**
    * Gets the left child of the node.
    * @remarks Time O(1), Space O(1)
@@ -2699,6 +2704,7 @@ var _BSTNode = class _BSTNode extends BinaryTreeNode {
     if (v) v.parent = this;
     this._left = v;
   }
+  _right = void 0;
   /**
    * Gets the right child of the node.
    * @remarks Time O(1), Space O(1)
@@ -2718,10 +2724,85 @@ var _BSTNode = class _BSTNode extends BinaryTreeNode {
     if (v) v.parent = this;
     this._right = v;
   }
+  _height = 0;
+  /**
+   * Gets the height of the node (used in self-balancing trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The height.
+   */
+  get height() {
+    return this._height;
+  }
+  /**
+   * Sets the height of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new height.
+   */
+  set height(value) {
+    this._height = value;
+  }
+  _color = "BLACK";
+  /**
+   * Gets the color of the node (used in Red-Black trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The node's color.
+   */
+  get color() {
+    return this._color;
+  }
+  /**
+   * Sets the color of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new color.
+   */
+  set color(value) {
+    this._color = value;
+  }
+  _count = 1;
+  /**
+   * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The subtree node count.
+   */
+  get count() {
+    return this._count;
+  }
+  /**
+   * Sets the count of nodes in the subtree.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new count.
+   */
+  set count(value) {
+    this._count = value;
+  }
+  /**
+   * Gets the position of the node relative to its parent.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+   */
+  get familyPosition() {
+    if (!this.parent) {
+      return this.left || this.right ? "ROOT" : "ISOLATED";
+    }
+    if (this.parent.left === this) {
+      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
+    } else if (this.parent.right === this) {
+      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
+    }
+    return "MAL_NODE";
+  }
 };
-__name(_BSTNode, "BSTNode");
-var BSTNode = _BSTNode;
-var _BST = class _BST extends BinaryTree {
+var BST = class extends BinaryTree {
+  static {
+    __name(this, "BST");
+  }
   /**
    * Creates an instance of BST.
    * @remarks Time O(N log N) or O(N^2) depending on `isBalanceAdd` in `addMany` and input order. Space O(N).
@@ -2731,33 +2812,6 @@ var _BST = class _BST extends BinaryTree {
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    __publicField(this, "_root");
-    __publicField(this, "_isReverse", false);
-    /**
-     * The default comparator function.
-     * @remarks Time O(1) (or O(C) if `specifyComparable` is used, C is complexity of that function).
-     */
-    __publicField(this, "_comparator", /* @__PURE__ */ __name((a, b) => {
-      if (isComparable(a) && isComparable(b)) {
-        if (a > b) return 1;
-        if (a < b) return -1;
-        return 0;
-      }
-      if (this._specifyComparable) {
-        const va = this._specifyComparable(a);
-        const vb = this._specifyComparable(b);
-        if (va > vb) return 1;
-        if (va < vb) return -1;
-        return 0;
-      }
-      if (typeof a === "object" || typeof b === "object") {
-        throw TypeError(
-          `When comparing object types, a custom specifyComparable must be defined in the constructor's options.`
-        );
-      }
-      return 0;
-    }, "_comparator"));
-    __publicField(this, "_specifyComparable");
     if (options) {
       const { specifyComparable, isReverse } = options;
       if (typeof specifyComparable === "function") this._specifyComparable = specifyComparable;
@@ -2765,6 +2819,7 @@ var _BST = class _BST extends BinaryTree {
     }
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
+  _root = void 0;
   /**
    * Gets the root node of the tree.
    * @remarks Time O(1)
@@ -2774,6 +2829,7 @@ var _BST = class _BST extends BinaryTree {
   get root() {
     return this._root;
   }
+  _isReverse = false;
   /**
    * Gets whether the tree's comparison logic is reversed.
    * @remarks Time O(1)
@@ -2783,6 +2839,30 @@ var _BST = class _BST extends BinaryTree {
   get isReverse() {
     return this._isReverse;
   }
+  /**
+   * The default comparator function.
+   * @remarks Time O(1) (or O(C) if `specifyComparable` is used, C is complexity of that function).
+   */
+  _comparator = /* @__PURE__ */ __name((a, b) => {
+    if (isComparable(a) && isComparable(b)) {
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
+    }
+    if (this._specifyComparable) {
+      const va = this._specifyComparable(a);
+      const vb = this._specifyComparable(b);
+      if (va > vb) return 1;
+      if (va < vb) return -1;
+      return 0;
+    }
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError(
+        `When comparing object types, a custom specifyComparable must be defined in the constructor's options.`
+      );
+    }
+    return 0;
+  }, "_comparator");
   /**
    * Gets the comparator function used by the tree.
    * @remarks Time O(1)
@@ -2792,6 +2872,7 @@ var _BST = class _BST extends BinaryTree {
   get comparator() {
     return this._comparator;
   }
+  _specifyComparable;
   /**
    * Gets the function used to extract a comparable value from a complex key.
    * @remarks Time O(1)
@@ -2821,8 +2902,7 @@ var _BST = class _BST extends BinaryTree {
    * @returns The resolved node, or undefined if not found.
    */
   ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
-    var _a;
-    return (_a = super.ensureNode(keyNodeOrEntry, iterationType)) != null ? _a : void 0;
+    return super.ensureNode(keyNodeOrEntry, iterationType) ?? void 0;
   }
   /**
    * Checks if the given item is a `BSTNode` instance.
@@ -2895,8 +2975,7 @@ var _BST = class _BST extends BinaryTree {
    * @returns The first matching node, or undefined if not found.
    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    var _a;
-    return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
   }
   /**
    * Searches the tree for nodes matching a predicate, key, or range.
@@ -3001,7 +3080,7 @@ var _BST = class _BST extends BinaryTree {
     if (newNode === void 0) return false;
     if (this._root === void 0) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+      if (this._isMapMode) this._setValue(newNode?.key, newValue);
       this._size++;
       return true;
     }
@@ -3014,7 +3093,7 @@ var _BST = class _BST extends BinaryTree {
       } else if (this._compare(current.key, newNode.key) > 0) {
         if (current.left === void 0) {
           current.left = newNode;
-          if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+          if (this._isMapMode) this._setValue(newNode?.key, newValue);
           this._size++;
           return true;
         }
@@ -3022,7 +3101,7 @@ var _BST = class _BST extends BinaryTree {
       } else {
         if (current.right === void 0) {
           current.right = newNode;
-          if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+          if (this._isMapMode) this._setValue(newNode?.key, newValue);
           this._size++;
           return true;
         }
@@ -3045,10 +3124,10 @@ var _BST = class _BST extends BinaryTree {
    */
   addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
     const inserted = [];
-    const valuesIterator = values == null ? void 0 : values[Symbol.iterator]();
+    const valuesIterator = values?.[Symbol.iterator]();
     if (!isBalanceAdd) {
       for (let kve of keysNodesEntriesOrRaws) {
-        const val = valuesIterator == null ? void 0 : valuesIterator.next().value;
+        const val = valuesIterator?.next().value;
         if (this.isRaw(kve)) kve = this._toEntryFn(kve);
         inserted.push(this.add(kve, val));
       }
@@ -3057,7 +3136,7 @@ var _BST = class _BST extends BinaryTree {
     const realBTNExemplars = [];
     let i = 0;
     for (const kve of keysNodesEntriesOrRaws) {
-      realBTNExemplars.push({ key: kve, value: valuesIterator == null ? void 0 : valuesIterator.next().value, orgIndex: i++ });
+      realBTNExemplars.push({ key: kve, value: valuesIterator?.next().value, orgIndex: i++ });
     }
     const sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
       let keyA, keyB;
@@ -3279,7 +3358,7 @@ var _BST = class _BST extends BinaryTree {
    */
   _createInstance(options) {
     const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options != null ? options : {} });
+    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
   }
   /**
    * (Protected) Creates a new instance of the same BST constructor, potentially with different generic types.
@@ -3292,7 +3371,7 @@ var _BST = class _BST extends BinaryTree {
    */
   _createLike(iter = [], options) {
     const Ctor = this.constructor;
-    return new Ctor(iter, { ...this._snapshotOptions(), ...options != null ? options : {} });
+    return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
   }
   /**
    * (Protected) Snapshots the current BST's configuration options.
@@ -3319,7 +3398,7 @@ var _BST = class _BST extends BinaryTree {
   _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
     const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (node === null) return [void 0, void 0];
-    return [node, value != null ? value : entryValue];
+    return [node, value ?? entryValue];
   }
   /**
    * (Protected) Sets the root node and clears its parent reference.
@@ -3350,7 +3429,6 @@ var _BST = class _BST extends BinaryTree {
    * @returns True if the node was found and deleted, false otherwise.
    */
   _deleteByKey(key) {
-    var _a;
     let node = this._root;
     while (node) {
       const cmp = this._compare(node.key, key);
@@ -3359,7 +3437,7 @@ var _BST = class _BST extends BinaryTree {
     }
     if (!node) return false;
     const transplant = /* @__PURE__ */ __name((u, v) => {
-      const p = u == null ? void 0 : u.parent;
+      const p = u?.parent;
       if (!p) {
         this._setRoot(v);
       } else if (p.left === u) {
@@ -3389,15 +3467,19 @@ var _BST = class _BST extends BinaryTree {
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
-    this._size = Math.max(0, ((_a = this._size) != null ? _a : 0) - 1);
+    this._size = Math.max(0, (this._size ?? 0) - 1);
     return true;
   }
 };
-__name(_BST, "BST");
-var BST = _BST;
 
 // src/data-structures/binary-tree/red-black-tree.ts
-var _RedBlackTreeNode = class _RedBlackTreeNode extends BSTNode {
+var RedBlackTreeNode = class {
+  static {
+    __name(this, "RedBlackTreeNode");
+  }
+  key;
+  value;
+  parent = void 0;
   /**
    * Create a Red-Black Tree and optionally bulk-insert items.
    * @remarks Time O(n log n), Space O(n)
@@ -3407,12 +3489,11 @@ var _RedBlackTreeNode = class _RedBlackTreeNode extends BSTNode {
    * @returns New RedBlackTree instance.
    */
   constructor(key, value, color = "BLACK") {
-    super(key, value);
-    __publicField(this, "parent");
-    __publicField(this, "_left");
-    __publicField(this, "_right");
-    this._color = color;
+    this.key = key;
+    this.value = value;
+    this.color = color;
   }
+  _left = void 0;
   /**
    * Get the left child pointer.
    * @remarks Time O(1), Space O(1)
@@ -3433,6 +3514,7 @@ var _RedBlackTreeNode = class _RedBlackTreeNode extends BSTNode {
     }
     this._left = v;
   }
+  _right = void 0;
   /**
    * Get the right child pointer.
    * @remarks Time O(1), Space O(1)
@@ -3453,18 +3535,93 @@ var _RedBlackTreeNode = class _RedBlackTreeNode extends BSTNode {
     }
     this._right = v;
   }
+  _height = 0;
+  /**
+   * Gets the height of the node (used in self-balancing trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The height.
+   */
+  get height() {
+    return this._height;
+  }
+  /**
+   * Sets the height of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new height.
+   */
+  set height(value) {
+    this._height = value;
+  }
+  _color = "BLACK";
+  /**
+   * Gets the color of the node (used in Red-Black trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The node's color.
+   */
+  get color() {
+    return this._color;
+  }
+  /**
+   * Sets the color of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new color.
+   */
+  set color(value) {
+    this._color = value;
+  }
+  _count = 1;
+  /**
+   * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The subtree node count.
+   */
+  get count() {
+    return this._count;
+  }
+  /**
+   * Sets the count of nodes in the subtree.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new count.
+   */
+  set count(value) {
+    this._count = value;
+  }
+  /**
+   * Gets the position of the node relative to its parent.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+   */
+  get familyPosition() {
+    if (!this.parent) {
+      return this.left || this.right ? "ROOT" : "ISOLATED";
+    }
+    if (this.parent.left === this) {
+      return this.left || this.right ? "ROOT_LEFT" : "LEFT";
+    } else if (this.parent.right === this) {
+      return this.left || this.right ? "ROOT_RIGHT" : "RIGHT";
+    }
+    return "MAL_NODE";
+  }
 };
-__name(_RedBlackTreeNode, "RedBlackTreeNode");
-var RedBlackTreeNode = _RedBlackTreeNode;
-var _RedBlackTree = class _RedBlackTree extends BST {
+var RedBlackTree = class extends BST {
+  static {
+    __name(this, "RedBlackTree");
+  }
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    __publicField(this, "_root");
     this._root = this.NIL;
     if (keysNodesEntriesOrRaws) {
       this.addMany(keysNodesEntriesOrRaws);
     }
   }
+  _root;
   /**
    * Get the current root node.
    * @remarks Time O(1), Space O(1)
@@ -3609,11 +3766,11 @@ var _RedBlackTree = class _RedBlackTree extends BST {
   }
   _createInstance(options) {
     const Ctor = this.constructor;
-    return new Ctor([], { ...this._snapshotOptions(), ...options != null ? options : {} });
+    return new Ctor([], { ...this._snapshotOptions(), ...options ?? {} });
   }
   _createLike(iter = [], options) {
     const Ctor = this.constructor;
-    return new Ctor(iter, { ...this._snapshotOptions(), ...options != null ? options : {} });
+    return new Ctor(iter, { ...this._snapshotOptions(), ...options ?? {} });
   }
   _setRoot(v) {
     if (v) {
@@ -3632,16 +3789,15 @@ var _RedBlackTree = class _RedBlackTree extends BST {
    * @returns Status string: 'CREATED' or 'UPDATED'.
    */
   _insert(node) {
-    var _a, _b;
-    let current = this.root;
+    let current = this.root ?? this.NIL;
     let parent = void 0;
-    while (this.isRealNode(current)) {
+    while (current !== this.NIL) {
       parent = current;
       const compared = this._compare(node.key, current.key);
       if (compared < 0) {
-        current = (_a = current.left) != null ? _a : this.NIL;
+        current = current.left ?? this.NIL;
       } else if (compared > 0) {
-        current = (_b = current.right) != null ? _b : this.NIL;
+        current = current.right ?? this.NIL;
       } else {
         this._replaceNode(current, node);
         return "UPDATED";
@@ -3687,11 +3843,10 @@ var _RedBlackTree = class _RedBlackTree extends BST {
    * @returns void
    */
   _insertFixup(z) {
-    var _a, _b, _c, _d, _e;
-    while (((_a = z == null ? void 0 : z.parent) == null ? void 0 : _a.color) === "RED") {
-      if (z.parent === ((_b = z.parent.parent) == null ? void 0 : _b.left)) {
+    while (z?.parent?.color === "RED") {
+      if (z.parent === z.parent.parent?.left) {
         const y = z.parent.parent.right;
-        if ((y == null ? void 0 : y.color) === "RED") {
+        if (y?.color === "RED") {
           z.parent.color = "BLACK";
           y.color = "BLACK";
           z.parent.parent.color = "RED";
@@ -3701,15 +3856,15 @@ var _RedBlackTree = class _RedBlackTree extends BST {
             z = z.parent;
             this._leftRotate(z);
           }
-          if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
+          if (z && z.parent && z.parent.parent) {
             z.parent.color = "BLACK";
             z.parent.parent.color = "RED";
             this._rightRotate(z.parent.parent);
           }
         }
       } else {
-        const y = (_e = (_d = (_c = z == null ? void 0 : z.parent) == null ? void 0 : _c.parent) == null ? void 0 : _d.left) != null ? _e : void 0;
-        if ((y == null ? void 0 : y.color) === "RED") {
+        const y = z?.parent?.parent?.left ?? void 0;
+        if (y?.color === "RED") {
           z.parent.color = "BLACK";
           y.color = "BLACK";
           z.parent.parent.color = "RED";
@@ -3719,7 +3874,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
             z = z.parent;
             this._rightRotate(z);
           }
-          if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
+          if (z && z.parent && z.parent.parent) {
             z.parent.color = "BLACK";
             z.parent.parent.color = "RED";
             this._leftRotate(z.parent.parent);
@@ -3736,7 +3891,6 @@ var _RedBlackTree = class _RedBlackTree extends BST {
    * @returns void
    */
   _deleteFixup(node) {
-    var _a, _b, _c, _d;
     if (!node || node === this.root || node.color === "BLACK") {
       if (node) {
         node.color = "BLACK";
@@ -3750,17 +3904,17 @@ var _RedBlackTree = class _RedBlackTree extends BST {
       }
       if (node === parent.left) {
         let sibling = parent.right;
-        if ((sibling == null ? void 0 : sibling.color) === "RED") {
+        if (sibling?.color === "RED") {
           sibling.color = "BLACK";
           parent.color = "RED";
           this._leftRotate(parent);
           sibling = parent.right;
         }
-        if (((_b = (_a = sibling == null ? void 0 : sibling.left) == null ? void 0 : _a.color) != null ? _b : "BLACK") === "BLACK") {
+        if ((sibling?.left?.color ?? "BLACK") === "BLACK") {
           if (sibling) sibling.color = "RED";
           node = parent;
         } else {
-          if (sibling == null ? void 0 : sibling.left) sibling.left.color = "BLACK";
+          if (sibling?.left) sibling.left.color = "BLACK";
           if (sibling) sibling.color = parent.color;
           parent.color = "BLACK";
           this._rightRotate(parent);
@@ -3768,17 +3922,17 @@ var _RedBlackTree = class _RedBlackTree extends BST {
         }
       } else {
         let sibling = parent.left;
-        if ((sibling == null ? void 0 : sibling.color) === "RED") {
+        if (sibling?.color === "RED") {
           sibling.color = "BLACK";
           if (parent) parent.color = "RED";
           this._rightRotate(parent);
           if (parent) sibling = parent.left;
         }
-        if (((_d = (_c = sibling == null ? void 0 : sibling.right) == null ? void 0 : _c.color) != null ? _d : "BLACK") === "BLACK") {
+        if ((sibling?.right?.color ?? "BLACK") === "BLACK") {
           if (sibling) sibling.color = "RED";
           node = parent;
         } else {
-          if (sibling == null ? void 0 : sibling.right) sibling.right.color = "BLACK";
+          if (sibling?.right) sibling.right.color = "BLACK";
           if (sibling) sibling.color = parent.color;
           if (parent) parent.color = "BLACK";
           this._leftRotate(parent);
@@ -3802,7 +3956,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     }
     const y = x.right;
     x.right = y.left;
-    if (this.isRealNode(y.left)) {
+    if (y.left && y.left !== this.NIL) {
       y.left.parent = x;
     }
     y.parent = x.parent;
@@ -3828,7 +3982,7 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     }
     const x = y.left;
     y.left = x.right;
-    if (this.isRealNode(x.right)) {
+    if (x.right && x.right !== this.NIL) {
       x.right.parent = y;
     }
     x.parent = y.parent;
@@ -3843,8 +3997,6 @@ var _RedBlackTree = class _RedBlackTree extends BST {
     y.parent = x;
   }
 };
-__name(_RedBlackTree, "RedBlackTree");
-var RedBlackTree = _RedBlackTree;
 /**
  * data-structure-typed
  *