compostjs 0.0.11 → 0.1.0

package/dist/fable_modules/fable-library-js.4.28.0/FSharp.Core.js

@@ -0,0 +1,69 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Global.d.ts

@@ -0,0 +1,24 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Global.js

@@ -0,0 +1,8 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Guid.d.ts

@@ -0,0 +1,10 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Guid.js

@@ -0,0 +1,142 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Int32.d.ts

@@ -0,0 +1,28 @@
+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/dist/fable_modules/fable-library-js.4.28.0/Int32.js

@@ -0,0 +1,135 @@
+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/dist/fable_modules/fable-library-js.4.28.0/List.d.ts

@@ -0,0 +1,143 @@
+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>;