data-structure-typed 1.43.3 → 1.44.1

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/bst.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BST = exports.BSTNode = void 0;
-const types_1 = require("../../types");
-const binary_tree_1 = require("./binary-tree");
-const queue_1 = require("../queue");
-class BSTNode extends binary_tree_1.BinaryTreeNode {
+import { CP, IterationType } from '../../types';
+import { BinaryTree, BinaryTreeNode } from './binary-tree';
+import { Queue } from '../queue';
+export class BSTNode extends BinaryTreeNode {
     parent;
     constructor(key, value) {
         super(key, value);
@@ -47,8 +44,7 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
         this._right = v;
     }
 }
-exports.BSTNode = BSTNode;
-class BST extends binary_tree_1.BinaryTree {
+export class BST extends BinaryTree {
     /**
      * The constructor function initializes a binary search tree with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -123,7 +119,7 @@ class BST extends binary_tree_1.BinaryTree {
             let traversing = true;
             while (traversing) {
                 if (cur !== undefined && newNode !== undefined) {
-                    if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
+                    if (this._compare(cur.key, newNode.key) === CP.eq) {
                         if (newNode) {
                             cur.value = newNode.value;
                         }
@@ -131,7 +127,7 @@ class BST extends binary_tree_1.BinaryTree {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
@@ -149,7 +145,7 @@ class BST extends binary_tree_1.BinaryTree {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
@@ -260,7 +256,7 @@ class BST extends binary_tree_1.BinaryTree {
                 }
             }
         };
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             _dfs(sortedKeysOrNodes, sortedData);
         }
         else {
@@ -288,9 +284,9 @@ class BST extends binary_tree_1.BinaryTree {
      * rightmost node otherwise. If no node is found, it returns 0.
      */
     lastKey(beginRoot = this.root, iterationType = this.iterationType) {
-        if (this._compare(0, 1) === types_1.CP.lt)
+        if (this._compare(0, 1) === CP.lt)
             return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-        else if (this._compare(0, 1) === types_1.CP.gt)
+        else if (this._compare(0, 1) === CP.gt)
             return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
         else
             return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
@@ -313,32 +309,32 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+    getNodeByKey(key, iterationType = IterationType.ITERATIVE) {
         if (!this.root)
             return undefined;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!cur.left && !cur.right)
                     return;
-                if (this._compare(cur.key, key) === types_1.CP.gt && cur.left)
+                if (this._compare(cur.key, key) === CP.gt && cur.left)
                     return _dfs(cur.left);
-                if (this._compare(cur.key, key) === types_1.CP.lt && cur.right)
+                if (this._compare(cur.key, key) === CP.lt && cur.right)
                     return _dfs(cur.right);
             };
             return _dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
+            const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    if (this._compare(cur.key, key) === types_1.CP.eq)
+                    if (this._compare(cur.key, key) === CP.eq)
                         return cur;
-                    if (this._compare(cur.key, key) === types_1.CP.gt)
+                    if (this._compare(cur.key, key) === CP.gt)
                         cur.left && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === types_1.CP.lt)
+                    if (this._compare(cur.key, key) === CP.lt)
                         cur.right && queue.push(cur.right);
                 }
             }
@@ -353,7 +349,7 @@ class BST extends binary_tree_1.BinaryTree {
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+    ensureNotKey(key, iterationType = IterationType.ITERATIVE) {
         return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -388,7 +384,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
@@ -400,9 +396,9 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._defaultOneParamCallback) {
-                    if (this._compare(cur.key, identifier) === types_1.CP.gt)
+                    if (this._compare(cur.key, identifier) === CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, identifier) === types_1.CP.lt)
+                    if (this._compare(cur.key, identifier) === CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -413,7 +409,7 @@ class BST extends binary_tree_1.BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -425,9 +421,9 @@ class BST extends binary_tree_1.BinaryTree {
                     }
                     // TODO potential bug
                     if (callback === this._defaultOneParamCallback) {
-                        if (this._compare(cur.key, identifier) === types_1.CP.gt)
+                        if (this._compare(cur.key, identifier) === CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, identifier) === types_1.CP.lt)
+                        if (this._compare(cur.key, identifier) === CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -464,7 +460,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         targetNode = this.ensureNotKey(targetNode);
         const ans = [];
         if (!targetNode)
@@ -472,7 +468,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!this.root)
             return ans;
         const targetKey = targetNode.key;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
@@ -488,7 +484,7 @@ class BST extends binary_tree_1.BinaryTree {
             return ans;
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
+            const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -533,7 +529,7 @@ class BST extends binary_tree_1.BinaryTree {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -582,7 +578,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!this.root)
             return true;
         let balanced = true;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -641,11 +637,10 @@ class BST extends binary_tree_1.BinaryTree {
     _compare(a, b) {
         const compared = this._comparator(a, b);
         if (compared > 0)
-            return types_1.CP.gt;
+            return CP.gt;
         else if (compared < 0)
-            return types_1.CP.lt;
+            return CP.lt;
         else
-            return types_1.CP.eq;
+            return CP.eq;
     }
 }
-exports.BST = BST;

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

@@ -0,0 +1,7 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './binary-indexed-tree';
+export * from './segment-tree';
+export * from './avl-tree';
+export * from './rb-tree';
+export * from './tree-multimap';

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/rb-tree.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * data-structure-typed
  *
@@ -6,19 +5,16 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
-const types_1 = require("../../types");
-const bst_1 = require("./bst");
-const binary_tree_1 = require("./binary-tree");
-class RedBlackTreeNode extends bst_1.BSTNode {
+import { RBTNColor } from '../../types';
+import { BST, BSTNode } from './bst';
+import { BinaryTreeNode } from './binary-tree';
+export class RedBlackTreeNode extends BSTNode {
     color;
-    constructor(key, value, color = types_1.RBTNColor.BLACK) {
+    constructor(key, value, color = RBTNColor.BLACK) {
         super(key, value);
         this.color = color;
     }
 }
-exports.RedBlackTreeNode = RedBlackTreeNode;
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
@@ -26,7 +22,7 @@ exports.RedBlackTreeNode = RedBlackTreeNode;
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-class RedBlackTree extends bst_1.BST {
+export class RedBlackTree extends BST {
     NIL = new RedBlackTreeNode(NaN);
     /**
      * The constructor function initializes a Red-Black Tree with an optional set of options.
@@ -63,7 +59,7 @@ class RedBlackTree extends bst_1.BST {
     add(keyOrNode, value) {
         let node;
         if (this.isNodeKey(keyOrNode)) {
-            node = this.createNode(keyOrNode, value, types_1.RBTNColor.RED);
+            node = this.createNode(keyOrNode, value, RBTNColor.RED);
         }
         else if (keyOrNode instanceof RedBlackTreeNode) {
             node = keyOrNode;
@@ -101,7 +97,7 @@ class RedBlackTree extends bst_1.BST {
             y.right = node;
         }
         if (node.parent === undefined) {
-            node.color = types_1.RBTNColor.BLACK;
+            node.color = RBTNColor.BLACK;
             this._size++;
             return;
         }
@@ -112,7 +108,7 @@ class RedBlackTree extends bst_1.BST {
         this._fixInsert(node);
         this._size++;
     }
-    createNode(key, value, color = types_1.RBTNColor.BLACK) {
+    createNode(key, value, color = RBTNColor.BLACK) {
         return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -183,7 +179,7 @@ class RedBlackTree extends bst_1.BST {
                 y.left.parent = y;
                 y.color = z.color;
             }
-            if (yOriginalColor === types_1.RBTNColor.BLACK) {
+            if (yOriginalColor === RBTNColor.BLACK) {
                 this._fixDelete(x);
             }
             this._size--;
@@ -221,7 +217,7 @@ class RedBlackTree extends bst_1.BST {
      * @returns a value of type `N`, `null`, or `undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if (identifier instanceof binary_tree_1.BinaryTreeNode)
+        if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNotKey(beginRoot);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
@@ -363,32 +359,32 @@ class RedBlackTree extends bst_1.BST {
      */
     _fixDelete(x) {
         let s;
-        while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
+        while (x !== this.root && x.color === RBTNColor.BLACK) {
             if (x.parent && x === x.parent.left) {
                 s = x.parent.right;
                 if (s.color === 1) {
-                    s.color = types_1.RBTNColor.BLACK;
-                    x.parent.color = types_1.RBTNColor.RED;
+                    s.color = RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.RED;
                     this._leftRotate(x.parent);
                     s = x.parent.right;
                 }
-                if (s.left !== undefined && s.left.color === types_1.RBTNColor.BLACK && s.right && s.right.color === types_1.RBTNColor.BLACK) {
-                    s.color = types_1.RBTNColor.RED;
+                if (s.left !== undefined && s.left.color === RBTNColor.BLACK && s.right && s.right.color === RBTNColor.BLACK) {
+                    s.color = RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.right && s.right.color === types_1.RBTNColor.BLACK) {
+                    if (s.right && s.right.color === RBTNColor.BLACK) {
                         if (s.left)
-                            s.left.color = types_1.RBTNColor.BLACK;
-                        s.color = types_1.RBTNColor.RED;
+                            s.left.color = RBTNColor.BLACK;
+                        s.color = RBTNColor.RED;
                         this._rightRotate(s);
                         s = x.parent.right;
                     }
                     if (s)
                         s.color = x.parent.color;
-                    x.parent.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.BLACK;
                     if (s && s.right)
-                        s.right.color = types_1.RBTNColor.BLACK;
+                        s.right.color = RBTNColor.BLACK;
                     this._leftRotate(x.parent);
                     x = this.root;
                 }
@@ -396,34 +392,34 @@ class RedBlackTree extends bst_1.BST {
             else {
                 s = x.parent.left;
                 if (s.color === 1) {
-                    s.color = types_1.RBTNColor.BLACK;
-                    x.parent.color = types_1.RBTNColor.RED;
+                    s.color = RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.RED;
                     this._rightRotate(x.parent);
                     s = x.parent.left;
                 }
-                if (s && s.right && s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
-                    s.color = types_1.RBTNColor.RED;
+                if (s && s.right && s.right.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
+                    s.color = RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s && s.left && s.left.color === types_1.RBTNColor.BLACK) {
+                    if (s && s.left && s.left.color === RBTNColor.BLACK) {
                         if (s.right)
-                            s.right.color = types_1.RBTNColor.BLACK;
-                        s.color = types_1.RBTNColor.RED;
+                            s.right.color = RBTNColor.BLACK;
+                        s.color = RBTNColor.RED;
                         this._leftRotate(s);
                         s = x.parent.left;
                     }
                     if (s)
                         s.color = x.parent.color;
-                    x.parent.color = types_1.RBTNColor.BLACK;
+                    x.parent.color = RBTNColor.BLACK;
                     if (s && s.left)
-                        s.left.color = types_1.RBTNColor.BLACK;
+                        s.left.color = RBTNColor.BLACK;
                     this._rightRotate(x.parent);
                     x = this.root;
                 }
             }
         }
-        x.color = types_1.RBTNColor.BLACK;
+        x.color = RBTNColor.BLACK;
     }
     /**
      * Time Complexity: O(1)
@@ -467,9 +463,9 @@ class RedBlackTree extends bst_1.BST {
             if (k.parent.parent && k.parent === k.parent.parent.right) {
                 u = k.parent.parent.left;
                 if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    u.color = RBTNColor.BLACK;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     k = k.parent.parent;
                 }
                 else {
@@ -477,17 +473,17 @@ class RedBlackTree extends bst_1.BST {
                         k = k.parent;
                         this._rightRotate(k);
                     }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     this._leftRotate(k.parent.parent);
                 }
             }
             else {
                 u = k.parent.parent.right;
                 if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    u.color = RBTNColor.BLACK;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     k = k.parent.parent;
                 }
                 else {
@@ -495,8 +491,8 @@ class RedBlackTree extends bst_1.BST {
                         k = k.parent;
                         this._leftRotate(k);
                     }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k.parent.color = RBTNColor.BLACK;
+                    k.parent.parent.color = RBTNColor.RED;
                     this._rightRotate(k.parent.parent);
                 }
             }
@@ -504,7 +500,6 @@ class RedBlackTree extends bst_1.BST {
                 break;
             }
         }
-        this.root.color = types_1.RBTNColor.BLACK;
+        this.root.color = RBTNColor.BLACK;
     }
 }
-exports.RedBlackTree = RedBlackTree;

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/segment-tree.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * data-structure-typed
  *
@@ -6,9 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SegmentTree = exports.SegmentTreeNode = void 0;
-class SegmentTreeNode {
+export class SegmentTreeNode {
     start = 0;
     end = 0;
     value = null;
@@ -22,8 +19,7 @@ class SegmentTreeNode {
         this.value = value || null;
     }
 }
-exports.SegmentTreeNode = SegmentTreeNode;
-class SegmentTree {
+export class SegmentTree {
     /**
      * The constructor initializes the values, start, end, and root properties of an object.
      * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
@@ -179,4 +175,3 @@ class SegmentTree {
         return dfs(root, indexA, indexB);
     }
 }
-exports.SegmentTree = SegmentTree;

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/tree-multimap.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultimap = exports.TreeMultimapNode = void 0;
-const types_1 = require("../../types");
-const avl_tree_1 = require("./avl-tree");
-class TreeMultimapNode extends avl_tree_1.AVLTreeNode {
+import { CP, FamilyPosition, IterationType } from '../../types';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+export class TreeMultimapNode extends AVLTreeNode {
     count;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
@@ -20,11 +17,10 @@ class TreeMultimapNode extends avl_tree_1.AVLTreeNode {
         this.count = count;
     }
 }
-exports.TreeMultimapNode = TreeMultimapNode;
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-class TreeMultimap extends avl_tree_1.AVLTree {
+export class TreeMultimap extends AVLTree {
     /**
      * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.
@@ -94,14 +90,14 @@ class TreeMultimap extends avl_tree_1.AVLTree {
             while (traversing) {
                 if (cur) {
                     if (newNode) {
-                        if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
+                        if (this._compare(cur.key, newNode.key) === CP.eq) {
                             cur.value = newNode.value;
                             cur.count += newNode.count;
                             this._count += newNode.count;
                             traversing = false;
                             inserted = cur;
                         }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
+                        else if (this._compare(cur.key, newNode.key) === CP.gt) {
                             // Traverse left of the node
                             if (cur.left === undefined) {
                                 //Add to the left of the current node
@@ -117,7 +113,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                                     cur = cur.left;
                             }
                         }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
+                        else if (this._compare(cur.key, newNode.key) === CP.lt) {
                             // Traverse right of the node
                             if (cur.right === undefined) {
                                 //Add to the right of the current node
@@ -200,7 +196,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -275,10 +271,10 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 }
                 else {
                     const { familyPosition: fp } = curr;
-                    if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                    if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
                         parent.left = curr.right;
                     }
-                    else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                    else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
                         parent.right = curr.right;
                     }
                     needBalanced = parent;
@@ -395,4 +391,3 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return undefined;
     }
 }
-exports.TreeMultimap = TreeMultimap;

package/dist/mjs/{src/data-structures → data-structures}/graph/abstract-graph.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 /**
  * data-structure-typed
  *
@@ -8,10 +5,10 @@ exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-const utils_1 = require("../../utils");
-const priority_queue_1 = require("../priority-queue");
-const queue_1 = require("../queue");
-class AbstractVertex {
+import { uuidV4 } from '../../utils';
+import { PriorityQueue } from '../priority-queue';
+import { Queue } from '../queue';
+export class AbstractVertex {
     key;
     value;
     /**
@@ -26,8 +23,7 @@ class AbstractVertex {
         this.value = value;
     }
 }
-exports.AbstractVertex = AbstractVertex;
-class AbstractEdge {
+export class AbstractEdge {
     value;
     weight;
     /**
@@ -42,15 +38,14 @@ class AbstractEdge {
     constructor(weight, value) {
         this.weight = weight !== undefined ? weight : 1;
         this.value = value;
-        this._hashCode = (0, utils_1.uuidV4)();
+        this._hashCode = uuidV4();
     }
     _hashCode;
     get hashCode() {
         return this._hashCode;
     }
 }
-exports.AbstractEdge = AbstractEdge;
-class AbstractGraph {
+export class AbstractGraph {
     _vertices = new Map();
     get vertices() {
         return this._vertices;
@@ -310,7 +305,7 @@ class AbstractGraph {
                 return null;
             }
             const visited = new Map();
-            const queue = new queue_1.Queue([vertex1]);
+            const queue = new Queue([vertex1]);
             visited.set(vertex1, true);
             let cost = 0;
             while (queue.size > 0) {
@@ -594,7 +589,7 @@ class AbstractGraph {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new priority_queue_1.PriorityQueue({ comparator: (a, b) => a.key - b.key });
+        const heap = new PriorityQueue({ comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
@@ -1042,4 +1037,3 @@ class AbstractGraph {
         return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
     }
 }
-exports.AbstractGraph = AbstractGraph;