data-structure-typed 1.50.2 → 1.50.3

package/dist/mjs/data-structures/queue/queue.js

@@ -34,7 +34,7 @@ export class Queue extends IterableElementBase {
     _offset = 0;
     /**
      * The offset function returns the offset of the current page.
-     * @return The value of the private variable _offset
+     * @return The value of the protected variable _offset
      */
     get offset() {
         return this._offset;
@@ -47,8 +47,12 @@ export class Queue extends IterableElementBase {
         return this.elements.length - this.offset;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
@@ -58,12 +62,12 @@ export class Queue extends IterableElementBase {
         return this.size > 0 ? this.elements[this.offset] : undefined;
     }
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
@@ -73,10 +77,13 @@ export class Queue extends IterableElementBase {
         return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
     }
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
      * @static
@@ -88,12 +95,12 @@ export class Queue extends IterableElementBase {
         return new Queue(elements);
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
      * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
@@ -104,12 +111,12 @@ export class Queue extends IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
@@ -147,12 +154,12 @@ export class Queue extends IterableElementBase {
         return spliced.length === 1;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
@@ -162,12 +169,12 @@ export class Queue extends IterableElementBase {
         return this.first;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
@@ -177,12 +184,12 @@ export class Queue extends IterableElementBase {
         return this.last;
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -191,12 +198,12 @@ export class Queue extends IterableElementBase {
         return this.push(value);
     }
     /**
-     * Time Complexity: O(n) - same as shift().
-     * Space Complexity: O(1) - same as shift().
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - same as shift().
-     * Space Complexity: O(1) - same as shift().
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
      * @returns The method is returning a value of type E or undefined.
@@ -205,12 +212,12 @@ export class Queue extends IterableElementBase {
         return this.shift();
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * @param index
      */
@@ -218,12 +225,12 @@ export class Queue extends IterableElementBase {
         return this.elements[index];
     }
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
-     * Space Complexity: O(1) - no additional space is used.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function checks if a data structure is empty by comparing its size to zero.
      * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
@@ -232,12 +239,12 @@ export class Queue extends IterableElementBase {
         return this.size === 0;
     }
     /**
-     * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
-     * Space Complexity: O(n) - where n is the number of elements in the queue.
+     * Time Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
-     * Space Complexity: O(n) - where n is the number of elements in the queue.
+     * Time Complexity: O(1)
+     * Space Complexity: O(n)
      *
      * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
      * @returns An array of type E is being returned.
@@ -246,6 +253,13 @@ export class Queue extends IterableElementBase {
         return this.elements.slice(this.offset);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear function resets the elements array and offset to their initial values.
      */
     clear() {
@@ -329,6 +343,12 @@ export class Queue extends IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     */
     *_getIterator() {
         for (const item of this.elements) {
             yield item;

package/dist/mjs/data-structures/stack/stack.d.ts

@@ -29,18 +29,18 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @return An array of elements
      */
     get elements(): E[];
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
-     */
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
      */
     get size(): number;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -54,24 +54,24 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     isEmpty(): boolean;
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peek` function returns the last element of an array, or undefined if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
      */
     peek(): E | undefined;
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The push function adds an element to the stack and returns the updated stack.
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
@@ -79,12 +79,12 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     push(element: E): boolean;
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
@@ -116,16 +116,23 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     toArray(): E[];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear function clears the elements array.
      */
     clear(): void;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-     * Space Complexity: O(n), as it creates a new stack.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-     * Space Complexity: O(n), as it creates a new stack.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
@@ -171,6 +178,13 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * Custom iterator for the Stack class.
      * @returns An iterator object.
      */

package/dist/mjs/data-structures/stack/stack.js

@@ -29,10 +29,6 @@ export class Stack extends IterableElementBase {
     get elements() {
         return this._elements;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
-     */
     /**
      * The size() function returns the number of elements in an array.
      * @returns The size of the elements array.
@@ -41,8 +37,12 @@ export class Stack extends IterableElementBase {
         return this.elements.length;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
-     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -60,12 +60,12 @@ export class Stack extends IterableElementBase {
         return this.elements.length === 0;
     }
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `peek` function returns the last element of an array, or undefined if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
@@ -76,12 +76,12 @@ export class Stack extends IterableElementBase {
         return this.elements[this.elements.length - 1];
     }
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The push function adds an element to the stack and returns the updated stack.
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
@@ -92,12 +92,12 @@ export class Stack extends IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1), as it only involves accessing the last element of the array.
-     * Space Complexity: O(1), as it does not use any additional space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
@@ -141,18 +141,25 @@ export class Stack extends IterableElementBase {
         return this.elements.slice();
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear function clears the elements array.
      */
     clear() {
         this._elements = [];
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-     * Space Complexity: O(n), as it creates a new stack.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
-     * Space Complexity: O(n), as it creates a new stack.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
@@ -218,6 +225,13 @@ export class Stack extends IterableElementBase {
         return newStack;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * Custom iterator for the Stack class.
      * @returns An iterator object.
      */

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

@@ -1,8 +1,62 @@
 export declare class TreeNode<V = any> {
-    key: string;
-    value?: V | undefined;
-    children?: TreeNode<V>[] | undefined;
+    /**
+     * The constructor function initializes a TreeNode object with a key, optional value, and optional
+     * children.
+     * @param {string} key - A string representing the key of the tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the node. If no value is provided, it defaults to `undefined`.
+     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+     * objects. It represents the child nodes of the current node. If no children are provided, the
+     * default value is an empty array.
+     */
     constructor(key: string, value?: V, children?: TreeNode<V>[]);
+    protected _key: string;
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key(): string;
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value: string);
+    protected _value?: V | undefined;
+    /**
+     * The function returns the value stored in a variable, or undefined if the variable is empty.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value(): V | undefined;
+    /**
+     * The function sets the value of a variable.
+     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+     * can accept a value of type "V" or it can be undefined.
+     */
+    set value(value: V | undefined);
+    protected _children?: TreeNode<V>[] | undefined;
+    /**
+     * The function returns an array of TreeNode objects or undefined.
+     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+     */
+    get children(): TreeNode<V>[] | undefined;
+    /**
+     * The function sets the value of the children property of a TreeNode object.
+     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+     * undefined. This means that it can accept an array of TreeNode objects or undefined.
+     */
+    set children(value: TreeNode<V>[] | undefined);
+    /**
+     * The function `addChildren` adds one or more child nodes to the current node.
+     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+     */
     addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
+    /**
+     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+     * breadth-first search.
+     * @returns the maximum depth or height of the tree.
+     */
     getHeight(): number;
 }

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

@@ -1,23 +1,89 @@
 export class TreeNode {
-    key;
-    value;
-    children;
+    /**
+     * The constructor function initializes a TreeNode object with a key, optional value, and optional
+     * children.
+     * @param {string} key - A string representing the key of the tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the node. If no value is provided, it defaults to `undefined`.
+     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+     * objects. It represents the child nodes of the current node. If no children are provided, the
+     * default value is an empty array.
+     */
     constructor(key, value, children) {
-        this.key = key;
-        this.value = value || undefined;
-        this.children = children || [];
+        this._key = key;
+        this._value = value || undefined;
+        this._children = children || [];
     }
+    _key;
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+        return this._key;
+    }
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value) {
+        this._key = value;
+    }
+    _value;
+    /**
+     * The function returns the value stored in a variable, or undefined if the variable is empty.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * The function sets the value of a variable.
+     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+     * can accept a value of type "V" or it can be undefined.
+     */
+    set value(value) {
+        this._value = value;
+    }
+    _children;
+    /**
+     * The function returns an array of TreeNode objects or undefined.
+     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+     */
+    get children() {
+        return this._children;
+    }
+    /**
+     * The function sets the value of the children property of a TreeNode object.
+     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+     * undefined. This means that it can accept an array of TreeNode objects or undefined.
+     */
+    set children(value) {
+        this._children = value;
+    }
+    /**
+     * The function `addChildren` adds one or more child nodes to the current node.
+     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+     */
     addChildren(children) {
-        if (!this.children) {
-            this.children = [];
+        if (!this._children) {
+            this._children = [];
         }
         if (children instanceof TreeNode) {
-            this.children.push(children);
+            this._children.push(children);
         }
         else {
-            this.children = this.children.concat(children);
+            this._children = this._children.concat(children);
         }
     }
+    /**
+     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+     * breadth-first search.
+     * @returns the maximum depth or height of the tree.
+     */
     getHeight() {
         let maxDepth = 0;
         if (this) {
@@ -25,10 +91,10 @@ export class TreeNode {
                 if (level > maxDepth) {
                     maxDepth = level;
                 }
-                const { children } = node;
-                if (children) {
-                    for (let i = 0, len = children.length; i < len; i++) {
-                        bfs(children[i], level + 1);
+                const { _children } = node;
+                if (_children) {
+                    for (let i = 0, len = _children.length; i < len; i++) {
+                        bfs(_children[i], level + 1);
                     }
                 }
             };