data-structure-typed 0.9.16 → 1.3.1

package/dist/data-structures/trie/trie.js

@@ -1,136 +1,82 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
-var TrieNode = /** @class */ (function () {
-    function TrieNode(v) {
-        this._value = v;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+class TrieNode {
+    constructor(v) {
+        this._val = v;
         this._isEnd = false;
         this._children = new Map();
     }
-    Object.defineProperty(TrieNode.prototype, "children", {
-        get: function () {
-            return this._children;
-        },
-        set: function (v) {
-            this._children = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TrieNode.prototype, "isEnd", {
-        get: function () {
-            return this._isEnd;
-        },
-        set: function (v) {
-            this._isEnd = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TrieNode.prototype, "val", {
-        get: function () {
-            return this._value;
-        },
-        set: function (v) {
-            this._value = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return TrieNode;
-}());
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        this._val = v;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(v) {
+        this._children = v;
+    }
+    get isEnd() {
+        return this._isEnd;
+    }
+    set isEnd(v) {
+        this._isEnd = v;
+    }
+}
 exports.TrieNode = TrieNode;
-var Trie = /** @class */ (function () {
-    function Trie(words) {
-        var e_1, _a;
+class Trie {
+    constructor(words) {
         this._root = new TrieNode('');
         if (words) {
-            try {
-                for (var words_1 = __values(words), words_1_1 = words_1.next(); !words_1_1.done; words_1_1 = words_1.next()) {
-                    var i = words_1_1.value;
-                    this.put(i);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (words_1_1 && !words_1_1.done && (_a = words_1.return)) _a.call(words_1);
-                }
-                finally { if (e_1) throw e_1.error; }
+            for (const i of words) {
+                this.add(i);
             }
         }
     }
-    Object.defineProperty(Trie.prototype, "root", {
-        get: function () {
-            return this._root;
-        },
-        set: function (v) {
-            this._root = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Trie.prototype.put = function (word) {
-        var e_2, _a;
-        var cur = this._root;
-        try {
-            for (var word_1 = __values(word), word_1_1 = word_1.next(); !word_1_1.done; word_1_1 = word_1.next()) {
-                var c = word_1_1.value;
-                var nodeC = cur.children.get(c);
-                if (!nodeC) {
-                    nodeC = new TrieNode(c);
-                    cur.children.set(c, nodeC);
-                }
-                cur = nodeC;
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (word_1_1 && !word_1_1.done && (_a = word_1.return)) _a.call(word_1);
-            }
-            finally { if (e_2) throw e_2.error; }
+    get root() {
+        return this._root;
+    }
+    set root(v) {
+        this._root = v;
+    }
+    add(word) {
+        let cur = this._root;
+        for (const c of word) {
+            let nodeC = cur.children.get(c);
+            if (!nodeC) {
+                nodeC = new TrieNode(c);
+                cur.children.set(c, nodeC);
+            }
+            cur = nodeC;
         }
         cur.isEnd = true;
         return true;
-    };
-    Trie.prototype.has = function (input) {
-        var e_3, _a;
-        var cur = this._root;
-        try {
-            for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
-                var c = input_1_1.value;
-                var nodeC = cur.children.get(c);
-                if (!nodeC)
-                    return false;
-                cur = nodeC;
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
-            }
-            finally { if (e_3) throw e_3.error; }
+    }
+    has(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
         }
         return cur.isEnd;
-    };
-    Trie.prototype.remove = function (word) {
-        var isDeleted = false;
-        var dfs = function (cur, i) {
-            var char = word[i];
-            var child = cur.children.get(char);
+    }
+    remove(word) {
+        let isDeleted = false;
+        const dfs = (cur, i) => {
+            const char = word[i];
+            const child = cur.children.get(char);
             if (child) {
                 if (i === word.length - 1) {
                     if (child.isEnd) {
@@ -145,7 +91,7 @@ var Trie = /** @class */ (function () {
                     }
                     return false;
                 }
-                var res = dfs(child, i + 1);
+                const res = dfs(child, i + 1);
                 if (res && !cur.isEnd && child.children.size === 0) {
                     cur.children.delete(char);
                     return true;
@@ -156,65 +102,47 @@ var Trie = /** @class */ (function () {
         };
         dfs(this.root, 0);
         return isDeleted;
-    };
+    }
     // --- start additional methods ---
     /**
-     * Only can present as a prefix, not a word
-     * @param input
+     * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
+     * @param {string} input - The input parameter is a string that represents the input value for the function.
+     * @returns a boolean value.
      */
-    Trie.prototype.isAbsPrefix = function (input) {
-        var e_4, _a;
-        var cur = this._root;
-        try {
-            for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) {
-                var c = input_2_1.value;
-                var nodeC = cur.children.get(c);
-                if (!nodeC)
-                    return false;
-                cur = nodeC;
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2);
-            }
-            finally { if (e_4) throw e_4.error; }
+    isAbsPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
         }
         return !cur.isEnd;
-    };
+    }
     /**
-     * Can present as a abs prefix or word
-     * @param input
+     * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
+     * @param {string} input - The input parameter is a string that represents the prefix we want to check.
+     * @returns a boolean value.
      */
-    Trie.prototype.isPrefix = function (input) {
-        var e_5, _a;
-        var cur = this._root;
-        try {
-            for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) {
-                var c = input_3_1.value;
-                var nodeC = cur.children.get(c);
-                if (!nodeC)
-                    return false;
-                cur = nodeC;
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3);
-            }
-            finally { if (e_5) throw e_5.error; }
+    isPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
         }
         return true;
-    };
+    }
     /**
-     * Check if the input string is the common prefix of all the words
-     * @param input
+     * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
+     * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
+     * in the Trie data structure.
+     * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
      */
-    Trie.prototype.isCommonPrefix = function (input) {
-        var commonPre = '';
-        var dfs = function (cur) {
+    isCommonPrefix(input) {
+        let commonPre = '';
+        const dfs = (cur) => {
             commonPre += cur.val;
             if (commonPre === input)
                 return;
@@ -227,11 +155,16 @@ var Trie = /** @class */ (function () {
         };
         dfs(this._root);
         return commonPre === input;
-    };
-    // Retrieve the longest common prefix of all the words
-    Trie.prototype.getLongestCommonPrefix = function () {
-        var commonPre = '';
-        var dfs = function (cur) {
+    }
+    /**
+     * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
+     * structure.
+     * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
+     * Trie.
+     */
+    getLongestCommonPrefix() {
+        let commonPre = '';
+        const dfs = (cur) => {
             commonPre += cur.val;
             if (cur.isEnd)
                 return;
@@ -242,54 +175,36 @@ var Trie = /** @class */ (function () {
         };
         dfs(this._root);
         return commonPre;
-    };
-    Trie.prototype.getAll = function (prefix) {
-        var e_6, _a;
-        if (prefix === void 0) { prefix = ''; }
-        var words = [];
+    }
+    /**
+     * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
+     * @param [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.
+     * @returns an array of strings.
+     */
+    getAll(prefix = '') {
+        const words = [];
         function dfs(node, word) {
-            var e_7, _a;
-            try {
-                for (var _b = __values(node.children.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var char = _c.value;
-                    var charNode = node.children.get(char);
-                    if (charNode !== undefined) {
-                        dfs(charNode, word.concat(char));
-                    }
+            for (const char of node.children.keys()) {
+                const charNode = node.children.get(char);
+                if (charNode !== undefined) {
+                    dfs(charNode, word.concat(char));
                 }
             }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_7) throw e_7.error; }
-            }
             if (node.isEnd) {
                 words.push(word);
             }
         }
-        var startNode = this._root;
+        let startNode = this._root;
         if (prefix) {
-            try {
-                for (var prefix_1 = __values(prefix), prefix_1_1 = prefix_1.next(); !prefix_1_1.done; prefix_1_1 = prefix_1.next()) {
-                    var c = prefix_1_1.value;
-                    var nodeC = startNode.children.get(c);
-                    if (nodeC)
-                        startNode = nodeC;
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (prefix_1_1 && !prefix_1_1.done && (_a = prefix_1.return)) _a.call(prefix_1);
-                }
-                finally { if (e_6) throw e_6.error; }
+            for (const c of prefix) {
+                const nodeC = startNode.children.get(c);
+                if (nodeC)
+                    startNode = nodeC;
             }
         }
         dfs(startNode, prefix);
         return words;
-    };
-    return Trie;
-}());
+    }
+}
 exports.Trie = Trie;

package/dist/index.d.ts

@@ -1 +1,4 @@
 export * from './data-structures';
+export * from './utils';
+export * from './interfaces';
+export * from './types';

package/dist/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./types"), exports);

package/dist/interfaces/abstract-binary-tree.d.ts

@@ -0,0 +1,90 @@
+import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
+import { AbstractBinaryTreeNode } from '../data-structures';
+export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
+    get id(): BinaryTreeNodeId;
+    set id(v: BinaryTreeNodeId);
+    get val(): T | undefined;
+    set val(v: T | undefined);
+    get left(): NEIGHBOR | null | undefined;
+    set left(v: NEIGHBOR | null | undefined);
+    get right(): NEIGHBOR | null | undefined;
+    set right(v: NEIGHBOR | null | undefined);
+    get parent(): NEIGHBOR | null | undefined;
+    set parent(v: NEIGHBOR | null | undefined);
+    get familyPosition(): FamilyPosition;
+    get height(): number;
+    set height(v: number);
+}
+export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
+    get loopType(): LoopType;
+    get visitedId(): BinaryTreeNodeId[];
+    get visitedVal(): Array<N['val']>;
+    get visitedNode(): N[];
+    get visitedLeftSum(): number[];
+    get root(): N | null;
+    get size(): number;
+    swapLocation(srcNode: N, destNode: N): N;
+    clear(): void;
+    isEmpty(): boolean;
+    add(id: BinaryTreeNodeId | N, val?: N['val']): N | null | undefined;
+    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getDepth(node: N): number;
+    getHeight(beginRoot?: N | null): number;
+    getMinHeight(beginRoot?: N | null): number;
+    isPerfectlyBalanced(beginRoot?: N | null): boolean;
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    getPathToRoot(node: N): N[];
+    getLeftMost(): N | null;
+    getLeftMost(node: N): N;
+    getLeftMost(node?: N | null): N | null;
+    getRightMost(): N | null;
+    getRightMost(node: N): N;
+    getRightMost(node?: N | null): N | null;
+    isSubtreeBST(node: N | null): boolean;
+    isBST(): boolean;
+    getSubTreeSize(subTreeRoot: N | null | undefined): number;
+    subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
+    subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    BFS(): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'val'): N['val'][];
+    BFS(nodeOrPropertyName: 'node'): N[];
+    BFS(nodeOrPropertyName: 'count'): number[];
+    BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    DFS(): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    DFSIterative(): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFSIterative(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    levelIterative(node: N | null): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
+    levelIterative(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    listLevels(node: N | null): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
+    listLevels(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperty<N>[][];
+    getPredecessor(node: N): N;
+    morris(): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    morris(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+}

package/dist/interfaces/abstract-graph.d.ts

@@ -0,0 +1,17 @@
+import { VertexId } from '../types';
+export interface IAbstractGraph<V, E> {
+    hasVertex(vertexOrId: V | VertexId): boolean;
+    addVertex(id: VertexId, val?: V): boolean;
+    removeVertex(vertexOrId: V | VertexId): boolean;
+    removeAllVertices(vertices: V[] | VertexId[]): boolean;
+    degreeOf(vertexOrId: V | VertexId): number;
+    edgesOf(vertexOrId: V | VertexId): E[];
+    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
+    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    edgeSet(): E[];
+    addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
+    removeEdge(edge: E): E | null;
+    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
+    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
+    getNeighbors(vertexOrId: V | VertexId): V[];
+}

package/dist/interfaces/avl-tree.d.ts

@@ -0,0 +1,9 @@
+import { AVLTreeNode } from '../data-structures';
+import { IBST, IBSTNode } from './bst';
+import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
+export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
+    add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+}

package/dist/interfaces/binary-tree.d.ts

@@ -0,0 +1,6 @@
+import { BinaryTreeNode } from '../data-structures';
+import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
+export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> extends IAbstractBinaryTreeNode<T, NEIGHBOR> {
+}
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
+}

package/dist/interfaces/bst.d.ts

@@ -0,0 +1,17 @@
+import { BSTNode } from '../data-structures';
+import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
+import { BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName } from '../types';
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
+}
+export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    lastKey(): BinaryTreeNodeId;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    perfectlyBalance(): boolean;
+    isAVLBalanced(): boolean;
+}

package/dist/interfaces/directed-graph.d.ts

@@ -0,0 +1,12 @@
+import { VertexId } from '../types';
+import { IAbstractGraph } from './abstract-graph';
+export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    incomingEdgesOf(vertex: V): E[];
+    outgoingEdgesOf(vertex: V): E[];
+    inDegreeOf(vertexOrId: V | VertexId): number;
+    outDegreeOf(vertexOrId: V | VertexId): number;
+    getEdgeSrc(e: E): V | null;
+    getEdgeDest(e: E): V | null;
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
+}

package/{src/data-structures/types/index.ts → dist/interfaces/index.d.ts}

@@ -1,13 +1,15 @@
+export * from './abstract-binary-tree';
+export * from './abstract-graph';
+export * from './avl-tree';
 export * from './binary-tree';
 export * from './bst';
-export * from './avl-tree';
-export * from './segment-tree';
-export * from './tree-multiset';
-export * from './abstract-graph';
 export * from './directed-graph';
-export * from './priority-queue';
-export * from './heap';
-export * from './singly-linked-list';
 export * from './doubly-linked-list';
+export * from './heap';
 export * from './navigator';
-export * from './utils';
+export * from './priority-queue';
+export * from './rb-tree';
+export * from './segment-tree';
+export * from './singly-linked-list';
+export * from './tree-multiset';
+export * from './undirected-graph';

package/dist/interfaces/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-binary-tree"), exports);
+__exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./avl-tree"), exports);
+__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./bst"), exports);
+__exportStar(require("./directed-graph"), exports);
+__exportStar(require("./doubly-linked-list"), exports);
+__exportStar(require("./heap"), exports);
+__exportStar(require("./navigator"), exports);
+__exportStar(require("./priority-queue"), exports);
+__exportStar(require("./rb-tree"), exports);
+__exportStar(require("./segment-tree"), exports);
+__exportStar(require("./singly-linked-list"), exports);
+__exportStar(require("./tree-multiset"), exports);
+__exportStar(require("./undirected-graph"), exports);

package/{src/data-structures/hash/hash-table.ts → dist/interfaces/priority-queue.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/interfaces/rb-tree.d.ts

@@ -0,0 +1,8 @@
+import { RBTreeNode } from '../data-structures';
+import { IBST, IBSTNode } from './bst';
+import { BinaryTreeNodeId } from '../types';
+export interface IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+}

package/dist/interfaces/segment-tree.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/singly-linked-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/singly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });