semantic-typescript 0.4.1 → 0.5.0

package/dist/collector.js

@@ -297,7 +297,7 @@ export let useGroup = (classifier) => {
     }
     throw new TypeError("Classifier must be a function.");
 };
-export let useGroupBy = (keyExtractor, valueExtractor) => {
+export let useGroupBy = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
         return Collector.full(() => new Map(), (accumulator, element, index) => {
             let key = keyExtractor(element, index);
@@ -440,7 +440,7 @@ export let useToArray = () => {
     }, (array) => array);
 };
 ;
-export let useToMap = (keyExtractor, valueExtractor) => {
+export let useToMap = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
         return Collector.full(() => new Map(), (map, element, index) => {
             let key = keyExtractor(element, index);
@@ -452,7 +452,7 @@ export let useToMap = (keyExtractor, valueExtractor) => {
     throw new TypeError("Key extractor and value extractor must be functions.");
 };
 ;
-export let useToHashMap = (keyExtractor, valueExtractor) => {
+export let useToHashMap = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
         return Collector.full(() => new HashMap(), (map, element, index) => {
             let key = keyExtractor(element, index);

package/dist/factory.d.ts

@@ -8,6 +8,20 @@ interface Attribute<T> {
 export declare let attribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
 export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
+type KeyOfEventMap<T extends Window | Document | HTMLElement> = T extends Window ? keyof WindowEventMap : (T extends Document ? keyof DocumentEventMap : (T extends HTMLElement ? keyof HTMLElementEventMap : never));
+type ValueOfEventMap<T extends Window | Document | HTMLElement, K extends KeyOfEventMap<T>> = T extends Window ? (K extends keyof WindowEventMap ? WindowEventMap[K] : never) : (T extends Document ? (K extends keyof DocumentEventMap ? DocumentEventMap[K] : never) : (T extends HTMLElement ? (K extends keyof HTMLElementEventMap ? HTMLElementEventMap[K] : never) : never));
+interface EventFunction {
+    <E extends Window, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
+    <E extends Window, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
+    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: Iterable<E>, key: K): Semantic<V>;
+    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: Iterable<E>, key: Iterable<K>): Semantic<V>;
+}
+export declare let event: EventFunction;
 export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
 export interface From {
     <E>(iterable: Iterable<E>): Semantic<E>;

package/dist/factory.js

@@ -1,4 +1,4 @@
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable, isWindow, isString, isDocument } from "./guard";
 import { useCompare, useTraverse } from "./hook";
 import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
@@ -129,6 +129,164 @@ export let blob = (blob, chunk = 64n * 1024n) => {
 export let empty = () => {
     return new Semantic(() => { });
 };
+;
+export let event = (argument1, argument2) => {
+    if (isWindow(argument1)) {
+        let target = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let listener = (event) => {
+                        if (interrupt(event, index)) {
+                            target.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, index);
+                            index++;
+                        }
+                    };
+                    target.addEventListener(key, listener);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let key of keys) {
+                        if (isString(key)) {
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    target.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            target.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+    }
+    if (isDocument(argument1)) {
+        let target = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    let listener = (event) => {
+                        if (interrupt(event, index)) {
+                            target.removeEventListener(key, listener);
+                        }
+                        else {
+                            accept(event, index);
+                            index++;
+                        }
+                    };
+                    target.addEventListener(key, listener);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let key of keys) {
+                        if (isString(key)) {
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    target.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                    index++;
+                                }
+                            };
+                            target.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+    }
+    if (isIterable(argument1)) {
+        let targets = argument1;
+        if (isString(argument2)) {
+            let key = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let target of targets) {
+                        if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
+                            let listener = (event) => {
+                                if (interrupt(event, index)) {
+                                    target.removeEventListener(key, listener);
+                                }
+                                else {
+                                    accept(event, index);
+                                }
+                            };
+                            target.addEventListener(key, listener);
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+        if (isIterable(argument2)) {
+            let keys = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    for (let target of targets) {
+                        if (isObject(target) && isFunction(Reflect.get(target, "addEventListener"))) {
+                            for (let key of keys) {
+                                if (isString(key)) {
+                                    let listener = (event) => {
+                                        if (interrupt(event, index)) {
+                                            target.removeEventListener(key, listener);
+                                        }
+                                        else {
+                                            accept(event, index);
+                                            index++;
+                                        }
+                                    };
+                                    target.addEventListener(key, listener);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating event semantic.");
+                }
+            });
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
 export let fill = (element, count) => {
     if (validate(element) && count > 0n) {
         return new Semantic((accept, interrupt) => {

package/dist/guard.d.ts

@@ -1,12 +1,11 @@
-import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
+import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./collectable";
 import type { Collector } from "./collector";
-import type { Hashable } from "./hash";
 import type { HashMap, SemanticMap } from "./map";
+import type { BinaryNode, LinearNode, Node } from "./node";
+import type { Optional } from "./optional";
 import type { Semantic } from "./semantic";
 import type { HashSet } from "./set";
-import type { Statistics } from "./statistics";
 import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
-import type { WindowCollectable } from "./window";
 export declare let isBoolean: (target: unknown) => target is boolean;
 export declare let isString: (target: unknown) => target is string;
 export declare let isNumber: (target: unknown) => target is number;
@@ -27,10 +26,20 @@ export declare let isStatistics: (target: unknown) => target is Statistics<unkno
 export declare let isNumericStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
 export declare let isBigIntStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
 export declare let isSemanticMap: (target: unknown) => target is SemanticMap<unknown, unknown>;
-export declare let isHashable: (target: unknown) => target is Hashable;
 export declare let isHashMap: (target: unknown) => target is HashMap<unknown, unknown>;
 export declare let isHashSet: (target: unknown) => target is HashSet<unknown>;
+export declare let isNode: (target: unknown) => target is Node<unknown, any>;
+export declare let isLinearNode: (target: unknown) => target is LinearNode<unknown>;
+export declare let isBinaryNode: (target: unknown) => target is BinaryNode<unknown, any>;
+export declare let isRedBlackNode: (target: unknown) => target is BinaryNode<unknown, any>;
+export declare let isTree: (target: unknown) => target is Node<unknown, any>;
+export declare let isBinaryTree: (target: unknown) => target is Node<unknown, any>;
+export declare let isRedBlackTree: (target: unknown) => target is Node<unknown, any>;
+export declare let isOptional: <T>(target: unknown) => target is Optional<T>;
 export declare let isPromise: (target: unknown) => target is Promise<unknown>;
 export declare let isAsyncFunction: (target: unknown) => target is AsyncFunction;
 export declare let isGeneratorFunction: (target: unknown) => target is Generator<unknown, unknown, unknown>;
 export declare let isAsyncGeneratorFunction: (target: unknown) => target is AsyncGenerator<unknown, unknown, unknown>;
+export declare let isWindow: (target: unknown) => target is Window;
+export declare let isDocument: (target: unknown) => target is Document;
+export declare let isHTMLElemet: (target: unknown) => target is HTMLElement;

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, HashableSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticMapSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { BigIntStatisticsSymbol, BinaryNodeSymbol, CollectableSymbol, CollectorsSymbol, LinearNodeSymbol, NodeSymbol, NumericStatisticsSymbol, OptionalSymbol, OrderedCollectableSymbol, RedBlackNodeSymbol, SemanticMapSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
 export let isBoolean = (target) => {
     return typeof target === "boolean";
 };
@@ -95,12 +95,6 @@ export let isSemanticMap = (target) => {
     }
     return false;
 };
-export let isHashable = (target) => {
-    if (isObject(target)) {
-        return Reflect.get(target, HashableSymbol) === HashableSymbol;
-    }
-    return false;
-};
 export let isHashMap = (target) => {
     if (isObject(target)) {
         return Reflect.get(target, "HashMap") === SemanticMapSymbol;
@@ -113,6 +107,54 @@ export let isHashSet = (target) => {
     }
     return false;
 };
+export let isNode = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Node") === NodeSymbol;
+    }
+    return false;
+};
+export let isLinearNode = (target) => {
+    if (isObject(target)) {
+        return isNode(target) && Reflect.get(target, "LinearNode") === LinearNodeSymbol;
+    }
+    return false;
+};
+export let isBinaryNode = (target) => {
+    if (isObject(target)) {
+        return isNode(target) && Reflect.get(target, "BinaryNode") === BinaryNodeSymbol;
+    }
+    return false;
+};
+export let isRedBlackNode = (target) => {
+    if (isObject(target)) {
+        return isBinaryNode(target) && Reflect.get(target, "RedBlackNode") === RedBlackNodeSymbol;
+    }
+    return false;
+};
+export let isTree = (target) => {
+    if (isObject(target)) {
+        return isNode(target) && (isLinearNode(target) || isBinaryNode(target));
+    }
+    return false;
+};
+export let isBinaryTree = (target) => {
+    if (isObject(target)) {
+        return isNode(target) && isBinaryNode(target);
+    }
+    return false;
+};
+export let isRedBlackTree = (target) => {
+    if (isObject(target)) {
+        return isNode(target) && isRedBlackNode(target);
+    }
+    return false;
+};
+export let isOptional = (target) => {
+    if (isObject(target)) {
+        return Reflect.get(target, "Optional") === OptionalSymbol;
+    }
+    return false;
+};
 export let isPromise = (target) => {
     if (isObject(target)) {
         return isFunction(Reflect.get(target, "then")) && isFunction(Reflect.get(target, "catch"));
@@ -137,3 +179,22 @@ export let isAsyncGeneratorFunction = (target) => {
     }
     return false;
 };
+export let isWindow = (target) => {
+    if (isObject(target) && isObject(Reflect.get(target, "window"))) {
+        return Object.prototype.toString.call(Reflect.get(target, "window")) === "[object Window]";
+    }
+    return false;
+};
+export let isDocument = (target) => {
+    if (isObject(target) && isObject(Reflect.get(target, "document"))) {
+        return Object.prototype.toString.call(Reflect.get(target, "document")) === "[object HTMLDocument]";
+    }
+    return false;
+};
+export let isHTMLElemet = (target) => {
+    if (isObject(target)) {
+        let regex = /^\[object HTML\w+Element\]$/;
+        return regex.test(Object.prototype.toString.call(target));
+    }
+    return false;
+};

package/dist/hash.d.ts

@@ -1,6 +1,4 @@
 import { type Type } from "./utility";
-export interface Hashable {
-}
 export declare let maskOf: (type: Type) => bigint;
 interface Handler<T> {
     (value: T): bigint;
@@ -9,6 +7,7 @@ export declare let register: <T>(type: Type, handler: Handler<T>) => void;
 export declare let unregister: (type: Type) => void;
 interface UseHash {
     <T = unknown>(target: T): bigint;
+    (...value: Array<unknown>): bigint;
 }
 export declare let useHash: UseHash;
 export {};

package/dist/hash.js

@@ -1,8 +1,6 @@
-import { isBigInt, isBoolean, isFunction, isHashable, isNumber, isObject, isString, isSymbol } from "./guard";
+import { isBigInt, isBoolean, isFunction, isNumber, isObject, isString, isSymbol } from "./guard";
 import { useTraverse } from "./hook";
-import { HashableSymbol } from "./symbol";
 import { typeOf } from "./utility";
-;
 const masks = new Map();
 masks.set("undefined", BigInt(masks.size));
 masks.set("null", BigInt(masks.size));
@@ -14,7 +12,6 @@ masks.set("string", BigInt(masks.size));
 masks.set("function", BigInt(masks.size));
 masks.set("object", BigInt(masks.size));
 Object.freeze(masks);
-const internal = Object.freeze(Array.from(masks.keys()));
 export let maskOf = (type) => {
     return masks.get(type) || masks.get("object") || 0n;
 };
@@ -27,7 +24,8 @@ export let register = (type, handler) => {
     }
 };
 export let unregister = (type) => {
-    if (isString(type) && handlers.has(type) && !internal.includes(type)) {
+    let whiteList = ["undefined", "null", "boolean", "number", "bigint", "symbol", "string", "function", "object"];
+    if (isString(type) && handlers.has(type) && !whiteList.includes(type)) {
         handlers.delete(type);
     }
 };
@@ -196,16 +194,12 @@ register("object", (value) => {
     return 0n;
 });
 ;
-export let useHash = (target) => {
+export let useHash = (...value) => {
+    let target = value.length === 1 ? value[0] : value;
     let type = typeOf(target);
-    if (type === "object" && isHashable(target)) {
-        if (complex.has(target)) {
-            return complex.get(target) || 0n;
-        }
-        let hash = Reflect.get(target, HashableSymbol)();
-        complex.set(target, hash);
-        return hash;
+    let handler = handlers.get(type);
+    if (handler) {
+        return handler(target);
     }
-    let handler = handlers.get(type) || (() => 0n);
-    return handler(target);
+    return 0n;
 };

package/dist/index.d.ts

@@ -2,13 +2,8 @@ export * from "./collectable";
 export * from "./collector";
 export * from "./factory";
 export * from "./guard";
-export * from "./hash";
 export * from "./hook";
-export * from "./map";
 export * from "./optional";
 export * from "./semantic";
-export * from "./set";
 export * from "./symbol";
-export * from "./statistics";
 export * from "./utility";
-export * from "./window";

package/dist/index.js

@@ -2,13 +2,8 @@ export * from "./collectable";
 export * from "./collector";
 export * from "./factory";
 export * from "./guard";
-export * from "./hash";
 export * from "./hook";
-export * from "./map";
 export * from "./optional";
 export * from "./semantic";
-export * from "./set";
 export * from "./symbol";
-export * from "./statistics";
 export * from "./utility";
-export * from "./window";

package/dist/map.d.ts

@@ -70,3 +70,7 @@ export declare class HashMap<K, V> extends AbstractSemanticMap<K, V> {
     set(key: K, value: V): this;
     values(): IterableIterator<V>;
 }
+export declare class TreeMap<K, V> {
+    key: K;
+    value: V;
+}

package/dist/map.js

@@ -16,6 +16,7 @@ export class AbstractSemanticMap {
             writable: false,
             configurable: false
         });
+        Object.freeze(this);
     }
     compute(key, remapping) {
         let value = this.get(key);
@@ -127,6 +128,7 @@ export class HashMap extends AbstractSemanticMap {
             writable: false,
             configurable: false
         });
+        Object.freeze(this);
     }
     clear() {
         this.buckets.clear();
@@ -245,3 +247,7 @@ export class HashMap extends AbstractSemanticMap {
 Object.freeze(HashMap);
 Object.freeze(HashMap.prototype);
 Object.freeze(Object.getPrototypeOf(HashMap));
+export class TreeMap {
+    key = (void 0);
+    value = (void 0);
+}

package/dist/node.d.ts

@@ -0,0 +1,182 @@
+import { Optional } from "./optional";
+import { type Comparator } from "./utility";
+export interface Node<E, N extends Node<E, N>> extends Iterable<N> {
+    ancestors(): Iterable<N>;
+    children(): Iterable<N>;
+    descendants(): Iterable<N>;
+    siblings(): Iterable<N>;
+    parent(): Optional<N>;
+    root(): N;
+    previousSibling(): Optional<N>;
+    nextSibling(): Optional<N>;
+    preorder(): Generator<N>;
+    inorder(): Generator<N>;
+    postorder(): Generator<N>;
+    breadthfirst(): Generator<N>;
+    depth(): bigint;
+    height(): bigint;
+    width(): bigint;
+    level(): bigint;
+    isLeaf(): boolean;
+    isRoot(): boolean;
+    [Symbol.iterator](): Iterator<N>;
+}
+export declare abstract class AbstractNode<E, N extends Node<E, N>> implements Node<E, N> {
+    protected readonly Node: symbol;
+    constructor();
+    ancestors(): Iterable<N>;
+    abstract children(): Iterable<N>;
+    descendants(): Iterable<N>;
+    root(): N;
+    siblings(): Iterable<N>;
+    abstract parent(): Optional<N>;
+    previousSibling(): Optional<N>;
+    nextSibling(): Optional<N>;
+    preorder(): Generator<N>;
+    inorder(): Generator<N>;
+    postorder(): Generator<N>;
+    breadthfirst(): Generator<N>;
+    [Symbol.iterator](): Iterator<N>;
+    depth(): bigint;
+    height(): bigint;
+    width(): bigint;
+    level(): bigint;
+    isLeaf(): boolean;
+    isRoot(): boolean;
+}
+export declare class LinearNode<E> extends AbstractNode<E, LinearNode<E>> {
+    protected previous: Optional<LinearNode<E>>;
+    protected next: Optional<LinearNode<E>>;
+    protected element: Optional<E>;
+    protected readonly LinearNode: symbol;
+    constructor(element: E);
+    constructor(element: E, previous: Optional<LinearNode<E>>, next: Optional<LinearNode<E>>);
+    ancestors(): Iterable<LinearNode<E>>;
+    descendants(): Iterable<LinearNode<E>>;
+    root(): LinearNode<E>;
+    siblings(): Iterable<LinearNode<E>>;
+    children(): Iterable<LinearNode<E>>;
+    parent(): Optional<LinearNode<E>>;
+    [Symbol.iterator](): Iterator<LinearNode<E>>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getPrevious(): Optional<LinearNode<E>>;
+    setPrevious(previous: LinearNode<E>): void;
+    setPrevious(previous: Optional<LinearNode<E>>): void;
+    getNext(): Optional<LinearNode<E>>;
+    setNext(next: LinearNode<E>): void;
+    setNext(next: Optional<LinearNode<E>>): void;
+    linkPrevious(previous: LinearNode<E>): void;
+    unlinkPrevious(): void;
+    linkNext(next: LinearNode<E>): void;
+    unlinkNext(): void;
+}
+export declare abstract class BinaryNode<E, N extends BinaryNode<E, N>> extends AbstractNode<E, N> {
+    BinaryNode: symbol;
+    protected ancestor: Optional<N>;
+    protected left: Optional<N>;
+    protected right: Optional<N>;
+    protected element: Optional<E>;
+    constructor(element: E);
+    constructor(element: E, ancestor: Optional<N>, left: Optional<N>, right: Optional<N>);
+    ancestors(): Iterable<N>;
+    compare(other: N): bigint;
+    compare(other: N, comparator: Comparator<E>): bigint;
+    descendants(): Iterable<N>;
+    abstract identity(): N;
+    root(): N;
+    siblings(): Iterable<N>;
+    children(): Iterable<N>;
+    parent(): Optional<N>;
+    [Symbol.iterator](): Iterator<N>;
+    preorder(): Generator<N>;
+    inorder(): Generator<N>;
+    postorder(): Generator<N>;
+    breadthfirst(): Generator<N>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<N>;
+    setLeft(left: N): void;
+    setLeft(left: Optional<N>): void;
+    getRight(): Optional<N>;
+    setRight(right: N): void;
+    setRight(right: Optional<N>): void;
+    getAncestor(): Optional<N>;
+    setAncestor(ancestor: N): void;
+    setAncestor(ancestor: Optional<N>): void;
+    linkLeft(left: N): void;
+    unlinkLeft(): Optional<N>;
+    linkRight(right: N): void;
+    unlinkRight(): Optional<N>;
+    isLeftChild(): boolean;
+    isRightChild(): boolean;
+    detach(): void;
+    isBanlanced(): boolean;
+    isFull(): boolean;
+    isComplete(): boolean;
+    isPerfect(): boolean;
+    invert(): void;
+    invert(deep: boolean): void;
+}
+type Color = "RED" | "BLACK";
+export declare class RedBlackNode<E> extends BinaryNode<E, RedBlackNode<E>> {
+    protected readonly RedBlackNode: symbol;
+    protected color: Color;
+    constructor(element: E);
+    constructor(element: E, color: Color);
+    constructor(element: E, color: Color, ancestor: Optional<RedBlackNode<E>>, left: Optional<RedBlackNode<E>>, right: Optional<RedBlackNode<E>>);
+    identity(): RedBlackNode<E>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<RedBlackNode<E>>;
+    getRight(): Optional<RedBlackNode<E>>;
+    getColor(): Color;
+    setColor(color: Color): void;
+    isRed(): boolean;
+    isBlack(): boolean;
+    turnRed(): void;
+    turnBlack(): void;
+    toggle(): void;
+    compareAndLink(other: RedBlackNode<E>): void;
+    compareAndLink(other: RedBlackNode<E>, comparator: Comparator<E>): void;
+    rotate(): void;
+    rotateLeft(): RedBlackNode<E>;
+    rotateRight(): RedBlackNode<E>;
+    fix(): void;
+    uncle(): Optional<RedBlackNode<E>>;
+    findMinimum(): RedBlackNode<E>;
+    findMaximum(): RedBlackNode<E>;
+}
+export declare class AverageLevelNode<E> extends BinaryNode<E, AverageLevelNode<E>> {
+    constructor(element: E);
+    constructor(element: E, ancestor: Optional<AverageLevelNode<E>>, left: Optional<AverageLevelNode<E>>, right: Optional<AverageLevelNode<E>>);
+    [Symbol.iterator](): Iterator<AverageLevelNode<E>>;
+    identity(): AverageLevelNode<E>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<AverageLevelNode<E>>;
+    getRight(): Optional<AverageLevelNode<E>>;
+}
+export declare class BinarySearchNode<E> extends AbstractNode<E, BinarySearchNode<E>> {
+    protected left: Optional<BinarySearchNode<E>>;
+    protected right: Optional<BinarySearchNode<E>>;
+    protected element: Optional<E>;
+    constructor(element: E);
+    constructor(element: E, left: Optional<BinarySearchNode<E>>, right: Optional<BinarySearchNode<E>>);
+    ancestors(): Iterable<BinarySearchNode<E>>;
+    descendants(): Iterable<BinarySearchNode<E>>;
+    root(): BinarySearchNode<E>;
+    siblings(): Iterable<BinarySearchNode<E>>;
+    children(): Iterable<BinarySearchNode<E>>;
+    parent(): Optional<BinarySearchNode<E>>;
+    [Symbol.iterator](): Iterator<BinarySearchNode<E>>;
+    inorder(): Generator<BinarySearchNode<E>>;
+    preorder(): Generator<BinarySearchNode<E>>;
+    postorder(): Generator<BinarySearchNode<E>>;
+    breadthfirst(): Generator<BinarySearchNode<E>>;
+    getElement(): Optional<E>;
+    setElement(element: E): void;
+    getLeft(): Optional<BinarySearchNode<E>>;
+    getRight(): Optional<BinarySearchNode<E>>;
+}
+export {};