linked-list-typed 1.45.0 → 1.45.2

package/src/data-structures/hash/hash-map.ts

@@ -6,8 +6,8 @@
  * @license MIT License
  */
 
-import {isObjOrFunc, rangeCheck, throwRangeError} from "../../utils";
-import {HashMapLinkedNode, HashMapOptions, IterateDirection} from "../../types";
+import { isObjOrFunc, rangeCheck, throwRangeError } from '../../utils';
+import { HashMapLinkedNode, HashMapOptions, IterateDirection } from '../../types';
 
 /**
  * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
@@ -16,9 +16,8 @@ import {HashMapLinkedNode, HashMapOptions, IterateDirection} from "../../types";
  */
 export class HashMapIterator<K, V> {
   readonly hashMap: HashMap<K, V>;
-
-  protected _node: HashMapLinkedNode<K, V>;
   readonly iterateDirection: IterateDirection;
+  protected _node: HashMapLinkedNode<K, V>;
   protected readonly _sentinel: HashMapLinkedNode<K, V>;
 
   /**
@@ -36,13 +35,16 @@ export class HashMapIterator<K, V> {
    * @returns The constructor does not return anything. It is used to initialize the properties and
    * methods of the object being created.
    */
-  constructor(node: HashMapLinkedNode<K, V>, sentinel: HashMapLinkedNode<K, V>,
-              hashMap: HashMap<K, V>, iterateDirection: IterateDirection = IterateDirection.DEFAULT) {
+  constructor(
+    node: HashMapLinkedNode<K, V>,
+    sentinel: HashMapLinkedNode<K, V>,
+    hashMap: HashMap<K, V>,
+    iterateDirection: IterateDirection = IterateDirection.DEFAULT
+  ) {
     this._node = node;
     this._sentinel = sentinel;
     this.iterateDirection = iterateDirection;
 
-
     if (this.iterateDirection === IterateDirection.DEFAULT) {
       this.prev = function () {
         if (this._node.prev === this._sentinel) {
@@ -87,7 +89,7 @@ export class HashMapIterator<K, V> {
       throwRangeError();
     }
 
-    return new Proxy(<[K, V]><unknown>[], {
+    return new Proxy(<[K, V]>(<unknown>[]), {
       get: (target, prop: '0' | '1') => {
         if (prop === '0') return this._node.key;
         else if (prop === '1') return this._node.value;
@@ -113,7 +115,6 @@ export class HashMapIterator<K, V> {
     return this._node !== this._sentinel;
   }
 
-
   prev() {
     return this;
   }
@@ -124,18 +125,12 @@ export class HashMapIterator<K, V> {
 }
 
 export class HashMap<K = any, V = any> {
+  readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
   protected _nodes: HashMapLinkedNode<K, V>[] = [];
   protected _orgMap: Record<string, HashMapLinkedNode<K, V>> = {};
   protected _head: HashMapLinkedNode<K, V>;
   protected _tail: HashMapLinkedNode<K, V>;
   protected readonly _sentinel: HashMapLinkedNode<K, V>;
-  readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
-
-  protected _size = 0;
-
-  get size() {
-    return this._size;
-  }
 
   /**
    * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
@@ -151,7 +146,85 @@ export class HashMap<K = any, V = any> {
     hashMap.forEach(el => {
       this.set(el[0], el[1]);
     });
+  }
+
+  protected _size = 0;
+
+  get size() {
+    return this._size;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns a new iterator object for a HashMap.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get begin() {
+    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
+   * end values.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get end() {
+    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
+  }
 
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
+   * a HashMap in reverse order.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get reverseBegin() {
+    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
+   * HashMap in reverse order.
+   * @returns A new instance of the HashMapIterator class is being returned.
+   */
+  get reverseEnd() {
+    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns the key-value pair at the front of a data structure.
+   * @returns The front element of the data structure, represented as a tuple with a key (K) and a
+   * value (V).
+   */
+  get front() {
+    if (this._size === 0) return;
+    return <[K, V]>[this._head.key, this._head.value];
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function returns the key-value pair at the end of a data structure.
+   * @returns The method is returning an array containing the key-value pair of the tail element in the
+   * data structure.
+   */
+  get back() {
+    if (this._size === 0) return;
+    return <[K, V]>[this._tail.key, this._tail.value];
   }
 
   /**
@@ -170,7 +243,7 @@ export class HashMap<K = any, V = any> {
   set(key: K, value?: V, isObjectKey: boolean = isObjOrFunc(key)) {
     let newTail;
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       if (index !== undefined) {
         this._nodes[<number>index].value = <V>value;
         return this._size;
@@ -187,12 +260,12 @@ export class HashMap<K = any, V = any> {
       };
       this._nodes.push(newTail);
     } else {
-      const node = this._orgMap[<string><unknown>key];
+      const node = this._orgMap[<string>(<unknown>key)];
       if (node) {
         node.value = <V>value;
         return this._size;
       }
-      this._orgMap[<string><unknown>key] = newTail = {
+      this._orgMap[<string>(<unknown>key)] = newTail = {
         key: key,
         value: <V>value,
         prev: this._tail,
@@ -228,10 +301,10 @@ export class HashMap<K = any, V = any> {
    */
   get(key: K, isObjectKey: boolean = isObjOrFunc(key)) {
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       return index !== undefined ? this._nodes[index].value : undefined;
     }
-    const node = this._orgMap[<string><unknown>key];
+    const node = this._orgMap[<string>(<unknown>key)];
     return node ? node.value : undefined;
   }
 
@@ -269,16 +342,16 @@ export class HashMap<K = any, V = any> {
    * @returns a new instance of the `HashMapIterator` class.
    */
   getIterator(key: K, isObjectKey?: boolean) {
-    let node: HashMapLinkedNode<K, V>
+    let node: HashMapLinkedNode<K, V>;
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       if (index === undefined) {
-        node = this._sentinel
+        node = this._sentinel;
       } else {
         node = this._nodes[index];
       }
     } else {
-      node = this._orgMap[<string><unknown>key] || this._sentinel;
+      node = this._orgMap[<string>(<unknown>key)] || this._sentinel;
     }
     return new HashMapIterator<K, V>(node, this._sentinel, this);
   }
@@ -299,15 +372,15 @@ export class HashMap<K = any, V = any> {
   delete(key: K, isObjectKey: boolean = isObjOrFunc(key)) {
     let node;
     if (isObjectKey) {
-      const index = (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       if (index === undefined) return false;
-      delete (<Record<symbol, number>><unknown>key)[this.OBJ_KEY_INDEX];
+      delete (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
       node = this._nodes[index];
       delete this._nodes[index];
     } else {
-      node = this._orgMap[<string><unknown>key];
+      node = this._orgMap[<string>(<unknown>key)];
       if (node === undefined) return false;
-      delete this._orgMap[<string><unknown>key];
+      delete this._orgMap[<string>(<unknown>key)];
     }
     this._deleteNode(node);
     return true;
@@ -362,79 +435,6 @@ export class HashMap<K = any, V = any> {
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new iterator object for a HashMap.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get begin() {
-    return new HashMapIterator<K, V>(this._head, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-   * end values.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get end() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-   * a HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseBegin() {
-    return new HashMapIterator<K, V>(this._tail, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-   * HashMap in reverse order.
-   * @returns A new instance of the HashMapIterator class is being returned.
-   */
-  get reverseEnd() {
-    return new HashMapIterator<K, V>(this._sentinel, this._sentinel, this, IterateDirection.REVERSE);
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns the key-value pair at the front of a data structure.
-   * @returns The front element of the data structure, represented as a tuple with a key (K) and a
-   * value (V).
-   */
-  get front() {
-    if (this._size === 0) return;
-    return <[K, V]>[this._head.key, this._head.value];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns the key-value pair at the end of a data structure.
-   * @returns The method is returning an array containing the key-value pair of the tail element in the
-   * data structure.
-   */
-  get back() {
-    if (this._size === 0) return;
-    return <[K, V]>[this._tail.key, this._tail.value];
-  }
-
   /**
    * Time Complexity: O(n), where n is the number of elements in the HashMap.
    * Space Complexity: O(1)
@@ -478,7 +478,7 @@ export class HashMap<K = any, V = any> {
    * and next nodes in the list.
    */
   protected _deleteNode(node: HashMapLinkedNode<K, V>) {
-    const {prev, next} = node;
+    const { prev, next } = node;
     prev.next = next;
     next.prev = prev;
     if (node === this._head) {

package/src/data-structures/hash/hash-table.ts

@@ -18,7 +18,7 @@ export class HashTableNode<K, V> {
   }
 }
 
-import {HashFunction} from '../../types';
+import { HashFunction } from '../../types';
 
 export class HashTable<K, V> {
   protected static readonly DEFAULT_CAPACITY = 16;

package/src/data-structures/hash/tree-map.ts

@@ -1 +1,2 @@
-export class TreeMap {}
+export class TreeMap {
+}

package/src/data-structures/hash/tree-set.ts

@@ -1 +1,2 @@
-export class TreeSet {}
+export class TreeSet {
+}

package/src/data-structures/heap/heap.ts

@@ -5,10 +5,10 @@
  * @license MIT License
  */
 
-import type {Comparator, DFSOrderPattern} from '../../types';
+import type { Comparator, DFSOrderPattern } from '../../types';
 
 export class Heap<E = any> {
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
     this._comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
       this._nodes = options.nodes;
@@ -48,7 +48,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
+  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
     return new Heap<E>(options);
   }
 
@@ -265,7 +265,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>({comparator: this.comparator});
+    const clonedHeap = new Heap<E>({ comparator: this.comparator });
     clonedHeap._nodes = [...this.nodes];
     return clonedHeap;
   }
@@ -305,18 +305,28 @@ export class Heap<E = any> {
    * @param index - The index of the newly added element.
    */
   protected bubbleUp(index: number): void {
-    const element = this.nodes[index];
+    // const element = this.nodes[index];
+    // while (index > 0) {
+    //   const parentIndex = (index - 1) >> 1;
+    //   const parent = this.nodes[parentIndex];
+    //   if (this.comparator(element, parent) < 0) {
+    //     this.nodes[index] = parent;
+    //     this.nodes[parentIndex] = element;
+    //     index = parentIndex;
+    //   } else {
+    //     break;
+    //   }
+    // }
+
+    const item = this.nodes[index];
     while (index > 0) {
-      const parentIndex = Math.floor((index - 1) / 2);
-      const parent = this.nodes[parentIndex];
-      if (this.comparator(element, parent) < 0) {
-        this.nodes[index] = parent;
-        this.nodes[parentIndex] = element;
-        index = parentIndex;
-      } else {
-        break;
-      }
+      const parent = (index - 1) >> 1;
+      const parentItem = this.nodes[parent];
+      if (this.comparator(parentItem, item) <= 0) break;
+      this.nodes[index] = parentItem;
+      index = parent;
     }
+    this.nodes[index] = item;
   }
 
   /**
@@ -332,8 +342,8 @@ export class Heap<E = any> {
    * @param index - The index from which to start sinking.
    */
   protected sinkDown(index: number): void {
-    const leftChildIndex = 2 * index + 1;
-    const rightChildIndex = 2 * index + 2;
+    const leftChildIndex = index << 1 | 1;
+    const rightChildIndex = leftChildIndex + 1;
     const length = this.nodes.length;
     let targetIndex = index;
 
@@ -741,7 +751,10 @@ export class FibonacciHeap<E> {
   protected consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
     const nodes = this.consumeLinkedList(this.root);
-    let x: FibonacciHeapNode<E> | undefined, y: FibonacciHeapNode<E> | undefined, d: number, t: FibonacciHeapNode<E> | undefined;
+    let x: FibonacciHeapNode<E> | undefined,
+      y: FibonacciHeapNode<E> | undefined,
+      d: number,
+      t: FibonacciHeapNode<E> | undefined;
 
     for (const node of nodes) {
       x = node;

package/src/data-structures/heap/max-heap.ts

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 
-import {Heap} from './heap';
-import type {Comparator} from '../../types';
+import { Heap } from './heap';
+import type { Comparator } from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/heap/min-heap.ts

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 
-import {Heap} from './heap';
-import type {Comparator} from '../../types';
+import { Heap } from './heap';
+import type { Comparator } from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -826,7 +826,7 @@ export class DoublyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -773,7 +773,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/matrix/matrix.ts

@@ -14,8 +14,8 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: {row: number; col: number; initialVal?: V}) {
-    const {row, col, initialVal} = options;
+  constructor(options: { row: number; col: number; initialVal?: V }) {
+    const { row, col, initialVal } = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }
 

package/src/data-structures/matrix/matrix2d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {Vector2D} from './vector2d';
+import { Vector2D } from './vector2d';
 
 export class Matrix2D {
   protected readonly _matrix: number[][];

package/src/data-structures/matrix/navigator.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {Direction, NavigatorParams, Turning} from '../../types';
+import type { Direction, NavigatorParams, Turning } from '../../types';
 
 export class Character {
   direction: Direction;
@@ -37,7 +37,7 @@ export class Navigator<T = number> {
    * in the matrix.
    * @param  - - `matrix`: a 2D array representing the grid or map
    */
-  constructor({matrix, turning, onMove, init: {cur, charDir, VISITED}}: NavigatorParams<T>) {
+  constructor({ matrix, turning, onMove, init: { cur, charDir, VISITED } }: NavigatorParams<T>) {
     this._matrix = matrix;
     this._cur = cur;
     this._character = new Character(charDir, turning);
@@ -53,7 +53,7 @@ export class Navigator<T = number> {
    */
   start() {
     while (this.check(this._character.direction) || this.check(this._character.turn().direction)) {
-      const {direction} = this._character;
+      const { direction } = this._character;
       if (this.check(direction)) {
         this.move(direction);
       } else if (this.check(this._character.turn().direction)) {

package/src/data-structures/matrix/vector2d.ts

@@ -10,7 +10,8 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {}
+  ) {
+  }
 
   /**
    * The function checks if the x and y values of a point are both zero.

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import {PriorityQueue} from './priority-queue';
-import type {Comparator} from '../../types';
+import { PriorityQueue } from './priority-queue';
+import type { Comparator } from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import {PriorityQueue} from './priority-queue';
-import type {Comparator} from '../../types';
+import { PriorityQueue } from './priority-queue';
+import type { Comparator } from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: {comparator: Comparator<E>; nodes?: E[]} = {
+    options: { comparator: Comparator<E>; nodes?: E[] } = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/priority-queue.ts

@@ -6,11 +6,11 @@
  * @license MIT License
  */
 
-import {Heap} from '../heap';
-import {Comparator} from '../../types';
+import { Heap } from '../heap';
+import { Comparator } from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
+  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
     super(options);
   }
 }

package/src/data-structures/queue/deque.ts

@@ -5,11 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {DoublyLinkedList} from '../linked-list';
+import { DoublyLinkedList } from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {}
+export class Deque<E = any> extends DoublyLinkedList<E> {
+}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -19,9 +20,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  protected _nodes: {[key: number]: E} = {};
+  protected _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 

package/src/data-structures/queue/queue.ts

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import {SinglyLinkedList} from '../linked-list';
+import { SinglyLinkedList } from '../linked-list';
 
 export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   /**
@@ -300,7 +300,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

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

@@ -27,7 +27,7 @@ export class TreeNode<V = any> {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const {children} = node;
+        const { children } = node;
         if (children) {
           for (let i = 0, len = children.length; i < len; i++) {
             bfs(children[i], level + 1);

package/src/data-structures/trie/trie.ts

@@ -164,7 +164,7 @@ export class Trie {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const {children} = node;
+        const { children } = node;
         if (children) {
           for (const child of children.entries()) {
             bfs(child[1], level + 1);