2369 lines
54 KiB
JavaScript
2369 lines
54 KiB
JavaScript
// Metro module 4389 (f4390).
|
|
function $mk74411($env) {
|
|
return function optional() {
|
|
let env25064;
|
|
let env25065;
|
|
const r0 = $env.$parent;
|
|
const r2 = $env[0];
|
|
const r6 = env25064 = {
|
|
$parent: r0
|
|
};
|
|
env25064[0] = r2;
|
|
const r3 = {};
|
|
r3[r0[1]] = $mk74417(r6);
|
|
const r4 = env25065 = {
|
|
$parent: r0
|
|
};
|
|
env25065[0] = r3;
|
|
return Object.assign(r3, {
|
|
optional: $mk74411(r4),
|
|
and: $mk74412(r4),
|
|
or: $mk74413(r4),
|
|
select: $mk74414(r4)
|
|
});
|
|
};
|
|
}
|
|
function $mk74412($env) {
|
|
return function and(a0) {
|
|
return (0, $env.$parent[12])($env[0], a0);
|
|
};
|
|
}
|
|
function $mk74413($env) {
|
|
return function or(a0) {
|
|
return (0, $env.$parent[13])($env[0], a0);
|
|
};
|
|
}
|
|
function $mk74414($env) {
|
|
return function select(a0) {
|
|
const r2 = $env;
|
|
return a0 === void 0 ? (0, $env.$parent[14])(r2[0]) : (0, $env.$parent[14])(a0, r2[0]);
|
|
};
|
|
}
|
|
function $mk74415($env) {
|
|
return function optional() {
|
|
let env25066;
|
|
let env25067;
|
|
let env25068;
|
|
let env25069;
|
|
const r0 = $env.$parent;
|
|
const r2 = $env[0];
|
|
const r9 = env25066 = {
|
|
$parent: r0
|
|
};
|
|
env25066[0] = r2;
|
|
const r4 = {};
|
|
r4[r0[1]] = $mk74417(r9);
|
|
const r5 = env25067 = {
|
|
$parent: r0
|
|
};
|
|
env25067[0] = r4;
|
|
const r17 = Object.assign(r4, {
|
|
optional: $mk74411(r5),
|
|
and: $mk74412(r5),
|
|
or: $mk74413(r5),
|
|
select: $mk74414(r5)
|
|
});
|
|
const r18 = env25068 = {
|
|
$parent: r0
|
|
};
|
|
env25068[0] = r17;
|
|
const r19 = Object;
|
|
const r7 = env25069 = {
|
|
$parent: r0
|
|
};
|
|
env25069[0] = r17;
|
|
const r21 = Object;
|
|
const r23 = {};
|
|
r23[Symbol.iterator] = $mk103755(r7);
|
|
return r19.assign(r21.assign(r17, r23), {
|
|
optional: $mk74415(r18),
|
|
select: $mk74416(r18)
|
|
});
|
|
};
|
|
}
|
|
function $mk74416($env) {
|
|
return function select(a0) {
|
|
const r2 = $env;
|
|
const r1 = $env.$parent;
|
|
const r7 = a0 === void 0 ? (0, r1[14])(r2[0]) : (0, r1[14])(a0, r2[0]);
|
|
let env25070;
|
|
let env25071;
|
|
const r12 = env25070 = {
|
|
$parent: r1
|
|
};
|
|
env25070[0] = r7;
|
|
const r13 = Object;
|
|
const r8 = env25071 = {
|
|
$parent: r1
|
|
};
|
|
env25071[0] = r7;
|
|
const r6 = Object;
|
|
const r16 = {};
|
|
r16[Symbol.iterator] = $mk103755(r8);
|
|
return r13.assign(r6.assign(r7, r16), {
|
|
optional: $mk74415(r12),
|
|
select: $mk74416(r12)
|
|
});
|
|
};
|
|
}
|
|
function $mk74417($env) {
|
|
return function() {
|
|
const r1 = $env;
|
|
return {
|
|
match: $mk103756(r1),
|
|
getSelectionKeys: $mk103757(r1),
|
|
matcherType: "optional"
|
|
};
|
|
};
|
|
}
|
|
function $mk74420($env) {
|
|
return function() {
|
|
return {
|
|
match: $mk103762($env)
|
|
};
|
|
};
|
|
}
|
|
function $mk74427($env) {
|
|
return function(a0, a1) {
|
|
return a0.concat((0, $env[0])(a1));
|
|
};
|
|
}
|
|
function $mk74428($env) {
|
|
return function startsWith(c25072_0) {
|
|
let env25073;
|
|
let env25074;
|
|
let env25075;
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r10 = $env[0];
|
|
const r11 = env25073 = {};
|
|
env25073[0] = function(a0) {
|
|
return typeof a0 === "string" ? a0.startsWith(c25072_0) : typeof a0 === "string";
|
|
};
|
|
const r13 = {};
|
|
r13[r2[1]] = $mk74420(r11);
|
|
const r7 = r4(r10, r13);
|
|
const r15 = env25074 = {
|
|
$parent: r2
|
|
};
|
|
env25074[0] = r7;
|
|
const r17 = Object;
|
|
const r8 = env25075 = {
|
|
$parent: r2
|
|
};
|
|
env25075[0] = r7;
|
|
return r17.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
startsWith: $mk74428(r15),
|
|
endsWith: $mk74429(r15),
|
|
minLength: $mk74430(r15),
|
|
maxLength: $mk74431(r15),
|
|
includes: $mk74432(r15),
|
|
regex: $mk74433(r15)
|
|
});
|
|
};
|
|
}
|
|
function $mk74429($env) {
|
|
return function endsWith(c25076_0) {
|
|
let env25077;
|
|
let env25078;
|
|
let env25079;
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r10 = $env[0];
|
|
const r11 = env25077 = {};
|
|
env25077[0] = function(a0) {
|
|
return typeof a0 === "string" ? a0.endsWith(c25076_0) : typeof a0 === "string";
|
|
};
|
|
const r13 = {};
|
|
r13[r2[1]] = $mk74420(r11);
|
|
const r7 = r4(r10, r13);
|
|
const r15 = env25078 = {
|
|
$parent: r2
|
|
};
|
|
env25078[0] = r7;
|
|
const r17 = Object;
|
|
const r8 = env25079 = {
|
|
$parent: r2
|
|
};
|
|
env25079[0] = r7;
|
|
return r17.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
startsWith: $mk74428(r15),
|
|
endsWith: $mk74429(r15),
|
|
minLength: $mk74430(r15),
|
|
maxLength: $mk74431(r15),
|
|
includes: $mk74432(r15),
|
|
regex: $mk74433(r15)
|
|
});
|
|
};
|
|
}
|
|
function $mk74430($env) {
|
|
return function minLength(c25080_0) {
|
|
let env25081;
|
|
let env25082;
|
|
let env25083;
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
const r11 = env25081 = {};
|
|
env25081[0] = function(a0) {
|
|
return typeof a0 === "string" ? a0.length >= c25080_0 : typeof a0 === "string";
|
|
};
|
|
const r13 = {};
|
|
r13[r2[1]] = $mk74420(r11);
|
|
const r7 = r4(r3, r13);
|
|
const r15 = env25082 = {
|
|
$parent: r2
|
|
};
|
|
env25082[0] = r7;
|
|
const r17 = Object;
|
|
const r8 = env25083 = {
|
|
$parent: r2
|
|
};
|
|
env25083[0] = r7;
|
|
return r17.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
startsWith: $mk74428(r15),
|
|
endsWith: $mk74429(r15),
|
|
minLength: $mk74430(r15),
|
|
maxLength: $mk74431(r15),
|
|
includes: $mk74432(r15),
|
|
regex: $mk74433(r15)
|
|
});
|
|
};
|
|
}
|
|
function $mk74431($env) {
|
|
return function maxLength(c25084_0) {
|
|
let env25085;
|
|
let env25086;
|
|
let env25087;
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
const r11 = env25085 = {};
|
|
env25085[0] = function(a0) {
|
|
return typeof a0 === "string" ? a0.length <= c25084_0 : typeof a0 === "string";
|
|
};
|
|
const r13 = {};
|
|
r13[r2[1]] = $mk74420(r11);
|
|
const r7 = r4(r3, r13);
|
|
const r15 = env25086 = {
|
|
$parent: r2
|
|
};
|
|
env25086[0] = r7;
|
|
const r17 = Object;
|
|
const r8 = env25087 = {
|
|
$parent: r2
|
|
};
|
|
env25087[0] = r7;
|
|
return r17.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
startsWith: $mk74428(r15),
|
|
endsWith: $mk74429(r15),
|
|
minLength: $mk74430(r15),
|
|
maxLength: $mk74431(r15),
|
|
includes: $mk74432(r15),
|
|
regex: $mk74433(r15)
|
|
});
|
|
};
|
|
}
|
|
function $mk74432($env) {
|
|
return function includes(c25088_0) {
|
|
let env25089;
|
|
let env25090;
|
|
let env25091;
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r10 = $env[0];
|
|
const r11 = env25089 = {};
|
|
env25089[0] = function(a0) {
|
|
return typeof a0 === "string" ? a0.includes(c25088_0) : typeof a0 === "string";
|
|
};
|
|
const r13 = {};
|
|
r13[r2[1]] = $mk74420(r11);
|
|
const r7 = r4(r10, r13);
|
|
const r15 = env25090 = {
|
|
$parent: r2
|
|
};
|
|
env25090[0] = r7;
|
|
const r17 = Object;
|
|
const r8 = env25091 = {
|
|
$parent: r2
|
|
};
|
|
env25091[0] = r7;
|
|
return r17.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
startsWith: $mk74428(r15),
|
|
endsWith: $mk74429(r15),
|
|
minLength: $mk74430(r15),
|
|
maxLength: $mk74431(r15),
|
|
includes: $mk74432(r15),
|
|
regex: $mk74433(r15)
|
|
});
|
|
};
|
|
}
|
|
function $mk74433($env) {
|
|
return function regex(c25092_0) {
|
|
let env25093;
|
|
let env25094;
|
|
let env25095;
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r10 = $env[0];
|
|
const r11 = env25093 = {};
|
|
env25093[0] = function(a0) {
|
|
return typeof a0 === "string" ? Boolean(a0.match(c25092_0)) : typeof a0 === "string";
|
|
};
|
|
const r13 = {};
|
|
r13[r2[1]] = $mk74420(r11);
|
|
const r7 = r4(r10, r13);
|
|
const r15 = env25094 = {
|
|
$parent: r2
|
|
};
|
|
env25094[0] = r7;
|
|
const r17 = Object;
|
|
const r8 = env25095 = {
|
|
$parent: r2
|
|
};
|
|
env25095[0] = r7;
|
|
return r17.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
startsWith: $mk74428(r15),
|
|
endsWith: $mk74429(r15),
|
|
minLength: $mk74430(r15),
|
|
maxLength: $mk74431(r15),
|
|
includes: $mk74432(r15),
|
|
regex: $mk74433(r15)
|
|
});
|
|
};
|
|
}
|
|
function $mk74434($env) {
|
|
return function(a0) {
|
|
const r2 = $env;
|
|
return (typeof a0 === "number" ? r2[0] <= a0 : typeof a0 === "number") && r2[1] >= a0;
|
|
};
|
|
}
|
|
function $mk74435($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? a0 < $env[0] : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74436($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? a0 > $env[0] : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74437($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? a0 <= $env[0] : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74438($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? a0 >= $env[0] : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74439() {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? Number.isInteger(a0) : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74440() {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? Number.isFinite(a0) : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74441() {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? a0 > 0 : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74442() {
|
|
return function(a0) {
|
|
return typeof a0 === "number" ? a0 < 0 : typeof a0 === "number";
|
|
};
|
|
}
|
|
function $mk74443($env) {
|
|
return function between(a0, a1) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25096;
|
|
let env25097;
|
|
let env25098;
|
|
let env25099;
|
|
const r14 = env25096 = {};
|
|
env25096[0] = a0;
|
|
env25096[1] = a1;
|
|
const r15 = env25097 = {};
|
|
env25097[0] = $mk74434(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r20 = env25098 = {
|
|
$parent: r2
|
|
};
|
|
env25098[0] = r7;
|
|
const r22 = Object;
|
|
const r8 = env25099 = {
|
|
$parent: r2
|
|
};
|
|
env25099[0] = r7;
|
|
return r22.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r20),
|
|
lt: $mk74444(r20),
|
|
gt: $mk74445(r20),
|
|
lte: $mk74446(r20),
|
|
gte: $mk74447(r20),
|
|
int: $mk74448(r20),
|
|
finite: $mk74449(r20),
|
|
positive: $mk74450(r20),
|
|
negative: $mk74451(r20)
|
|
});
|
|
};
|
|
}
|
|
function $mk74444($env) {
|
|
return function lt(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25100;
|
|
let env25101;
|
|
let env25102;
|
|
let env25103;
|
|
const r14 = env25100 = {};
|
|
env25100[0] = a0;
|
|
const r15 = env25101 = {};
|
|
env25101[0] = $mk74435(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25102 = {
|
|
$parent: r2
|
|
};
|
|
env25102[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25103 = {
|
|
$parent: r2
|
|
};
|
|
env25103[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r19),
|
|
lt: $mk74444(r19),
|
|
gt: $mk74445(r19),
|
|
lte: $mk74446(r19),
|
|
gte: $mk74447(r19),
|
|
int: $mk74448(r19),
|
|
finite: $mk74449(r19),
|
|
positive: $mk74450(r19),
|
|
negative: $mk74451(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74445($env) {
|
|
return function gt(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25104;
|
|
let env25105;
|
|
let env25106;
|
|
let env25107;
|
|
const r14 = env25104 = {};
|
|
env25104[0] = a0;
|
|
const r15 = env25105 = {};
|
|
env25105[0] = $mk74436(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25106 = {
|
|
$parent: r2
|
|
};
|
|
env25106[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25107 = {
|
|
$parent: r2
|
|
};
|
|
env25107[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r19),
|
|
lt: $mk74444(r19),
|
|
gt: $mk74445(r19),
|
|
lte: $mk74446(r19),
|
|
gte: $mk74447(r19),
|
|
int: $mk74448(r19),
|
|
finite: $mk74449(r19),
|
|
positive: $mk74450(r19),
|
|
negative: $mk74451(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74446($env) {
|
|
return function lte(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25108;
|
|
let env25109;
|
|
let env25110;
|
|
let env25111;
|
|
const r14 = env25108 = {};
|
|
env25108[0] = a0;
|
|
const r15 = env25109 = {};
|
|
env25109[0] = $mk74437(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25110 = {
|
|
$parent: r2
|
|
};
|
|
env25110[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25111 = {
|
|
$parent: r2
|
|
};
|
|
env25111[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r19),
|
|
lt: $mk74444(r19),
|
|
gt: $mk74445(r19),
|
|
lte: $mk74446(r19),
|
|
gte: $mk74447(r19),
|
|
int: $mk74448(r19),
|
|
finite: $mk74449(r19),
|
|
positive: $mk74450(r19),
|
|
negative: $mk74451(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74447($env) {
|
|
return function gte(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25112;
|
|
let env25113;
|
|
let env25114;
|
|
let env25115;
|
|
const r14 = env25112 = {};
|
|
env25112[0] = a0;
|
|
const r15 = env25113 = {};
|
|
env25113[0] = $mk74438(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25114 = {
|
|
$parent: r2
|
|
};
|
|
env25114[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25115 = {
|
|
$parent: r2
|
|
};
|
|
env25115[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r19),
|
|
lt: $mk74444(r19),
|
|
gt: $mk74445(r19),
|
|
lte: $mk74446(r19),
|
|
gte: $mk74447(r19),
|
|
int: $mk74448(r19),
|
|
finite: $mk74449(r19),
|
|
positive: $mk74450(r19),
|
|
negative: $mk74451(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74448($env) {
|
|
return function int() {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25116;
|
|
let env25117;
|
|
let env25118;
|
|
const r5 = env25116 = {};
|
|
env25116[0] = $mk74439();
|
|
const r15 = {};
|
|
r15[r2[1]] = $mk74420(r5);
|
|
const r7 = r4(r3, r15);
|
|
const r17 = env25117 = {
|
|
$parent: r2
|
|
};
|
|
env25117[0] = r7;
|
|
const r19 = Object;
|
|
const r8 = env25118 = {
|
|
$parent: r2
|
|
};
|
|
env25118[0] = r7;
|
|
return r19.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r17),
|
|
lt: $mk74444(r17),
|
|
gt: $mk74445(r17),
|
|
lte: $mk74446(r17),
|
|
gte: $mk74447(r17),
|
|
int: $mk74448(r17),
|
|
finite: $mk74449(r17),
|
|
positive: $mk74450(r17),
|
|
negative: $mk74451(r17)
|
|
});
|
|
};
|
|
}
|
|
function $mk74449($env) {
|
|
return function finite() {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25119;
|
|
let env25120;
|
|
let env25121;
|
|
const r5 = env25119 = {};
|
|
env25119[0] = $mk74440();
|
|
const r15 = {};
|
|
r15[r2[1]] = $mk74420(r5);
|
|
const r7 = r4(r3, r15);
|
|
const r17 = env25120 = {
|
|
$parent: r2
|
|
};
|
|
env25120[0] = r7;
|
|
const r19 = Object;
|
|
const r8 = env25121 = {
|
|
$parent: r2
|
|
};
|
|
env25121[0] = r7;
|
|
return r19.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r17),
|
|
lt: $mk74444(r17),
|
|
gt: $mk74445(r17),
|
|
lte: $mk74446(r17),
|
|
gte: $mk74447(r17),
|
|
int: $mk74448(r17),
|
|
finite: $mk74449(r17),
|
|
positive: $mk74450(r17),
|
|
negative: $mk74451(r17)
|
|
});
|
|
};
|
|
}
|
|
function $mk74450($env) {
|
|
return function positive() {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25122;
|
|
let env25123;
|
|
let env25124;
|
|
const r5 = env25122 = {};
|
|
env25122[0] = $mk74441();
|
|
const r15 = {};
|
|
r15[r2[1]] = $mk74420(r5);
|
|
const r7 = r4(r3, r15);
|
|
const r17 = env25123 = {
|
|
$parent: r2
|
|
};
|
|
env25123[0] = r7;
|
|
const r19 = Object;
|
|
const r8 = env25124 = {
|
|
$parent: r2
|
|
};
|
|
env25124[0] = r7;
|
|
return r19.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r17),
|
|
lt: $mk74444(r17),
|
|
gt: $mk74445(r17),
|
|
lte: $mk74446(r17),
|
|
gte: $mk74447(r17),
|
|
int: $mk74448(r17),
|
|
finite: $mk74449(r17),
|
|
positive: $mk74450(r17),
|
|
negative: $mk74451(r17)
|
|
});
|
|
};
|
|
}
|
|
function $mk74451($env) {
|
|
return function negative() {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25125;
|
|
let env25126;
|
|
let env25127;
|
|
const r5 = env25125 = {};
|
|
env25125[0] = $mk74442();
|
|
const r15 = {};
|
|
r15[r2[1]] = $mk74420(r5);
|
|
const r7 = r4(r3, r15);
|
|
const r17 = env25126 = {
|
|
$parent: r2
|
|
};
|
|
env25126[0] = r7;
|
|
const r19 = Object;
|
|
const r8 = env25127 = {
|
|
$parent: r2
|
|
};
|
|
env25127[0] = r7;
|
|
return r19.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74443(r17),
|
|
lt: $mk74444(r17),
|
|
gt: $mk74445(r17),
|
|
lte: $mk74446(r17),
|
|
gte: $mk74447(r17),
|
|
int: $mk74448(r17),
|
|
finite: $mk74449(r17),
|
|
positive: $mk74450(r17),
|
|
negative: $mk74451(r17)
|
|
});
|
|
};
|
|
}
|
|
function $mk74452($env) {
|
|
return function(a0) {
|
|
const r2 = $env;
|
|
return (typeof a0 === "bigint" ? r2[0] <= a0 : typeof a0 === "bigint") && r2[1] >= a0;
|
|
};
|
|
}
|
|
function $mk74453($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "bigint" ? a0 < $env[0] : typeof a0 === "bigint";
|
|
};
|
|
}
|
|
function $mk74454($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "bigint" ? a0 > $env[0] : typeof a0 === "bigint";
|
|
};
|
|
}
|
|
function $mk74455($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "bigint" ? a0 <= $env[0] : typeof a0 === "bigint";
|
|
};
|
|
}
|
|
function $mk74456($env) {
|
|
return function(a0) {
|
|
return typeof a0 === "bigint" ? a0 >= $env[0] : typeof a0 === "bigint";
|
|
};
|
|
}
|
|
function $mk74457() {
|
|
return function(a0) {
|
|
return typeof a0 === "bigint" ? a0 > 0 : typeof a0 === "bigint";
|
|
};
|
|
}
|
|
function $mk74458() {
|
|
return function(a0) {
|
|
return typeof a0 === "bigint" ? a0 < 0 : typeof a0 === "bigint";
|
|
};
|
|
}
|
|
function $mk74459($env) {
|
|
return function between(a0, a1) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25128;
|
|
let env25129;
|
|
let env25130;
|
|
let env25131;
|
|
const r14 = env25128 = {};
|
|
env25128[0] = a0;
|
|
env25128[1] = a1;
|
|
const r15 = env25129 = {};
|
|
env25129[0] = $mk74452(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r20 = env25130 = {
|
|
$parent: r2
|
|
};
|
|
env25130[0] = r7;
|
|
const r22 = Object;
|
|
const r8 = env25131 = {
|
|
$parent: r2
|
|
};
|
|
env25131[0] = r7;
|
|
return r22.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r20),
|
|
lt: $mk74460(r20),
|
|
gt: $mk74461(r20),
|
|
lte: $mk74462(r20),
|
|
gte: $mk74463(r20),
|
|
positive: $mk74464(r20),
|
|
negative: $mk74465(r20)
|
|
});
|
|
};
|
|
}
|
|
function $mk74460($env) {
|
|
return function lt(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25132;
|
|
let env25133;
|
|
let env25134;
|
|
let env25135;
|
|
const r14 = env25132 = {};
|
|
env25132[0] = a0;
|
|
const r15 = env25133 = {};
|
|
env25133[0] = $mk74453(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25134 = {
|
|
$parent: r2
|
|
};
|
|
env25134[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25135 = {
|
|
$parent: r2
|
|
};
|
|
env25135[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r19),
|
|
lt: $mk74460(r19),
|
|
gt: $mk74461(r19),
|
|
lte: $mk74462(r19),
|
|
gte: $mk74463(r19),
|
|
positive: $mk74464(r19),
|
|
negative: $mk74465(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74461($env) {
|
|
return function gt(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25136;
|
|
let env25137;
|
|
let env25138;
|
|
let env25139;
|
|
const r14 = env25136 = {};
|
|
env25136[0] = a0;
|
|
const r15 = env25137 = {};
|
|
env25137[0] = $mk74454(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25138 = {
|
|
$parent: r2
|
|
};
|
|
env25138[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25139 = {
|
|
$parent: r2
|
|
};
|
|
env25139[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r19),
|
|
lt: $mk74460(r19),
|
|
gt: $mk74461(r19),
|
|
lte: $mk74462(r19),
|
|
gte: $mk74463(r19),
|
|
positive: $mk74464(r19),
|
|
negative: $mk74465(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74462($env) {
|
|
return function lte(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25140;
|
|
let env25141;
|
|
let env25142;
|
|
let env25143;
|
|
const r14 = env25140 = {};
|
|
env25140[0] = a0;
|
|
const r15 = env25141 = {};
|
|
env25141[0] = $mk74455(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25142 = {
|
|
$parent: r2
|
|
};
|
|
env25142[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25143 = {
|
|
$parent: r2
|
|
};
|
|
env25143[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r19),
|
|
lt: $mk74460(r19),
|
|
gt: $mk74461(r19),
|
|
lte: $mk74462(r19),
|
|
gte: $mk74463(r19),
|
|
positive: $mk74464(r19),
|
|
negative: $mk74465(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74463($env) {
|
|
return function gte(a0) {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25144;
|
|
let env25145;
|
|
let env25146;
|
|
let env25147;
|
|
const r14 = env25144 = {};
|
|
env25144[0] = a0;
|
|
const r15 = env25145 = {};
|
|
env25145[0] = $mk74456(r14);
|
|
const r17 = {};
|
|
r17[r2[1]] = $mk74420(r15);
|
|
const r7 = r4(r3, r17);
|
|
const r19 = env25146 = {
|
|
$parent: r2
|
|
};
|
|
env25146[0] = r7;
|
|
const r21 = Object;
|
|
const r8 = env25147 = {
|
|
$parent: r2
|
|
};
|
|
env25147[0] = r7;
|
|
return r21.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r19),
|
|
lt: $mk74460(r19),
|
|
gt: $mk74461(r19),
|
|
lte: $mk74462(r19),
|
|
gte: $mk74463(r19),
|
|
positive: $mk74464(r19),
|
|
negative: $mk74465(r19)
|
|
});
|
|
};
|
|
}
|
|
function $mk74464($env) {
|
|
return function positive() {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25148;
|
|
let env25149;
|
|
let env25150;
|
|
const r5 = env25148 = {};
|
|
env25148[0] = $mk74457();
|
|
const r15 = {};
|
|
r15[r2[1]] = $mk74420(r5);
|
|
const r7 = r4(r3, r15);
|
|
const r17 = env25149 = {
|
|
$parent: r2
|
|
};
|
|
env25149[0] = r7;
|
|
const r19 = Object;
|
|
const r8 = env25150 = {
|
|
$parent: r2
|
|
};
|
|
env25150[0] = r7;
|
|
return r19.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r17),
|
|
lt: $mk74460(r17),
|
|
gt: $mk74461(r17),
|
|
lte: $mk74462(r17),
|
|
gte: $mk74463(r17),
|
|
positive: $mk74464(r17),
|
|
negative: $mk74465(r17)
|
|
});
|
|
};
|
|
}
|
|
function $mk74465($env) {
|
|
return function negative() {
|
|
const r2 = $env.$parent;
|
|
const r4 = r2[12];
|
|
const r3 = $env[0];
|
|
let env25151;
|
|
let env25152;
|
|
let env25153;
|
|
const r5 = env25151 = {};
|
|
env25151[0] = $mk74458();
|
|
const r15 = {};
|
|
r15[r2[1]] = $mk74420(r5);
|
|
const r7 = r4(r3, r15);
|
|
const r17 = env25152 = {
|
|
$parent: r2
|
|
};
|
|
env25152[0] = r7;
|
|
const r19 = Object;
|
|
const r8 = env25153 = {
|
|
$parent: r2
|
|
};
|
|
env25153[0] = r7;
|
|
return r19.assign(Object.assign(r7, {
|
|
optional: $mk74411(r8),
|
|
and: $mk74412(r8),
|
|
or: $mk74413(r8),
|
|
select: $mk74414(r8)
|
|
}), {
|
|
between: $mk74459(r17),
|
|
lt: $mk74460(r17),
|
|
gt: $mk74461(r17),
|
|
lte: $mk74462(r17),
|
|
gte: $mk74463(r17),
|
|
positive: $mk74464(r17),
|
|
negative: $mk74465(r17)
|
|
});
|
|
};
|
|
}
|
|
function $mk103755($env) {
|
|
return function() {
|
|
let env29320 = {
|
|
$parent: $env
|
|
};
|
|
const r3 = regeneratorRuntime;
|
|
const r5 = function t() {
|
|
const r3 = regeneratorRuntime;
|
|
const r1 = env29320[0];
|
|
let env31342 = {
|
|
$parent: env29320.$parent
|
|
};
|
|
return r3.wrap(function(a0) {
|
|
while (true) {
|
|
const next = a0.next;
|
|
a0.prev = next;
|
|
if (next === 0) {
|
|
a0.next = 2;
|
|
const r6 = Object;
|
|
const r15 = env31342.$parent[0];
|
|
const r8 = {};
|
|
env31342[0] = r8;
|
|
r8[env31342.$parent.$parent[2]] = true;
|
|
return r6.assign(r15, env31342[0]);
|
|
}
|
|
if (next !== 2 && next !== "end") {
|
|
continue;
|
|
}
|
|
return a0.stop();
|
|
}
|
|
}, r1);
|
|
};
|
|
env29320[0] = r5;
|
|
return r3.mark(r5)();
|
|
};
|
|
}
|
|
function $mk103756($env) {
|
|
return function match(a0) {
|
|
let r1;
|
|
const r4 = $env;
|
|
const selections2 = {};
|
|
let c29321_0 = selections2;
|
|
if (a0 === void 0) {
|
|
(0, $env.$parent[7])(r4[0]).forEach(function(item) {
|
|
c29321_0[item] = void 0;
|
|
});
|
|
r1 = {
|
|
matched: true,
|
|
selections: selections2
|
|
};
|
|
} else {
|
|
r1 = {
|
|
matched: (0, $env.$parent[6])(r4[0], a0, function r(a0, a1) {
|
|
c29321_0[a0] = a1;
|
|
}),
|
|
selections: selections2
|
|
};
|
|
}
|
|
return r1;
|
|
};
|
|
}
|
|
function $mk103757($env) {
|
|
return function getSelectionKeys() {
|
|
return (0, $env.$parent[7])($env[0]);
|
|
};
|
|
}
|
|
function $mk103762($env) {
|
|
return function match(a0) {
|
|
return {
|
|
matched: Boolean((0, $env[0])(a0))
|
|
};
|
|
};
|
|
}
|
|
let s2, p2, y, b, c2603_1, c2603_2, c2603_3, i, o2, n2, n3, n4, n5, f, g, m, c2604_0, c2605_0, S, c2607_0, c2608_0, B, I, E, K, T, k, P, _, M, w, c2610_0, c2611_0, N, z, _L, R, U, C, F, j, c2613_0, c2614_0, c2615_0, c2616_0, c2617_0, c2618_0, c2619_0, c2620_0, c2603_31, n7;
|
|
let env2603;
|
|
let env2604;
|
|
let env2605;
|
|
let env2606;
|
|
let env2607;
|
|
let env2608;
|
|
let env2609;
|
|
let env2610;
|
|
let env2611;
|
|
let env2612;
|
|
let env2613;
|
|
let env2614;
|
|
let env2615;
|
|
let env2616;
|
|
let env2617;
|
|
let env2618;
|
|
let env2619;
|
|
let env2620;
|
|
let n6;
|
|
const r2 = env2603 = {};
|
|
const t2 = function t(a0, a1) {
|
|
let r21, r36;
|
|
let c14165_0 = a0;
|
|
const Symbol2 = globalThis.Symbol;
|
|
const r4 = (typeof Symbol2 !== "undefined" ? a0[Symbol.iterator] : typeof Symbol2 !== "undefined") || a0["@@iterator"];
|
|
if (r4) {
|
|
const r69 = r4.call(a0);
|
|
return r69.next.bind(r69);
|
|
}
|
|
L31: {
|
|
const isArray = Array.isArray(a0);
|
|
r21 = r4;
|
|
if (!isArray) {
|
|
let r10 = void 0;
|
|
if (a0) {
|
|
if (typeof a0 === "string") {
|
|
const length2 = a0.length;
|
|
const array3 = new Array(length2);
|
|
let r54 = 0;
|
|
const r55 = 0 < length2;
|
|
r10 = array3;
|
|
if (r55) {
|
|
do {
|
|
array3[r54] = a0[r54];
|
|
r54 = r54 + 1;
|
|
r10 = array3;
|
|
} while (r54 < length2);
|
|
}
|
|
} else {
|
|
const r26 = Object.prototype.toString.call(a0).slice(8, -1);
|
|
const r13 = r26 === "Object" && a0.constructor ? a0.constructor.name : r26;
|
|
L23: {
|
|
if (r13 !== "Map" && r13 !== "Set") {
|
|
if (r13 !== "Arguments") {
|
|
const r35 = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r13);
|
|
r36 = void 0;
|
|
if (!r35) {
|
|
break L23;
|
|
}
|
|
}
|
|
const length = a0.length;
|
|
const array2 = new Array(length);
|
|
let r42 = 0;
|
|
const r3 = 0 < length;
|
|
r36 = array2;
|
|
if (!r3) {
|
|
break L23;
|
|
}
|
|
do {
|
|
array2[r42] = a0[r42];
|
|
r42 = r42 + 1;
|
|
r36 = array2;
|
|
} while (r42 < length);
|
|
} else {
|
|
r36 = Array.from(a0);
|
|
}
|
|
}
|
|
r10 = r36;
|
|
}
|
|
}
|
|
r21 = r10;
|
|
if (!r10) {
|
|
if (a1 && a0) {
|
|
const length3 = a0.length;
|
|
r21 = r10;
|
|
if (typeof length3 === "number") {
|
|
break L31;
|
|
}
|
|
}
|
|
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
}
|
|
}
|
|
if (r21) {
|
|
c14165_0 = r21;
|
|
}
|
|
let c14165_1 = 0;
|
|
return function() {
|
|
let r8;
|
|
const r1 = c14165_1;
|
|
if (r1 >= c14165_0.length) {
|
|
r8 = {
|
|
done: true
|
|
};
|
|
} else {
|
|
const r6 = +c14165_1;
|
|
c14165_1 = r6 + 1;
|
|
r8 = {
|
|
done: false,
|
|
value: c14165_0[r6]
|
|
};
|
|
}
|
|
return r8;
|
|
};
|
|
};
|
|
s2 = function() {
|
|
const r13 = [].slice.call(arguments);
|
|
if (r13.length === 1) {
|
|
let c14166_0 = r13[0];
|
|
return function(a0) {
|
|
return n3(c14166_0, a0, function() {});
|
|
};
|
|
}
|
|
if (r13.length === 2) {
|
|
return n3(r13[0], r13[1], function() {});
|
|
}
|
|
throw new Error("isMatching wasn't given the right number of arguments: expected 1 or 2, received " + r13.length + ".");
|
|
};
|
|
p2 = function() {
|
|
const r9 = [].slice.call(arguments);
|
|
let env14170;
|
|
let c14169_0 = r9;
|
|
const r13 = {};
|
|
r13[c2603_1] = function() {
|
|
return {
|
|
match: function match(c29322_0) {
|
|
const selections2 = {};
|
|
let c29322_1 = selections2;
|
|
let c29322_2 = function r(a0, a1) {
|
|
c29322_1[a0] = a1;
|
|
};
|
|
return {
|
|
matched: c14169_0.every(function(item) {
|
|
return n3(item, c29322_0, c29322_2);
|
|
}),
|
|
selections: selections2
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
let env29323;
|
|
const r8 = env29323 = {};
|
|
env29323[0] = n5;
|
|
return c14169_0.reduce($mk74427(r8), []);
|
|
},
|
|
matcherType: "and"
|
|
};
|
|
};
|
|
const r5 = env14170 = {
|
|
$parent: env2603
|
|
};
|
|
env14170[0] = r13;
|
|
return Object.assign(r13, {
|
|
optional: $mk74411(r5),
|
|
and: $mk74412(r5),
|
|
or: $mk74413(r5),
|
|
select: $mk74414(r5)
|
|
});
|
|
};
|
|
y = function y() {
|
|
const r9 = [].slice.call(arguments);
|
|
let env14172;
|
|
let c14171_0 = r9;
|
|
const r13 = {};
|
|
r13[c2603_1] = function() {
|
|
return {
|
|
match: function match(c29324_0) {
|
|
const selections2 = {};
|
|
let c29324_1 = selections2;
|
|
let c29324_2 = function r(a0, a1) {
|
|
c29324_1[a0] = a1;
|
|
};
|
|
let env29325;
|
|
const r13 = env29325 = {};
|
|
env29325[0] = n5;
|
|
c14171_0.reduce($mk74427(r13), []).forEach(function(item) {
|
|
c29324_1[item] = void 0;
|
|
});
|
|
return {
|
|
matched: c14171_0.some(function(item) {
|
|
return n3(item, c29324_0, c29324_2);
|
|
}),
|
|
selections: selections2
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
let env29326;
|
|
const r8 = env29326 = {};
|
|
env29326[0] = n5;
|
|
return c14171_0.reduce($mk74427(r8), []);
|
|
},
|
|
matcherType: "or"
|
|
};
|
|
};
|
|
const r5 = env14172 = {
|
|
$parent: env2603
|
|
};
|
|
env14172[0] = r13;
|
|
return Object.assign(r13, {
|
|
optional: $mk74411(r5),
|
|
and: $mk74412(r5),
|
|
or: $mk74413(r5),
|
|
select: $mk74414(r5)
|
|
});
|
|
};
|
|
b = function b() {
|
|
const r9 = [].slice.call(arguments);
|
|
const r12 = typeof r9[0] === "string" ? r9[0] : void 0;
|
|
let c14174_0 = r12;
|
|
const r3 = r9.length === 2 ? r9[1] : typeof r9[0] !== "string" ? r9[0] : void 0;
|
|
let env14175;
|
|
let c14174_1 = r3;
|
|
const r17 = {};
|
|
r17[c2603_1] = function() {
|
|
return {
|
|
match: function match(a0) {
|
|
let r4 = c14174_0;
|
|
if (r4 == null) {
|
|
r4 = c2603_3;
|
|
}
|
|
const selections2 = {};
|
|
selections2[r4] = a0;
|
|
let c29327_0 = selections2;
|
|
return {
|
|
matched: c14174_1 === void 0 || n3(c14174_1, a0, function(a0, a1) {
|
|
c29327_0[a0] = a1;
|
|
}),
|
|
selections: selections2
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
let r2 = c14174_0;
|
|
if (r2 == null) {
|
|
r2 = c2603_3;
|
|
}
|
|
const r5 = [r2];
|
|
return r5.concat(c14174_1 === void 0 ? [] : n5(c14174_1));
|
|
}
|
|
};
|
|
};
|
|
const r20 = env14175 = {
|
|
$parent: env2603
|
|
};
|
|
env14175[0] = r17;
|
|
return Object.assign(r17, {
|
|
optional: $mk74411(r20),
|
|
and: $mk74412(r20),
|
|
or: $mk74413(r20),
|
|
select: $mk74414(r20)
|
|
});
|
|
};
|
|
c2603_1 = Symbol.for("@ts-pattern/matcher");
|
|
c2603_2 = Symbol.for("@ts-pattern/isVariadic");
|
|
c2603_3 = "@ts-pattern/anonymous-select-key";
|
|
i = function i(a0) {};
|
|
o2 = function(a0) {};
|
|
n2 = function n(a0, a1, a2) {
|
|
let done;
|
|
let selections, c14176_4, c14176_5;
|
|
if (a0 ? !!a0[c2603_1] : a0) {
|
|
const r120 = a0[c2603_1]().match(a1);
|
|
const matched = r120.matched;
|
|
selections = r120.selections;
|
|
if (matched && selections) {
|
|
Object.keys(selections).forEach(function(item) {
|
|
return a2(item, selections[item]);
|
|
});
|
|
}
|
|
return matched;
|
|
}
|
|
if (Boolean(a0 ? typeof a0 === "object" : a0)) {
|
|
if (Boolean(a1 ? typeof a1 === "object" : a1)) {
|
|
if (Array.isArray(a0)) {
|
|
if (Array.isArray(a1)) {
|
|
const r11 = [];
|
|
const r14 = [];
|
|
const r51 = [];
|
|
const r12 = t2(a0.keys());
|
|
let r55 = r12();
|
|
if (!r55.done) {
|
|
do {
|
|
const r15 = a0[r55.value];
|
|
if (r15 && !!r15[c2603_1] && r15[c2603_2]) {
|
|
r51.push(r15);
|
|
} else if (r51.length) {
|
|
r14.push(r15);
|
|
} else {
|
|
r11.push(r15);
|
|
}
|
|
const r73 = r12();
|
|
done = r73.done;
|
|
r55 = r73;
|
|
} while (!done);
|
|
}
|
|
if (r51.length) {
|
|
if (r51.length > 1) {
|
|
throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
|
|
}
|
|
if (a1.length < r11.length + r14.length) {
|
|
return false;
|
|
}
|
|
c14176_4 = a1.slice(0, r11.length);
|
|
c14176_5 = r14.length === 0 ? [] : a1.slice(-r14.length);
|
|
const r100 = a1.slice.call(a1, r11.length, r14.length !== 0 ? -r14.length : Infinity);
|
|
return r11.every(function(item, index) {
|
|
return n2(item, c14176_4[index], a2);
|
|
}) && r14.every(function(item, index) {
|
|
return n2(item, c14176_5[index], a2);
|
|
}) && (r51.length === 0 || n2(r51[0], r100, a2));
|
|
}
|
|
return a0.length === a1.length && a0.every(function(item, index) {
|
|
return n2(item, a1[index], a2);
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
return Object.keys(a0).every(function(item) {
|
|
const r5 = a0[item];
|
|
return (item in a1 || r5 && !!r5[c2603_1] && r5[c2603_1]().matcherType === "optional") && n2(r5, a1[item], a2);
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
return Object.is(a1, a0);
|
|
};
|
|
n3 = n2;
|
|
n4 = function n(a0) {
|
|
let r16, r34;
|
|
if (Boolean(a0 ? typeof a0 === "object" : a0)) {
|
|
if (a0 ? !!a0[c2603_1] : a0) {
|
|
const r44 = a0[c2603_1]();
|
|
const getSelectionKeys2 = r44.getSelectionKeys;
|
|
let r47 = getSelectionKeys2 == null ? void 0 : getSelectionKeys2.call(r44);
|
|
if (r47 == null) {
|
|
r47 = [];
|
|
}
|
|
r34 = r47;
|
|
} else {
|
|
const isArray = Array.isArray(a0);
|
|
if (isArray) {
|
|
let env14178;
|
|
const r38 = env14178 = {};
|
|
env14178[0] = n4;
|
|
r34 = a0.reduce($mk74427(r38), []);
|
|
} else {
|
|
const r10 = Object.values(a0);
|
|
let env14177;
|
|
const r31 = env14177 = {};
|
|
env14177[0] = n4;
|
|
r34 = r10.reduce($mk74427(r31), []);
|
|
}
|
|
}
|
|
r16 = r34;
|
|
} else {
|
|
r16 = [];
|
|
}
|
|
return r16;
|
|
};
|
|
n5 = n4;
|
|
f = function f(a0, a1) {};
|
|
g = function g(a0, a1) {};
|
|
m = function m(a0, a1) {};
|
|
const r51 = env2604 = {};
|
|
c2604_0 = function(a0) {
|
|
return true;
|
|
};
|
|
const r9 = {};
|
|
r9[c2603_1] = $mk74420(r51);
|
|
const r10 = env2605 = {
|
|
$parent: r2
|
|
};
|
|
c2605_0 = r9;
|
|
const any = Object.assign(r9, {
|
|
optional: $mk74411(r10),
|
|
and: $mk74412(r10),
|
|
or: $mk74413(r10),
|
|
select: $mk74414(r10)
|
|
});
|
|
const r60 = env2606 = {};
|
|
S = function S(a0) {
|
|
return typeof a0 === "string";
|
|
};
|
|
const r12 = {};
|
|
r12[c2603_1] = $mk74420(r60);
|
|
const r63 = env2607 = {
|
|
$parent: r2
|
|
};
|
|
c2607_0 = r12;
|
|
const r64 = Object;
|
|
const r13 = env2608 = {
|
|
$parent: r2
|
|
};
|
|
c2608_0 = r12;
|
|
const string = r64.assign(Object.assign(r12, {
|
|
optional: $mk74411(r13),
|
|
and: $mk74412(r13),
|
|
or: $mk74413(r13),
|
|
select: $mk74414(r13)
|
|
}), {
|
|
startsWith: $mk74428(r63),
|
|
endsWith: $mk74429(r63),
|
|
minLength: $mk74430(r63),
|
|
maxLength: $mk74431(r63),
|
|
includes: $mk74432(r63),
|
|
regex: $mk74433(r63)
|
|
});
|
|
B = function B(a0, a1) {
|
|
let env14179;
|
|
let env14180;
|
|
const r0 = env14179 = {};
|
|
env14179[0] = a0;
|
|
env14179[1] = a1;
|
|
const r4 = env14180 = {};
|
|
env14180[0] = $mk74434(r0);
|
|
const r6 = {};
|
|
r6[c2603_1] = $mk74420(r4);
|
|
return r6;
|
|
};
|
|
I = function I(a0) {
|
|
let env14181;
|
|
let env14182;
|
|
const r0 = env14181 = {};
|
|
env14181[0] = a0;
|
|
const r3 = env14182 = {};
|
|
env14182[0] = $mk74435(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
E = function E(a0) {
|
|
let env14183;
|
|
let env14184;
|
|
const r0 = env14183 = {};
|
|
env14183[0] = a0;
|
|
const r3 = env14184 = {};
|
|
env14184[0] = $mk74436(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
K = function K(a0) {
|
|
let env14185;
|
|
let env14186;
|
|
const r0 = env14185 = {};
|
|
env14185[0] = a0;
|
|
const r3 = env14186 = {};
|
|
env14186[0] = $mk74437(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
T = function T(a0) {
|
|
let env14187;
|
|
let env14188;
|
|
const r0 = env14187 = {};
|
|
env14187[0] = a0;
|
|
const r3 = env14188 = {};
|
|
env14188[0] = $mk74438(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
k = function k() {
|
|
let env14189;
|
|
const r2 = env14189 = {};
|
|
env14189[0] = $mk74439();
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r2);
|
|
return r4;
|
|
};
|
|
P = function P() {
|
|
let env14190;
|
|
const r2 = env14190 = {};
|
|
env14190[0] = $mk74440();
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r2);
|
|
return r4;
|
|
};
|
|
_ = function _() {
|
|
let env14191;
|
|
const r2 = env14191 = {};
|
|
env14191[0] = $mk74441();
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r2);
|
|
return r4;
|
|
};
|
|
M = function M() {
|
|
let env14192;
|
|
const r2 = env14192 = {};
|
|
env14192[0] = $mk74442();
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r2);
|
|
return r4;
|
|
};
|
|
const r80 = env2609 = {};
|
|
w = function w(a0) {
|
|
return typeof a0 === "number";
|
|
};
|
|
const r82 = {};
|
|
r82[c2603_1] = $mk74420(r80);
|
|
const r84 = env2610 = {
|
|
$parent: r2
|
|
};
|
|
c2610_0 = r82;
|
|
const r85 = Object;
|
|
const r87 = env2611 = {
|
|
$parent: r2
|
|
};
|
|
c2611_0 = r82;
|
|
const number = r85.assign(Object.assign(r82, {
|
|
optional: $mk74411(r87),
|
|
and: $mk74412(r87),
|
|
or: $mk74413(r87),
|
|
select: $mk74414(r87)
|
|
}), {
|
|
between: $mk74443(r84),
|
|
lt: $mk74444(r84),
|
|
gt: $mk74445(r84),
|
|
lte: $mk74446(r84),
|
|
gte: $mk74447(r84),
|
|
int: $mk74448(r84),
|
|
finite: $mk74449(r84),
|
|
positive: $mk74450(r84),
|
|
negative: $mk74451(r84)
|
|
});
|
|
N = function N(a0, a1) {
|
|
let env14193;
|
|
let env14194;
|
|
const r0 = env14193 = {};
|
|
env14193[0] = a0;
|
|
env14193[1] = a1;
|
|
const r4 = env14194 = {};
|
|
env14194[0] = $mk74452(r0);
|
|
const r6 = {};
|
|
r6[c2603_1] = $mk74420(r4);
|
|
return r6;
|
|
};
|
|
z = function z(a0) {
|
|
let env14195;
|
|
let env14196;
|
|
const r0 = env14195 = {};
|
|
env14195[0] = a0;
|
|
const r3 = env14196 = {};
|
|
env14196[0] = $mk74453(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
_L = function L(a0) {
|
|
let env14197;
|
|
let env14198;
|
|
const r0 = env14197 = {};
|
|
env14197[0] = a0;
|
|
const r3 = env14198 = {};
|
|
env14198[0] = $mk74454(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
R = function R(a0) {
|
|
let env14199;
|
|
let env14200;
|
|
const r0 = env14199 = {};
|
|
env14199[0] = a0;
|
|
const r3 = env14200 = {};
|
|
env14200[0] = $mk74455(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
U = function U(a0) {
|
|
let env14201;
|
|
let env14202;
|
|
const r0 = env14201 = {};
|
|
env14201[0] = a0;
|
|
const r3 = env14202 = {};
|
|
env14202[0] = $mk74456(r0);
|
|
const r5 = {};
|
|
r5[c2603_1] = $mk74420(r3);
|
|
return r5;
|
|
};
|
|
C = function C() {
|
|
let env14203;
|
|
const r2 = env14203 = {};
|
|
env14203[0] = $mk74457();
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r2);
|
|
return r4;
|
|
};
|
|
F = function F() {
|
|
let env14204;
|
|
const r2 = env14204 = {};
|
|
env14204[0] = $mk74458();
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r2);
|
|
return r4;
|
|
};
|
|
const r111 = env2612 = {};
|
|
j = function j(a0) {
|
|
return typeof a0 === "bigint";
|
|
};
|
|
const r35 = {};
|
|
r35[c2603_1] = $mk74420(r111);
|
|
const r33 = env2613 = {
|
|
$parent: r2
|
|
};
|
|
c2613_0 = r35;
|
|
const r114 = Object;
|
|
const r36 = env2614 = {
|
|
$parent: r2
|
|
};
|
|
c2614_0 = r35;
|
|
const bigint = r114.assign(Object.assign(r35, {
|
|
optional: $mk74411(r36),
|
|
and: $mk74412(r36),
|
|
or: $mk74413(r36),
|
|
select: $mk74414(r36)
|
|
}), {
|
|
between: $mk74459(r33),
|
|
lt: $mk74460(r33),
|
|
gt: $mk74461(r33),
|
|
lte: $mk74462(r33),
|
|
gte: $mk74463(r33),
|
|
positive: $mk74464(r33),
|
|
negative: $mk74465(r33)
|
|
});
|
|
const r131 = env2615 = {};
|
|
c2615_0 = function(a0) {
|
|
return typeof a0 === "boolean";
|
|
};
|
|
const r133 = {};
|
|
r133[c2603_1] = $mk74420(r131);
|
|
const r135 = env2616 = {
|
|
$parent: r2
|
|
};
|
|
c2616_0 = r133;
|
|
const boolean = Object.assign(r133, {
|
|
optional: $mk74411(r135),
|
|
and: $mk74412(r135),
|
|
or: $mk74413(r135),
|
|
select: $mk74414(r135)
|
|
});
|
|
const r144 = env2617 = {};
|
|
c2617_0 = function(a0) {
|
|
return typeof a0 === "symbol";
|
|
};
|
|
const r146 = {};
|
|
r146[c2603_1] = $mk74420(r144);
|
|
const r148 = env2618 = {
|
|
$parent: r2
|
|
};
|
|
c2618_0 = r146;
|
|
const symbol = Object.assign(r146, {
|
|
optional: $mk74411(r148),
|
|
and: $mk74412(r148),
|
|
or: $mk74413(r148),
|
|
select: $mk74414(r148)
|
|
});
|
|
const r157 = env2619 = {};
|
|
c2619_0 = function(a0) {
|
|
return a0 == null;
|
|
};
|
|
const r159 = {};
|
|
r159[c2603_1] = $mk74420(r157);
|
|
const r161 = env2620 = {
|
|
$parent: r2
|
|
};
|
|
c2620_0 = r159;
|
|
const nullish = Object.assign(r159, {
|
|
optional: $mk74411(r161),
|
|
and: $mk74412(r161),
|
|
or: $mk74413(r161),
|
|
select: $mk74414(r161)
|
|
});
|
|
const r170 = {
|
|
__proto__: null,
|
|
matcher: c2603_1,
|
|
optional: null,
|
|
array: null,
|
|
set: null,
|
|
map: null,
|
|
intersection: null,
|
|
union: null,
|
|
not: null,
|
|
when: null,
|
|
select: null,
|
|
any: null,
|
|
_: null,
|
|
string: null,
|
|
between: null,
|
|
lt: null,
|
|
gt: null,
|
|
lte: null,
|
|
gte: null,
|
|
int: null,
|
|
finite: null,
|
|
positive: null,
|
|
negative: null,
|
|
number: null,
|
|
betweenBigInt: null,
|
|
ltBigInt: null,
|
|
gtBigInt: null,
|
|
lteBigInt: null,
|
|
gteBigInt: null,
|
|
positiveBigInt: null,
|
|
negativeBigInt: null,
|
|
bigint: null,
|
|
boolean: null,
|
|
symbol: null,
|
|
nullish: null,
|
|
instanceOf: null,
|
|
shape: null
|
|
};
|
|
r170.optional = function v(a0) {
|
|
let env14167;
|
|
let env14168;
|
|
const r0 = env14167 = {
|
|
$parent: env2603
|
|
};
|
|
env14167[0] = a0;
|
|
const r3 = {};
|
|
r3[c2603_1] = $mk74417(r0);
|
|
const r4 = env14168 = {
|
|
$parent: env2603
|
|
};
|
|
env14168[0] = r3;
|
|
return Object.assign(r3, {
|
|
optional: $mk74411(r4),
|
|
and: $mk74412(r4),
|
|
or: $mk74413(r4),
|
|
select: $mk74414(r4)
|
|
});
|
|
};
|
|
r170.array = function array() {
|
|
const r12 = [].slice.call(arguments);
|
|
let env14206;
|
|
let env14207;
|
|
let c14205_0 = r12;
|
|
const r7 = {};
|
|
r7[c2603_1] = function() {
|
|
return {
|
|
match: function match(a0) {
|
|
if (Array.isArray(a0)) {
|
|
if (c14205_0.length === 0) {
|
|
return {
|
|
matched: true
|
|
};
|
|
}
|
|
let c29328_2;
|
|
const r5 = c14205_0[0];
|
|
let c29328_0 = r5;
|
|
const selections2 = {};
|
|
let c29328_1 = selections2;
|
|
if (a0.length === 0) {
|
|
n5(r5).forEach(function(item) {
|
|
c29328_1[item] = [];
|
|
});
|
|
return {
|
|
matched: true,
|
|
selections: selections2
|
|
};
|
|
}
|
|
c29328_2 = function u(a0, a1) {
|
|
c29328_1[a0] = (c29328_1[a0] || []).concat([a1]);
|
|
};
|
|
return {
|
|
matched: a0.every(function(item) {
|
|
return n3(c29328_0, item, c29328_2);
|
|
}),
|
|
selections: selections2
|
|
};
|
|
}
|
|
return {
|
|
matched: false
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
return c14205_0.length === 0 ? [] : n5(c14205_0[0]);
|
|
}
|
|
};
|
|
};
|
|
const r5 = env14206 = {
|
|
$parent: env2603
|
|
};
|
|
env14206[0] = r7;
|
|
const r18 = Object;
|
|
const r8 = env14207 = {
|
|
$parent: env2603
|
|
};
|
|
env14207[0] = r7;
|
|
const r6 = Object;
|
|
const r21 = {};
|
|
r21[Symbol.iterator] = $mk103755(r8);
|
|
return r18.assign(r6.assign(r7, r21), {
|
|
optional: $mk74415(r5),
|
|
select: $mk74416(r5)
|
|
});
|
|
};
|
|
r170.set = function set() {
|
|
const r9 = [].slice.call(arguments);
|
|
let env14209;
|
|
let c14208_0 = r9;
|
|
const r13 = {};
|
|
r13[c2603_1] = function() {
|
|
return {
|
|
match: function match(a0) {
|
|
let done2;
|
|
if (a0 instanceof Set) {
|
|
const selections2 = {};
|
|
let c29329_0 = selections2;
|
|
if (a0.size === 0) {
|
|
return {
|
|
matched: true,
|
|
selections: selections2
|
|
};
|
|
}
|
|
if (c14208_0.length === 0) {
|
|
return {
|
|
matched: true
|
|
};
|
|
}
|
|
const r10 = function r(a0, a1) {
|
|
c29329_0[a0] = (c29329_0[a0] || []).concat([a1]);
|
|
};
|
|
const r21 = c14208_0[0];
|
|
const r25 = t2(a0);
|
|
let r26 = r25();
|
|
const done = r26.done;
|
|
let matched = true;
|
|
if (!done) {
|
|
do {
|
|
const r30 = n3(r21, r26.value, r10);
|
|
matched = false;
|
|
if (!r30) {
|
|
break;
|
|
}
|
|
const r31 = r25();
|
|
done2 = r31.done;
|
|
r26 = r31;
|
|
matched = true;
|
|
} while (!done2);
|
|
}
|
|
return {
|
|
matched,
|
|
selections: selections2
|
|
};
|
|
}
|
|
return {
|
|
matched: false
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
return c14208_0.length === 0 ? [] : n5(c14208_0[0]);
|
|
}
|
|
};
|
|
};
|
|
const r5 = env14209 = {
|
|
$parent: env2603
|
|
};
|
|
env14209[0] = r13;
|
|
return Object.assign(r13, {
|
|
optional: $mk74411(r5),
|
|
and: $mk74412(r5),
|
|
or: $mk74413(r5),
|
|
select: $mk74414(r5)
|
|
});
|
|
};
|
|
r170.map = function map() {
|
|
const r9 = [].slice.call(arguments);
|
|
let env14211;
|
|
let c14210_0 = r9;
|
|
const r13 = {};
|
|
r13[c2603_1] = function() {
|
|
return {
|
|
match: function match(a0) {
|
|
let done2;
|
|
if (a0 instanceof Map) {
|
|
const selections2 = {};
|
|
let c29330_0 = selections2;
|
|
if (a0.size === 0) {
|
|
return {
|
|
matched: true,
|
|
selections: selections2
|
|
};
|
|
}
|
|
const r13 = function u(a0, a1) {
|
|
c29330_0[a0] = (c29330_0[a0] || []).concat([a1]);
|
|
};
|
|
if (c14210_0.length === 0) {
|
|
return {
|
|
matched: true
|
|
};
|
|
}
|
|
if (c14210_0.length === 1) {
|
|
const r43 = Error;
|
|
const r44 = c14210_0[0];
|
|
throw new r43("`P.map` wasn't given enough arguments. Expected (key, value), received " + (r44 == null ? void 0 : r44.toString()));
|
|
}
|
|
const r12 = c14210_0[0];
|
|
const r11 = c14210_0[1];
|
|
const r32 = t2(a0.entries());
|
|
let r33 = r32();
|
|
const done = r33.done;
|
|
let matched = true;
|
|
if (!done) {
|
|
do {
|
|
const value = r33.value;
|
|
const r16 = value[1];
|
|
const r37 = value[0];
|
|
let r38 = n3(r12, r37, r13);
|
|
const r39 = n3(r11, r16, r13);
|
|
if (r38) {
|
|
r38 = r39;
|
|
}
|
|
matched = false;
|
|
if (!r38) {
|
|
break;
|
|
}
|
|
const r40 = r32();
|
|
done2 = r40.done;
|
|
r33 = r40;
|
|
matched = true;
|
|
} while (!done2);
|
|
}
|
|
return {
|
|
matched,
|
|
selections: selections2
|
|
};
|
|
}
|
|
return {
|
|
matched: false
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
let r13;
|
|
if (c14210_0.length === 0) {
|
|
r13 = [];
|
|
} else {
|
|
const r5 = [];
|
|
r13 = r5.concat(n5(c14210_0[0]), n5(c14210_0[1]));
|
|
}
|
|
return r13;
|
|
}
|
|
};
|
|
};
|
|
const r5 = env14211 = {
|
|
$parent: env2603
|
|
};
|
|
env14211[0] = r13;
|
|
return Object.assign(r13, {
|
|
optional: $mk74411(r5),
|
|
and: $mk74412(r5),
|
|
or: $mk74413(r5),
|
|
select: $mk74414(r5)
|
|
});
|
|
};
|
|
r170.intersection = p2;
|
|
r170.union = y;
|
|
r170.not = function not(c14212_0) {
|
|
let env14213;
|
|
const r3 = {};
|
|
r3[c2603_1] = function() {
|
|
return {
|
|
match: function match(a0) {
|
|
return {
|
|
matched: !n3(c14212_0, a0, function() {})
|
|
};
|
|
},
|
|
getSelectionKeys: function getSelectionKeys() {
|
|
return [];
|
|
},
|
|
matcherType: "not"
|
|
};
|
|
};
|
|
const r4 = env14213 = {
|
|
$parent: env2603
|
|
};
|
|
env14213[0] = r3;
|
|
return Object.assign(r3, {
|
|
optional: $mk74411(r4),
|
|
and: $mk74412(r4),
|
|
or: $mk74413(r4),
|
|
select: $mk74414(r4)
|
|
});
|
|
};
|
|
r170.when = function d(a0) {
|
|
let env14173;
|
|
const r1 = env14173 = {};
|
|
env14173[0] = a0;
|
|
const r3 = {};
|
|
r3[c2603_1] = $mk74420(r1);
|
|
return r3;
|
|
};
|
|
r170.select = b;
|
|
r170.any = any;
|
|
r170._ = any;
|
|
r170.string = string;
|
|
r170.between = B;
|
|
r170.lt = I;
|
|
r170.gt = E;
|
|
r170.lte = K;
|
|
r170.gte = T;
|
|
r170.int = k;
|
|
r170.finite = P;
|
|
r170.positive = _;
|
|
r170.negative = M;
|
|
r170.number = number;
|
|
r170.betweenBigInt = N;
|
|
r170.ltBigInt = z;
|
|
r170.gtBigInt = _L;
|
|
r170.lteBigInt = R;
|
|
r170.gteBigInt = U;
|
|
r170.positiveBigInt = C;
|
|
r170.negativeBigInt = F;
|
|
r170.bigint = bigint;
|
|
r170.boolean = boolean;
|
|
r170.symbol = symbol;
|
|
r170.nullish = nullish;
|
|
r170.instanceOf = function instanceOf(c14214_0) {
|
|
let env14215;
|
|
let env14216;
|
|
const r6 = env14215 = {};
|
|
env14215[0] = function(a0) {
|
|
return a0 instanceof c14214_0;
|
|
};
|
|
const r3 = {};
|
|
r3[c2603_1] = $mk74420(r6);
|
|
const r4 = env14216 = {
|
|
$parent: env2603
|
|
};
|
|
env14216[0] = r3;
|
|
return Object.assign(r3, {
|
|
optional: $mk74411(r4),
|
|
and: $mk74412(r4),
|
|
or: $mk74413(r4),
|
|
select: $mk74414(r4)
|
|
});
|
|
};
|
|
r170.shape = function shape(a0) {
|
|
let env14217;
|
|
let env14218;
|
|
const r7 = s2(a0);
|
|
const r8 = env14217 = {};
|
|
env14217[0] = r7;
|
|
const r4 = {};
|
|
r4[c2603_1] = $mk74420(r8);
|
|
const r5 = env14218 = {
|
|
$parent: env2603
|
|
};
|
|
env14218[0] = r4;
|
|
return Object.assign(r4, {
|
|
optional: $mk74411(r5),
|
|
and: $mk74412(r5),
|
|
or: $mk74413(r5),
|
|
select: $mk74414(r5)
|
|
});
|
|
};
|
|
c2603_31 = {
|
|
matched: false,
|
|
value: void 0
|
|
};
|
|
n6 = function n(a0, a1) {
|
|
this.input = void 0;
|
|
this.state = void 0;
|
|
this.input = a0;
|
|
this.state = a1;
|
|
};
|
|
const prototype = n6.prototype;
|
|
prototype.with = function() {
|
|
let r11, r50, state;
|
|
let c25154_1, c25154_2, c25154_3;
|
|
const _this = this;
|
|
const r17 = [].slice.call(arguments);
|
|
if (this.state.matched) {
|
|
return this;
|
|
}
|
|
const r22 = r17[r17.length - 1];
|
|
const r12 = [r17[0]];
|
|
if (r17.length === 3 && typeof r17[1] === "function") {
|
|
r12.push(r17[0]);
|
|
r11 = r17[1];
|
|
} else {
|
|
const r3 = r17.length > 2;
|
|
r11 = void 0;
|
|
if (r3) {
|
|
r12.push.apply(r12, r17.slice(1, r17.length - 1));
|
|
r11 = void 0;
|
|
}
|
|
}
|
|
L19: {
|
|
L12: {
|
|
c25154_1 = false;
|
|
const r38 = {};
|
|
c25154_2 = r38;
|
|
c25154_3 = function(a0, a1) {
|
|
c25154_1 = true;
|
|
c25154_2[a0] = a1;
|
|
};
|
|
if (r12.some(function(item) {
|
|
return n3(item, _this.input, c25154_3);
|
|
})) {
|
|
if (r11 && !Boolean(r11(this.input))) {
|
|
break L12;
|
|
}
|
|
if (c25154_1) {
|
|
r50 = c2603_3 in r38 ? r38[c2603_3] : r38;
|
|
} else {
|
|
r50 = this.input;
|
|
}
|
|
state = {
|
|
matched: true,
|
|
value: r22(r50, this.input)
|
|
};
|
|
break L19;
|
|
}
|
|
}
|
|
state = c2603_31;
|
|
}
|
|
const input = this.input;
|
|
const r61 = {
|
|
__proto__: n6.prototype
|
|
};
|
|
r61.input = void 0;
|
|
r61.state = void 0;
|
|
r61.input = input;
|
|
r61.state = state;
|
|
return r61;
|
|
};
|
|
prototype.when = function(a0, a1) {
|
|
if (this.state.matched) {
|
|
return this;
|
|
}
|
|
const r13 = Boolean(a0(this.input));
|
|
const input = this.input;
|
|
const state = r13 ? {
|
|
matched: true,
|
|
value: a1(this.input, this.input)
|
|
} : c2603_31;
|
|
const r21 = {
|
|
__proto__: n6.prototype
|
|
};
|
|
r21.input = void 0;
|
|
r21.state = void 0;
|
|
r21.input = input;
|
|
r21.state = state;
|
|
return r21;
|
|
};
|
|
prototype.otherwise = function(a0) {
|
|
return this.state.matched ? this.state.value : a0(this.input);
|
|
};
|
|
prototype.exhaustive = function() {
|
|
return this.run();
|
|
};
|
|
prototype.run = function() {
|
|
let r10;
|
|
if (this.state.matched) {
|
|
return this.state.value;
|
|
}
|
|
try {
|
|
r10 = JSON.stringify(this.input);
|
|
} catch ($e) {
|
|
r10 = this.input;
|
|
}
|
|
throw new Error("Pattern matching error: no pattern matches value " + r10);
|
|
};
|
|
prototype.returnType = function() {
|
|
return this;
|
|
};
|
|
n7 = n6;
|
|
export { r170 as P };
|
|
export { r170 as Pattern };
|
|
export { s2 as isMatching };
|
|
export const match = function(a0) {
|
|
const state = c2603_31;
|
|
const r6 = Object.create(n7.prototype);
|
|
r6.input = void 0;
|
|
r6.state = void 0;
|
|
r6.input = a0;
|
|
r6.state = state;
|
|
return r6;
|
|
};
|