@fossa-app/bridge 0.1.5 → 0.1.7

package/dist/fable_modules/fable-library-ts.5.0.0-rc.1/Seq.js

@@ -0,0 +1,1501 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedSeq$1 = exports.Enumerator_FromFunctions$1 = exports.Enumerator_Seq = exports.SR_resetNotSupported = exports.SR_notEnoughElements = exports.SR_keyNotFoundAlt = exports.SR_inputSequenceTooLong = exports.SR_inputSequenceEmpty = exports.SR_enumerationNotStarted = exports.SR_enumerationAlreadyFinished = void 0;
+exports.Enumerator_noReset = Enumerator_noReset;
+exports.Enumerator_notStarted = Enumerator_notStarted;
+exports.Enumerator_alreadyFinished = Enumerator_alreadyFinished;
+exports.Enumerator_Seq_$reflection = Enumerator_Seq_$reflection;
+exports.Enumerator_Seq_$ctor_673A07F2 = Enumerator_Seq_$ctor_673A07F2;
+exports.Enumerator_FromFunctions$1_$reflection = Enumerator_FromFunctions$1_$reflection;
+exports.Enumerator_FromFunctions$1_$ctor_58C54629 = Enumerator_FromFunctions$1_$ctor_58C54629;
+exports.Enumerator_cast = Enumerator_cast;
+exports.Enumerator_concat = Enumerator_concat;
+exports.Enumerator_enumerateThenFinally = Enumerator_enumerateThenFinally;
+exports.Enumerator_generateWhileSome = Enumerator_generateWhileSome;
+exports.Enumerator_unfold = Enumerator_unfold;
+exports.indexNotFound = indexNotFound;
+exports.mkSeq = mkSeq;
+exports.ofSeq = ofSeq;
+exports.delay = delay;
+exports.concat = concat;
+exports.unfold = unfold;
+exports.empty = empty;
+exports.singleton = singleton;
+exports.ofArray = ofArray;
+exports.toArray = toArray;
+exports.ofList = ofList;
+exports.toList = toList;
+exports.generate = generate;
+exports.generateIndexed = generateIndexed;
+exports.append = append;
+exports.cast = cast;
+exports.choose = choose;
+exports.compareWith = compareWith;
+exports.contains = contains;
+exports.enumerateFromFunctions = enumerateFromFunctions;
+exports.enumerateThenFinally = enumerateThenFinally;
+exports.enumerateUsing = enumerateUsing;
+exports.enumerateWhile = enumerateWhile;
+exports.filter = filter;
+exports.exists = exists;
+exports.exists2 = exists2;
+exports.exactlyOne = exactlyOne;
+exports.tryExactlyOne = tryExactlyOne;
+exports.tryFind = tryFind;
+exports.find = find;
+exports.tryFindBack = tryFindBack;
+exports.findBack = findBack;
+exports.tryFindIndex = tryFindIndex;
+exports.findIndex = findIndex;
+exports.tryFindIndexBack = tryFindIndexBack;
+exports.findIndexBack = findIndexBack;
+exports.fold = fold;
+exports.foldBack = foldBack;
+exports.fold2 = fold2;
+exports.foldBack2 = foldBack2;
+exports.forAll = forAll;
+exports.forAll2 = forAll2;
+exports.tryHead = tryHead;
+exports.head = head;
+exports.initialize = initialize;
+exports.initializeInfinite = initializeInfinite;
+exports.isEmpty = isEmpty;
+exports.tryItem = tryItem;
+exports.item = item;
+exports.iterate = iterate;
+exports.iterate2 = iterate2;
+exports.iterateIndexed = iterateIndexed;
+exports.iterateIndexed2 = iterateIndexed2;
+exports.tryLast = tryLast;
+exports.last = last;
+exports.length = length;
+exports.map = map;
+exports.mapIndexed = mapIndexed;
+exports.indexed = indexed;
+exports.map2 = map2;
+exports.mapIndexed2 = mapIndexed2;
+exports.map3 = map3;
+exports.readOnly = readOnly;
+exports.CachedSeq$1_$reflection = CachedSeq$1_$reflection;
+exports.CachedSeq$1_$ctor_Z7A8347D4 = CachedSeq$1_$ctor_Z7A8347D4;
+exports.CachedSeq$1__Clear = CachedSeq$1__Clear;
+exports.cache = cache;
+exports.allPairs = allPairs;
+exports.mapFold = mapFold;
+exports.mapFoldBack = mapFoldBack;
+exports.tryPick = tryPick;
+exports.pick = pick;
+exports.reduce = reduce;
+exports.reduceBack = reduceBack;
+exports.replicate = replicate;
+exports.reverse = reverse;
+exports.scan = scan;
+exports.scanBack = scanBack;
+exports.skip = skip;
+exports.skipWhile = skipWhile;
+exports.tail = tail;
+exports.take = take;
+exports.takeWhile = takeWhile;
+exports.truncate = truncate;
+exports.zip = zip;
+exports.zip3 = zip3;
+exports.collect = collect;
+exports.where = where;
+exports.pairwise = pairwise;
+exports.splitInto = splitInto;
+exports.windowed = windowed;
+exports.transpose = transpose;
+exports.sortWith = sortWith;
+exports.sort = sort;
+exports.sortBy = sortBy;
+exports.sortDescending = sortDescending;
+exports.sortByDescending = sortByDescending;
+exports.sum = sum;
+exports.sumBy = sumBy;
+exports.maxBy = maxBy;
+exports.max = max;
+exports.minBy = minBy;
+exports.min = min;
+exports.average = average;
+exports.averageBy = averageBy;
+exports.permute = permute;
+exports.chunkBySize = chunkBySize;
+exports.insertAt = insertAt;
+exports.insertManyAt = insertManyAt;
+exports.removeAt = removeAt;
+exports.removeManyAt = removeManyAt;
+exports.updateAt = updateAt;
+const System_ts_1 = require("./System.js");
+const Util_ts_1 = require("./Util.js");
+const Types_ts_1 = require("./Types.js");
+const Reflection_ts_1 = require("./Reflection.js");
+const Option_ts_1 = require("./Option.js");
+const System_Collections_Generic_ts_1 = require("./System.Collections.Generic.js");
+const FSharp_Core_ts_1 = require("./FSharp.Core.js");
+const Array_ts_1 = require("./Array.js");
+const List_ts_1 = require("./List.js");
+const Global_ts_1 = require("./Global.js");
+exports.SR_enumerationAlreadyFinished = "Enumeration already finished.";
+exports.SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
+exports.SR_inputSequenceEmpty = "The input sequence was empty.";
+exports.SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+exports.SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+exports.SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
+exports.SR_resetNotSupported = "Reset is not supported on this enumerator.";
+function Enumerator_noReset() {
+    throw (0, System_ts_1.NotSupportedException_$ctor_Z721C83C5)(exports.SR_resetNotSupported);
+}
+function Enumerator_notStarted() {
+    throw (0, System_ts_1.InvalidOperationException_$ctor_Z721C83C5)(exports.SR_enumerationNotStarted);
+}
+function Enumerator_alreadyFinished() {
+    throw (0, System_ts_1.InvalidOperationException_$ctor_Z721C83C5)(exports.SR_enumerationAlreadyFinished);
+}
+class Enumerator_Seq {
+    constructor(f) {
+        this.f = f;
+    }
+    toString() {
+        const xs = this;
+        let i = 0;
+        let str = "seq [";
+        const e = (0, Util_ts_1.getEnumerator)(xs);
+        try {
+            while ((i < 4) && e["System.Collections.IEnumerator.MoveNext"]()) {
+                if (i > 0) {
+                    str = (str + "; ");
+                }
+                str = (str + (0, Types_ts_1.toString)(e["System.Collections.Generic.IEnumerator`1.get_Current"]()));
+                i = ((i + 1) | 0);
+            }
+            if (i === 4) {
+                str = (str + "; ...");
+            }
+            return str + "]";
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(e);
+        }
+    }
+    GetEnumerator() {
+        const x = this;
+        return x.f();
+    }
+    [Symbol.iterator]() {
+        return (0, Util_ts_1.toIterator)((0, Util_ts_1.getEnumerator)(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const x = this;
+        return x.f();
+    }
+}
+exports.Enumerator_Seq = Enumerator_Seq;
+function Enumerator_Seq_$reflection(gen0) {
+    return (0, Reflection_ts_1.class_type)("SeqModule.Enumerator.Seq", [gen0], Enumerator_Seq);
+}
+function Enumerator_Seq_$ctor_673A07F2(f) {
+    return new Enumerator_Seq(f);
+}
+class Enumerator_FromFunctions$1 {
+    constructor(current, next, dispose) {
+        this.current = current;
+        this.next = next;
+        this.dispose = dispose;
+    }
+    "System.Collections.Generic.IEnumerator`1.get_Current"() {
+        const _ = this;
+        return _.current();
+    }
+    "System.Collections.IEnumerator.get_Current"() {
+        const _ = this;
+        return _.current();
+    }
+    "System.Collections.IEnumerator.MoveNext"() {
+        const _ = this;
+        return _.next();
+    }
+    "System.Collections.IEnumerator.Reset"() {
+        Enumerator_noReset();
+    }
+    Dispose() {
+        const _ = this;
+        _.dispose();
+    }
+}
+exports.Enumerator_FromFunctions$1 = Enumerator_FromFunctions$1;
+function Enumerator_FromFunctions$1_$reflection(gen0) {
+    return (0, Reflection_ts_1.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"](), () => {
+        (0, Util_ts_1.disposeSafe)(e);
+    });
+}
+function Enumerator_concat(sources) {
+    let outerOpt = undefined;
+    let innerOpt = undefined;
+    let started = false;
+    let finished = false;
+    let curr = undefined;
+    const finish = () => {
+        finished = true;
+        if (innerOpt != null) {
+            const inner = (0, Option_ts_1.value)(innerOpt);
+            try {
+                (0, Util_ts_1.disposeSafe)(inner);
+            }
+            finally {
+                innerOpt = undefined;
+            }
+        }
+        if (outerOpt != null) {
+            const outer = (0, Option_ts_1.value)(outerOpt);
+            try {
+                (0, Util_ts_1.disposeSafe)(outer);
+            }
+            finally {
+                outerOpt = undefined;
+            }
+        }
+    };
+    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+        if (!started) {
+            Enumerator_notStarted();
+        }
+        else if (finished) {
+            Enumerator_alreadyFinished();
+        }
+        if (curr != null) {
+            return (0, Option_ts_1.value)(curr);
+        }
+        else {
+            return Enumerator_alreadyFinished();
+        }
+    }, () => {
+        if (!started) {
+            started = true;
+        }
+        if (finished) {
+            return false;
+        }
+        else {
+            let res = undefined;
+            while (res == null) {
+                let copyOfStruct = undefined;
+                const outerOpt_1 = outerOpt;
+                const innerOpt_1 = innerOpt;
+                if (outerOpt_1 != null) {
+                    if (innerOpt_1 != null) {
+                        const inner_1 = (0, Option_ts_1.value)(innerOpt_1);
+                        if (inner_1["System.Collections.IEnumerator.MoveNext"]()) {
+                            curr = (0, Option_ts_1.some)(inner_1["System.Collections.Generic.IEnumerator`1.get_Current"]());
+                            res = true;
+                        }
+                        else {
+                            try {
+                                (0, Util_ts_1.disposeSafe)(inner_1);
+                            }
+                            finally {
+                                innerOpt = undefined;
+                            }
+                        }
+                    }
+                    else {
+                        const outer_1 = (0, Option_ts_1.value)(outerOpt_1);
+                        if (outer_1["System.Collections.IEnumerator.MoveNext"]()) {
+                            const ie = outer_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                            innerOpt = ((copyOfStruct = ie, (0, Util_ts_1.getEnumerator)(copyOfStruct)));
+                        }
+                        else {
+                            finish();
+                            res = false;
+                        }
+                    }
+                }
+                else {
+                    outerOpt = (0, Util_ts_1.getEnumerator)(sources);
+                }
+            }
+            return (0, Option_ts_1.value)(res);
+        }
+    }, () => {
+        if (!finished) {
+            finish();
+        }
+    });
+}
+function Enumerator_enumerateThenFinally(f, e) {
+    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e["System.Collections.Generic.IEnumerator`1.get_Current"](), () => e["System.Collections.IEnumerator.MoveNext"](), () => {
+        try {
+            (0, Util_ts_1.disposeSafe)(e);
+        }
+        finally {
+            f();
+        }
+    });
+}
+function Enumerator_generateWhileSome(openf, compute, closef) {
+    let started = false;
+    let curr = undefined;
+    let state = (0, Option_ts_1.some)(openf());
+    const dispose = () => {
+        if (state != null) {
+            const x_1 = (0, Option_ts_1.value)(state);
+            try {
+                closef(x_1);
+            }
+            finally {
+                state = undefined;
+            }
+        }
+    };
+    const finish = () => {
+        try {
+            dispose();
+        }
+        finally {
+            curr = undefined;
+        }
+    };
+    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+        if (!started) {
+            Enumerator_notStarted();
+        }
+        if (curr != null) {
+            return (0, Option_ts_1.value)(curr);
+        }
+        else {
+            return Enumerator_alreadyFinished();
+        }
+    }, () => {
+        if (!started) {
+            started = true;
+        }
+        if (state != null) {
+            const s = (0, Option_ts_1.value)(state);
+            let matchValue_1;
+            try {
+                matchValue_1 = compute(s);
+            }
+            catch (matchValue) {
+                finish();
+                throw matchValue;
+            }
+            if (matchValue_1 != null) {
+                curr = matchValue_1;
+                return true;
+            }
+            else {
+                finish();
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }, dispose);
+}
+function Enumerator_unfold(f, state) {
+    let curr = undefined;
+    let acc = state;
+    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+        if (curr != null) {
+            const x = (0, Option_ts_1.value)(curr)[0];
+            const st = (0, Option_ts_1.value)(curr)[1];
+            return x;
+        }
+        else {
+            return Enumerator_notStarted();
+        }
+    }, () => {
+        curr = f(acc);
+        if (curr != null) {
+            const x_1 = (0, Option_ts_1.value)(curr)[0];
+            const st_1 = (0, Option_ts_1.value)(curr)[1];
+            acc = st_1;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, () => {
+    });
+}
+function indexNotFound() {
+    throw (0, System_Collections_Generic_ts_1.KeyNotFoundException_$ctor_Z721C83C5)(exports.SR_keyNotFoundAlt);
+}
+function mkSeq(f) {
+    return Enumerator_Seq_$ctor_673A07F2(f);
+}
+function ofSeq(xs) {
+    return (0, Util_ts_1.getEnumerator)((0, FSharp_Core_ts_1.Operators_NullArgCheck)("source", xs));
+}
+function delay(generator) {
+    return mkSeq(() => (0, Util_ts_1.getEnumerator)(generator()));
+}
+function concat(sources) {
+    return mkSeq(() => Enumerator_concat(sources));
+}
+function unfold(generator, state) {
+    return mkSeq(() => Enumerator_unfold(generator, state));
+}
+function empty() {
+    return delay(() => (new Array(0)));
+}
+function singleton(x) {
+    return delay(() => (0, Array_ts_1.singleton)(x));
+}
+function ofArray(arr) {
+    return arr;
+}
+function toArray(xs) {
+    if (xs instanceof List_ts_1.FSharpList) {
+        const a = xs;
+        return (0, List_ts_1.toArray)(a);
+    }
+    else {
+        return Array.from(xs);
+    }
+}
+function ofList(xs) {
+    return xs;
+}
+function toList(xs) {
+    if ((0, Util_ts_1.isArrayLike)(xs)) {
+        return (0, List_ts_1.ofArray)(xs);
+    }
+    else if (xs instanceof List_ts_1.FSharpList) {
+        return xs;
+    }
+    else {
+        return (0, List_ts_1.ofSeq)(xs);
+    }
+}
+function generate(create, compute, dispose) {
+    return mkSeq(() => Enumerator_generateWhileSome(create, compute, dispose));
+}
+function generateIndexed(create, compute, dispose) {
+    return mkSeq(() => {
+        let i = -1;
+        return Enumerator_generateWhileSome(create, (x) => {
+            i = ((i + 1) | 0);
+            return compute(i, x);
+        }, dispose);
+    });
+}
+function append(xs, ys) {
+    return concat([xs, ys]);
+}
+function cast(xs) {
+    return mkSeq(() => Enumerator_cast((0, Util_ts_1.getEnumerator)((0, FSharp_Core_ts_1.Operators_NullArgCheck)("source", xs))));
+}
+function choose(chooser, xs) {
+    return generate(() => ofSeq(xs), (e) => {
+        let curr = undefined;
+        while ((curr == null) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            curr = chooser(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        return curr;
+    }, (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function compareWith(comparer, xs, ys) {
+    const e1 = ofSeq(xs);
+    try {
+        const e2 = ofSeq(ys);
+        try {
+            let c = 0;
+            let b1 = e1["System.Collections.IEnumerator.MoveNext"]();
+            let b2 = e2["System.Collections.IEnumerator.MoveNext"]();
+            while (((c === 0) && b1) && b2) {
+                c = (comparer(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]()) | 0);
+                if (c === 0) {
+                    b1 = e1["System.Collections.IEnumerator.MoveNext"]();
+                    b2 = e2["System.Collections.IEnumerator.MoveNext"]();
+                }
+            }
+            return ((c !== 0) ? c : (b1 ? 1 : (b2 ? -1 : 0))) | 0;
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(e2);
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e1);
+    }
+}
+function contains(value, xs, comparer) {
+    const e = ofSeq(xs);
+    try {
+        let found = false;
+        while (!found && e["System.Collections.IEnumerator.MoveNext"]()) {
+            found = comparer.Equals(value, e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        return found;
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function enumerateFromFunctions(create, moveNext, current) {
+    return generate(create, (x) => (moveNext(x) ? (0, Option_ts_1.some)(current(x)) : undefined), (x_1) => {
+        const matchValue = x_1;
+        if ((0, Util_ts_1.isDisposable)(matchValue)) {
+            const id = matchValue;
+            (0, Util_ts_1.disposeSafe)(id);
+        }
+    });
+}
+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 (resource == null) {
+        }
+        else {
+            let copyOfStruct = resource;
+            (0, Util_ts_1.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));
+}
+function filter(f, xs) {
+    return choose((x) => {
+        if (f(x)) {
+            return (0, Option_ts_1.some)(x);
+        }
+        else {
+            return undefined;
+        }
+    }, xs);
+}
+function exists(predicate, xs) {
+    const e = ofSeq(xs);
+    try {
+        let found = false;
+        while (!found && e["System.Collections.IEnumerator.MoveNext"]()) {
+            found = predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        return found;
+    }
+    finally {
+        (0, Util_ts_1.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 {
+            (0, Util_ts_1.disposeSafe)(e2);
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e1);
+    }
+}
+function exactlyOne(xs) {
+    const e = ofSeq(xs);
+    try {
+        if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            const v = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (e["System.Collections.IEnumerator.MoveNext"]()) {
+                throw new Util_ts_1.Exception((exports.SR_inputSequenceTooLong + "\\nParameter name: ") + "source");
+            }
+            else {
+                return v;
+            }
+        }
+        else {
+            throw new Util_ts_1.Exception((exports.SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+        }
+    }
+    finally {
+        (0, Util_ts_1.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 : (0, Option_ts_1.some)(v);
+        }
+        else {
+            return undefined;
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function tryFind(predicate, xs) {
+    const e = ofSeq(xs);
+    try {
+        let res = undefined;
+        while ((res == null) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            const c = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (predicate(c)) {
+                res = (0, Option_ts_1.some)(c);
+            }
+        }
+        return res;
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function find(predicate, xs) {
+    const matchValue = tryFind(predicate, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function tryFindBack(predicate, xs) {
+    return (0, Array_ts_1.tryFindBack)(predicate, toArray(xs));
+}
+function findBack(predicate, xs) {
+    const matchValue = tryFindBack(predicate, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function tryFindIndex(predicate, xs) {
+    const e = ofSeq(xs);
+    try {
+        const loop = (i_mut) => {
+            loop: while (true) {
+                const i = i_mut;
+                if (e["System.Collections.IEnumerator.MoveNext"]()) {
+                    if (predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) {
+                        return i;
+                    }
+                    else {
+                        i_mut = (i + 1);
+                        continue loop;
+                    }
+                }
+                else {
+                    return undefined;
+                }
+                break;
+            }
+        };
+        return loop(0);
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function findIndex(predicate, xs) {
+    const matchValue = tryFindIndex(predicate, xs);
+    if (matchValue == null) {
+        indexNotFound();
+        return -1;
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue) | 0;
+    }
+}
+function tryFindIndexBack(predicate, xs) {
+    return (0, Array_ts_1.tryFindIndexBack)(predicate, toArray(xs));
+}
+function findIndexBack(predicate, xs) {
+    const matchValue = tryFindIndexBack(predicate, xs);
+    if (matchValue == null) {
+        indexNotFound();
+        return -1;
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue) | 0;
+    }
+}
+function fold(folder, state, xs) {
+    const e = ofSeq(xs);
+    try {
+        let acc = state;
+        while (e["System.Collections.IEnumerator.MoveNext"]()) {
+            acc = folder(acc, e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        return acc;
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function foldBack(folder, xs, state) {
+    return (0, Array_ts_1.foldBack)(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 {
+            (0, Util_ts_1.disposeSafe)(e2);
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e1);
+    }
+}
+function foldBack2(folder, xs, ys, state) {
+    return (0, Array_ts_1.foldBack2)(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 ((0, Util_ts_1.isArrayLike)(xs)) {
+        return (0, Array_ts_1.tryHead)(xs);
+    }
+    else if (xs instanceof List_ts_1.FSharpList) {
+        return (0, List_ts_1.tryHead)(xs);
+    }
+    else {
+        const e = ofSeq(xs);
+        try {
+            return e["System.Collections.IEnumerator.MoveNext"]() ? (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(e);
+        }
+    }
+}
+function head(xs) {
+    const matchValue = tryHead(xs);
+    if (matchValue == null) {
+        throw new Util_ts_1.Exception((exports.SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+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 ((0, Util_ts_1.isArrayLike)(xs)) {
+        const a = xs;
+        return a.length === 0;
+    }
+    else if (xs instanceof List_ts_1.FSharpList) {
+        return (0, List_ts_1.isEmpty)(xs);
+    }
+    else {
+        const e = ofSeq(xs);
+        try {
+            return !e["System.Collections.IEnumerator.MoveNext"]();
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(e);
+        }
+    }
+}
+function tryItem(index, xs) {
+    if ((0, Util_ts_1.isArrayLike)(xs)) {
+        return (0, Array_ts_1.tryItem)(index, xs);
+    }
+    else if (xs instanceof List_ts_1.FSharpList) {
+        return (0, List_ts_1.tryItem)(index, xs);
+    }
+    else {
+        const e = ofSeq(xs);
+        try {
+            const loop = (index_1_mut) => {
+                loop: while (true) {
+                    const index_1 = index_1_mut;
+                    if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+                        return undefined;
+                    }
+                    else if (index_1 === 0) {
+                        return (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+                    }
+                    else {
+                        index_1_mut = (index_1 - 1);
+                        continue loop;
+                    }
+                    break;
+                }
+            };
+            return loop(index);
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(e);
+        }
+    }
+}
+function item(index, xs) {
+    const matchValue = tryItem(index, xs);
+    if (matchValue == null) {
+        throw new Util_ts_1.Exception((exports.SR_notEnoughElements + "\\nParameter name: ") + "index");
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+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 tryLast(xs) {
+    const e = ofSeq(xs);
+    try {
+        const loop = (acc_mut) => {
+            loop: while (true) {
+                const acc = acc_mut;
+                if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+                    return acc;
+                }
+                else {
+                    acc_mut = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    continue loop;
+                }
+                break;
+            }
+        };
+        return e["System.Collections.IEnumerator.MoveNext"]() ? (0, Option_ts_1.some)(loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function last(xs) {
+    const matchValue = tryLast(xs);
+    if (matchValue == null) {
+        throw new Util_ts_1.Exception((exports.SR_notEnoughElements + "\\nParameter name: ") + "source");
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function length(xs) {
+    if ((0, Util_ts_1.isArrayLike)(xs)) {
+        const a = xs;
+        return a.length | 0;
+    }
+    else if (xs instanceof List_ts_1.FSharpList) {
+        return (0, List_ts_1.length)(xs) | 0;
+    }
+    else {
+        const e = ofSeq(xs);
+        try {
+            let count = 0;
+            while (e["System.Collections.IEnumerator.MoveNext"]()) {
+                count = ((count + 1) | 0);
+            }
+            return count | 0;
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(e);
+        }
+    }
+}
+function map(mapping, xs) {
+    return generate(() => ofSeq(xs), (e) => (e["System.Collections.IEnumerator.MoveNext"]() ? (0, Option_ts_1.some)(mapping(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined), (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function mapIndexed(mapping, xs) {
+    return generateIndexed(() => ofSeq(xs), (i, e) => (e["System.Collections.IEnumerator.MoveNext"]() ? (0, Option_ts_1.some)(mapping(i, e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined), (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function indexed(xs) {
+    return mapIndexed((i, x) => [i, x], xs);
+}
+function map2(mapping, xs, ys) {
+    return generate(() => [ofSeq(xs), ofSeq(ys)], (tupledArg) => {
+        const e1 = tupledArg[0];
+        const e2 = tupledArg[1];
+        return (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) ? (0, Option_ts_1.some)(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
+    }, (tupledArg_1) => {
+        try {
+            (0, Util_ts_1.disposeSafe)(tupledArg_1[0]);
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(tupledArg_1[1]);
+        }
+    });
+}
+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"]()) ? (0, Option_ts_1.some)(mapping(i, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : undefined;
+    }, (tupledArg_1) => {
+        try {
+            (0, Util_ts_1.disposeSafe)(tupledArg_1[0]);
+        }
+        finally {
+            (0, Util_ts_1.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"]()) ? (0, Option_ts_1.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 {
+            (0, Util_ts_1.disposeSafe)(tupledArg_1[0]);
+        }
+        finally {
+            try {
+                (0, Util_ts_1.disposeSafe)(tupledArg_1[1]);
+            }
+            finally {
+                (0, Util_ts_1.disposeSafe)(tupledArg_1[2]);
+            }
+        }
+    });
+}
+function readOnly(xs) {
+    return map((x) => x, (0, FSharp_Core_ts_1.Operators_NullArgCheck)("source", xs));
+}
+class CachedSeq$1 {
+    constructor(cleanup, res) {
+        this.cleanup = cleanup;
+        this.res = res;
+    }
+    Dispose() {
+        const _ = this;
+        _.cleanup();
+    }
+    GetEnumerator() {
+        const _ = this;
+        return (0, Util_ts_1.getEnumerator)(_.res);
+    }
+    [Symbol.iterator]() {
+        return (0, Util_ts_1.toIterator)((0, Util_ts_1.getEnumerator)(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const _ = this;
+        return (0, Util_ts_1.getEnumerator)(_.res);
+    }
+}
+exports.CachedSeq$1 = CachedSeq$1;
+function CachedSeq$1_$reflection(gen0) {
+    return (0, Reflection_ts_1.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) {
+    const source_1 = (0, FSharp_Core_ts_1.Operators_NullArgCheck)("source", source);
+    const prefix = [];
+    let enumeratorR = undefined;
+    return CachedSeq$1_$ctor_Z7A8347D4(() => {
+        (0, FSharp_Core_ts_1.Operators_Lock)(prefix, () => {
+            (0, Util_ts_1.clear)(prefix);
+            let matchResult = undefined, e = undefined;
+            if (enumeratorR != null) {
+                if ((0, Option_ts_1.value)(enumeratorR) != null) {
+                    matchResult = 0;
+                    e = (0, Option_ts_1.value)((0, Option_ts_1.value)(enumeratorR));
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0: {
+                    (0, Util_ts_1.disposeSafe)(e);
+                    break;
+                }
+            }
+            enumeratorR = undefined;
+        });
+    }, unfold((i_1) => (0, FSharp_Core_ts_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 = (0, Option_ts_1.value)(enumeratorR);
+                }
+                else {
+                    const optEnumerator = (0, Util_ts_1.getEnumerator)(source_1);
+                    enumeratorR = (0, Option_ts_1.some)(optEnumerator);
+                    optEnumerator_2 = optEnumerator;
+                }
+                if (optEnumerator_2 == null) {
+                }
+                else {
+                    const enumerator = (0, Option_ts_1.value)(optEnumerator_2);
+                    if (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                        void (prefix.push(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]()));
+                    }
+                    else {
+                        (0, Util_ts_1.disposeSafe)(enumerator);
+                        enumeratorR = (0, Option_ts_1.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 = (0, Array_ts_1.mapFold)(mapping, state, toArray(xs));
+    return [readOnly(patternInput[0]), patternInput[1]];
+}
+function mapFoldBack(mapping, xs, state) {
+    const patternInput = (0, Array_ts_1.mapFoldBack)(mapping, toArray(xs), state);
+    return [readOnly(patternInput[0]), patternInput[1]];
+}
+function tryPick(chooser, xs) {
+    const e = ofSeq(xs);
+    try {
+        let res = undefined;
+        while ((res == null) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            res = chooser(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        return res;
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function pick(chooser, xs) {
+    const matchValue = tryPick(chooser, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function reduce(folder, xs) {
+    const e = ofSeq(xs);
+    try {
+        const loop = (acc_mut) => {
+            loop: while (true) {
+                const acc = acc_mut;
+                if (e["System.Collections.IEnumerator.MoveNext"]()) {
+                    acc_mut = folder(acc, e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+                    continue loop;
+                }
+                else {
+                    return acc;
+                }
+                break;
+            }
+        };
+        if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            return loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        else {
+            throw new Util_ts_1.Exception(exports.SR_inputSequenceEmpty);
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(e);
+    }
+}
+function reduceBack(folder, xs) {
+    const arr = toArray(xs);
+    if (arr.length > 0) {
+        return arr.reduceRight(folder);
+    }
+    else {
+        throw new Util_ts_1.Exception(exports.SR_inputSequenceEmpty);
+    }
+}
+function replicate(n, x) {
+    return initialize(n, (_arg) => x);
+}
+function reverse(xs) {
+    return delay(() => ofArray((0, Array_ts_1.reverse)(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((0, Array_ts_1.scanBack)(folder, toArray(xs), state)));
+}
+function skip(count, source) {
+    return mkSeq(() => {
+        const e = ofSeq(source);
+        try {
+            for (let _ = 1; _ <= count; _++) {
+                if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+                    throw new Util_ts_1.Exception((exports.SR_notEnoughElements + "\\nParameter name: ") + "source");
+                }
+            }
+            return Enumerator_enumerateThenFinally(() => {
+            }, e);
+        }
+        catch (matchValue) {
+            (0, Util_ts_1.disposeSafe)(e);
+            throw matchValue;
+        }
+    });
+}
+function skipWhile(predicate, xs) {
+    return delay(() => {
+        let skipped = true;
+        return filter((x) => {
+            if (skipped) {
+                skipped = predicate(x);
+            }
+            return !skipped;
+        }, 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 (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                throw new Util_ts_1.Exception((exports.SR_notEnoughElements + "\\nParameter name: ") + "source");
+            }
+        }
+        else {
+            return undefined;
+        }
+    }, (e_1) => {
+        (0, Util_ts_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"]())) ? (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined), (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function truncate(count, xs) {
+    return generateIndexed(() => ofSeq(xs), (i, e) => (((i < count) && e["System.Collections.IEnumerator.MoveNext"]()) ? (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined), (e_1) => {
+        (0, Util_ts_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((0, Array_ts_1.pairwise)(toArray(xs))));
+}
+function splitInto(chunks, xs) {
+    return delay(() => ofArray((0, Array_ts_1.splitInto)(chunks, toArray(xs))));
+}
+function windowed(windowSize, xs) {
+    return delay(() => ofArray((0, Array_ts_1.windowed)(windowSize, toArray(xs))));
+}
+function transpose(xss) {
+    return delay(() => ofArray((0, Array_ts_1.map)(ofArray, (0, Array_ts_1.transpose)((0, Array_ts_1.map)(toArray, toArray(xss))))));
+}
+function sortWith(comparer, xs) {
+    return delay(() => {
+        const arr = toArray(xs);
+        arr.sort(comparer);
+        return ofArray(arr);
+    });
+}
+function sort(xs, comparer) {
+    return sortWith((x, y) => (comparer.Compare(x, y) | 0), xs);
+}
+function sortBy(projection, xs, comparer) {
+    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) | 0), xs);
+}
+function sortDescending(xs, comparer) {
+    return sortWith((x, y) => ((comparer.Compare(x, y) * -1) | 0), xs);
+}
+function sortByDescending(projection, xs, comparer) {
+    return sortWith((x, y) => ((comparer.Compare(projection(x), projection(y)) * -1) | 0), 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);
+    if (count === 0) {
+        throw new Util_ts_1.Exception((exports.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 Util_ts_1.Exception((exports.SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    else {
+        return averager.DivideByInt(total, count);
+    }
+}
+function permute(f, xs) {
+    return delay(() => ofArray((0, Array_ts_1.permute)(f, toArray(xs))));
+}
+function chunkBySize(chunkSize, xs) {
+    return delay(() => ofArray((0, Array_ts_1.chunkBySize)(chunkSize, toArray(xs))));
+}
+function insertAt(index, y, xs) {
+    let isDone = false;
+    if (index < 0) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            return (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        else if (i === index) {
+            isDone = true;
+            return (0, Option_ts_1.some)(y);
+        }
+        else {
+            if (!isDone) {
+                throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+            return undefined;
+        }
+    }, (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function insertManyAt(index, ys, xs) {
+    let status = -1;
+    if (index < 0) {
+        throw new Util_ts_1.Exception((Global_ts_1.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 = (0, Option_ts_1.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 (0, Option_ts_1.some)(e1["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                if (status < 1) {
+                    throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+                }
+                return undefined;
+            }
+        }
+        else {
+            return (0, Option_ts_1.some)((0, Option_ts_1.value)(inserted));
+        }
+    }, (tupledArg_1) => {
+        (0, Util_ts_1.disposeSafe)(tupledArg_1[0]);
+        (0, Util_ts_1.disposeSafe)(tupledArg_1[1]);
+    });
+}
+function removeAt(index, xs) {
+    let isDone = false;
+    if (index < 0) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            return (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        else if ((i === index) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            isDone = true;
+            return e["System.Collections.IEnumerator.MoveNext"]() ? (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
+        }
+        else {
+            if (!isDone) {
+                throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+            return undefined;
+        }
+    }, (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function removeManyAt(index, count, xs) {
+    if (index < 0) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if (i < index) {
+            if (e["System.Collections.IEnumerator.MoveNext"]()) {
+                return (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+            else {
+                throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+        }
+        else {
+            if (i === index) {
+                for (let _ = 1; _ <= count; _++) {
+                    if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+                        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "count");
+                    }
+                }
+            }
+            return e["System.Collections.IEnumerator.MoveNext"]() ? (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : undefined;
+        }
+    }, (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+function updateAt(index, y, xs) {
+    let isDone = false;
+    if (index < 0) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return generateIndexed(() => ofSeq(xs), (i, e) => {
+        if ((isDone ? true : (i < index)) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            return (0, Option_ts_1.some)(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        }
+        else if ((i === index) && e["System.Collections.IEnumerator.MoveNext"]()) {
+            isDone = true;
+            return (0, Option_ts_1.some)(y);
+        }
+        else {
+            if (!isDone) {
+                throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+            return undefined;
+        }
+    }, (e_1) => {
+        (0, Util_ts_1.disposeSafe)(e_1);
+    });
+}
+//# sourceMappingURL=Seq.js.map