data-structure-typed 1.38.7 → 1.38.9

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "data-structure-typed",
-  "version": "1.38.7",
+  "version": "1.38.9",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/mjs/index.d.ts",
-  "umd:main": "dist/umd/index.global.js",
+  "umd:main": "dist/umd/data-structure-typed.min.js",
   "exports": {
     ".": {
       "import": "./dist/mjs/index.js",
@@ -61,17 +61,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.38.6",
+    "avl-tree-typed": "^1.38.8",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.38.6",
-    "bst-typed": "^1.38.6",
+    "binary-tree-typed": "^1.38.8",
+    "bst-typed": "^1.38.8",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.38.6",
+    "heap-typed": "^1.38.8",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -19,10 +19,9 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
   }
 }
 
-export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode>
+export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -161,7 +160,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode>
       // 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-indexed-tree.ts

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
+  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};

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

@@ -115,7 +115,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode> implements IBinaryTree<V, N> {
+export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
+  implements IBinaryTree<V, N> {
   /**
    * Creates a new instance of BinaryTree.
    * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -404,7 +405,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         return -1;
       }
 
-      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
+      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -887,7 +888,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
+      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -930,10 +931,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that will be called for each node in the
    * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
    * `BFSCallbackReturn<N>`. The default value for this parameter is `this._defaultCallbackByKey
-   * @param {boolean} [withLevel=false] - The `withLevel` parameter is a boolean flag that determines
-   * whether to include the level of each node in the callback function. If `withLevel` is set
-   * to `true`, the level of each node will be passed as an argument to the callback function. If
-   * `withLevel` is
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
    * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
    * will not be performed and an empty array will be returned.
@@ -943,7 +940,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
     callback: C = this._defaultCallbackByKey as C,
-    withLevel: boolean = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -951,9 +947,66 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
     const ans: BFSCallbackReturn<N>[] = [];
 
+    if (iterationType === IterationType.RECURSIVE) {
+      const queue = new Queue<N>([beginRoot]);
+
+      function traverse(level: number) {
+        if (queue.size === 0) return;
+
+        const current = queue.shift()!;
+        ans.push(callback(current));
+
+        if (current.left) queue.push(current.left);
+        if (current.right) queue.push(current.right);
+
+        traverse(level + 1);
+      }
+
+      traverse(0);
+    } else {
+      const queue = new Queue<N>([beginRoot]);
+      while (queue.size > 0) {
+        const levelSize = queue.size;
+
+        for (let i = 0; i < levelSize; i++) {
+          const current = queue.shift()!;
+          ans.push(callback(current));
+
+          if (current.left) queue.push(current.left);
+          if (current.right) queue.push(current.right);
+        }
+      }
+    }
+    return ans;
+  }
+
+  /**
+   * The `listLevels` function takes a binary tree node and a callback function, and returns an array
+   * of arrays representing the levels of the tree.
+   * @param {C} callback - The `callback` parameter is a function that will be called on each node in
+   * the tree. It takes a node as input and returns a value. The return type of the callback function
+   * is determined by the generic type `C`.
+   * @param {N | null} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
+   * traversal. It can be any node in the binary tree. If no node is provided, the traversal will start
+   * from the root node of the binary tree.
+   * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
+   * recursively or iteratively. It can have two possible values:
+   * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
+   * level in a binary tree. Each inner array contains the return type of the provided callback
+   * function `C` applied to the nodes at that level.
+   */
+  listLevels<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
+    callback: C = this._defaultCallbackByKey as C,
+    beginRoot: N | null = this.root,
+    iterationType = this.iterationType
+  ): ReturnType<C>[][] {
+    if (!beginRoot) return [];
+    const levelsNodes: ReturnType<C>[][] = [];
+
     if (iterationType === IterationType.RECURSIVE) {
       const _recursive = (node: N, level: number) => {
-        callback && ans.push(callback(node, withLevel ? level : undefined));
+        if (!levelsNodes[level]) levelsNodes[level] = [];
+        levelsNodes[level].push(callback(node));
         if (node.left) _recursive(node.left, level + 1);
         if (node.right) _recursive(node.right, level + 1);
       };
@@ -966,12 +1019,14 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         const head = stack.pop()!;
         const [node, level] = head;
 
-        callback && ans.push(callback(node, withLevel ? level : undefined));
+        if (!levelsNodes[level]) levelsNodes[level] = [];
+        levelsNodes[level].push(callback(node));
         if (node.right) stack.push([node.right, level + 1]);
         if (node.left) stack.push([node.left, level + 1]);
       }
     }
-    return ans;
+
+    return levelsNodes;
   }
 
   /**

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

@@ -24,7 +24,9 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
-export class BST<V = any, N extends BSTNode<V, N> = BSTNode> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
+export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
+  extends BinaryTree<V, N>
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.

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

@@ -19,7 +19,9 @@ export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V
   }
 }
 
-export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode> extends BST<V, N> implements IBinaryTree<V, N> {
+export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
+  extends BST<V, N>
+  implements IBinaryTree<V, N> {
   constructor(options?: RBTreeOptions) {
     super(options);
   }

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

@@ -35,10 +35,9 @@ export class TreeMultisetNode<
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode>
+export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
   extends AVLTree<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.

package/src/data-structures/graph/abstract-graph.ts

@@ -105,8 +105,7 @@ export abstract class AbstractEdge<V = any> {
 export abstract class AbstractGraph<
   V extends AbstractVertex<any> = AbstractVertex<any>,
   E extends AbstractEdge<any> = AbstractEdge<any>
-> implements IGraph<V, E>
-{
+> implements IGraph<V, E> {
   private _vertices: Map<VertexKey, V> = new Map<VertexKey, V>();
 
   get vertices(): Map<VertexKey, V> {
@@ -554,14 +553,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-      distMap.forEach((d, v) => {
-        if (v !== srcVertex) {
-          if (d < minDist) {
-            minDist = d;
-            if (genPaths) minDest = v;
-          }
+    distMap.forEach((d, v) => {
+      if (v !== srcVertex) {
+        if (d < minDist) {
+          minDist = d;
+          if (genPaths) minDest = v;
         }
-      });
+      }
+    });
 
     genPaths && getPaths(minDest);
 
@@ -623,7 +622,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{key: number; val: V}>((a, b) => a.key - b.key);
+    const heap = new PriorityQueue<{ key: number; val: V }>((a, b) => a.key - b.key);
     heap.add({key: 0, val: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -852,7 +851,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): {costs: number[][]; predecessor: (V | null)[][]} {
+  floyd(): { costs: number[][]; predecessor: (V | null)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 

package/src/data-structures/graph/directed-graph.ts

@@ -64,8 +64,7 @@ export class DirectedEdge<V = any> extends AbstractEdge<V> {
 
 export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge>
   extends AbstractGraph<V, E>
-  implements IGraph<V, E>
-{
+  implements IGraph<V, E> {
   /**
    * The constructor function initializes an instance of a class.
    */

package/src/data-structures/graph/undirected-graph.ts

@@ -51,12 +51,11 @@ export class UndirectedEdge<V = number> extends AbstractEdge<V> {
 }
 
 export class UndirectedGraph<
-    V extends UndirectedVertex<any> = UndirectedVertex,
-    E extends UndirectedEdge<any> = UndirectedEdge
-  >
+  V extends UndirectedVertex<any> = UndirectedVertex,
+  E extends UndirectedEdge<any> = UndirectedEdge
+>
   extends AbstractGraph<V, E>
-  implements IGraph<V, E>
-{
+  implements IGraph<V, E> {
   /**
    * The constructor initializes a new Map object to store edges.
    */

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

@@ -157,7 +157,7 @@ export class HashMap<K, V> {
     }
   }
 
-  *entries(): IterableIterator<[K, V]> {
+  * entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {

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/linked-list/singly-linked-list.ts

@@ -485,7 +485,7 @@ export class SinglyLinkedList<E = any> {
     return count;
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -14,7 +14,7 @@ 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}) {
+  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/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/queue/deque.ts

@@ -9,7 +9,8 @@ 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;
   }
 
-  private _nodes: {[key: number]: E} = {};
+  private _nodes: { [key: number]: E } = {};
 
-  get nodes(): {[p: number]: E} {
+  get nodes(): { [p: number]: E } {
     return this._nodes;
   }
 
@@ -156,7 +157,7 @@ export class ObjectDeque<E = number> {
     return this._size <= 0;
   }
 
-  protected _seNodes(value: {[p: number]: E}) {
+  protected _seNodes(value: { [p: number]: E }) {
     this._nodes = value;
   }
 

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

@@ -183,7 +183,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/trie/trie.ts

@@ -241,9 +241,10 @@ export class Trie {
    * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
    * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
    * @param {number} max - The max count of words will be found
+   * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
    * @returns {string[]} an array of strings.
    */
-  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER): string[] {
+  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false): string[] {
     prefix = this._caseProcess(prefix);
     const words: string[] = [];
     let found = 0;
@@ -270,7 +271,8 @@ export class Trie {
         if (nodeC) startNode = nodeC;
       }
     }
-    if (startNode !== this.root) dfs(startNode, prefix);
+
+    if (isAllWhenEmptyPrefix || startNode !== this.root) dfs(startNode, prefix);
 
     return words;
   }

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

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 

package/test/integration/bst.test.ts

@@ -183,7 +183,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<BSTNode<{key: number; keyA: number}>>();
+    const objBST = new BST<{key: number; keyA: number}>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});

package/test/integration/index.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset='UTF-8'>
   <title>CDN Test</title>
-  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/index.global.js'></script>
+  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>
 </head>
 <body>
 <div id='app'>

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -123,7 +123,7 @@ describe('AVLTree APIs test', () => {
     avl.add(node3);
     avl.add(node3, {id: 3, text: 'text33'});
 
-    const bfsRes = avl.bfs(node => node.key, false);
+    const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
   });
 });

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -1,4 +1,8 @@
-import {AVLTree, AVLTreeNode, BinaryTree, BinaryTreeNode} from '../../../../src';
+import {AVLTree, AVLTreeNode, BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
+import {isDebugTest} from '../../../config';
+
+const isDebug = isDebugTest;
+// const isDebug = true;
 
 describe('BinaryTreeNode', () => {
   it('should create an instance of BinaryTreeNode', () => {
@@ -213,3 +217,23 @@ describe('BinaryTree APIs test', () => {
     expect(bfsRes[0]?.key).toBe(2);
   });
 });
+
+describe('BinaryTree traversals', () => {
+  const tree = new BinaryTree<number>();
+
+  const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
+  tree.refill(arr);
+  expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
+  expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
+  expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
+
+  const levels = tree.listLevels(node => node.key);
+  expect(levels).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
+  isDebug && console.log(levels);
+});

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -435,13 +435,7 @@ describe('BST Performance test', function () {
     bst.addMany(nodes);
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    const arr: number[][] = [];
-    bst.bfs((node, level) => {
-      if (level !== undefined) {
-        if (!arr[level]) arr[level] = [];
-        arr[level].push(node.key);
-      }
-    }, true);
+    const arr: number[][] = bst.listLevels(node => node.key);
     isDebug && console.log('---listLevels', arr);
     isDebug && console.log('---listLevels', performance.now() - startL);
   });

package/test/unit/data-structures/binary-tree/overall.test.ts

@@ -6,27 +6,27 @@ describe('Overall BinaryTree Test', () => {
     bst.add(11);
     bst.add(3);
     bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
-    bst.size === 16;                                // true
-    expect(bst.size).toBe(16);                      // true
-    bst.has(6);                                     // true
-    expect(bst.has(6)).toBe(true);                  // true
-    bst.getHeight(6) === 2;                         // true
-    bst.getHeight() === 5;                          // true
-    bst.getDepth(6) === 3;                          // true
-    expect(bst.getHeight(6)).toBe(2);               // true
-    expect(bst.getHeight()).toBe(5);                // true
-    expect(bst.getDepth(6)).toBe(3);                // true
+    bst.size === 16; // true
+    expect(bst.size).toBe(16); // true
+    bst.has(6); // true
+    expect(bst.has(6)).toBe(true); // true
+    bst.getHeight(6) === 2; // true
+    bst.getHeight() === 5; // true
+    bst.getDepth(6) === 3; // true
+    expect(bst.getHeight(6)).toBe(2); // true
+    expect(bst.getHeight()).toBe(5); // true
+    expect(bst.getDepth(6)).toBe(3); // true
     const leftMost = bst.getLeftMost();
-    leftMost?.key === 1;                            // true
+    leftMost?.key === 1; // true
     expect(leftMost?.key).toBe(1);
     bst.delete(6);
-    bst.get(6);                                     // null
+    bst.get(6); // null
     expect(bst.get(6)).toBeNull();
-    bst.isAVLBalanced();                            // true or false
+    bst.isAVLBalanced(); // true or false
     expect(bst.isAVLBalanced()).toBe(true);
     const bfsIDs: number[] = [];
     bst.bfs(node => bfsIDs.push(node.key));
-    bfsIDs[0] === 11;                               // true
+    bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<{key: number; keyA: number}>();
@@ -57,10 +57,10 @@ describe('Overall BinaryTree Test', () => {
 
     const avlTree = new AVLTree();
     avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
-    avlTree.isAVLBalanced();                        // true
-    expect(avlTree.isAVLBalanced()).toBe(true);     // true
+    avlTree.isAVLBalanced(); // true
+    expect(avlTree.isAVLBalanced()).toBe(true); // true
     avlTree.delete(10);
-    avlTree.isAVLBalanced();                        // true
-    expect(avlTree.isAVLBalanced()).toBe(true);     // true
+    avlTree.isAVLBalanced(); // true
+    expect(avlTree.isAVLBalanced()).toBe(true); // true
   });
 });

package/test/unit/data-structures/binary-tree/tree-multiset.test.ts

@@ -481,7 +481,7 @@ describe('TreeMultiset Performance test', function () {
     }
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse((node: TreeMultisetNode<number>) => (node.count += 1), CP.lt, inputSize / 2);
+    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), CP.lt, inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 });

package/tsup.config.js

@@ -1,11 +1,18 @@
 export default [{
-  entry: ['src/index.ts'],
+  entryPoints: {
+    "data-structure-typed": "src/index.ts"
+  },
   format: ["iife"],
   clean: true,
   sourcemap: true,
   minify: true,
-  outDir: 'dist/umd',
-  globalName: 'dataStructureTyped',
+  outDir: "dist/umd",
+  globalName: "dataStructureTyped",
   platform: "browser",
-  bundle: true
+  bundle: true,
+  outExtension() {
+    return {
+      js: `.min.js`,
+    }
+  },
 }];