semantic-typescript 0.6.0 → 0.7.1

package/dist/guard.d.ts

@@ -37,6 +37,3 @@ 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

@@ -173,22 +173,3 @@ 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.js

@@ -70,6 +70,9 @@ register("number", (value) => {
         if (primitive.has(value)) {
             return primitive.get(value) || 0n;
         }
+        if (Number.isNaN(value)) {
+            return 0x7ff8000000000000n;
+        }
         let mask = maskOf("number");
         let bit = 0xffffffffffffffffn;
         let buffer = new ArrayBuffer(8);

package/dist/hook.d.ts

@@ -1,5 +1,5 @@
 import { type DeepPropertyKey, type DeepPropertyValue } from "./utility";
-import type { Comparator, SynchronousGenerator } from "./utility";
+import type { BiFunctional, Comparator, SynchronousGenerator } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 interface UseRandom {
     <N extends number | bigint>(start: N): N extends number ? number : (N extends bigint ? bigint : never);
@@ -30,4 +30,9 @@ interface UseArrange {
 export declare let useArrange: UseArrange;
 export declare let useToNumber: <T = unknown>(target: T) => number;
 export declare let useToBigInt: <T = unknown>(target: T) => bigint;
+interface UseStringify {
+    <T extends object>(target: T): string;
+    <T extends object, K extends DeepPropertyKey<T>, V extends DeepPropertyValue<T>>(target: T, callback: BiFunctional<K, V, string>): string;
+}
+export declare let useStringify: UseStringify;
 export {};

package/dist/hook.js

@@ -246,7 +246,7 @@ export let useToNumber = (target) => {
                 return 0;
             }
             if (Reflect.has(target, Symbol.toPrimitive)) {
-                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["number"]);
                 return isNumber(resolved) ? resolved : 0;
             }
             return 0;
@@ -257,7 +257,7 @@ export let useToNumber = (target) => {
 export let useToBigInt = (target) => {
     switch (typeof target) {
         case "number":
-            return isNumber(target) ? BigInt(target) : 0n;
+            return isNumber(target) ? BigInt(Math.floor(target)) : 0n;
         case "boolean":
             return target ? 1n : 0n;
         case "string":
@@ -270,7 +270,7 @@ export let useToBigInt = (target) => {
                 return 0n;
             }
             if (Reflect.has(target, Symbol.toPrimitive)) {
-                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["bigint"]);
                 return isBigInt(resolved) ? resolved : 0n;
             }
             return 0n;
@@ -278,3 +278,20 @@ export let useToBigInt = (target) => {
             return 0n;
     }
 };
+;
+export let useStringify = (target, callback) => {
+    let seen = new WeakSet();
+    let resolve = isFunction(callback) ? callback : (_key, value) => {
+        return JSON.stringify(value);
+    };
+    return JSON.stringify(target, (key, value) => {
+        if (isObject(value)) {
+            if (seen.has(value)) {
+                return (void 0);
+            }
+            seen.add(value);
+            return resolve(key, value);
+        }
+        return resolve(key, value);
+    });
+};

package/dist/synchronous/collector.d.ts

@@ -1,5 +1,5 @@
 import { Optional } from "../optional";
-import type { Supplier, Predicate, BiPredicate, TriPredicate, BiFunctional, TriFunctional, Functional, SynchronousGenerator, Comparator, Consumer, BiConsumer } from "../utility";
+import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, TriPredicate, Consumer, BiConsumer, Comparator, SynchronousGenerator } from "../utility";
 export declare class SynchronousCollector<E, A, R> {
     protected identity: Supplier<A>;
     protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
@@ -14,6 +14,10 @@ export declare class SynchronousCollector<E, A, R> {
     collect(iterable: Iterable<E>): R;
     collect(start: number, end: number): R;
     collect(start: bigint, end: bigint): R;
+    getIdentity(): Supplier<A>;
+    getInterrupt(): Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    getAccumulator(): BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    getFinisher(): Functional<A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
     static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
@@ -140,17 +144,17 @@ interface UseSynchronousWrite {
 export declare let useSynchronousWrite: UseSynchronousWrite;
 interface UseSynchronousNumericSummate {
     <E>(): SynchronousCollector<E, number, number>;
-    <E>(mapper: Functional<E, number>): SynchronousCollector<E, number, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<number, number, number>;
 }
 export declare let useSynchronousNumericSummate: UseSynchronousNumericSummate;
 interface UseSynchronousBigIntSummate {
     <E>(): SynchronousCollector<E, bigint, bigint>;
-    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<bigint, bigint, bigint>;
 }
 export declare let useSynchronousBigIntSummate: UseSynchronousBigIntSummate;
 interface UseSynchronousNumericAverage {
     <E>(): SynchronousCollector<E, NumericAverageAccumulator, number>;
-    <E>(mapper: Functional<E, number>): SynchronousCollector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<number, NumericAverageAccumulator, number>;
 }
 interface NumericAverageAccumulator {
     summate: number;

package/dist/synchronous/collector.js

@@ -1,8 +1,8 @@
-import { isFunction, isIterable, isNumber, isBigInt, isBoolean, isString, isObject } from "../guard";
+import { isFunction, isNumber, isBigInt, isBoolean, isString, isObject, isAsyncFunction, isIterable } from "../guard";
 import { useCompare, useToBigInt, useToNumber } from "../hook";
 import { Optional } from "../optional";
 import { SynchronousCollectorSymbol } from "../symbol";
-import { validate, invalidate } from "../utility";
+import { invalidate, validate } from "../utility";
 export class SynchronousCollector {
     identity;
     interrupt;
@@ -54,7 +54,7 @@ export class SynchronousCollector {
         }
     }
     collect(argument1, argument2) {
-        if (isFunction(argument1)) {
+        if (isAsyncFunction(argument1) || isFunction(argument1)) {
             try {
                 let generator = argument1;
                 let accumulator = this.identity();
@@ -66,29 +66,25 @@ export class SynchronousCollector {
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error on collect.");
+                throw error;
             }
         }
         else if (isIterable(argument1)) {
             try {
                 let iterable = argument1;
-                let index = 0n;
                 let accumulator = this.identity();
                 let count = 0n;
                 for (let element of iterable) {
-                    if (this.interrupt(element, index, accumulator)) {
+                    if (this.interrupt(element, count, accumulator)) {
                         break;
                     }
                     accumulator = this.accumulator(accumulator, element, count);
                     count++;
-                    index++;
                 }
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error n collect.");
+                throw error;
             }
         }
         else if (isNumber(argument1) && isNumber(argument2)) {
@@ -107,8 +103,7 @@ export class SynchronousCollector {
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error on collect.");
+                throw error;
             }
         }
         else if (isBigInt(argument1) && isBigInt(argument2)) {
@@ -127,12 +122,23 @@ export class SynchronousCollector {
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error on collect.");
+                throw error;
             }
         }
         throw new Error("Invalid arguments.");
     }
+    getIdentity() {
+        return this.identity;
+    }
+    getInterrupt() {
+        return this.interrupt;
+    }
+    getAccumulator() {
+        return this.accumulator;
+    }
+    getFinisher() {
+        return this.finisher;
+    }
     static full(identity, accumulator, finisher) {
         return new SynchronousCollector(identity, () => false, accumulator, finisher);
     }
@@ -173,7 +179,7 @@ export let useSynchronousCollect = (argument1, argument2, argument3, argument4)
     throw new TypeError("Identity, accumulator, and finisher must be functions.");
 };
 export let useSynchronousCount = () => {
-    return SynchronousCollector.full(() => 0n, (count) => count + 1n, (count) => count);
+    return SynchronousCollector.full(() => 0n, (count) => isBigInt(count) ? (count + 1n) : 1n, (count) => isBigInt(count) ? count : 0n);
 };
 ;
 export let useSynchronousError = (argument1, argument2, argument3) => {
@@ -215,65 +221,78 @@ export let useSynchronousFindAt = (index) => {
     let target = useToBigInt(index);
     if (target < 0n) {
         return SynchronousCollector.full(() => [], (accumulator, element) => {
-            accumulator.push(element);
-            return accumulator;
-        }, (accumulator) => {
-            if (accumulator.length === 0) {
-                return Optional.empty();
+            let accumulated = Array.isArray(accumulator) ? accumulator : [];
+            accumulated.push(element);
+            return accumulated;
+        }, (result) => {
+            if (Array.isArray(result) && result.length > 0) {
+                let index = ((Number(target) % result.length) + result.length) % result.length;
+                return Optional.of(result[index]);
             }
-            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
-            return Optional.ofNullable(accumulator[Number(limited)]);
+            return Optional.empty();
         });
     }
     return SynchronousCollector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
-        accumulator.push(element);
-        return accumulator;
-    }, (accumulator) => {
-        if (accumulator.length === 0) {
-            return Optional.empty();
+        let accumulated = Array.isArray(accumulator) ? accumulator : [];
+        accumulated.push(element);
+        return accumulated;
+    }, (result) => {
+        let index = ((Number(target) % result.length) + result.length) % result.length;
+        if (Array.isArray(result) && result.length > 0) {
+            return Optional.of(result[index]);
         }
-        return Optional.ofNullable(accumulator[Number(target)]);
+        return Optional.empty();
     });
 };
 export let useSynchronousFindFirst = () => {
     return SynchronousCollector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
-        if (validate(accumulator) && accumulator.isPresent()) {
-            return accumulator;
+        if (validate(accumulator) && accumulator.isPresent() && validate(element)) {
+            return Optional.of(element);
         }
-        return Optional.ofNullable(element);
-    }, (accumulator) => accumulator);
+        return accumulator;
+    }, (result) => result);
 };
 export let useSynchronousFindAny = () => {
     return SynchronousCollector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
-        if (validate(accumulator) && accumulator.isPresent() && Math.random() < 0.5) {
-            return accumulator;
+        if (validate(accumulator) && accumulator.isPresent() && validate(element) && Math.random() < 0.5) {
+            return Optional.of(element);
         }
-        return Optional.ofNullable(element);
-    }, (accumulator) => accumulator);
+        return accumulator;
+    }, (result) => result);
 };
 export let useSynchronousFindLast = () => {
     return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
-        if (validate(accumulator) && accumulator.isPresent()) {
-            return Optional.ofNullable(element);
+        if (validate(accumulator) && accumulator.isPresent() && validate(element)) {
+            return Optional.of(element);
         }
         return accumulator;
-    }, (accumulator) => accumulator);
+    }, (result) => result);
 };
 export let useSynchronousFindMaximum = (comparator = (useCompare)) => {
-    return SynchronousCollector.full(() => Optional.ofNullable(), (accumulator, element) => {
-        if (accumulator.isPresent()) {
-            return comparator(accumulator.get(), element) > 0 ? accumulator : Optional.ofNullable(element);
-        }
-        return Optional.ofNullable(element);
-    }, (result) => result);
+    if (isFunction(comparator)) {
+        return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
+            if (validate(accumulator) && accumulator.isPresent()) {
+                return accumulator.map((previous) => {
+                    return comparator(previous, element) > 0 ? previous : element;
+                });
+            }
+            return accumulator;
+        }, (result) => result);
+    }
+    throw new TypeError("Invalid argument.");
 };
 export let useSynchronousFindMinimum = (comparator = (useCompare)) => {
-    return SynchronousCollector.full(() => Optional.ofNullable(), (accumulator, element) => {
-        if (accumulator.isPresent()) {
-            return comparator(accumulator.get(), element) < 0 ? accumulator : Optional.ofNullable(element);
-        }
-        return Optional.ofNullable(element);
-    }, (result) => result);
+    if (isFunction(comparator)) {
+        return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
+            if (validate(accumulator) && accumulator.isPresent()) {
+                return accumulator.map((previous) => {
+                    return comparator(previous, element) < 0 ? previous : element;
+                });
+            }
+            return accumulator;
+        }, (result) => result);
+    }
+    throw new TypeError("Invalid argument.");
 };
 ;
 export let useSynchronousForEach = (action) => {
@@ -364,7 +383,6 @@ export let useSynchronousLog = (argument1, argument2, argument3) => {
     }
     else {
         return SynchronousCollector.full(() => "[", (accumulator, element) => {
-            console.log(element);
             if (isString(accumulator) && isString(element)) {
                 return accumulator + element + ",";
             }
@@ -416,14 +434,11 @@ export let useSynchronousPartitionBy = (classifier) => {
 export let useSynchronousReduce = (argument1, argument2, argument3) => {
     if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
         let accumulator = argument1;
-        return SynchronousCollector.full(() => Optional.ofNullable(), (result, element, index) => {
-            if (result.isEmpty()) {
-                return Optional.of(element);
-            }
-            else {
-                let current = result.get();
-                return Optional.of(accumulator(current, element, index));
+        return SynchronousCollector.full(() => Optional.empty(), (result, element, index) => {
+            if (validate(result) && result.isPresent()) {
+                return result.map((previous) => accumulator(previous, element, index));
             }
+            return result;
         }, (result) => result);
     }
     else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {

package/dist/synchronous/semantic.d.ts

@@ -1,9 +1,10 @@
+import { type BiConsumer, type BiFunctional, type BiPredicate, type Comparator, type Consumer, type Functional, type Indexed, type Predicate, type Supplier, type SynchronousGenerator, type TriFunctional, type TriPredicate } from "../utility";
 import { SynchronousCollector } from "./collector";
 import type { Optional } from "../optional";
-import type { BiConsumer, BiFunctional, BiPredicate, Comparator, Consumer, Functional, Indexed, Predicate, Supplier, SynchronousGenerator, TriFunctional, TriPredicate } from "../utility";
 export declare class SynchronousSemantic<E> {
     protected generator: SynchronousGenerator<E>;
     protected readonly SynchronousSemantic: Symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     concat(other: SynchronousSemantic<E>): SynchronousSemantic<E>;
     concat(other: Iterable<E>): SynchronousSemantic<E>;
@@ -22,8 +23,10 @@ export declare class SynchronousSemantic<E> {
     flatMap<R>(mapper: BiFunctional<E, bigint, Iterable<R>>): SynchronousSemantic<R>;
     flatMap<R>(mapper: Functional<E, SynchronousSemantic<R>>): SynchronousSemantic<R>;
     flatMap<R>(mapper: BiFunctional<E, bigint, SynchronousSemantic<R>>): SynchronousSemantic<R>;
-    limit(n: number): SynchronousSemantic<E>;
-    limit(n: bigint): SynchronousSemantic<E>;
+    limit(count: number): SynchronousSemantic<E>;
+    limit(count: bigint): SynchronousSemantic<E>;
+    map(mapper: Functional<E, E>): SynchronousSemantic<E>;
+    map(mapper: BiFunctional<E, bigint, E>): SynchronousSemantic<E>;
     map<R>(mapper: Functional<E, R>): SynchronousSemantic<R>;
     map<R>(mapper: BiFunctional<E, bigint, R>): SynchronousSemantic<R>;
     peek(consumer: Consumer<E>): SynchronousSemantic<E>;
@@ -32,16 +35,15 @@ export declare class SynchronousSemantic<E> {
     reverse(): SynchronousSemantic<E>;
     shuffle(): SynchronousSemantic<E>;
     shuffle(mapper: BiFunctional<E, bigint, bigint>): SynchronousSemantic<E>;
-    skip(n: number): SynchronousSemantic<E>;
-    skip(n: bigint): SynchronousSemantic<E>;
+    skip(count: number): SynchronousSemantic<E>;
+    skip(count: bigint): SynchronousSemantic<E>;
     source(): SynchronousGenerator<E>;
-    sorted(): SynchronousOrderedCollectable<E>;
-    sorted(comparator: Comparator<E>): SynchronousOrderedCollectable<E>;
+    sub(start: number, end: number): SynchronousSemantic<E>;
     sub(start: bigint, end: bigint): SynchronousSemantic<E>;
     takeWhile(predicate: Predicate<E>): SynchronousSemantic<E>;
     takeWhile(predicate: BiPredicate<E, bigint>): SynchronousSemantic<E>;
-    toSynchronousCollectable(): SynchronousCollectable<E>;
-    toSynchronousCollectable<C extends SynchronousCollectable<E>>(mapper: Functional<SynchronousGenerator<E>, C>): C;
+    toCollectable(): SynchronousCollectable<E>;
+    toCollectable<C extends SynchronousCollectable<E>>(mapper: Functional<SynchronousGenerator<E>, C>): C;
     toBigintStatistics(): SynchronousBigIntStatistics<E>;
     toNumericStatistics(): SynchronousNumericStatistics<E>;
     toOrdered(): SynchronousOrderedCollectable<E>;
@@ -51,13 +53,15 @@ export declare class SynchronousSemantic<E> {
     translate(offset: bigint): SynchronousSemantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): SynchronousSemantic<E>;
 }
-export declare abstract class SynchronousCollectable<E> {
+export declare abstract class SynchronousCollectable<E> implements Iterable<E> {
     protected readonly SynchronousCollectable: symbol;
+    [Symbol.toStringTag]: string;
     constructor();
-    abstract [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    abstract [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
     anyMatch(predicate: Predicate<E>): boolean;
+    anyMatch(predicate: BiPredicate<E, bigint>): boolean;
     allMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: BiPredicate<E, bigint>): boolean;
     collect<A, R>(collector: SynchronousCollector<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;
@@ -104,8 +108,10 @@ export declare abstract class SynchronousCollectable<E> {
     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>;
+    pipe(conversion: Functional<SynchronousGenerator<E>, SynchronousSemantic<E>>): SynchronousSemantic<E>;
+    pipe<R>(conversion: Functional<SynchronousGenerator<E>, SynchronousSemantic<R>>): SynchronousSemantic<R>;
+    reduce(accumulator: BiFunctional<E, E, E>): E;
+    reduce(accumulator: TriFunctional<E, E, bigint, E>): 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;
@@ -122,30 +128,32 @@ export declare abstract class SynchronousCollectable<E> {
     write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Promise<WritableStream<S>>;
 }
 export declare class SynchronousOrderedCollectable<E> extends SynchronousCollectable<E> {
-    protected readonly SynchronousOrderedCollectable: symbol;
+    protected readonly OrderedCollectable: symbol;
     protected buffer: Array<Indexed<E>>;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    allMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: BiPredicate<E, bigint>): boolean;
     source(): SynchronousGenerator<E>;
     isEmpty(): boolean;
+    count(): bigint;
 }
 export declare class SynchronousUnorderedCollectable<E> extends SynchronousCollectable<E> {
     protected readonly SynchronousUnorderedCollectable: symbol;
+    [Symbol.toStringTag]: string;
     protected buffer: Map<bigint, E>;
     constructor(generator: SynchronousGenerator<E>);
-    source(): SynchronousGenerator<E>;
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    source(): SynchronousGenerator<E>;
 }
 export declare abstract class SynchronousStatistics<E, D extends number | bigint> extends SynchronousOrderedCollectable<E> {
     protected readonly SynchronousStatistics: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<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;
@@ -174,10 +182,10 @@ export declare abstract class SynchronousStatistics<E, D extends number | bigint
 }
 export declare class SynchronousBigIntStatistics<E> extends SynchronousStatistics<E, bigint> {
     protected readonly BigIntStatistics: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<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;
@@ -205,10 +213,10 @@ export declare class SynchronousBigIntStatistics<E> extends SynchronousStatistic
 }
 export declare class SynchronousNumericStatistics<E> extends SynchronousStatistics<E, number> {
     protected readonly SynchronousNumericStatistics: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<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;
@@ -236,10 +244,10 @@ export declare class SynchronousNumericStatistics<E> extends SynchronousStatisti
 }
 export declare class SynchronousWindowCollectable<E> extends SynchronousOrderedCollectable<E> {
     protected readonly WindowCollectable: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
     slide(size: bigint, step?: bigint): SynchronousSemantic<SynchronousSemantic<E>>;
     tumble(size: bigint): SynchronousSemantic<SynchronousSemantic<E>>;
 }