1271 lines
48 KiB
React
1271 lines
48 KiB
React
/* Metro module 512; source: unknown; dependencies: [513] */
|
|
function _fun6560(global, require, importDefault, importAll, module, exports, dependencyMap) { // fn#6560, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:6, offset: 0x00cff298, size: 136 bytes, params: 8, frame: 13
|
|
const env0_0 = require;
|
|
const Object = global.Object;
|
|
const env0_2 = Object.prototype.hasOwnProperty;
|
|
const Array = global.Array;
|
|
const env0_3 = Array.isArray;
|
|
({'allowDots': false, 'allowEmptyArrays': false, 'allowPrototypes': false, 'allowSparse': false, 'arrayLimit': 20,
|
|
'charset': 'utf-8', 'charsetSentinel': false, 'comma': false, 'decodeDotInKeys': false, 'decoder': null,
|
|
'delimiter': '&', 'depth': 5, 'duplicates': 'combine', 'ignoreQueryPrefix': false,
|
|
'interpretNumericEntities': false, 'parameterLimit': 1000, 'parseArrays': true, 'plainObjects': false,
|
|
'strictDepth': false, 'strictNullHandling': false,
|
|
'throwOnLimitExceeded': false}).decoder = (require(513) /* metro dependency 513 */).decode;
|
|
const interpretNumericEntities = function(a0) {
|
|
return a0.replace(RegExp('&#(\\d+);', 'g'), _fun6562);
|
|
};
|
|
module.exports = exports_6565;
|
|
}
|
|
|
|
function interpretNumericEntities(a0) { // fn#6561, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:474, offset: 0x00cff320, size: 37 bytes, params: 2, frame: 13
|
|
return a0.replace(RegExp('&#(\\d+);', 'g'), function(a0, a1) {
|
|
var String = global.String;
|
|
return String.fromCharCode((0, global.parseInt)(a1, 10));
|
|
});
|
|
}
|
|
|
|
function parseArrayValue(a0, a1, a2) { // fn#6563, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:604, offset: 0x00cff36e, size: 181 bytes, params: 4, frame: 15
|
|
var r5;
|
|
var value;
|
|
var arrayLimit;
|
|
var RangeError;
|
|
var value4;
|
|
var rangeError;
|
|
if (a0) {
|
|
if (typeof a0 !== 'string') {
|
|
if (a1.throwOnLimitExceeded) {
|
|
arrayLimit = a1.arrayLimit;
|
|
if (a2 >= arrayLimit) {
|
|
RangeError = global.RangeError;
|
|
arrayLimit = a1.arrayLimit;
|
|
value = 'Array limit exceeded. Only ' + arrayLimit;
|
|
arrayLimit = a1.arrayLimit;
|
|
r5 = arrayLimit !== 1 ? 's' : '';
|
|
value4 = Object.create(RangeError.prototype, {constructor: {value: RangeError}});
|
|
value = value + ' element' + r5 + ' allowed in an array.';
|
|
rangeError = new RangeError();
|
|
value = rangeError instanceof Object ? rangeError : value4;
|
|
throw value;
|
|
}
|
|
return a0;
|
|
}
|
|
return a0;
|
|
}
|
|
if (a1.comma) {
|
|
value = a0.indexOf(',');
|
|
if (value > -1) {
|
|
return a0.split(',');
|
|
}
|
|
if (a1.throwOnLimitExceeded) {
|
|
arrayLimit = a1.arrayLimit;
|
|
if (a2 >= arrayLimit) {
|
|
RangeError = global.RangeError;
|
|
arrayLimit = a1.arrayLimit;
|
|
value = 'Array limit exceeded. Only ' + arrayLimit;
|
|
arrayLimit = a1.arrayLimit;
|
|
r5 = arrayLimit !== 1 ? 's' : '';
|
|
value4 = Object.create(RangeError.prototype, {constructor: {value: RangeError}});
|
|
value = value + ' element' + r5 + ' allowed in an array.';
|
|
rangeError = new RangeError();
|
|
value = rangeError instanceof Object ? rangeError : value4;
|
|
throw value;
|
|
}
|
|
return a0;
|
|
}
|
|
return a0;
|
|
}
|
|
if (a1.throwOnLimitExceeded) {
|
|
arrayLimit = a1.arrayLimit;
|
|
if (a2 >= arrayLimit) {
|
|
RangeError = global.RangeError;
|
|
arrayLimit = a1.arrayLimit;
|
|
value = 'Array limit exceeded. Only ' + arrayLimit;
|
|
arrayLimit = a1.arrayLimit;
|
|
r5 = arrayLimit !== 1 ? 's' : '';
|
|
value4 = Object.create(RangeError.prototype, {constructor: {value: RangeError}});
|
|
value = value + ' element' + r5 + ' allowed in an array.';
|
|
rangeError = new RangeError();
|
|
value = rangeError instanceof Object ? rangeError : value4;
|
|
throw value;
|
|
}
|
|
return a0;
|
|
}
|
|
} else if (a1.throwOnLimitExceeded) {
|
|
arrayLimit = a1.arrayLimit;
|
|
if (a2 >= arrayLimit) {
|
|
RangeError = global.RangeError;
|
|
arrayLimit = a1.arrayLimit;
|
|
value = 'Array limit exceeded. Only ' + arrayLimit;
|
|
arrayLimit = a1.arrayLimit;
|
|
r5 = arrayLimit !== 1 ? 's' : '';
|
|
value4 = Object.create(RangeError.prototype, {constructor: {value: RangeError}});
|
|
value = value + ' element' + r5 + ' allowed in an array.';
|
|
rangeError = new RangeError();
|
|
value = rangeError instanceof Object ? rangeError : value4;
|
|
throw value;
|
|
}
|
|
return a0;
|
|
}
|
|
return a0;
|
|
}
|
|
|
|
function parseQueryStringKeys(a0, a1, a2, a3) { // fn#6564, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:890, offset: 0x00cff423, size: 1138 bytes, params: 5, frame: 42
|
|
var r4;
|
|
var r1;
|
|
var r3;
|
|
var r6;
|
|
var length;
|
|
var r5;
|
|
var r18;
|
|
var r29;
|
|
var r28;
|
|
var r23;
|
|
var r26;
|
|
var r22;
|
|
var replace;
|
|
var regexp;
|
|
var depth;
|
|
var value3;
|
|
var regexp2;
|
|
var exec;
|
|
var value4;
|
|
var slice;
|
|
var index;
|
|
var value5;
|
|
var items3;
|
|
var plainObjects;
|
|
var value6;
|
|
var hasOwnPropertyBinding;
|
|
var call;
|
|
var Object;
|
|
var prototype;
|
|
var allowPrototypes;
|
|
var push;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
var property;
|
|
var value10;
|
|
var value12;
|
|
var join;
|
|
var value13;
|
|
var Array;
|
|
var isArray;
|
|
var value14;
|
|
var arrayValue;
|
|
var value15;
|
|
var parseArrays;
|
|
var value17;
|
|
var charAt;
|
|
var value18;
|
|
var decodeDotInKeys;
|
|
var value19;
|
|
var parseInt;
|
|
var int;
|
|
var isNaN;
|
|
var String;
|
|
var arrayLimit;
|
|
var items2;
|
|
var allowEmptyArrays;
|
|
var strictNullHandling;
|
|
var moduleValue;
|
|
var combine;
|
|
var value20;
|
|
var value21;
|
|
var RangeError;
|
|
var value22;
|
|
var rangeError;
|
|
let value = a0;
|
|
const value2 = a1;
|
|
if (value) {
|
|
reducibleJoin4: while (true) {
|
|
if (a2.allowDots) {
|
|
replace = value.replace;
|
|
value = Reflect.apply(replace, value, [RegExp('\\.([^.[]+)', 'g'), '[$1]']);
|
|
r4 = value;
|
|
break reducibleJoin4;
|
|
}
|
|
r4 = value;
|
|
break reducibleJoin4;
|
|
}
|
|
regexp = RegExp('(\\[[^[\\]]*])', 'g');
|
|
depth = a2.depth;
|
|
value = 0;
|
|
value3 = depth > value;
|
|
reducibleJoin6: while (true) {
|
|
if (value3) {
|
|
regexp2 = RegExp('(\\[[^[\\]]*])', '');
|
|
exec = regexp2.exec;
|
|
value4 = Reflect.apply(exec, regexp2, [r4]);
|
|
r1 = value4;
|
|
break reducibleJoin6;
|
|
}
|
|
r1 = value3;
|
|
break reducibleJoin6;
|
|
}
|
|
reducibleJoin8: while (true) {
|
|
if (r1) {
|
|
slice = r4.slice;
|
|
index = r1.index;
|
|
value5 = Reflect.apply(slice, r4, [value, index]);
|
|
r3 = value5;
|
|
break reducibleJoin8;
|
|
}
|
|
r3 = r4;
|
|
break reducibleJoin8;
|
|
}
|
|
items3 = [];
|
|
if (r3) {
|
|
plainObjects = a2.plainObjects;
|
|
reducibleJoin14: while (true) {
|
|
reducibleJoin13: while (true) {
|
|
if (plainObjects) {
|
|
break reducibleJoin13;
|
|
}
|
|
value6 = environment;
|
|
hasOwnPropertyBinding = hasOwnProperty;
|
|
call = hasOwnPropertyBinding.call;
|
|
Object = global.Object;
|
|
prototype = Object.prototype;
|
|
if (Reflect.apply(call, hasOwnPropertyBinding, [prototype, r3])) {
|
|
allowPrototypes = a2.allowPrototypes;
|
|
if (!allowPrototypes) {
|
|
return undefined;
|
|
}
|
|
break reducibleJoin13;
|
|
}
|
|
break reducibleJoin13;
|
|
}
|
|
push = items3.push;
|
|
Reflect.apply(push, items3, [r3]);
|
|
break reducibleJoin14;
|
|
}
|
|
}
|
|
depth = a2.depth;
|
|
if (depth > value) {
|
|
value7 = regexp.exec(r4);
|
|
reducibleJoin24: while (true) {
|
|
if (value7 === null) {
|
|
r1 = value7;
|
|
break reducibleJoin24;
|
|
}
|
|
depth = a2.depth;
|
|
value8 = environment;
|
|
if (!(value < depth)) {
|
|
r1 = value7;
|
|
break reducibleJoin24;
|
|
}
|
|
r3 = value;
|
|
r6 = value7;
|
|
reducibleLoop17: while (true) {
|
|
value9 = r3 + 1;
|
|
plainObjects = a2.plainObjects;
|
|
if (!plainObjects) {
|
|
hasOwnPropertyBinding = hasOwnProperty;
|
|
call = hasOwnPropertyBinding.call;
|
|
Object = global.Object;
|
|
prototype = Object.prototype;
|
|
property = r6[1];
|
|
slice = property.slice;
|
|
reducibleJoin21: while (true) {
|
|
if (Reflect.apply(call, hasOwnPropertyBinding, [prototype, Reflect.apply(slice, property,
|
|
[1,
|
|
-1])])) {
|
|
allowPrototypes = a2.allowPrototypes;
|
|
if (!allowPrototypes) {
|
|
return undefined;
|
|
}
|
|
break reducibleJoin21;
|
|
}
|
|
break reducibleJoin21;
|
|
}
|
|
}
|
|
push = items3.push;
|
|
Reflect.apply(push, items3, [r6[1]]);
|
|
depth = a2.depth;
|
|
if (depth > value) {
|
|
exec = regexp.exec;
|
|
value10 = Reflect.apply(exec, regexp, [r4]);
|
|
if (value10 === null) {
|
|
r1 = value10;
|
|
break reducibleJoin24;
|
|
}
|
|
depth = a2.depth;
|
|
if (value9 < depth) {
|
|
r3 = value9;
|
|
r6 = value10;
|
|
continue reducibleLoop17;
|
|
}
|
|
r1 = value10;
|
|
break reducibleJoin24;
|
|
}
|
|
r1 = r6;
|
|
break reducibleJoin24;
|
|
}
|
|
}
|
|
}
|
|
if (r1) {
|
|
if (a2.strictDepth === true) {
|
|
RangeError = global.RangeError;
|
|
value = 'Input depth exceeded depth option of ' + a2.depth;
|
|
value22 = Object.create(RangeError.prototype, {constructor: {value: RangeError}});
|
|
value += ' and strictDepth is true';
|
|
rangeError = new RangeError(value);
|
|
value = rangeError instanceof Object ? rangeError : value22;
|
|
throw value;
|
|
}
|
|
push = items3.push;
|
|
slice = r4.slice;
|
|
Reflect.apply(push, items3, ['[' + Reflect.apply(slice, r4, [r1.index]) + ']']);
|
|
}
|
|
length = items3.length;
|
|
reducibleJoin33: while (true) {
|
|
if (length > value) {
|
|
length = items3.length;
|
|
if (items3[length - 1] !== '[]') {
|
|
r4 = value;
|
|
break reducibleJoin33;
|
|
}
|
|
slice = items3.slice;
|
|
value12 = Reflect.apply(slice, items3, [value, -1]);
|
|
join = value12.join;
|
|
value13 = Reflect.apply(join, value12, ['']);
|
|
Array = global.Array;
|
|
isArray = Array.isArray;
|
|
reducibleJoin32: while (true) {
|
|
if (Reflect.apply(isArray, Array, [value2])) {
|
|
if (value2[value13]) {
|
|
length = value2[value13].length;
|
|
break reducibleJoin32;
|
|
}
|
|
length = value;
|
|
break reducibleJoin32;
|
|
}
|
|
length = value;
|
|
break reducibleJoin32;
|
|
}
|
|
r4 = length;
|
|
break reducibleJoin33;
|
|
}
|
|
r4 = value;
|
|
break reducibleJoin33;
|
|
}
|
|
reducibleJoin35: while (true) {
|
|
if (a3) {
|
|
r1 = value2;
|
|
break reducibleJoin35;
|
|
}
|
|
value14 = environment;
|
|
arrayValue = parseArrayValue(value2, a2, r4);
|
|
r1 = arrayValue;
|
|
break reducibleJoin35;
|
|
}
|
|
length = items3.length;
|
|
value15 = length - 1;
|
|
if (value15 >= value) {
|
|
r5 = r1;
|
|
r18 = value15;
|
|
reducibleLoop36: while (true) {
|
|
property = items3[r18];
|
|
reducibleJoin65: while (true) {
|
|
reducibleJoin38: while (true) {
|
|
if (property !== '[]') {
|
|
break reducibleJoin38;
|
|
}
|
|
parseArrays = a2.parseArrays;
|
|
if (parseArrays) {
|
|
allowEmptyArrays = a2.allowEmptyArrays;
|
|
reducibleJoin64: while (true) {
|
|
reducibleJoin62: while (true) {
|
|
if (allowEmptyArrays) {
|
|
if (r5 !== '') {
|
|
strictNullHandling = a2.strictNullHandling;
|
|
if (!strictNullHandling) {
|
|
break reducibleJoin62;
|
|
}
|
|
if (r5 !== null) {
|
|
break reducibleJoin62;
|
|
}
|
|
}
|
|
r26 = [];
|
|
break reducibleJoin64;
|
|
}
|
|
break reducibleJoin62;
|
|
}
|
|
moduleValue = require(dependencyMap[value]);
|
|
combine = moduleValue.combine;
|
|
value20 = Reflect.apply(combine, moduleValue, [[], r5]);
|
|
r26 = value20;
|
|
break reducibleJoin64;
|
|
}
|
|
r22 = r26;
|
|
break reducibleJoin65;
|
|
}
|
|
break reducibleJoin38;
|
|
}
|
|
plainObjects = a2.plainObjects;
|
|
if (plainObjects) {
|
|
value17 = Object.create(null);
|
|
r29 = value17;
|
|
} else {
|
|
r29 = {};
|
|
}
|
|
charAt = property.charAt;
|
|
reducibleJoin44: while (true) {
|
|
if (Reflect.apply(charAt, property, [value]) !== '[') {
|
|
r28 = property;
|
|
break reducibleJoin44;
|
|
}
|
|
charAt = property.charAt;
|
|
length = property.length;
|
|
if (Reflect.apply(charAt, property, [length - 1]) !== ']') {
|
|
r28 = property;
|
|
break reducibleJoin44;
|
|
}
|
|
slice = property.slice;
|
|
value18 = Reflect.apply(slice, property, [1, -1]);
|
|
r28 = value18;
|
|
break reducibleJoin44;
|
|
}
|
|
decodeDotInKeys = a2.decodeDotInKeys;
|
|
reducibleJoin46: while (true) {
|
|
if (decodeDotInKeys) {
|
|
replace = r28.replace;
|
|
value19 = Reflect.apply(replace, r28, [RegExp('%2E', 'g'), '.']);
|
|
r23 = value19;
|
|
break reducibleJoin46;
|
|
}
|
|
r23 = r28;
|
|
break reducibleJoin46;
|
|
}
|
|
parseInt = global.parseInt;
|
|
int = parseInt(r23, 10);
|
|
parseArrays = a2.parseArrays;
|
|
if (!parseArrays) {
|
|
if (r23 === '') {
|
|
r22 = {[0]: r5};
|
|
break reducibleJoin65;
|
|
}
|
|
}
|
|
isNaN = global.isNaN;
|
|
if (!isNaN(int)) {
|
|
if (property !== r23) {
|
|
String = global.String;
|
|
if (String(int) === r23) {
|
|
if (int >= value) {
|
|
parseArrays = a2.parseArrays;
|
|
if (parseArrays) {
|
|
arrayLimit = a2.arrayLimit;
|
|
if (int <= arrayLimit) {
|
|
items2 = [];
|
|
items2[int] = r5;
|
|
r22 = items2;
|
|
break reducibleJoin65;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (r23 === '__proto__') {
|
|
r22 = r29;
|
|
break reducibleJoin65;
|
|
}
|
|
r29[r23] = r5;
|
|
r22 = r29;
|
|
break reducibleJoin65;
|
|
}
|
|
value21 = typeof r18 === 'bigint' ? r18 - 1n : +r18 - 1;
|
|
if (value21 >= value) {
|
|
r5 = r22;
|
|
r18 = value21;
|
|
continue reducibleLoop36;
|
|
}
|
|
r1 = r22;
|
|
break reducibleLoop36;
|
|
}
|
|
}
|
|
return r1;
|
|
}
|
|
}
|
|
|
|
function exports_6565(a0, a1) { // fn#6565, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:2151, offset: 0x00cff895, size: 1558 bytes, params: 3, frame: 24
|
|
var environment;
|
|
var charset;
|
|
var duplicates;
|
|
var r6;
|
|
var r5;
|
|
var allowPrototypes;
|
|
var allowSparse;
|
|
var arrayLimit;
|
|
var charsetSentinel;
|
|
var comma;
|
|
var decodeDotInKeys;
|
|
var decoder;
|
|
var delimiter;
|
|
var r7;
|
|
var interpretNumericEntities;
|
|
var parameterLimit;
|
|
var plainObjects;
|
|
var r2;
|
|
var strictNullHandling;
|
|
var r0;
|
|
var r9;
|
|
var r4;
|
|
var r3;
|
|
var r1;
|
|
var allowEmptyArrays;
|
|
var throwOnLimitExceeded;
|
|
var value3;
|
|
var value4;
|
|
var object2;
|
|
var allowDots;
|
|
var value5;
|
|
var value6;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
var value10;
|
|
var value11;
|
|
var value12;
|
|
var value13;
|
|
var value14;
|
|
var value15;
|
|
var value16;
|
|
var value17;
|
|
var moduleValue;
|
|
var isRegExp;
|
|
var depth;
|
|
var value18;
|
|
var value19;
|
|
var ignoreQueryPrefix;
|
|
var value20;
|
|
var value21;
|
|
var parseArrays;
|
|
var value22;
|
|
var strictDepth;
|
|
var value23;
|
|
var value24;
|
|
var value25;
|
|
var value26;
|
|
var value27;
|
|
var Object;
|
|
var keys;
|
|
var length;
|
|
var value28;
|
|
var value29;
|
|
var property;
|
|
var queryStringKeys;
|
|
var moduleValue2;
|
|
var merge;
|
|
var value30;
|
|
var value31;
|
|
var compact;
|
|
let value = a0;
|
|
if (a1) {
|
|
allowEmptyArrays = a1.allowEmptyArrays;
|
|
reducibleJoin78: while (true) {
|
|
reducibleJoin14: while (true) {
|
|
if (allowEmptyArrays === undefined) {
|
|
if (a1.decodeDotInKeys !== undefined) {
|
|
reducibleJoin6: while (true) {
|
|
if (typeof a1.decodeDotInKeys !== 'boolean') {
|
|
throw new global.TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');
|
|
}
|
|
break reducibleJoin6;
|
|
}
|
|
}
|
|
decoder = a1.decoder;
|
|
if (decoder !== null) {
|
|
decoder = a1.decoder;
|
|
reducibleJoin9: while (true) {
|
|
if (decoder === undefined) {
|
|
break reducibleJoin9;
|
|
}
|
|
decoder = a1.decoder;
|
|
if (typeof decoder !== 'function') {
|
|
throw new global.TypeError('Decoder has to be a function.');
|
|
}
|
|
break reducibleJoin9;
|
|
}
|
|
}
|
|
charset = a1.charset;
|
|
if (charset !== undefined) {
|
|
charset = a1.charset;
|
|
reducibleJoin12: while (true) {
|
|
if (charset === 'utf-8') {
|
|
break reducibleJoin12;
|
|
}
|
|
charset = a1.charset;
|
|
if (charset !== 'iso-8859-1') {
|
|
throw new global.TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
|
|
}
|
|
break reducibleJoin12;
|
|
}
|
|
}
|
|
throwOnLimitExceeded = a1.throwOnLimitExceeded;
|
|
if (throwOnLimitExceeded === undefined) {
|
|
break reducibleJoin14;
|
|
}
|
|
throwOnLimitExceeded = a1.throwOnLimitExceeded;
|
|
if (typeof throwOnLimitExceeded !== 'boolean') {
|
|
throw new global.TypeError('`throwOnLimitExceeded` option must be a boolean');
|
|
}
|
|
break reducibleJoin14;
|
|
}
|
|
allowEmptyArrays = a1.allowEmptyArrays;
|
|
if (typeof allowEmptyArrays !== 'boolean') {
|
|
throw new global.TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
|
|
}
|
|
decodeDotInKeys = a1.decodeDotInKeys;
|
|
if (decodeDotInKeys !== undefined) {
|
|
decodeDotInKeys = a1.decodeDotInKeys;
|
|
reducibleJoin6: while (true) {
|
|
if (typeof decodeDotInKeys !== 'boolean') {
|
|
throw new global.TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');
|
|
}
|
|
break reducibleJoin6;
|
|
}
|
|
}
|
|
decoder = a1.decoder;
|
|
if (decoder !== null) {
|
|
decoder = a1.decoder;
|
|
reducibleJoin9: while (true) {
|
|
if (decoder === undefined) {
|
|
break reducibleJoin9;
|
|
}
|
|
decoder = a1.decoder;
|
|
if (typeof decoder !== 'function') {
|
|
throw new global.TypeError('Decoder has to be a function.');
|
|
}
|
|
break reducibleJoin9;
|
|
}
|
|
}
|
|
charset = a1.charset;
|
|
if (charset !== undefined) {
|
|
charset = a1.charset;
|
|
reducibleJoin12: while (true) {
|
|
if (charset === 'utf-8') {
|
|
break reducibleJoin12;
|
|
}
|
|
charset = a1.charset;
|
|
if (charset !== 'iso-8859-1') {
|
|
throw new global.TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
|
|
}
|
|
break reducibleJoin12;
|
|
}
|
|
}
|
|
throwOnLimitExceeded = a1.throwOnLimitExceeded;
|
|
if (throwOnLimitExceeded === undefined) {
|
|
break reducibleJoin14;
|
|
}
|
|
throwOnLimitExceeded = a1.throwOnLimitExceeded;
|
|
if (typeof throwOnLimitExceeded !== 'boolean') {
|
|
throw new global.TypeError('`throwOnLimitExceeded` option must be a boolean');
|
|
}
|
|
break reducibleJoin14;
|
|
}
|
|
charset = a1.charset;
|
|
if (charset === undefined) {
|
|
value3 = environment;
|
|
charset = env0_4.charset;
|
|
} else {
|
|
charset = a1.charset;
|
|
}
|
|
duplicates = a1.duplicates;
|
|
if (duplicates === undefined) {
|
|
value4 = environment;
|
|
duplicates = env0_4.duplicates;
|
|
} else {
|
|
duplicates = a1.duplicates;
|
|
}
|
|
if (duplicates !== 'combine') {
|
|
reducibleJoin23: while (true) {
|
|
if (duplicates === 'first') {
|
|
break reducibleJoin23;
|
|
}
|
|
if (duplicates !== 'last') {
|
|
throw new global.TypeError('The duplicates option must be either combine, first, or last');
|
|
}
|
|
break reducibleJoin23;
|
|
}
|
|
}
|
|
object2 = {};
|
|
allowDots = a1.allowDots;
|
|
if (allowDots === undefined) {
|
|
value6 = a1.decodeDotInKeys === true;
|
|
reducibleJoin27: while (true) {
|
|
if (value6) {
|
|
r6 = value6;
|
|
break reducibleJoin27;
|
|
}
|
|
value7 = environment;
|
|
allowDots = env0_4.allowDots;
|
|
r6 = allowDots;
|
|
break reducibleJoin27;
|
|
}
|
|
r5 = r6;
|
|
} else {
|
|
allowDots = a1.allowDots;
|
|
value5 = !!allowDots;
|
|
r5 = value5;
|
|
}
|
|
object2.allowDots = r5;
|
|
allowEmptyArrays = a1.allowEmptyArrays;
|
|
if (typeof allowEmptyArrays === 'boolean') {
|
|
allowEmptyArrays = a1.allowEmptyArrays;
|
|
value9 = !!allowEmptyArrays;
|
|
r6 = value9;
|
|
} else {
|
|
value8 = environment;
|
|
allowEmptyArrays = env0_4.allowEmptyArrays;
|
|
r6 = allowEmptyArrays;
|
|
}
|
|
object2.allowEmptyArrays = r6;
|
|
allowPrototypes = a1.allowPrototypes;
|
|
if (typeof allowPrototypes === 'boolean') {
|
|
allowPrototypes = a1.allowPrototypes;
|
|
} else {
|
|
value10 = environment;
|
|
allowPrototypes = env0_4.allowPrototypes;
|
|
}
|
|
object2.allowPrototypes = allowPrototypes;
|
|
allowSparse = a1.allowSparse;
|
|
if (typeof allowSparse === 'boolean') {
|
|
allowSparse = a1.allowSparse;
|
|
} else {
|
|
value11 = environment;
|
|
allowSparse = env0_4.allowSparse;
|
|
}
|
|
object2.allowSparse = allowSparse;
|
|
arrayLimit = a1.arrayLimit;
|
|
if (typeof arrayLimit === 'number') {
|
|
arrayLimit = a1.arrayLimit;
|
|
} else {
|
|
value12 = environment;
|
|
arrayLimit = env0_4.arrayLimit;
|
|
}
|
|
object2.arrayLimit = arrayLimit;
|
|
object2.charset = charset;
|
|
charsetSentinel = a1.charsetSentinel;
|
|
if (typeof charsetSentinel === 'boolean') {
|
|
charsetSentinel = a1.charsetSentinel;
|
|
} else {
|
|
value13 = environment;
|
|
charsetSentinel = env0_4.charsetSentinel;
|
|
}
|
|
object2.charsetSentinel = charsetSentinel;
|
|
comma = a1.comma;
|
|
if (typeof comma === 'boolean') {
|
|
comma = a1.comma;
|
|
} else {
|
|
value14 = environment;
|
|
comma = env0_4.comma;
|
|
}
|
|
object2.comma = comma;
|
|
decodeDotInKeys = a1.decodeDotInKeys;
|
|
if (typeof decodeDotInKeys === 'boolean') {
|
|
decodeDotInKeys = a1.decodeDotInKeys;
|
|
} else {
|
|
value15 = environment;
|
|
decodeDotInKeys = env0_4.decodeDotInKeys;
|
|
}
|
|
object2.decodeDotInKeys = decodeDotInKeys;
|
|
decoder = a1.decoder;
|
|
if (typeof decoder === 'function') {
|
|
decoder = a1.decoder;
|
|
} else {
|
|
value16 = environment;
|
|
decoder = env0_4.decoder;
|
|
}
|
|
object2.decoder = decoder;
|
|
delimiter = a1.delimiter;
|
|
reducibleJoin56: while (true) {
|
|
reducibleJoin55: while (true) {
|
|
if (typeof delimiter === 'string') {
|
|
break reducibleJoin55;
|
|
}
|
|
value17 = environment;
|
|
moduleValue = require(513) /* metro dependency 513 */;
|
|
isRegExp = moduleValue.isRegExp;
|
|
delimiter = a1.delimiter;
|
|
if (Reflect.apply(isRegExp, moduleValue, [delimiter])) {
|
|
break reducibleJoin55;
|
|
}
|
|
delimiter = env0_4.delimiter;
|
|
break reducibleJoin56;
|
|
}
|
|
delimiter = a1.delimiter;
|
|
break reducibleJoin56;
|
|
}
|
|
object2.delimiter = delimiter;
|
|
depth = a1.depth;
|
|
reducibleJoin60: while (true) {
|
|
reducibleJoin59: while (true) {
|
|
if (typeof depth === 'number') {
|
|
break reducibleJoin59;
|
|
}
|
|
depth = a1.depth;
|
|
if (depth === false) {
|
|
break reducibleJoin59;
|
|
}
|
|
value18 = environment;
|
|
depth = env0_4.depth;
|
|
r7 = depth;
|
|
break reducibleJoin60;
|
|
}
|
|
depth = a1.depth;
|
|
value19 = Number(depth);
|
|
r7 = value19;
|
|
break reducibleJoin60;
|
|
}
|
|
object2.depth = r7;
|
|
object2.duplicates = duplicates;
|
|
ignoreQueryPrefix = a1.ignoreQueryPrefix;
|
|
object2.ignoreQueryPrefix = ignoreQueryPrefix === true;
|
|
interpretNumericEntities = a1.interpretNumericEntities;
|
|
if (typeof interpretNumericEntities === 'boolean') {
|
|
interpretNumericEntities = a1.interpretNumericEntities;
|
|
} else {
|
|
value20 = environment;
|
|
interpretNumericEntities = env0_4.interpretNumericEntities;
|
|
}
|
|
object2.interpretNumericEntities = interpretNumericEntities;
|
|
parameterLimit = a1.parameterLimit;
|
|
if (typeof parameterLimit === 'number') {
|
|
parameterLimit = a1.parameterLimit;
|
|
} else {
|
|
value21 = environment;
|
|
parameterLimit = env0_4.parameterLimit;
|
|
}
|
|
object2.parameterLimit = parameterLimit;
|
|
parseArrays = a1.parseArrays;
|
|
object2.parseArrays = parseArrays !== false;
|
|
plainObjects = a1.plainObjects;
|
|
if (typeof plainObjects === 'boolean') {
|
|
plainObjects = a1.plainObjects;
|
|
} else {
|
|
value22 = environment;
|
|
plainObjects = env0_4.plainObjects;
|
|
}
|
|
object2.plainObjects = plainObjects;
|
|
strictDepth = a1.strictDepth;
|
|
if (typeof strictDepth === 'boolean') {
|
|
strictDepth = a1.strictDepth;
|
|
value24 = !!strictDepth;
|
|
r2 = value24;
|
|
} else {
|
|
value23 = environment;
|
|
strictDepth = env0_4.strictDepth;
|
|
r2 = strictDepth;
|
|
}
|
|
object2.strictDepth = r2;
|
|
strictNullHandling = a1.strictNullHandling;
|
|
if (typeof strictNullHandling === 'boolean') {
|
|
strictNullHandling = a1.strictNullHandling;
|
|
} else {
|
|
value25 = environment;
|
|
strictNullHandling = env0_4.strictNullHandling;
|
|
}
|
|
object2.strictNullHandling = strictNullHandling;
|
|
throwOnLimitExceeded = a1.throwOnLimitExceeded;
|
|
value26 = typeof throwOnLimitExceeded === 'boolean';
|
|
reducibleJoin77: while (true) {
|
|
if (value26) {
|
|
throwOnLimitExceeded = a1.throwOnLimitExceeded;
|
|
r2 = throwOnLimitExceeded;
|
|
break reducibleJoin77;
|
|
}
|
|
r2 = value26;
|
|
break reducibleJoin77;
|
|
}
|
|
object2.throwOnLimitExceeded = r2;
|
|
r0 = object2;
|
|
break reducibleJoin78;
|
|
}
|
|
} else {
|
|
r0 = env0_4;
|
|
}
|
|
if (value !== '') {
|
|
reducibleJoin90: while (true) {
|
|
if (value != null) {
|
|
value27 = typeof value === 'string';
|
|
reducibleJoin82: while (true) {
|
|
if (value27) {
|
|
value = parseQueryStringValues(value, r0);
|
|
r9 = value;
|
|
break reducibleJoin82;
|
|
}
|
|
r9 = value;
|
|
break reducibleJoin82;
|
|
}
|
|
plainObjects = r0.plainObjects;
|
|
if (!plainObjects) {
|
|
r4 = {};
|
|
}
|
|
Object = global.Object;
|
|
keys = Object.keys;
|
|
value = Reflect.apply(keys, Object, [r9]);
|
|
length = value.length;
|
|
value28 = 0;
|
|
value29 = environment;
|
|
if (value28 < length) {
|
|
r3 = value28;
|
|
r7 = r4;
|
|
reducibleLoop86: while (true) {
|
|
property = value[r3];
|
|
queryStringKeys = parseQueryStringKeys(property, r9[property], r0, value27);
|
|
moduleValue2 = require(dependencyMap[value28]);
|
|
merge = moduleValue2.merge;
|
|
value30 = Reflect.apply(merge, moduleValue2, [r7, queryStringKeys, r0]);
|
|
value31 = typeof r3 === 'bigint' ? r3 + 1n : +r3 + 1;
|
|
length = value.length;
|
|
if (value31 < length) {
|
|
r3 = value31;
|
|
r7 = value30;
|
|
continue reducibleLoop86;
|
|
}
|
|
r4 = value30;
|
|
break reducibleLoop86;
|
|
}
|
|
}
|
|
allowSparse = r0.allowSparse;
|
|
reducibleJoin89: while (true) {
|
|
if (allowSparse === true) {
|
|
r1 = r4;
|
|
break reducibleJoin89;
|
|
}
|
|
value = require(dependencyMap[value28]);
|
|
compact = value.compact;
|
|
value = Reflect.apply(compact, value, [r4]);
|
|
r1 = value;
|
|
break reducibleJoin89;
|
|
}
|
|
return r1;
|
|
}
|
|
break reducibleJoin90;
|
|
}
|
|
}
|
|
r0 = r0.plainObjects ? Object.create(null) : {};
|
|
return r0;
|
|
}
|
|
|
|
function parseQueryStringValues(a0, a1) { // fn#6566, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:4774, owner: exports_6565.parseQueryStringValues, offset: 0x00cffeab, size: 1029 bytes, params: 3, frame: 50
|
|
var r4;
|
|
var r2;
|
|
var r3;
|
|
var r5;
|
|
var r12;
|
|
var r22;
|
|
var r23;
|
|
var r9;
|
|
var r30;
|
|
var length;
|
|
var r34;
|
|
var r35;
|
|
var r36;
|
|
var r33;
|
|
var replace;
|
|
var value5;
|
|
var value7;
|
|
var value8;
|
|
var value9;
|
|
var property;
|
|
var indexOf;
|
|
var value10;
|
|
var value15;
|
|
var value16;
|
|
var value17;
|
|
var decoder;
|
|
var slice;
|
|
var value18;
|
|
var decoder2;
|
|
var value19;
|
|
var moduleValue;
|
|
var maybeMap;
|
|
var parseArrayValueBinding;
|
|
var value20;
|
|
var arrayValue;
|
|
var value21;
|
|
var decoder3;
|
|
var value22;
|
|
var strictNullHandling;
|
|
var interpretNumericEntities2;
|
|
var interpretNumericEntitiesBinding;
|
|
var String;
|
|
var value23;
|
|
var hasOwnPropertyBinding;
|
|
var call;
|
|
var value24;
|
|
var duplicates;
|
|
var value25;
|
|
var moduleValue2;
|
|
var combine;
|
|
var value26;
|
|
var RangeError;
|
|
var value27;
|
|
var value28;
|
|
var prototype;
|
|
var value29;
|
|
var rangeError;
|
|
let value = a0;
|
|
const env0_0 = a1;
|
|
const value2 = null;
|
|
const value3 = Object.create(value2);
|
|
reducibleJoin2: while (true) {
|
|
if (a1.ignoreQueryPrefix) {
|
|
replace = value.replace;
|
|
value = Reflect.apply(replace, value, [RegExp('^\\?', ''), '']);
|
|
r4 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
r4 = value;
|
|
break reducibleJoin2;
|
|
}
|
|
value = r4.replace(RegExp('%5B', 'gi'), '[');
|
|
value = value.replace(RegExp('%5D', 'gi'), ']');
|
|
let parameterLimit = a1.parameterLimit;
|
|
reducibleJoin4: while (true) {
|
|
if (parameterLimit === Infinity) {
|
|
parameterLimit = undefined;
|
|
break reducibleJoin4;
|
|
}
|
|
parameterLimit = a1.parameterLimit;
|
|
break reducibleJoin4;
|
|
}
|
|
const split = value.split;
|
|
const delimiter = a1.delimiter;
|
|
reducibleJoin6: while (true) {
|
|
if (a1.throwOnLimitExceeded) {
|
|
value5 = parameterLimit + 1;
|
|
r2 = value5;
|
|
break reducibleJoin6;
|
|
}
|
|
r2 = parameterLimit;
|
|
break reducibleJoin6;
|
|
}
|
|
value = Reflect.apply(split, value, [delimiter, r2]);
|
|
if (a1.throwOnLimitExceeded) {
|
|
length = value.length;
|
|
reducibleJoin8: while (true) {
|
|
if (length > parameterLimit) {
|
|
RangeError = global.RangeError;
|
|
value = 'Parameter limit exceeded. Only ' + parameterLimit;
|
|
value27 = 's';
|
|
reducibleJoin48: while (true) {
|
|
if (parameterLimit !== 1) {
|
|
r3 = value27;
|
|
break reducibleJoin48;
|
|
}
|
|
value28 = '';
|
|
r3 = value28;
|
|
break reducibleJoin48;
|
|
}
|
|
prototype = RangeError.prototype;
|
|
value29 = Object.create(prototype, {constructor: {value: RangeError}});
|
|
value = value + ' parameter' + r3 + ' allowed.';
|
|
rangeError = new RangeError(value);
|
|
value = rangeError instanceof Object ? rangeError : value29;
|
|
throw value;
|
|
}
|
|
break reducibleJoin8;
|
|
}
|
|
}
|
|
const charset = a1.charset;
|
|
var env0_1;
|
|
const charsetSentinel = a1.charsetSentinel;
|
|
const value6 = -1;
|
|
reducibleJoin17: while (true) {
|
|
if (!charsetSentinel) {
|
|
r22 = charset;
|
|
r23 = value6;
|
|
break reducibleJoin17;
|
|
}
|
|
length = value.length;
|
|
value7 = 0;
|
|
value8 = 'utf-8';
|
|
value9 = 'iso-8859-1';
|
|
if (!(value7 < length)) {
|
|
r22 = charset;
|
|
r23 = value6;
|
|
break reducibleJoin17;
|
|
}
|
|
r3 = charset;
|
|
r4 = value6;
|
|
r5 = value7;
|
|
reducibleLoop10: while (true) {
|
|
property = value[r5];
|
|
indexOf = property.indexOf;
|
|
reducibleJoin16: while (true) {
|
|
if (value7 !== Reflect.apply(indexOf, property, ['utf8='])) {
|
|
r2 = r5;
|
|
r12 = r3;
|
|
break reducibleJoin16;
|
|
}
|
|
if (value[r5] === 'utf8=%E2%9C%93') {
|
|
env0_1 = value8;
|
|
r3 = value8;
|
|
} else {
|
|
reducibleJoin15: while (true) {
|
|
if (value[r5] !== 'utf8=%26%2310003%3B') {
|
|
break reducibleJoin15;
|
|
}
|
|
env0_1 = value9;
|
|
r3 = value9;
|
|
break reducibleJoin15;
|
|
}
|
|
}
|
|
length = value.length;
|
|
r2 = length;
|
|
r4 = r5;
|
|
r12 = r3;
|
|
break reducibleJoin16;
|
|
}
|
|
value10 = typeof r2 === 'bigint' ? r2 + 1n : +r2 + 1;
|
|
length = value.length;
|
|
if (value10 < length) {
|
|
r3 = r12;
|
|
r5 = value10;
|
|
continue reducibleLoop10;
|
|
}
|
|
r22 = r12;
|
|
r23 = r4;
|
|
break reducibleJoin17;
|
|
}
|
|
}
|
|
length = value.length;
|
|
const value11 = 0;
|
|
if (value11 < length) {
|
|
r9 = value11;
|
|
reducibleLoop18: while (true) {
|
|
reducibleJoin44: while (true) {
|
|
if (r9 === r23) {
|
|
break reducibleJoin44;
|
|
}
|
|
property = value[r9];
|
|
indexOf = property.indexOf;
|
|
value15 = Reflect.apply(indexOf, property, [']=']);
|
|
if (value6 === value15) {
|
|
value17 = property.indexOf('=');
|
|
r30 = value17;
|
|
} else {
|
|
value16 = value15 + 1;
|
|
r30 = value16;
|
|
}
|
|
if (value6 === r30) {
|
|
decoder = a1.decoder;
|
|
decoder3 = env1_4.decoder;
|
|
value22 = Reflect.apply(decoder, a1, [property, decoder3, r22, 'key']);
|
|
strictNullHandling = a1.strictNullHandling;
|
|
r2 = strictNullHandling ? value2 : '';
|
|
r34 = value22;
|
|
r35 = r2;
|
|
} else {
|
|
decoder = a1.decoder;
|
|
slice = property.slice;
|
|
value18 = Reflect.apply(slice, property, [value11, r30]);
|
|
decoder2 = env1_4.decoder;
|
|
value19 = Reflect.apply(decoder, a1, [value18, decoder2, r22, 'key']);
|
|
moduleValue = require(dependencyMap[value11]);
|
|
maybeMap = moduleValue.maybeMap;
|
|
parseArrayValueBinding = parseArrayValue;
|
|
slice = property.slice;
|
|
value20 = Reflect.apply(slice, property, [r30 + 1]);
|
|
reducibleJoin25: while (true) {
|
|
if (isArray(value3[value19])) {
|
|
length = value3[value19].length;
|
|
break reducibleJoin25;
|
|
}
|
|
length = value11;
|
|
break reducibleJoin25;
|
|
}
|
|
arrayValue = parseArrayValueBinding(value20, a1, length);
|
|
value21 = Reflect.apply(maybeMap, moduleValue, [arrayValue, _fun6567]);
|
|
r34 = value19;
|
|
r35 = value21;
|
|
}
|
|
reducibleJoin30: while (true) {
|
|
if (r35) {
|
|
interpretNumericEntities2 = a1.interpretNumericEntities;
|
|
r2 = interpretNumericEntities2;
|
|
break reducibleJoin30;
|
|
}
|
|
r2 = r35;
|
|
break reducibleJoin30;
|
|
}
|
|
if (r2) {
|
|
r2 = r22 === 'iso-8859-1';
|
|
}
|
|
reducibleJoin33: while (true) {
|
|
if (r2) {
|
|
interpretNumericEntitiesBinding = interpretNumericEntities;
|
|
String = global.String;
|
|
value23 = interpretNumericEntitiesBinding(String(r35));
|
|
r36 = value23;
|
|
break reducibleJoin33;
|
|
}
|
|
r36 = r35;
|
|
break reducibleJoin33;
|
|
}
|
|
indexOf = property.indexOf;
|
|
reducibleJoin37: while (true) {
|
|
if (Reflect.apply(indexOf, property, ['[]=']) > value6) {
|
|
reducibleJoin36: while (true) {
|
|
if (isArray(r36)) {
|
|
r2 = [r36];
|
|
break reducibleJoin36;
|
|
}
|
|
r2 = r36;
|
|
break reducibleJoin36;
|
|
}
|
|
r33 = r2;
|
|
break reducibleJoin37;
|
|
}
|
|
r33 = r36;
|
|
break reducibleJoin37;
|
|
}
|
|
hasOwnPropertyBinding = hasOwnProperty;
|
|
call = hasOwnPropertyBinding.call;
|
|
value24 = Reflect.apply(call, hasOwnPropertyBinding, [value3, r34]);
|
|
if (value24) {
|
|
duplicates = a1.duplicates;
|
|
if (duplicates === 'combine') {
|
|
moduleValue2 = require(dependencyMap[value11]);
|
|
combine = moduleValue2.combine;
|
|
value3[r34] = Reflect.apply(combine, moduleValue2, [value3[r34], r33]);
|
|
break reducibleJoin44;
|
|
}
|
|
}
|
|
reducibleJoin41: while (true) {
|
|
if (value24) {
|
|
duplicates = a1.duplicates;
|
|
value25 = duplicates !== 'last';
|
|
r35 = value25;
|
|
break reducibleJoin41;
|
|
}
|
|
r35 = value24;
|
|
break reducibleJoin41;
|
|
}
|
|
if (r35) {
|
|
break reducibleJoin44;
|
|
}
|
|
value3[r34] = r33;
|
|
break reducibleJoin44;
|
|
}
|
|
value26 = typeof r9 === 'bigint' ? r9 + 1n : +r9 + 1;
|
|
length = value.length;
|
|
if (value26 < length) {
|
|
r9 = value26;
|
|
continue reducibleLoop18;
|
|
}
|
|
break reducibleLoop18;
|
|
}
|
|
}
|
|
return value3;
|
|
}
|
|
|
|
function _fun6567(a0) { // fn#6567, source: /ci/build/discord/discord/discord_android_rn/android/app/src/main/assets/index.android.bundle:562:5629, offset: 0x00d002b0, size: 46 bytes, params: 2, frame: 17
|
|
return require.decoder(a0, env2_4.decoder, charset, 'value');
|
|
}
|
|
|