data-structure-typed 1.19.3 → 1.19.5

package/src/data-structures/trie/trie.ts

@@ -0,0 +1,227 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class TrieNode {
+
+    constructor(v: string) {
+        this._val = v;
+        this._isEnd = false;
+        this._children = new Map<string, TrieNode>();
+    }
+
+    private _val;
+
+    get val(): string {
+        return this._val;
+    }
+
+    set val(v: string) {
+        this._val = v;
+    }
+
+    protected _children: Map<string, TrieNode>;
+
+    get children(): Map<string, TrieNode> {
+        return this._children;
+    }
+
+    set children(v: Map<string, TrieNode>) {
+        this._children = v;
+    }
+
+    protected _isEnd: boolean;
+
+    get isEnd(): boolean {
+        return this._isEnd;
+    }
+
+    set isEnd(v: boolean) {
+        this._isEnd = v;
+    }
+
+}
+
+export class Trie {
+    constructor(words?: string[]) {
+        this._root = new TrieNode('');
+        if (words) {
+            for (const i of words) {
+                this.add(i);
+            }
+        }
+    }
+
+    protected _root: TrieNode;
+
+    get root() {
+        return this._root;
+    }
+
+    set root(v: TrieNode) {
+        this._root = v;
+    }
+
+    add(word: string): boolean {
+        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: string): boolean {
+        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: string) {
+        let isDeleted = false;
+        const dfs = (cur: TrieNode, i: number): boolean => {
+            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: string): boolean {
+        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: string): boolean {
+        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: string): boolean {
+        let commonPre = '';
+        const dfs = (cur: TrieNode) => {
+            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(): string {
+        let commonPre = '';
+        const dfs = (cur: TrieNode) => {
+            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 = ''): string[] {
+        const words: string[] = [];
+
+        function dfs(node: TrieNode, word: string) {
+            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;
+    }
+
+    // --- end additional methods ---
+}

package/src/data-structures/types/abstract-binary-tree.ts

@@ -0,0 +1,42 @@
+import {AbstractBinaryTreeNode} from '../binary-tree';
+
+/**
+ * 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 enum LoopType { ITERATIVE = 'ITERATIVE', RECURSIVE = 'RECURSIVE'}
+
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
+export 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 = 'id' | 'val';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = 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
+    | BinaryTreeNodeId;
+
+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,
+    autoIncrementId?: boolean,
+    isMergeDuplicatedVal?: boolean
+}

package/src/data-structures/types/abstract-graph.ts

@@ -0,0 +1,5 @@
+export type VertexId = string | number;
+export type EdgeId = string;
+export type DijkstraResult<V> =
+    { distMap: Map<V, number>, preMap: Map<V, V | null>, seen: Set<V>, paths: V[][], minDist: number, minPath: V[] }
+    | null;

package/src/data-structures/types/avl-tree.ts

@@ -0,0 +1,5 @@
+import {AVLTreeNode} from '../binary-tree';
+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/src/data-structures/types/binary-tree.ts

@@ -0,0 +1,9 @@
+import {BinaryTreeNode} from '../binary-tree';
+import {AbstractBinaryTreeOptions} from './abstract-binary-tree';
+
+
+// export type BinaryTreeDeleted<N> = { deleted: N | null | undefined, needBalanced: N | null };
+// export type ResultByProperty<N extends BinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+// export type ResultsByProperty<N extends BinaryTreeNode<N['val'], N>> = ResultByProperty<N>[];
+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/src/data-structures/types/bst.ts

@@ -0,0 +1,12 @@
+import {BSTNode} from '../binary-tree';
+import type {BinaryTreeOptions} from './binary-tree';
+import {BinaryTreeNodeId} from './abstract-binary-tree';
+
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => 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 enum CP {lt = 'lt', eq = 'eq', gt = 'gt'}

package/src/data-structures/types/directed-graph.ts

@@ -0,0 +1,8 @@
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;
+
+export enum TopologicalProperty {
+    VAL = 'VAL',
+    NODE = 'NODE',
+    ID = 'ID',
+}

package/src/data-structures/types/doubly-linked-list.ts

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

package/src/data-structures/types/heap.ts

@@ -0,0 +1,5 @@
+export type HeapOptions<T> = {
+    priorityExtractor?: (element: T) => number;
+    // TODO there is an idea that support chaining which is for conveniently using the data structure
+    // isChaining? : boolean
+}

package/src/data-structures/types/helpers.ts

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

package/src/data-structures/types/index.ts

@@ -0,0 +1,15 @@
+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 './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 './helpers';

package/src/data-structures/types/navigator.ts

@@ -0,0 +1,13 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+export type Turning = { [key in Direction]: Direction };
+
+export type NavigatorParams<T> = {
+    matrix: T[][],
+    turning: Turning,
+    onMove: (cur: [number, number]) => void
+    init: {
+        cur: [number, number],
+        charDir: Direction,
+        VISITED: T,
+    }
+}

package/src/data-structures/types/priority-queue.ts

@@ -0,0 +1,9 @@
+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/src/data-structures/types/rb-tree.ts

@@ -0,0 +1,8 @@
+import {BinaryTreeOptions} from './binary-tree';
+import {RBTreeNode} from '../binary-tree';
+
+export 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/src/data-structures/types/segment-tree.ts

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

package/src/data-structures/types/singly-linked-list.ts

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

package/src/data-structures/types/tree-multiset.ts

@@ -0,0 +1,8 @@
+import {TreeMultisetNode} from '../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, 'isMergeDuplicatedVal'> & {
+    isMergeDuplicatedVal: true,
+}

package/src/index.ts

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

package/src/utils/index.ts

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

package/src/utils/types/index.ts

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

package/src/utils/types/utils.ts

@@ -0,0 +1,6 @@
+export type ToThunkFn = () => ReturnType<TrlFn>;
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: Symbol };
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+
+export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/utils/types/validate-type.ts

@@ -0,0 +1,25 @@
+export type KeyValueObject = { [key: string]: any };
+
+export type KeyValueObjectWithId = { [key: string]: any, id: string | number | symbol };
+
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+
+export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
+
+export type ObjectWithNonNumberId = {
+    [key: string]: any,
+    id: string | boolean | symbol | null | object | undefined;
+}
+
+export type ObjectWithNumberId = {
+    [key: string]: any,
+    id: number;
+}
+
+export type RestrictValById =
+    NonNumberNonObjectButDefined
+    | ObjectWithoutId
+    | ObjectWithNonNumberId
+    | ObjectWithNumberId;
+
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | Function | never;

package/src/utils/utils.ts

@@ -0,0 +1,78 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from './types';
+
+export const uuidV4 = function () {
+    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);
+    });
+};
+
+export const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {
+    let i = -1, len = array ? array.length : 0;
+    const result = [];
+
+    while (++i < len) {
+        const value = array[i];
+        if (predicate(value, i, array)) {
+            result.push(value);
+            Array.prototype.splice.call(array, i--, 1);
+            len--;
+        }
+    }
+
+    return result;
+};
+
+
+export const THUNK_SYMBOL = Symbol('thunk')
+
+export const isThunk = (fnOrValue: any) => {
+    return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL
+}
+
+export const toThunk = (fn: ToThunkFn): Thunk => {
+    const thunk = () => fn()
+    thunk.__THUNK__ = THUNK_SYMBOL
+    return thunk
+}
+
+export const trampoline = (fn: TrlFn) => {
+    const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args))
+
+    return Object.assign(
+        (...args: [...Parameters<TrlFn>]) => {
+            let result = fn(...args)
+
+            while (isThunk(result) && typeof result === 'function') {
+                result = result()
+            }
+
+            return result
+        },
+        {cont}
+    )
+}
+
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+    const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args))
+
+    return Object.assign(
+        async (...args: [...Parameters<TrlAsyncFn>]) => {
+            let result = await fn(...args)
+
+            while (isThunk(result) && typeof result === 'function') {
+                result = await result()
+            }
+
+            return result
+        },
+        {cont}
+    )
+}

package/src/utils/validate-type.ts

@@ -0,0 +1,69 @@
+import {z} from 'zod';
+import {NonNumberNonObjectButDefined, ObjectWithNonNumberId, ObjectWithNumberId, ObjectWithoutId} from './types';
+
+
+export const nonNumberNonObjectButDefinedSchema = z.union([z.string(),
+    z.boolean(), z.any()])
+    .nullable()
+
+export const keyValueObjectSchema = z.record(z.unknown())
+
+export const objectWithoutIdSchema = keyValueObjectSchema.refine(obj => !('id' in obj), {
+    message: 'Object cannot contain the \'id\' field',
+});
+
+export const keyValueObjectWithIdSchema = z.record(z.any()).and(
+    z.object({
+        id: z.union([z.string(), z.number(), z.any()])
+    })
+)
+
+export const objectWithNonNumberIdSchema = z.record(z.any()).and(
+    z.object({
+        id: z
+            .union([z.string(), z.boolean(), z.any(), z.any(), z.undefined()])
+            .nullable()
+    })
+)
+
+export const objectWithNumberIdSchema = z.record(z.any()).and(
+    z.object({
+        id: z.number()
+    })
+)
+
+export const binaryTreeNodeValWithId = z.union([
+    nonNumberNonObjectButDefinedSchema,
+    objectWithoutIdSchema,
+    objectWithNonNumberIdSchema,
+    objectWithNumberIdSchema
+])
+
+export function parseBySchema(schema: z.Schema, val: any) {
+    try {
+        schema.parse(val);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+export function isNonNumberNonObjectButDefined(val: any): val is NonNumberNonObjectButDefined {
+    return parseBySchema(nonNumberNonObjectButDefinedSchema, val);
+}
+
+export function isObjectWithoutId(val: any): val is ObjectWithoutId {
+    return parseBySchema(objectWithoutIdSchema, val);
+}
+
+export function isObjectWithNonNumberId(val: any): val is ObjectWithNonNumberId {
+    return parseBySchema(objectWithNonNumberIdSchema, val);
+}
+
+export function isObjectWithNumberId(val: any): val is ObjectWithNumberId {
+    return parseBySchema(objectWithNonNumberIdSchema, val);
+}
+
+export function isNumber(val: any): val is number {
+    return typeof val === 'number';
+}

package/tsconfig.json

@@ -3,7 +3,7 @@
     "declaration": true,
     "outDir": "./dist",
     "module": "commonjs",
-    "target": "es5",
+    "target": "es6",
     "lib": [
 //      "es2015",
       "esnext"