compostjs 0.0.11 → 0.1.0

package/dist/fable_modules/fable-library-js.4.28.0/Uri.js

@@ -0,0 +1,159 @@
+const ok = (value) => ({
+    tag: "ok",
+    value,
+});
+const error = (error) => ({ tag: "error", error });
+export class Uri {
+    constructor(state) {
+        this.uri = state;
+    }
+    static isAbsoluteUri(uri) {
+        try {
+            new URL(uri);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static tryCreateWithKind(uri, kind) {
+        switch (kind) {
+            case 1 /* UriKind.Absolute */:
+                return Uri.isAbsoluteUri(uri)
+                    ? ok(new Uri({ original: uri, value: new URL(uri), kind }))
+                    : error("Invalid URI: The format of the URI could not be determined.");
+            case 2 /* UriKind.Relative */:
+                return Uri.isAbsoluteUri(uri)
+                    ? error("URI is not a relative path.")
+                    : ok(new Uri({ original: uri, value: uri, kind }));
+            case 0 /* UriKind.RelativeOrAbsolute */:
+                return Uri.isAbsoluteUri(uri)
+                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: 1 /* UriKind.Absolute */ }))
+                    : ok(new Uri({ original: uri, value: uri, kind: 2 /* UriKind.Relative */ }));
+            default:
+                const never = kind;
+                return never;
+        }
+    }
+    static tryCreateWithBase(baseUri, relativeUri) {
+        return baseUri.uri.kind !== 1 /* UriKind.Absolute */
+            ? error("Base URI should have Absolute kind")
+            : typeof relativeUri === "string"
+                ? ok(new Uri({
+                    original: new URL(relativeUri, baseUri.uri.value).toString(),
+                    value: new URL(relativeUri, baseUri.uri.value),
+                    kind: 1 /* UriKind.Absolute */,
+                }))
+                : relativeUri.uri.kind === 2 /* UriKind.Relative */
+                    ? ok(new Uri({
+                        original: new URL(relativeUri.uri.value, baseUri.uri.value).toString(),
+                        value: new URL(relativeUri.uri.value, baseUri.uri.value),
+                        kind: 1 /* UriKind.Absolute */,
+                    }))
+                    : ok(baseUri);
+    }
+    static tryCreateImpl(value, kindOrUri = 1 /* UriKind.Absolute */) {
+        return typeof value === "string"
+            ? typeof kindOrUri !== "number"
+                ? error("Kind must be specified when the baseUri is a string.")
+                : Uri.tryCreateWithKind(value, kindOrUri)
+            : typeof kindOrUri === "number"
+                ? error("Kind should not be specified when the baseUri is an absolute Uri.")
+                : Uri.tryCreateWithBase(value, kindOrUri);
+    }
+    static create(value, kindOrUri = 1 /* UriKind.Absolute */) {
+        const result = Uri.tryCreateImpl(value, kindOrUri);
+        switch (result.tag) {
+            case "ok":
+                return result.value;
+            case "error":
+                throw new Error(result.error);
+            default:
+                const never = result;
+                return never;
+        }
+    }
+    static tryCreate(value, kindOrUri = 1 /* UriKind.Absolute */, out) {
+        const result = Uri.tryCreateImpl(value, kindOrUri);
+        switch (result.tag) {
+            case "ok":
+                out.contents = result.value;
+                return true;
+            case "error":
+                return false;
+            default:
+                const never = result;
+                return never;
+        }
+    }
+    toString() {
+        switch (this.uri.kind) {
+            case 1 /* UriKind.Absolute */:
+                return decodeURIComponent(this.asUrl().toString());
+            case 2 /* UriKind.Relative */:
+                return this.uri.value;
+            default:
+                const never = this.uri;
+                return never;
+        }
+    }
+    asUrl() {
+        switch (this.uri.kind) {
+            case 1 /* UriKind.Absolute */:
+                return this.uri.value;
+            case 2 /* UriKind.Relative */:
+                throw new Error("This operation is not supported for a relative URI.");
+            default:
+                const never = this.uri;
+                return never;
+        }
+    }
+    get isAbsoluteUri() {
+        return this.uri.kind === 1 /* UriKind.Absolute */;
+    }
+    get absoluteUri() {
+        return this.asUrl().href;
+    }
+    get scheme() {
+        const protocol = this.asUrl().protocol;
+        return protocol.slice(0, protocol.length - 1);
+    }
+    get host() {
+        const host = this.asUrl().host;
+        if (host.includes(":")) {
+            return host.split(":")[0];
+        }
+        else {
+            return host;
+        }
+    }
+    get absolutePath() {
+        return this.asUrl().pathname;
+    }
+    get query() {
+        return this.asUrl().search;
+    }
+    get isDefaultPort() {
+        return this.port === 80;
+    }
+    get port() {
+        const port = this.asUrl().port;
+        if (port === "") {
+            return 80;
+        }
+        else {
+            return parseInt(port);
+        }
+    }
+    get pathAndQuery() {
+        const url = this.asUrl();
+        return url.pathname + url.search;
+    }
+    get fragment() {
+        return this.asUrl().hash;
+    }
+    get originalString() {
+        return this.uri.original;
+    }
+}
+export default Uri;

package/dist/fable_modules/fable-library-js.4.28.0/Util.d.ts

@@ -0,0 +1,210 @@
+export declare const enum DateKind {
+    Unspecified = 0,
+    UTC = 1,
+    Local = 2
+}
+export interface IDateTime extends Date {
+    kind?: DateKind;
+}
+export interface IDateTimeOffset extends Date {
+    offset?: number;
+}
+export interface IComparable<T> extends IEquatable<T> {
+    CompareTo(x: T): number;
+}
+export interface IEquatable<T> {
+    Equals(x: T): boolean;
+}
+export interface IHashable {
+    GetHashCode(): number;
+}
+export interface IDisposable {
+    Dispose(): void;
+}
+export interface IComparer<T> {
+    Compare(x: T, y: T): number;
+}
+export interface IEqualityComparer<T> {
+    Equals(x: T, y: T): boolean;
+    GetHashCode(x: T): number;
+}
+export interface ICollection<T> extends Iterable<T> {
+    readonly Count: number;
+    readonly IsReadOnly: boolean;
+    Add(item: T): void;
+    Clear(): void;
+    Contains(item: T): boolean;
+    CopyTo(array: T[], arrayIndex: number): void;
+    Remove(item: T): boolean;
+}
+export declare function isArrayLike<T>(x: T | ArrayLike<T> | Iterable<T>): x is T[];
+export declare function isIterable<T>(x: T | ArrayLike<T> | Iterable<T>): x is Iterable<T>;
+export declare function isEnumerable<T>(x: T | Iterable<T>): x is IEnumerable<T>;
+export declare function isComparer<T>(x: T | IComparer<T>): x is IComparer<T>;
+export declare function isComparable<T>(x: T | IComparable<T>): x is IComparable<T>;
+export declare function isEquatable<T>(x: T | IEquatable<T>): x is IEquatable<T>;
+export declare function isHashable<T>(x: T | IHashable): x is IHashable;
+export declare function isDisposable<T>(x: T | IDisposable): x is IDisposable;
+export declare function disposeSafe(x: any): void;
+export declare function defaultOf<T>(): T;
+export declare function sameConstructor<T>(x: T, y: T): boolean;
+export interface IEnumerator<T> extends IDisposable {
+    ["System.Collections.Generic.IEnumerator`1.get_Current"](): T;
+    ["System.Collections.IEnumerator.get_Current"](): T;
+    ["System.Collections.IEnumerator.MoveNext"](): boolean;
+    ["System.Collections.IEnumerator.Reset"](): void;
+    Dispose(): void;
+}
+export interface IEnumerable<T> extends Iterable<T> {
+    GetEnumerator(): IEnumerator<T>;
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
+}
+export declare class Enumerable<T> implements IEnumerable<T> {
+    private en;
+    constructor(en: IEnumerator<T>);
+    GetEnumerator(): IEnumerator<T>;
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
+    [Symbol.iterator](): this;
+    next(): IteratorResult<T>;
+}
+export declare class Enumerator<T> implements IEnumerator<T> {
+    private iter;
+    private current;
+    constructor(iter: Iterator<T>);
+    ["System.Collections.Generic.IEnumerator`1.get_Current"](): T;
+    ["System.Collections.IEnumerator.get_Current"](): T;
+    ["System.Collections.IEnumerator.MoveNext"](): boolean;
+    ["System.Collections.IEnumerator.Reset"](): void;
+    Dispose(): void;
+}
+export declare function toEnumerable<T>(e: IEnumerable<T> | Iterable<T>): IEnumerable<T>;
+export declare function getEnumerator<T>(e: IEnumerable<T> | Iterable<T>): IEnumerator<T>;
+export declare function toIterator<T>(en: IEnumerator<T>): Iterator<T>;
+export declare function enumerableToIterator<T>(e: IEnumerable<T> | Iterable<T>): Iterator<T>;
+export interface ISet<T> {
+    add(value: T): ISet<T>;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackfn: (value: T, value2: T, set: ISet<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+    [Symbol.iterator](): Iterator<T>;
+    entries(): Iterable<[T, T]>;
+    keys(): Iterable<T>;
+    values(): Iterable<T>;
+}
+export interface IMapOrWeakMap<K, V> {
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): IMapOrWeakMap<K, V>;
+}
+export interface IMap<K, V> extends IMapOrWeakMap<K, V> {
+    clear(): void;
+    set(key: K, value: V): IMap<K, V>;
+    forEach(callbackfn: (value: V, key: K, map: IMap<K, V>) => void, thisArg?: any): void;
+    readonly size: number;
+    [Symbol.iterator](): Iterator<[K, V]>;
+    entries(): Iterable<[K, V]>;
+    keys(): Iterable<K>;
+    values(): Iterable<V>;
+}
+export declare class Comparer<T> implements IComparer<T> {
+    Compare: (x: T, y: T) => number;
+    constructor(f?: (x: T, y: T) => number);
+}
+export declare function comparerFromEqualityComparer<T>(comparer: IEqualityComparer<T>): IComparer<T>;
+export declare function assertEqual<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertNotEqual<T>(actual: T, expected: T, msg?: string): void;
+export declare class Lazy<T> {
+    private factory;
+    private isValueCreated;
+    private createdValue?;
+    constructor(factory: () => T);
+    get Value(): T | undefined;
+    get IsValueCreated(): boolean;
+}
+export declare function lazyFromValue<T>(v: T): Lazy<T>;
+export declare function padWithZeros(i: number, length: number): string;
+export declare function padLeftAndRightWithZeros(i: number, lengthLeft: number, lengthRight: number): string;
+export declare function dateOffset(date: IDateTime | IDateTimeOffset): number;
+export declare function int16ToString(i: number, radix?: number): string;
+export declare function int32ToString(i: number, radix?: number): string;
+export declare function int64ToString(i: bigint, radix?: number): string;
+export declare abstract class ObjectRef {
+    static id(o: any): any;
+    private static idMap;
+    private static count;
+}
+export declare function stringHash(s: string): number;
+export declare function numberHash(x: number): number;
+export declare function bigintHash(x: bigint): number;
+export declare function combineHashCodes(hashes: ArrayLike<number>): number;
+export declare function physicalHash<T>(x: T): number;
+export declare function identityHash<T>(x: T): number;
+export declare function dateHash(x: Date): number;
+export declare function arrayHash<T>(x: ArrayLike<T>): number;
+export declare function structuralHash<T>(x: T): number;
+export declare function fastStructuralHash<T>(x: T): number;
+export declare function safeHash<T>(x: T): number;
+export declare function equalArraysWith<T>(x: ArrayLike<T>, y: ArrayLike<T>, eq: (x: T, y: T) => boolean): boolean;
+export declare function equalArrays<T>(x: ArrayLike<T>, y: ArrayLike<T>): boolean;
+export declare function physicalEquality<T>(x: T, y: T): boolean;
+export declare function equals<T>(x: T, y: T): boolean;
+export declare function compareDates(x: Date | IDateTime | IDateTimeOffset, y: Date | IDateTime | IDateTimeOffset): 0 | 1 | -1;
+export declare function comparePrimitives<T>(x: T, y: T): number;
+export declare function compareArraysWith<T>(x: ArrayLike<T>, y: ArrayLike<T>, comp: (x: T, y: T) => number): number;
+export declare function compareArrays<T>(x: ArrayLike<T>, y: ArrayLike<T>): number;
+export declare function compare<T>(x: T, y: T): number;
+export declare function min<T>(comparer: (x: T, y: T) => number, x: T, y: T): T;
+export declare function max<T>(comparer: (x: T, y: T) => number, x: T, y: T): T;
+export declare function clamp<T>(comparer: (x: T, y: T) => number, value: T, min: T, max: T): T;
+export declare function createAtom<T>(value: T): (<Args extends [] | [T]>(...args: Args) => Args extends [] ? T : void);
+export declare function createObj(fields: Iterable<[string, any]>): any;
+export declare function jsOptions<T>(mutator: (x: T) => void): T;
+export declare function round(value: number, digits?: number): number;
+export declare function sign(x: number): number;
+export declare function unescapeDataString(s: string): string;
+export declare function escapeDataString(s: string): string;
+export declare function escapeUriString(s: string): string;
+export declare function count<T>(col: Iterable<T>): number;
+export declare function clear<T>(col: Iterable<T>): void;
+export declare function uncurry2<T1, T2, TResult>(f: (a1: T1) => (a2: T2) => TResult): (a1: T1, a2: T2) => TResult;
+export declare function curry2<T1, T2, TResult>(f: (a1: T1, a2: T2) => TResult): (a1: T1) => (a2: T2) => TResult;
+export declare function uncurry3<T1, T2, T3, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => TResult): (a1: T1, a2: T2, a3: T3) => TResult;
+export declare function curry3<T1, T2, T3, TResult>(f: (a1: T1, a2: T2, a3: T3) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => TResult;
+export declare function uncurry4<T1, T2, T3, T4, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4) => TResult;
+export declare function curry4<T1, T2, T3, T4, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => TResult;
+export declare function uncurry5<T1, T2, T3, T4, T5, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => TResult;
+export declare function curry5<T1, T2, T3, T4, T5, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => TResult;
+export declare function uncurry6<T1, T2, T3, T4, T5, T6, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => TResult;
+export declare function curry6<T1, T2, T3, T4, T5, T6, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => TResult;
+export declare function uncurry7<T1, T2, T3, T4, T5, T6, T7, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7) => TResult;
+export declare function curry7<T1, T2, T3, T4, T5, T6, T7, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => TResult;
+export declare function uncurry8<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8) => TResult;
+export declare function curry8<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => TResult;
+export declare function uncurry9<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => TResult;
+export declare function curry9<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => TResult;
+export declare function uncurry10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10) => TResult;
+export declare function curry10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => TResult;
+export declare function uncurry11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11) => TResult;
+export declare function curry11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => TResult;
+export declare function uncurry12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12) => TResult;
+export declare function curry12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => TResult;
+export declare function uncurry13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13) => TResult;
+export declare function curry13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => TResult;
+export declare function uncurry14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14) => TResult;
+export declare function curry14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => TResult;
+export declare function uncurry15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15) => TResult;
+export declare function curry15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => TResult;
+export declare function uncurry16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16) => TResult;
+export declare function curry16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => TResult;
+export declare function uncurry17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17) => TResult;
+export declare function curry17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => TResult;
+export declare function uncurry18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18) => TResult;
+export declare function curry18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => TResult;
+export declare function uncurry19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18, a19: T19) => TResult;
+export declare function curry19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18, a19: T19) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => TResult;
+export declare function uncurry20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => (a20: T20) => TResult): (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18, a19: T19, a20: T20) => TResult;
+export declare function curry20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18, a19: T19, a20: T20) => TResult): (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => (a20: T20) => TResult;
+export declare function copyToArray<T>(source: T[], sourceIndex: number, target: T[], targetIndex: number, count: number): void;