data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import * as _ from 'lodash';
 import {AnyFunction} from './types';
 
 export type JSONSerializable = {
@@ -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,18 @@ 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 +421,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 +442,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 +456,6 @@ export const bunnyConsole = {
     }
 };
 
-
 export const timeStart = () => {
     return performance ? performance.now() : new Date().getTime();
 };
@@ -601,5 +512,4 @@ export function zip<T = number, T1 = number>(array1: T[], array2: T1[], options?
         }
     }
     return isToObj ? zippedObjCoords : zipped;
-}
-
+}

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

@@ -0,0 +1,185 @@
+import {BST, BSTNode} from '../../../../src';
+
+describe('bst-case6', () => {
+    it('should perform various operations on a Binary Search Tree', () => {
+        const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+
+        const tree = new BST();
+
+        expect(tree).toBeInstanceOf(BST);
+
+        for (const i of arr) tree.put(i, i);
+
+        expect(tree.root).toBeInstanceOf(BSTNode);
+        if (tree.root) expect(tree.root.id).toBe(11);
+        expect(tree.count).toBe(16);
+        expect(tree.has(6)).toBe(true);
+
+        const node6 = tree.get(6);
+        expect(node6 && tree.getHeight(node6)).toBe(2);
+        expect(node6 && tree.getDepth(node6)).toBe(3);
+        const getNodeById = tree.get(10, 'id');
+        expect(getNodeById?.id).toBe(10);
+
+        const getNodesByCount = tree.getNodes(1, 'count');
+        expect(getNodesByCount.length).toBe(16);
+
+        const getMinNodeByRoot = tree.getLeftMost();
+        expect(getMinNodeByRoot?.id).toBe(1);
+
+        const node15 = tree.get(15);
+        const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+        expect(getMinNodeBySpecificNode?.id).toBe(12);
+
+        const subTreeSum = node15 && tree.subTreeSum(node15);
+        expect(subTreeSum).toBe(70);
+
+        const lesserSum = tree.lesserSum(10);
+        expect(lesserSum).toBe(45);
+
+        expect(node15).toBeInstanceOf(BSTNode);
+        if (node15 instanceof BSTNode) {
+            const subTreeAdd = tree.subTreeAdd(node15, 1, 'count');
+            expect(subTreeAdd).toBeDefined();
+        }
+
+
+        const node11 = tree.get(11);
+        expect(node11).toBeInstanceOf(BSTNode);
+        if (node11 instanceof BSTNode) {
+            const allGreaterNodesAdd = tree.allGreaterNodesAdd(node11, 2, 'count');
+            expect(allGreaterNodesAdd).toBeDefined();
+        }
+
+        const dfs = tree.DFS('in', 'node');
+        expect(dfs[0].id).toBe(1);
+        expect(dfs[dfs.length - 1].id).toBe(16);
+
+        tree.balance();
+        const bfs = tree.BFS('node');
+        expect(tree.isBalanced()).toBe(true);
+        expect(bfs[0].id).toBe(8);
+        expect(bfs[bfs.length - 1].id).toBe(16);
+
+        const removed11 = tree.remove(11, true);
+        expect(removed11).toBeInstanceOf(Array);
+        expect(removed11[0]).toBeDefined();
+        expect(removed11[0].deleted).toBeDefined();
+        if (removed11[0].deleted) expect(removed11[0].deleted.id).toBe(11);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(node15 && tree.getHeight(node15)).toBe(2);
+
+        const removed1 = tree.remove(1, true);
+        expect(removed1).toBeInstanceOf(Array);
+        expect(removed1[0]).toBeDefined();
+        expect(removed1[0].deleted).toBeDefined();
+        if (removed1[0].deleted) expect(removed1[0].deleted.id).toBe(1);
+
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(4);
+
+        const removed4 = tree.remove(4, true);
+        expect(removed4).toBeInstanceOf(Array);
+        expect(removed4[0]).toBeDefined();
+        expect(removed4[0].deleted).toBeDefined();
+        if (removed4[0].deleted) expect(removed4[0].deleted.id).toBe(4);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(4);
+
+        const removed10 = tree.remove(10, true);
+        expect(removed10).toBeInstanceOf(Array);
+        expect(removed10[0]).toBeDefined();
+        expect(removed10[0].deleted).toBeDefined();
+        if (removed10[0].deleted) expect(removed10[0].deleted.id).toBe(10);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(4);
+
+        const removed15 = tree.remove(15, true);
+        expect(removed15).toBeInstanceOf(Array);
+        expect(removed15[0]).toBeDefined();
+        expect(removed15[0].deleted).toBeDefined();
+        if (removed15[0].deleted) expect(removed15[0].deleted.id).toBe(15);
+
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed5 = tree.remove(5, true);
+        expect(removed5).toBeInstanceOf(Array);
+        expect(removed5[0]).toBeDefined();
+        expect(removed5[0].deleted).toBeDefined();
+        if (removed5[0].deleted) expect(removed5[0].deleted.id).toBe(5);
+
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed13 = tree.remove(13, true);
+        expect(removed13).toBeInstanceOf(Array);
+        expect(removed13[0]).toBeDefined();
+        expect(removed13[0].deleted).toBeDefined();
+        if (removed13[0].deleted) expect(removed13[0].deleted.id).toBe(13);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed3 = tree.remove(3, true);
+        expect(removed3).toBeInstanceOf(Array);
+        expect(removed3[0]).toBeDefined();
+        expect(removed3[0].deleted).toBeDefined();
+        if (removed3[0].deleted) expect(removed3[0].deleted.id).toBe(3);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed8 = tree.remove(8, true);
+        expect(removed8).toBeInstanceOf(Array);
+        expect(removed8[0]).toBeDefined();
+        expect(removed8[0].deleted).toBeDefined();
+        if (removed8[0].deleted) expect(removed8[0].deleted.id).toBe(8);
+        expect(tree.isAVLBalanced()).toBe(true);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed6 = tree.remove(6, true);
+        expect(removed6).toBeInstanceOf(Array);
+        expect(removed6[0]).toBeDefined();
+        expect(removed6[0].deleted).toBeDefined();
+        if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
+        expect(tree.remove(6, true).length).toBe(0);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed7 = tree.remove(7, true);
+        expect(removed7).toBeInstanceOf(Array);
+        expect(removed7[0]).toBeDefined();
+        expect(removed7[0].deleted).toBeDefined();
+        if (removed7[0].deleted) expect(removed7[0].deleted.id).toBe(7);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed9 = tree.remove(9, true);
+        expect(removed9).toBeInstanceOf(Array);
+        expect(removed9[0]).toBeDefined();
+        expect(removed9[0].deleted).toBeDefined();
+        if (removed9[0].deleted) expect(removed9[0].deleted.id).toBe(9);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(3);
+
+        const removed14 = tree.remove(14, true);
+        expect(removed14).toBeInstanceOf(Array);
+        expect(removed14[0]).toBeDefined();
+        expect(removed14[0].deleted).toBeDefined();
+        if (removed14[0].deleted) expect(removed14[0].deleted.id).toBe(14);
+        expect(tree.isAVLBalanced()).toBe(false);
+        expect(tree.getHeight()).toBe(2);
+
+
+        expect(!tree.isAVLBalanced()).toBe(true);
+
+        const lastBFSIds = tree.BFS();
+        expect(lastBFSIds[0]).toBe(2);
+        expect(lastBFSIds[1]).toBe(12);
+        expect(lastBFSIds[2]).toBe(16);
+
+        const lastBFSNodes = tree.BFS('node');
+        expect(lastBFSNodes[0].id).toBe(2);
+        expect(lastBFSNodes[1].id).toBe(12);
+        expect(lastBFSNodes[2].id).toBe(16);
+    });
+});

package/tests/unit/data-structures/graph/directed-graph.test.ts

@@ -0,0 +1,71 @@
+import { DirectedGraph, DirectedVertex, DirectedEdge } from '../../../../src';
+
+describe('DirectedGraph', () => {
+    let graph: DirectedGraph<DirectedVertex, DirectedEdge>;
+
+    beforeEach(() => {
+        graph = new DirectedGraph();
+    });
+
+    it('should add vertices', () => {
+        const vertex1 = new DirectedVertex('A');
+        const vertex2 = new DirectedVertex('B');
+
+        graph.addVertex(vertex1);
+        graph.addVertex(vertex2);
+
+        expect(graph.containsVertex(vertex1)).toBe(true);
+        expect(graph.containsVertex(vertex2)).toBe(true);
+    });
+
+    it('should add edges', () => {
+        const vertex1 = new DirectedVertex('A');
+        const vertex2 = new DirectedVertex('B');
+        const edge = new DirectedEdge('A', 'B');
+
+        graph.addVertex(vertex1);
+        graph.addVertex(vertex2);
+        graph.addEdge(edge);
+
+        expect(graph.containsEdge('A', 'B')).toBe(true);
+        expect(graph.containsEdge('B', 'A')).toBe(false);
+    });
+
+    it('should remove edges', () => {
+        const vertex1 = new DirectedVertex('A');
+        const vertex2 = new DirectedVertex('B');
+        const edge = new DirectedEdge('A', 'B');
+
+        graph.addVertex(vertex1);
+        graph.addVertex(vertex2);
+        graph.addEdge(edge);
+
+        expect(graph.removeEdge(edge)).toBe(edge);
+        expect(graph.containsEdge('A', 'B')).toBe(false);
+    });
+
+    // Add more test cases for other methods...
+
+    it('should perform topological sort', () => {
+        // Create a graph with vertices and edges
+        const vertexA = new DirectedVertex('A');
+        const vertexB = new DirectedVertex('B');
+        const vertexC = new DirectedVertex('C');
+        const edgeAB = new DirectedEdge('A', 'B');
+        const edgeBC = new DirectedEdge('B', 'C');
+
+        graph.addVertex(vertexA);
+        graph.addVertex(vertexB);
+        graph.addVertex(vertexC);
+        graph.addEdge(edgeAB);
+        graph.addEdge(edgeBC);
+
+        // Perform topological sort
+        const topologicalOrder = graph.topologicalSort();
+
+        if (topologicalOrder) expect(topologicalOrder.map(v => v.id)).toEqual(['A', 'B', 'C']);
+
+    });
+
+    // Add more test cases for other methods...
+});

package/{dist/types/data-structures/graph/index.d.ts → tests/unit/data-structures/graph/index.ts}

@@ -1,3 +1,3 @@
 export * from './abstract-graph';
-export * from './directed-graph';
+export * from './directed-graph.test';
 export * from './undirected-graph';

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/data-structures/trampoline.d.ts

@@ -1,25 +0,0 @@
-export type ArgumentTypes<T extends (...args: any[]) => any> = T extends (...args: infer A) => any ? A : never;
-export declare const THUNK_SYMBOL: unique symbol;
-export interface Thunk<T> extends Function {
-    __THUNK__: typeof THUNK_SYMBOL;
-    (): T;
-}
-export type ThunkOrValue<T> = T | Thunk<T>;
-export type UnwrapThunkDeep<T> = {
-    0: T extends Thunk<infer U> ? UnwrapThunkDeep<U> : T;
-}[T extends ThunkOrValue<T> ? 0 : never];
-export declare const isThunk: <T>(value: any) => value is Thunk<T>;
-export declare const toThunk: <R>(fn: () => R) => Thunk<R>;
-export type UnwrapPromise<T> = T extends Promise<infer U> ? Exclude<U, Promise<T>> : T;
-export type Unbox<T> = UnwrapThunkDeep<UnwrapPromise<T>>;
-export type Cont<A extends any[], R> = (...args: A) => Thunk<Unbox<R>>;
-export interface Trampoline<F extends ((...args: any[]) => any)> {
-    (...args: ArgumentTypes<F>): Unbox<ReturnType<F>>;
-    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
-}
-export interface TrampolineAsync<F extends ((...args: any[]) => any)> {
-    (...args: ArgumentTypes<F>): Promise<Unbox<ReturnType<F>>>;
-    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
-}
-export declare const trampoline: <F extends (...args: any[]) => any>(fn: F) => Trampoline<F>;
-export declare const trampolineAsync: <F extends (...args: any[]) => any>(fn: F) => TrampolineAsync<F>;

package/dist/data-structures/trampoline.js

@@ -1,52 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = void 0;
-exports.THUNK_SYMBOL = Symbol('thunk');
-const isThunk = (value) => {
-    return typeof value === 'function' && value.__THUNK__ === exports.THUNK_SYMBOL;
-};
-exports.isThunk = isThunk;
-const toThunk = (fn) => {
-    const thunk = () => fn();
-    thunk.__THUNK__ = exports.THUNK_SYMBOL;
-    return thunk;
-};
-exports.toThunk = toThunk;
-const trampoline = (fn) => {
-    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
-    return Object.assign((...args) => {
-        let result = fn(...args);
-        while ((0, exports.isThunk)(result)) {
-            result = result();
-        }
-        return result;
-    }, { cont });
-};
-exports.trampoline = trampoline;
-const trampolineAsync = (fn) => {
-    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
-    return Object.assign((...args) => __awaiter(void 0, void 0, void 0, function* () {
-        let result = yield fn(...args);
-        while ((0, exports.isThunk)(result)) {
-            result = yield result();
-        }
-        return result;
-    }), { cont });
-};
-exports.trampolineAsync = trampolineAsync;
-const factorial = (0, exports.trampoline)((n, acc = 1) => {
-    return n
-        // Note: calling factorial.cont instead of factorial directly
-        ? factorial.cont(n - 1, acc * n)
-        : acc;
-});
-// factorial(32768)

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

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