import { e as creeSyntaxError, f as reporteEtLeveErreur, g as ERREUR_SYNTAXE_INVALIDE, h as ERREUR_SELECTEUR_INEXISTANT } from "./erreurs.js";
import { p as pipe } from "./pipe.XPB0wEfw.js";
import { E as Either, r as right, l as left } from "./Either.wHNxn7Os.js";
import "./exports.BuUzFliQ.js";
function int_compare(e, r) {
  if (e < r) {
    return -1;
  } else if (e === r) {
    return 0;
  } else {
    return 1;
  }
}
function bool_compare(e, r) {
  if (e) {
    if (r) {
      return 0;
    } else {
      return 1;
    }
  } else if (r) {
    return -1;
  } else {
    return 0;
  }
}
function string_compare(e, r) {
  if (e === r) {
    return 0;
  } else if (e < r) {
    return -1;
  } else {
    return 1;
  }
}
function int_max(e, r) {
  if (e > r) {
    return e;
  } else {
    return r;
  }
}
var for_in = function(r, e) {
  for (var n in r) {
    e(n);
  }
};
function compare(t, a) {
  if (t === a) {
    return 0;
  }
  var i2 = typeof t;
  var u = typeof a;
  switch (i2) {
    case "boolean":
      if ("boolean" === u) {
        return bool_compare(t, a);
      }
      break;
    case "function":
      if ("function" === u) {
        throw {
          RE_EXN_ID: "Invalid_argument",
          _1: "compare: functional value",
          Error: new Error()
        };
      }
      break;
    case "number":
      if ("number" === u) {
        return int_compare(t, a);
      }
      break;
    case "string":
      if ("string" === u) {
        return string_compare(t, a);
      } else {
        return 1;
      }
    case "undefined":
      return -1;
  }
  switch (u) {
    case "string":
      return -1;
    case "undefined":
      return 1;
    default:
      if ("boolean" === i2) {
        return 1;
      }
      if ("boolean" === u) {
        return -1;
      }
      if ("function" === i2) {
        return 1;
      }
      if ("function" === u) {
        return -1;
      }
      if ("number" === i2) {
        if (null === a || void 0 !== a.BS_PRIVATE_NESTED_SOME_NONE) {
          return 1;
        } else {
          return -1;
        }
      }
      if ("number" === u) {
        if (null === t || void 0 !== t.BS_PRIVATE_NESTED_SOME_NONE) {
          return -1;
        } else {
          return 1;
        }
      }
      if (null === t) {
        if (void 0 !== a.BS_PRIVATE_NESTED_SOME_NONE) {
          return 1;
        } else {
          return -1;
        }
      }
      if (null === a) {
        if (void 0 !== t.BS_PRIVATE_NESTED_SOME_NONE) {
          return -1;
        } else {
          return 1;
        }
      }
      if (void 0 !== t.BS_PRIVATE_NESTED_SOME_NONE) {
        if (void 0 !== a.BS_PRIVATE_NESTED_SOME_NONE) {
          return aux_obj_compare(t, a);
        } else {
          return -1;
        }
      }
      var o = 0 | t.TAG;
      var f = 0 | a.TAG;
      if (248 === o) {
        return int_compare(t[1], a[1]);
      }
      if (251 === o) {
        throw {
          RE_EXN_ID: "Invalid_argument",
          _1: "equal: abstract value",
          Error: new Error()
        };
      }
      if (o !== f) {
        if (o < f) {
          return -1;
        } else {
          return 1;
        }
      }
      var l = 0 | t.length;
      var s = 0 | a.length;
      if (l === s) {
        if (Array.isArray(t)) {
          var c = 0;
          while (1) {
            var v = c;
            if (v === l) {
              return 0;
            }
            var E = compare(t[v], a[v]);
            if (0 !== E) {
              return E;
            }
            c = v + 1 | 0;
          }
        } else if (t instanceof Date && a instanceof Date) {
          return t - a;
        } else {
          return aux_obj_compare(t, a);
        }
      } else if (l < s) {
        var _ = 0;
        while (1) {
          var d = _;
          if (d === l) {
            return -1;
          }
          var p = compare(t[d], a[d]);
          if (0 !== p) {
            return p;
          }
          _ = d + 1 | 0;
        }
      } else {
        var m = 0;
        while (1) {
          var b = m;
          if (b === s) {
            return 1;
          }
          var N2 = compare(t[b], a[b]);
          if (0 !== N2) {
            return N2;
          }
          m = b + 1 | 0;
        }
      }
  }
}
function aux_obj_compare(e, n) {
  var t = {
    contents: void 0
  };
  var a = {
    contents: void 0
  };
  var do_key = function(r, e2) {
    var n2 = r[2];
    var t2 = r[1];
    if (Object.prototype.hasOwnProperty.call(t2, e2) && !(compare(r[0][e2], t2[e2]) > 0)) {
      return;
    }
    var a2 = n2.contents;
    if (void 0 !== a2 && e2 >= a2) {
      return;
    } else {
      n2.contents = e2;
      return;
    }
  };
  var i2 = [e, n, a];
  var u = [n, e, t];
  for_in(e, function(r) {
    return do_key(i2, r);
  });
  for_in(n, function(r) {
    return do_key(u, r);
  });
  var o = t.contents;
  var f = a.contents;
  if (void 0 !== o) {
    if (void 0 !== f) {
      return string_compare(o, f);
    } else {
      return -1;
    }
  } else if (void 0 !== f) {
    return 1;
  } else {
    return 0;
  }
}
function equal(r, e) {
  if (r === e) {
    return true;
  }
  var n = typeof r;
  if ("string" === n || "number" === n || "boolean" === n || "undefined" === n || null === r) {
    return false;
  }
  var t = typeof e;
  if ("function" === n || "function" === t) {
    throw {
      RE_EXN_ID: "Invalid_argument",
      _1: "equal: functional value",
      Error: new Error()
    };
  }
  if ("number" === t || "undefined" === t || null === e) {
    return false;
  }
  var a = 0 | r.TAG;
  var i2 = 0 | e.TAG;
  if (248 === a) {
    return r[1] === e[1];
  }
  if (251 === a) {
    throw {
      RE_EXN_ID: "Invalid_argument",
      _1: "equal: abstract value",
      Error: new Error()
    };
  }
  if (a !== i2) {
    return false;
  }
  var u = 0 | r.length;
  if (u === (0 | e.length)) {
    if (Array.isArray(r)) {
      var o = 0;
      while (1) {
        var f = o;
        if (f === u) {
          return true;
        }
        if (!equal(r[f], e[f])) {
          return false;
        }
        o = f + 1 | 0;
      }
    } else if (r instanceof Date && e instanceof Date) {
      return !(r > e || r < e);
    } else {
      var l = {
        contents: true
      };
      for_in(r, function(r2) {
        if (!Object.prototype.hasOwnProperty.call(e, r2)) {
          l.contents = false;
          return;
        }
      });
      if (l.contents) {
        for_in(e, function(n2) {
          if (!Object.prototype.hasOwnProperty.call(r, n2) || !equal(e[n2], r[n2])) {
            l.contents = false;
            return;
          }
        });
      }
      return l.contents;
    }
  } else {
    return false;
  }
}
function lessthan(r, e) {
  return compare(r, e) < 0;
}
function some$1(_) {
  if (void 0 === _) {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: 0
    };
  } else if (null !== _ && void 0 !== _.BS_PRIVATE_NESTED_SOME_NONE) {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: _.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
    };
  } else {
    return _;
  }
}
function nullable_to_opt(_) {
  if (null == _) {
    return;
  } else {
    return some$1(_);
  }
}
function valFromOption(_) {
  if (null === _ || void 0 === _.BS_PRIVATE_NESTED_SOME_NONE) {
    return _;
  }
  var n = _.BS_PRIVATE_NESTED_SOME_NONE;
  if (0 === n) {
    return;
  } else {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: n - 1 | 0
    };
  }
}
function floor_int(r) {
  if (r > 2147483647) {
    return 2147483647;
  } else if (r < -2147483648) {
    return -2147483648;
  } else {
    return Math.floor(r);
  }
}
function random_int(r, n) {
  return floor_int(Math.random() * (n - r | 0)) + r | 0;
}
function get$2(r, a) {
  if (a >= 0 && a < r.length) {
    return some$1(r[a]);
  }
}
function getExn(r, n) {
  if (!(n < r.length)) {
    throw {
      RE_EXN_ID: "Assert_failure",
      _1: ["belt_Array.ml", 35, 2],
      Error: new Error()
    };
  }
  return r[n];
}
function swapUnsafe(r, n, a) {
  var e = r[n];
  r[n] = r[a];
  r[a] = e;
}
function shuffle(r) {
  var n = r.slice(0);
  !function shuffleInPlace(r2) {
    var n2 = r2.length;
    for (var a = 0; a < n2; ++a) {
      swapUnsafe(r2, a, random_int(a, n2));
    }
  }(n);
  return n;
}
function reverse(r) {
  var n = r.length;
  var a = new Array(n);
  for (var e = 0; e < n; ++e) {
    a[e] = r[(n - 1 | 0) - e | 0];
  }
  return a;
}
function make$1(r, n) {
  if (r <= 0) {
    return [];
  }
  var a = new Array(r);
  for (var e = 0; e < r; ++e) {
    a[e] = n;
  }
  return a;
}
function makeByU(r, n) {
  if (r <= 0) {
    return [];
  }
  var a = new Array(r);
  for (var e = 0; e < r; ++e) {
    a[e] = n(e);
  }
  return a;
}
function range$1(r, n) {
  var a = n - r | 0;
  if (a < 0) {
    return [];
  }
  var e = new Array(a + 1 | 0);
  for (var t = 0; t <= a; ++t) {
    e[t] = r + t | 0;
  }
  return e;
}
function rangeBy$1(r, n, a) {
  var e = n - r | 0;
  if (e < 0 || a <= 0) {
    return [];
  }
  var t = 1 + (e / a | 0) | 0;
  var v = new Array(t);
  var f = r;
  for (var o = 0; o < t; ++o) {
    v[o] = f;
    f = f + a | 0;
  }
  return v;
}
function zip$1(r, n) {
  var a = r.length;
  var e = n.length;
  var t = a < e ? a : e;
  var v = new Array(t);
  for (var f = 0; f < t; ++f) {
    v[f] = [r[f], n[f]];
  }
  return v;
}
function zipByU(r, n, a) {
  var e = r.length;
  var t = n.length;
  var v = e < t ? e : t;
  var f = new Array(v);
  for (var o = 0; o < v; ++o) {
    f[o] = a(r[o], n[o]);
  }
  return f;
}
function concat$1(r, n) {
  var a = r.length;
  var e = n.length;
  var t = new Array(a + e | 0);
  for (var v = 0; v < a; ++v) {
    t[v] = r[v];
  }
  for (var f = 0; f < e; ++f) {
    t[a + f | 0] = n[f];
  }
  return t;
}
function concatMany(r) {
  var n = r.length;
  var a = 0;
  for (var e = 0; e < n; ++e) {
    a = a + r[e].length | 0;
  }
  var t = new Array(a);
  a = 0;
  for (var v = 0; v < n; ++v) {
    var f = r[v];
    for (var o = 0, i2 = f.length; o < i2; ++o) {
      t[a] = f[o];
      a = a + 1 | 0;
    }
  }
  return t;
}
function slice$1(n, a, e) {
  if (e <= 0) {
    return [];
  }
  var t = n.length;
  var v = a < 0 ? int_max(t + a | 0, 0) : a;
  var f = t - v | 0;
  var o = f < e ? f : e;
  if (o <= 0) {
    return [];
  }
  var i2 = new Array(o);
  for (var u = 0; u < o; ++u) {
    i2[u] = n[v + u | 0];
  }
  return i2;
}
function sliceToEnd$1(n, a) {
  var e = n.length;
  var t = a < 0 ? int_max(e + a | 0, 0) : a;
  var v = e > t ? e - t | 0 : 0;
  var f = new Array(v);
  for (var o = 0; o < v; ++o) {
    f[o] = n[t + o | 0];
  }
  return f;
}
function blitUnsafe(r, n, a, e, t) {
  if (e <= n) {
    for (var v = 0; v < t; ++v) {
      a[v + e | 0] = r[v + n | 0];
    }
    return;
  }
  for (var f = t - 1 | 0; f >= 0; --f) {
    a[f + e | 0] = r[f + n | 0];
  }
}
function forEachU(r, n) {
  for (var a = 0, e = r.length; a < e; ++a) {
    n(r[a]);
  }
}
function mapU(r, n) {
  var a = r.length;
  var e = new Array(a);
  for (var t = 0; t < a; ++t) {
    e[t] = n(r[t]);
  }
  return e;
}
function getByU(r, a) {
  var e = r.length;
  var t = 0;
  var v;
  while (void 0 === v && t < e) {
    var f = r[t];
    if (a(f)) {
      v = some$1(f);
    }
    t = t + 1 | 0;
  }
  return v;
}
function getIndexByU(r, n) {
  var a = r.length;
  var e = 0;
  var t;
  while (void 0 === t && e < a) {
    if (n(r[e])) {
      t = e;
    }
    e = e + 1 | 0;
  }
  return t;
}
function keepMapU(r, n) {
  var e = r.length;
  var t = new Array(e);
  var v = 0;
  for (var f = 0; f < e; ++f) {
    var o = n(r[f]);
    if (void 0 !== o) {
      t[v] = valFromOption(o);
      v = v + 1 | 0;
    }
  }
  t.length = v;
  return t;
}
function forEachWithIndexU(r, n) {
  for (var a = 0, e = r.length; a < e; ++a) {
    n(a, r[a]);
  }
}
function mapWithIndexU(r, n) {
  var a = r.length;
  var e = new Array(a);
  for (var t = 0; t < a; ++t) {
    e[t] = n(t, r[t]);
  }
  return e;
}
function reduceU(r, n, a) {
  var e = n;
  for (var t = 0, v = r.length; t < v; ++t) {
    e = a(e, r[t]);
  }
  return e;
}
function reduceReverseU(r, n, a) {
  var e = n;
  for (var t = r.length - 1 | 0; t >= 0; --t) {
    e = a(e, r[t]);
  }
  return e;
}
function reduceWithIndexU(r, n, a) {
  var e = n;
  for (var t = 0, v = r.length; t < v; ++t) {
    e = a(e, r[t], t);
  }
  return e;
}
function everyU(r, n) {
  var a = r.length;
  var e = 0;
  while (1) {
    var t = e;
    if (t === a) {
      return true;
    }
    if (!n(r[t])) {
      return false;
    }
    e = t + 1 | 0;
  }
}
function someU(r, n) {
  var a = r.length;
  var e = 0;
  while (1) {
    var t = e;
    if (t === a) {
      return false;
    }
    if (n(r[t])) {
      return true;
    }
    e = t + 1 | 0;
  }
}
function eqU(r, n, a) {
  var e = r.length;
  if (e === n.length) {
    return function everyAux2(r2, n2, a2, e2, t) {
      while (1) {
        var v = a2;
        if (v === t) {
          return true;
        }
        if (!e2(r2[v], n2[v])) {
          return false;
        }
        a2 = v + 1 | 0;
      }
    }(r, n, 0, a, e);
  } else {
    return false;
  }
}
function partitionU(r, n) {
  var a = r.length;
  var e = 0;
  var t = 0;
  var v = new Array(a);
  var f = new Array(a);
  for (var o = 0; o < a; ++o) {
    var i2 = r[o];
    if (n(i2)) {
      v[e] = i2;
      e = e + 1 | 0;
    } else {
      f[t] = i2;
      t = t + 1 | 0;
    }
  }
  v.length = e;
  f.length = t;
  return [v, f];
}
function unzip(r) {
  var n = r.length;
  var a = new Array(n);
  var e = new Array(n);
  for (var t = 0; t < n; ++t) {
    var v = r[t];
    a[t] = v[0];
    e[t] = v[1];
  }
  return [a, e];
}
function merge(n, t, e, u, i2, f, a, o, c) {
  var s = t + e | 0;
  var l = i2 + f | 0;
  var h = t;
  var p = n[t];
  var v = i2;
  var g = u[i2];
  var _ = o;
  while (1) {
    var d = _;
    var y = g;
    var m = v;
    var A = p;
    var x = h;
    if (c(A, y) <= 0) {
      a[d] = A;
      var B = x + 1 | 0;
      if (B >= s) {
        return blitUnsafe(u, m, a, d + 1 | 0, l - m | 0);
      }
      _ = d + 1 | 0;
      p = n[B];
      h = B;
      continue;
    }
    a[d] = y;
    var W = m + 1 | 0;
    if (W >= l) {
      return blitUnsafe(n, x, a, d + 1 | 0, s - x | 0);
    }
    _ = d + 1 | 0;
    g = u[W];
    v = W;
  }
}
function insertionSort(n, t, r, e, u, i2) {
  for (var f = 0; f < u; ++f) {
    var a = n[t + f | 0];
    var o = (e + f | 0) - 1 | 0;
    while (o >= e && i2(r[o], a) > 0) {
      r[o + 1 | 0] = r[o];
      o = o - 1 | 0;
    }
    r[o + 1 | 0] = a;
  }
}
function sortTo(n, t, r, e, u, i2) {
  if (u <= 5) {
    return insertionSort(n, t, r, e, u, i2);
  }
  var f = u / 2 | 0;
  var a = u - f | 0;
  sortTo(n, t + f | 0, r, e + f | 0, a, i2);
  sortTo(n, t, n, t + a | 0, f, i2);
  merge(n, t + a | 0, f, r, e + f | 0, a, r, e, i2);
}
function stableSortByU(n, t) {
  var r = n.slice(0);
  !function stableSortInPlaceByU(n2, t2) {
    var r2 = n2.length;
    if (r2 <= 5) {
      return insertionSort(n2, 0, n2, 0, r2, t2);
    }
    var e = r2 / 2 | 0;
    var u = r2 - e | 0;
    var i2 = new Array(u);
    sortTo(n2, e, i2, 0, u, t2);
    sortTo(n2, 0, n2, u, e, t2);
    merge(n2, u, e, i2, 0, u, n2, 0, t2);
  }(r, t);
  return r;
}
function get$1(t, r) {
  if (r in t) {
    return some$1(t[r]);
  }
}
var unsafeDeleteKey = function(n, t) {
  delete n[t];
};
function values(n) {
  var t = Object.keys(n);
  var r = t.length;
  var e = new Array(r);
  for (var u = 0; u < r; ++u) {
    e[u] = n[t[u]];
  }
  return e;
}
function fromArray(n) {
  var t = {};
  var r = n.length;
  for (var e = 0; e < r; ++e) {
    var u = n[e];
    t[u[0]] = u[1];
  }
  return t;
}
function placeholder(n) {
}
function makeEmpty(n) {
  return [];
}
var z = makeByU;
function makeWithIndex() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return z(t, n[0]);
    };
  }
  return z(arguments[0], arguments[1]);
}
var S = make$1;
function make() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return S(t, n[0]);
    };
  }
  return S(arguments[0], arguments[1]);
}
var O = make$1;
function repeat() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return O(t, n[0]);
    };
  }
  return O(arguments[0], arguments[1]);
}
function length(n) {
  return n.length;
}
function isEmpty(n) {
  return 0 === n.length;
}
function isNotEmpty(n) {
  return 0 !== n.length;
}
var $ = reverse;
function _append(n, t) {
  return concat$1(n, [t]);
}
function append() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _append(t, n[0]);
    };
  }
  return _append(arguments[0], arguments[1]);
}
function _prepend(n, t) {
  return concat$1([t], n);
}
function prepend() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _prepend(t, n[0]);
    };
  }
  return _prepend(arguments[0], arguments[1]);
}
function _prependToAll(n, t) {
  return reduceU(n, [], function(n2, r) {
    return concat$1(n2, [t, r]);
  });
}
function prependToAll() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _prependToAll(t, n[0]);
    };
  }
  return _prependToAll(arguments[0], arguments[1]);
}
function _intersperse(n, t) {
  return reduceWithIndexU(n, [], function(r, e, u) {
    if ((n.length - 1 | 0) === u) {
      r.push(e);
    } else {
      r.push(e, t);
    }
    return r;
  });
}
function intersperse() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _intersperse(t, n[0]);
    };
  }
  return _intersperse(arguments[0], arguments[1]);
}
var C = get$2;
function get() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return C(t, n[0]);
    };
  }
  return C(arguments[0], arguments[1]);
}
var D = get$2;
function at() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return D(t, n[0]);
    };
  }
  return D(arguments[0], arguments[1]);
}
function _getUnsafe(n, t) {
  return n[t];
}
function getUnsafe() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _getUnsafe(t, n[0]);
    };
  }
  return _getUnsafe(arguments[0], arguments[1]);
}
function _getUndefined(n, t) {
  return n[t];
}
function getUndefined() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _getUndefined(t, n[0]);
    };
  }
  return _getUndefined(arguments[0], arguments[1]);
}
var N = getByU;
function getBy() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return N(t, n[0]);
    };
  }
  return N(arguments[0], arguments[1]);
}
var R = getByU;
function find() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return R(t, n[0]);
    };
  }
  return R(arguments[0], arguments[1]);
}
function head(n) {
  return get$2(n, 0);
}
function last(n) {
  var t = n.length;
  if (0 === t) {
    return;
  } else {
    return get$2(n, t - 1 | 0);
  }
}
function tail(n) {
  var t = n.length;
  if (1 === t) {
    return [];
  }
  if (0 === t) {
    return;
  }
  var r = sliceToEnd$1(n, 1);
  if (0 !== r.length) {
    return r;
  }
}
function tailOrEmpty(n) {
  var t = tail(n);
  if (void 0 !== t) {
    return t;
  } else {
    return [];
  }
}
function init(n) {
  var t = n.length;
  if (0 === t) {
    return;
  } else {
    return slice$1(n, 0, t - 1 | 0);
  }
}
function initOrEmpty(n) {
  var t = init(n);
  if (void 0 !== t) {
    return t;
  } else {
    return [];
  }
}
function _take(n, t) {
  var r = n.length;
  return slice$1(n, 0, t < 0 ? 0 : r < t ? r : t);
}
function take() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _take(t, n[0]);
    };
  }
  return _take(arguments[0], arguments[1]);
}
function _takeExactly(n, t) {
  if (t < 0 || t > n.length) {
    return;
  } else {
    return slice$1(n, 0, t);
  }
}
function takeExactly() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _takeExactly(t, n[0]);
    };
  }
  return _takeExactly(arguments[0], arguments[1]);
}
function _takeWhile(n, t) {
  var r = 0;
  var e = false;
  var u = [];
  while (r < n.length && !e) {
    var i2 = n[r];
    if (t(i2)) {
      u.push(i2);
      r = r + 1 | 0;
    } else {
      e = true;
    }
  }
  return u;
}
function takeWhile() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _takeWhile(t, n[0]);
    };
  }
  return _takeWhile(arguments[0], arguments[1]);
}
function _drop(n, t) {
  var r = n.length;
  return sliceToEnd$1(n, t < 0 ? 0 : r < t ? r : t);
}
function drop() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _drop(t, n[0]);
    };
  }
  return _drop(arguments[0], arguments[1]);
}
function _dropExactly(n, t) {
  if (t < 0 || t > n.length) {
    return;
  } else {
    return sliceToEnd$1(n, t);
  }
}
function dropExactly() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _dropExactly(t, n[0]);
    };
  }
  return _dropExactly(arguments[0], arguments[1]);
}
function _dropWhile(n, t) {
  return reduceU(n, [], function(n2, r) {
    if (!t(r)) {
      n2.push(r);
    }
    return n2;
  });
}
function dropWhile() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _dropWhile(t, n[0]);
    };
  }
  return _dropWhile(arguments[0], arguments[1]);
}
function uncons(n) {
  if (0 !== n.length) {
    return [getExn(n, 0), sliceToEnd$1(n, 1)];
  }
}
function _map(n, t) {
  return mapU(n, t);
}
function map() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _map(t, n[0]);
    };
  }
  return _map(arguments[0], arguments[1]);
}
var G = mapWithIndexU;
function mapWithIndex() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return G(t, n[0]);
    };
  }
  return G(arguments[0], arguments[1]);
}
function _filter(n, t) {
  var r = 0;
  var e = [];
  while (r < n.length) {
    var u = n[r];
    if (t(u)) {
      e.push(u);
    }
    r = r + 1 | 0;
  }
  return e;
}
function filter() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _filter(t, n[0]);
    };
  }
  return _filter(arguments[0], arguments[1]);
}
var P = filter;
function _filterWithIndex(n, t) {
  var r = 0;
  var e = [];
  while (r < n.length) {
    var u = n[r];
    if (t(r, u)) {
      e.push(u);
    }
    r = r + 1 | 0;
  }
  return e;
}
function filterWithIndex() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _filterWithIndex(t, n[0]);
    };
  }
  return _filterWithIndex(arguments[0], arguments[1]);
}
var H = filterWithIndex;
function _reject(n, t) {
  return filter(n, function(n2) {
    return !t(n2);
  });
}
function reject() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _reject(t, n[0]);
    };
  }
  return _reject(arguments[0], arguments[1]);
}
function _rejectWithIndex(n, t) {
  return filterWithIndex(n, function(n2, r) {
    return !t(n2, r);
  });
}
function rejectWithIndex() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _rejectWithIndex(t, n[0]);
    };
  }
  return _rejectWithIndex(arguments[0], arguments[1]);
}
var J = reduceU;
function reduce() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return J(t, n[0], n[1]);
    };
  }
  return J(arguments[0], arguments[1], arguments[2]);
}
var K = reduceReverseU;
function reduceReverse() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return K(t, n[0], n[1]);
    };
  }
  return K(arguments[0], arguments[1], arguments[2]);
}
var L = reduceWithIndexU;
function reduceWithIndex() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return L(t, n[0], n[1]);
    };
  }
  return L(arguments[0], arguments[1], arguments[2]);
}
function _splitAt(n, t) {
  if (t < 0 || t > n.length) {
    return;
  } else {
    return [slice$1(n, 0, t), sliceToEnd$1(n, t)];
  }
}
function splitAt() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _splitAt(t, n[0]);
    };
  }
  return _splitAt(arguments[0], arguments[1]);
}
function _splitEvery(n, t) {
  if (t < 1 || n.length <= t) {
    return [n];
  }
  var r = 0;
  var e = [];
  while (r < n.length) {
    var u = r + t | 0;
    e.push(slice$1(n, r, t));
    r = u;
  }
  return e;
}
function splitEvery() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _splitEvery(t, n[0]);
    };
  }
  return _splitEvery(arguments[0], arguments[1]);
}
var Q = shuffle;
var V = partitionU;
function partition() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return V(t, n[0]);
    };
  }
  return V(arguments[0], arguments[1]);
}
var X = concat$1;
function concat() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return X(t, n[0]);
    };
  }
  return X(arguments[0], arguments[1]);
}
var Y = concatMany;
var Z = everyU;
function every() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return Z(t, n[0]);
    };
  }
  return Z(arguments[0], arguments[1]);
}
var nn = someU;
function some() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return nn(t, n[0]);
    };
  }
  return nn(arguments[0], arguments[1]);
}
var tn = slice$1;
function slice() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return tn(t, n[0], n[1]);
    };
  }
  return tn(arguments[0], arguments[1], arguments[2]);
}
var rn = sliceToEnd$1;
function sliceToEnd() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return rn(t, n[0]);
    };
  }
  return rn(arguments[0], arguments[1]);
}
var en = eqU;
function eq() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return en(t, n[0], n[1]);
    };
  }
  return en(arguments[0], arguments[1], arguments[2]);
}
var un = range$1;
function range() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return un(t, n[0]);
    };
  }
  return un(arguments[0], arguments[1]);
}
var an = rangeBy$1;
function rangeBy() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return an(t, n[0], n[1]);
    };
  }
  return an(arguments[0], arguments[1], arguments[2]);
}
function copy(n) {
  return n.slice(0);
}
var on = zip$1;
function zip() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return on(t, n[0]);
    };
  }
  return on(arguments[0], arguments[1]);
}
var cn = zipByU;
function zipWith() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return cn(t, n[0], n[1]);
    };
  }
  return cn(arguments[0], arguments[1], arguments[2]);
}
var sn = unzip;
function _replaceAt(n, t, r) {
  return mapWithIndexU(n, function(n2, e) {
    if (n2 === t) {
      return r;
    } else {
      return e;
    }
  });
}
function replaceAt() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _replaceAt(t, n[0], n[1]);
    };
  }
  return _replaceAt(arguments[0], arguments[1], arguments[2]);
}
function _insertAt(n, t, r) {
  var e = splitAt(n, t);
  if (void 0 !== e) {
    return concat$1(e[0], concat$1([r], e[1]));
  } else {
    return n;
  }
}
function insertAt() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _insertAt(t, n[0], n[1]);
    };
  }
  return _insertAt(arguments[0], arguments[1], arguments[2]);
}
function _updateAt(n, t, r) {
  return mapWithIndexU(n, function(n2, e) {
    if (n2 === t) {
      return r(e);
    } else {
      return e;
    }
  });
}
function updateAt() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _updateAt(t, n[0], n[1]);
    };
  }
  return _updateAt(arguments[0], arguments[1], arguments[2]);
}
function _swapAt(n, r, e) {
  var i2 = get$2(n, r);
  var f = get$2(n, e);
  if (void 0 === i2) {
    return n;
  }
  if (void 0 === f) {
    return n;
  }
  var a = valFromOption(f);
  var o = valFromOption(i2);
  return mapWithIndexU(n, function(n2, t) {
    if (r === n2) {
      return a;
    } else if (e === n2) {
      return o;
    } else {
      return t;
    }
  });
}
function swapAt() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _swapAt(t, n[0], n[1]);
    };
  }
  return _swapAt(arguments[0], arguments[1], arguments[2]);
}
function _removeAt(n, t) {
  return filterWithIndex(n, function(n2, r) {
    return n2 !== t;
  });
}
function removeAt() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _removeAt(t, n[0]);
    };
  }
  return _removeAt(arguments[0], arguments[1]);
}
function _uniqBy(n, t) {
  var r = 0;
  var e = [];
  while (r < n.length) {
    var u = n[r];
    var i2 = someU(e, /* @__PURE__ */ function(n2) {
      return function(r2) {
        return equal(t(r2), t(n2));
      };
    }(u));
    if (!i2) {
      e.push(u);
    }
    r = r + 1 | 0;
  }
  return e;
}
function uniqBy() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _uniqBy(t, n[0]);
    };
  }
  return _uniqBy(arguments[0], arguments[1]);
}
function uniq(n) {
  return uniqBy(n, function(n2) {
    return n2;
  });
}
var ln = forEachU;
function forEach() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return ln(t, n[0]);
    };
  }
  return ln(arguments[0], arguments[1]);
}
var hn = forEachWithIndexU;
function forEachWithIndex() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return hn(t, n[0]);
    };
  }
  return hn(arguments[0], arguments[1]);
}
var pn = getIndexByU;
function getIndexBy() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return pn(t, n[0]);
    };
  }
  return pn(arguments[0], arguments[1]);
}
function _includes(n, t) {
  return someU(n, function(n2) {
    return equal(n2, t);
  });
}
function includes() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _includes(t, n[0]);
    };
  }
  return _includes(arguments[0], arguments[1]);
}
function _join(n, t) {
  return n.join(t);
}
function join() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _join(t, n[0]);
    };
  }
  return _join(arguments[0], arguments[1]);
}
var vn = stableSortByU;
function sort() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return vn(t, n[0]);
    };
  }
  return vn(arguments[0], arguments[1]);
}
function _sortBy(n, t) {
  return stableSortByU(n, function(n2, r) {
    var e = t(n2);
    var u = t(r);
    if (e === u) {
      return 0;
    } else if (lessthan(e, u)) {
      return -1;
    } else {
      return 1;
    }
  });
}
function sortBy() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _sortBy(t, n[0]);
    };
  }
  return _sortBy(arguments[0], arguments[1]);
}
function _groupBy(n, t) {
  return reduceU(n, {}, function(n2, r) {
    var e = t(r);
    var u = get$1(n2, e);
    if (void 0 !== u) {
      u.push(r);
    } else {
      n2[e] = [r];
    }
    return n2;
  });
}
function groupBy() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _groupBy(t, n[0]);
    };
  }
  return _groupBy(arguments[0], arguments[1]);
}
function flat(n) {
  return reduceU(n, [], function(n2, t) {
    if (Array.isArray(t)) {
      forEachU(t, function(t2) {
        n2.push(t2);
      });
    } else {
      n2.push(t);
    }
    return n2;
  });
}
function _flatten(n, t) {
  var r = 0;
  while (r < n.length) {
    var e = n[r];
    if (Array.isArray(e)) {
      flatten(e, t);
    } else {
      t.push(e);
    }
    r = r + 1 | 0;
  }
  return t;
}
function flatten() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _flatten(t, n[0]);
    };
  }
  return _flatten(arguments[0], arguments[1]);
}
function deepFlat(n) {
  return flatten(n, []);
}
function toTuple(n) {
  return n;
}
function _tap(n, t) {
  forEachU(n, t);
  return n;
}
function tap() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _tap(t, n[0]);
    };
  }
  return _tap(arguments[0], arguments[1]);
}
function flip(n) {
  return [n[1], n[0]];
}
var gn = keepMapU;
function filterMap() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return gn(t, n[0]);
    };
  }
  return gn(arguments[0], arguments[1]);
}
var _n = keepMapU;
function keepMap() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _n(t, n[0]);
    };
  }
  return _n(arguments[0], arguments[1]);
}
function _removeFirstBy(n, t, r) {
  return reduceU(n, [false, []], function(n2, e) {
    var u = n2[1];
    if (n2[0]) {
      u.push(e);
      return [true, u];
    } else if (r(e, t)) {
      return [true, u];
    } else {
      u.push(e);
      return [false, u];
    }
  })[1];
}
function removeFirstBy() {
  if (2 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _removeFirstBy(t, n[0], n[1]);
    };
  }
  return _removeFirstBy(arguments[0], arguments[1], arguments[2]);
}
function _removeFirst(n, t) {
  return removeFirstBy(n, t, equal);
}
function removeFirst() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _removeFirst(t, n[0]);
    };
  }
  return _removeFirst(arguments[0], arguments[1]);
}
function zipWithIndex(n) {
  return reduceWithIndexU(n, [], function(n2, t, r) {
    n2.push([t, r]);
    return n2;
  });
}
function _all(n, t) {
  return everyU(n, t);
}
function all() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _all(t, n[0]);
    };
  }
  return _all(arguments[0], arguments[1]);
}
function _any(n, t) {
  return someU(n, t);
}
function any() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _any(t, n[0]);
    };
  }
  return _any(arguments[0], arguments[1]);
}
function _difference(n, t) {
  return reject(uniqBy(n, function(n2) {
    return n2;
  }), function(n2) {
    return includes(t, n2);
  });
}
function difference() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _difference(t, n[0]);
    };
  }
  return _difference(arguments[0], arguments[1]);
}
function _union(n, t) {
  return uniqBy(concat$1(n, t), function(n2) {
    return n2;
  });
}
function union() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _union(t, n[0]);
    };
  }
  return _union(arguments[0], arguments[1]);
}
function _intersection(n, t) {
  var r = n.length > t.length ? [n, t] : [t, n];
  var e = r[1];
  return uniqBy(filter(r[0], function(n2) {
    return includes(e, n2);
  }), function(n2) {
    return n2;
  });
}
function intersection() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _intersection(t, n[0]);
    };
  }
  return _intersection(arguments[0], arguments[1]);
}
function sample(n) {
  return n[random_int(0, n.length - 1 | 0)];
}
function _flatMap(n, t) {
  return flat(mapU(n, t));
}
function flatMap() {
  if (1 === arguments.length) {
    const n = arguments;
    return function fn(t) {
      return _flatMap(t, n[0]);
    };
  }
  return _flatMap(arguments[0], arguments[1]);
}
var Ra = {
  __proto__: null,
  placeholder,
  makeEmpty,
  makeWithIndex,
  make,
  repeat,
  length,
  isEmpty,
  isNotEmpty,
  reverse: $,
  append,
  prepend,
  prependToAll,
  intersperse,
  get,
  at,
  getUnsafe,
  getUndefined,
  getBy,
  find,
  head,
  last,
  tail,
  tailOrEmpty,
  init,
  initOrEmpty,
  take,
  takeExactly,
  takeWhile,
  drop,
  dropExactly,
  dropWhile,
  uncons,
  map,
  mapWithIndex,
  filter,
  keep: P,
  filterWithIndex,
  keepWithIndex: H,
  reject,
  rejectWithIndex,
  reduce,
  reduceReverse,
  reduceWithIndex,
  splitAt,
  splitEvery,
  shuffle: Q,
  partition,
  concat,
  concatMany: Y,
  every,
  some,
  slice,
  sliceToEnd,
  eq,
  range,
  rangeBy,
  copy,
  zip,
  zipWith,
  unzip: sn,
  replaceAt,
  insertAt,
  updateAt,
  swapAt,
  removeAt,
  uniqBy,
  uniq,
  forEach,
  forEachWithIndex,
  getIndexBy,
  includes,
  join,
  sort,
  sortBy,
  groupBy,
  flat,
  flatten,
  deepFlat,
  toTuple,
  tap,
  flip,
  filterMap,
  keepMap,
  removeFirstBy,
  removeFirst,
  zipWithIndex,
  all,
  any,
  difference,
  union,
  intersection,
  sample,
  flatMap
};
function _is(i2, n) {
  return typeof i2 === n;
}
function is() {
  if (1 === arguments.length) {
    const i2 = arguments;
    return function fn(n) {
      return _is(n, i2[0]);
    };
  }
  return _is(arguments[0], arguments[1]);
}
function isString(i2) {
  return "string" == typeof i2;
}
function isNumber(i2) {
  if ("number" == typeof i2) {
    return !Number.isNaN(i2);
  } else {
    return false;
  }
}
function isBoolean(i2) {
  return "boolean" == typeof i2;
}
var isPromise = (i2) => i2 instanceof Promise;
function isArray(i2) {
  return Array.isArray(i2);
}
function isObject(i2) {
  if (i2 && !Array.isArray(i2)) {
    return "object" == typeof i2;
  } else {
    return false;
  }
}
function isFunction(i2) {
  return "function" == typeof i2;
}
var isError = (i2) => i2 instanceof Error;
var isDate = (i2) => i2 instanceof Date;
function isNullable(i2) {
  return null == i2;
}
function isNotNullable(i2) {
  return !(null == i2);
}
var isNull = (i2) => null === i2;
var isUndefined = (i2) => void 0 === i2;
function _isNot(i2, n) {
  return !n(i2);
}
function isNot() {
  if (1 === arguments.length) {
    const i2 = arguments;
    return function fn(n) {
      return _isNot(n, i2[0]);
    };
  }
  return _isNot(arguments[0], arguments[1]);
}
var i = {
  __proto__: null,
  is,
  isString,
  isNumber,
  isBoolean,
  isPromise,
  isArray,
  isObject,
  isFunction,
  isError,
  isDate,
  isNullable,
  isNotNullable,
  isNull,
  isUndefined,
  isNot
};
const identity = (x) => x;
const recupereElementAvecSelecteur = (parent) => (selecteur) => Either.encase(() => parent.querySelector(selecteur)).mapLeft((_) => creeSyntaxError(ERREUR_SYNTAXE_INVALIDE(selecteur))).chain(
  (e) => i.isNotNullable(e) ? right(e) : left(creeSyntaxError(ERREUR_SELECTEUR_INEXISTANT(selecteur)))
);
const recupereElementsAvecSelecteur = (parent) => (selecteur) => Either.encase(() => pipe(parent.querySelectorAll(selecteur), Array.from)).mapLeft((_) => creeSyntaxError(ERREUR_SYNTAXE_INVALIDE(selecteur))).chain((e) => Ra.isEmpty(e) ? left(creeSyntaxError(ERREUR_SELECTEUR_INEXISTANT(selecteur))) : right(e));
const recupereElementOuLeve = (elementOuErreur) => elementOuErreur.caseOf({
  Left: reporteEtLeveErreur,
  Right: identity
});
const recupereElementsOuLeve = (elementsOuErreur) => elementsOuErreur.caseOf({
  Left: reporteEtLeveErreur,
  Right: identity
});
const majElementInnerHtml = (element) => (innerHtml) => {
  element.innerHTML = innerHtml;
  return element;
};
const html = (strings, ...args) => pipe(
  document.createElement("template"),
  (template) => majElementInnerHtml(template)(args.reduce(
    (prev, value, i2) => prev + value + strings[i2 + 1],
    strings[0]
  )),
  (template) => template.content
);
export {
  Ra as R,
  recupereElementsAvecSelecteur as a,
  recupereElementAvecSelecteur as b,
  recupereElementsOuLeve as c,
  everyU as d,
  equal as e,
  some$1 as f,
  values as g,
  html as h,
  fromArray as i,
  get$1 as j,
  forEachU as k,
  reduceU as l,
  mapU as m,
  append as n,
  nullable_to_opt as o,
  concat$1 as p,
  recupereElementOuLeve as r,
  someU as s,
  unsafeDeleteKey as u,
  valFromOption as v
};
//# sourceMappingURL=dom2.js.map