min-heap-typed 1.50.2 → 1.50.4

package/dist/data-structures/binary-tree/bst.js

@@ -11,18 +11,37 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
         this._left = undefined;
         this._right = undefined;
     }
+    /**
+     * The function returns the value of the `_left` property.
+     * @returns The `_left` property of the current object is being returned.
+     */
     get left() {
         return this._left;
     }
+    /**
+     * The function sets the left child of a node and updates the parent reference of the child.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+     * instance of the `NODE` class or `undefined`.
+     */
     set left(v) {
         if (v) {
             v.parent = this;
         }
         this._left = v;
     }
+    /**
+     * The function returns the right node of a binary tree or undefined if there is no right node.
+     * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
+     * `undefined`.
+     */
     get right() {
         return this._right;
     }
+    /**
+     * The function sets the right child of a node and updates the parent reference of the child.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+     * `NODE` object or `undefined`.
+     */
     set right(v) {
         if (v) {
             v.parent = this;
@@ -42,10 +61,10 @@ exports.BSTNode = BSTNode;
  */
 class BST extends binary_tree_1.BinaryTree {
     /**
-     * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
-     * binary search tree.
+     * This is the constructor function for a TypeScript class that initializes a binary search tree with
+     * optional keys or nodes or entries and options.
+     * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
+     * to initialize the binary search tree with the provided keys, nodes, or entries.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
@@ -61,19 +80,27 @@ class BST extends binary_tree_1.BinaryTree {
         if (keysOrNodesOrEntries)
             this.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the root node of a tree structure.
+     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
+     */
     get root() {
         return this._root;
     }
+    /**
+     * The function returns the value of the _variant property.
+     * @returns The value of the `_variant` property.
+     */
     get variant() {
         return this._variant;
     }
     /**
-     * The function creates a new binary search tree node with the given key and value.
-     * @param {K} key - The key parameter is the key value that will be associated with
-     * the new node. It is used to determine the position of the node in the binary search tree.
-     * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
-     * represents the value associated with the node in a binary search tree.
-     * @returns a new instance of the BSTNode class with the specified key and value.
+     * The function creates a new BSTNode with the given key and value and returns it.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
+     * being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the node being created.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
      */
     createNode(key, value) {
         return new BSTNode(key, value);
@@ -81,9 +108,10 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function creates a new binary search tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
-     * that defines various options for creating a binary search tree.
-     * @returns a new instance of the BST class with the specified options.
+     * behavior of the `createTree` method. It is of type `Partial<BSTOptions<K>>`, which means it is a
+     * partial object of type `BSTOptions<K>`.
+     * @returns a new instance of the BST class, with the provided options merged with the default
+     * options. The returned value is casted as TREE.
      */
     createTree(options) {
         return new BST([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
@@ -596,11 +624,9 @@ class BST extends binary_tree_1.BinaryTree {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
                     ans.push(callback(cur));
-                if (!cur.left && !cur.right)
-                    return;
-                if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+                if (this.isRealNode(cur.left))
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+                if (this.isRealNode(cur.right))
                     _traverse(cur.right);
             };
             _traverse(this.root);
@@ -610,13 +636,13 @@ class BST extends binary_tree_1.BinaryTree {
             const queue = new queue_1.Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
-                if (cur) {
+                if (this.isRealNode(cur)) {
                     const compared = this._compare(cur.key, targetKey);
                     if (compared === lesserOrGreater)
                         ans.push(callback(cur));
-                    if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+                    if (this.isRealNode(cur.left))
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+                    if (this.isRealNode(cur.right))
                         queue.push(cur.right);
                 }
             }
@@ -742,6 +768,11 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return balanced;
     }
+    /**
+     * The function sets the root property of an object and updates the parent property of the new root.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
+     * can either be an object of type `NODE` or it can be `undefined`.
+     */
     _setRoot(v) {
         if (v) {
             v.parent = undefined;

package/dist/data-structures/binary-tree/index.d.ts

@@ -4,4 +4,5 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './rb-tree';
-export * from './tree-multimap';
+export * from './avl-tree-multi-map';
+export * from './tree-multi-map';

package/dist/data-structures/binary-tree/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./binary-indexed-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./rb-tree"), exports);
-__exportStar(require("./tree-multimap"), exports);
+__exportStar(require("./avl-tree-multi-map"), exports);
+__exportStar(require("./tree-multi-map"), exports);

package/dist/data-structures/binary-tree/rb-tree.d.ts

@@ -9,8 +9,29 @@ import { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, R
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
-    color: RBTNColor;
+    /**
+     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
+     * color.
+     * @param {K} key - The key parameter is of type K and represents the key of the node in the
+     * Red-Black Tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
+     * creating a new instance of the Red-Black Tree Node.
+     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
+     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     */
     constructor(key: K, value?: V, color?: RBTNColor);
+    protected _color: RBTNColor;
+    /**
+     * The function returns the color value of a variable.
+     * @returns The color value stored in the protected variable `_color`.
+     */
+    get color(): RBTNColor;
+    /**
+     * The function sets the color property to the specified value.
+     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
+     */
+    set color(value: RBTNColor);
 }
 /**
  * 1. Each node is either red or black.
@@ -20,7 +41,6 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
 export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, NODE, TREE> = RedBlackTree<K, V, NODE, RedBlackTreeNested<K, V, NODE>>> extends BST<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
-    Sentinel: NODE;
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
@@ -33,9 +53,23 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K>);
+    protected _Sentinel: NODE;
+    /**
+     * The function returns the value of the `_Sentinel` property.
+     * @returns The method is returning the value of the `_Sentinel` property.
+     */
+    get Sentinel(): NODE;
     protected _root: NODE;
+    /**
+     * The function returns the root node.
+     * @returns The root node of the data structure.
+     */
     get root(): NODE;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
@@ -74,6 +108,12 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * class.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
+    /**
+     * The function checks if a given node is a real node in a Red-Black Tree.
+     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
+     * it can either be of type `NODE` or `undefined`.
+     * @returns a boolean value.
+     */
     isRealNode(node: NODE | undefined): node is NODE;
     /**
      * Time Complexity: O(log n)
@@ -143,6 +183,12 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function sets the root node to the sentinel node and resets the size to 0.
+     */
     clear(): void;
     /**
      * Time Complexity: O(log n)
@@ -158,6 +204,12 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x: NODE): NODE;
+    /**
+     * The function sets the root node of a tree structure and updates the parent property of the new
+     * root node.
+     * @param {NODE} v - The parameter "v" is of type "NODE", which represents a node in a data
+     * structure.
+     */
     protected _setRoot(v: NODE): void;
     /**
      * Time Complexity: O(1)

package/dist/data-structures/binary-tree/rb-tree.js

@@ -11,9 +11,34 @@ exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
 const types_1 = require("../../types");
 const bst_1 = require("./bst");
 class RedBlackTreeNode extends bst_1.BSTNode {
+    /**
+     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
+     * color.
+     * @param {K} key - The key parameter is of type K and represents the key of the node in the
+     * Red-Black Tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
+     * creating a new instance of the Red-Black Tree Node.
+     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
+     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     */
     constructor(key, value, color = types_1.RBTNColor.BLACK) {
         super(key, value);
-        this.color = color;
+        this._color = color;
+    }
+    /**
+     * The function returns the color value of a variable.
+     * @returns The color value stored in the protected variable `_color`.
+     */
+    get color() {
+        return this._color;
+    }
+    /**
+     * The function sets the color property to the specified value.
+     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
+     */
+    set color(value) {
+        this._color = value;
     }
 }
 exports.RedBlackTreeNode = RedBlackTreeNode;
@@ -38,15 +63,30 @@ class RedBlackTree extends bst_1.BST {
      */
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        this.Sentinel = new RedBlackTreeNode(NaN);
+        this._Sentinel = new RedBlackTreeNode(NaN);
         this._size = 0;
-        this._root = this.Sentinel;
+        this._root = this._Sentinel;
         if (keysOrNodesOrEntries)
             super.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the value of the `_Sentinel` property.
+     * @returns The method is returning the value of the `_Sentinel` property.
+     */
+    get Sentinel() {
+        return this._Sentinel;
+    }
+    /**
+     * The function returns the root node.
+     * @returns The root node of the data structure.
+     */
     get root() {
         return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
         return this._size;
     }
@@ -117,8 +157,14 @@ class RedBlackTree extends bst_1.BST {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
+    /**
+     * The function checks if a given node is a real node in a Red-Black Tree.
+     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
+     * it can either be of type `NODE` or `undefined`.
+     * @returns a boolean value.
+     */
     isRealNode(node) {
-        if (node === this.Sentinel || node === undefined)
+        if (node === this._Sentinel || node === undefined)
             return false;
         return node instanceof RedBlackTreeNode;
     }
@@ -143,11 +189,11 @@ class RedBlackTree extends bst_1.BST {
         const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return false;
-        newNode.left = this.Sentinel;
-        newNode.right = this.Sentinel;
+        newNode.left = this._Sentinel;
+        newNode.right = this._Sentinel;
         let y = undefined;
         let x = this.root;
-        while (x !== this.Sentinel) {
+        while (x !== this._Sentinel) {
             y = x;
             if (x) {
                 if (newNode.key < x.key) {
@@ -211,9 +257,9 @@ class RedBlackTree extends bst_1.BST {
         if (identifier === null)
             return ans;
         const helper = (node) => {
-            let z = this.Sentinel;
+            let z = this._Sentinel;
             let x, y;
-            while (node !== this.Sentinel) {
+            while (node !== this._Sentinel) {
                 if (node && callback(node) === identifier) {
                     z = node;
                 }
@@ -224,17 +270,17 @@ class RedBlackTree extends bst_1.BST {
                     node = node === null || node === void 0 ? void 0 : node.left;
                 }
             }
-            if (z === this.Sentinel) {
+            if (z === this._Sentinel) {
                 this._size--;
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === this.Sentinel) {
+            if (z.left === this._Sentinel) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === this.Sentinel) {
+            else if (z.right === this._Sentinel) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -300,8 +346,14 @@ class RedBlackTree extends bst_1.BST {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function sets the root node to the sentinel node and resets the size to 0.
+     */
     clear() {
-        this._root = this.Sentinel;
+        this._root = this._Sentinel;
         this._size = 0;
     }
     /**
@@ -328,6 +380,12 @@ class RedBlackTree extends bst_1.BST {
         }
         return y;
     }
+    /**
+     * The function sets the root node of a tree structure and updates the parent property of the new
+     * root node.
+     * @param {NODE} v - The parameter "v" is of type "NODE", which represents a node in a data
+     * structure.
+     */
     _setRoot(v) {
         if (v) {
             v.parent = undefined;
@@ -349,7 +407,7 @@ class RedBlackTree extends bst_1.BST {
         if (x.right) {
             const y = x.right;
             x.right = y.left;
-            if (y.left !== this.Sentinel) {
+            if (y.left !== this._Sentinel) {
                 if (y.left)
                     y.left.parent = x;
             }
@@ -383,7 +441,7 @@ class RedBlackTree extends bst_1.BST {
         if (x.left) {
             const y = x.left;
             x.left = y.right;
-            if (y.right !== this.Sentinel) {
+            if (y.right !== this._Sentinel) {
                 if (y.right)
                     y.right.parent = x;
             }
@@ -415,12 +473,13 @@ class RedBlackTree extends bst_1.BST {
      */
     _fixInsert(k) {
         let u;
-        while (k.parent && k.parent.color === 1) {
+        while (k.parent && k.parent.color === types_1.RBTNColor.RED) {
             if (k.parent.parent && k.parent === k.parent.parent.right) {
                 u = k.parent.parent.left;
-                if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
+                if (u && u.color === types_1.RBTNColor.RED) {
+                    // Delay color flip
                     k.parent.color = types_1.RBTNColor.BLACK;
+                    u.color = types_1.RBTNColor.BLACK;
                     k.parent.parent.color = types_1.RBTNColor.RED;
                     k = k.parent.parent;
                 }
@@ -429,16 +488,20 @@ class RedBlackTree extends bst_1.BST {
                         k = k.parent;
                         this._rightRotate(k);
                     }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    // Check color before rotation
+                    if (k.parent.color === types_1.RBTNColor.RED) {
+                        k.parent.color = types_1.RBTNColor.BLACK;
+                        k.parent.parent.color = types_1.RBTNColor.RED;
+                    }
                     this._leftRotate(k.parent.parent);
                 }
             }
             else {
                 u = k.parent.parent.right;
-                if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
+                if (u && u.color === types_1.RBTNColor.RED) {
+                    // Delay color flip
                     k.parent.color = types_1.RBTNColor.BLACK;
+                    u.color = types_1.RBTNColor.BLACK;
                     k.parent.parent.color = types_1.RBTNColor.RED;
                     k = k.parent.parent;
                 }
@@ -447,8 +510,11 @@ class RedBlackTree extends bst_1.BST {
                         k = k.parent;
                         this._leftRotate(k);
                     }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    // Check color before rotation
+                    if (k.parent.color === types_1.RBTNColor.RED) {
+                        k.parent.color = types_1.RBTNColor.BLACK;
+                        k.parent.parent.color = types_1.RBTNColor.RED;
+                    }
                     this._rightRotate(k.parent.parent);
                 }
             }

package/dist/data-structures/binary-tree/segment-tree.d.ts

@@ -7,13 +7,90 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
-    start: number;
-    end: number;
-    value: SegmentTreeNodeVal | undefined;
-    sum: number;
-    left: SegmentTreeNode | undefined;
-    right: SegmentTreeNode | undefined;
+    /**
+     * The constructor initializes the properties of a SegmentTreeNode object.
+     * @param {number} start - The `start` parameter represents the starting index of the segment covered
+     * by this node in a segment tree.
+     * @param {number} end - The `end` parameter represents the end index of the segment covered by this
+     * node in a segment tree.
+     * @param {number} sum - The `sum` parameter represents the sum of the values in the range covered by
+     * the segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} [value] - The `value` parameter is an optional parameter
+     * of type `SegmentTreeNodeVal`. It represents the value associated with the segment tree node.
+     */
     constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | undefined);
+    protected _start: number;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
+    get start(): number;
+    /**
+     * The above function sets the value of the "start" property.
+     * @param {number} value - The value parameter is of type number.
+     */
+    set start(value: number);
+    protected _end: number;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
+    get end(): number;
+    /**
+     * The above function sets the value of the "end" property.
+     * @param {number} value - The value parameter is a number that represents the new value for the end
+     * property.
+     */
+    set end(value: number);
+    protected _value: SegmentTreeNodeVal | undefined;
+    /**
+     * The function returns the value of a segment tree node.
+     * @returns The value being returned is either a `SegmentTreeNodeVal` object or `undefined`.
+     */
+    get value(): SegmentTreeNodeVal | undefined;
+    /**
+     * The function sets the value of a segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} value - The `value` parameter is of type
+     * `SegmentTreeNodeVal` or `undefined`.
+     */
+    set value(value: SegmentTreeNodeVal | undefined);
+    protected _sum: number;
+    /**
+     * The function returns the value of the sum property.
+     * @returns The method is returning the value of the variable `_sum`.
+     */
+    get sum(): number;
+    /**
+     * The above function sets the value of the sum property.
+     * @param {number} value - The parameter "value" is of type "number".
+     */
+    set sum(value: number);
+    protected _left: SegmentTreeNode | undefined;
+    /**
+     * The function returns the left child of a segment tree node.
+     * @returns The `left` property of the `SegmentTreeNode` object is being returned. It is of type
+     * `SegmentTreeNode` or `undefined`.
+     */
+    get left(): SegmentTreeNode | undefined;
+    /**
+     * The function sets the value of the left property of a SegmentTreeNode object.
+     * @param {SegmentTreeNode | undefined} value - The value parameter is of type SegmentTreeNode or
+     * undefined.
+     */
+    set left(value: SegmentTreeNode | undefined);
+    protected _right: SegmentTreeNode | undefined;
+    /**
+     * The function returns the right child of a segment tree node.
+     * @returns The `getRight()` method is returning a value of type `SegmentTreeNode` or `undefined`.
+     */
+    get right(): SegmentTreeNode | undefined;
+    /**
+     * The function sets the right child of a segment tree node.
+     * @param {SegmentTreeNode | undefined} value - The `value` parameter is of type `SegmentTreeNode |
+     * undefined`. This means that it can accept either a `SegmentTreeNode` object or `undefined` as its
+     * value.
+     */
+    set right(value: SegmentTreeNode | undefined);
 }
 export declare class SegmentTree {
     /**
@@ -27,12 +104,28 @@ export declare class SegmentTree {
      */
     constructor(values: number[], start?: number, end?: number);
     protected _values: number[];
+    /**
+     * The function returns an array of numbers.
+     * @returns An array of numbers is being returned.
+     */
     get values(): number[];
     protected _start: number;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
     get start(): number;
     protected _end: number;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
     get end(): number;
     protected _root: SegmentTreeNode | undefined;
+    /**
+     * The function returns the root node of a segment tree.
+     * @returns The `root` property of the class `SegmentTreeNode` or `undefined` if it is not defined.
+     */
     get root(): SegmentTreeNode | undefined;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning