data-structure-typed 0.8.18 → 0.9.16

package/src/{utils.ts → utils/utils.ts}

@@ -1,5 +1,5 @@
-import _ from 'lodash';
-import {AnyFunction} from './types';
+import * as _ from 'lodash';
+import {AnyFunction} from '../data-structures/types';
 
 export type JSONSerializable = {
     [key: string]: any
@@ -21,7 +21,7 @@ export function randomText(length: number) {
 }
 
 export const uuidV4 = function () {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
         return v.toString(16);
     });
@@ -60,25 +60,15 @@ export function incrementId(prefix?: string) {
     };
 }
 
-export const getValue = <T, K extends keyof T>(obj: T, names: K[]): Array<T[K]> => {
-    return names.map(i => obj[i]);
-};
+export const getValue = <T, K extends keyof T>(obj: T, names: K[]): Array<T[K]> => names.map(i => obj[i]);
 
-export const isObject = (object: string | JSONObject | boolean | AnyFunction | number) => {
-    return object != null && typeof object === 'object';
-};
+export const isObject = (object: string | JSONObject | boolean | AnyFunction | number) => object != null && typeof object === 'object';
 
-export const looseEqual = (a: any, b: any): boolean => {
-    return a == b;
-};
+export const looseEqual = (a: any, b: any): boolean => a == b;
 
-export const strictEqual = (a: any, b: any): boolean => {
-    return a === b;
-};
+export const strictEqual = (a: any, b: any): boolean => a === b;
 
-export const strictObjectIsEqual = (a: any, b: any): boolean => {
-    return Object.is(a, b);
-};
+export const strictObjectIsEqual = (a: any, b: any): boolean => Object.is(a, b);
 
 export const deepObjectStrictEqual = (object1: JSONSerializable, object2: JSONSerializable) => {
     const keys1 = Object.keys(object1);
@@ -100,10 +90,6 @@ export const deepObjectStrictEqual = (object1: JSONSerializable, object2: JSONSe
     return true;
 };
 
-export const isTypeEqual = <T>(obj: unknown) => {
-    const m = obj as unknown as T;
-};
-
 export function reverseColor(oldColor: string) {
     const oldColorTemp = '0x' + oldColor.replace(/#/g, '');
     const str = '000000' + (0xFFFFFF - Number(oldColorTemp)).toString(16);
@@ -152,48 +138,62 @@ export const addDays = (date: Date, days: number): Date => {
 };
 
 export class WaitManager {
+    private _time30 = 20000;
+    private readonly _nXSpeed: number = 1;
+
+    constructor(nXSpeed?: number) {
+        if (nXSpeed === undefined) nXSpeed = 1;
+        this._nXSpeed = nXSpeed;
+    }
+
     private _time1 = 1000;
+
     get time1(): number {
         return this._time1 / this._nXSpeed;
     }
 
     private _time2 = 2000;
+
     get time2(): number {
         return this._time2 / this._nXSpeed;
     }
 
     private _time3 = 3000;
+
     get time3(): number {
         return this._time3 / this._nXSpeed;
     }
 
     private _time4 = 4000;
+
     get time4(): number {
         return this._time4 / this._nXSpeed;
     }
 
     private _time10 = 10000;
+
     get time10(): number {
         return this._time10 / this._nXSpeed;
     }
 
     private _time20 = 20000;
+
     get time20(): number {
         return this._time20 / this._nXSpeed;
     }
 
-    private _time30 = 20000;
-
     get time50(): number {
         return this._time30 / this._nXSpeed;
     }
 
     private _time60 = 60000;
+
     get time60(): number {
         return this._time60 / this._nXSpeed;
     }
 
     private _cusTime = 1000;
+
     get cusTime(): number {
         return this._cusTime / this._nXSpeed;
     }
@@ -201,13 +201,6 @@ export class WaitManager {
     set cusTime(v: number) {
         this._cusTime = v;
     }
-
-    private readonly _nXSpeed: number = 1;
-
-    constructor(nXSpeed?: number) {
-        if (nXSpeed === undefined) nXSpeed = 1;
-        this._nXSpeed = nXSpeed;
-    }
 }
 
 export const wait = async (ms: number, resolveValue?: any) => {
@@ -219,78 +212,6 @@ export const wait = async (ms: number, resolveValue?: any) => {
     });
 };
 
-export class AuthAPIError extends Error {
-    protected serverErrorStack;
-    protected serverErrorCode;
-
-    constructor(serverErrorMessage: string, serverErrorCode?: string, serverErrorStack?: string) {
-        super(serverErrorMessage);
-        if (serverErrorStack) {
-            this.serverErrorStack = serverErrorStack;
-        }
-        if (serverErrorCode) {
-            this.serverErrorCode = serverErrorCode;
-        }
-        this.name = new.target.name;
-        if (typeof (Error as any).captureStackTrace === 'function') {
-            (Error as any).captureStackTrace(this, new.target);
-        }
-        if (typeof Object.setPrototypeOf === 'function') {
-            Object.setPrototypeOf(this, new.target.prototype);
-        } else {
-            (this as any).__proto__ = new.target.prototype;
-        }
-    }
-}
-
-export class BunnyAPIError extends Error {
-    protected serverErrorStack;
-    protected serverErrorCode;
-
-    constructor(serverErrorMessage: string, serverErrorCode?: string, serverErrorStack?: string) {
-        super(serverErrorMessage);
-        if (serverErrorStack) {
-            this.serverErrorStack = serverErrorStack;
-        }
-        if (serverErrorCode) {
-            this.serverErrorCode = serverErrorCode;
-        }
-        this.name = new.target.name;
-        if (typeof (Error as any).captureStackTrace === 'function') {
-            (Error as any).captureStackTrace(this, new.target);
-        }
-        if (typeof Object.setPrototypeOf === 'function') {
-            Object.setPrototypeOf(this, new.target.prototype);
-        } else {
-            (this as any).__proto__ = new.target.prototype;
-        }
-    }
-}
-
-export class NomicsAPIError extends Error {
-    protected serverErrorStack;
-    protected serverErrorCode;
-
-    constructor(serverErrorMessage: string, serverErrorCode?: string, serverErrorStack?: string) {
-        super(serverErrorMessage);
-        if (serverErrorStack) {
-            this.serverErrorStack = serverErrorStack;
-        }
-        if (serverErrorCode) {
-            this.serverErrorCode = serverErrorCode;
-        }
-        this.name = new.target.name;
-        if (typeof (Error as any).captureStackTrace === 'function') {
-            (Error as any).captureStackTrace(this, new.target);
-        }
-        if (typeof Object.setPrototypeOf === 'function') {
-            Object.setPrototypeOf(this, new.target.prototype);
-        } else {
-            (this as any).__proto__ = new.target.prototype;
-        }
-    }
-}
-
 export function extractValue<Item>(data: { key: string, value: Item }[]) {
     let result: Item[] = [];
     if (data && data.length > 0) {
@@ -328,14 +249,9 @@ export function randomDate(start?: Date, end?: Date, specificProbabilityStart?:
     return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
 }
 
+export const capitalizeWords = (str: string) => str.replace(/(?:^|\s)\S/g, (a: string) => a.toUpperCase());
 
-export const capitalizeWords = (str: string) => {
-    return str.replace(/(?:^|\s)\S/g, (a: string) => a.toUpperCase());
-};
-
-export const capitalizeFirstLetter = (str: string) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-};
+export const capitalizeFirstLetter = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
 
 export const comparerArray = <T>(otherArray: T[], limitKeys?: string[]) => {
     return function (current: T) {
@@ -349,17 +265,11 @@ export const comparerArray = <T>(otherArray: T[], limitKeys?: string[]) => {
     };
 };
 
-export const onlyInA = <T>(a: T[], b: T[]) => {
-    return a.filter(comparerArray(b));
-};
+export const onlyInA = <T>(a: T[], b: T[]) => a.filter(comparerArray(b));
 
-export const onlyInB = <T>(a: T[], b: T[]) => {
-    return b.filter(comparerArray(a));
-};
+export const onlyInB = <T>(a: T[], b: T[]) => b.filter(comparerArray(a));
 
-export const diffAB = <T>(a: T[], b: T[]) => {
-    return onlyInA(a, b).concat(onlyInB(a, b));
-};
+export const diffAB = <T>(a: T[], b: T[]) => onlyInA(a, b).concat(onlyInB(a, b));
 
 export class StringUtil {
     // camelCase
@@ -413,8 +323,8 @@ export class StringUtil {
     }
 }
 
-type ToCase = 'camel' | 'snake' | 'pascal' | 'constant' | 'kebab' | 'lower' | 'title' | 'sentence' | 'path' | 'dot';
-export const deepKeysConvert = (obj: any, toType?: ToCase): any => {
+export type CaseType = 'camel' | 'snake' | 'pascal' | 'constant' | 'kebab' | 'lower' | 'title' | 'sentence' | 'path' | 'dot';
+export const deepKeysConvert = (obj: any, toType?: CaseType): any => {
     const _toType = toType || 'snake';
     if (Array.isArray(obj)) {
         return obj.map(v => deepKeysConvert(v, _toType));
@@ -501,13 +411,6 @@ export const deepReplaceValues = (obj: JSONSerializable, keyReducerMap: { [key i
     return newObject;
 };
 
-// function getCallStackSize() {
-//     let count = 0, fn = arguments.callee;
-//     while ( (fn = fn.caller) ) {
-//         count++;
-//     }
-//     return count;
-// }
 // TODO determine depth and pass root node as a param through callback
 export const deepAdd = (obj: JSONSerializable, keyReducerMap: { [key in string]: (item: JSONSerializable) => any }, isItemRootParent?: boolean) => {
     const newObject = _.clone(obj) as JSONObject | [];
@@ -529,7 +432,6 @@ export const deepAdd = (obj: JSONSerializable, keyReducerMap: { [key in string]:
 
 const styleString = (color: string) => `color: ${color}; font-weight: bold`;
 
-
 const styleHeader = (header: string) => `%c[${header}]`;
 
 export const bunnyConsole = {
@@ -544,7 +446,6 @@ export const bunnyConsole = {
     }
 };
 
-
 export const timeStart = () => {
     return performance ? performance.now() : new Date().getTime();
 };
@@ -601,5 +502,4 @@ export function zip<T = number, T1 = number>(array1: T[], array2: T1[], options?
         }
     }
     return isToObj ? zippedObjCoords : zipped;
-}
-
+}

package/tsconfig.json

@@ -3,18 +3,17 @@
     "declaration": true,
     "outDir": "./dist",
     "module": "commonjs",
-    "target": "es6",
+    "target": "es5",
     "lib": [
-      "es6",
-      "dom",
-      "dom.iterable",
+//      "es2015",
       "esnext"
     ],
     "strict": true,
     "esModuleInterop": true,
     "moduleResolution": "node",
     "declarationDir": "./dist",
-    "skipLibCheck": true
+    "skipLibCheck": true,
+        "downlevelIteration": true,
 
     //    "allowJs": true,
     //    "allowSyntheticDefaultImports": true,
@@ -23,12 +22,16 @@
     //    "resolveJsonModule": true,
     //    "isolatedModules": true,
     //    "noEmit": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ]
   },
+
   "include": [
     "src",
-    "node_modules/data-structure-typed"
   ],
   "exclude": [
+//    "node_modules/data-structure-typed",
     "node_modules",
     "dist"
   ]

package/dist/types/data-structures/binary-tree/aa-tree.d.ts

@@ -1,2 +0,0 @@
-export declare class AaTree {
-}

package/dist/types/data-structures/binary-tree/avl-tree.d.ts

@@ -1,21 +0,0 @@
-import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}
-export declare class AVLTreeNode<T> extends BSTNode<T> {
-    clone(): AVLTreeNode<T>;
-}
-export declare class AVLTree<T> extends BST<T> {
-    createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[];
-    balanceFactor(node: AVLTreeNode<T>): number;
-    updateHeight(node: AVLTreeNode<T>): void;
-    balancePath(node: AVLTreeNode<T>): void;
-    balanceLL(A: AVLTreeNode<T>): void;
-    balanceLR(A: AVLTreeNode<T>): void;
-    balanceRR(A: AVLTreeNode<T>): void;
-    balanceRL(A: AVLTreeNode<T>): void;
-}

package/dist/types/data-structures/binary-tree/b-tree.d.ts

@@ -1,2 +0,0 @@
-export declare class BTree {
-}

package/dist/types/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -1,8 +0,0 @@
-export declare class BinaryIndexedTree {
-    private readonly _sumTree;
-    constructor(n: number);
-    update(i: number, delta: number): void;
-    getPrefixSum(i: number): number;
-    getRangeSum(start: number, end: number): number;
-    static lowBit(x: number): number;
-}

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

@@ -1,140 +0,0 @@
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = {
-    deleted: BinaryTreeNode<T> | null | undefined;
-    needBalanced: BinaryTreeNode<T> | null;
-};
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
-export interface BinaryTreeNodeObj<T> {
-    id: BinaryTreeNodeId;
-    val: T;
-    count?: number;
-}
-export declare enum FamilyPosition {
-    root = 0,
-    left = 1,
-    right = 2
-}
-export declare enum LoopType {
-    iterative = 1,
-    recursive = 2
-}
-export declare class BinaryTreeNode<T> {
-    protected _id: BinaryTreeNodeId;
-    get id(): BinaryTreeNodeId;
-    set id(v: BinaryTreeNodeId);
-    protected _val: T;
-    get val(): T;
-    set val(v: T);
-    protected _left?: BinaryTreeNode<T> | null;
-    get left(): BinaryTreeNode<T> | null | undefined;
-    set left(v: BinaryTreeNode<T> | null | undefined);
-    protected _right?: BinaryTreeNode<T> | null;
-    get right(): BinaryTreeNode<T> | null | undefined;
-    set right(v: BinaryTreeNode<T> | null | undefined);
-    protected _parent: BinaryTreeNode<T> | null | undefined;
-    get parent(): BinaryTreeNode<T> | null | undefined;
-    set parent(v: BinaryTreeNode<T> | null | undefined);
-    protected _familyPosition: FamilyPosition;
-    get familyPosition(): FamilyPosition;
-    set familyPosition(v: FamilyPosition);
-    protected _count: number;
-    get count(): number;
-    set count(v: number);
-    protected _height: number;
-    get height(): number;
-    set height(v: number);
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
-    swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    clone(): BinaryTreeNode<T>;
-}
-export declare class BinaryTree<T> {
-    protected _root: BinaryTreeNode<T> | null;
-    get root(): BinaryTreeNode<T> | null;
-    protected set root(v: BinaryTreeNode<T> | null);
-    protected _size: number;
-    get size(): number;
-    protected set size(v: number);
-    protected _count: number;
-    get count(): number;
-    protected set count(v: number);
-    private readonly _autoIncrementId;
-    private _maxId;
-    private readonly _isDuplicatedVal;
-    protected _loopType: LoopType;
-    protected _visitedId: BinaryTreeNodeId[];
-    protected _visitedVal: Array<T>;
-    protected _visitedNode: BinaryTreeNode<T>[];
-    protected _visitedCount: number[];
-    protected _visitedLeftSum: number[];
-    protected _resetResults(): void;
-    constructor(options?: {
-        loopType?: LoopType;
-        autoIncrementId?: boolean;
-        isDuplicatedVal?: boolean;
-    });
-    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null;
-    clear(): void;
-    isEmpty(): boolean;
-    insertTo({ newNode, parent }: {
-        newNode: BinaryTreeNode<T> | null;
-        parent: BinaryTreeNode<T>;
-    }): BinaryTreeNode<T> | null | undefined;
-    put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
-    insertMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
-    fill(data: T[] | BinaryTreeNode<T>[]): boolean;
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeleted<T>[];
-    getDepth(node: BinaryTreeNode<T>): number;
-    getHeight(beginRoot?: BinaryTreeNode<T> | null): number;
-    getMinHeight(beginRoot?: BinaryTreeNode<T> | null): number;
-    isBalanced(beginRoot?: BinaryTreeNode<T> | null): boolean;
-    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (BinaryTreeNode<T> | null | undefined)[];
-    has(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): boolean;
-    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BinaryTreeNode<T> | null;
-    getPathToRoot(node: BinaryTreeNode<T>): BinaryTreeNode<T>[];
-    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
-    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
-    getLeftMost(): BinaryTreeNode<T> | null;
-    getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    getRightMost(): BinaryTreeNode<T> | null;
-    getRightMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    isBST(node?: BinaryTreeNode<T> | null): boolean;
-    getSubTreeSizeAndCount(subTreeRoot: BinaryTreeNode<T> | null | undefined): [number, number];
-    subTreeSum(subTreeRoot: BinaryTreeNode<T>, propertyName?: BinaryTreeNodePropertyName): number;
-    subTreeAdd(subTreeRoot: BinaryTreeNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    BFS(): BinaryTreeNodeId[];
-    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
-    BFS(nodeOrPropertyName: 'val'): T[];
-    BFS(nodeOrPropertyName: 'node'): BinaryTreeNode<T>[];
-    BFS(nodeOrPropertyName: 'count'): number[];
-    DFS(): BinaryTreeNodeId[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    DFSIterative(): BinaryTreeNodeId[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    levelIterative(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[];
-    listLevels(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[][];
-    getPredecessor(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    morris(): BinaryTreeNodeId[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-}

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,32 +0,0 @@
-import { BinaryTree, BinaryTreeNode, BinaryTreeNodeId, BinaryTreeNodePropertyName, LoopType } from './binary-tree';
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
-};
-export declare enum CP {
-    lt = -1,
-    eq = 0,
-    gt = 1
-}
-export declare class BSTNode<T> extends BinaryTreeNode<T> {
-    clone(): BSTNode<T>;
-}
-export declare class BST<T> extends BinaryTree<T> {
-    protected _comparator: BSTComparator;
-    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP;
-    constructor(options?: {
-        comparator?: BSTComparator;
-        loopType?: LoopType;
-    });
-    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
-    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BSTNode<T> | null;
-    lastKey(): number;
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[];
-    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): BSTNode<T>[];
-    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
-    allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    balance(): boolean;
-    isAVLBalanced(): boolean;
-}

package/dist/types/data-structures/binary-tree/index.d.ts

@@ -1,4 +0,0 @@
-export * from './binary-tree';
-export * from './bst';
-export * from './binary-indexed-tree';
-export * from './segment-tree';

package/dist/types/data-structures/binary-tree/rb-tree.d.ts

@@ -1,2 +0,0 @@
-export declare class RBTree {
-}

package/dist/types/data-structures/binary-tree/segment-tree.d.ts

@@ -1,33 +0,0 @@
-export type SegmentTreeNodeVal = number;
-export declare class SegmentTreeNode {
-    protected _start: number;
-    get start(): number;
-    set start(v: number);
-    protected _end: number;
-    get end(): number;
-    set end(v: number);
-    protected _val: SegmentTreeNodeVal | null;
-    get val(): SegmentTreeNodeVal | null;
-    set val(v: SegmentTreeNodeVal | null);
-    protected _sum: number;
-    get sum(): number;
-    set sum(v: number);
-    protected _left: SegmentTreeNode | null;
-    get left(): SegmentTreeNode | null;
-    set left(v: SegmentTreeNode | null);
-    protected _right: SegmentTreeNode | null;
-    get right(): SegmentTreeNode | null;
-    set right(v: SegmentTreeNode | null);
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
-}
-export declare class SegmentTree {
-    protected _values: number[];
-    protected _start: number;
-    protected _end: number;
-    protected _root: SegmentTreeNode | null;
-    get root(): SegmentTreeNode | null;
-    constructor(values: number[], start?: number, end?: number);
-    build(start: number, end: number): SegmentTreeNode;
-    updateNode(index: number, sum: number, val?: SegmentTreeNodeVal): void;
-    querySumByRange(indexA: number, indexB: number): number;
-}

package/dist/types/data-structures/binary-tree/splay-tree.d.ts

@@ -1,2 +0,0 @@
-export declare class SplayTree {
-}

package/dist/types/data-structures/binary-tree/tree-multiset.d.ts

@@ -1,11 +0,0 @@
-import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export type TreeMultiSetDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
-};
-export declare class TreeMultiSet<T> extends BST<T> {
-    createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T>;
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<T>[];
-}

package/dist/types/data-structures/binary-tree/two-three-tree.d.ts

@@ -1,2 +0,0 @@
-export declare class TwoThreeTree {
-}