531 lines
17 KiB
JavaScript
531 lines
17 KiB
JavaScript
// Module ID: 514
|
|
// Function ID: 6589
|
|
// Name: pushToArray
|
|
// Dependencies: []
|
|
|
|
// Module 514 (pushToArray)
|
|
let obj = {
|
|
brackets(arg0) {
|
|
return arg0 + "[]";
|
|
},
|
|
comma: "comma",
|
|
indices(arg0, arg1) {
|
|
return arg0 + "[" + arg1 + "]";
|
|
},
|
|
repeat(arg0) {
|
|
return arg0;
|
|
}
|
|
};
|
|
function pushToArray(arg0, arg1) {
|
|
let tmp2 = arg1;
|
|
if (!isArray(arg1)) {
|
|
const items = [arg1];
|
|
tmp2 = items;
|
|
}
|
|
push.apply(arg0, tmp2);
|
|
}
|
|
obj = {
|
|
"Bool(false)": "<string:2159231459>",
|
|
"Bool(false)": "<string:1360068609>",
|
|
"Bool(false)": "<string:2705467300>",
|
|
"Bool(false)": "<string:1409286744>",
|
|
"Bool(false)": "<string:1358955042>",
|
|
"Bool(false)": "<string:1895992845>",
|
|
"Bool(false)": "isArray",
|
|
"Bool(false)": "handleHeaderLayout",
|
|
"Bool(false)": "isArray",
|
|
"Bool(false)": "<string:587268096>",
|
|
"Bool(false)": "MediaManager",
|
|
"Bool(false)": "<string:1896022016>",
|
|
encoder: require(dependencyMap[0]).encode,
|
|
filter: undefined,
|
|
format: require(dependencyMap[1]).default,
|
|
formatter: require(dependencyMap[1]).formatters[require(undefined, dependencyMap[1]).default],
|
|
indices: false,
|
|
serializeDate(arg0) {
|
|
return toISOString.call(arg0);
|
|
},
|
|
skipNulls: false,
|
|
strictNullHandling: false
|
|
};
|
|
let closure_9 = {};
|
|
function stringify(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, get) {
|
|
const require = arg12;
|
|
let value = get.get(closure_9);
|
|
let num = 0;
|
|
let flag = false;
|
|
let num2 = 0;
|
|
if (undefined !== value) {
|
|
while (true) {
|
|
value = value.get(arg0);
|
|
let num3 = num + 1;
|
|
let tmp2 = value;
|
|
if (undefined !== value) {
|
|
flag = true;
|
|
if (value === num3) {
|
|
break;
|
|
}
|
|
}
|
|
let tmp3 = closure_9;
|
|
if (undefined === value.get(closure_9)) {
|
|
num3 = 0;
|
|
}
|
|
let tmp4 = closure_9;
|
|
let value1 = value.get(closure_9);
|
|
num2 = num3;
|
|
if (undefined !== value1) {
|
|
value = value1;
|
|
num = num3;
|
|
num2 = num3;
|
|
}
|
|
}
|
|
const _RangeError = RangeError;
|
|
const rangeError = new RangeError("Cyclic object value");
|
|
throw rangeError;
|
|
}
|
|
if ("function" === typeof arg9) {
|
|
let str2 = arg9(arg1, arg0);
|
|
} else {
|
|
const _Date = Date;
|
|
if (arg0 instanceof Date) {
|
|
str2 = arg12(arg0);
|
|
} else {
|
|
let tmp7 = "comma" === arg2;
|
|
if (tmp7) {
|
|
tmp7 = isArray(arg0);
|
|
}
|
|
str2 = arg0;
|
|
if (tmp7) {
|
|
str2 = require(dependencyMap[0]).maybeMap(arg0, (arg0) => {
|
|
let tmp = arg0;
|
|
if (arg0 instanceof Date) {
|
|
tmp = arg12(arg0);
|
|
}
|
|
return tmp;
|
|
});
|
|
const obj2 = require(dependencyMap[0]);
|
|
}
|
|
}
|
|
}
|
|
if (null === str2) {
|
|
str2 = "";
|
|
if (arg5) {
|
|
let tmp77 = arg1;
|
|
if (arg8) {
|
|
tmp77 = arg1;
|
|
if (!arg15) {
|
|
tmp77 = arg8(arg1, obj.encoder, arg16, "key", arg13);
|
|
}
|
|
}
|
|
return tmp77;
|
|
}
|
|
}
|
|
let tmp12 = "string" === tmp11;
|
|
if (!tmp12) {
|
|
tmp12 = "number" === tmp11;
|
|
}
|
|
if (!tmp12) {
|
|
tmp12 = "boolean" === tmp11;
|
|
}
|
|
if (!tmp12) {
|
|
tmp12 = "symbol" === tmp11;
|
|
}
|
|
if (!tmp12) {
|
|
tmp12 = "bigint" === tmp11;
|
|
}
|
|
if (!tmp12) {
|
|
if (!obj3.isBuffer(str2)) {
|
|
const items = [];
|
|
if (undefined === str2) {
|
|
return items;
|
|
} else {
|
|
if ("comma" === arg2) {
|
|
if (isArray(str2)) {
|
|
let tmp19 = arg15;
|
|
if (arg15) {
|
|
tmp19 = arg8;
|
|
}
|
|
let maybeMapResult = str2;
|
|
if (tmp19) {
|
|
maybeMapResult = require(dependencyMap[0]).maybeMap(str2, arg8);
|
|
const obj5 = require(dependencyMap[0]);
|
|
}
|
|
const obj = {};
|
|
let tmp22;
|
|
if (maybeMapResult.length > 0) {
|
|
tmp22 = maybeMapResult.join(",") || null;
|
|
const tmp23 = maybeMapResult.join(",") || null;
|
|
}
|
|
obj.value = tmp22;
|
|
const items1 = [obj];
|
|
let arr2 = maybeMapResult;
|
|
let arr3 = items1;
|
|
}
|
|
const _String = String;
|
|
const str8 = String(arg1);
|
|
if (arg7) {
|
|
let replaced = str8.replace(/\./g, "%2E");
|
|
} else {
|
|
replaced = str8;
|
|
}
|
|
let text = replaced;
|
|
if (arg3) {
|
|
text = replaced;
|
|
if (isArray(arr2)) {
|
|
text = replaced;
|
|
if (1 === arr2.length) {
|
|
text = `${tmp25}[]`;
|
|
}
|
|
}
|
|
}
|
|
if (arg4) {
|
|
if (isArray(arr2)) {
|
|
if (0 === arr2.length) {
|
|
return text + "[]";
|
|
}
|
|
}
|
|
}
|
|
let num5 = 0;
|
|
if (0 < arr3.length) {
|
|
while (true) {
|
|
let iter = arr3[num5];
|
|
if ("object" === typeof iter) {
|
|
if (iter) {
|
|
if (undefined !== iter.value) {
|
|
value = iter.value;
|
|
if (!arg6) {
|
|
if (arg11) {
|
|
if (arg7) {
|
|
let _String3 = String;
|
|
let str16 = String(iter);
|
|
let replaced1 = str16.replace(/\./g, "%2E");
|
|
let tmp31 = isArray;
|
|
if (isArray(arr2)) {
|
|
let tmp34 = text;
|
|
if ("function" === tmp29) {
|
|
tmp34 = arg2(text, replaced1);
|
|
}
|
|
let sum = tmp34;
|
|
} else {
|
|
if (arg11) {
|
|
let text1 = `.${tmp30}`;
|
|
} else {
|
|
text1 = `${"[" + tmp30}]`;
|
|
}
|
|
sum = text + text1;
|
|
}
|
|
let result = get.set(arg0, num2);
|
|
let tmp36 = require;
|
|
let tmp37 = dependencyMap;
|
|
let obj7 = require(dependencyMap[2])();
|
|
let tmp38 = closure_9;
|
|
let result1 = obj7.set(closure_9, get);
|
|
if (tmp87) {
|
|
if (arg15) {
|
|
let tmp42 = isArray;
|
|
let tmp43 = null;
|
|
}
|
|
let tmp44 = value;
|
|
let tmp45 = sum;
|
|
let tmp46 = arg2;
|
|
let tmp47 = arg3;
|
|
let tmp48 = arg4;
|
|
let tmp49 = arg5;
|
|
let tmp50 = arg6;
|
|
let tmp51 = arg7;
|
|
let tmp52 = tmp43;
|
|
let tmp53 = arg9;
|
|
let tmp54 = arg10;
|
|
let tmp55 = arg11;
|
|
let tmp56 = arg12;
|
|
let tmp57 = arg13;
|
|
let tmp58 = arg14;
|
|
let tmp59 = arg15;
|
|
let tmp60 = arg16;
|
|
let tmp61 = obj7;
|
|
let tmp40Result = tmp40(items, tmp41(value, sum, arg2, arg3, arg4, arg5, arg6, arg7, tmp43, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, obj7));
|
|
let tmp63 = replaced1;
|
|
let tmp64 = obj7;
|
|
}
|
|
tmp43 = arg8;
|
|
}
|
|
}
|
|
let _String2 = String;
|
|
replaced1 = String(iter);
|
|
}
|
|
num5 = num5 + 1;
|
|
if (num5 >= arr3.length) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
value = arr2[iter];
|
|
}
|
|
}
|
|
return items;
|
|
}
|
|
arr2 = str2;
|
|
arr3 = arg9;
|
|
if (!isArray(arg9)) {
|
|
const _Object = Object;
|
|
const keys = Object.keys(str2);
|
|
let sorted = keys;
|
|
if (arg10) {
|
|
sorted = keys.sort(arg10);
|
|
}
|
|
arr3 = sorted;
|
|
arr2 = str2;
|
|
}
|
|
}
|
|
}
|
|
const obj3 = require(dependencyMap[0]);
|
|
}
|
|
if (arg8) {
|
|
let tmp67 = arg1;
|
|
if (!arg15) {
|
|
tmp67 = arg8(arg1, obj.encoder, arg16, "key", arg13);
|
|
}
|
|
const text2 = `${arg14(tmp67)}=`;
|
|
const items2 = [`${arg14(tmp67)}=` + arg14(arg8(str2, obj.encoder, arg16, "value", arg13))];
|
|
let items3 = items2;
|
|
} else {
|
|
const _String4 = String;
|
|
const text3 = `${arg14(arg1)}=`;
|
|
items3 = [`${arg14(arg1)}=` + arg14(String(str2))];
|
|
}
|
|
return items3;
|
|
}
|
|
|
|
export default (arg0, allowEmptyArrays) => {
|
|
let allowEmptyArrays2;
|
|
let encodeDotInKeys2;
|
|
let skipNulls2;
|
|
let strictNullHandling2;
|
|
if (allowEmptyArrays) {
|
|
if (undefined !== allowEmptyArrays.allowEmptyArrays) {
|
|
if ("boolean" !== typeof allowEmptyArrays.allowEmptyArrays) {
|
|
const _TypeError6 = TypeError;
|
|
const typeError = new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (undefined !== allowEmptyArrays.encodeDotInKeys) {
|
|
if ("boolean" !== typeof allowEmptyArrays.encodeDotInKeys) {
|
|
const _TypeError5 = TypeError;
|
|
const typeError1 = new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
|
|
throw typeError1;
|
|
}
|
|
}
|
|
if (null !== allowEmptyArrays.encoder) {
|
|
if (undefined !== allowEmptyArrays.encoder) {
|
|
if ("function" !== typeof allowEmptyArrays.encoder) {
|
|
const _TypeError4 = TypeError;
|
|
const typeError2 = new TypeError("Encoder has to be a function.");
|
|
throw typeError2;
|
|
}
|
|
}
|
|
}
|
|
let charset = allowEmptyArrays.charset;
|
|
if (!charset) {
|
|
charset = obj.charset;
|
|
}
|
|
if (undefined !== allowEmptyArrays.charset) {
|
|
if ("utf-8" !== allowEmptyArrays.charset) {
|
|
if ("iso-8859-1" !== allowEmptyArrays.charset) {
|
|
const _TypeError3 = TypeError;
|
|
const typeError3 = new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
|
|
throw typeError3;
|
|
}
|
|
}
|
|
}
|
|
let format = require(dependencyMap[1]).default;
|
|
if (undefined !== allowEmptyArrays.format) {
|
|
if (hasOwnProperty.call(require(dependencyMap[1]).formatters, allowEmptyArrays.format)) {
|
|
format = allowEmptyArrays.format;
|
|
} else {
|
|
const _TypeError = TypeError;
|
|
const typeError4 = new TypeError("Unknown format option provided.");
|
|
throw typeError4;
|
|
}
|
|
}
|
|
let filter = obj.filter;
|
|
let tmp16 = "function" === typeof allowEmptyArrays.filter;
|
|
if (!tmp16) {
|
|
tmp16 = isArray(allowEmptyArrays.filter);
|
|
}
|
|
if (tmp16) {
|
|
filter = allowEmptyArrays.filter;
|
|
}
|
|
if (allowEmptyArrays.arrayFormat in obj) {
|
|
let arrayFormat = allowEmptyArrays.arrayFormat;
|
|
} else if ("indices" in allowEmptyArrays) {
|
|
let str9 = "repeat";
|
|
if (allowEmptyArrays.indices) {
|
|
str9 = "indices";
|
|
}
|
|
arrayFormat = str9;
|
|
} else {
|
|
arrayFormat = obj.arrayFormat;
|
|
}
|
|
if ("commaRoundTrip" in allowEmptyArrays) {
|
|
if ("boolean" !== typeof allowEmptyArrays.commaRoundTrip) {
|
|
const _TypeError2 = TypeError;
|
|
const typeError5 = new TypeError("`commaRoundTrip` must be a boolean, or absent");
|
|
throw typeError5;
|
|
}
|
|
}
|
|
if (undefined === allowEmptyArrays.allowDots) {
|
|
let allowDots = true === allowEmptyArrays.encodeDotInKeys;
|
|
if (!allowDots) {
|
|
allowDots = obj.allowDots;
|
|
}
|
|
} else {
|
|
allowDots = allowEmptyArrays.allowDots;
|
|
}
|
|
const obj = {};
|
|
if ("boolean" === typeof allowEmptyArrays.addQueryPrefix) {
|
|
let addQueryPrefix = allowEmptyArrays.addQueryPrefix;
|
|
} else {
|
|
addQueryPrefix = obj.addQueryPrefix;
|
|
}
|
|
obj.addQueryPrefix = addQueryPrefix;
|
|
obj.allowDots = allowDots;
|
|
if ("boolean" === typeof allowEmptyArrays.allowEmptyArrays) {
|
|
allowEmptyArrays = allowEmptyArrays.allowEmptyArrays;
|
|
} else {
|
|
allowEmptyArrays = obj.allowEmptyArrays;
|
|
}
|
|
obj.allowEmptyArrays = allowEmptyArrays;
|
|
obj.arrayFormat = arrayFormat;
|
|
obj.charset = charset;
|
|
if ("boolean" === typeof allowEmptyArrays.charsetSentinel) {
|
|
let charsetSentinel = allowEmptyArrays.charsetSentinel;
|
|
} else {
|
|
charsetSentinel = obj.charsetSentinel;
|
|
}
|
|
obj.charsetSentinel = charsetSentinel;
|
|
obj.commaRoundTrip = allowEmptyArrays.commaRoundTrip;
|
|
if (undefined === allowEmptyArrays.delimiter) {
|
|
let delimiter = obj.delimiter;
|
|
} else {
|
|
delimiter = allowEmptyArrays.delimiter;
|
|
}
|
|
obj.delimiter = delimiter;
|
|
if ("boolean" === typeof allowEmptyArrays.encode) {
|
|
let encode = allowEmptyArrays.encode;
|
|
} else {
|
|
encode = obj.encode;
|
|
}
|
|
obj.encode = encode;
|
|
if ("boolean" === typeof allowEmptyArrays.encodeDotInKeys) {
|
|
let encodeDotInKeys = allowEmptyArrays.encodeDotInKeys;
|
|
} else {
|
|
encodeDotInKeys = obj.encodeDotInKeys;
|
|
}
|
|
obj.encodeDotInKeys = encodeDotInKeys;
|
|
if ("function" === typeof allowEmptyArrays.encoder) {
|
|
let encoder = allowEmptyArrays.encoder;
|
|
} else {
|
|
encoder = obj.encoder;
|
|
}
|
|
obj.encoder = encoder;
|
|
if ("boolean" === typeof allowEmptyArrays.encodeValuesOnly) {
|
|
let encodeValuesOnly = allowEmptyArrays.encodeValuesOnly;
|
|
} else {
|
|
encodeValuesOnly = obj.encodeValuesOnly;
|
|
}
|
|
obj.encodeValuesOnly = encodeValuesOnly;
|
|
obj.filter = filter;
|
|
obj.format = format;
|
|
obj.formatter = require(dependencyMap[1]).formatters[format];
|
|
if ("function" === typeof allowEmptyArrays.serializeDate) {
|
|
let serializeDate = allowEmptyArrays.serializeDate;
|
|
} else {
|
|
serializeDate = obj.serializeDate;
|
|
}
|
|
obj.serializeDate = serializeDate;
|
|
if ("boolean" === typeof allowEmptyArrays.skipNulls) {
|
|
let skipNulls = allowEmptyArrays.skipNulls;
|
|
} else {
|
|
skipNulls = obj.skipNulls;
|
|
}
|
|
obj.skipNulls = skipNulls;
|
|
let sort = null;
|
|
if ("function" === typeof allowEmptyArrays.sort) {
|
|
sort = allowEmptyArrays.sort;
|
|
}
|
|
obj.sort = sort;
|
|
if ("boolean" === typeof allowEmptyArrays.strictNullHandling) {
|
|
let strictNullHandling = allowEmptyArrays.strictNullHandling;
|
|
} else {
|
|
strictNullHandling = obj.strictNullHandling;
|
|
}
|
|
obj.strictNullHandling = strictNullHandling;
|
|
} else {
|
|
if ("function" === typeof obj.filter) {
|
|
let found = arr.filter("", arg0);
|
|
} else {
|
|
found = arg0;
|
|
if (isArray(arr.filter)) {
|
|
filter = arr.filter;
|
|
found = arg0;
|
|
}
|
|
}
|
|
const items = [];
|
|
if ("object" === typeof found) {
|
|
if (null !== found) {
|
|
if (!filter) {
|
|
const _Object = Object;
|
|
filter = Object.keys(found);
|
|
}
|
|
if (arr.sort) {
|
|
const sorted = filter.sort(arr.sort);
|
|
}
|
|
const tmp42 = require(dependencyMap[2])();
|
|
for (let num4 = 0; num4 < filter.length; num4 = num4 + 1) {
|
|
let tmp43 = filter[num4];
|
|
let tmp44 = found[tmp43];
|
|
let tmp45 = arr.skipNulls && null === tmp44;
|
|
if (!tmp45) {
|
|
({ allowEmptyArrays: allowEmptyArrays2, strictNullHandling: strictNullHandling2, skipNulls: skipNulls2, encodeDotInKeys: encodeDotInKeys2 } = arr);
|
|
encoder = null;
|
|
let tmp46 = pushToArray;
|
|
let tmp47 = stringify;
|
|
if (arr.encode) {
|
|
encoder = arr.encoder;
|
|
}
|
|
let tmp49 = tmp44;
|
|
let tmp50 = tmp43;
|
|
let tmp51 = tmp90;
|
|
let tmp52 = tmp37;
|
|
let tmp53 = allowEmptyArrays2;
|
|
let tmp54 = strictNullHandling2;
|
|
let tmp55 = skipNulls2;
|
|
let tmp56 = encodeDotInKeys2;
|
|
let tmp57 = encoder;
|
|
let tmp58 = tmp42;
|
|
let tmp46Result = tmp46(items, tmp47(tmp44, tmp43, tmp90, tmp37, allowEmptyArrays2, strictNullHandling2, skipNulls2, encodeDotInKeys2, encoder, arr.filter, arr.sort, arr.allowDots, arr.serializeDate, arr.format, arr.formatter, arr.encodeValuesOnly, arr.charset, tmp42));
|
|
}
|
|
}
|
|
const joined = items.join(arr.delimiter);
|
|
let str16 = "";
|
|
let str17 = "";
|
|
if (true === arr.addQueryPrefix) {
|
|
str17 = "?";
|
|
}
|
|
if (!arr.charsetSentinel) {
|
|
if (joined.length > 0) {
|
|
str16 = str17 + joined;
|
|
}
|
|
return str16;
|
|
} else if ("iso-8859-1" === arr.charset) {
|
|
let text = `${str17}utf8=%26%2310003%3B&`;
|
|
} else {
|
|
text = `${str17}utf8=%E2%9C%93&`;
|
|
}
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
};
|