350 lines
11 KiB
JavaScript
350 lines
11 KiB
JavaScript
// Module ID: 536
|
|
// Function ID: 537
|
|
// Name: items
|
|
// Dependencies: [534]
|
|
|
|
// Module 536 (items)
|
|
import _mod534 from "module_534" /* 534 */;
|
|
|
|
let items = [];
|
|
let num = 0;
|
|
do {
|
|
let tmp = num;
|
|
let str = "";
|
|
if (num < 16) {
|
|
str = "0";
|
|
}
|
|
let str2 = str + require("module_16");
|
|
let arr = items.push(`%${str2.toUpperCase()}`);
|
|
num = num + 1;
|
|
} while (num < 256);
|
|
function arrayToObject(arg0, plainObjects) {
|
|
if (plainObjects) {
|
|
if (plainObjects.plainObjects) {
|
|
let obj = Object.create(null);
|
|
}
|
|
for (let num = 0; num < arg0.length; num = num + 1) {
|
|
let tmp3 = num;
|
|
if (undefined !== arg0[num]) {
|
|
obj[num] = arg0[num];
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
obj = {};
|
|
}
|
|
let c6 = 1024;
|
|
function merge(arr, obj, plainObjects) {
|
|
closure_0 = arr;
|
|
closure_1 = obj;
|
|
closure_2 = plainObjects;
|
|
if (obj) {
|
|
if (typeof obj !== "object") {
|
|
if (typeof obj !== "function") {
|
|
if (isArray(arr)) {
|
|
arr.push(obj);
|
|
} else {
|
|
if (arr) {
|
|
if (typeof arr === "object") {
|
|
let tmp11 = plainObjects;
|
|
if (plainObjects) {
|
|
tmp11 = plainObjects.plainObjects || plainObjects.allowPrototypes;
|
|
const tmp10 = plainObjects.plainObjects || plainObjects.allowPrototypes;
|
|
}
|
|
if (tmp11) {
|
|
if (tmp11) {
|
|
arr[obj] = true;
|
|
}
|
|
} else {
|
|
let call = closure_2.call;
|
|
const _Object2 = Object;
|
|
!(typeof call === "unknown" ? closure_2(obj) : call(prototype, obj));
|
|
const tmp12 = closure_2;
|
|
}
|
|
}
|
|
}
|
|
items = [arr, obj];
|
|
return items;
|
|
}
|
|
return arr;
|
|
}
|
|
}
|
|
if (arr) {
|
|
if (typeof arr === "object") {
|
|
let tmp2 = arr;
|
|
if (tmp) {
|
|
if (typeof arrayToObject !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
if (plainObjects) {
|
|
if (plainObjects.plainObjects) {
|
|
obj = Object.create(null);
|
|
}
|
|
let num = 0;
|
|
tmp2 = obj;
|
|
if (0 < arr.length) {
|
|
do {
|
|
let tmp5 = num;
|
|
if (undefined !== arr[num]) {
|
|
obj[num] = arr[num];
|
|
}
|
|
num = num + 1;
|
|
tmp2 = obj;
|
|
} while (num < arr.length);
|
|
}
|
|
}
|
|
obj = {};
|
|
}
|
|
if (isArray(arr)) {
|
|
if (tmp16(obj)) {
|
|
const item = obj.forEach((obj) => {
|
|
const call = closure_2.call;
|
|
arr = closure_0;
|
|
if (typeof call === "unknown" ? closure_2(arg1) : call(arr, arg1)) {
|
|
if (arr[arg1]) {
|
|
if (typeof tmp2 === "object") {
|
|
if (obj) {
|
|
if (typeof obj === "object") {
|
|
arr[arg1] = closure_1_7(tmp2, obj, closure_2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
arr = arr.push(obj);
|
|
} else {
|
|
arr[arg1] = obj;
|
|
}
|
|
});
|
|
let reduced = arr;
|
|
}
|
|
return reduced;
|
|
}
|
|
const _Object = Object;
|
|
const keys = Object.keys(obj);
|
|
reduced = keys.reduce((arg0, arg1) => {
|
|
const call = closure_2.call;
|
|
if (typeof call === "unknown" ? closure_2(arg1) : call(arg0, arg1)) {
|
|
arg0[arg1] = closure_1_7(arg0[arg1], tmp, closure_2);
|
|
} else {
|
|
arg0[arg1] = tmp;
|
|
}
|
|
return arg0;
|
|
}, tmp2);
|
|
tmp = isArray(arr) && !isArray(obj);
|
|
}
|
|
}
|
|
const items1 = [arr];
|
|
return items1.concat(obj);
|
|
} else {
|
|
return arr;
|
|
}
|
|
}
|
|
|
|
export default {
|
|
arrayToObject,
|
|
assign: function assignSingleSource(arg0, arg1) {
|
|
closure_0 = arg1;
|
|
const keys = Object.keys(arg1);
|
|
return keys.reduce((arg0, arg1) => {
|
|
arg0[arg1] = table[arg1];
|
|
return arg0;
|
|
}, arg0);
|
|
},
|
|
combine(arg0, arg1) {
|
|
items = [];
|
|
return items.concat(arg0, arg1);
|
|
},
|
|
compact(o) {
|
|
let obj = { o };
|
|
items = [{ obj, prop: "o" }];
|
|
const items1 = [];
|
|
for (let num = 0; num < items.length; num = num + 1) {
|
|
let tmp = items[num];
|
|
let tmp2 = tmp.obj[tmp.prop];
|
|
let _Object = Object;
|
|
let keys = Object.keys(tmp2);
|
|
let tmp3 = num;
|
|
for (let num2 = 0; num2 < keys.length; num2 = num2 + 1) {
|
|
let tmp4 = keys[num2];
|
|
let tmp5 = tmp2[tmp4];
|
|
let tmp6 = typeof tmp5 === "object";
|
|
let tmp7 = num2;
|
|
if (typeof tmp5 === "object") {
|
|
tmp6 = null !== tmp5;
|
|
}
|
|
if (tmp6) {
|
|
tmp6 = -1 === items1.indexOf(tmp5);
|
|
}
|
|
if (tmp6) {
|
|
obj = { obj: null, prop: null };
|
|
obj[0] = tmp2;
|
|
obj[1] = tmp4;
|
|
let arr = items.push(obj);
|
|
arr = items1.push(tmp5);
|
|
}
|
|
}
|
|
}
|
|
if (items.length > 1) {
|
|
do {
|
|
let arr1 = items.pop();
|
|
let arr4 = arr1.obj[arr1.prop];
|
|
let tmp11 = isArray;
|
|
if (isArray(arr4)) {
|
|
let items2 = [];
|
|
for (let num3 = 0; num3 < arr4.length; num3 = num3 + 1) {
|
|
let tmp12 = num3;
|
|
if (undefined !== arr4[num3]) {
|
|
let arr2 = items2.push(arr4[num3]);
|
|
}
|
|
}
|
|
arr1.obj[arr1.prop] = items2;
|
|
}
|
|
} while (items.length > 1);
|
|
}
|
|
return o;
|
|
},
|
|
decode(str) {
|
|
str = str.replace(/\+/g, " ");
|
|
if ("iso-8859-1" === arg2) {
|
|
const _unescape = unescape;
|
|
return str.replace(/%[0-9a-f]{2}/gi, unescape);
|
|
} else {
|
|
try {
|
|
const _decodeURIComponent = decodeURIComponent;
|
|
return decodeURIComponent(str);
|
|
} catch (err) {
|
|
return tmp;
|
|
}
|
|
}
|
|
},
|
|
encode(str) {
|
|
if (0 === str.length) {
|
|
return str;
|
|
} else if (typeof str === "symbol") {
|
|
const _Symbol = Symbol;
|
|
const call = toString.call;
|
|
typeof call === "unknown" ? toString() : call(str);
|
|
} else {
|
|
let StringResult = str;
|
|
if (typeof str !== "string") {
|
|
const _String = String;
|
|
StringResult = String(str);
|
|
}
|
|
if ("iso-8859-1" === arg2) {
|
|
const _escape = escape;
|
|
return escape(StringResult).replace(/%u[0-9a-f]{4}/gi, (arr) => "%26%23" + parseInt(arr.slice(2), 16) + "%3B");
|
|
} else {
|
|
let num2 = 0;
|
|
let str2 = "";
|
|
let str3 = "";
|
|
if (0 < StringResult.length) {
|
|
do {
|
|
let tmp5 = num2;
|
|
let tmp6 = str2;
|
|
let substr = StringResult;
|
|
if (StringResult.length >= c6) {
|
|
substr = StringResult.slice(num2, num2 + tmp4);
|
|
}
|
|
items = [];
|
|
let num = 0;
|
|
if (0 < substr.length) {
|
|
while (true) {
|
|
let charCodeAtResult = substr.charCodeAt(num);
|
|
let tmp8 = num;
|
|
if (45 !== charCodeAtResult) {
|
|
if (46 !== charCodeAtResult) {
|
|
if (95 !== charCodeAtResult) {
|
|
if (126 !== charCodeAtResult) {
|
|
if (charCodeAtResult < 48) {
|
|
if (charCodeAtResult < 65) {
|
|
if (charCodeAtResult < 97) {
|
|
let tmp9 = require;
|
|
let tmp10 = dependencyMap;
|
|
if (arg4 !== _mod534.RFC1738) {
|
|
if (charCodeAtResult < 128) {
|
|
let tmp14 = items;
|
|
items[items.length] = items[charCodeAtResult];
|
|
let sum = num;
|
|
} else if (charCodeAtResult < 2048) {
|
|
let tmp13 = items;
|
|
items[items.length] = items[192 | charCodeAtResult >> 6] + items[128 | 63 & charCodeAtResult];
|
|
sum = num;
|
|
} else {
|
|
if (charCodeAtResult >= 55296) {
|
|
if (charCodeAtResult < 57344) {
|
|
sum = num + 1;
|
|
let tmp18 = 1023 & charCodeAtResult;
|
|
let sum1 = 65536 + (tmp18 << 10 | 1023 & substr.charCodeAt(sum));
|
|
let tmp20 = items;
|
|
items[items.length] = items[240 | sum1 >> 18] + items[128 | sum1 >> 12 & 63] + items[128 | sum1 >> 6 & 63] + items[128 | 63 & sum1];
|
|
}
|
|
}
|
|
let tmp11 = items;
|
|
items[items.length] = items[224 | charCodeAtResult >> 12] + items[128 | charCodeAtResult >> 6 & 63] + items[128 | 63 & charCodeAtResult];
|
|
sum = num;
|
|
}
|
|
num = sum + 1;
|
|
if (num >= substr.length) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
items[items.length] = substr.charAt(num);
|
|
sum = num;
|
|
}
|
|
}
|
|
str2 = str2 + items.join("");
|
|
let tmp15 = c6;
|
|
num2 = num2 + c6;
|
|
str3 = str2;
|
|
} while (num2 < StringResult.length);
|
|
}
|
|
return str3;
|
|
}
|
|
}
|
|
},
|
|
isBuffer(obj) {
|
|
let tmp = !obj;
|
|
if (obj) {
|
|
tmp = typeof obj !== "object";
|
|
}
|
|
let tmp2 = !tmp;
|
|
if (!tmp) {
|
|
let isBufferResult = obj.constructor && obj.constructor.isBuffer;
|
|
if (isBufferResult) {
|
|
const constructor = obj.constructor;
|
|
isBufferResult = constructor.isBuffer(obj);
|
|
}
|
|
tmp2 = isBufferResult;
|
|
}
|
|
return tmp2;
|
|
},
|
|
isRegExp(arg0) {
|
|
const call = toString.call;
|
|
return "[object RegExp]" === (typeof call === "unknown" ? toString() : call(arg0));
|
|
},
|
|
maybeMap(parts1, arg1) {
|
|
let length;
|
|
if (isArray(parts1)) {
|
|
items = [];
|
|
let num = 0;
|
|
if (0 < parts1.length) {
|
|
do {
|
|
let arr = items.push(arg1(parts1[num]));
|
|
num = num + 1;
|
|
length = parts1.length;
|
|
} while (num < length);
|
|
}
|
|
return items;
|
|
} else {
|
|
return arg1(parts1);
|
|
}
|
|
},
|
|
merge
|
|
};
|