1117 lines
27 KiB
JavaScript
1117 lines
27 KiB
JavaScript
// Module ID: 4321
|
|
// Function ID: 37920
|
|
// Name: n
|
|
// Dependencies: []
|
|
// Exports: match
|
|
|
|
// Module 4321 (n)
|
|
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(@@iterator) {
|
|
let closure_0 = Symbol_iterator;
|
|
@@iterator = "undefined" !== typeof Symbol;
|
|
if (Symbol_iterator) {
|
|
const _Symbol = Symbol;
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (!Symbol_iterator) {
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (Symbol_iterator) {
|
|
const iter = Symbol_iterator.call(Symbol_iterator);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = Symbol_iterator;
|
|
if (!Array.isArray(Symbol_iterator)) {
|
|
let tmp2;
|
|
if (Symbol_iterator) {
|
|
if ("string" === typeof Symbol_iterator) {
|
|
tmp2 = n(Symbol_iterator, undefined);
|
|
} else {
|
|
const _Object = Object;
|
|
const substr = toString.call(Symbol_iterator).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = Symbol_iterator.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = n(Symbol_iterator, undefined);
|
|
} else {
|
|
const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(Symbol_iterator);
|
|
const callResult = toString.call(Symbol_iterator);
|
|
const tmp3 = "Object" === substr && Symbol_iterator.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 closure_1 = 0;
|
|
return () => {
|
|
if (closure_1 >= tmp.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = tmp[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
const fn = function s() {
|
|
const slice = [].slice;
|
|
const callResult = slice.call(arguments);
|
|
if (1 === callResult.length) {
|
|
let closure_0 = callResult[0];
|
|
return (arg0) => callback(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 callback(arg0);
|
|
},
|
|
and(arg0) {
|
|
return callback2(arg0, arg0);
|
|
},
|
|
or(arg0) {
|
|
return callback3(arg0, arg0);
|
|
},
|
|
select(arg0) {
|
|
if (undefined === arg0) {
|
|
let tmp3 = callback4(arg0);
|
|
} else {
|
|
tmp3 = callback4(arg0, arg0);
|
|
}
|
|
return tmp3;
|
|
}
|
|
});
|
|
};
|
|
function h(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign((arg0) => Object.assign(arg0, {
|
|
[Symbol.iterator]: () => {
|
|
const fn = function t() {
|
|
return fn.wrap((next) => {
|
|
next = next.next;
|
|
next.prev = next;
|
|
while (0 !== next) {
|
|
return next.stop();
|
|
}
|
|
next.next = 2;
|
|
const obj = {};
|
|
obj[closure_2] = true;
|
|
return Object.assign(obj, obj);
|
|
}, fn);
|
|
};
|
|
const arg0 = fn;
|
|
return arg0.mark(fn)();
|
|
}
|
|
})(arg0), {
|
|
optional() {
|
|
return callback(callback2(arg0));
|
|
},
|
|
select(arg0) {
|
|
if (undefined === arg0) {
|
|
let tmp4 = callback3(arg0);
|
|
} else {
|
|
tmp4 = callback3(arg0, arg0);
|
|
}
|
|
return closure_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 = callback2(obj).forEach((arg0) => {
|
|
fn(arg0, undefined);
|
|
});
|
|
obj = { matched: true };
|
|
obj.selections = obj;
|
|
const arr = callback2(obj);
|
|
} else {
|
|
obj = {};
|
|
obj.matched = callback(obj, arg0, fn);
|
|
obj.selections = obj;
|
|
}
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
return callback2(closure_0);
|
|
},
|
|
matcherType: "optional"
|
|
})
|
|
});
|
|
};
|
|
const fn4 = function p() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
let obj = {};
|
|
function r(arg0, arg1) {
|
|
obj[arg0] = arg1;
|
|
}
|
|
obj = { matched: arg0.every((arg0) => callback(arg0, arg0, r)), selections: obj };
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
return callback(closure_0, closure_7);
|
|
},
|
|
matcherType: "and"
|
|
})
|
|
});
|
|
};
|
|
const fn5 = function y() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
let obj = {};
|
|
function r(arg0, arg1) {
|
|
obj[arg0] = arg1;
|
|
}
|
|
const item = callback(arg0, closure_7).forEach((arg0) => {
|
|
r(arg0, undefined);
|
|
});
|
|
obj = { matched: arg0.some((arg0) => callback(arg0, arg0, r)), selections: obj };
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
return callback(closure_0, closure_7);
|
|
},
|
|
matcherType: "or"
|
|
})
|
|
});
|
|
};
|
|
const fn6 = function d(S) {
|
|
let closure_0 = S;
|
|
return {
|
|
[closure_1]: () => ({
|
|
match(arg0) {
|
|
return { matched: Boolean(callback(arg0)) };
|
|
}
|
|
})
|
|
};
|
|
};
|
|
const fn7 = function b() {
|
|
const slice = [].slice;
|
|
const callResult = slice.call(arguments);
|
|
let first;
|
|
if ("string" === typeof callResult[0]) {
|
|
first = callResult[0];
|
|
}
|
|
let closure_0 = first;
|
|
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 != closure_0 ? closure_0 : closure_3]: arg0 };
|
|
obj = {};
|
|
let tmp = undefined === closure_1;
|
|
if (!tmp) {
|
|
tmp = callback(closure_1, arg0, (arg0, arg1) => {
|
|
obj[arg0] = arg1;
|
|
});
|
|
}
|
|
obj.matched = tmp;
|
|
obj.selections = obj;
|
|
return obj;
|
|
},
|
|
getSelectionKeys() {
|
|
const items = [null != closure_0 ? closure_0 : closure_3];
|
|
if (undefined === closure_1) {
|
|
let items1 = [];
|
|
} else {
|
|
items1 = callback2(closure_1);
|
|
}
|
|
return items.concat(items1);
|
|
}
|
|
})
|
|
});
|
|
};
|
|
const fn8 = function w(arg0) {
|
|
return "number" === typeof arg0;
|
|
};
|
|
class S {
|
|
constructor(arg0) {
|
|
return "string" === typeof global;
|
|
}
|
|
}
|
|
const fn9 = function j(arg0) {
|
|
return "bigint" === typeof arg0;
|
|
};
|
|
let closure_0 = require(dependencyMap[0]);
|
|
const forResult = Symbol.for("@ts-pattern/matcher");
|
|
let closure_2 = Symbol.for("@ts-pattern/isVariadic");
|
|
let closure_3 = "@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_2 = arg2;
|
|
if (o(arr)) {
|
|
const match = arr[closure_1]().match(arr2);
|
|
({ matched, selections } = match);
|
|
let closure_3 = selections;
|
|
let tmp24 = matched;
|
|
if (matched) {
|
|
tmp24 = selections;
|
|
}
|
|
if (tmp24) {
|
|
const _Object3 = Object;
|
|
const keys = Object.keys(selections);
|
|
const item = keys.forEach((arg0) => arg2(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 = o;
|
|
if (o(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 {
|
|
const i = arr2.slice(0, items.length);
|
|
if (0 === items1.length) {
|
|
let items3 = [];
|
|
} else {
|
|
items3 = arr2.slice(-items1.length);
|
|
}
|
|
const o = items3;
|
|
let num2 = Infinity;
|
|
if (0 !== items1.length) {
|
|
num2 = -items1.length;
|
|
}
|
|
const substr = arr2.slice(items.length, num2);
|
|
let tmp15 = items.every((arg0, arg1) => callback(arg0, closure_4[arg1], arg2)) && items1.every((arg0, arg1) => callback(arg0, items3[arg1], arg2));
|
|
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) => callback(arg0, arg1[arg1], arg2));
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
const _Object2 = Object;
|
|
const keys1 = Object.keys(arr);
|
|
return keys1.every((arg0) => {
|
|
let tmp2 = arg0 in arg1;
|
|
if (!tmp2) {
|
|
let tmp4 = items3(tmp);
|
|
if (tmp4) {
|
|
tmp4 = "optional" === tmp[closure_1]().matcherType;
|
|
}
|
|
tmp2 = tmp4;
|
|
}
|
|
if (tmp2) {
|
|
tmp2 = callback(tmp, arg1[arg0], arg2);
|
|
}
|
|
return tmp2;
|
|
});
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
const _Object = Object;
|
|
return Object.is(arr2, arr);
|
|
}
|
|
const forResult = arr2;
|
|
};
|
|
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(arg1(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) {
|
|
return callback3(callback(arg0, callback2((str) => {
|
|
let startsWithResult = callback(str);
|
|
if (startsWithResult) {
|
|
startsWithResult = str.startsWith(str);
|
|
}
|
|
return startsWithResult;
|
|
})));
|
|
},
|
|
endsWith(arg0) {
|
|
return callback3(callback(arg0, callback2((str) => {
|
|
let endsWithResult = callback(str);
|
|
if (endsWithResult) {
|
|
endsWithResult = str.endsWith(str);
|
|
}
|
|
return endsWithResult;
|
|
})));
|
|
},
|
|
minLength(arg0) {
|
|
return callback3(callback(arg0, (arg0) => callback((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0.length >= arg0;
|
|
}
|
|
return tmp;
|
|
})(arg0)));
|
|
},
|
|
maxLength(arg0) {
|
|
return callback3(callback(arg0, (arg0) => callback((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0.length <= arg0;
|
|
}
|
|
return tmp;
|
|
})(arg0)));
|
|
},
|
|
includes(arg0) {
|
|
return callback3(callback(arg0, callback2((arr) => {
|
|
let hasItem = callback(arr);
|
|
if (hasItem) {
|
|
hasItem = arr.includes(arr);
|
|
}
|
|
return hasItem;
|
|
})));
|
|
},
|
|
regex(arg0) {
|
|
return callback3(callback(arg0, callback2((str) => {
|
|
let BooleanResult = callback(str);
|
|
if (BooleanResult) {
|
|
const _Boolean = Boolean;
|
|
BooleanResult = Boolean(str.match(str));
|
|
}
|
|
return BooleanResult;
|
|
})));
|
|
}
|
|
});
|
|
};
|
|
class B {
|
|
constructor(arg0, arg1) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 <= arg0;
|
|
}
|
|
if (tmp) {
|
|
tmp = arg1 >= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class I {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class E {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class K {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 <= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class T {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 >= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
const fn13 = function k() {
|
|
return fn6((arg0) => {
|
|
let isIntegerResult = callback(arg0);
|
|
if (isIntegerResult) {
|
|
const _Number = Number;
|
|
isIntegerResult = Number.isInteger(arg0);
|
|
}
|
|
return isIntegerResult;
|
|
});
|
|
};
|
|
class P {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let isFiniteResult = callback(arg0);
|
|
if (isFiniteResult) {
|
|
const _Number = Number;
|
|
isFiniteResult = Number.isFinite(arg0);
|
|
}
|
|
return isFiniteResult;
|
|
});
|
|
}
|
|
}
|
|
const fn14 = function _() {
|
|
return fn6((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
};
|
|
class M {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
const fn15 = function n(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(fn2(arg0), {
|
|
between(arg0, arg1) {
|
|
return callback11(callback10(arg0, callback(arg0, arg1)));
|
|
},
|
|
lt(arg0) {
|
|
return callback11(callback10(arg0, callback2(arg0)));
|
|
},
|
|
gt(arg0) {
|
|
return callback11(callback10(arg0, callback3(arg0)));
|
|
},
|
|
lte(arg0) {
|
|
return callback11(callback10(arg0, callback4(arg0)));
|
|
},
|
|
gte(arg0) {
|
|
return callback11(callback10(arg0, callback5(arg0)));
|
|
},
|
|
int() {
|
|
return callback11(callback10(arg0, callback6()));
|
|
},
|
|
finite() {
|
|
return callback11(callback10(arg0, callback7()));
|
|
},
|
|
positive() {
|
|
return callback11(callback10(arg0, callback8()));
|
|
},
|
|
negative() {
|
|
return callback11(callback10(arg0, callback9()));
|
|
}
|
|
});
|
|
};
|
|
class N {
|
|
constructor(arg0, arg1) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 <= arg0;
|
|
}
|
|
if (tmp) {
|
|
tmp = arg1 >= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
const fn16 = function z(arg0) {
|
|
let closure_0 = arg0;
|
|
return fn6((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
};
|
|
class L {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class R {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 <= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class U {
|
|
constructor(arg0) {
|
|
require = global;
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 >= arg0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class C {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 > 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
class F {
|
|
constructor() {
|
|
return d((arg0) => {
|
|
let tmp = callback(arg0);
|
|
if (tmp) {
|
|
tmp = arg0 < 0;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
}
|
|
const fn17 = function n(arg0) {
|
|
let closure_0 = arg0;
|
|
return Object.assign(fn2(arg0), {
|
|
between(arg0, arg1) {
|
|
return callback9(callback8(arg0, callback(arg0, arg1)));
|
|
},
|
|
lt(arg0) {
|
|
return callback9(callback8(arg0, callback2(arg0)));
|
|
},
|
|
gt(arg0) {
|
|
return callback9(callback8(arg0, callback3(arg0)));
|
|
},
|
|
lte(arg0) {
|
|
return callback9(callback8(arg0, callback4(arg0)));
|
|
},
|
|
gte(arg0) {
|
|
return callback9(callback8(arg0, callback5(arg0)));
|
|
},
|
|
positive() {
|
|
return callback9(callback8(arg0, callback6()));
|
|
},
|
|
negative() {
|
|
return callback9(callback8(arg0, callback7()));
|
|
}
|
|
});
|
|
};
|
|
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));
|
|
const 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 === first.length) {
|
|
let obj = { matched: true };
|
|
return obj;
|
|
} else {
|
|
const first = first[0];
|
|
obj = {};
|
|
if (0 === arr.length) {
|
|
const item = callback(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) => callback(first, arg0, u)), selections: obj };
|
|
return obj2;
|
|
}
|
|
}
|
|
} else {
|
|
obj = { matched: false };
|
|
return obj;
|
|
}
|
|
},
|
|
getSelectionKeys() {
|
|
if (0 === length.length) {
|
|
let items = [];
|
|
} else {
|
|
items = callback(length[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 === obj.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 = obj[0];
|
|
const obj2 = { matched: callback2(size, (arg0) => callback(closure_2, arg0, r)), selections: obj };
|
|
return obj2;
|
|
}
|
|
} else {
|
|
obj = { matched: false };
|
|
return obj;
|
|
}
|
|
},
|
|
getSelectionKeys() {
|
|
if (0 === length.length) {
|
|
let items = [];
|
|
} else {
|
|
items = callback(length[0]);
|
|
}
|
|
return items;
|
|
}
|
|
})
|
|
});
|
|
};
|
|
obj.map = function map() {
|
|
const slice = [].slice;
|
|
let closure_0 = slice.call(arguments);
|
|
return fn2({
|
|
[closure_1]: () => ({
|
|
match(size) {
|
|
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 === obj.length) {
|
|
const obj1 = { matched: true };
|
|
return obj1;
|
|
} else if (1 === obj.length) {
|
|
let _Error = Error;
|
|
let str = obj[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] = obj;
|
|
const obj2 = {
|
|
matched: callback2(size, (arg0, arg1) => {
|
|
let tmp = callback(closure_2, arg1, u);
|
|
if (tmp) {
|
|
tmp = callback(closure_3, arg0, u);
|
|
}
|
|
return tmp;
|
|
}),
|
|
selections: obj
|
|
};
|
|
return obj2;
|
|
}
|
|
}
|
|
} else {
|
|
obj = { matched: false };
|
|
return obj;
|
|
}
|
|
},
|
|
getSelectionKeys() {
|
|
if (0 === length.length) {
|
|
let items = [];
|
|
} else {
|
|
const items1 = [];
|
|
items = items1.concat(callback(length[0]), callback(length[1]));
|
|
const tmp3 = callback(length[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: !callback(closure_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) => (arg0) => arg0 instanceof arg0(Value)));
|
|
};
|
|
obj.shape = function shape(arg0) {
|
|
return fn2(fn6(fn(arg0)));
|
|
};
|
|
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 closure_0 = fn;
|
|
const prototype = fn.prototype;
|
|
prototype.with = function() {
|
|
const self = this;
|
|
const fn = 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 closure_1 = false;
|
|
let obj = {};
|
|
function s(arg0, arg1) {
|
|
let closure_1 = true;
|
|
obj[arg0] = arg1;
|
|
}
|
|
if (items.some((arg0) => callback(arg0, self.input, s))) {
|
|
if (tmp2) {
|
|
const _Boolean = Boolean;
|
|
}
|
|
obj = { matched: true };
|
|
if (closure_1) {
|
|
let tmp9 = obj;
|
|
if (s in obj) {
|
|
tmp9 = obj[closure_3];
|
|
}
|
|
let input = tmp9;
|
|
} else {
|
|
input = self.input;
|
|
}
|
|
obj.value = tmp(input, self.input);
|
|
}
|
|
const prototype = fn.prototype;
|
|
const tmp16 = new fn(self.input, closure_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 = closure_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);
|