semantic-typescript 0.3.7 → 0.3.8

package/dist/collectable.js

@@ -8,6 +8,13 @@ import { invalidate, validate } from "./utility";
 export class Collectable {
     Collectable = CollectableSymbol;
     constructor() {
+        Object.defineProperty(this, "Collectable", {
+            value: CollectableSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     anyMatch(predicate) {
         if (isFunction(predicate)) {
@@ -363,6 +370,9 @@ export class Collectable {
     }
 }
 ;
+Object.freeze(Collectable);
+Object.freeze(Collectable.prototype);
+Object.freeze(Object.getPrototypeOf(Collectable.prototype));
 export class UnorderedCollectable extends Collectable {
     UnorderedCollectable = UnorderedCollectableSymbol;
     generator;
@@ -370,6 +380,21 @@ export class UnorderedCollectable extends Collectable {
         super();
         if (isFunction(argument1)) {
             this.generator = argument1;
+            Object.defineProperties(this, {
+                "UnorderedCollectable": {
+                    value: UnorderedCollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                },
+                "generator": {
+                    value: this.generator,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+            Object.freeze(this);
         }
         else {
             throw new TypeError("Source must be an iterable or a generator function.");
@@ -398,6 +423,9 @@ export class UnorderedCollectable extends Collectable {
     }
 }
 ;
+Object.freeze(UnorderedCollectable);
+Object.freeze(UnorderedCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(UnorderedCollectable.prototype));
 export class OrderedCollectable extends Collectable {
     OrderedCollectable = OrderedCollectableSymbol;
     buffer;
@@ -425,6 +453,21 @@ export class OrderedCollectable extends Collectable {
                         return Number(a.index - b.index);
                     });
                 }
+                Object.defineProperties(this, {
+                    "OrderedCollectable": {
+                        value: OrderedCollectableSymbol,
+                        writable: false,
+                        enumerable: false,
+                        configurable: false
+                    },
+                    "buffer": {
+                        value: this.buffer,
+                        writable: false,
+                        enumerable: false,
+                        configurable: false
+                    }
+                });
+                Object.freeze(this);
             }
             catch (error) {
                 throw new Error("Uncaught error on creating buffer.");
@@ -472,3 +515,6 @@ export class OrderedCollectable extends Collectable {
     }
 }
 ;
+Object.freeze(OrderedCollectable);
+Object.freeze(OrderedCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(OrderedCollectable.prototype));

package/dist/collector.d.ts

@@ -3,15 +3,15 @@ import { Optional } from "./optional";
 import type { Semantic } from "./semantic";
 import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer, type Comparator } from "./utility";
 export declare class Collector<E, A, R> {
-    protected identity: Supplier<A>;
-    protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
-    protected accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
-    protected finisher: Functional<A, R>;
+    protected readonly identity: Supplier<A>;
+    protected readonly interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    protected readonly accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    protected readonly finisher: Functional<A, R>;
     protected readonly Collector: symbol;
-    protected constructor(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
-    protected constructor(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
-    protected constructor(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
-    protected constructor(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
     collect(generator: Generator<E>): R;
     collect(iterable: Iterable<E>): R;
     collect(semantic: Semantic<E>): R;

package/dist/collector.js

@@ -9,12 +9,45 @@ export class Collector {
     accumulator;
     finisher;
     Collector = CollectableSymbol;
-    constructor(identity, interruptor, accumulator, finisher) {
-        if (isFunction(identity) && isFunction(interruptor) && isFunction(accumulator) && isFunction(finisher)) {
+    constructor(identity, interrupt, accumulator, finisher) {
+        if (isFunction(identity) && isFunction(interrupt) && isFunction(accumulator) && isFunction(finisher)) {
             this.identity = identity;
-            this.interrupt = interruptor;
+            this.interrupt = interrupt;
             this.accumulator = accumulator;
             this.finisher = finisher;
+            Object.defineProperties(this, {
+                "identity": {
+                    enumerable: false,
+                    writable: false,
+                    configurable: false,
+                    value: identity,
+                },
+                "interrupt": {
+                    enumerable: false,
+                    writable: false,
+                    configurable: false,
+                    value: interrupt,
+                },
+                "accumulator": {
+                    enumerable: false,
+                    writable: false,
+                    configurable: false,
+                    value: accumulator,
+                },
+                "finisher": {
+                    enumerable: false,
+                    writable: false,
+                    configurable: false,
+                    value: finisher,
+                },
+                "Collector": {
+                    enumerable: false,
+                    writable: false,
+                    configurable: false,
+                    value: CollectableSymbol,
+                }
+            });
+            Object.freeze(this);
         }
         else {
             throw new TypeError("Invalid arguments");
@@ -24,68 +57,98 @@ export class Collector {
         let accumulator = this.identity();
         let count = 0n;
         if (isFunction(argument1)) {
-            let generator = argument1;
-            generator((element, index) => {
-                accumulator = this.accumulator(accumulator, element, index);
-                count++;
-            }, (element, index) => this.interrupt(element, index, accumulator));
+            try {
+                let generator = argument1;
+                generator((element, index) => {
+                    accumulator = this.accumulator(accumulator, element, index);
+                    count++;
+                }, (element, index) => this.interrupt(element, index, accumulator));
+            }
+            catch (error) {
+                throw new Error("Uncaught error on collect.");
+            }
         }
         else if (isIterable(argument1)) {
-            let iterable = argument1;
-            let index = 0n;
-            for (let element of iterable) {
-                if (this.interrupt(element, index, accumulator)) {
-                    break;
+            try {
+                let iterable = argument1;
+                let index = 0n;
+                for (let element of iterable) {
+                    if (this.interrupt(element, index, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, element, count);
+                    count++;
+                    index++;
                 }
-                accumulator = this.accumulator(accumulator, element, count);
-                count++;
-                index++;
+            }
+            catch (error) {
+                throw new Error("Uncaught error on collect.");
             }
         }
         else if (isSemantic(argument1)) {
-            let semantic = argument1;
-            let generator = Reflect.get(semantic, "generator");
-            if (isFunction(generator)) {
-                generator((element, index) => {
-                    accumulator = this.accumulator(accumulator, element, index);
-                    count++;
-                }, (element, index) => this.interrupt(element, index, accumulator));
+            try {
+                let semantic = argument1;
+                let generator = Reflect.get(semantic, "generator");
+                if (isFunction(generator)) {
+                    generator((element, index) => {
+                        accumulator = this.accumulator(accumulator, element, index);
+                        count++;
+                    }, (element, index) => this.interrupt(element, index, accumulator));
+                }
+                else {
+                    throw new TypeError("Invalid arguments");
+                }
             }
-            else {
-                throw new TypeError("Invalid arguments");
+            catch (error) {
+                throw new Error("Uncaught error on collect.");
             }
         }
         else if (isCollectable(argument1)) {
-            let collectable = argument1;
-            let source = collectable.source();
-            if (isFunction(source)) {
-                let generator = source;
-                generator((element, index) => {
-                    accumulator = this.accumulator(accumulator, element, index);
-                    count++;
-                }, (element, index) => this.interrupt(element, index, accumulator));
+            try {
+                let collectable = argument1;
+                let source = collectable.source();
+                if (isFunction(source)) {
+                    let generator = source;
+                    generator((element, index) => {
+                        accumulator = this.accumulator(accumulator, element, index);
+                        count++;
+                    }, (element, index) => this.interrupt(element, index, accumulator));
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error on collect.");
             }
         }
         else if (isNumber(argument1) && isNumber(argument2)) {
-            let start = argument1 < argument2 ? argument1 : argument2;
-            let end = argument1 > argument2 ? argument1 : argument2;
-            for (let i = start; i < end; i++) {
-                if (this.interrupt(i, count, accumulator)) {
-                    break;
+            try {
+                let start = argument1 < argument2 ? argument1 : argument2;
+                let end = argument1 > argument2 ? argument1 : argument2;
+                for (let i = start; i < end; i++) {
+                    if (this.interrupt(i, count, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, i, count);
+                    count++;
                 }
-                accumulator = this.accumulator(accumulator, i, count);
-                count++;
+            }
+            catch (error) {
+                throw new Error("Uncaught error on collect.");
             }
         }
         else if (isBigInt(argument1) && isBigInt(argument2)) {
-            let start = argument1 < argument2 ? argument1 : argument2;
-            let end = argument1 > argument2 ? argument1 : argument2;
-            for (let i = start; i < end; i++) {
-                if (this.interrupt(i, count, accumulator)) {
-                    break;
+            try {
+                let start = argument1 < argument2 ? argument1 : argument2;
+                let end = argument1 > argument2 ? argument1 : argument2;
+                for (let i = start; i < end; i++) {
+                    if (this.interrupt(i, count, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, i, count);
+                    count++;
                 }
-                accumulator = this.accumulator(accumulator, i, count);
-                count++;
+            }
+            catch (error) {
+                throw new Error("Uncaught error on collect.");
             }
         }
         return this.finisher(accumulator);
@@ -98,6 +161,9 @@ export class Collector {
     }
 }
 ;
+Object.freeze(Collector);
+Object.freeze(Collector.prototype);
+Object.freeze(Object.getPrototypeOf(Collector));
 export let useAnyMatch = (predicate) => {
     if (isFunction(predicate)) {
         return Collector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element) => accumulator || predicate(element), (accumulator) => accumulator);

package/dist/factory.d.ts

@@ -1,19 +1,49 @@
 import { Semantic } from "./semantic";
-import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
-export declare let animationFrame: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
+import type { BiPredicate, Functional, Predicate, Supplier, Generator } from "./utility";
+interface AnimationFrameFunction {
+    (period: number): Semantic<number>;
+    (period: number, delay: number): Semantic<number>;
+}
+export declare let animationFrame: AnimationFrameFunction;
 interface Attribute<T> {
     key: keyof T;
     value: T[keyof 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>>;
+interface BlobFunction {
+    (blob: Blob): Semantic<Uint8Array>;
+    (blob: Blob, chunk: bigint): Semantic<Uint8Array>;
+}
+export declare let blob: BlobFunction;
 export declare let empty: <E>() => Semantic<E>;
-export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
-export declare let from: <E>(iterable: Iterable<E>) => Semantic<E>;
-export declare let generate: (<E>(supplier: Supplier<E>, interrupt: Predicate<E>) => Semantic<E>) & (<E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>) => Semantic<E>);
-export declare let interval: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
+interface FillFunction {
+    <E>(element: E, count: bigint): Semantic<E>;
+    <E>(supplier: Supplier<E>, count: bigint): Semantic<E>;
+}
+export declare let fill: FillFunction;
+export interface FromFunction {
+    <E>(iterable: Iterable<E>): Semantic<E>;
+    <E>(iterable: AsyncIterable<E>): Semantic<E>;
+}
+export declare let from: FromFunction;
+interface GenerateFunction {
+    <E>(supplier: Supplier<E>, count: bigint): Semantic<E>;
+    <E>(element: E, count: bigint): Semantic<E>;
+    <E>(supplier: Supplier<E>, interrupt: Predicate<E>): Semantic<E>;
+    <E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>): Semantic<E>;
+}
+export declare let generate: GenerateFunction;
+interface IntervalFunction {
+    (period: number): Semantic<number>;
+    (period: number, delay: number): Semantic<number>;
+}
+export declare let interval: IntervalFunction;
 export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
 export declare let promise: (<T>(promise: Promise<T>) => Semantic<T>);
-export declare let range: BiFunctional<number, number, Semantic<number>> & TriFunctional<number, number, number, Semantic<number>>;
+interface RangeFunction {
+    (start: number, end: number): Semantic<number>;
+    (start: number, end: number, step: number): Semantic<number>;
+}
+export declare let range: RangeFunction;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
 export {};

package/dist/factory.js

@@ -1,7 +1,8 @@
-import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise } from "./guard";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyncIterable } from "./guard";
 import { useCompare, useTraverse } from "./hook";
 import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
+;
 export let animationFrame = (period, delay = 0) => {
     if (period <= 0 || !Number.isFinite(period) || delay < 0 || !Number.isFinite(delay)) {
         throw new TypeError("Period must be positive finite number and delay must be non-negative finite number.");
@@ -56,6 +57,7 @@ export let attribute = (target) => {
     }
     throw new TypeError("Target must be an object.");
 };
+;
 export let blob = (blob, chunk = 64n * 1024n) => {
     let size = Number(chunk);
     if (size <= 0 || !Number.isSafeInteger(size)) {
@@ -129,6 +131,7 @@ export let blob = (blob, chunk = 64n * 1024n) => {
 export let empty = () => {
     return new Semantic(() => { });
 };
+;
 export let fill = (element, count) => {
     if (validate(element) && count > 0n) {
         return new Semantic((accept, interrupt) => {
@@ -148,6 +151,7 @@ export let fill = (element, count) => {
     }
     throw new TypeError("Invalid arguments.");
 };
+;
 export let from = (iterable) => {
     if (isIterable(iterable)) {
         return new Semantic((accept, interrupt) => {
@@ -166,15 +170,91 @@ export let from = (iterable) => {
             }
         });
     }
+    else if (isAsyncIterable(iterable)) {
+        return new Semantic(async (accept, interrupt) => {
+            try {
+                let index = 0n;
+                for await (let element of iterable) {
+                    if (interrupt(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating from semantic.");
+            }
+        });
+    }
     throw new TypeError("Invalid arguments");
 };
-export let generate = (supplier, interrupt) => {
-    if (isFunction(supplier) && isFunction(interrupt)) {
+;
+export let generate = (argument1, argument2) => {
+    if (isFunction(argument1)) {
+        if (isFunction(argument2)) {
+            let shutdown = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    while (true) {
+                        if (interrupt(argument1(), index) || shutdown(argument1(), index)) {
+                            break;
+                        }
+                        accept(argument1(), index);
+                        index++;
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating generate semantic.");
+                }
+            });
+        }
+        if (isBigInt(argument2)) {
+            let limit = argument2;
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let index = 0n;
+                    while (index < limit) {
+                        if (interrupt(argument1(), index)) {
+                            break;
+                        }
+                        accept(argument1(), index);
+                        index++;
+                    }
+                }
+                catch (error) {
+                    throw new Error("Uncaught error as creating generate semantic.");
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments.");
+    }
+    let element = argument1;
+    if (isFunction(argument2)) {
+        let shutdown = argument2;
         return new Semantic((accept, interrupt) => {
             try {
                 let index = 0n;
                 while (true) {
-                    let element = supplier();
+                    if (interrupt(element, index) || shutdown(element, index)) {
+                        break;
+                    }
+                    accept(element, index);
+                    index++;
+                }
+            }
+            catch (error) {
+                throw new Error("Uncaught error as creating generate semantic.");
+            }
+        });
+    }
+    if (isBigInt(argument2)) {
+        let limit = argument2;
+        return new Semantic((accept, interrupt) => {
+            try {
+                let index = 0n;
+                while (index < limit) {
                     if (interrupt(element, index)) {
                         break;
                     }
@@ -187,8 +267,9 @@ export let generate = (supplier, interrupt) => {
             }
         });
     }
-    throw new TypeError("Invalid arguments");
+    throw new TypeError("Invalid arguments.");
 };
+;
 export let interval = (period, delay = 0) => {
     if (period > 0 && delay >= 0) {
         return new Semantic((accept, interrupt) => {
@@ -260,6 +341,7 @@ export let promise = (promise) => {
         throw new TypeError("Invalid arguments.");
     }
 };
+;
 export let range = (start, end, step = 1) => {
     if ((!isNumber(step) && !isBigInt(step)) || (isNumber(step) && useCompare(step, 0) === 0) || (isBigInt(step) && useCompare(step, 0n) === 0)) {
         throw new TypeError("Step must be numeric and cannot be zero.");

package/dist/guard.d.ts

@@ -2,7 +2,8 @@ import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./co
 import type { Collector } from "./collector";
 import type { Semantic } from "./semantic";
 import type { Statistics } from "./statistics";
-import type { AsyncFunction, MaybePrimitive, Primitive } from "./utility";
+import type { AsyncFunction, Generator, MaybePrimitive, Primitive } from "./utility";
+import type { WindowCollectable } from "./window";
 export declare let isBoolean: (t: unknown) => t is boolean;
 export declare let isString: (t: unknown) => t is string;
 export declare let isNumber: (t: unknown) => t is number;
@@ -11,17 +12,19 @@ export declare let isObject: (t: unknown) => t is object;
 export declare let isSymbol: (t: unknown) => t is symbol;
 export declare let isBigInt: (t: unknown) => t is bigint;
 export declare let isPrimitive: (t: MaybePrimitive<unknown>) => t is Primitive;
+export declare let isAsyncIterable: (t: unknown) => t is Iterable<unknown>;
 export declare let isIterable: (t: unknown) => t is Iterable<unknown>;
 export declare let isSemantic: (t: unknown) => t is Semantic<unknown>;
 export declare let isCollector: (t: unknown) => t is Collector<unknown, unknown, unknown>;
 export declare let isCollectable: (t: unknown) => t is Collectable<unknown>;
 export declare let isOrderedCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
-export declare let isWindowCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
+export declare let isWindowCollectable: (t: unknown) => t is WindowCollectable<unknown>;
 export declare let isUnorderedCollectable: (t: unknown) => t is UnorderedCollectable<unknown>;
 export declare let isStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
 export declare let isNumericStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
 export declare let isBigIntStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
 export declare let isPromise: (t: unknown) => t is Promise<unknown>;
+export declare let isGenerator: (t: unknown) => t is Generator<unknown>;
 export declare let isAsyncFunction: (t: unknown) => t is AsyncFunction;
-export declare let isGeneratorFunction: (t: unknown) => t is Generator<unknown, unknown, unknown>;
-export declare let isAsyncGeneratorFunction: (t: unknown) => t is AsyncGenerator<unknown, unknown, unknown>;
+export declare let isGeneratorFunction: (t: unknown) => t is globalThis.Generator<unknown, unknown, unknown>;
+export declare let isAsyncGeneratorFunction: (t: unknown) => t is globalThis.AsyncGenerator<unknown, unknown, unknown>;

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol } from "./symbol";
+import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
 export let isBoolean = (t) => {
     return typeof t === "boolean";
 };
@@ -23,6 +23,12 @@ export let isBigInt = (t) => {
 export let isPrimitive = (t) => {
     return isBoolean(t) || isString(t) || isNumber(t) || isSymbol(t) || isBigInt(t) || isFunction(t);
 };
+export let isAsyncIterable = (t) => {
+    if (isObject(t)) {
+        return isFunction(Reflect.get(t, Symbol.asyncIterator));
+    }
+    return false;
+};
 export let isIterable = (t) => {
     if (isObject(t)) {
         return isFunction(Reflect.get(t, Symbol.iterator));
@@ -55,7 +61,7 @@ export let isOrderedCollectable = (t) => {
 };
 export let isWindowCollectable = (t) => {
     if (isObject(t)) {
-        return Reflect.get(t, "WindowCollectable") === OrderedCollectableSymbol;
+        return Reflect.get(t, "WindowCollectable") === WindowCollectableSymbol;
     }
     return false;
 };
@@ -89,21 +95,27 @@ export let isPromise = (t) => {
     }
     return false;
 };
+export let isGenerator = (t) => {
+    if (isFunction(t)) {
+        return t.length === 2;
+    }
+    return false;
+};
 export let isAsyncFunction = (t) => {
     if (isFunction(t)) {
-        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction" && t.constructor.name === "AsyncFunction";
+        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction";
     }
     return false;
 };
 export let isGeneratorFunction = (t) => {
-    if (isObject(t)) {
-        return isFunction(t) && Reflect.get(t, "constructor").name === "GeneratorFunction";
+    if (isFunction(t)) {
+        return Reflect.get(t, Symbol.toStringTag) === "GeneratorFunction";
     }
     return false;
 };
 export let isAsyncGeneratorFunction = (t) => {
-    if (isObject(t)) {
-        return isFunction(t) && Reflect.get(t, "constructor").name === "AsyncGeneratorFunction";
+    if (isFunction(t)) {
+        return Reflect.get(t, Symbol.toStringTag) === "AsyncGeneratorFunction";
     }
     return false;
 };

package/dist/hook.d.ts

@@ -13,4 +13,5 @@ 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;
+export declare let useFunction: <T extends ((...args: any[]) => any)>(target: T) => T;
 export {};