semantic-typescript 0.5.0 → 0.6.0

package/dist/guard.d.ts

@@ -1,10 +1,8 @@
-import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./collectable";
-import type { Collector } from "./collector";
-import type { HashMap, SemanticMap } from "./map";
-import type { BinaryNode, LinearNode, Node } from "./node";
+import type { AsynchronousCollector } from "./asynchronous/collector";
+import type { AsynchronousBigIntStatistics, AsynchronousNumericStatistics, AsynchronousOrderedCollectable, AsynchronousSemantic, AsynchronousStatistics, AsynchronousUnorderedCollectable, AsynchronousWindowCollectable } from "./asynchronous/semantic";
 import type { Optional } from "./optional";
-import type { Semantic } from "./semantic";
-import type { HashSet } from "./set";
+import type { SynchronousCollector } from "./synchronous/collector";
+import type { SynchronousBigIntStatistics, SynchronousNumericStatistics, SynchronousOrderedCollectable, SynchronousSemantic, SynchronousStatistics, SynchronousUnorderedCollectable, SynchronousWindowCollectable } from "./synchronous/semantic";
 import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
 export declare let isBoolean: (target: unknown) => target is boolean;
 export declare let isString: (target: unknown) => target is string;
@@ -14,28 +12,27 @@ export declare let isObject: (target: unknown) => target is object;
 export declare let isSymbol: (target: unknown) => target is symbol;
 export declare let isBigInt: (target: unknown) => target is bigint;
 export declare let isPrimitive: (target: MaybePrimitive<unknown>) => target is Primitive;
-export declare let isAsyncIterable: (target: unknown) => target is Iterable<unknown>;
+export declare let isAsyncIterable: (target: unknown) => target is AsyncIterable<unknown>;
 export declare let isIterable: (target: unknown) => target is Iterable<unknown>;
-export declare let isSemantic: (target: unknown) => target is Semantic<unknown>;
-export declare let isCollector: (target: unknown) => target is Collector<unknown, unknown, unknown>;
-export declare let isCollectable: (target: unknown) => target is Collectable<unknown>;
-export declare let isOrderedCollectable: (target: unknown) => target is OrderedCollectable<unknown>;
-export declare let isWindowCollectable: (target: unknown) => target is WindowCollectable<unknown>;
-export declare let isUnorderedCollectable: (target: unknown) => target is UnorderedCollectable<unknown>;
-export declare let isStatistics: (target: unknown) => target is Statistics<unknown, number | bigint>;
-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 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 isAsynchronousSemantic: (target: unknown) => target is AsynchronousSemantic<unknown>;
+export declare let isSynchronousSemantic: (target: unknown) => target is SynchronousSemantic<unknown>;
+export declare let isAsynchronousCollectable: (target: unknown) => target is AsynchronousSemantic<unknown>;
+export declare let isSynchronousCollectable: (target: unknown) => target is SynchronousSemantic<unknown>;
+export declare let isAsynchronousOrderedCollectable: (target: unknown) => target is AsynchronousOrderedCollectable<unknown>;
+export declare let isSynchronousOrderedCollectable: (target: unknown) => target is SynchronousOrderedCollectable<unknown>;
+export declare let isAsynchronousUnorderedCollectable: (target: unknown) => target is AsynchronousUnorderedCollectable<unknown>;
+export declare let isSynchronousUnorderedCollectable: (target: unknown) => target is SynchronousUnorderedCollectable<unknown>;
+export declare let isAsynchronousStatistics: (target: unknown) => target is AsynchronousStatistics<unknown, number | bigint>;
+export declare let isSynchronousStatistics: (target: unknown) => target is SynchronousStatistics<unknown, number | bigint>;
+export declare let isAsynchronousBigIntStatistics: (target: unknown) => target is AsynchronousBigIntStatistics<unknown>;
+export declare let isSynchronousBigIntStatistics: (target: unknown) => target is SynchronousBigIntStatistics<unknown>;
+export declare let isAsynchronousNumericStatistics: (target: unknown) => target is AsynchronousNumericStatistics<unknown>;
+export declare let isSynchronousNumericStatistics: (target: unknown) => target is SynchronousNumericStatistics<unknown>;
+export declare let isAsynchronousWindowCollectable: (target: unknown) => target is AsynchronousWindowCollectable<unknown>;
+export declare let isSynchronousWindowCollectable: (target: unknown) => target is SynchronousWindowCollectable<unknown>;
+export declare let isSynchronousCollector: (target: unknown) => target is SynchronousCollector<unknown, unknown, unknown>;
+export declare let isAsynchronousCollector: (target: unknown) => target is AsynchronousCollector<unknown, unknown, unknown>;
+export declare let isOptional: (target: unknown) => target is Optional<unknown>;
 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>;

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, BinaryNodeSymbol, CollectableSymbol, CollectorsSymbol, LinearNodeSymbol, NodeSymbol, NumericStatisticsSymbol, OptionalSymbol, OrderedCollectableSymbol, RedBlackNodeSymbol, SemanticMapSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { AsynchronousBigIntStatisticsSymbol, AsynchronousCollectorSymbol, AsynchronousNumericStatisticsSymbol, AsynchronousOrderedCollectableSymbol, AsynchronousSemanticSymbol, AsynchronousStatisticsSymbol, AsynchronousUnorderedCollectableSymbol, AsynchronousWindowCollectableSymbol, OptionalSymbol, SynchronousBigIntStatisticsSymbol, SynchronousCollectorSymbol, SynchronousNumericStatisticsSymbol, SynchronousOrderedCollectableSymbol, SynchronousSemanticSymbol, SynchronousStatisticsSymbol, SynchronousUnorderedCollectableSymbol, SynchronousWindowCollectableSymbol } from "./symbol";
 export let isBoolean = (target) => {
     return typeof target === "boolean";
 };
@@ -35,117 +35,111 @@ export let isIterable = (target) => {
     }
     return false;
 };
-export let isSemantic = (target) => {
+export let isAsynchronousSemantic = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Semantic") === SemanticSymbol;
+        return Reflect.get(target, "AsynchronousSemantic") === AsynchronousSemanticSymbol;
     }
     return false;
 };
-export let isCollector = (target) => {
+export let isSynchronousSemantic = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Collector") === CollectorsSymbol;
+        return Reflect.get(target, "SynchronousSemantic") === SynchronousSemanticSymbol;
     }
     return false;
 };
-export let isCollectable = (target) => {
+export let isAsynchronousCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Collectable") === CollectableSymbol;
+        return Reflect.get(target, "AsynchronousCollectable") === AsynchronousSemanticSymbol || isAsynchronousSemantic(target) || isAsynchronousOrderedCollectable(target) || isAsynchronousUnorderedCollectable(target) || isAsynchronousStatistics(target) || isAsynchronousNumericStatistics(target) || isAsynchronousBigIntStatistics(target) || isAsynchronousWindowCollectable(target);
     }
     return false;
 };
-export let isOrderedCollectable = (target) => {
+export let isSynchronousCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "OrderedCollectable") === OrderedCollectableSymbol;
+        return Reflect.get(target, "SynchronousCollectable") === SynchronousSemanticSymbol || isSynchronousSemantic(target) || isSynchronousOrderedCollectable(target) || isSynchronousUnorderedCollectable(target) || isSynchronousStatistics(target) || isSynchronousNumericStatistics(target) || isSynchronousBigIntStatistics(target) || isSynchronousWindowCollectable(target);
     }
     return false;
 };
-export let isWindowCollectable = (target) => {
+export let isAsynchronousOrderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "WindowCollectable") === WindowCollectableSymbol;
+        return Reflect.get(target, "AsynchronousOrderedCollectable") === AsynchronousOrderedCollectableSymbol;
     }
     return false;
 };
-export let isUnorderedCollectable = (target) => {
+export let isSynchronousOrderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "UnorderedCollectable") === UnorderedCollectableSymbol;
+        return Reflect.get(target, "SynchronousOrderedCollectable") === SynchronousOrderedCollectableSymbol;
     }
     return false;
 };
-export let isStatistics = (target) => {
+export let isAsynchronousUnorderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Statistics") === StatisticsSymbol;
+        return Reflect.get(target, "AsynchronousUnorderedCollectable") === AsynchronousUnorderedCollectableSymbol;
     }
     return false;
 };
-export let isNumericStatistics = (target) => {
+export let isSynchronousUnorderedCollectable = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "NumericStatistics") === NumericStatisticsSymbol;
+        return Reflect.get(target, "SynchronousUnorderedCollectable") === SynchronousUnorderedCollectableSymbol;
     }
     return false;
 };
-export let isBigIntStatistics = (target) => {
+export let isAsynchronousStatistics = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "BigIntStatistics") === BigIntStatisticsSymbol;
+        return Reflect.get(target, "AsynchronousStatistics") === AsynchronousStatisticsSymbol;
     }
     return false;
 };
-export let isSemanticMap = (target) => {
+export let isSynchronousStatistics = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "SemanticMap") === SemanticMapSymbol;
+        return Reflect.get(target, "SynchronousStatistics") === SynchronousStatisticsSymbol;
     }
     return false;
 };
-export let isHashMap = (target) => {
+export let isAsynchronousBigIntStatistics = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "HashMap") === SemanticMapSymbol;
+        return Reflect.get(target, "AsynchronousBigIntStatistics") === AsynchronousBigIntStatisticsSymbol;
     }
     return false;
 };
-export let isHashSet = (target) => {
+export let isSynchronousBigIntStatistics = (target) => {
     if (isObject(target)) {
-        return false;
+        return Reflect.get(target, "SynchronousBigIntStatistics") === SynchronousBigIntStatisticsSymbol;
     }
     return false;
 };
-export let isNode = (target) => {
+export let isAsynchronousNumericStatistics = (target) => {
     if (isObject(target)) {
-        return Reflect.get(target, "Node") === NodeSymbol;
+        return Reflect.get(target, "AsynchronousBigIntStatistics") === AsynchronousNumericStatisticsSymbol;
     }
     return false;
 };
-export let isLinearNode = (target) => {
+export let isSynchronousNumericStatistics = (target) => {
     if (isObject(target)) {
-        return isNode(target) && Reflect.get(target, "LinearNode") === LinearNodeSymbol;
+        return Reflect.get(target, "AsynchronousNumericStatistics") === SynchronousNumericStatisticsSymbol;
     }
     return false;
 };
-export let isBinaryNode = (target) => {
+export let isAsynchronousWindowCollectable = (target) => {
     if (isObject(target)) {
-        return isNode(target) && Reflect.get(target, "BinaryNode") === BinaryNodeSymbol;
+        return Reflect.get(target, "AsynchronousWindowCollectable") === AsynchronousWindowCollectableSymbol;
     }
     return false;
 };
-export let isRedBlackNode = (target) => {
+export let isSynchronousWindowCollectable = (target) => {
     if (isObject(target)) {
-        return isBinaryNode(target) && Reflect.get(target, "RedBlackNode") === RedBlackNodeSymbol;
+        return Reflect.get(target, "SynchronousWindowCollectable") === SynchronousWindowCollectableSymbol;
     }
     return false;
 };
-export let isTree = (target) => {
+export let isSynchronousCollector = (target) => {
     if (isObject(target)) {
-        return isNode(target) && (isLinearNode(target) || isBinaryNode(target));
+        return Reflect.get(target, "SynchronousCollector") === SynchronousCollectorSymbol;
     }
     return false;
 };
-export let isBinaryTree = (target) => {
+export let isAsynchronousCollector = (target) => {
     if (isObject(target)) {
-        return isNode(target) && isBinaryNode(target);
-    }
-    return false;
-};
-export let isRedBlackTree = (target) => {
-    if (isObject(target)) {
-        return isNode(target) && isRedBlackNode(target);
+        return Reflect.get(target, "AsynchronousCollector") === AsynchronousCollectorSymbol;
     }
     return false;
 };

package/dist/hook.d.ts

@@ -1,7 +1,11 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
-import type { Comparator, Generator } from "./utility";
+import type { Comparator, SynchronousGenerator } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
-export declare let Useandom: <T = number | bigint>(index: T) => T;
+interface UseRandom {
+    <N extends number | bigint>(start: N): N extends number ? number : (N extends bigint ? bigint : never);
+    <N extends number | bigint>(start: N, end: N): N;
+}
+export declare let useRandom: UseRandom;
 export type UseTraverseKey<T extends object> = DeepPropertyKey<T> & (symbol | string | number);
 export type UseTraverseValue<T extends object> = DeepPropertyValue<T>;
 export type UseTraversePath<T extends object> = Array<UseTraverseKey<T> & (symbol | string | number)>;
@@ -16,12 +20,12 @@ interface UseTraverse {
     <T extends object>(t: T, callback: UseTraversePathCallback<T>): void;
 }
 export declare let useTraverse: UseTraverse;
-export declare let useGenerator: <E>(iterable: Iterable<E>) => Generator<E>;
+export declare let useGenerator: <E>(iterable: Iterable<E>) => SynchronousGenerator<E>;
 interface UseArrange {
-    <E>(source: Iterable<E>): Generator<E>;
-    <E>(source: Iterable<E>, comparator: Comparator<E>): Generator<E>;
-    <E>(source: Generator<E>): Generator<E>;
-    <E>(source: Generator<E>, comparator: Comparator<E>): Generator<E>;
+    <E>(source: Iterable<E>): SynchronousGenerator<E>;
+    <E>(source: Iterable<E>, comparator: Comparator<E>): SynchronousGenerator<E>;
+    <E>(source: SynchronousGenerator<E>): SynchronousGenerator<E>;
+    <E>(source: SynchronousGenerator<E>, comparator: Comparator<E>): SynchronousGenerator<E>;
 }
 export declare let useArrange: UseArrange;
 export declare let useToNumber: <T = unknown>(target: T) => number;

package/dist/hook.js

@@ -1,4 +1,4 @@
-import { useToArray } from "./collector";
+import { useSynchronousToArray } from "./synchronous/collector";
 import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
 import { invalidate, validate } from "./utility";
 export let useCompare = (t1, t2) => {
@@ -44,28 +44,81 @@ export let useCompare = (t1, t2) => {
     }
     throw new TypeError("Cannot compare values of different types.");
 };
-export let Useandom = (index) => {
-    if (isNumber(index)) {
-        let x = Number(index);
-        let phi = (1 + Math.sqrt(5)) / 2;
-        let vanDerCorput = (base, n) => {
-            let result = 0;
-            let f = 1 / base;
-            let i = n;
-            while (i > 0) {
-                result += (i % base) * f;
-                i = Math.floor(i / base);
-                f = f / base;
+;
+export let useRandom = (start, end) => {
+    let getRandomBits = () => {
+        let random = Math.random();
+        let full = random * 0x10000000000000;
+        let high = Math.floor(full / 0x100000000);
+        let low = Math.floor(full) & 0xFFFFFFFF;
+        return [high, low];
+    };
+    let getRandomBigInt = () => {
+        let [h1, l1] = getRandomBits();
+        let [h2, l2] = getRandomBits();
+        let [h3, l3] = getRandomBits();
+        return ((BigInt(h1) << 84n) | (BigInt(l1) << 52n) | (BigInt(h2) << 32n) | (BigInt(l2) << 3n) | (BigInt(h3) << 116n)) | (BigInt(l3) << 80n);
+    };
+    if (isNumber(start)) {
+        let seed = Math.random();
+        if (isNumber(end)) {
+            let minimum = Math.min(start, end);
+            let maximum = Math.max(start, end);
+            let range = maximum - minimum;
+            return (minimum + seed * range);
+        }
+        else {
+            return Math.exp(-seed);
+        }
+    }
+    if (isBigInt(start)) {
+        let randomBigInt = getRandomBigInt();
+        if (isBigInt(end)) {
+            let minimum = start < end ? start : end;
+            let maximum = start < end ? end : start;
+            let range = maximum - minimum;
+            if (range === 0n) {
+                return minimum;
+            }
+            let mask = range;
+            mask |= mask >> 1n;
+            mask |= mask >> 2n;
+            mask |= mask >> 4n;
+            mask |= mask >> 8n;
+            mask |= mask >> 16n;
+            mask |= mask >> 32n;
+            mask |= mask >> 64n;
+            let result;
+            do {
+                let raw = randomBigInt & mask;
+                result = raw;
+                result ^= result >> 17n;
+                result *= 0xed5ad4bbn;
+                result ^= result >> 11n;
+                result *= 0xac4c1b51n;
+                result ^= result >> 15n;
+                result *= 0x31848babn;
+                result ^= result >> 14n;
+            } while (result >= range);
+            return (minimum + result);
+        }
+        else {
+            let seed = Math.random();
+            let expValue = Math.exp(-seed);
+            let normalized = expValue / Math.E;
+            let [high, low] = getRandomBits();
+            let adjusted = BigInt(Math.floor(normalized * 0xFFFFFFFF)) << 32n;
+            let result = (adjusted | BigInt(low)) ^ BigInt(high);
+            if (start <= 0n) {
+                return 0n;
+            }
+            if (result >= start) {
+                result = result % start;
             }
             return result;
-        };
-        let h = vanDerCorput(2, x) + vanDerCorput(3, x);
-        let golden = (x * phi) % 1;
-        let lcg = (1103515245 * x + 12345) % 2147483648;
-        let mixed = (h * 0.5 + golden * 0.3 + lcg / 2147483648 * 0.2);
-        return (mixed * 1000000);
+        }
     }
-    throw new TypeError("Invalid input type");
+    throw new TypeError("Invalid arguments.");
 };
 ;
 ;
@@ -157,7 +210,7 @@ export let useArrange = (source, comparator) => {
         }
     }
     else if (isFunction(source)) {
-        let collector = useToArray();
+        let collector = useSynchronousToArray();
         let buffer = collector.collect(source);
         if (validate(comparator) && isFunction(comparator)) {
             return useGenerator(buffer.sort(comparator));

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-export * from "./collectable";
-export * from "./collector";
+export * from "./asynchronous/collector";
+export * from "./synchronous/collector";
 export * from "./factory";
 export * from "./guard";
 export * from "./hook";
 export * from "./optional";
-export * from "./semantic";
 export * from "./symbol";
 export * from "./utility";

package/dist/index.js

@@ -1,9 +1,8 @@
-export * from "./collectable";
-export * from "./collector";
+export * from "./asynchronous/collector";
+export * from "./synchronous/collector";
 export * from "./factory";
 export * from "./guard";
 export * from "./hook";
 export * from "./optional";
-export * from "./semantic";
 export * from "./symbol";
 export * from "./utility";

package/dist/optional.d.ts

@@ -1,12 +1,12 @@
-import type { Semantic } from "./semantic";
-import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable } from "./utility";
+import type { SynchronousSemantic } from "./synchronous/semantic";
+import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable, type Valid } from "./utility";
 export declare class Optional<T> {
     protected value: MaybeInvalid<T>;
     protected readonly Optional: Symbol;
     protected constructor(value: MaybeInvalid<T>);
     filter(predicate: Predicate<T>): Optional<T>;
-    get(): T;
-    get(defaultValue: T): T;
+    get(): Valid<T>;
+    get(defaultValue: T): Valid<T>;
     ifPresent(action: Consumer<T>): void;
     ifPresent(action: Consumer<T>, elseAction: Runnable): void;
     isEmpty(): boolean;
@@ -15,7 +15,7 @@ export declare class Optional<T> {
     flat(mapper: Functional<T, Optional<T>>): Optional<T>;
     flatMap<R>(mapper: Functional<T, Optional<R>>): Optional<R>;
     orElse(other: MaybeInvalid<T>): MaybeInvalid<T>;
-    semantic(): Semantic<T>;
+    semantic(): SynchronousSemantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;

package/dist/optional.js

@@ -1,5 +1,5 @@
-import { empty, generate } from "./factory";
-import { isFunction } from "./guard";
+import { useEmpty, useOf } from "./factory";
+import { isFunction, isOptional } from "./guard";
 import { OptionalSymbol } from "./symbol";
 import { invalidate, validate } from "./utility";
 export class Optional {
@@ -64,13 +64,21 @@ export class Optional {
     }
     flat(mapper) {
         if (this.isPresent() && isFunction(mapper)) {
-            return mapper(this.value);
+            let result = mapper(this.value);
+            if (isOptional(result)) {
+                return result;
+            }
+            throw new TypeError("Must return an Optional.");
         }
         return new Optional(null);
     }
     flatMap(mapper) {
         if (this.isPresent() && isFunction(mapper)) {
-            return mapper(this.value);
+            let result = mapper(this.value);
+            if (isOptional(result)) {
+                return result;
+            }
+            throw new TypeError("Must return an Optional.");
         }
         return new Optional(null);
     }
@@ -82,13 +90,9 @@ export class Optional {
     }
     semantic() {
         if (this.isPresent()) {
-            return generate(() => {
-                return this.value;
-            }, () => {
-                return this.isEmpty();
-            });
+            return useOf(this.value);
         }
-        return empty();
+        return useEmpty();
     }
     static empty() {
         return new Optional(null);

package/dist/symbol.d.ts

@@ -1,24 +1,20 @@
 export declare let OptionalSymbol: symbol;
-export declare let SemanticSymbol: symbol;
-export declare let CollectorsSymbol: symbol;
-export declare let CollectableSymbol: symbol;
-export declare let OrderedCollectableSymbol: symbol;
-export declare let WindowCollectableSymbol: symbol;
-export declare let StatisticsSymbol: symbol;
-export declare let NumericStatisticsSymbol: symbol;
-export declare let BigIntStatisticsSymbol: symbol;
-export declare let UnorderedCollectableSymbol: symbol;
-export declare let SemanticMapSymbol: symbol;
-export declare let HashMapSymbol: symbol;
-export declare let HashSetSymbol: symbol;
-export declare let TreeMapSymbol: symbol;
-export declare let TreeSetSymbol: symbol;
-export declare let NodeSymbol: symbol;
-export declare let LinearNodeSymbol: symbol;
-export declare let BinaryNodeSymbol: symbol;
-export declare let RedBlackNodeSymbol: symbol;
-export declare let AverageLevelNodeSymbol: symbol;
-export declare let TreeSymbol: symbol;
-export declare let BinaryTreeSymbol: symbol;
-export declare let RedBlackTreeSymbol: symbol;
-export declare let AVLTreeSymbol: symbol;
+export declare let AsynchronousSemanticSymbol: symbol;
+export declare let SynchronousSemanticSymbol: symbol;
+export declare let AsynchronousCollectorSymbol: symbol;
+export declare let SynchronousCollectorSymbol: symbol;
+export declare let DispatchCollectableSymbol: symbol;
+export declare let AsynchronousCollectableSymbol: symbol;
+export declare let SynchronousCollectableSymbol: symbol;
+export declare let AsynchronousOrderedCollectableSymbol: symbol;
+export declare let SynchronousOrderedCollectableSymbol: symbol;
+export declare let AsynchronousUnorderedCollectableSymbol: symbol;
+export declare let SynchronousUnorderedCollectableSymbol: symbol;
+export declare let AsynchronousWindowCollectableSymbol: symbol;
+export declare let SynchronousWindowCollectableSymbol: symbol;
+export declare let AsynchronousStatisticsSymbol: symbol;
+export declare let SynchronousStatisticsSymbol: symbol;
+export declare let AsynchronousNumericStatisticsSymbol: symbol;
+export declare let SynchronousNumericStatisticsSymbol: symbol;
+export declare let AsynchronousBigIntStatisticsSymbol: symbol;
+export declare let SynchronousBigIntStatisticsSymbol: symbol;

package/dist/symbol.js

@@ -1,24 +1,20 @@
 export let OptionalSymbol = Symbol.for("Optional");
-export let SemanticSymbol = Symbol.for("Semantic");
-export let CollectorsSymbol = Symbol.for("Collector");
-export let CollectableSymbol = Symbol.for("Collectable");
-export let OrderedCollectableSymbol = Symbol.for("OrderedCollectable");
-export let WindowCollectableSymbol = Symbol.for("WindowCollectable");
-export let StatisticsSymbol = Symbol.for("Statistics");
-export let NumericStatisticsSymbol = Symbol.for("NumericStatistics");
-export let BigIntStatisticsSymbol = Symbol.for("BigIntStatistics");
-export let UnorderedCollectableSymbol = Symbol.for("UnorderedCollectable");
-export let SemanticMapSymbol = Symbol.for("SemanticMap");
-export let HashMapSymbol = Symbol.for("HashMap");
-export let HashSetSymbol = Symbol.for("HashSet");
-export let TreeMapSymbol = Symbol.for("TreeMap");
-export let TreeSetSymbol = Symbol.for("TreeSet");
-export let NodeSymbol = Symbol.for("Node");
-export let LinearNodeSymbol = Symbol.for("LinearNode");
-export let BinaryNodeSymbol = Symbol.for("BinaryNode");
-export let RedBlackNodeSymbol = Symbol.for("RedBlackNode");
-export let AverageLevelNodeSymbol = Symbol.for("AverageLevelNode");
-export let TreeSymbol = Symbol.for("Tree");
-export let BinaryTreeSymbol = Symbol.for("BinaryTree");
-export let RedBlackTreeSymbol = Symbol.for("RedBlackTree");
-export let AVLTreeSymbol = Symbol.for("AVLTree");
+export let AsynchronousSemanticSymbol = Symbol.for("AsynchronousSemantic");
+export let SynchronousSemanticSymbol = Symbol.for("SynchronousSemantic");
+export let AsynchronousCollectorSymbol = Symbol.for("AsynchronousCollector");
+export let SynchronousCollectorSymbol = Symbol.for("SynchronousCollector");
+export let DispatchCollectableSymbol = Symbol.for("DispatchCollectable");
+export let AsynchronousCollectableSymbol = Symbol.for("AsynchronousCollectable");
+export let SynchronousCollectableSymbol = Symbol.for("SynchronousCollectable");
+export let AsynchronousOrderedCollectableSymbol = Symbol.for("OrderedAsynchronousCollectable");
+export let SynchronousOrderedCollectableSymbol = Symbol.for("OrderedSynchronousCollectable");
+export let AsynchronousUnorderedCollectableSymbol = Symbol.for("AsynchronousUnorderedCollectable");
+export let SynchronousUnorderedCollectableSymbol = Symbol.for("SynchronousUnorderedCollectable");
+export let AsynchronousWindowCollectableSymbol = Symbol.for("AsynchronousWindowCollectable");
+export let SynchronousWindowCollectableSymbol = Symbol.for("SynchronousWindowCollectable");
+export let AsynchronousStatisticsSymbol = Symbol.for("AsynchronousStatistics");
+export let SynchronousStatisticsSymbol = Symbol.for("AsynchronousStatistics");
+export let AsynchronousNumericStatisticsSymbol = Symbol.for("AsynchronousNumericStatistics");
+export let SynchronousNumericStatisticsSymbol = Symbol.for("SynchronousNumericStatisticsSymbol");
+export let AsynchronousBigIntStatisticsSymbol = Symbol.for("AsynchronousBigIntStatistics");
+export let SynchronousBigIntStatisticsSymbol = Symbol.for("SynchronousBigIntStatisticsSymbol");