@nfdi4plants/arctrl 3.0.0-beta.4 → 3.0.0-beta.6

package/dist/ts/node_modules/@fable-org/fable-library-js/List.js

@@ -1,9 +1,10 @@
 import { join } from './String.js';
-import { value, some } from './Option.js';
-import { toIterator, getEnumerator, equals, structuralHash, compare, defaultOf, isArrayLike, disposeSafe } from './Util.js';
+import { value, some, defaultArg } from './Option.js';
+import { equals, structuralHash, compare, toIterator, getEnumerator, defaultOf, isArrayLike, disposeSafe } from './Util.js';
 import { Record } from './Types.js';
-import { SR_inputWasEmpty, SR_keyNotFoundAlt, SR_indexOutOfBounds } from './Global.js';
-import { fill, setItem, item as item$1, foldBack as foldBack$1, map as map$1, transpose as transpose$1 } from './Array.js';
+import { record_type, option_type, class_type } from './Reflection.js';
+import { SR_inputWasEmpty, SR_indexOutOfBounds, SR_keyNotFoundAlt, SR_differentLengths, SR_notEnoughElements, SR_inputMustBeNonNegative, SR_inputSequenceEmpty, SR_inputSequenceTooLong } from './Global.js';
+import { fill, setItem, foldBack as foldBack$1, foldBack2 as foldBack2$1, item as item$1, scanBack as scanBack$1, tryFindBack as tryFindBack$1, tryFindIndexBack as tryFindIndexBack$1, permute as permute$1, map as map$1, chunkBySize as chunkBySize$1, pairwise as pairwise$1, windowed as windowed$1, splitInto as splitInto$1, transpose as transpose$1 } from './Array.js';
 
 class FSharpList extends Record {
     constructor(head, tail) {
@@ -49,6 +50,7 @@ class FSharpList extends Record {
                     else {
                         return true;
                     }
+                    break;
                 }
             };
             return loop(xs, other);
@@ -75,6 +77,7 @@ class FSharpList extends Record {
                 else {
                     return h | 0;
                 }
+                break;
             }
         };
         return loop(0, 0, xs) | 0;
@@ -114,6 +117,7 @@ class FSharpList extends Record {
                 else {
                     return 0;
                 }
+                break;
             }
         };
         return loop(xs, other) | 0;
@@ -130,6 +134,9 @@ class FSharpList extends Record {
         return getEnumerator(xs);
     }
 }
+function FSharpList_$reflection(gen0) {
+    return record_type("ListModule.FSharpList", [gen0], FSharpList, () => [["head", gen0], ["tail", option_type(FSharpList_$reflection(gen0))]]);
+}
 class ListEnumerator$1 {
     constructor(xs) {
         this.xs = xs;
@@ -165,6 +172,9 @@ class ListEnumerator$1 {
     Dispose() {
     }
 }
+function ListEnumerator$1_$reflection(gen0) {
+    return class_type("ListModule.ListEnumerator`1", [gen0], ListEnumerator$1);
+}
 function ListEnumerator$1_$ctor_3002E699(xs) {
     return new ListEnumerator$1(xs);
 }
@@ -190,6 +200,7 @@ function FSharpList__get_Length(xs) {
             else {
                 return i | 0;
             }
+            break;
         }
     };
     return loop(0, xs) | 0;
@@ -230,6 +241,7 @@ function FSharpList__get_Item_Z524259A4(xs, index) {
             else {
                 throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
             }
+            break;
         }
     };
     return loop(0, xs);
@@ -282,8 +294,51 @@ function tryLast(xs_mut) {
                 continue tryLast;
             }
         }
+        break;
     }
 }
+function last(xs) {
+    const matchValue = tryLast(xs);
+    if (matchValue == null) {
+        throw new Error(SR_inputWasEmpty);
+    }
+    else {
+        return value(matchValue);
+    }
+}
+function compareWith(comparer, xs, ys) {
+    const loop = (xs_1_mut, ys_1_mut) => {
+        loop: while (true) {
+            const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+            const matchValue = FSharpList__get_IsEmpty(xs_1);
+            const matchValue_1 = FSharpList__get_IsEmpty(ys_1);
+            if (matchValue) {
+                if (matchValue_1) {
+                    return 0;
+                }
+                else {
+                    return -1;
+                }
+            }
+            else if (matchValue_1) {
+                return 1;
+            }
+            else {
+                const c = comparer(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)) | 0;
+                if (c === 0) {
+                    xs_1_mut = FSharpList__get_Tail(xs_1);
+                    ys_1_mut = FSharpList__get_Tail(ys_1);
+                    continue loop;
+                }
+                else {
+                    return c | 0;
+                }
+            }
+            break;
+        }
+    };
+    return loop(xs, ys) | 0;
+}
 function toArray(xs) {
     const len = FSharpList__get_Length(xs) | 0;
     const res = fill(new Array(len), 0, len, null);
@@ -330,6 +385,7 @@ function foldIndexed(folder, state, xs) {
                 xs_1_mut = FSharpList__get_Tail(xs_1);
                 continue loop;
             }
+            break;
         }
     };
     return loop(0, state, xs);
@@ -345,17 +401,57 @@ function fold2(folder, state, xs, ys) {
     }
     return acc;
 }
+function foldBack2(folder, xs, ys, state) {
+    return foldBack2$1(folder, toArray(xs), toArray(ys), state);
+}
+function unfold(gen, state) {
+    const loop = (acc_mut, node_mut) => {
+        let t;
+        loop: while (true) {
+            const acc = acc_mut, node = node_mut;
+            const matchValue = gen(acc);
+            if (matchValue != null) {
+                acc_mut = value(matchValue)[1];
+                node_mut = ((t = (new FSharpList(value(matchValue)[0], undefined)), (node.tail = t, t)));
+                continue loop;
+            }
+            else {
+                return node;
+            }
+            break;
+        }
+    };
+    const root = FSharpList_get_Empty();
+    const node_1 = loop(state, root);
+    const t_2 = FSharpList_get_Empty();
+    node_1.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
 function iterate(action, xs) {
     fold((unitVar, x) => {
         action(x);
     }, undefined, xs);
 }
+function iterate2(action, xs, ys) {
+    fold2((unitVar, x, y) => {
+        action(x, y);
+    }, undefined, xs, ys);
+}
 function iterateIndexed(action, xs) {
     fold((i, x) => {
         action(i, x);
         return (i + 1) | 0;
     }, 0, xs);
 }
+function iterateIndexed2(action, xs, ys) {
+    fold2((i, x, y) => {
+        action(i, x, y);
+        return (i + 1) | 0;
+    }, 0, xs, ys);
+}
+function toSeq(xs) {
+    return xs;
+}
 function ofArrayWithTail(xs, tail_1) {
     let res = tail_1;
     for (let i = xs.length - 1; i >= 0; i--) {
@@ -426,6 +522,28 @@ function concat(lists) {
     xs_6.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function scan(folder, state, xs) {
+    let xs_4, t_2;
+    const root = FSharpList_get_Empty();
+    let node;
+    const t = new FSharpList(state, undefined);
+    root.tail = t;
+    node = t;
+    let acc = state;
+    let xs_3 = xs;
+    while (!FSharpList__get_IsEmpty(xs_3)) {
+        acc = folder(acc, FSharpList__get_Head(xs_3));
+        node = ((xs_4 = node, (t_2 = (new FSharpList(acc, undefined)), (xs_4.tail = t_2, t_2))));
+        xs_3 = FSharpList__get_Tail(xs_3);
+    }
+    const xs_6 = node;
+    const t_4 = FSharpList_get_Empty();
+    xs_6.tail = t_4;
+    return FSharpList__get_Tail(root);
+}
+function scanBack(folder, xs, state) {
+    return ofArray(scanBack$1(folder, toArray(xs), state));
+}
 function append(xs, ys) {
     return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));
 }
@@ -469,6 +587,9 @@ function map(mapping, xs) {
     node.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function indexed(xs) {
+    return mapIndexed((i, x) => [i, x], xs);
+}
 function map2(mapping, xs, ys) {
     const root = FSharpList_get_Empty();
     const node = fold2((acc, x, y) => {
@@ -480,6 +601,68 @@ function map2(mapping, xs, ys) {
     node.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function mapIndexed2(mapping, xs, ys) {
+    const loop = (i_mut, acc_mut, xs_1_mut, ys_1_mut) => {
+        let t;
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) {
+                return acc;
+            }
+            else {
+                i_mut = (i + 1);
+                acc_mut = ((t = (new FSharpList(mapping(i, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)), undefined)), (acc.tail = t, t)));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                ys_1_mut = FSharpList__get_Tail(ys_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    const root = FSharpList_get_Empty();
+    const node_1 = loop(0, root, xs, ys);
+    const t_2 = FSharpList_get_Empty();
+    node_1.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function map3(mapping, xs, ys, zs) {
+    const loop = (acc_mut, xs_1_mut, ys_1_mut, zs_1_mut) => {
+        let t;
+        loop: while (true) {
+            const acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut, zs_1 = zs_1_mut;
+            if ((FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) ? true : FSharpList__get_IsEmpty(zs_1)) {
+                return acc;
+            }
+            else {
+                acc_mut = ((t = (new FSharpList(mapping(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1), FSharpList__get_Head(zs_1)), undefined)), (acc.tail = t, t)));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                ys_1_mut = FSharpList__get_Tail(ys_1);
+                zs_1_mut = FSharpList__get_Tail(zs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    const root = FSharpList_get_Empty();
+    const node_1 = loop(root, xs, ys, zs);
+    const t_2 = FSharpList_get_Empty();
+    node_1.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function mapFold(mapping, state, xs) {
+    const root = FSharpList_get_Empty();
+    const patternInput_1 = fold((tupledArg, x) => {
+        let t;
+        const patternInput = mapping(tupledArg[1], x);
+        return [(t = (new FSharpList(patternInput[0], undefined)), (tupledArg[0].tail = t, t)), patternInput[1]];
+    }, [root, state], xs);
+    const t_2 = FSharpList_get_Empty();
+    patternInput_1[0].tail = t_2;
+    return [FSharpList__get_Tail(root), patternInput_1[1]];
+}
+function mapFoldBack(mapping, xs, state) {
+    return mapFold((acc, x) => mapping(x, acc), state, reverse(xs));
+}
 function tryPick(f, xs) {
     const loop = (xs_1_mut) => {
         loop: while (true) {
@@ -497,6 +680,7 @@ function tryPick(f, xs) {
                     return matchValue;
                 }
             }
+            break;
         }
     };
     return loop(xs);
@@ -522,6 +706,18 @@ function find(f, xs) {
         return value(matchValue);
     }
 }
+function tryFindBack(f, xs) {
+    return tryFindBack$1(f, toArray(xs));
+}
+function findBack(f, xs) {
+    const matchValue = tryFindBack(f, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return value(matchValue);
+    }
+}
 function tryFindIndex(f, xs) {
     const loop = (i_mut, xs_1_mut) => {
         loop: while (true) {
@@ -537,10 +733,34 @@ function tryFindIndex(f, xs) {
                 xs_1_mut = FSharpList__get_Tail(xs_1);
                 continue loop;
             }
+            break;
         }
     };
     return loop(0, xs);
 }
+function findIndex(f, xs) {
+    const matchValue = tryFindIndex(f, xs);
+    if (matchValue == null) {
+        indexNotFound();
+        return -1;
+    }
+    else {
+        return value(matchValue) | 0;
+    }
+}
+function tryFindIndexBack(f, xs) {
+    return tryFindIndexBack$1(f, toArray(xs));
+}
+function findIndexBack(f, xs) {
+    const matchValue = tryFindIndexBack(f, xs);
+    if (matchValue == null) {
+        indexNotFound();
+        return -1;
+    }
+    else {
+        return value(matchValue) | 0;
+    }
+}
 function tryItem(n, xs) {
     const loop = (i_mut, xs_1_mut) => {
         loop: while (true) {
@@ -556,6 +776,7 @@ function tryItem(n, xs) {
                 xs_1_mut = FSharpList__get_Tail(xs_1);
                 continue loop;
             }
+            break;
         }
     };
     return loop(0, xs);
@@ -579,6 +800,27 @@ function filter(f, xs) {
     node.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function partition(f, xs) {
+    const matchValue = FSharpList_get_Empty();
+    const root2 = FSharpList_get_Empty();
+    const root1 = matchValue;
+    const patternInput_1 = fold((tupledArg, x) => {
+        let t, t_2;
+        const lacc = tupledArg[0];
+        const racc = tupledArg[1];
+        if (f(x)) {
+            return [(t = (new FSharpList(x, undefined)), (lacc.tail = t, t)), racc];
+        }
+        else {
+            return [lacc, (t_2 = (new FSharpList(x, undefined)), (racc.tail = t_2, t_2))];
+        }
+    }, [root1, root2], xs);
+    const t_4 = FSharpList_get_Empty();
+    patternInput_1[0].tail = t_4;
+    const t_5 = FSharpList_get_Empty();
+    patternInput_1[1].tail = t_5;
+    return [FSharpList__get_Tail(root1), FSharpList__get_Tail(root2)];
+}
 function choose(f, xs) {
     const root = FSharpList_get_Empty();
     const node = fold((acc, x) => {
@@ -596,6 +838,9 @@ function choose(f, xs) {
     node.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function contains(value, xs, eq) {
+    return tryFindIndex((v) => eq.Equals(value, v), xs) != null;
+}
 function initialize(n, f) {
     let xs, t;
     const root = FSharpList_get_Empty();
@@ -608,6 +853,9 @@ function initialize(n, f) {
     xs_2.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function replicate(n, x) {
+    return initialize(n, (_arg) => x);
+}
 function reduce(f, xs) {
     if (FSharpList__get_IsEmpty(xs)) {
         throw new Error(SR_inputWasEmpty);
@@ -616,23 +864,162 @@ function reduce(f, xs) {
         return fold(f, head(xs), tail(xs));
     }
 }
+function reduceBack(f, xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        throw new Error(SR_inputWasEmpty);
+    }
+    else {
+        return foldBack(f, tail(xs), head(xs));
+    }
+}
+function forAll(f, xs) {
+    return fold((acc, x) => (acc && f(x)), true, xs);
+}
+function forAll2(f, xs, ys) {
+    return fold2((acc, x, y) => (acc && f(x, y)), true, xs, ys);
+}
 function exists(f, xs) {
     return tryFindIndex(f, xs) != null;
 }
+function exists2(f_mut, xs_mut, ys_mut) {
+    exists2: while (true) {
+        const f = f_mut, xs = xs_mut, ys = ys_mut;
+        const matchValue = FSharpList__get_IsEmpty(xs);
+        const matchValue_1 = FSharpList__get_IsEmpty(ys);
+        let matchResult;
+        if (matchValue) {
+            if (matchValue_1) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else if (matchValue_1) {
+            matchResult = 2;
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return false;
+            case 1:
+                if (f(FSharpList__get_Head(xs), FSharpList__get_Head(ys))) {
+                    return true;
+                }
+                else {
+                    f_mut = f;
+                    xs_mut = FSharpList__get_Tail(xs);
+                    ys_mut = FSharpList__get_Tail(ys);
+                    continue exists2;
+                }
+            default:
+                throw new Error((SR_differentLengths + "\\nParameter name: ") + "list2");
+        }
+        break;
+    }
+}
 function unzip(xs) {
     return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty()]);
 }
+function unzip3(xs) {
+    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1]), FSharpList_Cons_305B8EAC(tupledArg[2], tupledArg_1[2])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty(), FSharpList_get_Empty()]);
+}
 function zip(xs, ys) {
     return map2((x, y) => [x, y], xs, ys);
 }
+function zip3(xs, ys, zs) {
+    return map3((x, y, z) => [x, y, z], xs, ys, zs);
+}
 function sortWith(comparer, xs) {
     const arr = toArray(xs);
     arr.sort(comparer);
     return ofArray(arr);
 }
+function sort(xs, comparer) {
+    return sortWith((x, y) => comparer.Compare(x, y), xs);
+}
 function sortBy(projection, xs, comparer) {
     return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);
 }
+function sortDescending(xs, comparer) {
+    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);
+}
+function sortByDescending(projection, xs, comparer) {
+    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);
+}
+function sum(xs, adder) {
+    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);
+}
+function sumBy(f, xs, adder) {
+    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);
+}
+function maxBy(projection, xs, comparer) {
+    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);
+}
+function max(xs, comparer) {
+    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);
+}
+function minBy(projection, xs, comparer) {
+    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);
+}
+function min(xs, comparer) {
+    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);
+}
+function average(xs, averager) {
+    let count = 0;
+    const total = fold((acc, x) => {
+        count = ((count + 1) | 0);
+        return averager.Add(acc, x);
+    }, averager.GetZero(), xs);
+    return averager.DivideByInt(total, count);
+}
+function averageBy(f, xs, averager) {
+    let count = 0;
+    const total = fold((acc, x) => {
+        count = ((count + 1) | 0);
+        return averager.Add(acc, f(x));
+    }, averager.GetZero(), xs);
+    return averager.DivideByInt(total, count);
+}
+function permute(f, xs) {
+    return ofArray(permute$1(f, toArray(xs)));
+}
+function chunkBySize(chunkSize, xs) {
+    return ofArray(map$1(ofArray, chunkBySize$1(chunkSize, toArray(xs))));
+}
+function allPairs(xs, ys) {
+    const root = FSharpList_get_Empty();
+    let node = root;
+    iterate((x) => {
+        iterate((y) => {
+            let xs_1, t;
+            node = ((xs_1 = node, (t = (new FSharpList([x, y], undefined)), (xs_1.tail = t, t))));
+        }, ys);
+    }, xs);
+    const xs_3 = node;
+    const t_2 = FSharpList_get_Empty();
+    xs_3.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function skip(count_mut, xs_mut) {
+    skip: while (true) {
+        const count = count_mut, xs = xs_mut;
+        if (count <= 0) {
+            return xs;
+        }
+        else if (FSharpList__get_IsEmpty(xs)) {
+            throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "list");
+        }
+        else {
+            count_mut = (count - 1);
+            xs_mut = FSharpList__get_Tail(xs);
+            continue skip;
+        }
+        break;
+    }
+}
 function skipWhile(predicate_mut, xs_mut) {
     skipWhile: while (true) {
         const predicate = predicate_mut, xs = xs_mut;
@@ -647,8 +1034,38 @@ function skipWhile(predicate_mut, xs_mut) {
             xs_mut = FSharpList__get_Tail(xs);
             continue skipWhile;
         }
+        break;
     }
 }
+function take(count, xs) {
+    if (count < 0) {
+        throw new Error((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    const loop = (i_mut, acc_mut, xs_1_mut) => {
+        let t;
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            if (i <= 0) {
+                return acc;
+            }
+            else if (FSharpList__get_IsEmpty(xs_1)) {
+                throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "list");
+            }
+            else {
+                i_mut = (i - 1);
+                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), undefined)), (acc.tail = t, t)));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    const root = FSharpList_get_Empty();
+    const node = loop(count, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
 function takeWhile(predicate, xs) {
     const loop = (acc_mut, xs_1_mut) => {
         let t;
@@ -665,6 +1082,7 @@ function takeWhile(predicate, xs) {
                 xs_1_mut = FSharpList__get_Tail(xs_1);
                 continue loop;
             }
+            break;
         }
     };
     const root = FSharpList_get_Empty();
@@ -673,8 +1091,186 @@ function takeWhile(predicate, xs) {
     node.tail = t_2;
     return FSharpList__get_Tail(root);
 }
+function truncate(count, xs) {
+    const loop = (i_mut, acc_mut, xs_1_mut) => {
+        let t;
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            if (i <= 0) {
+                return acc;
+            }
+            else if (FSharpList__get_IsEmpty(xs_1)) {
+                return acc;
+            }
+            else {
+                i_mut = (i - 1);
+                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), undefined)), (acc.tail = t, t)));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    const root = FSharpList_get_Empty();
+    const node = loop(count, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function getSlice(startIndex, endIndex, xs) {
+    const len = length(xs) | 0;
+    let startIndex_1;
+    const index = defaultArg(startIndex, 0) | 0;
+    startIndex_1 = ((index < 0) ? 0 : index);
+    let endIndex_1;
+    const index_1 = defaultArg(endIndex, len - 1) | 0;
+    endIndex_1 = ((index_1 >= len) ? (len - 1) : index_1);
+    if (endIndex_1 < startIndex_1) {
+        return FSharpList_get_Empty();
+    }
+    else {
+        return take((endIndex_1 - startIndex_1) + 1, skip(startIndex_1, xs));
+    }
+}
+function splitAt(index, xs) {
+    if (index < 0) {
+        throw new Error((SR_inputMustBeNonNegative + "\\nParameter name: ") + "index");
+    }
+    if (index > FSharpList__get_Length(xs)) {
+        throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "index");
+    }
+    return [take(index, xs), skip(index, xs)];
+}
+function exactlyOne(xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "list");
+    }
+    else if (FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {
+        return FSharpList__get_Head(xs);
+    }
+    else {
+        throw new Error((SR_inputSequenceTooLong + "\\nParameter name: ") + "list");
+    }
+}
+function tryExactlyOne(xs) {
+    if (!FSharpList__get_IsEmpty(xs) && FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {
+        return some(FSharpList__get_Head(xs));
+    }
+    else {
+        return undefined;
+    }
+}
+function where(predicate, xs) {
+    return filter(predicate, xs);
+}
+function pairwise(xs) {
+    return ofArray(pairwise$1(toArray(xs)));
+}
+function windowed(windowSize, xs) {
+    return ofArray(map$1(ofArray, windowed$1(windowSize, toArray(xs))));
+}
+function splitInto(chunks, xs) {
+    return ofArray(map$1(ofArray, splitInto$1(chunks, toArray(xs))));
+}
 function transpose(lists) {
     return ofArray(map$1(ofArray, transpose$1(map$1(toArray, Array.from(lists)))));
 }
+function insertAt(index, y, xs) {
+    let i = -1;
+    let isDone = false;
+    const result = fold((acc, x) => {
+        i = ((i + 1) | 0);
+        if (i === index) {
+            isDone = true;
+            return FSharpList_Cons_305B8EAC(x, FSharpList_Cons_305B8EAC(y, acc));
+        }
+        else {
+            return FSharpList_Cons_305B8EAC(x, acc);
+        }
+    }, FSharpList_get_Empty(), xs);
+    return reverse(isDone ? result : (((i + 1) === index) ? FSharpList_Cons_305B8EAC(y, result) : (() => {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    })()));
+}
+function insertManyAt(index, ys, xs) {
+    let i = -1;
+    let isDone = false;
+    const ys_1 = ofSeq(ys);
+    const result = fold((acc, x) => {
+        i = ((i + 1) | 0);
+        if (i === index) {
+            isDone = true;
+            return FSharpList_Cons_305B8EAC(x, append(ys_1, acc));
+        }
+        else {
+            return FSharpList_Cons_305B8EAC(x, acc);
+        }
+    }, FSharpList_get_Empty(), xs);
+    return reverse(isDone ? result : (((i + 1) === index) ? append(ys_1, result) : (() => {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    })()));
+}
+function removeAt(index, xs) {
+    let i = -1;
+    let isDone = false;
+    const ys = filter((_arg) => {
+        i = ((i + 1) | 0);
+        if (i === index) {
+            isDone = true;
+            return false;
+        }
+        else {
+            return true;
+        }
+    }, xs);
+    if (!isDone) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return ys;
+}
+function removeManyAt(index, count, xs) {
+    let i = -1;
+    let status = -1;
+    const ys = filter((_arg) => {
+        i = ((i + 1) | 0);
+        if (i === index) {
+            status = 0;
+            return false;
+        }
+        else if (i > index) {
+            if (i < (index + count)) {
+                return false;
+            }
+            else {
+                status = 1;
+                return true;
+            }
+        }
+        else {
+            return true;
+        }
+    }, xs);
+    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;
+    if (status_1 < 1) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + ((status_1 < 0) ? "index" : "count"));
+    }
+    return ys;
+}
+function updateAt(index, y, xs) {
+    let isDone = false;
+    const ys = mapIndexed((i, x) => {
+        if (i === index) {
+            isDone = true;
+            return y;
+        }
+        else {
+            return x;
+        }
+    }, xs);
+    if (!isDone) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return ys;
+}
 
-export { FSharpList, FSharpList_Cons_305B8EAC, FSharpList__get_Head, FSharpList__get_IsEmpty, FSharpList__get_Item_Z524259A4, FSharpList__get_Length, FSharpList__get_Tail, FSharpList_get_Empty, ListEnumerator$1, ListEnumerator$1_$ctor_3002E699, append, choose, collect, concat, cons, empty, exists, filter, find, fold, fold2, foldBack, foldIndexed, head, indexNotFound, initialize, isEmpty, item, iterate, iterateIndexed, length, map, map2, mapIndexed, ofArray, ofArrayWithTail, ofSeq, pick, reduce, reverse, singleton, skipWhile, sortBy, sortWith, tail, takeWhile, toArray, transpose, tryFind, tryFindIndex, tryHead, tryItem, tryLast, tryPick, unzip, zip };
+export { FSharpList, FSharpList_$reflection, FSharpList_Cons_305B8EAC, FSharpList__get_Head, FSharpList__get_IsEmpty, FSharpList__get_Item_Z524259A4, FSharpList__get_Length, FSharpList__get_Tail, FSharpList_get_Empty, ListEnumerator$1, ListEnumerator$1_$ctor_3002E699, ListEnumerator$1_$reflection, allPairs, append, average, averageBy, choose, chunkBySize, collect, compareWith, concat, cons, contains, empty, exactlyOne, exists, exists2, filter, find, findBack, findIndex, findIndexBack, fold, fold2, foldBack, foldBack2, foldIndexed, forAll, forAll2, getSlice, head, indexNotFound, indexed, initialize, insertAt, insertManyAt, isEmpty, item, iterate, iterate2, iterateIndexed, iterateIndexed2, last, length, map, map2, map3, mapFold, mapFoldBack, mapIndexed, mapIndexed2, max, maxBy, min, minBy, ofArray, ofArrayWithTail, ofSeq, pairwise, partition, permute, pick, reduce, reduceBack, removeAt, removeManyAt, replicate, reverse, scan, scanBack, singleton, skip, skipWhile, sort, sortBy, sortByDescending, sortDescending, sortWith, splitAt, splitInto, sum, sumBy, tail, take, takeWhile, toArray, toSeq, transpose, truncate, tryExactlyOne, tryFind, tryFindBack, tryFindIndex, tryFindIndexBack, tryHead, tryItem, tryLast, tryPick, unfold, unzip, unzip3, updateAt, where, windowed, zip, zip3 };