@mobily/ts-belt/dist/esm/Array/index.js

🔧 Fast, modern, and practical utility library for FP in TypeScript.

// node_modules/rescript/lib/es6/caml_option.js
function some(x) {
  if (x === void 0) {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: 0
    };
  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
    };
  } else {
    return x;
  }
}
function valFromOption(x) {
  if (!(x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0)) {
    return x;
  }
  var depth = x.BS_PRIVATE_NESTED_SOME_NONE;
  if (depth === 0) {
    return;
  } else {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
    };
  }
}

// node_modules/rescript/lib/es6/js_dict.js
function get(dict, k) {
  if (k in dict) {
    return some(dict[k]);
  }
}

// node_modules/rescript/lib/es6/caml.js
function caml_int_compare(x, y) {
  if (x < y) {
    return -1;
  } else if (x === y) {
    return 0;
  } else {
    return 1;
  }
}
function caml_bool_compare(x, y) {
  if (x) {
    if (y) {
      return 0;
    } else {
      return 1;
    }
  } else if (y) {
    return -1;
  } else {
    return 0;
  }
}
function caml_string_compare(s1, s2) {
  if (s1 === s2) {
    return 0;
  } else if (s1 < s2) {
    return -1;
  } else {
    return 1;
  }
}
function caml_int_max(x, y) {
  if (x > y) {
    return x;
  } else {
    return y;
  }
}

// node_modules/rescript/lib/es6/caml_obj.js
var for_in = function(o, foo) {
  for (var x in o) {
    foo(x);
  }
};
function caml_compare(a, b) {
  if (a === b) {
    return 0;
  }
  var a_type = typeof a;
  var b_type = typeof b;
  switch (a_type) {
    case "boolean":
      if (b_type === "boolean") {
        return caml_bool_compare(a, b);
      }
      break;
    case "function":
      if (b_type === "function") {
        throw {
          RE_EXN_ID: "Invalid_argument",
          _1: "compare: functional value",
          Error: new Error()
        };
      }
      break;
    case "number":
      if (b_type === "number") {
        return caml_int_compare(a, b);
      }
      break;
    case "string":
      if (b_type === "string") {
        return caml_string_compare(a, b);
      } else {
        return 1;
      }
    case "undefined":
      return -1;
    default:
  }
  switch (b_type) {
    case "string":
      return -1;
    case "undefined":
      return 1;
    default:
      if (a_type === "boolean") {
        return 1;
      }
      if (b_type === "boolean") {
        return -1;
      }
      if (a_type === "function") {
        return 1;
      }
      if (b_type === "function") {
        return -1;
      }
      if (a_type === "number") {
        if (b === null || b.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
          return 1;
        } else {
          return -1;
        }
      }
      if (b_type === "number") {
        if (a === null || a.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
          return -1;
        } else {
          return 1;
        }
      }
      if (a === null) {
        if (b.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
          return 1;
        } else {
          return -1;
        }
      }
      if (b === null) {
        if (a.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
          return -1;
        } else {
          return 1;
        }
      }
      if (a.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
        if (b.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
          return aux_obj_compare(a, b);
        } else {
          return -1;
        }
      }
      var tag_a = a.TAG | 0;
      var tag_b = b.TAG | 0;
      if (tag_a === 248) {
        return caml_int_compare(a[1], b[1]);
      }
      if (tag_a === 251) {
        throw {
          RE_EXN_ID: "Invalid_argument",
          _1: "equal: abstract value",
          Error: new Error()
        };
      }
      if (tag_a !== tag_b) {
        if (tag_a < tag_b) {
          return -1;
        } else {
          return 1;
        }
      }
      var len_a = a.length | 0;
      var len_b = b.length | 0;
      if (len_a === len_b) {
        if (Array.isArray(a)) {
          var _i = 0;
          while (true) {
            var i = _i;
            if (i === len_a) {
              return 0;
            }
            var res = caml_compare(a[i], b[i]);
            if (res !== 0) {
              return res;
            }
            _i = i + 1 | 0;
            continue;
          }
          ;
        } else if (a instanceof Date && b instanceof Date) {
          return a - b;
        } else {
          return aux_obj_compare(a, b);
        }
      } else if (len_a < len_b) {
        var _i$1 = 0;
        while (true) {
          var i$1 = _i$1;
          if (i$1 === len_a) {
            return -1;
          }
          var res$1 = caml_compare(a[i$1], b[i$1]);
          if (res$1 !== 0) {
            return res$1;
          }
          _i$1 = i$1 + 1 | 0;
          continue;
        }
        ;
      } else {
        var _i$2 = 0;
        while (true) {
          var i$2 = _i$2;
          if (i$2 === len_b) {
            return 1;
          }
          var res$2 = caml_compare(a[i$2], b[i$2]);
          if (res$2 !== 0) {
            return res$2;
          }
          _i$2 = i$2 + 1 | 0;
          continue;
        }
        ;
      }
  }
}
function aux_obj_compare(a, b) {
  var min_key_lhs = {
    contents: void 0
  };
  var min_key_rhs = {
    contents: void 0
  };
  var do_key = function(param, key) {
    var min_key = param[2];
    var b2 = param[1];
    if (!(!Object.prototype.hasOwnProperty.call(b2, key) || caml_compare(param[0][key], b2[key]) > 0)) {
      return;
    }
    var mk = min_key.contents;
    if (mk !== void 0 && key >= mk) {
      return;
    } else {
      min_key.contents = key;
      return;
    }
  };
  var partial_arg = [
    a,
    b,
    min_key_rhs
  ];
  var do_key_a = function(param) {
    return do_key(partial_arg, param);
  };
  var partial_arg$1 = [
    b,
    a,
    min_key_lhs
  ];
  var do_key_b = function(param) {
    return do_key(partial_arg$1, param);
  };
  for_in(a, do_key_a);
  for_in(b, do_key_b);
  var match = min_key_lhs.contents;
  var match$1 = min_key_rhs.contents;
  if (match !== void 0) {
    if (match$1 !== void 0) {
      return caml_string_compare(match, match$1);
    } else {
      return -1;
    }
  } else if (match$1 !== void 0) {
    return 1;
  } else {
    return 0;
  }
}
function caml_equal(a, b) {
  if (a === b) {
    return true;
  }
  var a_type = typeof a;
  if (a_type === "string" || a_type === "number" || a_type === "boolean" || a_type === "undefined" || a === null) {
    return false;
  }
  var b_type = typeof b;
  if (a_type === "function" || b_type === "function") {
    throw {
      RE_EXN_ID: "Invalid_argument",
      _1: "equal: functional value",
      Error: new Error()
    };
  }
  if (b_type === "number" || b_type === "undefined" || b === null) {
    return false;
  }
  var tag_a = a.TAG | 0;
  var tag_b = b.TAG | 0;
  if (tag_a === 248) {
    return a[1] === b[1];
  }
  if (tag_a === 251) {
    throw {
      RE_EXN_ID: "Invalid_argument",
      _1: "equal: abstract value",
      Error: new Error()
    };
  }
  if (tag_a !== tag_b) {
    return false;
  }
  var len_a = a.length | 0;
  var len_b = b.length | 0;
  if (len_a === len_b) {
    if (Array.isArray(a)) {
      var _i = 0;
      while (true) {
        var i = _i;
        if (i === len_a) {
          return true;
        }
        if (!caml_equal(a[i], b[i])) {
          return false;
        }
        _i = i + 1 | 0;
        continue;
      }
      ;
    } else if (a instanceof Date && b instanceof Date) {
      return !(a > b || a < b);
    } else {
      var result = {
        contents: true
      };
      var do_key_a = function(key) {
        if (!Object.prototype.hasOwnProperty.call(b, key)) {
          result.contents = false;
          return;
        }
      };
      var do_key_b = function(key) {
        if (!Object.prototype.hasOwnProperty.call(a, key) || !caml_equal(b[key], a[key])) {
          result.contents = false;
          return;
        }
      };
      for_in(a, do_key_a);
      if (result.contents) {
        for_in(b, do_key_b);
      }
      return result.contents;
    }
  } else {
    return false;
  }
}
function caml_lessthan(a, b) {
  return caml_compare(a, b) < 0;
}

// node_modules/rescript/lib/es6/js_int.js
var max = 2147483647;
var min = -2147483648;

// node_modules/rescript/lib/es6/js_math.js
function floor_int(f) {
  if (f > max) {
    return max;
  } else if (f < min) {
    return min;
  } else {
    return Math.floor(f);
  }
}
function random_int(min2, max2) {
  return floor_int(Math.random() * (max2 - min2 | 0)) + min2 | 0;
}

// node_modules/rescript/lib/es6/belt_Array.js
function get2(arr, i) {
  if (i >= 0 && i < arr.length) {
    return some(arr[i]);
  }
}
function getExn(arr, i) {
  if (!(i >= 0 && i < arr.length)) {
    throw {
      RE_EXN_ID: "Assert_failure",
      _1: [
        "belt_Array.ml",
        27,
        4
      ],
      Error: new Error()
    };
  }
  return arr[i];
}
function swapUnsafe(xs, i, j) {
  var tmp = xs[i];
  xs[i] = xs[j];
  xs[j] = tmp;
}
function shuffleInPlace(xs) {
  var len = xs.length;
  for (var i = 0; i < len; ++i) {
    swapUnsafe(xs, i, random_int(i, len));
  }
}
function shuffle(xs) {
  var result = xs.slice(0);
  shuffleInPlace(result);
  return result;
}
function reverse(xs) {
  var len = xs.length;
  var result = new Array(len);
  for (var i = 0; i < len; ++i) {
    result[i] = xs[(len - 1 | 0) - i | 0];
  }
  return result;
}
function make(l, f) {
  if (l <= 0) {
    return [];
  }
  var res = new Array(l);
  for (var i = 0; i < l; ++i) {
    res[i] = f;
  }
  return res;
}
function makeByU(l, f) {
  if (l <= 0) {
    return [];
  }
  var res = new Array(l);
  for (var i = 0; i < l; ++i) {
    res[i] = f(i);
  }
  return res;
}
function range(start, finish) {
  var cut = finish - start | 0;
  if (cut < 0) {
    return [];
  }
  var arr = new Array(cut + 1 | 0);
  for (var i = 0; i <= cut; ++i) {
    arr[i] = start + i | 0;
  }
  return arr;
}
function rangeBy(start, finish, step) {
  var cut = finish - start | 0;
  if (cut < 0 || step <= 0) {
    return [];
  }
  var nb = (cut / step | 0) + 1 | 0;
  var arr = new Array(nb);
  var cur = start;
  for (var i = 0; i < nb; ++i) {
    arr[i] = cur;
    cur = cur + step | 0;
  }
  return arr;
}
function zip(xs, ys) {
  var lenx = xs.length;
  var leny = ys.length;
  var len = lenx < leny ? lenx : leny;
  var s = new Array(len);
  for (var i = 0; i < len; ++i) {
    s[i] = [
      xs[i],
      ys[i]
    ];
  }
  return s;
}
function zipByU(xs, ys, f) {
  var lenx = xs.length;
  var leny = ys.length;
  var len = lenx < leny ? lenx : leny;
  var s = new Array(len);
  for (var i = 0; i < len; ++i) {
    s[i] = f(xs[i], ys[i]);
  }
  return s;
}
function concat(a1, a2) {
  var l1 = a1.length;
  var l2 = a2.length;
  var a1a2 = new Array(l1 + l2 | 0);
  for (var i = 0; i < l1; ++i) {
    a1a2[i] = a1[i];
  }
  for (var i$1 = 0; i$1 < l2; ++i$1) {
    a1a2[l1 + i$1 | 0] = a2[i$1];
  }
  return a1a2;
}
function concatMany(arrs) {
  var lenArrs = arrs.length;
  var totalLen = 0;
  for (var i = 0; i < lenArrs; ++i) {
    totalLen = totalLen + arrs[i].length | 0;
  }
  var result = new Array(totalLen);
  totalLen = 0;
  for (var j = 0; j < lenArrs; ++j) {
    var cur = arrs[j];
    for (var k = 0, k_finish = cur.length; k < k_finish; ++k) {
      result[totalLen] = cur[k];
      totalLen = totalLen + 1 | 0;
    }
  }
  return result;
}
function slice(a, offset, len) {
  if (len <= 0) {
    return [];
  }
  var lena = a.length;
  var ofs = offset < 0 ? caml_int_max(lena + offset | 0, 0) : offset;
  var hasLen = lena - ofs | 0;
  var copyLength = hasLen < len ? hasLen : len;
  if (copyLength <= 0) {
    return [];
  }
  var result = new Array(copyLength);
  for (var i = 0; i < copyLength; ++i) {
    result[i] = a[ofs + i | 0];
  }
  return result;
}
function sliceToEnd(a, offset) {
  var lena = a.length;
  var ofs = offset < 0 ? caml_int_max(lena + offset | 0, 0) : offset;
  var len = lena - ofs | 0;
  var result = new Array(len);
  for (var i = 0; i < len; ++i) {
    result[i] = a[ofs + i | 0];
  }
  return result;
}
function blitUnsafe(a1, srcofs1, a2, srcofs2, blitLength) {
  if (srcofs2 <= srcofs1) {
    for (var j = 0; j < blitLength; ++j) {
      a2[j + srcofs2 | 0] = a1[j + srcofs1 | 0];
    }
    return;
  }
  for (var j$1 = blitLength - 1 | 0; j$1 >= 0; --j$1) {
    a2[j$1 + srcofs2 | 0] = a1[j$1 + srcofs1 | 0];
  }
}
function forEachU(a, f) {
  for (var i = 0, i_finish = a.length; i < i_finish; ++i) {
    f(a[i]);
  }
}
function mapU(a, f) {
  var l = a.length;
  var r = new Array(l);
  for (var i = 0; i < l; ++i) {
    r[i] = f(a[i]);
  }
  return r;
}
function getByU(a, p) {
  var l = a.length;
  var i = 0;
  var r;
  while (r === void 0 && i < l) {
    var v = a[i];
    if (p(v)) {
      r = some(v);
    }
    i = i + 1 | 0;
  }
  ;
  return r;
}
function getIndexByU(a, p) {
  var l = a.length;
  var i = 0;
  var r;
  while (r === void 0 && i < l) {
    var v = a[i];
    if (p(v)) {
      r = i;
    }
    i = i + 1 | 0;
  }
  ;
  return r;
}
function keepMapU(a, f) {
  var l = a.length;
  var r = new Array(l);
  var j = 0;
  for (var i = 0; i < l; ++i) {
    var v = a[i];
    var v$1 = f(v);
    if (v$1 !== void 0) {
      r[j] = valFromOption(v$1);
      j = j + 1 | 0;
    }
  }
  r.length = j;
  return r;
}
function forEachWithIndexU(a, f) {
  for (var i = 0, i_finish = a.length; i < i_finish; ++i) {
    f(i, a[i]);
  }
}
function mapWithIndexU(a, f) {
  var l = a.length;
  var r = new Array(l);
  for (var i = 0; i < l; ++i) {
    r[i] = f(i, a[i]);
  }
  return r;
}
function reduceU(a, x, f) {
  var r = x;
  for (var i = 0, i_finish = a.length; i < i_finish; ++i) {
    r = f(r, a[i]);
  }
  return r;
}
function reduceReverseU(a, x, f) {
  var r = x;
  for (var i = a.length - 1 | 0; i >= 0; --i) {
    r = f(r, a[i]);
  }
  return r;
}
function reduceWithIndexU(a, x, f) {
  var r = x;
  for (var i = 0, i_finish = a.length; i < i_finish; ++i) {
    r = f(r, a[i], i);
  }
  return r;
}
function everyU(arr, b) {
  var len = arr.length;
  var _i = 0;
  while (true) {
    var i = _i;
    if (i === len) {
      return true;
    }
    if (!b(arr[i])) {
      return false;
    }
    _i = i + 1 | 0;
    continue;
  }
  ;
}
function someU(arr, b) {
  var len = arr.length;
  var _i = 0;
  while (true) {
    var i = _i;
    if (i === len) {
      return false;
    }
    if (b(arr[i])) {
      return true;
    }
    _i = i + 1 | 0;
    continue;
  }
  ;
}
function everyAux2(arr1, arr2, _i, b, len) {
  while (true) {
    var i = _i;
    if (i === len) {
      return true;
    }
    if (!b(arr1[i], arr2[i])) {
      return false;
    }
    _i = i + 1 | 0;
    continue;
  }
  ;
}
function eqU(a, b, p) {
  var lena = a.length;
  var lenb = b.length;
  if (lena === lenb) {
    return everyAux2(a, b, 0, p, lena);
  } else {
    return false;
  }
}
function partitionU(a, f) {
  var l = a.length;
  var i = 0;
  var j = 0;
  var a1 = new Array(l);
  var a2 = new Array(l);
  for (var ii = 0; ii < l; ++ii) {
    var v = a[ii];
    if (f(v)) {
      a1[i] = v;
      i = i + 1 | 0;
    } else {
      a2[j] = v;
      j = j + 1 | 0;
    }
  }
  a1.length = i;
  a2.length = j;
  return [
    a1,
    a2
  ];
}
function unzip(a) {
  var l = a.length;
  var a1 = new Array(l);
  var a2 = new Array(l);
  for (var i = 0; i < l; ++i) {
    var match = a[i];
    a1[i] = match[0];
    a2[i] = match[1];
  }
  return [
    a1,
    a2
  ];
}

// node_modules/rescript/lib/es6/belt_SortArray.js
function merge(src, src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs, cmp) {
  var src1r = src1ofs + src1len | 0;
  var src2r = src2ofs + src2len | 0;
  var _i1 = src1ofs;
  var _s1 = src[src1ofs];
  var _i2 = src2ofs;
  var _s2 = src2[src2ofs];
  var _d = dstofs;
  while (true) {
    var d = _d;
    var s2 = _s2;
    var i2 = _i2;
    var s1 = _s1;
    var i1 = _i1;
    if (cmp(s1, s2) <= 0) {
      dst[d] = s1;
      var i1$1 = i1 + 1 | 0;
      if (i1$1 >= src1r) {
        return blitUnsafe(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
      }
      _d = d + 1 | 0;
      _s1 = src[i1$1];
      _i1 = i1$1;
      continue;
    }
    dst[d] = s2;
    var i2$1 = i2 + 1 | 0;
    if (i2$1 >= src2r) {
      return blitUnsafe(src, i1, dst, d + 1 | 0, src1r - i1 | 0);
    }
    _d = d + 1 | 0;
    _s2 = src2[i2$1];
    _i2 = i2$1;
    continue;
  }
  ;
}
function insertionSort(src, srcofs, dst, dstofs, len, cmp) {
  for (var i = 0; i < len; ++i) {
    var e = src[srcofs + i | 0];
    var j = (dstofs + i | 0) - 1 | 0;
    while (j >= dstofs && cmp(dst[j], e) > 0) {
      dst[j + 1 | 0] = dst[j];
      j = j - 1 | 0;
    }
    ;
    dst[j + 1 | 0] = e;
  }
}
function sortTo(src, srcofs, dst, dstofs, len, cmp) {
  if (len <= 5) {
    return insertionSort(src, srcofs, dst, dstofs, len, cmp);
  }
  var l1 = len / 2 | 0;
  var l2 = len - l1 | 0;
  sortTo(src, srcofs + l1 | 0, dst, dstofs + l1 | 0, l2, cmp);
  sortTo(src, srcofs, src, srcofs + l2 | 0, l1, cmp);
  return merge(src, srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs, cmp);
}
function stableSortInPlaceByU(a, cmp) {
  var l = a.length;
  if (l <= 5) {
    return insertionSort(a, 0, a, 0, l, cmp);
  }
  var l1 = l / 2 | 0;
  var l2 = l - l1 | 0;
  var t = new Array(l2);
  sortTo(a, l1, t, 0, l2, cmp);
  sortTo(a, 0, a, l2, l1, cmp);
  return merge(a, l2, l1, t, 0, l2, a, 0, cmp);
}
function stableSortByU(a, cmp) {
  var b = a.slice(0);
  stableSortInPlaceByU(b, cmp);
  return b;
}

// src/Array/Array.bs.js
function placeholder(param) {
}
function makeEmpty(param) {
  return [];
}
var _makeWithIndex = makeByU;
function makeWithIndex() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _makeWithIndex(data, args[0]);
    };
  }
  return _makeWithIndex(arguments[0], arguments[1]);
}
var _make = make;
function make2() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _make(data, args[0]);
    };
  }
  return _make(arguments[0], arguments[1]);
}
var _repeat = make;
function repeat() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _repeat(data, args[0]);
    };
  }
  return _repeat(arguments[0], arguments[1]);
}
function length(xs) {
  return xs.length;
}
function isEmpty(xs) {
  return xs.length === 0;
}
function isNotEmpty(xs) {
  return xs.length !== 0;
}
var reverse2 = reverse;
function _append(xs, element) {
  return concat(xs, [element]);
}
function append() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _append(data, args[0]);
    };
  }
  return _append(arguments[0], arguments[1]);
}
function _prepend(xs, element) {
  return concat([element], xs);
}
function prepend() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _prepend(data, args[0]);
    };
  }
  return _prepend(arguments[0], arguments[1]);
}
function _prependToAll(xs, delimiter) {
  return reduceU(xs, [], function(acc, value) {
    return concat(acc, [
      delimiter,
      value
    ]);
  });
}
function prependToAll() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _prependToAll(data, args[0]);
    };
  }
  return _prependToAll(arguments[0], arguments[1]);
}
function _intersperse(xs, delimiter) {
  return reduceWithIndexU(xs, [], function(acc, value, index) {
    if ((xs.length - 1 | 0) === index) {
      acc.push(value);
    } else {
      acc.push(value, delimiter);
    }
    return acc;
  });
}
function intersperse() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _intersperse(data, args[0]);
    };
  }
  return _intersperse(arguments[0], arguments[1]);
}
var _get = get2;
function get3() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _get(data, args[0]);
    };
  }
  return _get(arguments[0], arguments[1]);
}
var _at = get2;
function at() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _at(data, args[0]);
    };
  }
  return _at(arguments[0], arguments[1]);
}
function _getUnsafe(xs, index) {
  return xs[index];
}
function getUnsafe() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _getUnsafe(data, args[0]);
    };
  }
  return _getUnsafe(arguments[0], arguments[1]);
}
function _getUndefined(xs, index) {
  return xs[index];
}
function getUndefined() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _getUndefined(data, args[0]);
    };
  }
  return _getUndefined(arguments[0], arguments[1]);
}
var _getBy = getByU;
function getBy() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _getBy(data, args[0]);
    };
  }
  return _getBy(arguments[0], arguments[1]);
}
var _find = getByU;
function find() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _find(data, args[0]);
    };
  }
  return _find(arguments[0], arguments[1]);
}
function head(xs) {
  return get2(xs, 0);
}
function last(xs) {
  var l = xs.length;
  if (l === 0) {
    return;
  } else {
    return get2(xs, l - 1 | 0);
  }
}
function tail(xs) {
  var l = xs.length;
  if (l === 1) {
    return [];
  }
  if (l === 0) {
    return;
  }
  var xs$1 = sliceToEnd(xs, 1);
  if (xs$1.length !== 0) {
    return xs$1;
  }
}
function tailOrEmpty(xs) {
  var xs$1 = tail(xs);
  if (xs$1 !== void 0) {
    return xs$1;
  } else {
    return [];
  }
}
function init(xs) {
  var l = xs.length;
  if (l === 0) {
    return;
  } else {
    return slice(xs, 0, l - 1 | 0);
  }
}
function initOrEmpty(xs) {
  var xs$1 = init(xs);
  if (xs$1 !== void 0) {
    return xs$1;
  } else {
    return [];
  }
}
function _take(xs, n) {
  var l = xs.length;
  var len = n < 0 ? 0 : l < n ? l : n;
  return slice(xs, 0, len);
}
function take() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _take(data, args[0]);
    };
  }
  return _take(arguments[0], arguments[1]);
}
function _takeExactly(xs, n) {
  if (n < 0 || n > xs.length) {
    return;
  } else {
    return slice(xs, 0, n);
  }
}
function takeExactly() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _takeExactly(data, args[0]);
    };
  }
  return _takeExactly(arguments[0], arguments[1]);
}
function _takeWhile(xs, predicateFn) {
  return reduceU(xs, [], function(acc, element) {
    if (predicateFn(element)) {
      acc.push(element);
    }
    return acc;
  });
}
function takeWhile() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _takeWhile(data, args[0]);
    };
  }
  return _takeWhile(arguments[0], arguments[1]);
}
function _drop(xs, n) {
  var l = xs.length;
  var start = n < 0 ? 0 : l < n ? l : n;
  return sliceToEnd(xs, start);
}
function drop() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _drop(data, args[0]);
    };
  }
  return _drop(arguments[0], arguments[1]);
}
function _dropExactly(xs, n) {
  if (n < 0 || n > xs.length) {
    return;
  } else {
    return sliceToEnd(xs, n);
  }
}
function dropExactly() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _dropExactly(data, args[0]);
    };
  }
  return _dropExactly(arguments[0], arguments[1]);
}
function _dropWhile(xs, predicateFn) {
  return reduceU(xs, [], function(acc, element) {
    if (!predicateFn(element)) {
      acc.push(element);
    }
    return acc;
  });
}
function dropWhile() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _dropWhile(data, args[0]);
    };
  }
  return _dropWhile(arguments[0], arguments[1]);
}
function uncons(xs) {
  if (xs.length !== 0) {
    return [
      getExn(xs, 0),
      sliceToEnd(xs, 1)
    ];
  }
}
function _map(xs, mapFn) {
  return mapU(xs, mapFn);
}
function map() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _map(data, args[0]);
    };
  }
  return _map(arguments[0], arguments[1]);
}
var _mapWithIndex = mapWithIndexU;
function mapWithIndex() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _mapWithIndex(data, args[0]);
    };
  }
  return _mapWithIndex(arguments[0], arguments[1]);
}
function _filter(xs, predicateFn) {
  var index = 0;
  var arr = [];
  while (index < xs.length) {
    var value = xs[index];
    if (predicateFn(value)) {
      arr.push(value);
    }
    index = index + 1 | 0;
  }
  ;
  return arr;
}
function filter() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _filter(data, args[0]);
    };
  }
  return _filter(arguments[0], arguments[1]);
}
var keep = filter;
function _filterWithIndex(xs, predicateFn) {
  var index = 0;
  var arr = [];
  while (index < xs.length) {
    var value = xs[index];
    if (predicateFn(index, value)) {
      arr.push(value);
    }
    index = index + 1 | 0;
  }
  ;
  return arr;
}
function filterWithIndex() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _filterWithIndex(data, args[0]);
    };
  }
  return _filterWithIndex(arguments[0], arguments[1]);
}
var keepWithIndex = filterWithIndex;
function _reject(xs, predicateFn) {
  return filter(xs, function(el) {
    return !predicateFn(el);
  });
}
function reject() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _reject(data, args[0]);
    };
  }
  return _reject(arguments[0], arguments[1]);
}
function _rejectWithIndex(xs, predicateFn) {
  return filterWithIndex(xs, function(index, el) {
    return !predicateFn(index, el);
  });
}
function rejectWithIndex() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _rejectWithIndex(data, args[0]);
    };
  }
  return _rejectWithIndex(arguments[0], arguments[1]);
}
var _reduce = reduceU;
function reduce() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _reduce(data, args[0], args[1]);
    };
  }
  return _reduce(arguments[0], arguments[1], arguments[2]);
}
var _reduceReverse = reduceReverseU;
function reduceReverse() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _reduceReverse(data, args[0], args[1]);
    };
  }
  return _reduceReverse(arguments[0], arguments[1], arguments[2]);
}
var _reduceWithIndex = reduceWithIndexU;
function reduceWithIndex() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _reduceWithIndex(data, args[0], args[1]);
    };
  }
  return _reduceWithIndex(arguments[0], arguments[1], arguments[2]);
}
function _splitAt(xs, offset) {
  if (offset < 0 || offset > xs.length) {
    return;
  } else {
    return [
      slice(xs, 0, offset),
      sliceToEnd(xs, offset)
    ];
  }
}
function splitAt() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _splitAt(data, args[0]);
    };
  }
  return _splitAt(arguments[0], arguments[1]);
}
function _splitEvery(xs, size) {
  if (size < 1 || xs.length <= size) {
    return [xs];
  }
  var offset = 0;
  var arr = [];
  while (offset < xs.length) {
    var len = offset + size | 0;
    arr.push(slice(xs, offset, size));
    offset = len;
  }
  ;
  return arr;
}
function splitEvery() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _splitEvery(data, args[0]);
    };
  }
  return _splitEvery(arguments[0], arguments[1]);
}
var shuffle2 = shuffle;
var _partition = partitionU;
function partition() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _partition(data, args[0]);
    };
  }
  return _partition(arguments[0], arguments[1]);
}
var _concat = concat;
function concat2() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _concat(data, args[0]);
    };
  }
  return _concat(arguments[0], arguments[1]);
}
var concatMany2 = concatMany;
var _every = everyU;
function every() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _every(data, args[0]);
    };
  }
  return _every(arguments[0], arguments[1]);
}
var _some = someU;
function some2() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _some(data, args[0]);
    };
  }
  return _some(arguments[0], arguments[1]);
}
var _slice = slice;
function slice2() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _slice(data, args[0], args[1]);
    };
  }
  return _slice(arguments[0], arguments[1], arguments[2]);
}
var _sliceToEnd = sliceToEnd;
function sliceToEnd2() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _sliceToEnd(data, args[0]);
    };
  }
  return _sliceToEnd(arguments[0], arguments[1]);
}
var _eq = eqU;
function eq() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _eq(data, args[0], args[1]);
    };
  }
  return _eq(arguments[0], arguments[1], arguments[2]);
}
var _range = range;
function range2() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _range(data, args[0]);
    };
  }
  return _range(arguments[0], arguments[1]);
}
var _rangeBy = rangeBy;
function rangeBy2() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _rangeBy(data, args[0], args[1]);
    };
  }
  return _rangeBy(arguments[0], arguments[1], arguments[2]);
}
function copy(xs) {
  return xs.slice(0);
}
var _zip = zip;
function zip2() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _zip(data, args[0]);
    };
  }
  return _zip(arguments[0], arguments[1]);
}
var _zipWith = zipByU;
function zipWith() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _zipWith(data, args[0], args[1]);
    };
  }
  return _zipWith(arguments[0], arguments[1], arguments[2]);
}
var unzip2 = unzip;
function _replaceAt(xs, targetIndex, element) {
  return mapWithIndexU(xs, function(currentIndex, current) {
    if (currentIndex === targetIndex) {
      return element;
    } else {
      return current;
    }
  });
}
function replaceAt() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _replaceAt(data, args[0], args[1]);
    };
  }
  return _replaceAt(arguments[0], arguments[1], arguments[2]);
}
function _insertAt(xs, targetIndex, element) {
  var match = splitAt(xs, targetIndex);
  if (match !== void 0) {
    return concat(match[0], concat([element], match[1]));
  } else {
    return xs;
  }
}
function insertAt() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _insertAt(data, args[0], args[1]);
    };
  }
  return _insertAt(arguments[0], arguments[1], arguments[2]);
}
function _updateAt(xs, targetIndex, fn) {
  return mapWithIndexU(xs, function(index, el) {
    if (index === targetIndex) {
      return fn(el);
    } else {
      return el;
    }
  });
}
function updateAt() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _updateAt(data, args[0], args[1]);
    };
  }
  return _updateAt(arguments[0], arguments[1], arguments[2]);
}
function _swapAt(xs, targetIndex, swapIndex) {
  var match = get2(xs, targetIndex);
  var match$1 = get2(xs, swapIndex);
  if (match === void 0) {
    return xs;
  }
  if (match$1 === void 0) {
    return xs;
  }
  var b = valFromOption(match$1);
  var a = valFromOption(match);
  return mapWithIndexU(xs, function(k, x) {
    if (targetIndex === k) {
      return b;
    } else if (swapIndex === k) {
      return a;
    } else {
      return x;
    }
  });
}
function swapAt() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _swapAt(data, args[0], args[1]);
    };
  }
  return _swapAt(arguments[0], arguments[1], arguments[2]);
}
function _removeAt(xs, targetIndex) {
  return filterWithIndex(xs, function(index, param) {
    return index !== targetIndex;
  });
}
function removeAt() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _removeAt(data, args[0]);
    };
  }
  return _removeAt(arguments[0], arguments[1]);
}
function _uniqBy(xs, uniqFn) {
  var index = 0;
  var arr = [];
  while (index < xs.length) {
    var value = xs[index];
    var alreadyAdded = someU(arr, function(value2) {
      return function(x) {
        return caml_equal(uniqFn(x), uniqFn(value2));
      };
    }(value));
    if (!alreadyAdded) {
      arr.push(value);
    }
    index = index + 1 | 0;
  }
  ;
  return arr;
}
function uniqBy() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _uniqBy(data, args[0]);
    };
  }
  return _uniqBy(arguments[0], arguments[1]);
}
function uniq(xs) {
  return uniqBy(xs, function(element) {
    return element;
  });
}
var _forEach = forEachU;
function forEach() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _forEach(data, args[0]);
    };
  }
  return _forEach(arguments[0], arguments[1]);
}
var _forEachWithIndex = forEachWithIndexU;
function forEachWithIndex() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _forEachWithIndex(data, args[0]);
    };
  }
  return _forEachWithIndex(arguments[0], arguments[1]);
}
var _getIndexBy = getIndexByU;
function getIndexBy() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _getIndexBy(data, args[0]);
    };
  }
  return _getIndexBy(arguments[0], arguments[1]);
}
function _includes(xs, value) {
  return someU(xs, function(x) {
    return caml_equal(x, value);
  });
}
function includes() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _includes(data, args[0]);
    };
  }
  return _includes(arguments[0], arguments[1]);
}
function _join(xs, delimiter) {
  return xs.join(delimiter);
}
function join() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _join(data, args[0]);
    };
  }
  return _join(arguments[0], arguments[1]);
}
var _sort = stableSortByU;
function sort() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _sort(data, args[0]);
    };
  }
  return _sort(arguments[0], arguments[1]);
}
function _sortBy(xs, sortFn) {
  return stableSortByU(xs, function(a, b) {
    var a$1 = sortFn(a);
    var b$1 = sortFn(b);
    if (a$1 === b$1) {
      return 0;
    } else if (caml_lessthan(a$1, b$1)) {
      return -1;
    } else {
      return 1;
    }
  });
}
function sortBy() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _sortBy(data, args[0]);
    };
  }
  return _sortBy(arguments[0], arguments[1]);
}
function _groupBy(xs, groupFn) {
  return reduceU(xs, {}, function(acc, element) {
    var key = groupFn(element);
    var value = get(acc, key);
    if (value !== void 0) {
      value.push(element);
    } else {
      acc[key] = [element];
    }
    return acc;
  });
}
function groupBy() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _groupBy(data, args[0]);
    };
  }
  return _groupBy(arguments[0], arguments[1]);
}
function flat(xs) {
  return reduceU(xs, [], function(acc, value) {
    if (Array.isArray(value)) {
      forEachU(value, function(element) {
        acc.push(element);
      });
    } else {
      acc.push(value);
    }
    return acc;
  });
}
function _flatten(xs, arr) {
  var index = 0;
  while (index < xs.length) {
    var value = xs[index];
    if (Array.isArray(value)) {
      flatten(value, arr);
    } else {
      arr.push(value);
    }
    index = index + 1 | 0;
  }
  ;
  return arr;
}
function flatten() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _flatten(data, args[0]);
    };
  }
  return _flatten(arguments[0], arguments[1]);
}
function deepFlat(xs) {
  return flatten(xs, []);
}
function toTuple(xs) {
  return xs;
}
function _tap(xs, fn) {
  forEachU(xs, fn);
  return xs;
}
function tap() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _tap(data, args[0]);
    };
  }
  return _tap(arguments[0], arguments[1]);
}
function flip(xs) {
  return [
    xs[1],
    xs[0]
  ];
}
var _filterMap = keepMapU;
function filterMap() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _filterMap(data, args[0]);
    };
  }
  return _filterMap(arguments[0], arguments[1]);
}
var _keepMap = keepMapU;
function keepMap() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _keepMap(data, args[0]);
    };
  }
  return _keepMap(arguments[0], arguments[1]);
}
function _removeFirstBy(xs, value, predicateFn) {
  return reduceU(xs, [
    false,
    []
  ], function(acc, v) {
    var ys = acc[1];
    if (acc[0]) {
      ys.push(v);
      return [
        true,
        ys
      ];
    } else if (predicateFn(v, value)) {
      return [
        true,
        ys
      ];
    } else {
      ys.push(v);
      return [
        false,
        ys
      ];
    }
  })[1];
}
function removeFirstBy() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _removeFirstBy(data, args[0], args[1]);
    };
  }
  return _removeFirstBy(arguments[0], arguments[1], arguments[2]);
}
function _removeFirst(xs, value) {
  return removeFirstBy(xs, value, caml_equal);
}
function removeFirst() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _removeFirst(data, args[0]);
    };
  }
  return _removeFirst(arguments[0], arguments[1]);
}
function zipWithIndex(xs) {
  return reduceWithIndexU(xs, [], function(acc, value, index) {
    acc.push([
      value,
      index
    ]);
    return acc;
  });
}
function _all(xs, predicateFn) {
  return everyU(xs, predicateFn);
}
function all() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _all(data, args[0]);
    };
  }
  return _all(arguments[0], arguments[1]);
}
function _any(xs, predicateFn) {
  return someU(xs, predicateFn);
}
function any() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _any(data, args[0]);
    };
  }
  return _any(arguments[0], arguments[1]);
}
function _difference(xs, ys) {
  return reject(uniqBy(xs, function(element) {
    return element;
  }), function(value) {
    return includes(ys, value);
  });
}
function difference() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _difference(data, args[0]);
    };
  }
  return _difference(arguments[0], arguments[1]);
}
function _union(xs, ys) {
  var xs$1 = concat(xs, ys);
  return uniqBy(xs$1, function(element) {
    return element;
  });
}
function union() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _union(data, args[0]);
    };
  }
  return _union(arguments[0], arguments[1]);
}
function _intersection(xs, ys) {
  var match = xs.length > ys.length ? [
    xs,
    ys
  ] : [
    ys,
    xs
  ];
  var ys$1 = match[1];
  var xs$1 = filter(match[0], function(value) {
    return includes(ys$1, value);
  });
  return uniqBy(xs$1, function(element) {
    return element;
  });
}
function intersection() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _intersection(data, args[0]);
    };
  }
  return _intersection(arguments[0], arguments[1]);
}
export {
  all,
  any,
  append,
  at,
  concat2 as concat,
  concatMany2 as concatMany,
  copy,
  deepFlat,
  difference,
  drop,
  dropExactly,
  dropWhile,
  eq,
  every,
  filter,
  filterMap,
  filterWithIndex,
  find,
  flat,
  flatten,
  flip,
  forEach,
  forEachWithIndex,
  get3 as get,
  getBy,
  getIndexBy,
  getUndefined,
  getUnsafe,
  groupBy,
  head,
  includes,
  init,
  initOrEmpty,
  insertAt,
  intersection,
  intersperse,
  isEmpty,
  isNotEmpty,
  join,
  keep,
  keepMap,
  keepWithIndex,
  last,
  length,
  make2 as make,
  makeEmpty,
  makeWithIndex,
  map,
  mapWithIndex,
  partition,
  placeholder,
  prepend,
  prependToAll,
  range2 as range,
  rangeBy2 as rangeBy,
  reduce,
  reduceReverse,
  reduceWithIndex,
  reject,
  rejectWithIndex,
  removeAt,
  removeFirst,
  removeFirstBy,
  repeat,
  replaceAt,
  reverse2 as reverse,
  shuffle2 as shuffle,
  slice2 as slice,
  sliceToEnd2 as sliceToEnd,
  some2 as some,
  sort,
  sortBy,
  splitAt,
  splitEvery,
  swapAt,
  tail,
  tailOrEmpty,
  take,
  takeExactly,
  takeWhile,
  tap,
  toTuple,
  uncons,
  union,
  uniq,
  uniqBy,
  unzip2 as unzip,
  updateAt,
  zip2 as zip,
  zipWith,
  zipWithIndex
};