2062 lines
40 KiB
JavaScript
2062 lines
40 KiB
JavaScript
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
|