data-structure-typed 1.49.9 → 1.50.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-structure-typed",
-  "version": "1.49.9",
-  "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
+  "version": "1.50.1",
+  "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/mjs/index.d.ts",
@@ -92,17 +92,14 @@
     "typescript": "^5.3.2"
   },
   "keywords": [
-    "data",
-    "structure",
-    "structures",
     "data structure",
-    "datastructure",
     "data-structure",
-    "data structures",
-    "datastructures",
-    "data-structures",
-    "in data structures",
-    "in data structure",
+    "datastructure",
+    "javascript data structure",
+    "typescript data structure",
+    "js data structure",
+    "data",
+    "structure",
     "binary",
     "depth",
     "breadth",
@@ -112,7 +109,7 @@
     "avl",
     "red",
     "black",
-    "redblack",
+    "red black",
     "RB",
     "segment",
     "prefix",
@@ -150,7 +147,6 @@
     "Python",
     "collections",
     "Python Collections",
-    "pythoncollections",
     "python-collections",
     "C#",
     "System.Collections.Generic",
@@ -159,41 +155,30 @@
     "Java",
     "util",
     "binary search tree",
-    "binarysearchtree",
     "binary-search-tree",
     "BST",
     "binary tree",
-    "binarytree",
     "binary-tree",
     "red black tree",
-    "redblacktree",
-    "redblack tree",
+    "red black tree",
     "red-black-tree",
-    "redblack-tree",
+    "rb tree",
     "trie",
     "prefix tree",
-    "prefixtree",
     "prefix-tree",
     "avl tree",
-    "avltree",
     "avl-tree",
     "tree set",
-    "treeset",
     "tree-set",
     "tree multiset",
-    "treemultiset",
     "tree-multiset",
     "tree map",
-    "treemap",
     "tree-map",
     "tree multimap",
-    "treemultimap",
     "tree-multimap",
     "binary indexed tree",
-    "binaryindexedtree",
     "binary-indexed-tree",
     "segment tree",
-    "segmenttree",
     "segment-tree",
     "sort",
     "sorted",
@@ -203,60 +188,46 @@
     "morris",
     "Morris",
     "bellman ford",
-    "bellmanford",
     "bellman-ford",
     "dijkstra",
     "Dijkstra",
     "floyd warshall",
-    "floydwarshall",
     "floyd-warshall",
     "tarjan",
     "tarjan's",
     "dfs",
     "depth first Search",
-    "depthfirstSearch",
     "depth-first-Search",
     "bfs",
     "breadth first search",
-    "breadthfirstsearch",
     "dfs iterative",
     "recursive",
     "iterative",
     "directed graph",
-    "directedgraph",
     "directed-graph",
     "undirected graph",
-    "undirectedgraph",
     "undirected-graph",
     "min heap",
-    "minheap",
     "min-heap",
     "max heap",
-    "maxheap",
     "max-heap",
     "priority queue",
-    "priorityqueue",
     "priority-queue",
     "max priority queue",
-    "maxpriorityqueue",
     "max-priority-queue",
     "min priority queue",
-    "minpriorityqueue",
     "min-priority-queue",
     "hash",
     "map",
-    "hash map",
     "hashmap",
+    "hash map",
     "hash-map",
     "deque",
     "linked list",
-    "linkedlist",
     "linked-list",
     "singly linked list",
-    "singlylinkedlist",
     "singly-linked-list",
     "doubly linked list",
-    "doublylinkedlist",
     "doubly-linked-list",
     "stack",
     "CommonJS",

package/src/data-structures/base/iterable-base.ts

@@ -15,7 +15,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any additional arguments to the `_getIterator` method.
    */
-  *[Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
+  * [Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
     yield* this._getIterator(...args);
   }
 
@@ -30,7 +30,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * The function returns an iterator that yields key-value pairs from the object, where the value can
    * be undefined.
    */
-  *entries(): IterableIterator<[K, V | undefined]> {
+  * entries(): IterableIterator<[K, V | undefined]> {
     for (const item of this) {
       yield item;
     }
@@ -46,7 +46,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The function returns an iterator that yields the keys of a data structure.
    */
-  *keys(): IterableIterator<K> {
+  * keys(): IterableIterator<K> {
     for (const item of this) {
       yield item[0];
     }
@@ -62,7 +62,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The function returns an iterator that yields the values of a collection.
    */
-  *values(): IterableIterator<V> {
+  * values(): IterableIterator<V> {
     for (const item of this) {
       yield item[1];
     }
@@ -212,7 +212,7 @@ export abstract class IterableElementBase<V> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any number of arguments to the `_getIterator` method.
    */
-  *[Symbol.iterator](...args: any[]): IterableIterator<V> {
+  * [Symbol.iterator](...args: any[]): IterableIterator<V> {
     yield* this._getIterator(...args);
   }
 
@@ -226,7 +226,7 @@ export abstract class IterableElementBase<V> {
    *
    * The function returns an iterator that yields all the values in the object.
    */
-  *values(): IterableIterator<V> {
+  * values(): IterableIterator<V> {
     for (const item of this) {
       yield item;
     }

package/src/data-structures/binary-tree/avl-tree.ts

@@ -40,14 +40,13 @@ export class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLT
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  */
 export class AVLTree<
-    K = any,
-    V = any,
-    N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
-    TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
+  TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>
+>
   extends BST<K, V, N, TREE>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   /**
    * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
    * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
@@ -99,16 +98,6 @@ export class AVLTree<
     return keyOrNodeOrEntry instanceof AVLTreeNode;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof AVLTreeNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -278,7 +267,7 @@ export class AVLTree<
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-      ) {
+        ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

package/src/data-structures/binary-tree/binary-tree.ts

@@ -101,14 +101,13 @@ export class BinaryTreeNode<
  */
 
 export class BinaryTree<
-    K = any,
-    V = any,
-    N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
-    TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
+  TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>
+>
   extends IterableEntryBase<K, V | undefined>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   iterationType = IterationType.ITERATIVE;
 
   /**
@@ -197,7 +196,7 @@ export class BinaryTree<
       }
     } else if (this.isNode(keyOrNodeOrEntry)) {
       node = keyOrNodeOrEntry;
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value);
     } else {
       return;
@@ -293,16 +292,6 @@ export class BinaryTree<
     return this.isRealNode(node) || node === null;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof BinaryTreeNode);
-  }
-
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
@@ -1029,7 +1018,7 @@ export class BinaryTree<
    *
    * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
    * structure, with the option to reverse the order of the nodes.
-   * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+   * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
    * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
    * `null`, or `undefined`.
    * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
@@ -1037,20 +1026,20 @@ export class BinaryTree<
    * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
    * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
    */
-  getPathToRoot(beginRoot: KeyOrNodeOrEntry<K, V, N>, isReverse = true): N[] {
+  getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, N>, isReverse = true): N[] {
     // TODO to support get path through passing key
     const result: N[] = [];
-    beginRoot = this.ensureNode(beginRoot);
+    beginNode = this.ensureNode(beginNode);
 
-    if (!beginRoot) return result;
+    if (!beginNode) return result;
 
-    while (beginRoot.parent) {
+    while (beginNode.parent) {
       // Array.push + Array.reverse is more efficient than Array.unshift
       // TODO may consider using Deque, so far this is not the performance bottleneck
-      result.push(beginRoot);
-      beginRoot = beginRoot.parent;
+      result.push(beginNode);
+      beginNode = beginNode.parent;
     }
-    result.push(beginRoot);
+    result.push(beginNode);
     return isReverse ? result.reverse() : result;
   }
 
@@ -1203,99 +1192,94 @@ export class BinaryTree<
     }
   }
 
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(log n)
-   */
-
-  subTreeTraverse<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: false
-  ): ReturnType<C>[];
-
-  subTreeTraverse<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[];
-
-  subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: true
-  ): ReturnType<C>[];
-
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(log n)
-   *
-   * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
-   * node, either recursively or iteratively.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-   * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
-   * returns a value of any type.
-   * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-   * starting node or key from which the subtree traversal should begin. It can be of type `K`,
-   * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
-   * the default value.
-   * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-   * performed on the subtree. It can have two possible values:
-   * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-   * whether to include null values in the traversal. If `includeNull` is set to `true`, the
-   * traversal will include null values, otherwise it will skip them.
-   * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-   * the `callback` function on each node in the subtree. The type of the array nodes is determined
-   * by the return type of the `callback` function.
-   */
-  subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
-    callback: C = this._defaultOneParamCallback as C,
-    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
-    iterationType = this.iterationType,
-    includeNull = false
-  ): ReturnType<C>[] {
-    beginRoot = this.ensureNode(beginRoot);
-
-    const ans: (ReturnType<BTNCallback<N>> | null | undefined)[] = [];
-    if (!beginRoot) return ans;
-
-    if (iterationType === IterationType.RECURSIVE) {
-      const _traverse = (cur: N | null | undefined) => {
-        if (cur !== undefined) {
-          ans.push(callback(cur));
-          if (includeNull) {
-            cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
-            cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
-          } else {
-            cur && cur.left && _traverse(cur.left);
-            cur && cur.right && _traverse(cur.right);
-          }
-        }
-      };
-
-      _traverse(beginRoot);
-    } else {
-      const stack: (N | null | undefined)[] = [beginRoot];
-
-      while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur !== undefined) {
-          ans.push(callback(cur));
-          if (includeNull) {
-            cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
-            cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
-          } else {
-            cur && cur.right && stack.push(cur.right);
-            cur && cur.left && stack.push(cur.left);
-          }
-        }
-      }
-    }
-    return ans;
-  }
+  // /**
+  //  * Time complexity: O(n)
+  //  * Space complexity: O(log n)
+  //  */
+  //
+  // subTreeTraverse<C extends BTNCallback<N>>(
+  //   callback?: C,
+  //   beginRoot?: KeyOrNodeOrEntry<K, V, N>,
+  //   iterationType?: IterationType,
+  //   includeNull?: false
+  // ): ReturnType<C>[];
+  //
+  // subTreeTraverse<C extends BTNCallback<N | null>>(
+  //   callback?: C,
+  //   beginRoot?: KeyOrNodeOrEntry<K, V, N>,
+  //   iterationType?: IterationType,
+  //   includeNull?: true
+  // ): ReturnType<C>[];
+  //
+  // /**
+  //  * Time complexity: O(n)
+  //  * Space complexity: O(log n)
+  //  *
+  //  * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
+  //  * node, either recursively or iteratively.
+  //  * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+  //  * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
+  //  * returns a value of any type.
+  //  * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+  //  * starting node or key from which the subtree traversal should begin. It can be of type `K`,
+  //  * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
+  //  * the default value.
+  //  * @param iterationType - The `iterationType` parameter determines the type of traversal to be
+  //  * performed on the subtree. It can have two possible values:
+  //  * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
+  //  * whether to include null values in the traversal. If `includeNull` is set to `true`, the
+  //  * traversal will include null values, otherwise it will skip them.
+  //  * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
+  //  * the `callback` function on each node in the subtree. The type of the array nodes is determined
+  //  * by the return type of the `callback` function.
+  //  */
+  // subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
+  //   callback: C = this._defaultOneParamCallback as C,
+  //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+  //   iterationType = this.iterationType,
+  //   includeNull = false
+  // ): ReturnType<C>[] {
+  //   console.warn('subTreeTraverse is unnecessary, since the dfs method can substitute it.');
+  //
+  //   beginRoot = this.ensureNode(beginRoot);
+  //
+  //   const ans: (ReturnType<BTNCallback<N>> | null | undefined)[] = [];
+  //   if (!beginRoot) return ans;
+  //
+  //   if (iterationType === IterationType.RECURSIVE) {
+  //     const _traverse = (cur: N | null | undefined) => {
+  //       if (cur !== undefined) {
+  //         ans.push(callback(cur));
+  //         if (includeNull) {
+  //           cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
+  //           cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
+  //         } else {
+  //           cur && cur.left && _traverse(cur.left);
+  //           cur && cur.right && _traverse(cur.right);
+  //         }
+  //       }
+  //     };
+  //
+  //     _traverse(beginRoot);
+  //   } else {
+  //     const stack: (N | null | undefined)[] = [beginRoot];
+  //
+  //     while (stack.length > 0) {
+  //       const cur = stack.pop();
+  //       if (cur !== undefined) {
+  //         ans.push(callback(cur));
+  //         if (includeNull) {
+  //           cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
+  //           cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
+  //         } else {
+  //           cur && cur.right && stack.push(cur.right);
+  //           cur && cur.left && stack.push(cur.left);
+  //         }
+  //       }
+  //     }
+  //   }
+  //   return ans;
+  // }
 
   dfs<C extends BTNCallback<N>>(
     callback?: C,
@@ -1305,15 +1289,7 @@ export class BinaryTree<
     includeNull?: false
   ): ReturnType<C>[];
 
-  dfs<C extends BTNCallback<N>>(
-    callback?: C,
-    pattern?: DFSOrderPattern,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[];
-
-  dfs<C extends BTNCallback<N | null | undefined>>(
+  dfs<C extends BTNCallback<N | null>>(
     callback?: C,
     pattern?: DFSOrderPattern,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
@@ -1451,14 +1427,7 @@ export class BinaryTree<
     includeNull?: false
   ): ReturnType<C>[];
 
-  bfs<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[];
-
-  bfs<C extends BTNCallback<N | null | undefined>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
@@ -1486,7 +1455,7 @@ export class BinaryTree<
    * @returns an array of values that are the result of invoking the callback function on each node in
    * the breadth-first traversal of a binary tree.
    */
-  bfs<C extends BTNCallback<N | null | undefined>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
@@ -1552,14 +1521,7 @@ export class BinaryTree<
     includeNull?: false
   ): ReturnType<C>[][];
 
-  listLevels<C extends BTNCallback<N>>(
-    callback?: C,
-    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
-    iterationType?: IterationType,
-    includeNull?: undefined
-  ): ReturnType<C>[][];
-
-  listLevels<C extends BTNCallback<N | null | undefined>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
@@ -1587,7 +1549,7 @@ export class BinaryTree<
    * be excluded
    * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
    */
-  listLevels<C extends BTNCallback<N | null | undefined>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
@@ -1598,7 +1560,7 @@ export class BinaryTree<
     if (!beginRoot) return levelsNodes;
 
     if (iterationType === IterationType.RECURSIVE) {
-      const _recursive = (node: N | null | undefined, level: number) => {
+      const _recursive = (node: N | null, level: number) => {
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
         if (includeNull) {
@@ -1612,7 +1574,7 @@ export class BinaryTree<
 
       _recursive(beginRoot, 0);
     } else {
-      const stack: [N | null | undefined, number][] = [[beginRoot, 0]];
+      const stack: [N | null, number][] = [[beginRoot, 0]];
 
       while (stack.length > 0) {
         const head = stack.pop()!;
@@ -1923,7 +1885,7 @@ export class BinaryTree<
     display(beginRoot);
   }
 
-  protected *_getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
+  protected* _getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
     if (!node) return;
 
     if (this.iterationType === IterationType.ITERATIVE) {