@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/fable_modules/fable-library-js.4.24.0/FSharp.Core.js

@@ -1,69 +0,0 @@
-import { disposeSafe, defaultOf, structuralHash, equals } from "./Util.js";
-import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
-import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
-export const LanguagePrimitives_GenericEqualityComparer = {
-    "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
-        return equals(x, y);
-    },
-    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
-        return structuralHash(x_1);
-    },
-};
-export const LanguagePrimitives_GenericEqualityERComparer = {
-    "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
-        return equals(x, y);
-    },
-    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
-        return structuralHash(x_1);
-    },
-};
-export function LanguagePrimitives_FastGenericComparer() {
-    return ComparisonIdentity_Structural();
-}
-export function LanguagePrimitives_FastGenericComparerFromTable() {
-    return ComparisonIdentity_Structural();
-}
-export function LanguagePrimitives_FastGenericEqualityComparer() {
-    return HashIdentity_Structural();
-}
-export function LanguagePrimitives_FastGenericEqualityComparerFromTable() {
-    return HashIdentity_Structural();
-}
-export function Operators_Failure(message) {
-    return new Error(message);
-}
-export function Operators_FailurePattern(exn) {
-    return exn.message;
-}
-export function Operators_NullArg(x) {
-    throw new Error(x);
-}
-export function Operators_Using(resource, action) {
-    try {
-        return action(resource);
-    }
-    finally {
-        if (equals(resource, defaultOf())) {
-        }
-        else {
-            let copyOfStruct = resource;
-            disposeSafe(copyOfStruct);
-        }
-    }
-}
-export function Operators_Lock(_lockObj, action) {
-    return action();
-}
-export function ExtraTopLevelOperators_LazyPattern(input) {
-    return input.Value;
-}
-export function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {
-    return format.cont((s) => {
-        StringBuilder__Append_Z721C83C5(builder, s);
-        return continuation();
-    });
-}
-export function PrintfModule_PrintFormatToStringBuilder(builder, format) {
-    return PrintfModule_PrintFormatToStringBuilderThen(() => {
-    }, builder, format);
-}

package/fable_modules/fable-library-js.4.24.0/Global.d.ts

@@ -1,24 +0,0 @@
-import { int32 } from "./Int32.js";
-export interface Fable_Core_IGenericAdder$1<T> {
-    Add(arg0: T, arg1: T): T;
-    GetZero(): T;
-}
-export interface Fable_Core_IGenericAverager$1<T> {
-    Add(arg0: T, arg1: T): T;
-    DivideByInt(arg0: T, arg1: int32): T;
-    GetZero(): T;
-}
-export interface Fable_Core_Symbol_wellknown {
-    [Symbol.toStringTag]: string;
-}
-export interface Fable_Core_IJsonSerializable {
-    toJSON(): any;
-}
-export declare const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
-export declare const SR_inputWasEmpty = "Collection was empty.";
-export declare const SR_inputMustBeNonNegative = "The input must be non-negative.";
-export declare const SR_inputSequenceEmpty = "The input sequence was empty.";
-export declare const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
-export declare const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
-export declare const SR_differentLengths = "The collections had different lengths.";
-export declare const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";

package/fable_modules/fable-library-js.4.24.0/Global.js

@@ -1,8 +0,0 @@
-export const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
-export const SR_inputWasEmpty = "Collection was empty.";
-export const SR_inputMustBeNonNegative = "The input must be non-negative.";
-export const SR_inputSequenceEmpty = "The input sequence was empty.";
-export const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
-export const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
-export const SR_differentLengths = "The collections had different lengths.";
-export const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";

package/fable_modules/fable-library-js.4.24.0/Guid.d.ts

@@ -1,10 +0,0 @@
-import { FSharpRef } from "./Types.js";
-export declare function toString(str: string, format?: string, _provider?: any): string;
-/** Validates UUID as specified in RFC4122 (versions 1-5). */
-export declare function parse(str: string): string;
-export declare function tryParse(str: string, defValue: FSharpRef<string>): boolean;
-export declare function newGuid(): string;
-/** Parse a UUID into it's component bytes */
-export declare function guidToArray(s: string): number[];
-/** Convert UUID byte array into a string */
-export declare function arrayToGuid(buf: ArrayLike<number>): string;

package/fable_modules/fable-library-js.4.24.0/Guid.js

@@ -1,142 +0,0 @@
-import { trim } from "./String.js";
-// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220
-// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-// Relax GUID parsing, see #1637
-const guidRegex = /^[\(\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\)\}]{0,2}$/;
-const guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;
-const guidRegexHex = /^\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\}\}$/;
-const guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;
-export function toString(str, format, _provider) {
-    if (format && format?.length > 0) {
-        switch (format) {
-            case "N":
-                return str.replace(/-/g, '');
-            case "D":
-                return str;
-            case "B":
-                return "{" + str + "}";
-            case "P":
-                return "(" + str + ")";
-            case "X":
-                return str.replace(guidHexCaptures, "{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}");
-            default:
-                throw new Error("Unrecognized Guid print format");
-        }
-    }
-    else {
-        return str;
-    }
-}
-/** Validates UUID as specified in RFC4122 (versions 1-5). */
-export function parse(str) {
-    function hyphenateGuid(str) {
-        return str.replace(guidRegexNoHyphen, "$1-$2-$3-$4-$5");
-    }
-    const wsTrimAndLowered = str.trim().toLowerCase();
-    if (guidRegex.test(wsTrimAndLowered)) {
-        return trim(wsTrimAndLowered, "{", "}", "(", ")");
-    }
-    else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {
-        return hyphenateGuid(wsTrimAndLowered);
-    }
-    else if (guidRegexHex.test(wsTrimAndLowered)) {
-        return hyphenateGuid(wsTrimAndLowered.replace(/[\{\},]|0x/g, ''));
-    }
-    else {
-        throw new Error("Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
-    }
-}
-export function tryParse(str, defValue) {
-    try {
-        defValue.contents = parse(str);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// From https://gist.github.com/LeverOne/1308368
-export function newGuid() {
-    let b = "";
-    for (let a = 0; a++ < 36;) {
-        b += a * 51 & 52
-            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)
-            : "-";
-    }
-    return b;
-}
-// Maps for number <-> hex string conversion
-let _convertMapsInitialized = false;
-let _byteToHex;
-let _hexToByte;
-function initConvertMaps() {
-    _byteToHex = new Array(256);
-    _hexToByte = {};
-    for (let i = 0; i < 256; i++) {
-        _byteToHex[i] = (i + 0x100).toString(16).substr(1);
-        _hexToByte[_byteToHex[i]] = i;
-    }
-    _convertMapsInitialized = true;
-}
-/** Parse a UUID into it's component bytes */
-// Adapted from https://github.com/zefferus/uuid-parse
-export function guidToArray(s) {
-    if (!_convertMapsInitialized) {
-        initConvertMaps();
-    }
-    let i = 0;
-    const buf = new Uint8Array(16);
-    s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct) => {
-        switch (i) {
-            // .NET saves first three byte groups with different endianness
-            // See https://stackoverflow.com/a/16722909/3922220
-            case 0:
-            case 1:
-            case 2:
-            case 3:
-                buf[3 - i++] = _hexToByte[oct];
-                break;
-            case 4:
-            case 5:
-                buf[9 - i++] = _hexToByte[oct];
-                break;
-            case 6:
-            case 7:
-                buf[13 - i++] = _hexToByte[oct];
-                break;
-            case 8:
-            case 9:
-            case 10:
-            case 11:
-            case 12:
-            case 13:
-            case 14:
-            case 15:
-                buf[i++] = _hexToByte[oct];
-                break;
-        }
-    }));
-    // Zero out remaining bytes if string was short
-    while (i < 16) {
-        buf[i++] = 0;
-    }
-    return buf;
-}
-/** Convert UUID byte array into a string */
-export function arrayToGuid(buf) {
-    if (buf.length !== 16) {
-        throw new Error("Byte array for GUID must be exactly 16 bytes long");
-    }
-    if (!_convertMapsInitialized) {
-        initConvertMaps();
-    }
-    const guid = _byteToHex[buf[3]] + _byteToHex[buf[2]] +
-        _byteToHex[buf[1]] + _byteToHex[buf[0]] + "-" +
-        _byteToHex[buf[5]] + _byteToHex[buf[4]] + "-" +
-        _byteToHex[buf[7]] + _byteToHex[buf[6]] + "-" +
-        _byteToHex[buf[8]] + _byteToHex[buf[9]] + "-" +
-        _byteToHex[buf[10]] + _byteToHex[buf[11]] +
-        _byteToHex[buf[12]] + _byteToHex[buf[13]] +
-        _byteToHex[buf[14]] + _byteToHex[buf[15]];
-    return guid;
-}

package/fable_modules/fable-library-js.4.24.0/Int32.d.ts

@@ -1,28 +0,0 @@
-import { FSharpRef } from "./Types.js";
-export type int8 = number;
-export type uint8 = number;
-export type int16 = number;
-export type uint16 = number;
-export type int32 = number;
-export type uint32 = number;
-export type float16 = number;
-export type float32 = number;
-export type float64 = number;
-export declare enum NumberStyles {
-    AllowHexSpecifier = 512
-}
-export declare function getPrefix(radix: number): string;
-export declare function getRadix(prefix: string, style: number): 2 | 8 | 16 | 10;
-export declare function isValid(str: string, style: number, radix?: number): {
-    sign: string;
-    prefix: string;
-    digits: string;
-    radix: number;
-} | null;
-export declare function parse(str: string, style: number, unsigned: boolean, bitsize: number, radix?: number): number;
-export declare function tryParse(str: string, style: number, unsigned: boolean, bitsize: number, defValue: FSharpRef<number>): boolean;
-export declare function op_UnaryNegation_Int8(x: number): number;
-export declare function op_UnaryNegation_Int16(x: number): number;
-export declare function op_UnaryNegation_Int32(x: number): number;
-export declare function divRem(x: number, y: number): [number, number];
-export declare function divRem(x: number, y: number, out: FSharpRef<number>): number;

package/fable_modules/fable-library-js.4.24.0/Int32.js

@@ -1,135 +0,0 @@
-export var NumberStyles;
-(function (NumberStyles) {
-    // None = 0x00000000,
-    // AllowLeadingWhite = 0x00000001,
-    // AllowTrailingWhite = 0x00000002,
-    // AllowLeadingSign = 0x00000004,
-    // AllowTrailingSign = 0x00000008,
-    // AllowParentheses = 0x00000010,
-    // AllowDecimalPoint = 0x00000020,
-    // AllowThousands = 0x00000040,
-    // AllowExponent = 0x00000080,
-    // AllowCurrencySymbol = 0x00000100,
-    NumberStyles[NumberStyles["AllowHexSpecifier"] = 512] = "AllowHexSpecifier";
-    // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,
-    // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,
-    // Number = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |
-    //          AllowTrailingSign | AllowDecimalPoint | AllowThousands,
-    // Float = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |
-    //         AllowDecimalPoint | AllowExponent,
-    // Currency = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
-    //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,
-    // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
-    //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,
-})(NumberStyles || (NumberStyles = {}));
-function validResponse(regexMatch, radix) {
-    const [/*all*/ , sign, prefix, digits] = regexMatch;
-    return {
-        sign: sign || "",
-        prefix: prefix || "",
-        digits,
-        radix,
-    };
-}
-function getRange(unsigned, bitsize) {
-    switch (bitsize) {
-        case 8: return unsigned ? [0, 255] : [-128, 127];
-        case 16: return unsigned ? [0, 65535] : [-32768, 32767];
-        case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];
-        default: throw new Error("Invalid bit size.");
-    }
-}
-function getInvalidDigits(radix) {
-    switch (radix) {
-        case 2: return /[^0-1]/;
-        case 8: return /[^0-7]/;
-        case 10: return /[^0-9]/;
-        case 16: return /[^0-9a-fA-F]/;
-        default:
-            throw new Error("Invalid Base.");
-    }
-}
-export function getPrefix(radix) {
-    switch (radix) {
-        case 2: return "0b";
-        case 8: return "0o";
-        case 10: return "";
-        case 16: return "0x";
-        default: return "";
-    }
-}
-export function getRadix(prefix, style) {
-    if (style & NumberStyles.AllowHexSpecifier) {
-        return 16;
-    }
-    else {
-        switch (prefix) {
-            case "0b":
-            case "0B": return 2;
-            case "0o":
-            case "0O": return 8;
-            case "0x":
-            case "0X": return 16;
-            default: return 10;
-        }
-    }
-}
-export function isValid(str, style, radix) {
-    const integerRegex = /^\s*([\+\-])?(0[xXoObB])?([0-9a-fA-F]+)\s*$/;
-    const res = integerRegex.exec(str.replace(/_/g, ""));
-    if (res != null) {
-        const [/*all*/ , /*sign*/ , prefix, digits] = res;
-        radix = radix || getRadix(prefix, style);
-        const invalidDigits = getInvalidDigits(radix);
-        if (!invalidDigits.test(digits)) {
-            return validResponse(res, radix);
-        }
-    }
-    return null;
-}
-export function parse(str, style, unsigned, bitsize, radix) {
-    const res = isValid(str, style, radix);
-    if (res != null) {
-        let v = Number.parseInt(res.sign + res.digits, res.radix);
-        if (!Number.isNaN(v)) {
-            const [umin, umax] = getRange(true, bitsize);
-            if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {
-                v = v << (32 - bitsize) >> (32 - bitsize);
-            }
-            const [min, max] = getRange(unsigned, bitsize);
-            if (v >= min && v <= max) {
-                return v;
-            }
-        }
-    }
-    throw new Error(`The input string ${str} was not in a correct format.`);
-}
-export function tryParse(str, style, unsigned, bitsize, defValue) {
-    try {
-        defValue.contents = parse(str, style, unsigned, bitsize);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function op_UnaryNegation_Int8(x) {
-    return x === -128 ? x : -x;
-}
-export function op_UnaryNegation_Int16(x) {
-    return x === -32768 ? x : -x;
-}
-export function op_UnaryNegation_Int32(x) {
-    return x === -2147483648 ? x : -x;
-}
-export function divRem(x, y, out) {
-    const div = ~~(x / y);
-    const rem = x % y;
-    if (out === void 0) {
-        return [div, rem];
-    }
-    else {
-        out.contents = rem;
-        return div;
-    }
-}

package/fable_modules/fable-library-js.4.24.0/List.d.ts

@@ -1,143 +0,0 @@
-import { Option } from "./Option.js";
-import { IComparer, IEqualityComparer, IDisposable, IEnumerator } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { Record } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class FSharpList<T> extends Record implements Iterable<T> {
-    readonly head: T;
-    tail: Option<FSharpList<T>>;
-    constructor(head: T, tail: Option<FSharpList<T>>);
-    toString(): string;
-    Equals(other: any): boolean;
-    GetHashCode(): int32;
-    toJSON(): any;
-    CompareTo(other: any): int32;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function FSharpList_$reflection(gen0: TypeInfo): TypeInfo;
-export declare class ListEnumerator$1<T> implements IEnumerator<T>, IDisposable {
-    readonly xs: FSharpList<T>;
-    it: FSharpList<T>;
-    current: T;
-    constructor(xs: FSharpList<T>);
-    "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
-    "System.Collections.IEnumerator.get_Current"(): any;
-    "System.Collections.IEnumerator.MoveNext"(): boolean;
-    "System.Collections.IEnumerator.Reset"(): void;
-    Dispose(): void;
-}
-export declare function ListEnumerator$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function ListEnumerator$1_$ctor_3002E699<T>(xs: FSharpList<T>): ListEnumerator$1<T>;
-export declare function FSharpList_get_Empty<T>(): FSharpList<T>;
-export declare function FSharpList_Cons_305B8EAC<T>(x: T, xs: FSharpList<T>): FSharpList<T>;
-export declare function FSharpList__get_IsEmpty<T>(xs: FSharpList<T>): boolean;
-export declare function FSharpList__get_Length<T>(xs: FSharpList<T>): int32;
-export declare function FSharpList__get_Head<T>(xs: FSharpList<T>): T;
-export declare function FSharpList__get_Tail<T>(xs: FSharpList<T>): FSharpList<T>;
-export declare function FSharpList__get_Item_Z524259A4<T>(xs: FSharpList<T>, index: int32): T;
-export declare function indexNotFound<$a>(): $a;
-export declare function empty<$a>(): FSharpList<$a>;
-export declare function cons<T>(x: T, xs: FSharpList<T>): FSharpList<T>;
-export declare function singleton<$a>(x: $a): FSharpList<$a>;
-export declare function isEmpty<T>(xs: FSharpList<T>): boolean;
-export declare function length<T>(xs: FSharpList<T>): int32;
-export declare function head<T>(xs: FSharpList<T>): T;
-export declare function tryHead<T>(xs: FSharpList<T>): Option<T>;
-export declare function tail<T>(xs: FSharpList<T>): FSharpList<T>;
-export declare function tryLast<T>(xs_mut: FSharpList<T>): Option<T>;
-export declare function last<T>(xs: FSharpList<T>): T;
-export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: FSharpList<T>, ys: FSharpList<T>): int32;
-export declare function toArray<T>(xs: FSharpList<T>): T[];
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, xs: FSharpList<T>): State;
-export declare function reverse<T>(xs: FSharpList<T>): FSharpList<T>;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: FSharpList<T>, state: State): State;
-export declare function foldIndexed<State, T>(folder: ((arg0: int32, arg1: State, arg2: T) => State), state: State, xs: FSharpList<T>): State;
-export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, xs: FSharpList<T1>, ys: FSharpList<T2>): State;
-export declare function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: FSharpList<T1>, ys: FSharpList<T2>, state: State): State;
-export declare function unfold<State, T>(gen: ((arg0: State) => Option<[T, State]>), state: State): FSharpList<T>;
-export declare function iterate<$a>(action: ((arg0: $a) => void), xs: FSharpList<$a>): void;
-export declare function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: FSharpList<$a>, ys: FSharpList<$b>): void;
-export declare function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: FSharpList<$a>): void;
-export declare function iterateIndexed2<$a, $b>(action: ((arg0: int32, arg1: $a, arg2: $b) => void), xs: FSharpList<$a>, ys: FSharpList<$b>): void;
-export declare function toSeq<T>(xs: FSharpList<T>): Iterable<T>;
-export declare function ofArrayWithTail<T>(xs: T[], tail_1: FSharpList<T>): FSharpList<T>;
-export declare function ofArray<T>(xs: T[]): FSharpList<T>;
-export declare function ofSeq<T>(xs: Iterable<T>): FSharpList<T>;
-export declare function concat<T>(lists: Iterable<FSharpList<T>>): FSharpList<T>;
-export declare function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state: State, xs: FSharpList<T>): FSharpList<State>;
-export declare function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: FSharpList<T>, state: State): FSharpList<State>;
-export declare function append<T>(xs: FSharpList<T>, ys: FSharpList<T>): FSharpList<T>;
-export declare function collect<T, U>(mapping: ((arg0: T) => FSharpList<U>), xs: FSharpList<T>): FSharpList<U>;
-export declare function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: FSharpList<T>): FSharpList<U>;
-export declare function map<T, U>(mapping: ((arg0: T) => U), xs: FSharpList<T>): FSharpList<U>;
-export declare function indexed<$a>(xs: FSharpList<$a>): FSharpList<[int32, $a]>;
-export declare function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<U>;
-export declare function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T2) => U), xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<U>;
-export declare function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) => U), xs: FSharpList<T1>, ys: FSharpList<T2>, zs: FSharpList<T3>): FSharpList<U>;
-export declare function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: FSharpList<T>): [FSharpList<Result>, State];
-export declare function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), xs: FSharpList<T>, state: State): [FSharpList<Result>, State];
-export declare function tryPick<T, $a>(f: ((arg0: T) => Option<$a>), xs: FSharpList<T>): Option<$a>;
-export declare function pick<$a, $b>(f: ((arg0: $a) => Option<$b>), xs: FSharpList<$a>): $b;
-export declare function tryFind<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<$a>;
-export declare function find<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): $a;
-export declare function tryFindBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<$a>;
-export declare function findBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): $a;
-export declare function tryFindIndex<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): Option<int32>;
-export declare function findIndex<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): int32;
-export declare function tryFindIndexBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): Option<int32>;
-export declare function findIndexBack<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): int32;
-export declare function tryItem<T>(n: int32, xs: FSharpList<T>): Option<T>;
-export declare function item<T>(n: int32, xs: FSharpList<T>): T;
-export declare function filter<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpList<T>;
-export declare function partition<T>(f: ((arg0: T) => boolean), xs: FSharpList<T>): [FSharpList<T>, FSharpList<T>];
-export declare function choose<T, U>(f: ((arg0: T) => Option<U>), xs: FSharpList<T>): FSharpList<U>;
-export declare function contains<T>(value: T, xs: FSharpList<T>, eq: IEqualityComparer<T>): boolean;
-export declare function initialize<T>(n: int32, f: ((arg0: int32) => T)): FSharpList<T>;
-export declare function replicate<$a>(n: int32, x: $a): FSharpList<$a>;
-export declare function reduce<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T;
-export declare function reduceBack<T>(f: ((arg0: T, arg1: T) => T), xs: FSharpList<T>): T;
-export declare function forAll<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): boolean;
-export declare function forAll2<$a, $b>(f: ((arg0: $a, arg1: $b) => boolean), xs: FSharpList<$a>, ys: FSharpList<$b>): boolean;
-export declare function exists<$a>(f: ((arg0: $a) => boolean), xs: FSharpList<$a>): boolean;
-export declare function exists2<T1, T2>(f_mut: ((arg0: T1, arg1: T2) => boolean), xs_mut: FSharpList<T1>, ys_mut: FSharpList<T2>): boolean;
-export declare function unzip<$a, $b>(xs: FSharpList<[$a, $b]>): [FSharpList<$a>, FSharpList<$b>];
-export declare function unzip3<$a, $b, $c>(xs: FSharpList<[$a, $b, $c]>): [FSharpList<$a>, FSharpList<$b>, FSharpList<$c>];
-export declare function zip<$a, $b>(xs: FSharpList<$a>, ys: FSharpList<$b>): FSharpList<[$a, $b]>;
-export declare function zip3<$a, $b, $c>(xs: FSharpList<$a>, ys: FSharpList<$b>, zs: FSharpList<$c>): FSharpList<[$a, $b, $c]>;
-export declare function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: FSharpList<T>): FSharpList<T>;
-export declare function sort<T>(xs: FSharpList<T>, comparer: IComparer<T>): FSharpList<T>;
-export declare function sortBy<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): FSharpList<T>;
-export declare function sortDescending<T>(xs: FSharpList<T>, comparer: IComparer<T>): FSharpList<T>;
-export declare function sortByDescending<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): FSharpList<T>;
-export declare function sum<T>(xs: FSharpList<T>, adder: any): T;
-export declare function sumBy<T, U>(f: ((arg0: T) => U), xs: FSharpList<T>, adder: any): U;
-export declare function maxBy<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): T;
-export declare function max<T>(xs: FSharpList<T>, comparer: IComparer<T>): T;
-export declare function minBy<T, U>(projection: ((arg0: T) => U), xs: FSharpList<T>, comparer: IComparer<U>): T;
-export declare function min<T>(xs: FSharpList<T>, comparer: IComparer<T>): T;
-export declare function average<T>(xs: FSharpList<T>, averager: any): T;
-export declare function averageBy<T, U>(f: ((arg0: T) => U), xs: FSharpList<T>, averager: any): U;
-export declare function permute<T>(f: ((arg0: int32) => int32), xs: FSharpList<T>): FSharpList<T>;
-export declare function chunkBySize<T>(chunkSize: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>>;
-export declare function allPairs<T1, T2>(xs: FSharpList<T1>, ys: FSharpList<T2>): FSharpList<[T1, T2]>;
-export declare function skip<T>(count_mut: int32, xs_mut: FSharpList<T>): FSharpList<T>;
-export declare function skipWhile<T>(predicate_mut: ((arg0: T) => boolean), xs_mut: FSharpList<T>): FSharpList<T>;
-export declare function take<T>(count: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpList<T>;
-export declare function truncate<T>(count: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function getSlice<T>(startIndex: Option<int32>, endIndex: Option<int32>, xs: FSharpList<T>): FSharpList<T>;
-export declare function splitAt<T>(index: int32, xs: FSharpList<T>): [FSharpList<T>, FSharpList<T>];
-export declare function exactlyOne<T>(xs: FSharpList<T>): T;
-export declare function tryExactlyOne<T>(xs: FSharpList<T>): Option<T>;
-export declare function where<T>(predicate: ((arg0: T) => boolean), xs: FSharpList<T>): FSharpList<T>;
-export declare function pairwise<T>(xs: FSharpList<T>): FSharpList<[T, T]>;
-export declare function windowed<T>(windowSize: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>>;
-export declare function splitInto<T>(chunks: int32, xs: FSharpList<T>): FSharpList<FSharpList<T>>;
-export declare function transpose<T>(lists: Iterable<FSharpList<T>>): FSharpList<FSharpList<T>>;
-export declare function insertAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T>;
-export declare function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: FSharpList<T>): FSharpList<T>;
-export declare function removeAt<T>(index: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function removeManyAt<T>(index: int32, count: int32, xs: FSharpList<T>): FSharpList<T>;
-export declare function updateAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T>;