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

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

@@ -1,9 +1,10 @@
-import { disposeSafe, getEnumerator, toIterator, isArrayLike, isDisposable } from './Util.js';
+import { getEnumerator, disposeSafe, toIterator, isArrayLike, isDisposable, equals, defaultOf, clear } from './Util.js';
 import { toString } from './Types.js';
-import { some, value } from './Option.js';
-import { Operators_NullArg } from './FSharp.Core.js';
-import { tryItem as tryItem$1, tryHead as tryHead$1, singleton as singleton$1 } from './Array.js';
-import { FSharpList, toArray as toArray$1, ofArray as ofArray$1, ofSeq as ofSeq$1, length as length$1, isEmpty as isEmpty$1, tryItem as tryItem$2, tryHead as tryHead$2 } from './List.js';
+import { class_type } from './Reflection.js';
+import { value, some } from './Option.js';
+import { Operators_NullArg, Operators_Lock } from './FSharp.Core.js';
+import { singleton as singleton$1, tryFindBack as tryFindBack$1, tryFindIndexBack as tryFindIndexBack$1, foldBack as foldBack$1, foldBack2 as foldBack2$1, tryHead as tryHead$1, tryItem as tryItem$1, mapFold as mapFold$1, mapFoldBack as mapFoldBack$1, reverse as reverse$1, scanBack as scanBack$1, pairwise as pairwise$1, splitInto as splitInto$1, windowed as windowed$1, map as map$1, transpose as transpose$1, permute as permute$1, chunkBySize as chunkBySize$1 } from './Array.js';
+import { FSharpList, toArray as toArray$1, ofArray as ofArray$1, ofSeq as ofSeq$1, tryHead as tryHead$2, isEmpty as isEmpty$1, tryItem as tryItem$2, length as length$1 } from './List.js';
 import { SR_indexOutOfBounds } from './Global.js';
 
 const SR_enumerationAlreadyFinished = "Enumeration already finished.";
@@ -60,6 +61,9 @@ class Enumerator_Seq {
         return x.f();
     }
 }
+function Enumerator_Seq_$reflection(gen0) {
+    return class_type("SeqModule.Enumerator.Seq", [gen0], Enumerator_Seq);
+}
 function Enumerator_Seq_$ctor_673A07F2(f) {
     return new Enumerator_Seq(f);
 }
@@ -89,9 +93,17 @@ class Enumerator_FromFunctions$1 {
         _.dispose();
     }
 }
+function Enumerator_FromFunctions$1_$reflection(gen0) {
+    return class_type("SeqModule.Enumerator.FromFunctions`1", [gen0], Enumerator_FromFunctions$1);
+}
 function Enumerator_FromFunctions$1_$ctor_58C54629(current, next, dispose) {
     return new Enumerator_FromFunctions$1(current, next, dispose);
 }
+function Enumerator_cast(e) {
+    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e["System.Collections.Generic.IEnumerator`1.get_Current"](), () => e["System.Collections.IEnumerator.MoveNext"](), () => {
+        disposeSafe(e);
+    });
+}
 function Enumerator_concat(sources) {
     let outerOpt = undefined;
     let innerOpt = undefined;
@@ -191,6 +203,7 @@ function Enumerator_enumerateThenFinally(f, e) {
             disposeSafe(e);
         }
         finally {
+            f();
         }
     });
 }
@@ -261,7 +274,7 @@ function Enumerator_unfold(f, state) {
     return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
         if (curr != null) {
             const x = value(curr)[0];
-            value(curr)[1];
+            const st = value(curr)[1];
             return x;
         }
         else {
@@ -270,7 +283,7 @@ function Enumerator_unfold(f, state) {
     }, () => {
         curr = f(acc);
         if (curr != null) {
-            value(curr)[0];
+            const x_1 = value(curr)[0];
             const st_1 = value(curr)[1];
             acc = st_1;
             return true;
@@ -323,6 +336,9 @@ function toArray(xs) {
         return Array.from(xs);
     }
 }
+function ofList(xs) {
+    return xs;
+}
 function toList(xs) {
     if (isArrayLike(xs)) {
         return ofArray$1(xs);
@@ -349,6 +365,12 @@ function generateIndexed(create, compute, dispose) {
 function append(xs, ys) {
     return concat([xs, ys]);
 }
+function cast(xs) {
+    return mkSeq(() => {
+        checkNonNull("source", xs);
+        return Enumerator_cast(getEnumerator(xs));
+    });
+}
 function choose(chooser, xs) {
     return generate(() => ofSeq(xs), (e) => {
         let curr = undefined;
@@ -407,6 +429,37 @@ function enumerateFromFunctions(create, moveNext, current) {
         }
     });
 }
+function enumerateThenFinally(source, compensation) {
+    const compensation_1 = compensation;
+    return mkSeq(() => {
+        try {
+            return Enumerator_enumerateThenFinally(compensation_1, ofSeq(source));
+        }
+        catch (matchValue) {
+            compensation_1();
+            throw matchValue;
+        }
+    });
+}
+function enumerateUsing(resource, source) {
+    const compensation = () => {
+        if (equals(resource, defaultOf())) {
+        }
+        else {
+            let copyOfStruct = resource;
+            disposeSafe(copyOfStruct);
+        }
+    };
+    return mkSeq(() => {
+        try {
+            return Enumerator_enumerateThenFinally(compensation, ofSeq(source(resource)));
+        }
+        catch (matchValue_1) {
+            compensation();
+            throw matchValue_1;
+        }
+    });
+}
 function enumerateWhile(guard, xs) {
     return concat(unfold((i) => (guard() ? [xs, i + 1] : undefined), 0));
 }
@@ -433,6 +486,25 @@ function exists(predicate, xs) {
         disposeSafe(e);
     }
 }
+function exists2(predicate, xs, ys) {
+    const e1 = ofSeq(xs);
+    try {
+        const e2 = ofSeq(ys);
+        try {
+            let found = false;
+            while ((!found && e1["System.Collections.IEnumerator.MoveNext"]()) && e2["System.Collections.IEnumerator.MoveNext"]()) {
+                found = predicate(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            return found;
+        }
+        finally {
+            disposeSafe(e2);
+        }
+    }
+    finally {
+        disposeSafe(e1);
+    }
+}
 function exactlyOne(xs) {
     const e = ofSeq(xs);
     try {
@@ -453,6 +525,21 @@ function exactlyOne(xs) {
         disposeSafe(e);
     }
 }
+function tryExactlyOne(xs) {
+    const e = ofSeq(xs);
+    try {
+        if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            const v = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            return e["System.Collections.IEnumerator.MoveNext"]() ? undefined : some(v);
+        }
+        else {
+            return undefined;
+        }
+    }
+    finally {
+        disposeSafe(e);
+    }
+}
 function tryFind(predicate, xs) {
     const e = ofSeq(xs);
     try {
@@ -478,6 +565,18 @@ function find(predicate, xs) {
         return value(matchValue);
     }
 }
+function tryFindBack(predicate, xs) {
+    return tryFindBack$1(predicate, toArray(xs));
+}
+function findBack(predicate, xs) {
+    const matchValue = tryFindBack(predicate, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return value(matchValue);
+    }
+}
 function tryFindIndex(predicate, xs) {
     const e = ofSeq(xs);
     try {
@@ -515,6 +614,19 @@ function findIndex(predicate, xs) {
         return value(matchValue) | 0;
     }
 }
+function tryFindIndexBack(predicate, xs) {
+    return tryFindIndexBack$1(predicate, toArray(xs));
+}
+function findIndexBack(predicate, xs) {
+    const matchValue = tryFindIndexBack(predicate, xs);
+    if (matchValue == null) {
+        indexNotFound();
+        return -1;
+    }
+    else {
+        return value(matchValue) | 0;
+    }
+}
 function fold(folder, state, xs) {
     const e = ofSeq(xs);
     try {
@@ -528,9 +640,37 @@ function fold(folder, state, xs) {
         disposeSafe(e);
     }
 }
+function foldBack(folder, xs, state) {
+    return foldBack$1(folder, toArray(xs), state);
+}
+function fold2(folder, state, xs, ys) {
+    const e1 = ofSeq(xs);
+    try {
+        const e2 = ofSeq(ys);
+        try {
+            let acc = state;
+            while (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) {
+                acc = folder(acc, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            return acc;
+        }
+        finally {
+            disposeSafe(e2);
+        }
+    }
+    finally {
+        disposeSafe(e1);
+    }
+}
+function foldBack2(folder, xs, ys, state) {
+    return foldBack2$1(folder, toArray(xs), toArray(ys), state);
+}
 function forAll(predicate, xs) {
     return !exists((x) => !predicate(x), xs);
 }
+function forAll2(predicate, xs, ys) {
+    return !exists2((x, y) => !predicate(x, y), xs, ys);
+}
 function tryHead(xs) {
     if (isArrayLike(xs)) {
         return tryHead$1(xs);
@@ -560,6 +700,9 @@ function head(xs) {
 function initialize(count, f) {
     return unfold((i) => ((i < count) ? [f(i), i + 1] : undefined), 0);
 }
+function initializeInfinite(f) {
+    return initialize(2147483647, f);
+}
 function isEmpty(xs) {
     if (isArrayLike(xs)) {
         const a = xs;
@@ -625,12 +768,23 @@ function iterate(action, xs) {
         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 tryLast(xs) {
     const e = ofSeq(xs);
     try {
@@ -711,6 +865,151 @@ function map2(mapping, xs, ys) {
         }
     });
 }
+function mapIndexed2(mapping, xs, ys) {
+    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {
+        const e1 = tupledArg[0];
+        const e2 = tupledArg[1];
+        return (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(i, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
+    }, (tupledArg_1) => {
+        try {
+            disposeSafe(tupledArg_1[0]);
+        }
+        finally {
+            disposeSafe(tupledArg_1[1]);
+        }
+    });
+}
+function map3(mapping, xs, ys, zs) {
+    return generate(() => [ofSeq(xs), ofSeq(ys), ofSeq(zs)], (tupledArg) => {
+        const e1 = tupledArg[0];
+        const e2 = tupledArg[1];
+        const e3 = tupledArg[2];
+        return ((e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) && e3["System.Collections.IEnumerator.MoveNext"]()) ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"](), e3["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
+    }, (tupledArg_1) => {
+        try {
+            disposeSafe(tupledArg_1[0]);
+        }
+        finally {
+            try {
+                disposeSafe(tupledArg_1[1]);
+            }
+            finally {
+                disposeSafe(tupledArg_1[2]);
+            }
+        }
+    });
+}
+function readOnly(xs) {
+    checkNonNull("source", xs);
+    return map((x) => x, xs);
+}
+class CachedSeq$1 {
+    constructor(cleanup, res) {
+        this.cleanup = cleanup;
+        this.res = res;
+    }
+    Dispose() {
+        const _ = this;
+        _.cleanup();
+    }
+    GetEnumerator() {
+        const _ = this;
+        return getEnumerator(_.res);
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const _ = this;
+        return getEnumerator(_.res);
+    }
+}
+function CachedSeq$1_$reflection(gen0) {
+    return class_type("SeqModule.CachedSeq`1", [gen0], CachedSeq$1);
+}
+function CachedSeq$1_$ctor_Z7A8347D4(cleanup, res) {
+    return new CachedSeq$1(cleanup, res);
+}
+function CachedSeq$1__Clear(_) {
+    _.cleanup();
+}
+function cache(source) {
+    checkNonNull("source", source);
+    const prefix = [];
+    let enumeratorR = undefined;
+    return CachedSeq$1_$ctor_Z7A8347D4(() => {
+        Operators_Lock(prefix, () => {
+            clear(prefix);
+            let matchResult, e;
+            if (enumeratorR != null) {
+                if (value(enumeratorR) != null) {
+                    matchResult = 0;
+                    e = value(value(enumeratorR));
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0: {
+                    disposeSafe(e);
+                    break;
+                }
+            }
+            enumeratorR = undefined;
+        });
+    }, unfold((i_1) => Operators_Lock(prefix, () => {
+        if (i_1 < prefix.length) {
+            return [prefix[i_1], i_1 + 1];
+        }
+        else {
+            if (i_1 >= prefix.length) {
+                let optEnumerator_2;
+                if (enumeratorR != null) {
+                    optEnumerator_2 = value(enumeratorR);
+                }
+                else {
+                    const optEnumerator = getEnumerator(source);
+                    enumeratorR = some(optEnumerator);
+                    optEnumerator_2 = optEnumerator;
+                }
+                if (optEnumerator_2 == null) {
+                }
+                else {
+                    const enumerator = value(optEnumerator_2);
+                    if (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                        void (prefix.push(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()));
+                    }
+                    else {
+                        disposeSafe(enumerator);
+                        enumeratorR = some(undefined);
+                    }
+                }
+            }
+            if (i_1 < prefix.length) {
+                return [prefix[i_1], i_1 + 1];
+            }
+            else {
+                return undefined;
+            }
+        }
+    }), 0));
+}
+function allPairs(xs, ys) {
+    const ysCache = cache(ys);
+    return delay(() => concat(map((x) => map((y) => [x, y], ysCache), xs)));
+}
+function mapFold(mapping, state, xs) {
+    const patternInput = mapFold$1(mapping, state, toArray(xs));
+    return [readOnly(patternInput[0]), patternInput[1]];
+}
+function mapFoldBack(mapping, xs, state) {
+    const patternInput = mapFoldBack$1(mapping, toArray(xs), state);
+    return [readOnly(patternInput[0]), patternInput[1]];
+}
 function tryPick(chooser, xs) {
     const e = ofSeq(xs);
     try {
@@ -724,6 +1023,15 @@ function tryPick(chooser, xs) {
         disposeSafe(e);
     }
 }
+function pick(chooser, xs) {
+    const matchValue = tryPick(chooser, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return value(matchValue);
+    }
+}
 function reduce(folder, xs) {
     const e = ofSeq(xs);
     try {
@@ -751,6 +1059,33 @@ function reduce(folder, xs) {
         disposeSafe(e);
     }
 }
+function reduceBack(folder, xs) {
+    const arr = toArray(xs);
+    if (arr.length > 0) {
+        return arr.reduceRight(folder);
+    }
+    else {
+        throw new Error(SR_inputSequenceEmpty);
+    }
+}
+function replicate(n, x) {
+    return initialize(n, (_arg) => x);
+}
+function reverse(xs) {
+    return delay(() => ofArray(reverse$1(toArray(xs))));
+}
+function scan(folder, state, xs) {
+    return delay(() => {
+        let acc = state;
+        return concat([singleton(state), map((x) => {
+                acc = folder(acc, x);
+                return acc;
+            }, xs)]);
+    });
+}
+function scanBack(folder, xs, state) {
+    return delay(() => ofArray(scanBack$1(folder, toArray(xs), state)));
+}
 function skip(count, source) {
     return mkSeq(() => {
         const e = ofSeq(source);
@@ -783,17 +1118,57 @@ function skipWhile(predicate, xs) {
 function tail(xs) {
     return skip(1, xs);
 }
+function take(count, xs) {
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if (i < count) {
+            if (e["System.Collections.IEnumerator.MoveNext"]()) {
+                return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                throw new Error((SR_notEnoughElements + "\\nParameter name: ") + "source");
+            }
+        }
+        else {
+            return undefined;
+        }
+    }, (e_1) => {
+        disposeSafe(e_1);
+    });
+}
 function takeWhile(predicate, xs) {
     return generate(() => ofSeq(xs), (e) => ((e["System.Collections.IEnumerator.MoveNext"]() && predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined), (e_1) => {
         disposeSafe(e_1);
     });
 }
+function truncate(count, xs) {
+    return generateIndexed(() => ofSeq(xs), (i, e) => (((i < count) && e["System.Collections.IEnumerator.MoveNext"]()) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined), (e_1) => {
+        disposeSafe(e_1);
+    });
+}
 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 collect(mapping, xs) {
     return delay(() => concat(map(mapping, xs)));
 }
+function where(predicate, xs) {
+    return filter(predicate, xs);
+}
+function pairwise(xs) {
+    return delay(() => ofArray(pairwise$1(toArray(xs))));
+}
+function splitInto(chunks, xs) {
+    return delay(() => ofArray(splitInto$1(chunks, toArray(xs))));
+}
+function windowed(windowSize, xs) {
+    return delay(() => ofArray(windowed$1(windowSize, toArray(xs))));
+}
+function transpose(xss) {
+    return delay(() => ofArray(map$1(ofArray, transpose$1(map$1(toArray, toArray(xss))))));
+}
 function sortWith(comparer, xs) {
     return delay(() => {
         const arr = toArray(xs);
@@ -807,6 +1182,18 @@ function sort(xs, comparer) {
 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);
 }
@@ -819,6 +1206,104 @@ function minBy(projection, xs, comparer) {
 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);
+    if (count === 0) {
+        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    else {
+        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);
+    if (count === 0) {
+        throw new Error((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    else {
+        return averager.DivideByInt(total, count);
+    }
+}
+function permute(f, xs) {
+    return delay(() => ofArray(permute$1(f, toArray(xs))));
+}
+function chunkBySize(chunkSize, xs) {
+    return delay(() => ofArray(chunkBySize$1(chunkSize, toArray(xs))));
+}
+function insertAt(index, y, xs) {
+    let isDone = false;
+    if (index < 0) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        else if (i === index) {
+            isDone = true;
+            return some(y);
+        }
+        else {
+            if (!isDone) {
+                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+            return undefined;
+        }
+    }, (e_1) => {
+        disposeSafe(e_1);
+    });
+}
+function insertManyAt(index, ys, xs) {
+    let status = -1;
+    if (index < 0) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {
+        const e1 = tupledArg[0];
+        const e2 = tupledArg[1];
+        if (i === index) {
+            status = 0;
+        }
+        let inserted;
+        if (status === 0) {
+            if (e2["System.Collections.IEnumerator.MoveNext"]()) {
+                inserted = some(e2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                status = 1;
+                inserted = undefined;
+            }
+        }
+        else {
+            inserted = undefined;
+        }
+        if (inserted == null) {
+            if (e1["System.Collections.IEnumerator.MoveNext"]()) {
+                return some(e1["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                if (status < 1) {
+                    throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                }
+                return undefined;
+            }
+        }
+        else {
+            return some(value(inserted));
+        }
+    }, (tupledArg_1) => {
+        disposeSafe(tupledArg_1[0]);
+        disposeSafe(tupledArg_1[1]);
+    });
+}
 function removeAt(index, xs) {
     let isDone = false;
     if (index < 0) {
@@ -842,5 +1327,55 @@ function removeAt(index, xs) {
         disposeSafe(e_1);
     });
 }
+function removeManyAt(index, count, xs) {
+    if (index < 0) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if (i < index) {
+            if (e["System.Collections.IEnumerator.MoveNext"]()) {
+                return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+        }
+        else {
+            if (i === index) {
+                for (let _ = 1; _ <= count; _++) {
+                    if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+                        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "count");
+                    }
+                }
+            }
+            return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
+        }
+    }, (e_1) => {
+        disposeSafe(e_1);
+    });
+}
+function updateAt(index, y, xs) {
+    let isDone = false;
+    if (index < 0) {
+        throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        else if ((i === index) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            isDone = true;
+            return some(y);
+        }
+        else {
+            if (!isDone) {
+                throw new Error((SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+            return undefined;
+        }
+    }, (e_1) => {
+        disposeSafe(e_1);
+    });
+}
 
-export { Enumerator_FromFunctions$1, Enumerator_FromFunctions$1_$ctor_58C54629, Enumerator_Seq, Enumerator_Seq_$ctor_673A07F2, Enumerator_alreadyFinished, Enumerator_concat, Enumerator_enumerateThenFinally, Enumerator_generateWhileSome, Enumerator_noReset, Enumerator_notStarted, Enumerator_unfold, SR_enumerationAlreadyFinished, SR_enumerationNotStarted, SR_inputSequenceEmpty, SR_inputSequenceTooLong, SR_keyNotFoundAlt, SR_notEnoughElements, SR_resetNotSupported, append, checkNonNull, choose, collect, compareWith, concat, contains, delay, empty, enumerateFromFunctions, enumerateWhile, exactlyOne, exists, filter, find, findIndex, fold, forAll, generate, generateIndexed, head, indexNotFound, indexed, initialize, isEmpty, item, iterate, iterateIndexed, last, length, map, map2, mapIndexed, max, maxBy, min, minBy, mkSeq, ofArray, ofSeq, reduce, removeAt, singleton, skip, skipWhile, sort, sortBy, sortWith, tail, takeWhile, toArray, toList, tryFind, tryFindIndex, tryHead, tryItem, tryLast, tryPick, unfold, zip };
+export { CachedSeq$1, CachedSeq$1_$ctor_Z7A8347D4, CachedSeq$1_$reflection, CachedSeq$1__Clear, Enumerator_FromFunctions$1, Enumerator_FromFunctions$1_$ctor_58C54629, Enumerator_FromFunctions$1_$reflection, Enumerator_Seq, Enumerator_Seq_$ctor_673A07F2, Enumerator_Seq_$reflection, Enumerator_alreadyFinished, Enumerator_cast, Enumerator_concat, Enumerator_enumerateThenFinally, Enumerator_generateWhileSome, Enumerator_noReset, Enumerator_notStarted, Enumerator_unfold, SR_enumerationAlreadyFinished, SR_enumerationNotStarted, SR_inputSequenceEmpty, SR_inputSequenceTooLong, SR_keyNotFoundAlt, SR_notEnoughElements, SR_resetNotSupported, allPairs, append, average, averageBy, cache, cast, checkNonNull, choose, chunkBySize, collect, compareWith, concat, contains, delay, empty, enumerateFromFunctions, enumerateThenFinally, enumerateUsing, enumerateWhile, exactlyOne, exists, exists2, filter, find, findBack, findIndex, findIndexBack, fold, fold2, foldBack, foldBack2, forAll, forAll2, generate, generateIndexed, head, indexNotFound, indexed, initialize, initializeInfinite, insertAt, insertManyAt, isEmpty, item, iterate, iterate2, iterateIndexed, iterateIndexed2, last, length, map, map2, map3, mapFold, mapFoldBack, mapIndexed, mapIndexed2, max, maxBy, min, minBy, mkSeq, ofArray, ofList, ofSeq, pairwise, permute, pick, readOnly, reduce, reduceBack, removeAt, removeManyAt, replicate, reverse, scan, scanBack, singleton, skip, skipWhile, sort, sortBy, sortByDescending, sortDescending, sortWith, splitInto, sum, sumBy, tail, take, takeWhile, toArray, toList, transpose, truncate, tryExactlyOne, tryFind, tryFindBack, tryFindIndex, tryFindIndexBack, tryHead, tryItem, tryLast, tryPick, unfold, updateAt, where, windowed, zip, zip3 };