data-structure-typed 1.40.0-rc → 1.40.0

package/lib/data-structures/tree/tree.d.ts

@@ -1,14 +0,0 @@
-export declare class TreeNode<V = any> {
-    constructor(key: string, value?: V, children?: TreeNode<V>[]);
-    private _key;
-    get key(): string;
-    set key(value: string);
-    private _value?;
-    get value(): V | undefined;
-    set value(value: V | undefined);
-    private _children?;
-    get children(): TreeNode<V>[] | undefined;
-    set children(value: TreeNode<V>[] | undefined);
-    addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
-    getHeight(): number;
-}

package/lib/data-structures/tree/tree.js

@@ -1,56 +0,0 @@
-export class TreeNode {
-    constructor(key, value, children) {
-        this._key = key;
-        this._value = value || undefined;
-        this._children = children || [];
-    }
-    get key() {
-        return this._key;
-    }
-    set key(value) {
-        this._key = value;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get children() {
-        return this._children;
-    }
-    set children(value) {
-        this._children = value;
-    }
-    addChildren(children) {
-        if (!this.children) {
-            this.children = [];
-        }
-        if (children instanceof TreeNode) {
-            this.children.push(children);
-        }
-        else {
-            this.children = this.children.concat(children);
-        }
-    }
-    getHeight() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const beginRoot = this;
-        let maxDepth = 1;
-        if (beginRoot) {
-            const bfs = (node, level) => {
-                if (level > maxDepth) {
-                    maxDepth = level;
-                }
-                const { children } = node;
-                if (children) {
-                    for (let i = 0, len = children.length; i < len; i++) {
-                        bfs(children[i], level + 1);
-                    }
-                }
-            };
-            bfs(beginRoot, 1);
-        }
-        return maxDepth;
-    }
-}

package/lib/data-structures/trie/trie.d.ts

@@ -1,61 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class TrieNode {
-    constructor(v: string);
-    private _val;
-    get val(): string;
-    set val(v: string);
-    protected _children: Map<string, TrieNode>;
-    get children(): Map<string, TrieNode>;
-    set children(v: Map<string, TrieNode>);
-    protected _isEnd: boolean;
-    get isEnd(): boolean;
-    set isEnd(v: boolean);
-}
-export declare class Trie {
-    constructor(words?: string[]);
-    protected _root: TrieNode;
-    get root(): TrieNode;
-    set root(v: TrieNode);
-    add(word: string): boolean;
-    has(input: string): boolean;
-    remove(word: string): boolean;
-    /**
-     * 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.
-     */
-    isAbsPrefix(input: string): boolean;
-    /**
-     * 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.
-     */
-    isPrefix(input: string): boolean;
-    /**
-     * 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.
-     */
-    isCommonPrefix(input: string): boolean;
-    /**
-     * 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(): string;
-    /**
-     * 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?: string): string[];
-}

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

@@ -1,205 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class TrieNode {
-    constructor(v) {
-        this._val = v;
-        this._isEnd = false;
-        this._children = new Map();
-    }
-    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;
-    }
-}
-export class Trie {
-    constructor(words) {
-        this._root = new TrieNode('');
-        if (words) {
-            for (const i of words) {
-                this.add(i);
-            }
-        }
-    }
-    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;
-    }
-    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;
-    }
-    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) {
-                        if (child.children.size > 0) {
-                            child.isEnd = false;
-                        }
-                        else {
-                            cur.children.delete(char);
-                        }
-                        isDeleted = true;
-                        return true;
-                    }
-                    return false;
-                }
-                const res = dfs(child, i + 1);
-                if (res && !cur.isEnd && child.children.size === 0) {
-                    cur.children.delete(char);
-                    return true;
-                }
-                return false;
-            }
-            return false;
-        };
-        dfs(this.root, 0);
-        return isDeleted;
-    }
-    // --- start additional methods ---
-    /**
-     * 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.
-     */
-    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;
-    }
-    /**
-     * 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.
-     */
-    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;
-    }
-    /**
-     * 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.
-     */
-    isCommonPrefix(input) {
-        let commonPre = '';
-        const dfs = (cur) => {
-            commonPre += cur.val;
-            if (commonPre === input)
-                return;
-            if (cur.isEnd)
-                return;
-            if (cur && cur.children && cur.children.size === 1)
-                dfs(Array.from(cur.children.values())[0]);
-            else
-                return;
-        };
-        dfs(this._root);
-        return commonPre === input;
-    }
-    /**
-     * 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;
-            if (cur && cur.children && cur.children.size === 1)
-                dfs(Array.from(cur.children.values())[0]);
-            else
-                return;
-        };
-        dfs(this._root);
-        return commonPre;
-    }
-    /**
-     * 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) {
-            for (const char of node.children.keys()) {
-                const charNode = node.children.get(char);
-                if (charNode !== undefined) {
-                    dfs(charNode, word.concat(char));
-                }
-            }
-            if (node.isEnd) {
-                words.push(word);
-            }
-        }
-        let startNode = this._root;
-        if (prefix) {
-            for (const c of prefix) {
-                const nodeC = startNode.children.get(c);
-                if (nodeC)
-                    startNode = nodeC;
-            }
-        }
-        dfs(startNode, prefix);
-        return words;
-    }
-}

package/lib/index.js

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

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

@@ -1,7 +0,0 @@
-import { BinaryTreeNodeKey } from '../types';
-import { AbstractBinaryTreeNode } from '../data-structures';
-export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
-}
-export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
-    createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N | null;
-}

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

@@ -1,5 +0,0 @@
-import { VertexKey } from '../types';
-export interface IAbstractGraph<V, E> {
-    createVertex(key: VertexKey, val?: V): V;
-    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
-}

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

@@ -1,7 +0,0 @@
-import { AVLTreeNode } from '../data-structures';
-import { IBST, IBSTNode } from './bst';
-export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
-    height: number;
-}
-export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
-}

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

@@ -1,6 +0,0 @@
-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/lib/interfaces/bst.d.ts

@@ -1,6 +0,0 @@
-import { BSTNode } from '../data-structures';
-import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
-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> {
-}

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

@@ -1,3 +0,0 @@
-import { IAbstractGraph } from './abstract-graph';
-export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
-}

package/lib/interfaces/index.d.ts

@@ -1,15 +0,0 @@
-export * from './abstract-binary-tree';
-export * from './abstract-graph';
-export * from './avl-tree';
-export * from './binary-tree';
-export * from './bst';
-export * from './directed-graph';
-export * from './doubly-linked-list';
-export * from './heap';
-export * from './navigator';
-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/lib/interfaces/index.js

@@ -1,15 +0,0 @@
-export * from './abstract-binary-tree';
-export * from './abstract-graph';
-export * from './avl-tree';
-export * from './binary-tree';
-export * from './bst';
-export * from './directed-graph';
-export * from './doubly-linked-list';
-export * from './heap';
-export * from './navigator';
-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/lib/interfaces/rb-tree.d.ts

@@ -1,6 +0,0 @@
-import { RBTreeNode } from '../data-structures';
-import { IBST, IBSTNode } from './bst';
-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> {
-}

package/lib/interfaces/tree-multiset.d.ts

@@ -1,6 +0,0 @@
-import { TreeMultisetNode } from '../data-structures';
-import { IAVLTree, IAVLTreeNode } from './avl-tree';
-export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IAVLTreeNode<T, NEIGHBOR> {
-}
-export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
-}

package/lib/interfaces/undirected-graph.d.ts

@@ -1,3 +0,0 @@
-import { IAbstractGraph } from './abstract-graph';
-export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
-}

package/lib/types/data-structures/abstract-binary-tree.d.ts

@@ -1,34 +0,0 @@
-import { AbstractBinaryTreeNode } from '../../data-structures';
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
-export declare enum LoopType {
-    ITERATIVE = "ITERATIVE",
-    RECURSIVE = "RECURSIVE"
-}
-export declare enum FamilyPosition {
-    ROOT = "ROOT",
-    LEFT = "LEFT",
-    RIGHT = "RIGHT",
-    ROOT_LEFT = "ROOT_LEFT",
-    ROOT_RIGHT = "ROOT_RIGHT",
-    ISOLATED = "ISOLATED",
-    MAL_NODE = "MAL_NODE"
-}
-export type BinaryTreeNodePropertyName = 'key' | 'val';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeKey = number;
-export type BinaryTreeDeletedResult<N> = {
-    deleted: N | null | undefined;
-    needBalanced: N | null;
-};
-export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeKey;
-export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
-export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AbstractBinaryTreeOptions = {
-    loopType?: LoopType;
-};

package/lib/types/data-structures/abstract-binary-tree.js

@@ -1,21 +0,0 @@
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
-export var LoopType;
-(function (LoopType) {
-    LoopType["ITERATIVE"] = "ITERATIVE";
-    LoopType["RECURSIVE"] = "RECURSIVE";
-})(LoopType || (LoopType = {}));
-export var FamilyPosition;
-(function (FamilyPosition) {
-    FamilyPosition["ROOT"] = "ROOT";
-    FamilyPosition["LEFT"] = "LEFT";
-    FamilyPosition["RIGHT"] = "RIGHT";
-    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition["ISOLATED"] = "ISOLATED";
-    FamilyPosition["MAL_NODE"] = "MAL_NODE";
-})(FamilyPosition || (FamilyPosition = {}));

package/lib/types/data-structures/abstract-graph.d.ts

@@ -1,11 +0,0 @@
-export type VertexKey = string | number;
-export type EdgeKey = string;
-export type DijkstraResult<V> = {
-    distMap: Map<V, number>;
-    distPaths?: Map<V, V[]>;
-    preMap: Map<V, V | null>;
-    seen: Set<V>;
-    paths: V[][];
-    minDist: number;
-    minPath: V[];
-} | null;

package/lib/types/data-structures/avl-tree.d.ts

@@ -1,4 +0,0 @@
-import { AVLTreeNode } from '../../data-structures';
-import { BSTOptions } from './bst';
-export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeOptions = BSTOptions & {};

package/lib/types/data-structures/binary-tree.d.ts

@@ -1,4 +0,0 @@
-import { BinaryTreeNode } from '../../data-structures/binary-tree';
-import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
-export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type BinaryTreeOptions = AbstractBinaryTreeOptions & {};

package/lib/types/data-structures/bst.d.ts

@@ -1,13 +0,0 @@
-import { BSTNode } from '../../data-structures/binary-tree';
-import type { BinaryTreeOptions } from './binary-tree';
-import { BinaryTreeNodeKey } from './abstract-binary-tree';
-export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
-export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type BSTOptions = BinaryTreeOptions & {
-    comparator?: BSTComparator;
-};
-export declare enum CP {
-    lt = "lt",
-    eq = "eq",
-    gt = "gt"
-}

package/lib/types/data-structures/bst.js

@@ -1,6 +0,0 @@
-export var CP;
-(function (CP) {
-    CP["lt"] = "lt";
-    CP["eq"] = "eq";
-    CP["gt"] = "gt";
-})(CP || (CP = {}));

package/lib/types/data-structures/directed-graph.js

@@ -1,6 +0,0 @@
-export var TopologicalProperty;
-(function (TopologicalProperty) {
-    TopologicalProperty["VAL"] = "VAL";
-    TopologicalProperty["NODE"] = "NODE";
-    TopologicalProperty["ID"] = "ID";
-})(TopologicalProperty || (TopologicalProperty = {}));

package/lib/types/data-structures/heap.d.ts

@@ -1,3 +0,0 @@
-export type HeapOptions<T> = {
-    priorityExtractor?: (element: T) => number;
-};

package/lib/types/data-structures/index.d.ts

@@ -1,16 +0,0 @@
-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 './map-graph';
-export * from './abstract-binary-tree';
-export * from './rb-tree';
-export * from './directed-graph';
-export * from './priority-queue';
-export * from './heap';
-export * from './singly-linked-list';
-export * from './doubly-linked-list';
-export * from './navigator';
-export * from './hash';

package/lib/types/data-structures/index.js

@@ -1,16 +0,0 @@
-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 './map-graph';
-export * from './abstract-binary-tree';
-export * from './rb-tree';
-export * from './directed-graph';
-export * from './priority-queue';
-export * from './heap';
-export * from './singly-linked-list';
-export * from './doubly-linked-list';
-export * from './navigator';
-export * from './hash';

package/lib/types/data-structures/priority-queue.d.ts

@@ -1,7 +0,0 @@
-export type PriorityQueueComparator<T> = (a: T, b: T) => number;
-export type PriorityQueueOptions<T> = {
-    nodes?: T[];
-    isFix?: boolean;
-    comparator: PriorityQueueComparator<T>;
-};
-export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

package/lib/types/data-structures/rb-tree.d.ts

@@ -1,8 +0,0 @@
-import { BinaryTreeOptions } from './binary-tree';
-import { RBTreeNode } from '../../data-structures/binary-tree';
-export declare enum RBColor {
-    RED = "RED",
-    BLACK = "BLACK"
-}
-export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RBTreeOptions = BinaryTreeOptions & {};

package/lib/types/data-structures/rb-tree.js

@@ -1,5 +0,0 @@
-export var RBColor;
-(function (RBColor) {
-    RBColor["RED"] = "RED";
-    RBColor["BLACK"] = "BLACK";
-})(RBColor || (RBColor = {}));

package/lib/types/data-structures/tree-multiset.d.ts

@@ -1,4 +0,0 @@
-import { TreeMultisetNode } from '../../data-structures/binary-tree';
-import { AVLTreeOptions } from './avl-tree';
-export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {};

package/lib/types/index.js

@@ -1,3 +0,0 @@
-export * from './data-structures';
-export * from './helpers';
-export * from './utils';

package/lib/types/utils/index.js

@@ -1,2 +0,0 @@
-export * from './utils';
-export * from './validate-type';