@fossa-app/bridge 0.1.6 → 0.1.8

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

@@ -0,0 +1,1371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.append = append;
+exports.filter = filter;
+exports.fill = fill;
+exports.getSubArray = getSubArray;
+exports.last = last;
+exports.tryLast = tryLast;
+exports.mapIndexed = mapIndexed;
+exports.map = map;
+exports.mapIndexed2 = mapIndexed2;
+exports.map2 = map2;
+exports.mapIndexed3 = mapIndexed3;
+exports.map3 = map3;
+exports.mapFold = mapFold;
+exports.mapFoldBack = mapFoldBack;
+exports.indexed = indexed;
+exports.truncate = truncate;
+exports.concat = concat;
+exports.collect = collect;
+exports.where = where;
+exports.indexOf = indexOf;
+exports.contains = contains;
+exports.empty = empty;
+exports.singleton = singleton;
+exports.initialize = initialize;
+exports.pairwise = pairwise;
+exports.replicate = replicate;
+exports.copy = copy;
+exports.copyTo = copyTo;
+exports.reverse = reverse;
+exports.scan = scan;
+exports.scanBack = scanBack;
+exports.skip = skip;
+exports.skipWhile = skipWhile;
+exports.take = take;
+exports.takeWhile = takeWhile;
+exports.findAll = findAll;
+exports.getRange = getRange;
+exports.addInPlace = addInPlace;
+exports.addRangeInPlace = addRangeInPlace;
+exports.insertRangeInPlace = insertRangeInPlace;
+exports.removeInPlace = removeInPlace;
+exports.removeAllInPlace = removeAllInPlace;
+exports.partition = partition;
+exports.find = find;
+exports.tryFind = tryFind;
+exports.findIndex = findIndex;
+exports.tryFindIndex = tryFindIndex;
+exports.pick = pick;
+exports.tryPick = tryPick;
+exports.findBack = findBack;
+exports.tryFindBack = tryFindBack;
+exports.findLastIndex = findLastIndex;
+exports.findIndexBack = findIndexBack;
+exports.tryFindIndexBack = tryFindIndexBack;
+exports.choose = choose;
+exports.foldIndexed = foldIndexed;
+exports.fold = fold;
+exports.iterate = iterate;
+exports.iterateIndexed = iterateIndexed;
+exports.iterate2 = iterate2;
+exports.iterateIndexed2 = iterateIndexed2;
+exports.isEmpty = isEmpty;
+exports.forAll = forAll;
+exports.permute = permute;
+exports.setSlice = setSlice;
+exports.sortInPlaceBy = sortInPlaceBy;
+exports.sortInPlace = sortInPlace;
+exports.sort = sort;
+exports.sortBy = sortBy;
+exports.sortDescending = sortDescending;
+exports.sortByDescending = sortByDescending;
+exports.sortWith = sortWith;
+exports.allPairs = allPairs;
+exports.unfold = unfold;
+exports.unzip = unzip;
+exports.unzip3 = unzip3;
+exports.zip = zip;
+exports.zip3 = zip3;
+exports.chunkBySize = chunkBySize;
+exports.splitAt = splitAt;
+exports.compareWith = compareWith;
+exports.compareTo = compareTo;
+exports.equalsWith = equalsWith;
+exports.exactlyOne = exactlyOne;
+exports.tryExactlyOne = tryExactlyOne;
+exports.head = head;
+exports.tryHead = tryHead;
+exports.tail = tail;
+exports.item = item;
+exports.setItem = setItem;
+exports.tryItem = tryItem;
+exports.foldBackIndexed = foldBackIndexed;
+exports.foldBack = foldBack;
+exports.foldIndexed2 = foldIndexed2;
+exports.fold2 = fold2;
+exports.foldBackIndexed2 = foldBackIndexed2;
+exports.foldBack2 = foldBack2;
+exports.reduce = reduce;
+exports.reduceBack = reduceBack;
+exports.forAll2 = forAll2;
+exports.existsOffset = existsOffset;
+exports.exists = exists;
+exports.existsOffset2 = existsOffset2;
+exports.exists2 = exists2;
+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.windowed = windowed;
+exports.splitInto = splitInto;
+exports.transpose = transpose;
+exports.insertAt = insertAt;
+exports.insertManyAt = insertManyAt;
+exports.removeAt = removeAt;
+exports.removeManyAt = removeManyAt;
+exports.updateAt = updateAt;
+exports.resize = resize;
+const Util_ts_1 = require("./Util.js");
+const Native_ts_1 = require("./Native.js");
+const Array_ts_1 = require("./Array.js");
+const Option_ts_1 = require("./Option.js");
+const Double_ts_1 = require("./Double.js");
+const Global_ts_1 = require("./Global.js");
+const FSharp_Core_ts_1 = require("./FSharp.Core.js");
+function indexNotFound() {
+    throw new Util_ts_1.Exception("An index satisfying the predicate was not found in the collection.");
+}
+function differentLengths() {
+    throw new Util_ts_1.Exception("Arrays had different lengths");
+}
+function append(array1, array2, cons) {
+    const len1 = array1.length | 0;
+    const len2 = array2.length | 0;
+    const newArray = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len1 + len2);
+    for (let i = 0; i <= (len1 - 1); i++) {
+        (0, Array_ts_1.setItem)(newArray, i, (0, Array_ts_1.item)(i, array1));
+    }
+    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {
+        (0, Array_ts_1.setItem)(newArray, i_1 + len1, (0, Array_ts_1.item)(i_1, array2));
+    }
+    return newArray;
+}
+function filter(predicate, array) {
+    return array.filter(predicate);
+}
+function fill(target, targetIndex, count, value) {
+    const start = targetIndex | 0;
+    return target.fill(value, start, (start + count));
+}
+function getSubArray(array, start, count) {
+    const start_1 = start | 0;
+    return array.slice(start_1, (start_1 + count));
+}
+function last(array) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("The input array was empty\\nParameter name: array");
+    }
+    return (0, Array_ts_1.item)(array.length - 1, array);
+}
+function tryLast(array) {
+    if (array.length === 0) {
+        return undefined;
+    }
+    else {
+        return (0, Option_ts_1.some)((0, Array_ts_1.item)(array.length - 1, array));
+    }
+}
+function mapIndexed(f, source, cons) {
+    const len = source.length | 0;
+    const target = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        (0, Array_ts_1.setItem)(target, i, f(i, (0, Array_ts_1.item)(i, source)));
+    }
+    return target;
+}
+function map(f, source, cons) {
+    const len = source.length | 0;
+    const target = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        (0, Array_ts_1.setItem)(target, i, f((0, Array_ts_1.item)(i, source)));
+    }
+    return target;
+}
+function mapIndexed2(f, source1, source2, cons) {
+    if (source1.length !== source2.length) {
+        throw new Util_ts_1.Exception("Arrays had different lengths");
+    }
+    const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, source1.length);
+    for (let i = 0; i <= (source1.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, f(i, (0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2)));
+    }
+    return result;
+}
+function map2(f, source1, source2, cons) {
+    if (source1.length !== source2.length) {
+        throw new Util_ts_1.Exception("Arrays had different lengths");
+    }
+    const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, source1.length);
+    for (let i = 0; i <= (source1.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, f((0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2)));
+    }
+    return result;
+}
+function mapIndexed3(f, source1, source2, source3, cons) {
+    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {
+        throw new Util_ts_1.Exception("Arrays had different lengths");
+    }
+    const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, source1.length);
+    for (let i = 0; i <= (source1.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, f(i, (0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2), (0, Array_ts_1.item)(i, source3)));
+    }
+    return result;
+}
+function map3(f, source1, source2, source3, cons) {
+    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {
+        throw new Util_ts_1.Exception("Arrays had different lengths");
+    }
+    const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, source1.length);
+    for (let i = 0; i <= (source1.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, f((0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2), (0, Array_ts_1.item)(i, source3)));
+    }
+    return result;
+}
+function mapFold(mapping, state, array, cons) {
+    const matchValue = array.length | 0;
+    if (matchValue === 0) {
+        return [[], state];
+    }
+    else {
+        let acc = state;
+        const res = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, matchValue);
+        for (let i = 0; i <= (array.length - 1); i++) {
+            const patternInput = mapping(acc, (0, Array_ts_1.item)(i, array));
+            (0, Array_ts_1.setItem)(res, i, patternInput[0]);
+            acc = patternInput[1];
+        }
+        return [res, acc];
+    }
+}
+function mapFoldBack(mapping, array, state, cons) {
+    const matchValue = array.length | 0;
+    if (matchValue === 0) {
+        return [[], state];
+    }
+    else {
+        let acc = state;
+        const res = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, matchValue);
+        for (let i = array.length - 1; i >= 0; i--) {
+            const patternInput = mapping((0, Array_ts_1.item)(i, array), acc);
+            (0, Array_ts_1.setItem)(res, i, patternInput[0]);
+            acc = patternInput[1];
+        }
+        return [res, acc];
+    }
+}
+function indexed(source) {
+    const len = source.length | 0;
+    const target = new Array(len);
+    for (let i = 0; i <= (len - 1); i++) {
+        (0, Array_ts_1.setItem)(target, i, [i, (0, Array_ts_1.item)(i, source)]);
+    }
+    return target;
+}
+function truncate(count, array) {
+    const count_1 = (0, Double_ts_1.max)(0, count) | 0;
+    return array.slice(0, (0 + count_1));
+}
+function concat(arrays, cons) {
+    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));
+    const matchValue = arrays_1.length | 0;
+    switch (matchValue) {
+        case 0:
+            return (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 0);
+        case 1:
+            return (0, Array_ts_1.item)(0, arrays_1);
+        default: {
+            let totalIdx = 0;
+            let totalLength = 0;
+            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {
+                const arr_1 = (0, Array_ts_1.item)(idx, arrays_1);
+                totalLength = ((totalLength + arr_1.length) | 0);
+            }
+            const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, totalLength);
+            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {
+                const arr_2 = (0, Array_ts_1.item)(idx_1, arrays_1);
+                for (let j = 0; j <= (arr_2.length - 1); j++) {
+                    (0, Array_ts_1.setItem)(result, totalIdx, (0, Array_ts_1.item)(j, arr_2));
+                    totalIdx = ((totalIdx + 1) | 0);
+                }
+            }
+            return result;
+        }
+    }
+}
+function collect(mapping, array, cons) {
+    return concat(map(mapping, array, (0, Util_ts_1.defaultOf)()), cons);
+}
+function where(predicate, array) {
+    return array.filter(predicate);
+}
+function indexOf(array, item_1, start, count, eq) {
+    const start_1 = (0, Option_ts_1.defaultArg)(start, 0) | 0;
+    const end$0027 = (0, Option_ts_1.defaultArg)((0, Option_ts_1.map)((c) => ((start_1 + c) | 0), count), array.length) | 0;
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= end$0027) {
+                return -1;
+            }
+            else if (eq.Equals(item_1, (0, Array_ts_1.item)(i, array))) {
+                return i | 0;
+            }
+            else {
+                i_mut = (i + 1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(start_1) | 0;
+}
+function contains(value, array, eq) {
+    return indexOf(array, value, undefined, undefined, eq) >= 0;
+}
+function empty(cons) {
+    return (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 0);
+}
+function singleton(value, cons) {
+    const ar = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 1);
+    (0, Array_ts_1.setItem)(ar, 0, value);
+    return ar;
+}
+function initialize(count, initializer, cons) {
+    if (count < 0) {
+        throw new Util_ts_1.Exception("The input must be non-negative\\nParameter name: count");
+    }
+    const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, count);
+    for (let i = 0; i <= (count - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, initializer(i));
+    }
+    return result;
+}
+function pairwise(array) {
+    if (array.length < 2) {
+        return [];
+    }
+    else {
+        const count = (array.length - 1) | 0;
+        const result = new Array(count);
+        for (let i = 0; i <= (count - 1); i++) {
+            (0, Array_ts_1.setItem)(result, i, [(0, Array_ts_1.item)(i, array), (0, Array_ts_1.item)(i + 1, array)]);
+        }
+        return result;
+    }
+}
+function replicate(count, initial, cons) {
+    if (count < 0) {
+        throw new Util_ts_1.Exception("The input must be non-negative\\nParameter name: count");
+    }
+    const result = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, count);
+    for (let i = 0; i <= (result.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, initial);
+    }
+    return result;
+}
+function copy(array) {
+    return array.slice();
+}
+function copyTo(source, sourceIndex, target, targetIndex, count) {
+    (0, Util_ts_1.copyToArray)(source, sourceIndex, target, targetIndex, count);
+}
+function reverse(array) {
+    const array_2 = array.slice();
+    return array_2.reverse();
+}
+function scan(folder, state, array, cons) {
+    const res = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, array.length + 1);
+    (0, Array_ts_1.setItem)(res, 0, state);
+    for (let i = 0; i <= (array.length - 1); i++) {
+        (0, Array_ts_1.setItem)(res, i + 1, folder((0, Array_ts_1.item)(i, res), (0, Array_ts_1.item)(i, array)));
+    }
+    return res;
+}
+function scanBack(folder, array, state, cons) {
+    const res = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, array.length + 1);
+    (0, Array_ts_1.setItem)(res, array.length, state);
+    for (let i = array.length - 1; i >= 0; i--) {
+        (0, Array_ts_1.setItem)(res, i, folder((0, Array_ts_1.item)(i, array), (0, Array_ts_1.item)(i + 1, res)));
+    }
+    return res;
+}
+function skip(count, array, cons) {
+    if (count > array.length) {
+        throw new Util_ts_1.Exception("count is greater than array length\\nParameter name: count");
+    }
+    if (count === array.length) {
+        return (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 0);
+    }
+    else {
+        const count_1 = ((count < 0) ? 0 : count) | 0;
+        return array.slice(count_1);
+    }
+}
+function skipWhile(predicate, array, cons) {
+    let count = 0;
+    while ((count < array.length) && predicate((0, Array_ts_1.item)(count, array))) {
+        count = ((count + 1) | 0);
+    }
+    if (count === array.length) {
+        return (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 0);
+    }
+    else {
+        const count_1 = count | 0;
+        return array.slice(count_1);
+    }
+}
+function take(count, array, cons) {
+    if (count < 0) {
+        throw new Util_ts_1.Exception("The input must be non-negative\\nParameter name: count");
+    }
+    if (count > array.length) {
+        throw new Util_ts_1.Exception("count is greater than array length\\nParameter name: count");
+    }
+    if (count === 0) {
+        return (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 0);
+    }
+    else {
+        return array.slice(0, (0 + count));
+    }
+}
+function takeWhile(predicate, array, cons) {
+    let count = 0;
+    while ((count < array.length) && predicate((0, Array_ts_1.item)(count, array))) {
+        count = ((count + 1) | 0);
+    }
+    if (count === 0) {
+        return (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, 0);
+    }
+    else {
+        const count_1 = count | 0;
+        return array.slice(0, (0 + count_1));
+    }
+}
+function findAll(predicate, array) {
+    return array.filter(predicate);
+}
+function getRange(array, start, count) {
+    const start_1 = start | 0;
+    return array.slice(start_1, (start_1 + count));
+}
+function addInPlace(x, array) {
+    array.push(x);
+}
+function addRangeInPlace(range, array) {
+    const enumerator = (0, Util_ts_1.getEnumerator)(range);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            addInPlace(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), array);
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(enumerator);
+    }
+}
+function insertRangeInPlace(index, range, array) {
+    let i = index;
+    const enumerator = (0, Util_ts_1.getEnumerator)(range);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            let index_1 = undefined;
+            const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            (index_1 = (i | 0), array.splice(index_1, 0, x));
+            i = ((i + 1) | 0);
+        }
+    }
+    finally {
+        (0, Util_ts_1.disposeSafe)(enumerator);
+    }
+}
+function removeInPlace(item_1, array, eq) {
+    const i = indexOf(array, item_1, undefined, undefined, eq) | 0;
+    if (i > -1) {
+        array.splice(i, 1);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function removeAllInPlace(predicate, array) {
+    const countRemoveAll = (count) => {
+        let i;
+        const array_1 = array;
+        i = (array_1.findIndex(predicate));
+        if (i > -1) {
+            array.splice(i, 1);
+            return (countRemoveAll(count) + 1) | 0;
+        }
+        else {
+            return count | 0;
+        }
+    };
+    return countRemoveAll(0) | 0;
+}
+function partition(f, source, cons) {
+    const len = source.length | 0;
+    const res1 = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len);
+    const res2 = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len);
+    let iTrue = 0;
+    let iFalse = 0;
+    for (let i = 0; i <= (len - 1); i++) {
+        if (f((0, Array_ts_1.item)(i, source))) {
+            (0, Array_ts_1.setItem)(res1, iTrue, (0, Array_ts_1.item)(i, source));
+            iTrue = ((iTrue + 1) | 0);
+        }
+        else {
+            (0, Array_ts_1.setItem)(res2, iFalse, (0, Array_ts_1.item)(i, source));
+            iFalse = ((iFalse + 1) | 0);
+        }
+    }
+    return [truncate(iTrue, res1), truncate(iFalse, res2)];
+}
+function find(predicate, array) {
+    const matchValue = array.find(predicate);
+    if (matchValue == null) {
+        return indexNotFound();
+    }
+    else {
+        return (0, Option_ts_1.value)(matchValue);
+    }
+}
+function tryFind(predicate, array) {
+    return array.find(predicate);
+}
+function findIndex(predicate, array) {
+    const matchValue = (array.findIndex(predicate)) | 0;
+    if (matchValue > -1) {
+        return matchValue | 0;
+    }
+    else {
+        indexNotFound();
+        return -1;
+    }
+}
+function tryFindIndex(predicate, array) {
+    const matchValue = (array.findIndex(predicate)) | 0;
+    if (matchValue > -1) {
+        return matchValue;
+    }
+    else {
+        return undefined;
+    }
+}
+function pick(chooser, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= array.length) {
+                return indexNotFound();
+            }
+            else {
+                const matchValue = chooser((0, Array_ts_1.item)(i, array));
+                if (matchValue != null) {
+                    return (0, Option_ts_1.value)(matchValue);
+                }
+                else {
+                    i_mut = (i + 1);
+                    continue loop;
+                }
+            }
+            break;
+        }
+    };
+    return loop(0);
+}
+function tryPick(chooser, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= array.length) {
+                return undefined;
+            }
+            else {
+                const matchValue = chooser((0, Array_ts_1.item)(i, array));
+                if (matchValue == null) {
+                    i_mut = (i + 1);
+                    continue loop;
+                }
+                else {
+                    return matchValue;
+                }
+            }
+            break;
+        }
+    };
+    return loop(0);
+}
+function findBack(predicate, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i < 0) {
+                return indexNotFound();
+            }
+            else if (predicate((0, Array_ts_1.item)(i, array))) {
+                return (0, Array_ts_1.item)(i, array);
+            }
+            else {
+                i_mut = (i - 1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(array.length - 1);
+}
+function tryFindBack(predicate, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i < 0) {
+                return undefined;
+            }
+            else if (predicate((0, Array_ts_1.item)(i, array))) {
+                return (0, Option_ts_1.some)((0, Array_ts_1.item)(i, array));
+            }
+            else {
+                i_mut = (i - 1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(array.length - 1);
+}
+function findLastIndex(predicate, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i < 0) {
+                return -1;
+            }
+            else if (predicate((0, Array_ts_1.item)(i, array))) {
+                return i | 0;
+            }
+            else {
+                i_mut = (i - 1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(array.length - 1) | 0;
+}
+function findIndexBack(predicate, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i < 0) {
+                indexNotFound();
+                return -1;
+            }
+            else if (predicate((0, Array_ts_1.item)(i, array))) {
+                return i | 0;
+            }
+            else {
+                i_mut = (i - 1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(array.length - 1) | 0;
+}
+function tryFindIndexBack(predicate, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i < 0) {
+                return undefined;
+            }
+            else if (predicate((0, Array_ts_1.item)(i, array))) {
+                return i;
+            }
+            else {
+                i_mut = (i - 1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(array.length - 1);
+}
+function choose(chooser, array, cons) {
+    const res = [];
+    for (let i = 0; i <= (array.length - 1); i++) {
+        const matchValue = chooser((0, Array_ts_1.item)(i, array));
+        if (matchValue != null) {
+            const y = (0, Option_ts_1.value)(matchValue);
+            res.push(y);
+        }
+    }
+    if (cons == null) {
+        return res;
+    }
+    else {
+        return map((x) => x, res, cons);
+    }
+}
+function foldIndexed(folder, state, array) {
+    return array.reduce(((delegateArg, delegateArg_1, delegateArg_2) => folder(delegateArg_2, delegateArg, delegateArg_1)), state);
+}
+function fold(folder, state, array) {
+    const folder_1 = folder;
+    return array.reduce((folder_1), state);
+}
+function iterate(action, array) {
+    for (let i = 0; i <= (array.length - 1); i++) {
+        action((0, Array_ts_1.item)(i, array));
+    }
+}
+function iterateIndexed(action, array) {
+    for (let i = 0; i <= (array.length - 1); i++) {
+        action(i, (0, Array_ts_1.item)(i, array));
+    }
+}
+function iterate2(action, array1, array2) {
+    if (array1.length !== array2.length) {
+        differentLengths();
+    }
+    for (let i = 0; i <= (array1.length - 1); i++) {
+        action((0, Array_ts_1.item)(i, array1), (0, Array_ts_1.item)(i, array2));
+    }
+}
+function iterateIndexed2(action, array1, array2) {
+    if (array1.length !== array2.length) {
+        differentLengths();
+    }
+    for (let i = 0; i <= (array1.length - 1); i++) {
+        action(i, (0, Array_ts_1.item)(i, array1), (0, Array_ts_1.item)(i, array2));
+    }
+}
+function isEmpty(array) {
+    return array.length === 0;
+}
+function forAll(predicate, array) {
+    return array.every(predicate);
+}
+function permute(f, array) {
+    const size = array.length | 0;
+    const res = array.slice();
+    const checkFlags = new Array(size);
+    iterateIndexed((i, x) => {
+        const j = f(i) | 0;
+        if ((j < 0) ? true : (j >= size)) {
+            throw new Util_ts_1.Exception("Not a valid permutation");
+        }
+        (0, Array_ts_1.setItem)(res, j, x);
+        (0, Array_ts_1.setItem)(checkFlags, j, 1);
+    }, array);
+    if (!(checkFlags.every((y) => (1 === y)))) {
+        throw new Util_ts_1.Exception("Not a valid permutation");
+    }
+    return res;
+}
+function setSlice(target, lower, upper, source) {
+    const lower_1 = (0, Option_ts_1.defaultArg)(lower, 0) | 0;
+    const upper_1 = (0, Option_ts_1.defaultArg)(upper, -1) | 0;
+    const length = (((upper_1 >= 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;
+    for (let i = 0; i <= length; i++) {
+        (0, Array_ts_1.setItem)(target, i + lower_1, (0, Array_ts_1.item)(i, source));
+    }
+}
+function sortInPlaceBy(projection, xs, comparer) {
+    xs.sort((x, y) => (comparer.Compare(projection(x), projection(y)) | 0));
+}
+function sortInPlace(xs, comparer) {
+    xs.sort((x, y) => (comparer.Compare(x, y) | 0));
+}
+function sort(xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => (comparer.Compare(x, y) | 0));
+    return xs_1;
+}
+function sortBy(projection, xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => (comparer.Compare(projection(x), projection(y)) | 0));
+    return xs_1;
+}
+function sortDescending(xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => ((comparer.Compare(x, y) * -1) | 0));
+    return xs_1;
+}
+function sortByDescending(projection, xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => ((comparer.Compare(projection(x), projection(y)) * -1) | 0));
+    return xs_1;
+}
+function sortWith(comparer, xs) {
+    const comparer_1 = comparer;
+    const xs_1 = xs.slice();
+    xs_1.sort(comparer_1);
+    return xs_1;
+}
+function allPairs(xs, ys) {
+    const len1 = xs.length | 0;
+    const len2 = ys.length | 0;
+    const res = new Array(len1 * len2);
+    for (let i = 0; i <= (xs.length - 1); i++) {
+        for (let j = 0; j <= (ys.length - 1); j++) {
+            (0, Array_ts_1.setItem)(res, (i * len2) + j, [(0, Array_ts_1.item)(i, xs), (0, Array_ts_1.item)(j, ys)]);
+        }
+    }
+    return res;
+}
+function unfold(generator, state) {
+    const res = [];
+    const loop = (state_1_mut) => {
+        loop: while (true) {
+            const state_1 = state_1_mut;
+            const matchValue = generator(state_1);
+            if (matchValue != null) {
+                const x = (0, Option_ts_1.value)(matchValue)[0];
+                const s = (0, Option_ts_1.value)(matchValue)[1];
+                res.push(x);
+                state_1_mut = s;
+                continue loop;
+            }
+            break;
+        }
+    };
+    loop(state);
+    return res;
+}
+function unzip(array) {
+    const len = array.length | 0;
+    const res1 = new Array(len);
+    const res2 = new Array(len);
+    iterateIndexed((i, tupledArg) => {
+        (0, Array_ts_1.setItem)(res1, i, tupledArg[0]);
+        (0, Array_ts_1.setItem)(res2, i, tupledArg[1]);
+    }, array);
+    return [res1, res2];
+}
+function unzip3(array) {
+    const len = array.length | 0;
+    const res1 = new Array(len);
+    const res2 = new Array(len);
+    const res3 = new Array(len);
+    iterateIndexed((i, tupledArg) => {
+        (0, Array_ts_1.setItem)(res1, i, tupledArg[0]);
+        (0, Array_ts_1.setItem)(res2, i, tupledArg[1]);
+        (0, Array_ts_1.setItem)(res3, i, tupledArg[2]);
+    }, array);
+    return [res1, res2, res3];
+}
+function zip(array1, array2) {
+    if (array1.length !== array2.length) {
+        differentLengths();
+    }
+    const result = new Array(array1.length);
+    for (let i = 0; i <= (array1.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, [(0, Array_ts_1.item)(i, array1), (0, Array_ts_1.item)(i, array2)]);
+    }
+    return result;
+}
+function zip3(array1, array2, array3) {
+    if ((array1.length !== array2.length) ? true : (array2.length !== array3.length)) {
+        differentLengths();
+    }
+    const result = new Array(array1.length);
+    for (let i = 0; i <= (array1.length - 1); i++) {
+        (0, Array_ts_1.setItem)(result, i, [(0, Array_ts_1.item)(i, array1), (0, Array_ts_1.item)(i, array2), (0, Array_ts_1.item)(i, array3)]);
+    }
+    return result;
+}
+function chunkBySize(chunkSize, array) {
+    if (chunkSize < 1) {
+        throw new Util_ts_1.Exception("The input must be positive.\\nParameter name: size");
+    }
+    const result = [];
+    if (array.length > 0) {
+        const chunks = ~~Math.ceil(array.length / chunkSize) | 0;
+        for (let x = 0; x <= (chunks - 1); x++) {
+            let slice;
+            const start_1 = (x * chunkSize) | 0;
+            slice = (array.slice(start_1, (start_1 + chunkSize)));
+            result.push(slice);
+        }
+    }
+    return result;
+}
+function splitAt(index, array) {
+    if ((index < 0) ? true : (index > array.length)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    return [array.slice(0, (0 + index)), array.slice(index)];
+}
+function compareWith(comparer, source1, source2) {
+    if ((0, FSharp_Core_ts_1.Operators_IsNull)(source1)) {
+        if ((0, FSharp_Core_ts_1.Operators_IsNull)(source2)) {
+            return 0;
+        }
+        else {
+            return -1;
+        }
+    }
+    else if ((0, FSharp_Core_ts_1.Operators_IsNull)(source2)) {
+        return 1;
+    }
+    else {
+        const len1 = source1.length | 0;
+        const len2 = source2.length | 0;
+        const len = ((len1 < len2) ? len1 : len2) | 0;
+        let i = 0;
+        let res = 0;
+        while ((res === 0) && (i < len)) {
+            res = (comparer((0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2)) | 0);
+            i = ((i + 1) | 0);
+        }
+        if (res !== 0) {
+            return res | 0;
+        }
+        else if (len1 > len2) {
+            return 1;
+        }
+        else if (len1 < len2) {
+            return -1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+function compareTo(comparer, source1, source2) {
+    if ((0, FSharp_Core_ts_1.Operators_IsNull)(source1)) {
+        if ((0, FSharp_Core_ts_1.Operators_IsNull)(source2)) {
+            return 0;
+        }
+        else {
+            return -1;
+        }
+    }
+    else if ((0, FSharp_Core_ts_1.Operators_IsNull)(source2)) {
+        return 1;
+    }
+    else {
+        const len1 = source1.length | 0;
+        const len2 = source2.length | 0;
+        if (len1 > len2) {
+            return 1;
+        }
+        else if (len1 < len2) {
+            return -1;
+        }
+        else {
+            let i = 0;
+            let res = 0;
+            while ((res === 0) && (i < len1)) {
+                res = (comparer((0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2)) | 0);
+                i = ((i + 1) | 0);
+            }
+            return res | 0;
+        }
+    }
+}
+function equalsWith(equals, source1, source2) {
+    if ((0, FSharp_Core_ts_1.Operators_IsNull)(source1)) {
+        if ((0, FSharp_Core_ts_1.Operators_IsNull)(source2)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if ((0, FSharp_Core_ts_1.Operators_IsNull)(source2)) {
+        return false;
+    }
+    else {
+        let i = 0;
+        let result = true;
+        const length1 = source1.length | 0;
+        const length2 = source2.length | 0;
+        if (length1 > length2) {
+            return false;
+        }
+        else if (length1 < length2) {
+            return false;
+        }
+        else {
+            while ((i < length1) && result) {
+                result = equals((0, Array_ts_1.item)(i, source1), (0, Array_ts_1.item)(i, source2));
+                i = ((i + 1) | 0);
+            }
+            return result;
+        }
+    }
+}
+function exactlyOne(array) {
+    switch (array.length) {
+        case 1:
+            return (0, Array_ts_1.item)(0, array);
+        case 0:
+            throw new Util_ts_1.Exception("The input sequence was empty\\nParameter name: array");
+        default:
+            throw new Util_ts_1.Exception("Input array too long\\nParameter name: array");
+    }
+}
+function tryExactlyOne(array) {
+    if (array.length === 1) {
+        return (0, Option_ts_1.some)((0, Array_ts_1.item)(0, array));
+    }
+    else {
+        return undefined;
+    }
+}
+function head(array) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("The input array was empty\\nParameter name: array");
+    }
+    else {
+        return (0, Array_ts_1.item)(0, array);
+    }
+}
+function tryHead(array) {
+    if (array.length === 0) {
+        return undefined;
+    }
+    else {
+        return (0, Option_ts_1.some)((0, Array_ts_1.item)(0, array));
+    }
+}
+function tail(array) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("Not enough elements\\nParameter name: array");
+    }
+    return array.slice(1);
+}
+function item(index, array) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Util_ts_1.Exception("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        return array[index];
+    }
+}
+function setItem(array, index, value) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Util_ts_1.Exception("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        array[index] = value;
+    }
+}
+function tryItem(index, array) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        return undefined;
+    }
+    else {
+        return (0, Option_ts_1.some)(array[index]);
+    }
+}
+function foldBackIndexed(folder, array, state) {
+    return array.reduceRight(((delegateArg, delegateArg_1, delegateArg_2) => folder(delegateArg_2, delegateArg_1, delegateArg)), state);
+}
+function foldBack(folder, array, state) {
+    return array.reduceRight(((delegateArg, delegateArg_1) => folder(delegateArg_1, delegateArg)), state);
+}
+function foldIndexed2(folder, state, array1, array2) {
+    let acc = state;
+    if (array1.length !== array2.length) {
+        throw new Util_ts_1.Exception("Arrays have different lengths");
+    }
+    for (let i = 0; i <= (array1.length - 1); i++) {
+        acc = folder(i, acc, (0, Array_ts_1.item)(i, array1), (0, Array_ts_1.item)(i, array2));
+    }
+    return acc;
+}
+function fold2(folder, state, array1, array2) {
+    return foldIndexed2((_arg, acc, x, y) => folder(acc, x, y), state, array1, array2);
+}
+function foldBackIndexed2(folder, array1, array2, state) {
+    let acc = state;
+    if (array1.length !== array2.length) {
+        differentLengths();
+    }
+    const size = array1.length | 0;
+    for (let i = 1; i <= size; i++) {
+        acc = folder(i - 1, (0, Array_ts_1.item)(size - i, array1), (0, Array_ts_1.item)(size - i, array2), acc);
+    }
+    return acc;
+}
+function foldBack2(f, array1, array2, state) {
+    return foldBackIndexed2((_arg, x, y, acc) => f(x, y, acc), array1, array2, state);
+}
+function reduce(reduction, array) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("The input array was empty");
+    }
+    const reduction_1 = reduction;
+    return array.reduce(reduction_1);
+}
+function reduceBack(reduction, array) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("The input array was empty");
+    }
+    const reduction_1 = reduction;
+    return array.reduceRight(reduction_1);
+}
+function forAll2(predicate, array1, array2) {
+    return fold2((acc, x, y) => (acc && predicate(x, y)), true, array1, array2);
+}
+function existsOffset(predicate_mut, array_mut, index_mut) {
+    existsOffset: while (true) {
+        const predicate = predicate_mut, array = array_mut, index = index_mut;
+        if (index === array.length) {
+            return false;
+        }
+        else if (predicate((0, Array_ts_1.item)(index, array))) {
+            return true;
+        }
+        else {
+            predicate_mut = predicate;
+            array_mut = array;
+            index_mut = (index + 1);
+            continue existsOffset;
+        }
+        break;
+    }
+}
+function exists(predicate, array) {
+    return existsOffset(predicate, array, 0);
+}
+function existsOffset2(predicate_mut, array1_mut, array2_mut, index_mut) {
+    existsOffset2: while (true) {
+        const predicate = predicate_mut, array1 = array1_mut, array2 = array2_mut, index = index_mut;
+        if (index === array1.length) {
+            return false;
+        }
+        else if (predicate((0, Array_ts_1.item)(index, array1), (0, Array_ts_1.item)(index, array2))) {
+            return true;
+        }
+        else {
+            predicate_mut = predicate;
+            array1_mut = array1;
+            array2_mut = array2;
+            index_mut = (index + 1);
+            continue existsOffset2;
+        }
+        break;
+    }
+}
+function exists2(predicate, array1, array2) {
+    if (array1.length !== array2.length) {
+        differentLengths();
+    }
+    return existsOffset2(predicate, array1, array2, 0);
+}
+function sum(array, adder) {
+    let acc = adder.GetZero();
+    for (let i = 0; i <= (array.length - 1); i++) {
+        acc = adder.Add(acc, (0, Array_ts_1.item)(i, array));
+    }
+    return acc;
+}
+function sumBy(projection, array, adder) {
+    let acc = adder.GetZero();
+    for (let i = 0; i <= (array.length - 1); i++) {
+        acc = adder.Add(acc, projection((0, Array_ts_1.item)(i, array)));
+    }
+    return acc;
+}
+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(array, averager) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("The input array was empty\\nParameter name: array");
+    }
+    let total = averager.GetZero();
+    for (let i = 0; i <= (array.length - 1); i++) {
+        total = averager.Add(total, (0, Array_ts_1.item)(i, array));
+    }
+    return averager.DivideByInt(total, array.length);
+}
+function averageBy(projection, array, averager) {
+    if (array.length === 0) {
+        throw new Util_ts_1.Exception("The input array was empty\\nParameter name: array");
+    }
+    let total = averager.GetZero();
+    for (let i = 0; i <= (array.length - 1); i++) {
+        total = averager.Add(total, projection((0, Array_ts_1.item)(i, array)));
+    }
+    return averager.DivideByInt(total, array.length);
+}
+function windowed(windowSize, source) {
+    if (windowSize <= 0) {
+        throw new Util_ts_1.Exception("windowSize must be positive");
+    }
+    let res;
+    const len = (0, Double_ts_1.max)(0, (source.length - windowSize) + 1) | 0;
+    res = (new Array(len));
+    for (let i = windowSize; i <= source.length; i++) {
+        (0, Array_ts_1.setItem)(res, i - windowSize, source.slice(i - windowSize, (i - 1) + 1));
+    }
+    return res;
+}
+function splitInto(chunks, array) {
+    if (chunks < 1) {
+        throw new Util_ts_1.Exception("The input must be positive.\\nParameter name: chunks");
+    }
+    const result = [];
+    if (array.length > 0) {
+        const chunks_1 = (0, Double_ts_1.min)(chunks, array.length) | 0;
+        const minChunkSize = ~~(array.length / chunks_1) | 0;
+        const chunksWithExtraItem = (array.length % chunks_1) | 0;
+        for (let i = 0; i <= (chunks_1 - 1); i++) {
+            const chunkSize = ((i < chunksWithExtraItem) ? (minChunkSize + 1) : minChunkSize) | 0;
+            let slice;
+            const start_1 = ((i * minChunkSize) + (0, Double_ts_1.min)(chunksWithExtraItem, i)) | 0;
+            slice = (array.slice(start_1, (start_1 + chunkSize)));
+            result.push(slice);
+        }
+    }
+    return result;
+}
+function transpose(arrays, cons) {
+    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));
+    const len = arrays_1.length | 0;
+    if (len === 0) {
+        return new Array(0);
+    }
+    else {
+        const firstArray = (0, Array_ts_1.item)(0, arrays_1);
+        const lenInner = firstArray.length | 0;
+        if (!forAll((a) => (a.length === lenInner), arrays_1)) {
+            differentLengths();
+        }
+        const result = new Array(lenInner);
+        for (let i = 0; i <= (lenInner - 1); i++) {
+            (0, Array_ts_1.setItem)(result, i, (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len));
+            for (let j = 0; j <= (len - 1); j++) {
+                (0, Array_ts_1.item)(i, result)[j] = (0, Array_ts_1.item)(i, (0, Array_ts_1.item)(j, arrays_1));
+            }
+        }
+        return result;
+    }
+}
+function insertAt(index, y, xs, cons) {
+    const len = xs.length | 0;
+    if ((index < 0) ? true : (index > len)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    const target = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len + 1);
+    for (let i = 0; i <= (index - 1); i++) {
+        (0, Array_ts_1.setItem)(target, i, (0, Array_ts_1.item)(i, xs));
+    }
+    (0, Array_ts_1.setItem)(target, index, y);
+    for (let i_1 = index; i_1 <= (len - 1); i_1++) {
+        (0, Array_ts_1.setItem)(target, i_1 + 1, (0, Array_ts_1.item)(i_1, xs));
+    }
+    return target;
+}
+function insertManyAt(index, ys, xs, cons) {
+    const len = xs.length | 0;
+    if ((index < 0) ? true : (index > len)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    const ys_1 = Array.from(ys);
+    const len2 = ys_1.length | 0;
+    const target = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len + len2);
+    for (let i = 0; i <= (index - 1); i++) {
+        (0, Array_ts_1.setItem)(target, i, (0, Array_ts_1.item)(i, xs));
+    }
+    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {
+        (0, Array_ts_1.setItem)(target, index + i_1, (0, Array_ts_1.item)(i_1, ys_1));
+    }
+    for (let i_2 = index; i_2 <= (len - 1); i_2++) {
+        (0, Array_ts_1.setItem)(target, i_2 + len2, (0, Array_ts_1.item)(i_2, xs));
+    }
+    return target;
+}
+function removeAt(index, xs) {
+    if ((index < 0) ? true : (index >= xs.length)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    let i = -1;
+    return filter((_arg) => {
+        i = ((i + 1) | 0);
+        return i !== index;
+    }, xs);
+}
+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, cons) {
+    const len = xs.length | 0;
+    if ((index < 0) ? true : (index >= len)) {
+        throw new Util_ts_1.Exception((Global_ts_1.SR_indexOutOfBounds + "\\nParameter name: ") + "index");
+    }
+    const target = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        (0, Array_ts_1.setItem)(target, i, (i === index) ? y : (0, Array_ts_1.item)(i, xs));
+    }
+    return target;
+}
+function resize(xs, newSize, zero, cons) {
+    let array = undefined, array_1 = undefined, start_2 = undefined, count_2 = undefined;
+    if (newSize < 0) {
+        throw new Util_ts_1.Exception("The input must be non-negative.\\nParameter name: newSize");
+    }
+    const zero_1 = (0, Option_ts_1.defaultArg)(zero, (0, Util_ts_1.defaultOf)());
+    if ((0, FSharp_Core_ts_1.Operators_IsNull)(xs.contents)) {
+        xs.contents = ((array = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, newSize), array.fill(zero_1, 0, (0 + newSize))));
+    }
+    else {
+        const len = xs.contents.length | 0;
+        if (newSize < len) {
+            xs.contents = ((array_1 = xs.contents, array_1.slice(0, (0 + newSize))));
+        }
+        else if (newSize > len) {
+            const target = (0, Native_ts_1.Helpers_allocateArrayFromCons)(cons, newSize);
+            if (len > 0) {
+                copyTo(xs.contents, 0, target, 0, len);
+            }
+            xs.contents = ((start_2 = (len | 0), (count_2 = ((newSize - len) | 0), target.fill(zero_1, start_2, (start_2 + count_2)))));
+        }
+    }
+}
+//# sourceMappingURL=Array.js.map