semantic-typescript 0.3.8 → 0.4.1

package/dist/collector.js

@@ -1,6 +1,8 @@
 import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
 import { useCompare, useToBigInt, useToNumber } from "./hook";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
+import { HashSet } from "./set";
 import { CollectableSymbol } from "./symbol";
 import { validate, invalidate } from "./utility";
 export class Collector {
@@ -17,34 +19,34 @@ export class Collector {
             this.finisher = finisher;
             Object.defineProperties(this, {
                 "identity": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: identity,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "interrupt": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: interrupt,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "accumulator": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: accumulator,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "finisher": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: finisher,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "Collector": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: CollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
                 }
             });
             Object.freeze(this);
@@ -57,98 +59,68 @@ export class Collector {
         let accumulator = this.identity();
         let count = 0n;
         if (isFunction(argument1)) {
-            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.");
-            }
+            let generator = argument1;
+            generator((element, index) => {
+                accumulator = this.accumulator(accumulator, element, index);
+                count++;
+            }, (element, index) => this.interrupt(element, index, accumulator));
         }
         else if (isIterable(argument1)) {
-            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++;
+            let iterable = argument1;
+            let index = 0n;
+            for (let element of iterable) {
+                if (this.interrupt(element, index, accumulator)) {
+                    break;
                 }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+                accumulator = this.accumulator(accumulator, element, count);
+                count++;
+                index++;
             }
         }
         else if (isSemantic(argument1)) {
-            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");
-                }
+            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));
             }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+            else {
+                throw new TypeError("Invalid arguments");
             }
         }
         else if (isCollectable(argument1)) {
-            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.");
+            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));
             }
         }
         else if (isNumber(argument1) && isNumber(argument2)) {
-            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++;
+            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;
                 }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+                accumulator = this.accumulator(accumulator, i, count);
+                count++;
             }
         }
         else if (isBigInt(argument1) && isBigInt(argument2)) {
-            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++;
+            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;
                 }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+                accumulator = this.accumulator(accumulator, i, count);
+                count++;
             }
         }
         return this.finisher(accumulator);
@@ -156,23 +128,22 @@ export class Collector {
     static full(identity, accumulator, finisher) {
         return new Collector(identity, () => false, accumulator, finisher);
     }
-    static shortable(identity, interruptor, accumulator, finisher) {
-        return new Collector(identity, interruptor, accumulator, finisher);
+    static shortable(identity, interrupt, accumulator, finisher) {
+        return new Collector(identity, interrupt, accumulator, finisher);
     }
 }
 ;
-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);
+        return Collector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element, index) => accumulator || predicate(element, index), (accumulator) => accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
+;
 export let useAllMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element) => accumulator && predicate(element), (accumulator) => accumulator);
+        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element, index) => accumulator && predicate(element, index), (accumulator) => accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
@@ -231,6 +202,31 @@ export let useError = (argument1, argument2, argument3) => {
         });
     }
 };
+;
+export let useFindAt = (index) => {
+    let target = useToBigInt(index);
+    if (target < 0n) {
+        return Collector.full(() => [], (accumulator, element) => {
+            accumulator.push(element);
+            return accumulator;
+        }, (accumulator) => {
+            if (accumulator.length === 0) {
+                return Optional.empty();
+            }
+            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
+            return Optional.ofNullable(accumulator[Number(limited)]);
+        });
+    }
+    return Collector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
+        accumulator.push(element);
+        return accumulator;
+    }, (accumulator) => {
+        if (accumulator.length === 0) {
+            return Optional.empty();
+        }
+        return Optional.ofNullable(accumulator[Number(target)]);
+    });
+};
 export let useFindFirst = () => {
     return Collector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
         if (validate(accumulator) && accumulator.isPresent()) {
@@ -281,16 +277,18 @@ export let useForEach = (action) => {
     }
     throw new TypeError("Action must be a function.");
 };
+;
 export let useNoneMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element) => accumulator && !predicate(element), (accumulator) => !accumulator);
+        return Collector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element, index) => accumulator && !predicate(element, index), (accumulator) => !accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
+;
 export let useGroup = (classifier) => {
     if (isFunction(classifier)) {
-        return Collector.full(() => new Map(), (accumulator, element) => {
-            let key = classifier(element);
+        return Collector.full(() => new Map(), (accumulator, element, index) => {
+            let key = classifier(element, index);
             let group = accumulator.get(key) || [];
             group.push(element);
             accumulator.set(key, group);
@@ -301,10 +299,10 @@ export let useGroup = (classifier) => {
 };
 export let useGroupBy = (keyExtractor, valueExtractor) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (accumulator, element) => {
-            let key = keyExtractor(element);
+        return Collector.full(() => new Map(), (accumulator, element, index) => {
+            let key = keyExtractor(element, index);
             let group = accumulator.get(key) || [];
-            group.push(valueExtractor(element));
+            group.push(valueExtractor(element, index));
             accumulator.set(key, group);
             return accumulator;
         }, (accumulator) => accumulator);
@@ -388,13 +386,14 @@ export let usePartition = (count) => {
     }
     throw new TypeError("Count must be a BigInt.");
 };
+;
 export let usePartitionBy = (classifier) => {
     if (isFunction(classifier)) {
         return Collector.full(() => {
             return [];
-        }, (array, element) => {
-            let index = classifier(element);
-            while (index > BigInt(array.length) - 1n) {
+        }, (array, element, index) => {
+            let resolved = classifier(element, index);
+            while (resolved > BigInt(array.length) - 1n) {
                 array.push([]);
             }
             array[Number(index)].push(element);
@@ -440,11 +439,24 @@ export let useToArray = () => {
         return array;
     }, (array) => array);
 };
+;
 export let useToMap = (keyExtractor, valueExtractor) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (map, element) => {
-            let key = keyExtractor(element);
-            let value = valueExtractor(element);
+        return Collector.full(() => new Map(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
+            map.set(key, value);
+            return map;
+        }, (map) => map);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+;
+export let useToHashMap = (keyExtractor, valueExtractor) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return Collector.full(() => new HashMap(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
             map.set(key, value);
             return map;
         }, (map) => map);
@@ -457,6 +469,12 @@ export let useToSet = () => {
         return set;
     }, (set) => set);
 };
+export let useToHashSet = () => {
+    return Collector.full(() => new HashSet(), (set, element) => {
+        set.add(element);
+        return set;
+    }, (set) => set);
+};
 ;
 export let useWrite = (argument1, argument2) => {
     if (isObject(argument1)) {

package/dist/factory.d.ts

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

package/dist/factory.js

@@ -2,7 +2,6 @@ import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise, isAsyn
 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.");
@@ -57,7 +56,6 @@ 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)) {
@@ -131,7 +129,6 @@ 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) => {
@@ -189,72 +186,13 @@ export let from = (iterable) => {
     }
     throw new TypeError("Invalid arguments");
 };
-;
-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;
+export let generate = (supplier, interrupt) => {
+    if (isFunction(supplier) && isFunction(interrupt)) {
         return new Semantic((accept, interrupt) => {
             try {
                 let index = 0n;
                 while (true) {
-                    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) {
+                    let element = supplier();
                     if (interrupt(element, index)) {
                         break;
                     }
@@ -267,9 +205,8 @@ export let generate = (argument1, argument2) => {
             }
         });
     }
-    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) => {
@@ -341,7 +278,6 @@ 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

@@ -1,30 +1,36 @@
 import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
 import type { Collector } from "./collector";
+import type { Hashable } from "./hash";
+import type { HashMap, SemanticMap } from "./map";
 import type { Semantic } from "./semantic";
+import type { HashSet } from "./set";
 import type { Statistics } from "./statistics";
-import type { AsyncFunction, Generator, MaybePrimitive, Primitive } from "./utility";
+import type { AsyncFunction, 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;
-export declare let isFunction: (t: unknown) => t is Function;
-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 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 globalThis.Generator<unknown, unknown, unknown>;
-export declare let isAsyncGeneratorFunction: (t: unknown) => t is globalThis.AsyncGenerator<unknown, unknown, unknown>;
+export declare let isBoolean: (target: unknown) => target is boolean;
+export declare let isString: (target: unknown) => target is string;
+export declare let isNumber: (target: unknown) => target is number;
+export declare let isFunction: (target: unknown) => target is Function;
+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 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 isHashable: (target: unknown) => target is Hashable;
+export declare let isHashMap: (target: unknown) => target is HashMap<unknown, unknown>;
+export declare let isHashSet: (target: unknown) => target is HashSet<unknown>;
+export declare let 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>;