@fossa-app/bridge 0.1.5 → 0.1.7

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

@@ -0,0 +1,1404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListEnumerator$1 = exports.FSharpList = void 0;
+exports.FSharpList_$reflection = FSharpList_$reflection;
+exports.ListEnumerator$1_$reflection = ListEnumerator$1_$reflection;
+exports.ListEnumerator$1_$ctor_3002E699 = ListEnumerator$1_$ctor_3002E699;
+exports.FSharpList_get_Empty = FSharpList_get_Empty;
+exports.FSharpList_Cons_305B8EAC = FSharpList_Cons_305B8EAC;
+exports.FSharpList__get_IsEmpty = FSharpList__get_IsEmpty;
+exports.FSharpList__get_Length = FSharpList__get_Length;
+exports.FSharpList__get_Head = FSharpList__get_Head;
+exports.FSharpList__get_Tail = FSharpList__get_Tail;
+exports.FSharpList__get_Item_Z524259A4 = FSharpList__get_Item_Z524259A4;
+exports.indexNotFound = indexNotFound;
+exports.empty = empty;
+exports.cons = cons;
+exports.singleton = singleton;
+exports.isEmpty = isEmpty;
+exports.length = length;
+exports.head = head;
+exports.tryHead = tryHead;
+exports.tail = tail;
+exports.tryLast = tryLast;
+exports.last = last;
+exports.compareWith = compareWith;
+exports.toArray = toArray;
+exports.fold = fold;
+exports.reverse = reverse;
+exports.foldBack = foldBack;
+exports.foldIndexed = foldIndexed;
+exports.fold2 = fold2;
+exports.foldBack2 = foldBack2;
+exports.unfold = unfold;
+exports.iterate = iterate;
+exports.iterate2 = iterate2;
+exports.iterateIndexed = iterateIndexed;
+exports.iterateIndexed2 = iterateIndexed2;
+exports.toSeq = toSeq;
+exports.ofArrayWithTail = ofArrayWithTail;
+exports.ofArray = ofArray;
+exports.ofSeq = ofSeq;
+exports.concat = concat;
+exports.scan = scan;
+exports.scanBack = scanBack;
+exports.append = append;
+exports.collect = collect;
+exports.mapIndexed = mapIndexed;
+exports.map = map;
+exports.indexed = indexed;
+exports.map2 = map2;
+exports.mapIndexed2 = mapIndexed2;
+exports.map3 = map3;
+exports.mapFold = mapFold;
+exports.mapFoldBack = mapFoldBack;
+exports.tryPick = tryPick;
+exports.pick = pick;
+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.tryItem = tryItem;
+exports.item = item;
+exports.filter = filter;
+exports.partition = partition;
+exports.choose = choose;
+exports.contains = contains;
+exports.initialize = initialize;
+exports.replicate = replicate;
+exports.reduce = reduce;
+exports.reduceBack = reduceBack;
+exports.forAll = forAll;
+exports.forAll2 = forAll2;
+exports.exists = exists;
+exports.exists2 = exists2;
+exports.unzip = unzip;
+exports.unzip3 = unzip3;
+exports.zip = zip;
+exports.zip3 = zip3;
+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.allPairs = allPairs;
+exports.skip = skip;
+exports.skipWhile = skipWhile;
+exports.take = take;
+exports.takeWhile = takeWhile;
+exports.truncate = truncate;
+exports.getSlice = getSlice;
+exports.splitAt = splitAt;
+exports.exactlyOne = exactlyOne;
+exports.tryExactlyOne = tryExactlyOne;
+exports.where = where;
+exports.pairwise = pairwise;
+exports.windowed = windowed;
+exports.splitInto = splitInto;
+exports.transpose = transpose;
+exports.insertAt = insertAt;
+exports.insertManyAt = insertManyAt;
+exports.removeAt = removeAt;
+exports.removeManyAt = removeManyAt;
+exports.updateAt = updateAt;
+const String_ts_1 = require("./String.js");
+const Option_ts_1 = require("./Option.js");
+const Util_ts_1 = require("./Util.js");
+const Types_ts_1 = require("./Types.js");
+const Reflection_ts_1 = require("./Reflection.js");
+const Global_ts_1 = require("./Global.js");
+const System_Collections_Generic_ts_1 = require("./System.Collections.Generic.js");
+const Array_ts_1 = require("./Array.js");
+class FSharpList extends Types_ts_1.Record {
+    constructor(head, tail) {
+        super();
+        this.head = head;
+        this.tail = tail;
+    }
+    toString() {
+        const xs = this;
+        return ("[" + (0, String_ts_1.join)("; ", xs)) + "]";
+    }
+    Equals(other) {
+        const xs = this;
+        if (xs === other) {
+            return true;
+        }
+        else if (other instanceof FSharpList) {
+            const ys = other;
+            const loop = (xs_1_mut, ys_1_mut) => {
+                loop: while (true) {
+                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+                    const matchValue = xs_1.tail;
+                    const matchValue_1 = ys_1.tail;
+                    if (matchValue != null) {
+                        if (matchValue_1 != null) {
+                            const xt = (0, Option_ts_1.value)(matchValue);
+                            const yt = (0, Option_ts_1.value)(matchValue_1);
+                            if ((0, Util_ts_1.equals)(xs_1.head, ys_1.head)) {
+                                xs_1_mut = xt;
+                                ys_1_mut = yt;
+                                continue loop;
+                            }
+                            else {
+                                return false;
+                            }
+                        }
+                        else {
+                            return false;
+                        }
+                    }
+                    else if (matchValue_1 != null) {
+                        return false;
+                    }
+                    else {
+                        return true;
+                    }
+                    break;
+                }
+            };
+            return loop(xs, ys);
+        }
+        else {
+            return false;
+        }
+    }
+    GetHashCode() {
+        const xs = this;
+        const loop = (i_mut, h_mut, xs_1_mut) => {
+            loop: while (true) {
+                const i = i_mut, h = h_mut, xs_1 = xs_1_mut;
+                const matchValue = xs_1.tail;
+                if (matchValue != null) {
+                    const t = (0, Option_ts_1.value)(matchValue);
+                    if (i > 18) {
+                        return h | 0;
+                    }
+                    else {
+                        i_mut = (i + 1);
+                        h_mut = (((h << 1) + (0, Util_ts_1.structuralHash)(xs_1.head)) + (631 * i));
+                        xs_1_mut = t;
+                        continue loop;
+                    }
+                }
+                else {
+                    return h | 0;
+                }
+                break;
+            }
+        };
+        return loop(0, 0, xs) | 0;
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    CompareTo(other) {
+        const xs = this;
+        if (other instanceof FSharpList) {
+            const ys = other;
+            const loop = (xs_1_mut, ys_1_mut) => {
+                loop: while (true) {
+                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+                    const matchValue = xs_1.tail;
+                    const matchValue_1 = ys_1.tail;
+                    if (matchValue != null) {
+                        if (matchValue_1 != null) {
+                            const xt = (0, Option_ts_1.value)(matchValue);
+                            const yt = (0, Option_ts_1.value)(matchValue_1);
+                            const c = (0, Util_ts_1.compare)(xs_1.head, ys_1.head) | 0;
+                            if (c === 0) {
+                                xs_1_mut = xt;
+                                ys_1_mut = yt;
+                                continue loop;
+                            }
+                            else {
+                                return c | 0;
+                            }
+                        }
+                        else {
+                            return 1;
+                        }
+                    }
+                    else if (matchValue_1 != null) {
+                        return -1;
+                    }
+                    else {
+                        return 0;
+                    }
+                    break;
+                }
+            };
+            return loop(xs, ys) | 0;
+        }
+        else {
+            return 1;
+        }
+    }
+    GetEnumerator() {
+        const xs = this;
+        return ListEnumerator$1_$ctor_3002E699(xs);
+    }
+    [Symbol.iterator]() {
+        return (0, Util_ts_1.toIterator)((0, Util_ts_1.getEnumerator)(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const xs = this;
+        return (0, Util_ts_1.getEnumerator)(xs);
+    }
+}
+exports.FSharpList = FSharpList;
+function FSharpList_$reflection(gen0) {
+    return (0, Reflection_ts_1.record_type)("ListModule.FSharpList", [gen0], FSharpList, () => [["head", gen0], ["tail", (0, Reflection_ts_1.option_type)(FSharpList_$reflection(gen0))]]);
+}
+class ListEnumerator$1 {
+    constructor(xs) {
+        this.xs = xs;
+        this.it = this.xs;
+        this.current = (0, Util_ts_1.defaultOf)();
+    }
+    "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;
+        const matchValue = _.it.tail;
+        if (matchValue != null) {
+            const t = (0, Option_ts_1.value)(matchValue);
+            _.current = _.it.head;
+            _.it = t;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    "System.Collections.IEnumerator.Reset"() {
+        const _ = this;
+        _.it = _.xs;
+        _.current = (0, Util_ts_1.defaultOf)();
+    }
+    Dispose() {
+    }
+}
+exports.ListEnumerator$1 = ListEnumerator$1;
+function ListEnumerator$1_$reflection(gen0) {
+    return (0, Reflection_ts_1.class_type)("ListModule.ListEnumerator`1", [gen0], ListEnumerator$1);
+}
+function ListEnumerator$1_$ctor_3002E699(xs) {
+    return new ListEnumerator$1(xs);
+}
+function FSharpList_get_Empty() {
+    return new FSharpList((0, Util_ts_1.defaultOf)(), undefined);
+}
+function FSharpList_Cons_305B8EAC(x, xs) {
+    return new FSharpList(x, xs);
+}
+function FSharpList__get_IsEmpty(xs) {
+    return xs.tail == null;
+}
+function FSharpList__get_Length(xs) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            const matchValue = xs_1.tail;
+            if (matchValue != null) {
+                i_mut = (i + 1);
+                xs_1_mut = (0, Option_ts_1.value)(matchValue);
+                continue loop;
+            }
+            else {
+                return i | 0;
+            }
+            break;
+        }
+    };
+    return loop(0, xs) | 0;
+}
+function FSharpList__get_Head(xs) {
+    const matchValue = xs.tail;
+    if (matchValue != null) {
+        return xs.head;
+    }
+    else {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_inputWasEmpty + "\\nParameter name: ") + "list");
+    }
+}
+function FSharpList__get_Tail(xs) {
+    const matchValue = xs.tail;
+    if (matchValue != null) {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+    else {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_inputWasEmpty + "\\nParameter name: ") + "list");
+    }
+}
+function FSharpList__get_Item_Z524259A4(xs, index) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            const matchValue = xs_1.tail;
+            if (matchValue != null) {
+                if (i === index) {
+                    return xs_1.head;
+                }
+                else {
+                    i_mut = (i + 1);
+                    xs_1_mut = (0, Option_ts_1.value)(matchValue);
+                    continue loop;
+                }
+            }
+            else {
+                throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+            }
+            break;
+        }
+    };
+    return loop(0, xs);
+}
+function indexNotFound() {
+    throw (0, System_Collections_Generic_ts_1.KeyNotFoundException_$ctor_Z721C83C5)(Global_ts_1.SR_keyNotFoundAlt);
+}
+function empty() {
+    return FSharpList_get_Empty();
+}
+function cons(x, xs) {
+    return FSharpList_Cons_305B8EAC(x, xs);
+}
+function singleton(x) {
+    return FSharpList_Cons_305B8EAC(x, FSharpList_get_Empty());
+}
+function isEmpty(xs) {
+    return FSharpList__get_IsEmpty(xs);
+}
+function length(xs) {
+    return FSharpList__get_Length(xs) | 0;
+}
+function head(xs) {
+    return FSharpList__get_Head(xs);
+}
+function tryHead(xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        return undefined;
+    }
+    else {
+        return (0, Option_ts_1.some)(FSharpList__get_Head(xs));
+    }
+}
+function tail(xs) {
+    return FSharpList__get_Tail(xs);
+}
+function tryLast(xs_mut) {
+    tryLast: while (true) {
+        const xs = xs_mut;
+        if (FSharpList__get_IsEmpty(xs)) {
+            return undefined;
+        }
+        else {
+            const t = FSharpList__get_Tail(xs);
+            if (FSharpList__get_IsEmpty(t)) {
+                return (0, Option_ts_1.some)(FSharpList__get_Head(xs));
+            }
+            else {
+                xs_mut = t;
+                continue tryLast;
+            }
+        }
+        break;
+    }
+}
+function last(xs) {
+    const matchValue = tryLast(xs);
+    if (matchValue == null) {
+        throw new Util_ts_1.Exception(Global_ts_1.SR_inputWasEmpty);
+    }
+    else {
+        return (0, Option_ts_1.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 = (0, Array_ts_1.fill)(new Array(len), 0, len, null);
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            if (!FSharpList__get_IsEmpty(xs_1)) {
+                (0, Array_ts_1.setItem)(res, i, FSharpList__get_Head(xs_1));
+                i_mut = (i + 1);
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    loop(0, xs);
+    return res;
+}
+function fold(folder, state, xs) {
+    let acc = state;
+    let xs_1 = xs;
+    while (!FSharpList__get_IsEmpty(xs_1)) {
+        acc = folder(acc, head(xs_1));
+        xs_1 = FSharpList__get_Tail(xs_1);
+    }
+    return acc;
+}
+function reverse(xs) {
+    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), FSharpList_get_Empty(), xs);
+}
+function foldBack(folder, xs, state) {
+    return (0, Array_ts_1.foldBack)(folder, toArray(xs), state);
+}
+function foldIndexed(folder, state, xs) {
+    const loop = (i_mut, acc_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return acc;
+            }
+            else {
+                i_mut = (i + 1);
+                acc_mut = folder(i, acc, FSharpList__get_Head(xs_1));
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(0, state, xs);
+}
+function fold2(folder, state, xs, ys) {
+    let acc = state;
+    let xs_1 = xs;
+    let ys_1 = ys;
+    while (!FSharpList__get_IsEmpty(xs_1) && !FSharpList__get_IsEmpty(ys_1)) {
+        acc = folder(acc, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1));
+        xs_1 = FSharpList__get_Tail(xs_1);
+        ys_1 = FSharpList__get_Tail(ys_1);
+    }
+    return acc;
+}
+function foldBack2(folder, xs, ys, state) {
+    return (0, Array_ts_1.foldBack2)(folder, toArray(xs), toArray(ys), state);
+}
+function unfold(generator, state) {
+    const loop = (acc_mut, node_mut) => {
+        loop: while (true) {
+            const acc = acc_mut, node = node_mut;
+            let t = undefined;
+            const matchValue = generator(acc);
+            if (matchValue != null) {
+                acc_mut = (0, Option_ts_1.value)(matchValue)[1];
+                node_mut = ((t = (new FSharpList((0, Option_ts_1.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--) {
+        res = FSharpList_Cons_305B8EAC((0, Array_ts_1.item)(i, xs), res);
+    }
+    return res;
+}
+function ofArray(xs) {
+    return ofArrayWithTail(xs, FSharpList_get_Empty());
+}
+function ofSeq(xs) {
+    if ((0, Util_ts_1.isArrayLike)(xs)) {
+        return ofArray(xs);
+    }
+    else if (xs instanceof FSharpList) {
+        return xs;
+    }
+    else {
+        const root = FSharpList_get_Empty();
+        let node = root;
+        const enumerator = (0, Util_ts_1.getEnumerator)(xs);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let xs_3 = undefined, t = undefined;
+                const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                node = ((xs_3 = node, (t = (new FSharpList(x, undefined)), (xs_3.tail = t, t))));
+            }
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(enumerator);
+        }
+        const xs_5 = node;
+        const t_2 = FSharpList_get_Empty();
+        xs_5.tail = t_2;
+        return FSharpList__get_Tail(root);
+    }
+}
+function concat(lists) {
+    const root = FSharpList_get_Empty();
+    let node = root;
+    const action = (xs) => {
+        node = fold((acc, x) => {
+            const t = new FSharpList(x, undefined);
+            acc.tail = t;
+            return t;
+        }, node, xs);
+    };
+    if ((0, Util_ts_1.isArrayLike)(lists)) {
+        const xs_3 = lists;
+        xs_3.forEach(action);
+    }
+    else if (lists instanceof FSharpList) {
+        iterate(action, lists);
+    }
+    else {
+        const enumerator = (0, Util_ts_1.getEnumerator)(lists);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                action(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            }
+        }
+        finally {
+            (0, Util_ts_1.disposeSafe)(enumerator);
+        }
+    }
+    const xs_6 = node;
+    const t_2 = FSharpList_get_Empty();
+    xs_6.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function scan(folder, state, xs) {
+    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)) {
+        let xs_4 = undefined, t_2 = undefined;
+        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((0, Array_ts_1.scanBack)(folder, toArray(xs), state));
+}
+function append(xs, ys) {
+    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));
+}
+function collect(mapping, xs) {
+    const root = FSharpList_get_Empty();
+    let node = root;
+    let ys = xs;
+    while (!FSharpList__get_IsEmpty(ys)) {
+        let zs = mapping(FSharpList__get_Head(ys));
+        while (!FSharpList__get_IsEmpty(zs)) {
+            let xs_1 = undefined, t = undefined;
+            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head(zs), undefined)), (xs_1.tail = t, t))));
+            zs = FSharpList__get_Tail(zs);
+        }
+        ys = FSharpList__get_Tail(ys);
+    }
+    const xs_3 = node;
+    const t_2 = FSharpList_get_Empty();
+    xs_3.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function mapIndexed(mapping, xs) {
+    const root = FSharpList_get_Empty();
+    const node = foldIndexed((i, acc, x) => {
+        const t = new FSharpList(mapping(i, x), undefined);
+        acc.tail = t;
+        return t;
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function map(mapping, xs) {
+    const root = FSharpList_get_Empty();
+    const node = fold((acc, x) => {
+        const t = new FSharpList(mapping(x), undefined);
+        acc.tail = t;
+        return t;
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    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) => {
+        const t = new FSharpList(mapping(x, y), undefined);
+        acc.tail = t;
+        return t;
+    }, root, xs, ys);
+    const t_2 = FSharpList_get_Empty();
+    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) => {
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut;
+            let t = undefined;
+            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) => {
+        loop: while (true) {
+            const acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut, zs_1 = zs_1_mut;
+            let t = undefined;
+            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 = undefined;
+        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) {
+            const xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return undefined;
+            }
+            else {
+                const matchValue = f(FSharpList__get_Head(xs_1));
+                if (matchValue == null) {
+                    xs_1_mut = FSharpList__get_Tail(xs_1);
+                    continue loop;
+                }
+                else {
+                    return matchValue;
+                }
+            }
+            break;
+        }
+    };
+    return loop(xs);
+}
+function pick(f, xs) {
+    const matchValue = tryPick(f, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function tryFind(f, xs) {
+    return tryPick((x) => (f(x) ? (0, Option_ts_1.some)(x) : undefined), xs);
+}
+function find(f, xs) {
+    const matchValue = tryFind(f, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function tryFindBack(f, xs) {
+    return (0, Array_ts_1.tryFindBack)(f, toArray(xs));
+}
+function findBack(f, xs) {
+    const matchValue = tryFindBack(f, xs);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function tryFindIndex(f, xs) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return undefined;
+            }
+            else if (f(FSharpList__get_Head(xs_1))) {
+                return i;
+            }
+            else {
+                i_mut = (i + 1);
+                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 (0, Option_ts_1.value)(matchValue) | 0;
+    }
+}
+function tryFindIndexBack(f, xs) {
+    return (0, Array_ts_1.tryFindIndexBack)(f, toArray(xs));
+}
+function findIndexBack(f, xs) {
+    const matchValue = tryFindIndexBack(f, xs);
+    if (matchValue == null) {
+        indexNotFound();
+        return -1;
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue) | 0;
+    }
+}
+function tryItem(n, xs) {
+    const loop = (i_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, xs_1 = xs_1_mut;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return undefined;
+            }
+            else if (i === n) {
+                return (0, Option_ts_1.some)(FSharpList__get_Head(xs_1));
+            }
+            else {
+                i_mut = (i + 1);
+                xs_1_mut = FSharpList__get_Tail(xs_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(0, xs);
+}
+function item(n, xs) {
+    return FSharpList__get_Item_Z524259A4(xs, n);
+}
+function filter(f, xs) {
+    const root = FSharpList_get_Empty();
+    const node = fold((acc, x) => {
+        if (f(x)) {
+            const t = new FSharpList(x, undefined);
+            acc.tail = t;
+            return t;
+        }
+        else {
+            return acc;
+        }
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    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 = undefined, t_2 = undefined;
+        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) => {
+        const matchValue = f(x);
+        if (matchValue == null) {
+            return acc;
+        }
+        else {
+            const t = new FSharpList((0, Option_ts_1.value)(matchValue), undefined);
+            acc.tail = t;
+            return t;
+        }
+    }, root, xs);
+    const t_2 = FSharpList_get_Empty();
+    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) {
+    const root = FSharpList_get_Empty();
+    let node = root;
+    for (let i = 0; i <= (n - 1); i++) {
+        let xs = undefined, t = undefined;
+        node = ((xs = node, (t = (new FSharpList(f(i), undefined)), (xs.tail = t, t))));
+    }
+    const xs_2 = node;
+    const t_2 = FSharpList_get_Empty();
+    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 Util_ts_1.Exception(Global_ts_1.SR_inputWasEmpty);
+    }
+    else {
+        return fold(f, head(xs), tail(xs));
+    }
+}
+function reduceBack(f, xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        throw new Util_ts_1.Exception(Global_ts_1.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 = undefined;
+        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 Util_ts_1.Exception((Global_ts_1.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) | 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);
+    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((0, Array_ts_1.permute)(f, toArray(xs)));
+}
+function chunkBySize(chunkSize, xs) {
+    return ofArray((0, Array_ts_1.map)(ofArray, (0, Array_ts_1.chunkBySize)(chunkSize, toArray(xs))));
+}
+function allPairs(xs, ys) {
+    const root = FSharpList_get_Empty();
+    let node = root;
+    iterate((x) => {
+        iterate((y) => {
+            let xs_1 = undefined, t = undefined;
+            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 Util_ts_1.Exception((Global_ts_1.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;
+        if (FSharpList__get_IsEmpty(xs)) {
+            return xs;
+        }
+        else if (!predicate(FSharpList__get_Head(xs))) {
+            return xs;
+        }
+        else {
+            predicate_mut = predicate;
+            xs_mut = FSharpList__get_Tail(xs);
+            continue skipWhile;
+        }
+        break;
+    }
+}
+function take(count, xs) {
+    if (count < 0) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    const loop = (i_mut, acc_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            let t = undefined;
+            if (i <= 0) {
+                return acc;
+            }
+            else if (FSharpList__get_IsEmpty(xs_1)) {
+                throw new Util_ts_1.Exception((Global_ts_1.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) => {
+        loop: while (true) {
+            const acc = acc_mut, xs_1 = xs_1_mut;
+            let t = undefined;
+            if (FSharpList__get_IsEmpty(xs_1)) {
+                return acc;
+            }
+            else if (!predicate(FSharpList__get_Head(xs_1))) {
+                return acc;
+            }
+            else {
+                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(root, xs);
+    const t_2 = FSharpList_get_Empty();
+    node.tail = t_2;
+    return FSharpList__get_Tail(root);
+}
+function truncate(count, xs) {
+    const loop = (i_mut, acc_mut, xs_1_mut) => {
+        loop: while (true) {
+            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;
+            let t = undefined;
+            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 = (0, Option_ts_1.defaultArg)(startIndex, 0) | 0;
+    startIndex_1 = ((index < 0) ? 0 : index);
+    let endIndex_1;
+    const index_1 = (0, Option_ts_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 Util_ts_1.Exception((Global_ts_1.SR_inputMustBeNonNegative + "\\nParameter name: ") + "index");
+    }
+    if (index > FSharpList__get_Length(xs)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_notEnoughElements + "\\nParameter name: ") + "index");
+    }
+    return [take(index, xs), skip(index, xs)];
+}
+function exactlyOne(xs) {
+    if (FSharpList__get_IsEmpty(xs)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_inputSequenceEmpty + "\\nParameter name: ") + "list");
+    }
+    else if (FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {
+        return FSharpList__get_Head(xs);
+    }
+    else {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_inputSequenceTooLong + "\\nParameter name: ") + "list");
+    }
+}
+function tryExactlyOne(xs) {
+    if (!FSharpList__get_IsEmpty(xs) && FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {
+        return (0, Option_ts_1.some)(FSharpList__get_Head(xs));
+    }
+    else {
+        return undefined;
+    }
+}
+function where(predicate, xs) {
+    return filter(predicate, xs);
+}
+function pairwise(xs) {
+    return ofArray((0, Array_ts_1.pairwise)(toArray(xs)));
+}
+function windowed(windowSize, xs) {
+    return ofArray((0, Array_ts_1.map)(ofArray, (0, Array_ts_1.windowed)(windowSize, toArray(xs))));
+}
+function splitInto(chunks, xs) {
+    return ofArray((0, Array_ts_1.map)(ofArray, (0, Array_ts_1.splitInto)(chunks, toArray(xs))));
+}
+function transpose(lists) {
+    return ofArray((0, Array_ts_1.map)(ofArray, (0, Array_ts_1.transpose)((0, Array_ts_1.map)(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 Util_ts_1.Exception((Global_ts_1.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 Util_ts_1.Exception((Global_ts_1.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 Util_ts_1.Exception((Global_ts_1.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 Util_ts_1.Exception((Global_ts_1.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 Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return ys;
+}
+//# sourceMappingURL=List.js.map