645 lines
20 KiB
JavaScript
645 lines
20 KiB
JavaScript
// Module ID: 12682
|
|
// Function ID: 97351
|
|
// Name: Range
|
|
// Dependencies: [0, 0, 0, 0, 0, 0, 0, 0, 0]
|
|
|
|
// Module 12682 (Range)
|
|
import "__exportStarResult1";
|
|
import "__exportStarResult1";
|
|
import "__exportStarResult1";
|
|
|
|
let closure_5 = /\s+/g;
|
|
let _module = require(dependencyMap[9]);
|
|
_module = new _module();
|
|
function isNullSet(value) {
|
|
return "<0.0.0-0" === value.value;
|
|
}
|
|
function isAny(value) {
|
|
return "" === value.value;
|
|
}
|
|
function isSatisfiable(arr) {
|
|
const require = arg1;
|
|
const substr = arr.slice();
|
|
let closure_1 = substr.pop();
|
|
let flag = true;
|
|
if (substr.length) {
|
|
const everyResult = substr.every((arg0) => closure_1.intersects(arg0, arg1));
|
|
closure_1 = substr.pop();
|
|
flag = everyResult;
|
|
while (everyResult) {
|
|
flag = everyResult;
|
|
if (!substr.length) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
function parseComparator(arg0, arg1) {
|
|
require(dependencyMap[7])("comp", arg0, arg1);
|
|
const tmp2 = replaceCarets(arg0, arg1);
|
|
require(dependencyMap[7])("caret", tmp2);
|
|
const tmp4 = replaceTildes(tmp2, arg1);
|
|
require(dependencyMap[7])("tildes", tmp4);
|
|
const tmp6 = replaceXRanges(tmp4, arg1);
|
|
require(dependencyMap[7])("xrange", tmp6);
|
|
const tmp8 = replaceStars(tmp6, arg1);
|
|
require(dependencyMap[7])("stars", tmp8);
|
|
return tmp8;
|
|
}
|
|
function isX(str) {
|
|
let tmp = !str;
|
|
if (!tmp) {
|
|
tmp = "x" === str.toLowerCase();
|
|
}
|
|
if (!tmp) {
|
|
tmp = "*" === str;
|
|
}
|
|
return tmp;
|
|
}
|
|
function replaceTildes(str, arg1) {
|
|
const require = arg1;
|
|
const parts = str.trim().split(/\s+/);
|
|
const mapped = parts.map((arg0) => callback(arg0, arg1));
|
|
return mapped.join(" ");
|
|
}
|
|
function replaceTilde(str, loose) {
|
|
const require = str;
|
|
const safeRe = require(dependencyMap[6]).safeRe;
|
|
const t = require(dependencyMap[6]).t;
|
|
if (loose.loose) {
|
|
let tmp = safeRe[t.TILDELOOSE];
|
|
} else {
|
|
tmp = safeRe[t.TILDE];
|
|
}
|
|
return str.replace(tmp, (arg0, arg1, arg2, arg3, arg4) => {
|
|
arg0(closure_1[7])("tilde", arg0, arg0, arg1, arg2, arg3, arg4);
|
|
let str = "";
|
|
if (!callback(arg1)) {
|
|
if (callback(arg2)) {
|
|
const _HermesInternal4 = HermesInternal;
|
|
str = ">=" + arg1 + ".0.0 <" + +arg1 + 1 + ".0.0-0";
|
|
} else if (callback(arg3)) {
|
|
const _HermesInternal3 = HermesInternal;
|
|
str = ">=" + arg1 + "." + arg2 + ".0 <" + arg1 + "." + +arg2 + 1 + ".0-0";
|
|
} else if (arg4) {
|
|
arg0(closure_1[7])("replaceTilde pr", arg4);
|
|
const _HermesInternal2 = HermesInternal;
|
|
str = ">=" + arg1 + "." + arg2 + "." + arg3 + "-" + arg4 + " <" + arg1 + "." + +arg2 + 1 + ".0-0";
|
|
} else {
|
|
const _HermesInternal = HermesInternal;
|
|
str = ">=" + arg1 + "." + arg2 + "." + arg3 + " <" + arg1 + "." + +arg2 + 1 + ".0-0";
|
|
}
|
|
}
|
|
arg0(closure_1[7])("tilde return", str);
|
|
return str;
|
|
});
|
|
}
|
|
function replaceCarets(str, arg1) {
|
|
const require = arg1;
|
|
const parts = str.trim().split(/\s+/);
|
|
const mapped = parts.map((arg0) => callback(arg0, arg1));
|
|
return mapped.join(" ");
|
|
}
|
|
function replaceCaret(str, loose) {
|
|
const require = str;
|
|
require(dependencyMap[7])("caret", str, loose);
|
|
const safeRe = require(dependencyMap[6]).safeRe;
|
|
const t = require(dependencyMap[6]).t;
|
|
if (loose.loose) {
|
|
let tmp2 = safeRe[t.CARETLOOSE];
|
|
} else {
|
|
tmp2 = safeRe[t.CARET];
|
|
}
|
|
str = "";
|
|
if (loose.includePrerelease) {
|
|
str = "-0";
|
|
}
|
|
const dependencyMap = str;
|
|
return str.replace(tmp2, (arg0, arg1, arg2, arg3, arg4) => {
|
|
arg0(str[7])("caret", arg0, arg0, arg1, arg2, arg3, arg4);
|
|
let str = "";
|
|
if (!callback(arg1)) {
|
|
if (callback(arg2)) {
|
|
const _HermesInternal9 = HermesInternal;
|
|
str = ">=" + arg1 + ".0.0" + str + " <" + +arg1 + 1 + ".0.0-0";
|
|
} else if (callback(arg3)) {
|
|
if ("0" === arg1) {
|
|
const _HermesInternal8 = HermesInternal;
|
|
let combined = ">=" + arg1 + "." + arg2 + ".0" + str + " <" + arg1 + "." + +arg2 + 1 + ".0-0";
|
|
} else {
|
|
const _HermesInternal7 = HermesInternal;
|
|
combined = ">=" + arg1 + "." + arg2 + ".0" + str + " <" + +arg1 + 1 + ".0.0-0";
|
|
}
|
|
str = combined;
|
|
} else {
|
|
const tmp6 = arg0(str[7]);
|
|
if (arg4) {
|
|
tmp6("replaceCaret pr", arg4);
|
|
if ("0" === arg1) {
|
|
if ("0" === arg2) {
|
|
const _HermesInternal6 = HermesInternal;
|
|
let combined1 = ">=" + arg1 + "." + arg2 + "." + arg3 + "-" + arg4 + " <" + arg1 + "." + arg2 + "." + +arg3 + 1 + "-0";
|
|
} else {
|
|
const _HermesInternal5 = HermesInternal;
|
|
combined1 = ">=" + arg1 + "." + arg2 + "." + arg3 + "-" + arg4 + " <" + arg1 + "." + +arg2 + 1 + ".0-0";
|
|
}
|
|
} else {
|
|
const _HermesInternal4 = HermesInternal;
|
|
str = ">=" + arg1 + "." + arg2 + "." + arg3 + "-" + arg4 + " <" + +arg1 + 1 + ".0.0-0";
|
|
}
|
|
} else {
|
|
tmp6("no pr");
|
|
if ("0" === arg1) {
|
|
if ("0" === arg2) {
|
|
const _HermesInternal3 = HermesInternal;
|
|
let combined2 = ">=" + arg1 + "." + arg2 + "." + arg3 + str + " <" + arg1 + "." + arg2 + "." + +arg3 + 1 + "-0";
|
|
} else {
|
|
const _HermesInternal2 = HermesInternal;
|
|
combined2 = ">=" + arg1 + "." + arg2 + "." + arg3 + str + " <" + arg1 + "." + +arg2 + 1 + ".0-0";
|
|
}
|
|
} else {
|
|
const _HermesInternal = HermesInternal;
|
|
str = ">=" + arg1 + "." + arg2 + "." + arg3 + " <" + +arg1 + 1 + ".0.0-0";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
arg0(str[7])("caret return", str);
|
|
return str;
|
|
});
|
|
}
|
|
function replaceXRanges(str, arg1) {
|
|
const require = arg1;
|
|
require(dependencyMap[7])("replaceXRanges", str, arg1);
|
|
const parts = str.split(/\s+/);
|
|
const mapped = parts.map((arg0) => callback(arg0, arg1));
|
|
return mapped.join(" ");
|
|
}
|
|
function replaceXRange(str, loose) {
|
|
const dependencyMap = loose;
|
|
str = str.trim();
|
|
const require = str;
|
|
const safeRe = require(dependencyMap[6]).safeRe;
|
|
const t = require(dependencyMap[6]).t;
|
|
if (loose.loose) {
|
|
let tmp = safeRe[t.XRANGELOOSE];
|
|
} else {
|
|
tmp = safeRe[t.XRANGE];
|
|
}
|
|
return str.replace(tmp, (arg0, arg1, arg2, arg3, arg4, arg5) => {
|
|
let combined = arg0;
|
|
let str = arg1;
|
|
str(arg1[7])("xRange", str, arg0, arg1, arg2, arg3, arg4, arg5);
|
|
const tmp3 = callback(arg2);
|
|
let tmp4 = tmp3;
|
|
if (!tmp3) {
|
|
tmp4 = callback(arg3);
|
|
}
|
|
let tmp6 = tmp4;
|
|
if (!tmp4) {
|
|
tmp6 = callback(arg4);
|
|
}
|
|
if (tmp8) {
|
|
str = "";
|
|
}
|
|
let str2 = "";
|
|
if (arg1.includePrerelease) {
|
|
str2 = "-0";
|
|
}
|
|
if (tmp3) {
|
|
if (">" === str) {
|
|
let str24 = "<0.0.0-0";
|
|
} else {
|
|
str24 = "*";
|
|
}
|
|
combined = str24;
|
|
} else {
|
|
if (str) {
|
|
if (tmp6) {
|
|
let num3 = arg3;
|
|
if (tmp4) {
|
|
num3 = 0;
|
|
}
|
|
if (">" === str) {
|
|
if (tmp4) {
|
|
let sum = +arg2 + 1;
|
|
let str16 = ">=";
|
|
let num4 = 0;
|
|
} else {
|
|
num4 = +num3 + 1;
|
|
str16 = ">=";
|
|
sum = arg2;
|
|
}
|
|
} else {
|
|
sum = arg2;
|
|
num4 = num3;
|
|
str16 = str;
|
|
if ("<=" === str) {
|
|
if (tmp4) {
|
|
let sum1 = +arg2 + 1;
|
|
let sum2 = num3;
|
|
} else {
|
|
sum2 = +num3 + 1;
|
|
sum1 = arg2;
|
|
}
|
|
str16 = "<";
|
|
sum = sum1;
|
|
num4 = sum2;
|
|
}
|
|
}
|
|
let str18 = str2;
|
|
if ("<" === str16) {
|
|
str18 = "-0";
|
|
}
|
|
const _HermesInternal3 = HermesInternal;
|
|
combined = "" + str16 + sum + "." + num4 + "." + 0 + str18;
|
|
}
|
|
}
|
|
if (tmp4) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
combined = ">=" + arg2 + ".0.0" + str2 + " <" + +arg2 + 1 + ".0.0-0";
|
|
} else if (tmp6) {
|
|
const _HermesInternal = HermesInternal;
|
|
combined = ">=" + arg2 + "." + arg3 + ".0" + str2 + " <" + arg2 + "." + +arg3 + 1 + ".0-0";
|
|
}
|
|
}
|
|
str(arg1[7])("xRange return", combined);
|
|
return combined;
|
|
});
|
|
}
|
|
function replaceStars(str, arg1) {
|
|
require(dependencyMap[7])("replaceStars", str, arg1);
|
|
return str.trim().replace(require(dependencyMap[6]).safeRe[closure_0(undefined, closure_1[6]).t.STAR], "");
|
|
}
|
|
function replaceGTE0(str) {
|
|
require(dependencyMap[7])("replaceGTE0", str, arg1);
|
|
const t = require(dependencyMap[6]).t;
|
|
return str.trim().replace(require(dependencyMap[6]).safeRe[arg1.includePrerelease ? t.GTE0PRE : t.GTE0], "");
|
|
}
|
|
function hyphenReplace(arg0) {
|
|
const require = arg0;
|
|
return (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => {
|
|
let str = arg8;
|
|
if (callback(arg2)) {
|
|
if (callback(str)) {
|
|
const _HermesInternal10 = HermesInternal;
|
|
return "" + "" + " " + "".trim();
|
|
} else if (callback(arg9)) {
|
|
const _HermesInternal9 = HermesInternal;
|
|
const sum = +str + 1;
|
|
str = ".0.0-0";
|
|
let combined = "<" + sum + ".0.0-0";
|
|
} else if (callback(arg10)) {
|
|
const _HermesInternal8 = HermesInternal;
|
|
combined = "<" + `.0.0-0` + "." + +arg9 + 1 + ".0-0";
|
|
} else if (arg11) {
|
|
const _HermesInternal7 = HermesInternal;
|
|
combined = "<=" + `.0.0-0` + "." + arg9 + "." + arg10 + "-" + arg11;
|
|
} else if (arg0) {
|
|
const _HermesInternal6 = HermesInternal;
|
|
combined = "<" + `.0.0-0` + "." + arg9 + "." + +arg10 + 1 + "-0";
|
|
} else {
|
|
const _HermesInternal5 = HermesInternal;
|
|
combined = "<=" + arg7;
|
|
}
|
|
} else if (callback(arg3)) {
|
|
let str9 = "";
|
|
if (arg0) {
|
|
str9 = "-0";
|
|
}
|
|
const _HermesInternal4 = HermesInternal;
|
|
let combined1 = ">=" + arg2 + ".0.0" + str9;
|
|
} else if (callback(arg4)) {
|
|
let str5 = "";
|
|
if (arg0) {
|
|
str5 = "-0";
|
|
}
|
|
const _HermesInternal3 = HermesInternal;
|
|
combined1 = ">=" + arg2 + "." + arg3 + ".0" + str5;
|
|
} else if (arg5) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
combined1 = ">=" + arg1;
|
|
} else {
|
|
let str2 = "";
|
|
if (arg0) {
|
|
str2 = "-0";
|
|
}
|
|
const _HermesInternal = HermesInternal;
|
|
combined1 = ">=" + arg1 + str2;
|
|
}
|
|
};
|
|
}
|
|
function testSet(arg0, prerelease, includePrerelease) {
|
|
let num = 0;
|
|
if (0 < arg0.length) {
|
|
while (obj.test(prerelease)) {
|
|
num = num + 1;
|
|
}
|
|
return false;
|
|
}
|
|
if (prerelease.prerelease.length) {
|
|
if (!includePrerelease.includePrerelease) {
|
|
let num4 = 0;
|
|
if (0 < arg0.length) {
|
|
while (true) {
|
|
let tmp3 = require;
|
|
let tmp4 = dependencyMap;
|
|
let tmp5 = require(dependencyMap[7])(arg0[num4].semver);
|
|
let tmp6 = tmp2;
|
|
if (arg0[num4].semver !== require(dependencyMap[4]).ANY) {
|
|
tmp6 = tmp2;
|
|
if (arg0[num4].semver.prerelease.length > 0) {
|
|
let semver = arg0[num4].semver;
|
|
tmp6 = semver;
|
|
if (semver.major === prerelease.major) {
|
|
tmp6 = semver;
|
|
if (semver.minor === prerelease.minor) {
|
|
tmp6 = semver;
|
|
if (semver.patch === prerelease.patch) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
num4 = num4 + 1;
|
|
let tmp2 = tmp6;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export default () => {
|
|
class Range {
|
|
constructor(arg0, arg1) {
|
|
self = this;
|
|
Range = this;
|
|
tmp = closure_3(this, Range);
|
|
tmp2 = Range(closure_1[3])(arg1);
|
|
if (arg0 instanceof Range) {
|
|
if (arg0.loose !== tmp2.loose) {
|
|
tmp17 = Range;
|
|
prototype2 = Range.prototype;
|
|
tmp18 = new.target;
|
|
tmp19 = new.target;
|
|
tmp20 = tmp2;
|
|
tmp16 = new Range(arg0.raw, tmp2);
|
|
} else {
|
|
tmp16 = arg0;
|
|
}
|
|
return tmp16;
|
|
} else {
|
|
tmp3 = Range;
|
|
tmp4 = closure_1;
|
|
num = 4;
|
|
if (arg0 instanceof Range(closure_1[4])) {
|
|
self.raw = arg0.value;
|
|
items = [];
|
|
items[0] = arg0;
|
|
items1 = [];
|
|
items1[0] = items;
|
|
self.set = items1;
|
|
self.formatted = undefined;
|
|
return self;
|
|
} else {
|
|
self.options = tmp2;
|
|
self.loose = tmp2.loose;
|
|
self.includePrerelease = tmp2.includePrerelease;
|
|
str = arg0.trim();
|
|
tmp5 = closure_5;
|
|
str2 = " ";
|
|
self.raw = str.replace(closure_5, " ");
|
|
str3 = self.raw;
|
|
str4 = "||";
|
|
parts = str3.split("||");
|
|
mapped = parts.map((str) => self.parseRange(str.trim()));
|
|
self.set = mapped.filter((arg0) => arg0.length);
|
|
if (self.set.length) {
|
|
num2 = 1;
|
|
if (self.set.length > 1) {
|
|
num3 = 0;
|
|
set = self.set;
|
|
self.set = set.filter((arg0) => !callback(arg0[0]));
|
|
if (0 === self.set.length) {
|
|
items2 = [];
|
|
items2[0] = self.set[0];
|
|
self.set = items2;
|
|
} else if (self.set.length > 1) {
|
|
set = self.set;
|
|
tmp11 = set;
|
|
for (const item10065 of set) {
|
|
tmp12 = item10065;
|
|
if (1 !== item10065.length) {
|
|
} else {
|
|
tmp13 = closure_8;
|
|
tmp14 = item10065;
|
|
if (closure_8(tmp12[0])) {
|
|
tmp15 = item10065;
|
|
items3 = [];
|
|
items3[0] = tmp12;
|
|
self.set = items3;
|
|
obj.return();
|
|
// break
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
self.formatted = undefined;
|
|
return;
|
|
} else {
|
|
tmp6 = globalThis;
|
|
_TypeError = TypeError;
|
|
_HermesInternal = HermesInternal;
|
|
str5 = "Invalid SemVer Range: ";
|
|
prototype = TypeError.prototype;
|
|
tmp7 = new.target;
|
|
tmp8 = new.target;
|
|
typeError = new TypeError("Invalid SemVer Range: " + self.raw);
|
|
tmp10 = typeError;
|
|
throw typeError;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const require = Range;
|
|
let obj = {
|
|
key: "range",
|
|
get() {
|
|
const self = this;
|
|
if (undefined === this.formatted) {
|
|
self.formatted = "";
|
|
for (let num2 = 0; num2 < self.set.length; num2 = num2 + 1) {
|
|
if (num2 > 0) {
|
|
self.formatted = `${self.formatted}||`;
|
|
}
|
|
let arr = self.set[num2];
|
|
for (let num = 0; num < arr.length; num = num + 1) {
|
|
if (num > 0) {
|
|
self.formatted = `${self.formatted} `;
|
|
}
|
|
let str = arr[num];
|
|
let str2 = str.toString();
|
|
self.formatted = self.formatted + str2.trim();
|
|
}
|
|
}
|
|
}
|
|
return self.formatted;
|
|
}
|
|
};
|
|
const items = [obj, , , , , ];
|
|
obj = {
|
|
key: "format",
|
|
value: function format() {
|
|
return this.range;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "toString",
|
|
value: function toString() {
|
|
return this.range;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "parseRange",
|
|
value: function parseRange(str) {
|
|
const self = this;
|
|
const Range = this;
|
|
let FLAG_INCLUDE_PRERELEASE = this.options.includePrerelease;
|
|
if (FLAG_INCLUDE_PRERELEASE) {
|
|
FLAG_INCLUDE_PRERELEASE = Range(closure_1[5]).FLAG_INCLUDE_PRERELEASE;
|
|
}
|
|
let FLAG_LOOSE = self.options.loose;
|
|
if (FLAG_LOOSE) {
|
|
FLAG_LOOSE = Range(closure_1[5]).FLAG_LOOSE;
|
|
}
|
|
const text = `${FLAG_INCLUDE_PRERELEASE | FLAG_LOOSE}:${str}`;
|
|
const value = store.get(text);
|
|
if (value) {
|
|
return value;
|
|
} else {
|
|
const loose = self.options.loose;
|
|
const safeRe = Range(closure_1[6]).safeRe;
|
|
const t = Range(closure_1[6]).t;
|
|
if (loose) {
|
|
let tmp9 = safeRe[t.HYPHENRANGELOOSE];
|
|
} else {
|
|
tmp9 = safeRe[t.HYPHENRANGE];
|
|
}
|
|
str = str.replace(tmp9, callback3(self.options.includePrerelease));
|
|
Range(closure_1[7])("hyphen replace", str);
|
|
const str3 = str.replace(Range(closure_1[6]).safeRe[closure_0(undefined, closure_1[6]).t.COMPARATORTRIM], Range(closure_1[6]).comparatorTrimReplace);
|
|
Range(closure_1[7])("comparator trim", str3);
|
|
const str5 = str3.replace(Range(closure_1[6]).safeRe[closure_0(undefined, closure_1[6]).t.TILDETRIM], Range(closure_1[6]).tildeTrimReplace);
|
|
Range(closure_1[7])("tilde trim", str5);
|
|
const str7 = str5.replace(Range(closure_1[6]).safeRe[closure_0(undefined, closure_1[6]).t.CARETTRIM], Range(closure_1[6]).caretTrimReplace);
|
|
Range(closure_1[7])("caret trim", str7);
|
|
const parts = str7.split(" ");
|
|
const mapped = parts.map((arg0) => callback(arg0, self.options));
|
|
const parts1 = mapped.join(" ").split(/\s+/);
|
|
const mapped1 = parts1.map((arg0) => callback2(arg0, self.options));
|
|
let found = mapped1;
|
|
if (loose) {
|
|
found = mapped1.filter((str) => {
|
|
self(closure_1[7])("loose invalid filter", str, self.options);
|
|
return str.match(self(closure_1[6]).safeRe[closure_0(undefined, closure_1[6]).t.COMPARATORLOOSE]);
|
|
});
|
|
}
|
|
Range(closure_1[7])("range list", found);
|
|
const _Map = Map;
|
|
const map = new Map();
|
|
const mapped2 = found.map((arg0) => {
|
|
let tmp = self(closure_1[4]);
|
|
tmp = new tmp(arg0, self.options);
|
|
return tmp;
|
|
});
|
|
for (const item10139 of mapped2) {
|
|
let iter = item10139;
|
|
let tmp26 = closure_7;
|
|
if (closure_7(item10139)) {
|
|
let tmp30 = item10139;
|
|
let items = [iter];
|
|
obj3.return();
|
|
return items;
|
|
} else {
|
|
let tmp27 = map;
|
|
let tmp28 = item10139;
|
|
let result = obj2.set(iter.value, iter);
|
|
// continue
|
|
}
|
|
}
|
|
let hasItem = obj2.size > 1;
|
|
if (hasItem) {
|
|
hasItem = obj2.has("");
|
|
}
|
|
if (hasItem) {
|
|
obj2.delete("");
|
|
}
|
|
const tmp38 = callback(map.values());
|
|
const result1 = store.set(text, tmp38);
|
|
return tmp38;
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "intersects",
|
|
value: function intersects(arg0, arg1) {
|
|
const Range = arg0;
|
|
if (arg0 instanceof Range) {
|
|
const self = this;
|
|
return this.set.some((arg0) => {
|
|
let someResult = callback(arg0, arg1);
|
|
if (someResult) {
|
|
someResult = arg0.set.some((arg0) => {
|
|
let everyResult = callback(arg0, closure_1);
|
|
if (everyResult) {
|
|
everyResult = arg0.every((arg0) => arg0.every(() => { ... }));
|
|
}
|
|
return everyResult;
|
|
});
|
|
const set = arg0.set;
|
|
}
|
|
return someResult;
|
|
});
|
|
} else {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("a Range is required");
|
|
throw typeError;
|
|
}
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "test",
|
|
value: function test(arg0) {
|
|
const self = this;
|
|
let tmp = arg0;
|
|
if (arg0) {
|
|
if ("string" === typeof tmp) {
|
|
const tmp5 = Range(closure_1[8]);
|
|
const prototype = tmp5.prototype;
|
|
tmp = new tmp5(tmp, self.options);
|
|
}
|
|
let num2 = 0;
|
|
if (0 < self.set.length) {
|
|
while (!callback4(self.set[num2], tmp, self.options)) {
|
|
num2 = num2 + 1;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
return __exportStarResult1(Range, items);
|
|
}();
|