1148 lines
28 KiB
JavaScript
1148 lines
28 KiB
JavaScript
// Module ID: 4330
|
|
// Function ID: 38029
|
|
// Name: n
|
|
// Dependencies: [4331]
|
|
// Exports: match
|
|
|
|
// Module 4330 (n)
|
|
import _regeneratorRuntime from "_regeneratorRuntime";
|
|
|
|
function n(arg0, arg1) {
|
|
let length;
|
|
if (tmp) {
|
|
length = arg0.length;
|
|
}
|
|
const array = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
array[num] = arg0[num];
|
|
}
|
|
return array;
|
|
}
|
|
function t(iterable) {
|
|
let closure_0 = iterable;
|
|
iterable = "undefined" !== typeof Symbol;
|
|
if (iterable) {
|
|
const _Symbol = Symbol;
|
|
iterable = iterable[Symbol.iterator];
|
|
}
|
|
if (!iterable) {
|
|
iterable = iterable[Symbol.iterator];
|
|
}
|
|
if (iterable) {
|
|
const iter = iterable.call(iterable);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = iterable;
|
|
if (!Array.isArray(iterable)) {
|
|
let tmp2;
|
|
if (iterable) {
|
|
if ("string" === typeof iterable) {
|
|
tmp2 = n(iterable, undefined);
|
|
} else {
|
|
const _Object = Object;
|
|
const substr = toString.call(iterable).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = iterable.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = n(iterable, undefined);
|
|
} else {
|
|
let obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(iterable);
|
|
const callResult = toString.call(iterable);
|
|
tmp3 = "Object" === substr && iterable.constructor;
|
|
}
|
|
}
|
|
tmp = tmp2;
|
|
if (!tmp2) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (tmp) {
|
|
closure_0 = tmp;
|
|
}
|
|
let c1 = 0;
|
|
return () => {
|
|
if (closure_1 >= length.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = length[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
let fn = function s() {
|
|
const slice = [].slice;
|
|
const callResult = slice.call(arguments);
|
|
if (1 === callResult.length) {
|
|
let closure_0 = callResult[0];
|
|
return (arg0) => outer1_6(closure_0, arg0, () => {
|
|
|
|
});
|
|
} else if (2 === callResult.length) {
|
|
return fn10(callResult[0], callResult[1], () => {
|
|
|
|
});
|
|
} else {
|
|
const _Error = Error;
|
|
const error = new Error("isMatching wasn't given the right number of arguments: expected 1 or 2, received " + callResult.length + ".");
|
|
throw error;
|
|
}
|
|
};
|
|
const fn2 = function l(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(arg0, {
|
|
optional() {
|
|
return outer1_34(closure_0);
|
|
},
|
|
and(arg0) {
|
|
return outer1_35(closure_0, arg0);
|
|
},
|
|
or(arg0) {
|
|
return outer1_36(closure_0, arg0);
|
|
},
|
|
select(arg0) {
|
|
if (undefined === arg0) {
|
|
let tmp3 = outer1_38(closure_0);
|
|
} else {
|
|
tmp3 = outer1_38(arg0, closure_0);
|
|
}
|
|
return tmp3;
|
|
}
|
|
});
|
|
};
|
|
function h(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(((arg0) => {
|
|
let closure_0 = arg0;
|
|
return Object.assign(arg0, {
|
|
[Symbol.iterator]: () => {
|
|
const fn = function t() {
|
|
return closure_0.wrap((next) => {
|
|
next = next.next;
|
|
next.prev = next;
|
|
while (0 !== next) {
|
|
return next.stop();
|
|
}
|
|
next.next = 2;
|
|
const obj = {};
|
|
obj[outer4_2] = true;
|
|
return Object.assign(fn, obj);
|
|
}, fn);
|
|
};
|
|
return closure_0.mark(fn)();
|
|
}
|
|
});
|
|
})(arg0), {
|
|
optional() {
|
|
return outer1_33(outer1_34(closure_0));
|
|
},
|
|
select(arg0) {
|
|
if (undefined === arg0) {
|
|
let tmp4 = outer1_38(closure_0);
|
|
} else {
|
|
tmp4 = outer1_38(arg0, closure_0);
|
|
}
|
|
return outer1_33(tmp4);
|
|
}
|
|
});
|
|
}
|
|
const fn3 = function v(arg0) {
|
|
let closure_0 = arg0;
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
let obj = {};
|
|
const fn = function r(arg0, arg1) {
|
|
obj[arg0] = arg1;
|
|
};
|
|
if (undefined === arg0) {
|
|
const item = outer2_7(outer1_0).forEach((prototype) => {
|
|
fn(prototype, undefined);
|
|
});
|
|
obj = { matched: true };
|
|
obj.selections = obj;
|
|
const arr = outer2_7(outer1_0);
|
|
} else {
|
|
obj = { matched: outer2_6(outer1_0, arg0, fn) };
|
|
obj.selections = obj;
|
|
}
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
return outer2_7(outer1_0);
|
|
},
|
|
matcherType: "optional"
|
|
})
|
|
});
|
|
};
|
|
const fn4 = function p() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
let closure_0 = arg0;
|
|
let obj = {};
|
|
function r(arg0, arg1) {
|
|
obj[arg0] = arg1;
|
|
}
|
|
obj = { matched: outer1_0.every((arg0) => outer3_6(arg0, closure_0, r)), selections: obj };
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
return outer2_8(outer1_0, outer2_7);
|
|
},
|
|
matcherType: "and"
|
|
})
|
|
});
|
|
};
|
|
const fn5 = function y() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
let closure_0 = arg0;
|
|
let obj = {};
|
|
function r(arg0, arg1) {
|
|
obj[arg0] = arg1;
|
|
}
|
|
const item = outer2_8(outer1_0, outer2_7).forEach((arg0) => {
|
|
r(arg0, undefined);
|
|
});
|
|
obj = { matched: outer1_0.some((arg0) => outer3_6(arg0, closure_0, r)), selections: obj };
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
return outer2_8(outer1_0, outer2_7);
|
|
},
|
|
matcherType: "or"
|
|
})
|
|
});
|
|
};
|
|
const fn6 = function d(S) {
|
|
let closure_0 = S;
|
|
return {
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
return { matched: Boolean(outer1_0(arg0)) };
|
|
}
|
|
})
|
|
};
|
|
};
|
|
const fn7 = function b() {
|
|
const slice = [].slice;
|
|
const callResult = slice.call(arguments);
|
|
let first;
|
|
if ("string" === typeof callResult[0]) {
|
|
first = callResult[0];
|
|
}
|
|
if (2 === callResult.length) {
|
|
let first1 = callResult[1];
|
|
} else if ("string" !== typeof callResult[0]) {
|
|
first1 = callResult[0];
|
|
}
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
let obj = { [null != outer1_0 ? outer1_0 : outer2_3]: arg0 };
|
|
obj = {};
|
|
let tmp = undefined === outer1_1;
|
|
if (!tmp) {
|
|
tmp = outer2_6(outer1_1, arg0, (arg0, arg1) => {
|
|
obj[arg0] = arg1;
|
|
});
|
|
}
|
|
obj.matched = tmp;
|
|
obj.selections = obj;
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
const items = [null != outer1_0 ? outer1_0 : outer2_3];
|
|
if (undefined === outer1_1) {
|
|
let items1 = [];
|
|
} else {
|
|
items1 = outer2_7(outer1_1);
|
|
}
|
|
return items.concat(items1);
|
|
}
|
|
})
|
|
});
|
|
};
|
|
const fn8 = function w(arg0) {
|
|
return "number" === typeof arg0;
|
|
};
|
|
class S {
|
|
constructor(arg0) {
|
|
return "string" === typeof global;
|
|
}
|
|
}
|
|
let closure_40 = S;
|
|
const fn9 = function j(arg0) {
|
|
return "bigint" === typeof arg0;
|
|
};
|
|
const forResult = Symbol.for("@ts-pattern/matcher");
|
|
let closure_2 = Symbol.for("@ts-pattern/isVariadic");
|
|
let c3 = "@ts-pattern/anonymous-select-key";
|
|
function i(arg0) {
|
|
let tmp = arg0;
|
|
if (arg0) {
|
|
tmp = "object" === typeof arg0;
|
|
}
|
|
return Boolean(tmp);
|
|
}
|
|
function o(arg0) {
|
|
let tmp = arg0;
|
|
if (arg0) {
|
|
tmp = arg0[closure_1];
|
|
}
|
|
return tmp;
|
|
}
|
|
const fn10 = function n(arr, arr2) {
|
|
let matched;
|
|
let selections;
|
|
let closure_0 = arr;
|
|
let closure_1 = arr2;
|
|
let closure_2 = arg2;
|
|
if (items3(arr)) {
|
|
const match = arr[closure_1]().match(arr2);
|
|
({ matched, selections } = match);
|
|
let tmp24 = matched;
|
|
if (matched) {
|
|
tmp24 = selections;
|
|
}
|
|
if (tmp24) {
|
|
const _Object3 = Object;
|
|
const keys = Object.keys(selections);
|
|
const item = keys.forEach((arg0) => callback(arg0, selections[arg0]));
|
|
}
|
|
return matched;
|
|
} else if (i(arr)) {
|
|
if (i(arr2)) {
|
|
const _Array = Array;
|
|
if (Array.isArray(arr)) {
|
|
const _Array2 = Array;
|
|
if (Array.isArray(arr2)) {
|
|
const items = [];
|
|
const items1 = [];
|
|
const items2 = [];
|
|
const tmp6 = t(arr.keys());
|
|
let iter = tmp6();
|
|
if (!iter.done) {
|
|
while (true) {
|
|
let tmp7 = arr[iter.value];
|
|
let tmp8 = items3;
|
|
if (items3(tmp7)) {
|
|
let tmp9 = closure_2;
|
|
if (tmp7[closure_2]) {
|
|
arr = items2.push(tmp7);
|
|
let iter2 = tmp6();
|
|
iter = iter2;
|
|
if (iter2.done) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (items2.length) {
|
|
arr = items1.push(tmp7);
|
|
} else {
|
|
let arr1 = items.push(tmp7);
|
|
}
|
|
}
|
|
}
|
|
if (items2.length) {
|
|
if (items2.length > 1) {
|
|
const _Error = Error;
|
|
const error = new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
|
|
throw error;
|
|
} else if (arr2.length < items.length + items1.length) {
|
|
return false;
|
|
} else {
|
|
i = arr2.slice(0, items.length);
|
|
if (0 === items1.length) {
|
|
items3 = [];
|
|
} else {
|
|
items3 = arr2.slice(-items1.length);
|
|
}
|
|
let num2 = Infinity;
|
|
if (0 !== items1.length) {
|
|
num2 = -items1.length;
|
|
}
|
|
const substr = arr2.slice(items.length, num2);
|
|
let tmp15 = items.every((arg0, arg1) => outer1_42(arg0, table[arg1], closure_2)) && items1.every((arg0, arg1) => outer1_42(arg0, items3[arg1], closure_2));
|
|
if (tmp15) {
|
|
let tmp16 = 0 === items2.length;
|
|
if (!tmp16) {
|
|
tmp16 = fn10(items2[0], substr, arg2);
|
|
}
|
|
tmp15 = tmp16;
|
|
}
|
|
return tmp15;
|
|
}
|
|
} else {
|
|
return arr.length === arr2.length && arr.every((arg0, arg1) => outer1_42(arg0, arr2[arg1], closure_2));
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
const _Object2 = Object;
|
|
const keys1 = Object.keys(arr);
|
|
return keys1.every((arg0) => {
|
|
let tmp2 = arg0 in arr2;
|
|
if (!tmp2) {
|
|
let tmp4 = items3(tmp);
|
|
if (tmp4) {
|
|
tmp4 = "optional" === tmp[arr2]().matcherType;
|
|
}
|
|
tmp2 = tmp4;
|
|
}
|
|
if (tmp2) {
|
|
tmp2 = outer1_42(tmp, arr2[arg0], closure_2);
|
|
}
|
|
return tmp2;
|
|
});
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
const _Object = Object;
|
|
return Object.is(arr2, arr);
|
|
}
|
|
};
|
|
const fn11 = function n(arg0) {
|
|
let tmp = arg0;
|
|
if (i(arg0)) {
|
|
if (o(tmp)) {
|
|
const tmp9 = tmp[closure_1]();
|
|
const getSelectionKeys = tmp9.getSelectionKeys;
|
|
tmp = null == getSelectionKeys;
|
|
let callResult;
|
|
if (!tmp) {
|
|
callResult = getSelectionKeys.call(tmp9);
|
|
}
|
|
if (null == callResult) {
|
|
callResult = [];
|
|
}
|
|
let tmp4Result = callResult;
|
|
} else {
|
|
const _Array = Array;
|
|
if (Array.isArray(tmp)) {
|
|
tmp4Result = tmp4(tmp, fn11);
|
|
} else {
|
|
const _Object = Object;
|
|
tmp4Result = tmp4(Object.values(tmp), fn11);
|
|
}
|
|
}
|
|
} else {
|
|
return [];
|
|
}
|
|
};
|
|
function f(arr) {
|
|
let closure_0 = arg1;
|
|
return arr.reduce((arr) => arr.concat(callback(arg1)), []);
|
|
}
|
|
function g(arg0, arg1) {
|
|
const tmp = t(arg0);
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
while (arg1(iter.value)) {
|
|
let iter2 = tmp();
|
|
iter = iter2;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function m(arr) {
|
|
const tmp = t(arr.entries());
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
const value = iter.value;
|
|
while (arg1(value[1], value[0])) {
|
|
let iter2 = tmp();
|
|
iter = iter2;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
const fn2Result = fn2(fn6((arg0) => true));
|
|
const fn12 = function n(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(fn2(arg0), {
|
|
startsWith(arg0) {
|
|
let closure_0 = arg0;
|
|
return outer1_44(outer1_35(closure_0, outer1_37((str) => {
|
|
let startsWithResult = outer2_40(str);
|
|
if (startsWithResult) {
|
|
startsWithResult = str.startsWith(closure_0);
|
|
}
|
|
return startsWithResult;
|
|
})));
|
|
},
|
|
endsWith(arg0) {
|
|
let closure_0 = arg0;
|
|
return outer1_44(outer1_35(closure_0, outer1_37((str) => {
|
|
let endsWithResult = outer2_40(str);
|
|
if (endsWithResult) {
|
|
endsWithResult = str.endsWith(closure_0);
|
|
}
|
|
return endsWithResult;
|
|
})));
|
|
},
|
|
minLength(minItems, arg1) {
|
|
return outer1_44(outer1_35(closure_0, ((minItems) => {
|
|
let closure_0 = minItems;
|
|
return outer2_37((arg0) => {
|
|
let tmp = outer3_40(arg0);
|
|
if (tmp) {
|
|
tmp = arg0.length >= closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
})(minItems)));
|
|
},
|
|
maxLength(maxItems, arg1) {
|
|
return outer1_44(outer1_35(closure_0, ((maxItems) => {
|
|
let closure_0 = maxItems;
|
|
return outer2_37((arg0) => {
|
|
let tmp = outer3_40(arg0);
|
|
if (tmp) {
|
|
tmp = arg0.length <= closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
})(maxItems)));
|
|
},
|
|
includes(arg0) {
|
|
let closure_0 = arg0;
|
|
return outer1_44(outer1_35(closure_0, outer1_37((arr) => {
|
|
let hasItem = outer2_40(arr);
|
|
if (hasItem) {
|
|
hasItem = arr.includes(closure_0);
|
|
}
|
|
return hasItem;
|
|
})));
|
|
},
|
|
regex(arg0) {
|
|
let closure_0 = arg0;
|
|
return outer1_44(outer1_35(closure_0, outer1_37((str) => {
|
|
let BooleanResult = outer2_40(str);
|
|
if (BooleanResult) {
|
|
const _Boolean = Boolean;
|
|
BooleanResult = Boolean(str.match(closure_0));
|
|
}
|
|
return BooleanResult;
|
|
})));
|
|
}
|
|
});
|
|
};
|
|
class B {
|
|
constructor(arg0, arg1) {
|
|
closure_0 = global;
|
|
closure_1 = require;
|
|
return d((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = closure_0 <= arg0;
|
|
}
|
|
if (tmp) {
|
|
tmp = closure_1 >= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_11 = B;
|
|
class I {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_12 = I;
|
|
class E {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_13 = E;
|
|
class K {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 <= closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_14 = K;
|
|
class T {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 >= closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_15 = T;
|
|
const fn13 = function k() {
|
|
return fn6((arg0) => {
|
|
let isIntegerResult = outer1_39(arg0);
|
|
if (isIntegerResult) {
|
|
const _Number = Number;
|
|
isIntegerResult = Number.isInteger(arg0);
|
|
}
|
|
return isIntegerResult;
|
|
});
|
|
};
|
|
class P {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let isFiniteResult = outer1_39(arg0);
|
|
if (isFiniteResult) {
|
|
const _Number = Number;
|
|
isFiniteResult = Number.isFinite(arg0);
|
|
}
|
|
return isFiniteResult;
|
|
});
|
|
}
|
|
}
|
|
let closure_17 = P;
|
|
const fn14 = function _() {
|
|
return fn6((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
};
|
|
class M {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let tmp = outer1_39(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_19 = M;
|
|
const fn15 = function n(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(fn2(arg0), {
|
|
between(arg0, arg1) {
|
|
return outer1_45(outer1_35(closure_0, outer1_11(arg0, arg1)));
|
|
},
|
|
lt(arg0) {
|
|
return outer1_45(outer1_35(closure_0, outer1_12(arg0)));
|
|
},
|
|
gt(arg0) {
|
|
return outer1_45(outer1_35(closure_0, outer1_13(arg0)));
|
|
},
|
|
lte(arg0) {
|
|
return outer1_45(outer1_35(closure_0, outer1_14(arg0)));
|
|
},
|
|
gte(arg0) {
|
|
return outer1_45(outer1_35(closure_0, outer1_15(arg0)));
|
|
},
|
|
int() {
|
|
return outer1_45(outer1_35(closure_0, outer1_16()));
|
|
},
|
|
finite() {
|
|
return outer1_45(outer1_35(closure_0, outer1_17()));
|
|
},
|
|
positive() {
|
|
return outer1_45(outer1_35(closure_0, outer1_18()));
|
|
},
|
|
negative() {
|
|
return outer1_45(outer1_35(closure_0, outer1_19()));
|
|
}
|
|
});
|
|
};
|
|
class N {
|
|
constructor(arg0, arg1) {
|
|
closure_0 = global;
|
|
closure_1 = require;
|
|
return d((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = closure_0 <= arg0;
|
|
}
|
|
if (tmp) {
|
|
tmp = closure_1 >= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_20 = N;
|
|
const fn16 = function z(arg0) {
|
|
let closure_0 = arg0;
|
|
return fn6((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
};
|
|
class L {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_22 = L;
|
|
class R {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 <= closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_23 = R;
|
|
class U {
|
|
constructor(arg0) {
|
|
closure_0 = global;
|
|
return d((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 >= closure_0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_24 = U;
|
|
class C {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_25 = C;
|
|
class F {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let tmp = outer1_41(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
let closure_26 = F;
|
|
const fn17 = function n(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(fn2(arg0), {
|
|
between(arg0, arg1) {
|
|
return outer1_46(outer1_35(closure_0, outer1_20(arg0, arg1)));
|
|
},
|
|
lt(arg0) {
|
|
return outer1_46(outer1_35(closure_0, outer1_21(arg0)));
|
|
},
|
|
gt(arg0) {
|
|
return outer1_46(outer1_35(closure_0, outer1_22(arg0)));
|
|
},
|
|
lte(arg0) {
|
|
return outer1_46(outer1_35(closure_0, outer1_23(arg0)));
|
|
},
|
|
gte(arg0) {
|
|
return outer1_46(outer1_35(closure_0, outer1_24(arg0)));
|
|
},
|
|
positive() {
|
|
return outer1_46(outer1_35(closure_0, outer1_25()));
|
|
},
|
|
negative() {
|
|
return outer1_46(outer1_35(closure_0, outer1_26()));
|
|
}
|
|
});
|
|
};
|
|
const fn12Result = fn12(fn6(S));
|
|
const fn15Result = fn15(fn6(fn8));
|
|
const fn17Result = fn17(fn6(fn9));
|
|
const fn2Result1 = fn2(fn6((arg0) => "boolean" === typeof arg0));
|
|
const fn2Result2 = fn2(fn6((arg0) => "symbol" === typeof arg0));
|
|
let obj = Object.create(null);
|
|
obj.matcher = forResult;
|
|
obj.optional = fn3;
|
|
obj.array = function array() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return h({
|
|
[closure_1]: () => ({
|
|
match(arr) {
|
|
if (Array.isArray(arr)) {
|
|
if (0 === outer1_0.length) {
|
|
let obj = { matched: true };
|
|
return obj;
|
|
} else {
|
|
const first = outer1_0[0];
|
|
obj = {};
|
|
if (0 === arr.length) {
|
|
const item = outer2_7(first).forEach((arg0) => {
|
|
obj[arg0] = [];
|
|
});
|
|
const obj1 = { matched: true, selections: obj };
|
|
return obj1;
|
|
} else {
|
|
function u(arg0, arg1) {
|
|
let items = obj[arg0];
|
|
if (!items) {
|
|
items = [];
|
|
}
|
|
const items1 = [arg1];
|
|
obj[arg0] = items.concat(items1);
|
|
}
|
|
const obj2 = { matched: arr.every((arg0) => outer3_6(first, arg0, u)), selections: obj };
|
|
return obj2;
|
|
}
|
|
}
|
|
} else {
|
|
obj = { matched: false };
|
|
return obj;
|
|
}
|
|
},
|
|
getSelectionKeys() {
|
|
if (0 === outer1_0.length) {
|
|
let items = [];
|
|
} else {
|
|
items = outer2_7(outer1_0[0]);
|
|
}
|
|
return items;
|
|
}
|
|
})
|
|
});
|
|
};
|
|
obj.set = function set() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(size) {
|
|
if (size instanceof Set) {
|
|
let obj = {};
|
|
if (0 === size.size) {
|
|
obj = { matched: true };
|
|
obj.selections = obj;
|
|
return obj;
|
|
} else if (0 === outer1_0.length) {
|
|
const obj1 = { matched: true };
|
|
return obj1;
|
|
} else {
|
|
function r(arg0, arg1) {
|
|
let items = obj[arg0];
|
|
if (!items) {
|
|
items = [];
|
|
}
|
|
const items1 = [arg1];
|
|
obj[arg0] = items.concat(items1);
|
|
}
|
|
let closure_2 = outer1_0[0];
|
|
const obj2 = { matched: outer2_9(size, (arg0) => outer3_6(closure_2, arg0, r)), selections: obj };
|
|
return obj2;
|
|
}
|
|
} else {
|
|
obj = { matched: false };
|
|
return obj;
|
|
}
|
|
},
|
|
getSelectionKeys() {
|
|
if (0 === outer1_0.length) {
|
|
let items = [];
|
|
} else {
|
|
items = outer2_7(outer1_0[0]);
|
|
}
|
|
return items;
|
|
}
|
|
})
|
|
});
|
|
};
|
|
obj.map = function map() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(size) {
|
|
let closure_2;
|
|
let closure_3;
|
|
if (size instanceof Map) {
|
|
let obj = {};
|
|
if (0 === size.size) {
|
|
obj = { matched: true };
|
|
obj.selections = obj;
|
|
return obj;
|
|
} else {
|
|
function u(arg0, arg1) {
|
|
let items = obj[arg0];
|
|
if (!items) {
|
|
items = [];
|
|
}
|
|
const items1 = [arg1];
|
|
obj[arg0] = items.concat(items1);
|
|
}
|
|
if (0 === outer1_0.length) {
|
|
const obj1 = { matched: true };
|
|
return obj1;
|
|
} else if (1 === outer1_0.length) {
|
|
let _Error = Error;
|
|
let str = outer1_0[0];
|
|
str = undefined;
|
|
if (null != str) {
|
|
str = str.toString();
|
|
}
|
|
const prototype = _Error.prototype;
|
|
_Error = new _Error("`P.map` wasn't given enough arguments. Expected (key, value), received " + str);
|
|
throw _Error;
|
|
} else {
|
|
[closure_2, closure_3] = outer1_0;
|
|
const obj2 = {
|
|
matched: outer2_10(size, (arg0, arg1) => {
|
|
let tmp = outer3_6(closure_2, arg1, u);
|
|
if (tmp) {
|
|
tmp = outer3_6(closure_3, arg0, u);
|
|
}
|
|
return tmp;
|
|
}),
|
|
selections: obj
|
|
};
|
|
return obj2;
|
|
}
|
|
}
|
|
} else {
|
|
obj = { matched: false };
|
|
return obj;
|
|
}
|
|
},
|
|
getSelectionKeys() {
|
|
if (0 === outer1_0.length) {
|
|
let items = [];
|
|
} else {
|
|
const items1 = [];
|
|
items = items1.concat(outer2_7(outer1_0[0]), outer2_7(outer1_0[1]));
|
|
const tmp3 = outer2_7(outer1_0[0]);
|
|
}
|
|
return items;
|
|
}
|
|
})
|
|
});
|
|
};
|
|
obj.intersection = fn4;
|
|
obj.union = fn5;
|
|
obj.not = function not(nullish) {
|
|
let closure_0 = nullish;
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
return {
|
|
matched: !outer2_6(outer1_0, arg0, () => {
|
|
|
|
})
|
|
};
|
|
},
|
|
getSelectionKeys() {
|
|
return [];
|
|
},
|
|
matcherType: "not"
|
|
})
|
|
});
|
|
};
|
|
obj.when = fn6;
|
|
obj.select = fn7;
|
|
obj.any = fn2Result;
|
|
obj._ = fn2Result;
|
|
obj.string = fn12Result;
|
|
obj.between = B;
|
|
obj.lt = I;
|
|
obj.gt = E;
|
|
obj.lte = K;
|
|
obj.gte = T;
|
|
obj.int = fn13;
|
|
obj.finite = P;
|
|
obj.positive = fn14;
|
|
obj.negative = M;
|
|
obj.number = fn15Result;
|
|
obj.betweenBigInt = N;
|
|
obj.ltBigInt = fn16;
|
|
obj.gtBigInt = L;
|
|
obj.lteBigInt = R;
|
|
obj.gteBigInt = U;
|
|
obj.positiveBigInt = C;
|
|
obj.negativeBigInt = F;
|
|
obj.bigint = fn17Result;
|
|
obj.boolean = fn2Result1;
|
|
obj.symbol = fn2Result2;
|
|
obj.nullish = fn2(fn6((arg0) => null == arg0));
|
|
obj.instanceOf = function instanceOf(Value) {
|
|
return fn2(fn6(((Value) => {
|
|
let closure_0 = Value;
|
|
return (arg0) => arg0 instanceof closure_0;
|
|
})(Value)));
|
|
};
|
|
obj.shape = function shape(get_ActivityIndicator) {
|
|
return fn2(fn6(fn(get_ActivityIndicator)));
|
|
};
|
|
let closure_27 = { matched: false, value: undefined };
|
|
let closure_28 = (() => {
|
|
const fn = function n(input, state) {
|
|
this.input = undefined;
|
|
this.state = undefined;
|
|
this.input = input;
|
|
this.state = state;
|
|
};
|
|
let prototype = fn.prototype;
|
|
prototype.with = function() {
|
|
let self = this;
|
|
self = this;
|
|
const slice = [].slice;
|
|
const callResult = slice.call(arguments);
|
|
if (this.state.matched) {
|
|
return self;
|
|
} else {
|
|
const items = [callResult[0]];
|
|
if (3 === callResult.length) {
|
|
if ("function" === typeof callResult[1]) {
|
|
items.push(callResult[0]);
|
|
}
|
|
let c1 = false;
|
|
let obj = {};
|
|
function s(arg0, arg1) {
|
|
let c1 = true;
|
|
obj[arg0] = arg1;
|
|
}
|
|
if (items.some((arg0) => outer2_6(arg0, self.input, s))) {
|
|
if (tmp2) {
|
|
const _Boolean = Boolean;
|
|
}
|
|
obj = { matched: true };
|
|
if (c1) {
|
|
let tmp9 = obj;
|
|
if (outer1_3 in obj) {
|
|
tmp9 = obj[outer1_3];
|
|
}
|
|
let input = tmp9;
|
|
} else {
|
|
input = self.input;
|
|
}
|
|
obj.value = tmp(input, self.input);
|
|
}
|
|
const prototype = self.prototype;
|
|
const tmp16 = new self(self.input, outer1_27);
|
|
return tmp16;
|
|
}
|
|
if (callResult.length > 2) {
|
|
const push = items.push;
|
|
push.apply(items, callResult.slice(1, callResult.length - 1));
|
|
}
|
|
}
|
|
};
|
|
prototype.when = function(arg0, arg1) {
|
|
const self = this;
|
|
if (this.state.matched) {
|
|
return self;
|
|
} else {
|
|
const _Boolean = Boolean;
|
|
let tmp3 = fn;
|
|
const input = self.input;
|
|
if (Boolean(arg0(self.input))) {
|
|
const obj = { matched: true, value: arg1(self.input, self.input) };
|
|
let tmp4 = obj;
|
|
} else {
|
|
tmp4 = outer1_27;
|
|
}
|
|
const prototype = tmp3.prototype;
|
|
tmp3 = new tmp3(input, tmp4);
|
|
return tmp3;
|
|
}
|
|
};
|
|
prototype.otherwise = function(arg0) {
|
|
const self = this;
|
|
if (this.state.matched) {
|
|
let value = self.state.value;
|
|
} else {
|
|
value = arg0(self.input);
|
|
}
|
|
return value;
|
|
};
|
|
prototype.exhaustive = function() {
|
|
return this.run();
|
|
};
|
|
prototype.run = function() {
|
|
const self = this;
|
|
if (this.state.matched) {
|
|
return self.state.value;
|
|
} else {
|
|
const _JSON = JSON;
|
|
const json = JSON.stringify(self.input);
|
|
const _Error = Error;
|
|
const error = new Error("Pattern matching error: no pattern matches value " + json);
|
|
}
|
|
};
|
|
prototype.returnType = function() {
|
|
return this;
|
|
};
|
|
return fn;
|
|
})();
|
|
|
|
export const P = obj;
|
|
export const Pattern = obj;
|
|
export const isMatching = fn;
|
|
export const match = (arg0) => new closure_28(arg0, closure_27);
|