/* 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');
}