@nfdi4plants/arctrl 3.1.1 → 3.2.0

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

@@ -0,0 +1,1296 @@
+import { Exception, defaultOf, copyToArray, getEnumerator, disposeSafe } from './Util.js';
+import { Helpers_allocateArrayFromCons } from './Native.js';
+import { some, defaultArg, value } from './Option.js';
+import { max as max$1, min as min$1 } from './Double.js';
+import { SR_indexOutOfBounds, SR_Arg_ArgumentOutOfRangeException, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements } from './Global.js';
+import { Operators_IsNull } from './FSharp.Core.js';
+import { nonSeeded } from './Random.js';
+
+function indexNotFound() {
+  throw new Exception("An index satisfying the predicate was not found in the collection.");
+}
+function differentLengths() {
+  throw new Exception("Arrays had different lengths");
+}
+function append(array1, array2, cons) {
+  const len1 = array1.length | 0;
+  const len2 = array2.length | 0;
+  const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);
+  for (let i = 0; i <= len1 - 1; i++) {
+    setItem(newArray, i, item(i, array1));
+  }
+  for (let i_1 = 0; i_1 <= len2 - 1; i_1++) {
+    setItem(newArray, i_1 + len1, 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 Exception("The input array was empty (Parameter 'array')");
+  }
+  return item(array.length - 1, array);
+}
+function tryLast(array) {
+  if (array.length === 0) {
+    return void 0;
+  } else {
+    return some(item(array.length - 1, array));
+  }
+}
+function mapIndexed(f, source, cons) {
+  const len = source.length | 0;
+  const target = Helpers_allocateArrayFromCons(cons, len);
+  for (let i = 0; i <= len - 1; i++) {
+    setItem(target, i, f(i, item(i, source)));
+  }
+  return target;
+}
+function map(f, source, cons) {
+  const len = source.length | 0;
+  const target = Helpers_allocateArrayFromCons(cons, len);
+  for (let i = 0; i <= len - 1; i++) {
+    setItem(target, i, f(item(i, source)));
+  }
+  return target;
+}
+function mapIndexed2(f, source1, source2, cons) {
+  if (source1.length !== source2.length) {
+    throw new Exception("Arrays had different lengths");
+  }
+  const result = Helpers_allocateArrayFromCons(cons, source1.length);
+  for (let i = 0; i <= source1.length - 1; i++) {
+    setItem(result, i, f(i, item(i, source1), item(i, source2)));
+  }
+  return result;
+}
+function map2(f, source1, source2, cons) {
+  if (source1.length !== source2.length) {
+    throw new Exception("Arrays had different lengths");
+  }
+  const result = Helpers_allocateArrayFromCons(cons, source1.length);
+  for (let i = 0; i <= source1.length - 1; i++) {
+    setItem(result, i, f(item(i, source1), item(i, source2)));
+  }
+  return result;
+}
+function mapIndexed3(f, source1, source2, source3, cons) {
+  if (source1.length !== source2.length ? true : source2.length !== source3.length) {
+    throw new Exception("Arrays had different lengths");
+  }
+  const result = Helpers_allocateArrayFromCons(cons, source1.length);
+  for (let i = 0; i <= source1.length - 1; i++) {
+    setItem(result, i, f(i, item(i, source1), item(i, source2), item(i, source3)));
+  }
+  return result;
+}
+function map3(f, source1, source2, source3, cons) {
+  if (source1.length !== source2.length ? true : source2.length !== source3.length) {
+    throw new Exception("Arrays had different lengths");
+  }
+  const result = Helpers_allocateArrayFromCons(cons, source1.length);
+  for (let i = 0; i <= source1.length - 1; i++) {
+    setItem(result, i, f(item(i, source1), item(i, source2), 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 = Helpers_allocateArrayFromCons(cons, matchValue);
+    for (let i = 0; i <= array.length - 1; i++) {
+      const patternInput = mapping(acc, item(i, array));
+      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 = Helpers_allocateArrayFromCons(cons, matchValue);
+    for (let i = array.length - 1; i >= 0; i--) {
+      const patternInput = mapping(item(i, array), acc);
+      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++) {
+    setItem(target, i, [i, item(i, source)]);
+  }
+  return target;
+}
+function truncate(count, array) {
+  const count_1 = max$1(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 Helpers_allocateArrayFromCons(cons, 0);
+    case 1:
+      return item(0, arrays_1);
+    default: {
+      let totalIdx = 0;
+      let totalLength = 0;
+      for (let idx = 0; idx <= arrays_1.length - 1; idx++) {
+        const arr_1 = item(idx, arrays_1);
+        totalLength = totalLength + arr_1.length | 0;
+      }
+      const result = Helpers_allocateArrayFromCons(cons, totalLength);
+      for (let idx_1 = 0; idx_1 <= arrays_1.length - 1; idx_1++) {
+        const arr_2 = item(idx_1, arrays_1);
+        for (let j = 0; j <= arr_2.length - 1; j++) {
+          setItem(result, totalIdx, item(j, arr_2));
+          totalIdx = totalIdx + 1 | 0;
+        }
+      }
+      return result;
+    }
+  }
+}
+function collect(mapping, array, cons) {
+  return concat(map(mapping, array, defaultOf()), cons);
+}
+function where(predicate, array) {
+  return array.filter(predicate);
+}
+function indexOf(array, item_1, start, count, eq) {
+  let option_1 = void 0;
+  const start_1 = defaultArg(start, 0) | 0;
+  const end$0027 = defaultArg((option_1 = count, option_1 != null ? start_1 + value(option_1) : void 0), 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, 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, void 0, void 0, eq) >= 0;
+}
+function empty(cons) {
+  return Helpers_allocateArrayFromCons(cons, 0);
+}
+function singleton(value, cons) {
+  const ar = Helpers_allocateArrayFromCons(cons, 1);
+  setItem(ar, 0, value);
+  return ar;
+}
+function initialize(count, initializer, cons) {
+  if (count < 0) {
+    throw new Exception("The input must be non-negative (Parameter 'count')");
+  }
+  const result = Helpers_allocateArrayFromCons(cons, count);
+  for (let i = 0; i <= count - 1; i++) {
+    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++) {
+      setItem(result, i, [item(i, array), item(i + 1, array)]);
+    }
+    return result;
+  }
+}
+function replicate(count, initial, cons) {
+  if (count < 0) {
+    throw new Exception("The input must be non-negative (Parameter 'count')");
+  }
+  const result = Helpers_allocateArrayFromCons(cons, count);
+  for (let i = 0; i <= result.length - 1; i++) {
+    setItem(result, i, initial);
+  }
+  return result;
+}
+function copy(array) {
+  return array.slice();
+}
+function copyTo(source, sourceIndex, target, targetIndex, count) {
+  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 = Helpers_allocateArrayFromCons(cons, array.length + 1);
+  setItem(res, 0, state);
+  for (let i = 0; i <= array.length - 1; i++) {
+    setItem(res, i + 1, folder(item(i, res), item(i, array)));
+  }
+  return res;
+}
+function scanBack(folder, array, state, cons) {
+  const res = Helpers_allocateArrayFromCons(cons, array.length + 1);
+  setItem(res, array.length, state);
+  for (let i = array.length - 1; i >= 0; i--) {
+    setItem(res, i, folder(item(i, array), item(i + 1, res)));
+  }
+  return res;
+}
+function skip(count, array, cons) {
+  if (count > array.length) {
+    throw new Exception("count is greater than array length (Parameter 'count')");
+  }
+  if (count === array.length) {
+    return 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(item(count, array))) {
+    count = count + 1 | 0;
+  }
+  if (count === array.length) {
+    return 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 Exception("The input must be non-negative (Parameter 'count')");
+  }
+  if (count > array.length) {
+    throw new Exception("count is greater than array length (Parameter 'count')");
+  }
+  if (count === 0) {
+    return Helpers_allocateArrayFromCons(cons, 0);
+  } else {
+    return array.slice(0, 0 + count);
+  }
+}
+function takeWhile(predicate, array, cons) {
+  let count = 0;
+  while (count < array.length && predicate(item(count, array))) {
+    count = count + 1 | 0;
+  }
+  if (count === 0) {
+    return 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 = getEnumerator(range);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      addInPlace(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), array);
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+function insertRangeInPlace(index, range, array) {
+  let i = index;
+  const enumerator = getEnumerator(range);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      let index_1 = void 0;
+      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 {
+    disposeSafe(enumerator);
+  }
+}
+function removeInPlace(item_1, array, eq) {
+  const i = indexOf(array, item_1, void 0, void 0, 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 = Helpers_allocateArrayFromCons(cons, len);
+  const res2 = Helpers_allocateArrayFromCons(cons, len);
+  let iTrue = 0;
+  let iFalse = 0;
+  for (let i = 0; i <= len - 1; i++) {
+    if (f(item(i, source))) {
+      setItem(res1, iTrue, item(i, source));
+      iTrue = iTrue + 1 | 0;
+    } else {
+      setItem(res2, iFalse, 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 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 void 0;
+  }
+}
+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(item(i, array));
+          if (matchValue != null) {
+            return 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 void 0;
+        } else {
+          const matchValue = chooser(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(item(i, array))) {
+          return 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 void 0;
+        } else if (predicate(item(i, array))) {
+          return some(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(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(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 void 0;
+        } else if (predicate(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(item(i, array));
+    if (matchValue != null) {
+      const y = 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(item(i, array));
+  }
+}
+function iterateIndexed(action, array) {
+  for (let i = 0; i <= array.length - 1; i++) {
+    action(i, item(i, array));
+  }
+}
+function iterate2(action, array1, array2) {
+  if (array1.length !== array2.length) {
+    differentLengths();
+  }
+  for (let i = 0; i <= array1.length - 1; i++) {
+    action(item(i, array1), 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, item(i, array1), 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 Exception("Not a valid permutation");
+    }
+    setItem(res, j, x);
+    setItem(checkFlags, j, 1);
+  }, array);
+  if (!checkFlags.every((y) => 1 === y)) {
+    throw new Exception("Not a valid permutation");
+  }
+  return res;
+}
+function setSlice(target, lower, upper, source) {
+  const lower_1 = defaultArg(lower, 0) | 0;
+  const upper_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++) {
+    setItem(target, i + lower_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++) {
+      setItem(res, i * len2 + j, [item(i, xs), 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 = value(matchValue)[0];
+          const s = 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) => {
+    setItem(res1, i, tupledArg[0]);
+    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) => {
+    setItem(res1, i, tupledArg[0]);
+    setItem(res2, i, tupledArg[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++) {
+    setItem(result, i, [item(i, array1), 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++) {
+    setItem(result, i, [item(i, array1), item(i, array2), item(i, array3)]);
+  }
+  return result;
+}
+function chunkBySize(chunkSize, array) {
+  if (chunkSize < 1) {
+    throw new Exception("The input must be positive. (Parameter '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 Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  return [array.slice(0, 0 + index), array.slice(index)];
+}
+function compareWith(comparer, source1, source2) {
+  if (Operators_IsNull(source1)) {
+    if (Operators_IsNull(source2)) {
+      return 0;
+    } else {
+      return -1;
+    }
+  } else if (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(item(i, source1), 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 (Operators_IsNull(source1)) {
+    if (Operators_IsNull(source2)) {
+      return 0;
+    } else {
+      return -1;
+    }
+  } else if (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(item(i, source1), item(i, source2)) | 0;
+        i = i + 1 | 0;
+      }
+      return res | 0;
+    }
+  }
+}
+function equalsWith(equals, source1, source2) {
+  if (Operators_IsNull(source1)) {
+    if (Operators_IsNull(source2)) {
+      return true;
+    } else {
+      return false;
+    }
+  } else if (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(item(i, source1), item(i, source2));
+        i = i + 1 | 0;
+      }
+      return result;
+    }
+  }
+}
+function exactlyOne(array) {
+  switch (array.length) {
+    case 1:
+      return item(0, array);
+    case 0:
+      throw new Exception("The input sequence was empty (Parameter 'array')");
+    default:
+      throw new Exception("Input array too long (Parameter 'array')");
+  }
+}
+function tryExactlyOne(array) {
+  if (array.length === 1) {
+    return some(item(0, array));
+  } else {
+    return void 0;
+  }
+}
+function head(array) {
+  if (array.length === 0) {
+    throw new Exception("The input array was empty (Parameter 'array')");
+  } else {
+    return item(0, array);
+  }
+}
+function tryHead(array) {
+  if (array.length === 0) {
+    return void 0;
+  } else {
+    return some(item(0, array));
+  }
+}
+function tail(array) {
+  if (array.length === 0) {
+    throw new Exception("Not enough elements (Parameter 'array')");
+  }
+  return array.slice(1);
+}
+function item(index, array) {
+  if (index < 0 ? true : index >= array.length) {
+    throw new Exception("Index was outside the bounds of the array. (Parameter 'index')");
+  } else {
+    return array[index];
+  }
+}
+function setItem(array, index, value) {
+  if (index < 0 ? true : index >= array.length) {
+    throw new Exception("Index was outside the bounds of the array. (Parameter 'index')");
+  } else {
+    array[index] = value;
+  }
+}
+function tryItem(index, array) {
+  if (index < 0 ? true : index >= array.length) {
+    return void 0;
+  } else {
+    return 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 Exception("Arrays have different lengths");
+  }
+  for (let i = 0; i <= array1.length - 1; i++) {
+    acc = folder(i, acc, item(i, array1), 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, item(size - i, array1), 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 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 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(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(item(index, array1), 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, 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(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 Exception("The input array was empty (Parameter 'array')");
+  }
+  let total = averager.GetZero();
+  for (let i = 0; i <= array.length - 1; i++) {
+    total = averager.Add(total, item(i, array));
+  }
+  return averager.DivideByInt(total, array.length);
+}
+function averageBy(projection, array, averager) {
+  if (array.length === 0) {
+    throw new Exception("The input array was empty (Parameter 'array')");
+  }
+  let total = averager.GetZero();
+  for (let i = 0; i <= array.length - 1; i++) {
+    total = averager.Add(total, projection(item(i, array)));
+  }
+  return averager.DivideByInt(total, array.length);
+}
+function windowed(windowSize, source) {
+  if (windowSize <= 0) {
+    throw new Exception("windowSize must be positive");
+  }
+  let res;
+  const len = max$1(0, source.length - windowSize + 1) | 0;
+  res = new Array(len);
+  for (let i = windowSize; i <= source.length; i++) {
+    setItem(res, i - windowSize, source.slice(i - windowSize, i - 1 + 1));
+  }
+  return res;
+}
+function splitInto(chunks, array) {
+  if (chunks < 1) {
+    throw new Exception("The input must be positive. (Parameter 'chunks')");
+  }
+  const result = [];
+  if (array.length > 0) {
+    const chunks_1 = min$1(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 + min$1(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 = 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++) {
+      setItem(result, i, Helpers_allocateArrayFromCons(cons, len));
+      for (let j = 0; j <= len - 1; j++) {
+        item(i, result)[j] = item(i, 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 Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  const target = Helpers_allocateArrayFromCons(cons, len + 1);
+  for (let i = 0; i <= index - 1; i++) {
+    setItem(target, i, item(i, xs));
+  }
+  setItem(target, index, y);
+  for (let i_1 = index; i_1 <= len - 1; i_1++) {
+    setItem(target, i_1 + 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 Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  const ys_1 = Array.from(ys);
+  const len2 = ys_1.length | 0;
+  const target = Helpers_allocateArrayFromCons(cons, len + len2);
+  for (let i = 0; i <= index - 1; i++) {
+    setItem(target, i, item(i, xs));
+  }
+  for (let i_1 = 0; i_1 <= len2 - 1; i_1++) {
+    setItem(target, index + i_1, item(i_1, ys_1));
+  }
+  for (let i_2 = index; i_2 <= len - 1; i_2++) {
+    setItem(target, i_2 + len2, item(i_2, xs));
+  }
+  return target;
+}
+function randomShuffleInPlaceBy(randomizer, xs) {
+  const len = xs.length | 0;
+  for (let i = len - 1; i >= 1; i--) {
+    const r = randomizer();
+    if (r < 0 ? true : r >= 1) {
+      throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter 'randomizer')");
+    }
+    const j = ~~(r * (i + 1)) | 0;
+    const tmp = item(i, xs);
+    setItem(xs, i, item(j, xs));
+    setItem(xs, j, tmp);
+  }
+}
+function randomShuffleInPlaceWith(random, xs) {
+  randomShuffleInPlaceBy(() => random.NextDouble(), xs);
+}
+function randomShuffleInPlace(xs) {
+  randomShuffleInPlaceWith(nonSeeded(), xs);
+}
+function randomShuffleBy(randomizer, xs) {
+  const arr = copy(xs);
+  randomShuffleInPlaceBy(randomizer, arr);
+  return arr;
+}
+function randomShuffleWith(random, xs) {
+  return randomShuffleBy(() => random.NextDouble(), xs);
+}
+function randomShuffle(xs) {
+  return randomShuffleWith(nonSeeded(), xs);
+}
+function randomChoiceBy(randomizer, xs) {
+  if (isEmpty(xs)) {
+    throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+  }
+  const len = xs.length | 0;
+  const r = randomizer();
+  if (r < 0 ? true : r >= 1) {
+    throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter 'randomizer')");
+  }
+  return item(~~(r * len), xs);
+}
+function randomChoiceWith(random, xs) {
+  return randomChoiceBy(() => random.NextDouble(), xs);
+}
+function randomChoice(xs) {
+  return randomChoiceWith(nonSeeded(), xs);
+}
+function randomChoicesBy(randomizer, count, xs, cons) {
+  if (count < 0) {
+    throw new Exception(SR_inputMustBeNonNegative + " (Parameter 'count')");
+  }
+  if (count > 0 && isEmpty(xs)) {
+    throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+  }
+  const len = xs.length | 0;
+  return initialize(count, (_arg) => {
+    const r = randomizer();
+    if (r < 0 ? true : r >= 1) {
+      throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter 'randomizer')");
+    }
+    return item(~~(r * len), xs);
+  }, cons);
+}
+function randomChoicesWith(random, count, xs, cons) {
+  return randomChoicesBy(() => random.NextDouble(), count, xs, cons);
+}
+function randomChoices(count, xs, cons) {
+  return randomChoicesWith(nonSeeded(), count, xs, cons);
+}
+function randomSampleBy(randomizer, count, xs) {
+  if (count < 0) {
+    throw new Exception(SR_inputMustBeNonNegative + " (Parameter 'count')");
+  }
+  const arr = copy(xs);
+  const len = arr.length | 0;
+  if (len === 0 && count > 0) {
+    throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+  }
+  if (count > len) {
+    throw new Exception(SR_notEnoughElements + " (Parameter 'count')");
+  }
+  for (let i = 0; i <= count - 1; i++) {
+    const r = randomizer();
+    if (r < 0 ? true : r >= 1) {
+      throw new Exception(SR_Arg_ArgumentOutOfRangeException + " (Parameter 'randomizer')");
+    }
+    const j = i + ~~(r * (len - i)) | 0;
+    const tmp = item(i, arr);
+    setItem(arr, i, item(j, arr));
+    setItem(arr, j, tmp);
+  }
+  return getSubArray(arr, 0, count);
+}
+function randomSampleWith(random, count, xs) {
+  return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+function randomSample(count, xs) {
+  return randomSampleWith(nonSeeded(), count, xs);
+}
+function removeAt(index, xs) {
+  if (index < 0 ? true : index >= xs.length) {
+    throw new Exception(SR_indexOutOfBounds + " (Parameter '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 Exception(SR_indexOutOfBounds + (" (Parameter '" + (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 Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  const target = Helpers_allocateArrayFromCons(cons, len);
+  for (let i = 0; i <= len - 1; i++) {
+    setItem(target, i, i === index ? y : item(i, xs));
+  }
+  return target;
+}
+function resize(xs, newSize, zero, cons) {
+  let array = void 0, array_1 = void 0, start_2 = void 0, count_2 = void 0;
+  if (newSize < 0) {
+    throw new Exception("The input must be non-negative. (Parameter 'newSize')");
+  }
+  const zero_1 = defaultArg(zero, defaultOf());
+  if (Operators_IsNull(xs.contents)) {
+    xs.contents = (array = 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 = 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));
+    }
+  }
+}
+
+export { addInPlace, addRangeInPlace, allPairs, append, average, averageBy, choose, chunkBySize, collect, compareTo, compareWith, concat, contains, copy, copyTo, empty, equalsWith, exactlyOne, exists, exists2, existsOffset, existsOffset2, fill, filter, find, findAll, findBack, findIndex, findIndexBack, findLastIndex, fold, fold2, foldBack, foldBack2, foldBackIndexed, foldBackIndexed2, foldIndexed, foldIndexed2, forAll, forAll2, getRange, getSubArray, head, indexOf, indexed, initialize, insertAt, insertManyAt, insertRangeInPlace, isEmpty, item, iterate, iterate2, iterateIndexed, iterateIndexed2, last, map, map2, map3, mapFold, mapFoldBack, mapIndexed, mapIndexed2, mapIndexed3, max, maxBy, min, minBy, pairwise, partition, permute, pick, randomChoice, randomChoiceBy, randomChoiceWith, randomChoices, randomChoicesBy, randomChoicesWith, randomSample, randomSampleBy, randomSampleWith, randomShuffle, randomShuffleBy, randomShuffleInPlace, randomShuffleInPlaceBy, randomShuffleInPlaceWith, randomShuffleWith, reduce, reduceBack, removeAllInPlace, removeAt, removeInPlace, removeManyAt, replicate, resize, reverse, scan, scanBack, setItem, setSlice, singleton, skip, skipWhile, sort, sortBy, sortByDescending, sortDescending, sortInPlace, sortInPlaceBy, sortWith, splitAt, splitInto, sum, sumBy, tail, take, takeWhile, transpose, truncate, tryExactlyOne, tryFind, tryFindBack, tryFindIndex, tryFindIndexBack, tryHead, tryItem, tryLast, tryPick, unfold, unzip, unzip3, updateAt, where, windowed, zip, zip3 };