data-structure-typed 1.50.7 → 1.50.9

package/dist/cjs/data-structures/heap/heap.js

@@ -229,26 +229,26 @@ class Heap extends base_1.IterableElementBase {
      * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
-     * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order = 'pre') {
+    dfs(order = 'PRE') {
         const result = [];
         // Auxiliary recursive function, traverses the binary heap according to the traversal order
         const _dfs = (index) => {
             const left = 2 * index + 1, right = left + 1;
             if (index < this.size) {
-                if (order === 'in') {
+                if (order === 'IN') {
                     _dfs(left);
                     result.push(this.elements[index]);
                     _dfs(right);
                 }
-                else if (order === 'pre') {
+                else if (order === 'PRE') {
                     result.push(this.elements[index]);
                     _dfs(left);
                     _dfs(right);
                 }
-                else if (order === 'post') {
+                else if (order === 'POST') {
                     _dfs(left);
                     _dfs(right);
                     result.push(this.elements[index]);

package/dist/cjs/types/common.d.ts

@@ -1,33 +1,15 @@
-export declare enum BSTVariant {
-    STANDARD = "STANDARD",
-    INVERSE = "INVERSE"
-}
-export declare enum CP {
-    lt = "lt",
-    eq = "eq",
-    gt = "gt"
-}
+export type BSTVariant = 'STANDARD' | 'INVERSE';
+export type CP = 'LT' | 'EQ' | 'GT';
 /**
  * Enum representing different loop types.
  *
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export declare enum IterationType {
-    ITERATIVE = "ITERATIVE",
-    RECURSIVE = "RECURSIVE"
-}
-export declare enum FamilyPosition {
-    ROOT = "ROOT",
-    LEFT = "LEFT",
-    RIGHT = "RIGHT",
-    ROOT_LEFT = "ROOT_LEFT",
-    ROOT_RIGHT = "ROOT_RIGHT",
-    ISOLATED = "ISOLATED",
-    MAL_NODE = "MAL_NODE"
-}
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 export type Comparator<K> = (a: K, b: K) => number;
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 export type NodeDisplayLayout = [string[], number, number, number];
 export type BTNCallback<N, D = any> = (node: N) => D;
 export interface IterableWithSize<T> extends Iterable<T> {
@@ -52,9 +34,4 @@ export type BinaryTreeDeleteResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null | undefined;
 };
-export declare enum CRUD {
-    CREATED = "CREATED",
-    READ = "READ",
-    UPDATED = "UPDATED",
-    DELETED = "DELETED"
-}
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

package/dist/cjs/types/common.js

@@ -1,43 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CRUD = exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
-var BSTVariant;
-(function (BSTVariant) {
-    BSTVariant["STANDARD"] = "STANDARD";
-    BSTVariant["INVERSE"] = "INVERSE";
-})(BSTVariant || (exports.BSTVariant = BSTVariant = {}));
-var CP;
-(function (CP) {
-    CP["lt"] = "lt";
-    CP["eq"] = "eq";
-    CP["gt"] = "gt";
-})(CP || (exports.CP = CP = {}));
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
-var IterationType;
-(function (IterationType) {
-    IterationType["ITERATIVE"] = "ITERATIVE";
-    IterationType["RECURSIVE"] = "RECURSIVE";
-})(IterationType || (exports.IterationType = IterationType = {}));
-var FamilyPosition;
-(function (FamilyPosition) {
-    FamilyPosition["ROOT"] = "ROOT";
-    FamilyPosition["LEFT"] = "LEFT";
-    FamilyPosition["RIGHT"] = "RIGHT";
-    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition["ISOLATED"] = "ISOLATED";
-    FamilyPosition["MAL_NODE"] = "MAL_NODE";
-})(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));
-var CRUD;
-(function (CRUD) {
-    CRUD["CREATED"] = "CREATED";
-    CRUD["READ"] = "READ";
-    CRUD["UPDATED"] = "UPDATED";
-    CRUD["DELETED"] = "DELETED";
-})(CRUD || (exports.CRUD = CRUD = {}));
 //# sourceMappingURL=common.js.map

package/dist/cjs/types/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/types/common.ts"],"names":[],"mappings":";;;AAAA,IAAY,UAGX;AAHD,WAAY,UAAU;IACpB,mCAAqB,CAAA;IACrB,iCAAmB,CAAA;AACrB,CAAC,EAHW,UAAU,0BAAV,UAAU,QAGrB;AAED,IAAY,EAIX;AAJD,WAAY,EAAE;IACZ,eAAS,CAAA;IACT,eAAS,CAAA;IACT,eAAS,CAAA;AACX,CAAC,EAJW,EAAE,kBAAF,EAAE,QAIb;AAED;;;;;GAKG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,wCAAuB,CAAA;IACvB,wCAAuB,CAAA;AACzB,CAAC,EAHW,aAAa,6BAAb,aAAa,QAGxB;AAED,IAAY,cAQX;AARD,WAAY,cAAc;IACxB,+BAAa,CAAA;IACb,+BAAa,CAAA;IACb,iCAAe,CAAA;IACf,yCAAuB,CAAA;IACvB,2CAAyB,CAAA;IACzB,uCAAqB,CAAA;IACrB,uCAAqB,CAAA;AACvB,CAAC,EARW,cAAc,8BAAd,cAAc,QAQzB;AAoCD,IAAY,IAKX;AALD,WAAY,IAAI;IACd,2BAAmB,CAAA;IACnB,qBAAa,CAAA;IACb,2BAAmB,CAAA;IACnB,2BAAmB,CAAA;AACrB,CAAC,EALW,IAAI,oBAAJ,IAAI,QAKf"}
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/types/common.ts"],"names":[],"mappings":""}

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

@@ -1,9 +1,6 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
-export declare enum RBTNColor {
-    RED = 1,
-    BLACK = 0
-}
+export type RBTNColor = 'RED' | 'BLACK';
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RedBlackTreeNested<K, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions<K> = Omit<BSTOptions<K>, 'variant'> & {};

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

@@ -1,9 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTNColor = void 0;
-var RBTNColor;
-(function (RBTNColor) {
-    RBTNColor[RBTNColor["RED"] = 1] = "RED";
-    RBTNColor[RBTNColor["BLACK"] = 0] = "BLACK";
-})(RBTNColor || (exports.RBTNColor = RBTNColor = {}));
 //# sourceMappingURL=rb-tree.js.map

package/dist/cjs/types/data-structures/binary-tree/rb-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"rb-tree.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/binary-tree/rb-tree.ts"],"names":[],"mappings":";;;AAGA,IAAY,SAA+B;AAA3C,WAAY,SAAS;IAAG,uCAAO,CAAA;IAAE,2CAAS,CAAA;AAAA,CAAC,EAA/B,SAAS,yBAAT,SAAS,QAAsB"}
+{"version":3,"file":"rb-tree.js","sourceRoot":"","sources":["../../../../../src/types/data-structures/binary-tree/rb-tree.ts"],"names":[],"mappings":""}

package/dist/mjs/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -5,8 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { IterationType } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
@@ -46,7 +45,19 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
-    getMutableCount(): number;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to

package/dist/mjs/data-structures/binary-tree/avl-tree-multi-map.js

@@ -1,4 +1,3 @@
-import { FamilyPosition, IterationType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export class AVLTreeMultiMapNode extends AVLTreeNode {
     /**
@@ -51,7 +50,19 @@ export class AVLTreeMultiMap extends AVLTree {
     get count() {
         return this._count;
     }
-    getMutableCount() {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
         return sum;
@@ -204,10 +215,10 @@ export class AVLTreeMultiMap extends AVLTree {
                 }
                 else {
                     const { familyPosition: fp } = curr;
-                    if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+                    if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
                         parent.left = curr.right;
                     }
-                    else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+                    else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
                         parent.right = curr.right;
                     }
                     needBalanced = parent;
@@ -270,11 +281,11 @@ export class AVLTreeMultiMap extends AVLTree {
      * @returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
+        const sorted = this.dfs(node => node, 'IN'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;

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

@@ -135,7 +135,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
-     * `IterationType.ITERATIVE`.
+     * `'ITERATIVE'`.
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */

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

@@ -5,7 +5,6 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { FamilyPosition, IterationType } from '../../types';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
 import { IterableEntryBase } from '../base';
@@ -77,15 +76,15 @@ export class BinaryTreeNode {
     get familyPosition() {
         const that = this;
         if (!this.parent) {
-            return this.left || this.right ? FamilyPosition.ROOT : FamilyPosition.ISOLATED;
+            return this.left || this.right ? 'ROOT' : 'ISOLATED';
         }
         if (this.parent.left === that) {
-            return this.left || this.right ? FamilyPosition.ROOT_LEFT : FamilyPosition.LEFT;
+            return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
         }
         else if (this.parent.right === that) {
-            return this.left || this.right ? FamilyPosition.ROOT_RIGHT : FamilyPosition.RIGHT;
+            return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
         }
-        return FamilyPosition.MAL_NODE;
+        return 'MAL_NODE';
     }
 }
 /**
@@ -96,7 +95,7 @@ export class BinaryTreeNode {
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
 export class BinaryTree extends IterableEntryBase {
-    iterationType = IterationType.ITERATIVE;
+    iterationType = 'ITERATIVE';
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
      * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
@@ -119,7 +118,7 @@ export class BinaryTree extends IterableEntryBase {
         if (keysOrNodesOrEntries)
             this.addMany(keysOrNodesOrEntries);
     }
-    _extractor = (key) => Number(key);
+    _extractor = (key) => (typeof key === 'number' ? key : Number(key));
     /**
      * The function returns the value of the `_extractor` property.
      * @returns The `_extractor` property is being returned.
@@ -215,11 +214,11 @@ export class BinaryTree extends IterableEntryBase {
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be used when searching for a node by key. It has a default value of
-     * `IterationType.ITERATIVE`.
+     * `'ITERATIVE'`.
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNode(keyOrNodeOrEntry, iterationType = IterationType.ITERATIVE) {
+    ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
         let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
             res = keyOrNodeOrEntry;
@@ -446,10 +445,10 @@ export class BinaryTree extends IterableEntryBase {
         }
         else if (parent) {
             const { familyPosition: fp } = curr;
-            if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+            if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
                 parent.left = curr.right;
             }
-            else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+            else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
                 parent.right = curr.right;
             }
             needBalanced = parent;
@@ -498,7 +497,7 @@ export class BinaryTree extends IterableEntryBase {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 if (callback(cur) === identifier) {
                     ans.push(cur);
@@ -577,10 +576,10 @@ export class BinaryTree extends IterableEntryBase {
      * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key, iterationType = IterationType.ITERATIVE) {
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
         if (!this.root)
             return undefined;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
@@ -734,7 +733,7 @@ export class BinaryTree extends IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return true;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const dfs = (cur, min, max) => {
                 if (!this.isRealNode(cur))
                     return true;
@@ -823,7 +822,7 @@ export class BinaryTree extends IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!this.isRealNode(beginRoot))
             return -1;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _getMaxHeight = (cur) => {
                 if (!this.isRealNode(cur))
                     return -1;
@@ -868,7 +867,7 @@ export class BinaryTree extends IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return -1;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _getMinHeight = (cur) => {
                 if (!this.isRealNode(cur))
                     return 0;
@@ -966,7 +965,7 @@ export class BinaryTree extends IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!this.isRealNode(beginRoot))
             return beginRoot;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
@@ -1010,7 +1009,7 @@ export class BinaryTree extends IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
@@ -1110,15 +1109,15 @@ export class BinaryTree extends IterableEntryBase {
      * `false`, null or undefined
      * @returns an array of values that are the return values of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE, includeNull = false) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (node) => {
                 switch (pattern) {
-                    case 'in':
+                    case 'IN':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
@@ -1134,7 +1133,7 @@ export class BinaryTree extends IterableEntryBase {
                                 _traverse(node.right);
                         }
                         break;
-                    case 'pre':
+                    case 'PRE':
                         if (includeNull) {
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
@@ -1150,7 +1149,7 @@ export class BinaryTree extends IterableEntryBase {
                                 _traverse(node.right);
                         }
                         break;
-                    case 'post':
+                    case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
@@ -1190,17 +1189,17 @@ export class BinaryTree extends IterableEntryBase {
                 }
                 else {
                     switch (pattern) {
-                        case 'in':
+                        case 'IN':
                             cur.node && stack.push({ opt: 0, node: cur.node.right });
                             stack.push({ opt: 1, node: cur.node });
                             cur.node && stack.push({ opt: 0, node: cur.node.left });
                             break;
-                        case 'pre':
+                        case 'PRE':
                             cur.node && stack.push({ opt: 0, node: cur.node.right });
                             cur.node && stack.push({ opt: 0, node: cur.node.left });
                             stack.push({ opt: 1, node: cur.node });
                             break;
-                        case 'post':
+                        case 'POST':
                             stack.push({ opt: 1, node: cur.node });
                             cur.node && stack.push({ opt: 0, node: cur.node.right });
                             cur.node && stack.push({ opt: 0, node: cur.node.left });
@@ -1246,7 +1245,7 @@ export class BinaryTree extends IterableEntryBase {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const queue = new Queue([beginRoot]);
             const traverse = (level) => {
                 if (queue.size === 0)
@@ -1323,7 +1322,7 @@ export class BinaryTree extends IterableEntryBase {
         const levelsNodes = [];
         if (!beginRoot)
             return levelsNodes;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _recursive = (node, level) => {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
@@ -1390,7 +1389,7 @@ export class BinaryTree extends IterableEntryBase {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
+    morris(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root) {
         beginRoot = this.ensureNode(beginRoot);
         if (beginRoot === null)
             return [];
@@ -1417,7 +1416,7 @@ export class BinaryTree extends IterableEntryBase {
             _reverseEdge(tail);
         };
         switch (pattern) {
-            case 'in':
+            case 'IN':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1434,7 +1433,7 @@ export class BinaryTree extends IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'pre':
+            case 'PRE':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1454,7 +1453,7 @@ export class BinaryTree extends IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'post':
+            case 'POST':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1610,7 +1609,7 @@ export class BinaryTree extends IterableEntryBase {
     *_getIterator(node = this.root) {
         if (!node)
             return;
-        if (this.iterationType === IterationType.ITERATIVE) {
+        if (this.iterationType === 'ITERATIVE') {
             const stack = [];
             let current = node;
             while (current || stack.length > 0) {

package/dist/mjs/data-structures/binary-tree/bst.d.ts

@@ -109,7 +109,7 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | undefined;
@@ -372,8 +372,27 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * is greater than, less than, or equal to the second value.
      * @param {K} a - The parameter "a" is of type K.
      * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
-     * than), CP.lt (less than), or CP.eq (equal).
+     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
+     * than), 'LT' (less than), or 'EQ' (equal).
      */
     protected _compare(a: K, b: K): CP;
+    /**
+     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
+     * `a` is less than `b` based on the specified variant.
+     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
+     * first value to be compared in the function.
+     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
+     * of the arguments for the comparison in the `_lt` function.
+     * @returns a boolean value.
+     */
+    protected _lt(a: K, b: K): boolean;
+    /**
+     * The function compares two values using a custom extractor function and returns true if the first
+     * value is greater than the second value.
+     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
+     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
+     * of the arguments for the comparison in the function.
+     * @returns a boolean value.
+     */
+    protected _gt(a: K, b: K): boolean;
 }