semantic-typescript 0.5.0 → 0.5.3

package/dist/guard.d.ts

@@ -1,10 +1,7 @@
-import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./collectable";
+import type { Collectable, OrderedCollectable, Statistics, UnorderedCollectable, WindowCollectable } from "./semantic";
 import type { Collector } from "./collector";
-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 { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
 export declare let isBoolean: (target: unknown) => target is boolean;
 export declare let isString: (target: unknown) => target is string;
@@ -25,16 +22,6 @@ export declare let isUnorderedCollectable: (target: unknown) => target is Unorde
 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 isPromise: (target: unknown) => target is Promise<unknown>;
 export declare let isAsyncFunction: (target: unknown) => target is AsyncFunction;

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 { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OptionalSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
 export let isBoolean = (target) => {
     return typeof target === "boolean";
 };
@@ -89,66 +89,6 @@ export let isBigIntStatistics = (target) => {
     }
     return false;
 };
-export let isSemanticMap = (target) => {
-    if (isObject(target)) {
-        return Reflect.get(target, "SemanticMap") === SemanticMapSymbol;
-    }
-    return false;
-};
-export let isHashMap = (target) => {
-    if (isObject(target)) {
-        return Reflect.get(target, "HashMap") === SemanticMapSymbol;
-    }
-    return false;
-};
-export let isHashSet = (target) => {
-    if (isObject(target)) {
-        return false;
-    }
-    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;

package/dist/hook.d.ts

@@ -1,7 +1,11 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
 import type { Comparator, Generator } 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)>;

package/dist/hook.js

@@ -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.");
 };
 ;
 ;

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./collectable";
 export * from "./collector";
 export * from "./factory";
 export * from "./guard";

package/dist/index.js

@@ -1,4 +1,3 @@
-export * from "./collectable";
 export * from "./collector";
 export * from "./factory";
 export * from "./guard";

package/dist/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,4 @@
+import { useWindow } from 'semantic-typescript';
+useWindow("click").toEvent().forEach((event, index) => {
+    console.log(event.type + `第${index}次触发`);
+});

package/dist/map.js

@@ -16,7 +16,6 @@ export class AbstractSemanticMap {
             writable: false,
             configurable: false
         });
-        Object.freeze(this);
     }
     compute(key, remapping) {
         let value = this.get(key);
@@ -84,9 +83,6 @@ export class AbstractSemanticMap {
     [Symbol.toStringTag] = "SemanticMap";
 }
 ;
-Object.freeze(AbstractSemanticMap);
-Object.freeze(AbstractSemanticMap.prototype);
-Object.freeze(Object.getPrototypeOf(AbstractSemanticMap));
 export class HashMap extends AbstractSemanticMap {
     buckets = new Map();
     threashold;
@@ -128,7 +124,6 @@ export class HashMap extends AbstractSemanticMap {
             writable: false,
             configurable: false
         });
-        Object.freeze(this);
     }
     clear() {
         this.buckets.clear();
@@ -244,9 +239,6 @@ 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/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 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;

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/semantic.d.ts

@@ -1,6 +1,7 @@
-import { BigIntStatistics, Collectable, NumericStatistics, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
+import { Collector } from "./collector";
+import type { Optional } from "./optional";
 import { type Predicate } from "./utility";
-import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate } from "./utility";
+import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate, Indexed, Supplier, TriFunctional, TriPredicate } from "./utility";
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;
@@ -42,6 +43,7 @@ export declare class Semantic<E> {
     toCollectable(): Collectable<E>;
     toCollectable<C extends Collectable<E>>(mapper: Functional<Generator<E>, C>): C;
     toBigintStatistics(): BigIntStatistics<E>;
+    toEvent(): EventCollectable<E>;
     toNumericStatistics(): NumericStatistics<E>;
     toOrdered(): OrderedCollectable<E>;
     toUnordered(): UnorderedCollectable<E>;
@@ -50,3 +52,203 @@ export declare class Semantic<E> {
     translate(offset: bigint): Semantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): Semantic<E>;
 }
+export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterable<E> {
+    protected readonly Collectable: symbol;
+    constructor();
+    abstract [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    abstract [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    anyMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: Predicate<E>): boolean;
+    collect<A, R>(collector: Collector<E, A, R>): R;
+    collect<A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    count(): bigint;
+    error(): void;
+    error(accumulator: BiFunctional<string, E, string>): void;
+    error(accumulator: TriFunctional<string, E, bigint, string>): void;
+    error(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): void;
+    error(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
+    isEmpty(): boolean;
+    findAny(): Optional<E>;
+    findAt(index: number): Optional<E>;
+    findAt(index: bigint): Optional<E>;
+    findFirst(): Optional<E>;
+    findLast(): Optional<E>;
+    findMaximum(): Optional<E>;
+    findMaximum(comparator: Comparator<E>): Optional<E>;
+    findMinimum(): Optional<E>;
+    findMinimum(comparator: Comparator<E>): Optional<E>;
+    forEach(action: Consumer<E>): void;
+    forEach(action: BiConsumer<E, bigint>): void;
+    group<K>(classifier: Functional<E, K>): Map<K, Array<E>>;
+    group<K>(classifier: BiFunctional<E, bigint, K>): Map<K, Array<E>>;
+    groupBy<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, Array<V>>;
+    groupBy<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, K>): Map<K, Array<V>>;
+    join(): string;
+    join(delimiter: string): string;
+    join(prefix: string, delimiter: string, suffix: string): string;
+    join(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): string;
+    join(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): string;
+    log(): void;
+    log(accumulator: BiFunctional<string, E, string>): void;
+    log(accumulator: TriFunctional<string, E, bigint, string>): void;
+    log(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): void;
+    log(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
+    nonMatch(predicate: Predicate<E>): boolean;
+    nonMatch(predicate: BiPredicate<E, bigint>): boolean;
+    partition(count: bigint): Array<Array<E>>;
+    partitionBy(classifier: Functional<E, bigint>): Array<Array<E>>;
+    partitionBy(classifier: BiFunctional<E, bigint, bigint>): Array<Array<E>>;
+    reduce(accumulator: BiFunctional<E, E, E>): Optional<E>;
+    reduce(accumulator: TriFunctional<E, E, bigint, E>): Optional<E>;
+    reduce(identity: E, accumulator: BiFunctional<E, E, E>): E;
+    reduce(identity: E, accumulator: TriFunctional<E, E, bigint, E>): E;
+    reduce<R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): R;
+    reduce<R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): R;
+    semantic(): Semantic<E>;
+    abstract source(): Generator<E>;
+    toArray(): Array<E>;
+    toMap<K, E>(keyExtractor: Functional<E, K>): Map<K, E>;
+    toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, V>;
+    toMap<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Map<K, V>;
+    toSet(): Set<E>;
+    write<S = string>(stream: WritableStream<S>): Promise<WritableStream<S>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Promise<WritableStream<S>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Promise<WritableStream<S>>;
+}
+export declare class EventCollectable<E> extends Collectable<E> {
+    protected readonly AsyncCollectable: symbol;
+    protected generator: Generator<E>;
+    constructor(generator: Generator<E>);
+    source(): Generator<E>;
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+}
+export declare class UnorderedCollectable<E> extends Collectable<E> {
+    protected readonly UnorderedCollectable: symbol;
+    protected buffer: Map<bigint, E>;
+    constructor(generator: Generator<E>);
+    source(): Generator<E>;
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+}
+export declare class OrderedCollectable<E> extends Collectable<E> {
+    protected readonly OrderedCollectable: symbol;
+    protected buffer: Array<Indexed<E>>;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    source(): Generator<E>;
+    isEmpty(): boolean;
+}
+export declare abstract class Statistics<E, D extends number | bigint> extends OrderedCollectable<E> {
+    protected readonly Statistics: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    count(): bigint;
+    abstract average(): D;
+    abstract average(mapper: Functional<E, D>): D;
+    abstract range(): D;
+    abstract range(mapper: Functional<E, D>): D;
+    abstract variance(): D;
+    abstract variance(mapper: Functional<E, D>): D;
+    abstract standardDeviation(): D;
+    abstract standardDeviation(mapper: Functional<E, D>): D;
+    abstract mean(): D;
+    abstract mean(mapper: Functional<E, D>): D;
+    abstract median(): D;
+    abstract median(mapper: Functional<E, D>): D;
+    abstract mode(): D;
+    abstract mode(mapper: Functional<E, D>): D;
+    frequency(): Map<E, bigint>;
+    abstract summate(): D;
+    abstract summate(mapper: Functional<E, D>): D;
+    abstract quantile(quantile: number): D;
+    abstract quantile(quantile: number, mapper: Functional<E, D>): D;
+    abstract interquartileRange(): D;
+    abstract interquartileRange(mapper: Functional<E, D>): D;
+    abstract skewness(): D;
+    abstract skewness(mapper: Functional<E, D>): D;
+    abstract kurtosis(): D;
+    abstract kurtosis(mapper: Functional<E, D>): D;
+}
+export declare class NumericStatistics<E> extends Statistics<E, number> {
+    protected readonly NumericStatistics: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    average(): number;
+    average(mapper: Functional<E, number>): number;
+    range(): number;
+    range(mapper: Functional<E, number>): number;
+    variance(): number;
+    variance(mapper: Functional<E, number>): number;
+    standardDeviation(): number;
+    standardDeviation(mapper: Functional<E, number>): number;
+    mean(): number;
+    mean(mapper: Functional<E, number>): number;
+    median(): number;
+    median(mapper: Functional<E, number>): number;
+    mode(): number;
+    mode(mapper: Functional<E, number>): number;
+    summate(): number;
+    summate(mapper: Functional<E, number>): number;
+    quantile(quantile: number): number;
+    quantile(quantile: number, mapper: Functional<E, number>): number;
+    interquartileRange(): number;
+    interquartileRange(mapper: Functional<E, number>): number;
+    skewness(): number;
+    skewness(mapper: Functional<E, number>): number;
+    kurtosis(): number;
+    kurtosis(mapper: Functional<E, number>): number;
+}
+export declare class BigIntStatistics<E> extends Statistics<E, bigint> {
+    protected readonly BigIntStatistics: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    average(): bigint;
+    average(mapper: Functional<E, bigint>): bigint;
+    range(): bigint;
+    range(mapper: Functional<E, bigint>): bigint;
+    variance(): bigint;
+    variance(mapper: Functional<E, bigint>): bigint;
+    standardDeviation(): bigint;
+    standardDeviation(mapper: Functional<E, bigint>): bigint;
+    mean(): bigint;
+    mean(mapper: Functional<E, bigint>): bigint;
+    median(): bigint;
+    median(mapper: Functional<E, bigint>): bigint;
+    mode(): bigint;
+    mode(mapper: Functional<E, bigint>): bigint;
+    summate(): bigint;
+    summate(mapper: Functional<E, bigint>): bigint;
+    quantile(quantile: number): bigint;
+    quantile(quantile: number, mapper: Functional<E, bigint>): bigint;
+    interquartileRange(): bigint;
+    interquartileRange(mapper: Functional<E, bigint>): bigint;
+    skewness(): bigint;
+    skewness(mapper: Functional<E, bigint>): bigint;
+    kurtosis(): bigint;
+    kurtosis(mapper: Functional<E, bigint>): bigint;
+}
+export declare class WindowCollectable<E> extends OrderedCollectable<E> {
+    protected readonly WindowCollectable: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    slide(size: bigint, step?: bigint): Semantic<Semantic<E>>;
+    tumble(size: bigint): Semantic<Semantic<E>>;
+}