{"version":3,"sources":["webpack:///./node_modules/qs/lib/stringify.js","webpack:///./node_modules/qs/lib/index.js","webpack:///./node_modules/qs/lib/parse.js","webpack:///./node_modules/qs/lib/formats.js","webpack:///./node_modules/qs/lib/utils.js"],"names":["getSideChannel","utils","formats","has","Object","prototype","hasOwnProperty","arrayPrefixGenerators","brackets","prefix","comma","indices","key","repeat","isArray","Array","push","pushToArray","arr","valueOrArray","apply","toISO","Date","toISOString","defaultFormat","defaults","addQueryPrefix","allowDots","allowEmptyArrays","arrayFormat","charset","charsetSentinel","commaRoundTrip","delimiter","encode","encodeDotInKeys","encoder","encodeValuesOnly","filter","format","formatter","formatters","serializeDate","date","call","skipNulls","strictNullHandling","isNonNullishPrimitive","v","sentinel","stringify","object","generateArrayPrefix","sort","sideChannel","obj","tmpSc","step","findFlag","get","pos","RangeError","maybeMap","value","isBuffer","keyValue","String","objKeys","values","length","join","keys","encodedPrefix","replace","adjustedPrefix","j","encodedKey","keyPrefix","set","valueSideChannel","normalizeStringifyOptions","opts","TypeError","module","exports","options","i","joined","parse","allowPrototypes","allowSparse","arrayLimit","decodeDotInKeys","decoder","decode","depth","duplicates","ignoreQueryPrefix","interpretNumericEntities","parameterLimit","parseArrays","plainObjects","strictDepth","str","$0","numberStr","fromCharCode","parseInt","parseArrayValue","val","indexOf","split","isoSentinel","parseValues","__proto__","cleanStr","limit","Infinity","undefined","parts","skipIndex","part","bracketEqualsPos","slice","encodedVal","existing","combine","parseObject","chain","valuesParsed","leaf","root","concat","cleanRoot","charAt","decodedRoot","index","isNaN","0","parseKeys","givenKey","child","segment","exec","parent","normalizeParseOptions","isRegExp","tempObj","newObj","merge","compact","percentTwenties","Format","RFC1738","RFC3986","hexTable","array","toString","toUpperCase","compactQueue","queue","item","pop","prop","compacted","arrayToObject","source","target","mergeTarget","forEach","targetItem","reduce","acc","assign","defaultDecoder","strWithoutPlus","unescape","decodeURIComponent","e","defaultEncoder","kind","string","Symbol","escape","out","c","charCodeAt","o","refs","constructor","a","b","fn","mapped"],"mappings":"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","file":"js/npm.qs~bc261e74.c6605d43.js","sourcesContent":["'use strict';\n\nvar getSideChannel = require('side-channel');\nvar utils = require('./utils');\nvar formats = require('./formats');\nvar has = Object.prototype.hasOwnProperty;\n\nvar arrayPrefixGenerators = {\n    brackets: function brackets(prefix) {\n        return prefix + '[]';\n    },\n    comma: 'comma',\n    indices: function indices(prefix, key) {\n        return prefix + '[' + key + ']';\n    },\n    repeat: function repeat(prefix) {\n        return prefix;\n    }\n};\n\nvar isArray = Array.isArray;\nvar push = Array.prototype.push;\nvar pushToArray = function (arr, valueOrArray) {\n    push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);\n};\n\nvar toISO = Date.prototype.toISOString;\n\nvar defaultFormat = formats['default'];\nvar defaults = {\n    addQueryPrefix: false,\n    allowDots: false,\n    allowEmptyArrays: false,\n    arrayFormat: 'indices',\n    charset: 'utf-8',\n    charsetSentinel: false,\n    commaRoundTrip: false,\n    delimiter: '&',\n    encode: true,\n    encodeDotInKeys: false,\n    encoder: utils.encode,\n    encodeValuesOnly: false,\n    filter: void undefined,\n    format: defaultFormat,\n    formatter: formats.formatters[defaultFormat],\n    // deprecated\n    indices: false,\n    serializeDate: function serializeDate(date) {\n        return toISO.call(date);\n    },\n    skipNulls: false,\n    strictNullHandling: false\n};\n\nvar isNonNullishPrimitive = function isNonNullishPrimitive(v) {\n    return typeof v === 'string'\n        || typeof v === 'number'\n        || typeof v === 'boolean'\n        || typeof v === 'symbol'\n        || typeof v === 'bigint';\n};\n\nvar sentinel = {};\n\nvar stringify = function stringify(\n    object,\n    prefix,\n    generateArrayPrefix,\n    commaRoundTrip,\n    allowEmptyArrays,\n    strictNullHandling,\n    skipNulls,\n    encodeDotInKeys,\n    encoder,\n    filter,\n    sort,\n    allowDots,\n    serializeDate,\n    format,\n    formatter,\n    encodeValuesOnly,\n    charset,\n    sideChannel\n) {\n    var obj = object;\n\n    var tmpSc = sideChannel;\n    var step = 0;\n    var findFlag = false;\n    while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) {\n        // Where object last appeared in the ref tree\n        var pos = tmpSc.get(object);\n        step += 1;\n        if (typeof pos !== 'undefined') {\n            if (pos === step) {\n                throw new RangeError('Cyclic object value');\n            } else {\n                findFlag = true; // Break while\n            }\n        }\n        if (typeof tmpSc.get(sentinel) === 'undefined') {\n            step = 0;\n        }\n    }\n\n    if (typeof filter === 'function') {\n        obj = filter(prefix, obj);\n    } else if (obj instanceof Date) {\n        obj = serializeDate(obj);\n    } else if (generateArrayPrefix === 'comma' && isArray(obj)) {\n        obj = utils.maybeMap(obj, function (value) {\n            if (value instanceof Date) {\n                return serializeDate(value);\n            }\n            return value;\n        });\n    }\n\n    if (obj === null) {\n        if (strictNullHandling) {\n            return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;\n        }\n\n        obj = '';\n    }\n\n    if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {\n        if (encoder) {\n            var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);\n            return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];\n        }\n        return [formatter(prefix) + '=' + formatter(String(obj))];\n    }\n\n    var values = [];\n\n    if (typeof obj === 'undefined') {\n        return values;\n    }\n\n    var objKeys;\n    if (generateArrayPrefix === 'comma' && isArray(obj)) {\n        // we need to join elements in\n        if (encodeValuesOnly && encoder) {\n            obj = utils.maybeMap(obj, encoder);\n        }\n        objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];\n    } else if (isArray(filter)) {\n        objKeys = filter;\n    } else {\n        var keys = Object.keys(obj);\n        objKeys = sort ? keys.sort(sort) : keys;\n    }\n\n    var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\\./g, '%2E') : String(prefix);\n\n    var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;\n\n    if (allowEmptyArrays && isArray(obj) && obj.length === 0) {\n        return adjustedPrefix + '[]';\n    }\n\n    for (var j = 0; j < objKeys.length; ++j) {\n        var key = objKeys[j];\n        var value = typeof key === 'object' && key && typeof key.value !== 'undefined'\n            ? key.value\n            : obj[key];\n\n        if (skipNulls && value === null) {\n            continue;\n        }\n\n        var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\\./g, '%2E') : String(key);\n        var keyPrefix = isArray(obj)\n            ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix\n            : adjustedPrefix + (allowDots ? '.' + encodedKey : '[' + encodedKey + ']');\n\n        sideChannel.set(object, step);\n        var valueSideChannel = getSideChannel();\n        valueSideChannel.set(sentinel, sideChannel);\n        pushToArray(values, stringify(\n            value,\n            keyPrefix,\n            generateArrayPrefix,\n            commaRoundTrip,\n            allowEmptyArrays,\n            strictNullHandling,\n            skipNulls,\n            encodeDotInKeys,\n            generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,\n            filter,\n            sort,\n            allowDots,\n            serializeDate,\n            format,\n            formatter,\n            encodeValuesOnly,\n            charset,\n            valueSideChannel\n        ));\n    }\n\n    return values;\n};\n\nvar normalizeStringifyOptions = function normalizeStringifyOptions(opts) {\n    if (!opts) {\n        return defaults;\n    }\n\n    if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {\n        throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');\n    }\n\n    if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {\n        throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');\n    }\n\n    if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {\n        throw new TypeError('Encoder has to be a function.');\n    }\n\n    var charset = opts.charset || defaults.charset;\n    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n    }\n\n    var format = formats['default'];\n    if (typeof opts.format !== 'undefined') {\n        if (!has.call(formats.formatters, opts.format)) {\n            throw new TypeError('Unknown format option provided.');\n        }\n        format = opts.format;\n    }\n    var formatter = formats.formatters[format];\n\n    var filter = defaults.filter;\n    if (typeof opts.filter === 'function' || isArray(opts.filter)) {\n        filter = opts.filter;\n    }\n\n    var arrayFormat;\n    if (opts.arrayFormat in arrayPrefixGenerators) {\n        arrayFormat = opts.arrayFormat;\n    } else if ('indices' in opts) {\n        arrayFormat = opts.indices ? 'indices' : 'repeat';\n    } else {\n        arrayFormat = defaults.arrayFormat;\n    }\n\n    if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {\n        throw new TypeError('`commaRoundTrip` must be a boolean, or absent');\n    }\n\n    var allowDots = typeof opts.allowDots === 'undefined' ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n\n    return {\n        addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,\n        allowDots: allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        arrayFormat: arrayFormat,\n        charset: charset,\n        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n        commaRoundTrip: !!opts.commaRoundTrip,\n        delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,\n        encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,\n        encodeDotInKeys: typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,\n        encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,\n        encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,\n        filter: filter,\n        format: format,\n        formatter: formatter,\n        serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,\n        skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,\n        sort: typeof opts.sort === 'function' ? opts.sort : null,\n        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n    };\n};\n\nmodule.exports = function (object, opts) {\n    var obj = object;\n    var options = normalizeStringifyOptions(opts);\n\n    var objKeys;\n    var filter;\n\n    if (typeof options.filter === 'function') {\n        filter = options.filter;\n        obj = filter('', obj);\n    } else if (isArray(options.filter)) {\n        filter = options.filter;\n        objKeys = filter;\n    }\n\n    var keys = [];\n\n    if (typeof obj !== 'object' || obj === null) {\n        return '';\n    }\n\n    var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];\n    var commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;\n\n    if (!objKeys) {\n        objKeys = Object.keys(obj);\n    }\n\n    if (options.sort) {\n        objKeys.sort(options.sort);\n    }\n\n    var sideChannel = getSideChannel();\n    for (var i = 0; i < objKeys.length; ++i) {\n        var key = objKeys[i];\n        var value = obj[key];\n\n        if (options.skipNulls && value === null) {\n            continue;\n        }\n        pushToArray(keys, stringify(\n            value,\n            key,\n            generateArrayPrefix,\n            commaRoundTrip,\n            options.allowEmptyArrays,\n            options.strictNullHandling,\n            options.skipNulls,\n            options.encodeDotInKeys,\n            options.encode ? options.encoder : null,\n            options.filter,\n            options.sort,\n            options.allowDots,\n            options.serializeDate,\n            options.format,\n            options.formatter,\n            options.encodeValuesOnly,\n            options.charset,\n            sideChannel\n        ));\n    }\n\n    var joined = keys.join(options.delimiter);\n    var prefix = options.addQueryPrefix === true ? '?' : '';\n\n    if (options.charsetSentinel) {\n        if (options.charset === 'iso-8859-1') {\n            // encodeURIComponent('&#10003;'), the \"numeric entity\" representation of a checkmark\n            prefix += 'utf8=%26%2310003%3B&';\n        } else {\n            // encodeURIComponent('✓')\n            prefix += 'utf8=%E2%9C%93&';\n        }\n    }\n\n    return joined.length > 0 ? prefix + joined : '';\n};\n","'use strict';\n\nvar stringify = require('./stringify');\nvar parse = require('./parse');\nvar formats = require('./formats');\n\nmodule.exports = {\n    formats: formats,\n    parse: parse,\n    stringify: stringify\n};\n","'use strict';\n\nvar utils = require('./utils');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar defaults = {\n    allowDots: false,\n    allowEmptyArrays: false,\n    allowPrototypes: false,\n    allowSparse: false,\n    arrayLimit: 20,\n    charset: 'utf-8',\n    charsetSentinel: false,\n    comma: false,\n    decodeDotInKeys: false,\n    decoder: utils.decode,\n    delimiter: '&',\n    depth: 5,\n    duplicates: 'combine',\n    ignoreQueryPrefix: false,\n    interpretNumericEntities: false,\n    parameterLimit: 1000,\n    parseArrays: true,\n    plainObjects: false,\n    strictDepth: false,\n    strictNullHandling: false\n};\n\nvar interpretNumericEntities = function (str) {\n    return str.replace(/&#(\\d+);/g, function ($0, numberStr) {\n        return String.fromCharCode(parseInt(numberStr, 10));\n    });\n};\n\nvar parseArrayValue = function (val, options) {\n    if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {\n        return val.split(',');\n    }\n\n    return val;\n};\n\n// This is what browsers will submit when the ✓ character occurs in an\n// application/x-www-form-urlencoded body and the encoding of the page containing\n// the form is iso-8859-1, or when the submitted form has an accept-charset\n// attribute of iso-8859-1. Presumably also with other charsets that do not contain\n// the ✓ character, such as us-ascii.\nvar isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('&#10003;')\n\n// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.\nvar charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')\n\nvar parseValues = function parseQueryStringValues(str, options) {\n    var obj = { __proto__: null };\n\n    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, '') : str;\n    cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');\n    var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;\n    var parts = cleanStr.split(options.delimiter, limit);\n    var skipIndex = -1; // Keep track of where the utf8 sentinel was found\n    var i;\n\n    var charset = options.charset;\n    if (options.charsetSentinel) {\n        for (i = 0; i < parts.length; ++i) {\n            if (parts[i].indexOf('utf8=') === 0) {\n                if (parts[i] === charsetSentinel) {\n                    charset = 'utf-8';\n                } else if (parts[i] === isoSentinel) {\n                    charset = 'iso-8859-1';\n                }\n                skipIndex = i;\n                i = parts.length; // The eslint settings do not allow break;\n            }\n        }\n    }\n\n    for (i = 0; i < parts.length; ++i) {\n        if (i === skipIndex) {\n            continue;\n        }\n        var part = parts[i];\n\n        var bracketEqualsPos = part.indexOf(']=');\n        var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;\n\n        var key;\n        var val;\n        if (pos === -1) {\n            key = options.decoder(part, defaults.decoder, charset, 'key');\n            val = options.strictNullHandling ? null : '';\n        } else {\n            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');\n            val = utils.maybeMap(\n                parseArrayValue(part.slice(pos + 1), options),\n                function (encodedVal) {\n                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');\n                }\n            );\n        }\n\n        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {\n            val = interpretNumericEntities(String(val));\n        }\n\n        if (part.indexOf('[]=') > -1) {\n            val = isArray(val) ? [val] : val;\n        }\n\n        var existing = has.call(obj, key);\n        if (existing && options.duplicates === 'combine') {\n            obj[key] = utils.combine(obj[key], val);\n        } else if (!existing || options.duplicates === 'last') {\n            obj[key] = val;\n        }\n    }\n\n    return obj;\n};\n\nvar parseObject = function (chain, val, options, valuesParsed) {\n    var leaf = valuesParsed ? val : parseArrayValue(val, options);\n\n    for (var i = chain.length - 1; i >= 0; --i) {\n        var obj;\n        var root = chain[i];\n\n        if (root === '[]' && options.parseArrays) {\n            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))\n                ? []\n                : [].concat(leaf);\n        } else {\n            obj = options.plainObjects ? { __proto__: null } : {};\n            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;\n            var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;\n            var index = parseInt(decodedRoot, 10);\n            if (!options.parseArrays && decodedRoot === '') {\n                obj = { 0: leaf };\n            } else if (\n                !isNaN(index)\n                && root !== decodedRoot\n                && String(index) === decodedRoot\n                && index >= 0\n                && (options.parseArrays && index <= options.arrayLimit)\n            ) {\n                obj = [];\n                obj[index] = leaf;\n            } else if (decodedRoot !== '__proto__') {\n                obj[decodedRoot] = leaf;\n            }\n        }\n\n        leaf = obj;\n    }\n\n    return leaf;\n};\n\nvar parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {\n    if (!givenKey) {\n        return;\n    }\n\n    // Transform dot notation to bracket notation\n    var key = options.allowDots ? givenKey.replace(/\\.([^.[]+)/g, '[$1]') : givenKey;\n\n    // The regex chunks\n\n    var brackets = /(\\[[^[\\]]*])/;\n    var child = /(\\[[^[\\]]*])/g;\n\n    // Get the parent\n\n    var segment = options.depth > 0 && brackets.exec(key);\n    var parent = segment ? key.slice(0, segment.index) : key;\n\n    // Stash the parent if it exists\n\n    var keys = [];\n    if (parent) {\n        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties\n        if (!options.plainObjects && has.call(Object.prototype, parent)) {\n            if (!options.allowPrototypes) {\n                return;\n            }\n        }\n\n        keys.push(parent);\n    }\n\n    // Loop through children appending to the array until we hit depth\n\n    var i = 0;\n    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {\n        i += 1;\n        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {\n            if (!options.allowPrototypes) {\n                return;\n            }\n        }\n        keys.push(segment[1]);\n    }\n\n    // If there's a remainder, check strictDepth option for throw, else just add whatever is left\n\n    if (segment) {\n        if (options.strictDepth === true) {\n            throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');\n        }\n        keys.push('[' + key.slice(segment.index) + ']');\n    }\n\n    return parseObject(keys, val, options, valuesParsed);\n};\n\nvar normalizeParseOptions = function normalizeParseOptions(opts) {\n    if (!opts) {\n        return defaults;\n    }\n\n    if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {\n        throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');\n    }\n\n    if (typeof opts.decodeDotInKeys !== 'undefined' && typeof opts.decodeDotInKeys !== 'boolean') {\n        throw new TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');\n    }\n\n    if (opts.decoder !== null && typeof opts.decoder !== 'undefined' && typeof opts.decoder !== 'function') {\n        throw new TypeError('Decoder has to be a function.');\n    }\n\n    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n        throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n    }\n    var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;\n\n    var duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;\n\n    if (duplicates !== 'combine' && duplicates !== 'first' && duplicates !== 'last') {\n        throw new TypeError('The duplicates option must be either combine, first, or last');\n    }\n\n    var allowDots = typeof opts.allowDots === 'undefined' ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n\n    return {\n        allowDots: allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,\n        allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,\n        arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,\n        charset: charset,\n        charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n        comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,\n        decodeDotInKeys: typeof opts.decodeDotInKeys === 'boolean' ? opts.decodeDotInKeys : defaults.decodeDotInKeys,\n        decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,\n        delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,\n        // eslint-disable-next-line no-implicit-coercion, no-extra-parens\n        depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,\n        duplicates: duplicates,\n        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,\n        interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,\n        parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,\n        parseArrays: opts.parseArrays !== false,\n        plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,\n        strictDepth: typeof opts.strictDepth === 'boolean' ? !!opts.strictDepth : defaults.strictDepth,\n        strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n    };\n};\n\nmodule.exports = function (str, opts) {\n    var options = normalizeParseOptions(opts);\n\n    if (str === '' || str === null || typeof str === 'undefined') {\n        return options.plainObjects ? { __proto__: null } : {};\n    }\n\n    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;\n    var obj = options.plainObjects ? { __proto__: null } : {};\n\n    // Iterate over the keys and setup the new object\n\n    var keys = Object.keys(tempObj);\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');\n        obj = utils.merge(obj, newObj, options);\n    }\n\n    if (options.allowSparse === true) {\n        return obj;\n    }\n\n    return utils.compact(obj);\n};\n","'use strict';\n\nvar replace = String.prototype.replace;\nvar percentTwenties = /%20/g;\n\nvar Format = {\n    RFC1738: 'RFC1738',\n    RFC3986: 'RFC3986'\n};\n\nmodule.exports = {\n    'default': Format.RFC3986,\n    formatters: {\n        RFC1738: function (value) {\n            return replace.call(value, percentTwenties, '+');\n        },\n        RFC3986: function (value) {\n            return String(value);\n        }\n    },\n    RFC1738: Format.RFC1738,\n    RFC3986: Format.RFC3986\n};\n","'use strict';\n\nvar formats = require('./formats');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar hexTable = (function () {\n    var array = [];\n    for (var i = 0; i < 256; ++i) {\n        array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());\n    }\n\n    return array;\n}());\n\nvar compactQueue = function compactQueue(queue) {\n    while (queue.length > 1) {\n        var item = queue.pop();\n        var obj = item.obj[item.prop];\n\n        if (isArray(obj)) {\n            var compacted = [];\n\n            for (var j = 0; j < obj.length; ++j) {\n                if (typeof obj[j] !== 'undefined') {\n                    compacted.push(obj[j]);\n                }\n            }\n\n            item.obj[item.prop] = compacted;\n        }\n    }\n};\n\nvar arrayToObject = function arrayToObject(source, options) {\n    var obj = options && options.plainObjects ? { __proto__: null } : {};\n    for (var i = 0; i < source.length; ++i) {\n        if (typeof source[i] !== 'undefined') {\n            obj[i] = source[i];\n        }\n    }\n\n    return obj;\n};\n\nvar merge = function merge(target, source, options) {\n    /* eslint no-param-reassign: 0 */\n    if (!source) {\n        return target;\n    }\n\n    if (typeof source !== 'object' && typeof source !== 'function') {\n        if (isArray(target)) {\n            target.push(source);\n        } else if (target && typeof target === 'object') {\n            if (\n                (options && (options.plainObjects || options.allowPrototypes))\n                || !has.call(Object.prototype, source)\n            ) {\n                target[source] = true;\n            }\n        } else {\n            return [target, source];\n        }\n\n        return target;\n    }\n\n    if (!target || typeof target !== 'object') {\n        return [target].concat(source);\n    }\n\n    var mergeTarget = target;\n    if (isArray(target) && !isArray(source)) {\n        mergeTarget = arrayToObject(target, options);\n    }\n\n    if (isArray(target) && isArray(source)) {\n        source.forEach(function (item, i) {\n            if (has.call(target, i)) {\n                var targetItem = target[i];\n                if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {\n                    target[i] = merge(targetItem, item, options);\n                } else {\n                    target.push(item);\n                }\n            } else {\n                target[i] = item;\n            }\n        });\n        return target;\n    }\n\n    return Object.keys(source).reduce(function (acc, key) {\n        var value = source[key];\n\n        if (has.call(acc, key)) {\n            acc[key] = merge(acc[key], value, options);\n        } else {\n            acc[key] = value;\n        }\n        return acc;\n    }, mergeTarget);\n};\n\nvar assign = function assignSingleSource(target, source) {\n    return Object.keys(source).reduce(function (acc, key) {\n        acc[key] = source[key];\n        return acc;\n    }, target);\n};\n\nvar decode = function (str, defaultDecoder, charset) {\n    var strWithoutPlus = str.replace(/\\+/g, ' ');\n    if (charset === 'iso-8859-1') {\n        // unescape never throws, no try...catch needed:\n        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);\n    }\n    // utf-8\n    try {\n        return decodeURIComponent(strWithoutPlus);\n    } catch (e) {\n        return strWithoutPlus;\n    }\n};\n\nvar limit = 1024;\n\n/* eslint operator-linebreak: [2, \"before\"] */\n\nvar encode = function encode(str, defaultEncoder, charset, kind, format) {\n    // This code was originally written by Brian White (mscdex) for the io.js core querystring library.\n    // It has been adapted here for stricter adherence to RFC 3986\n    if (str.length === 0) {\n        return str;\n    }\n\n    var string = str;\n    if (typeof str === 'symbol') {\n        string = Symbol.prototype.toString.call(str);\n    } else if (typeof str !== 'string') {\n        string = String(str);\n    }\n\n    if (charset === 'iso-8859-1') {\n        return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {\n            return '%26%23' + parseInt($0.slice(2), 16) + '%3B';\n        });\n    }\n\n    var out = '';\n    for (var j = 0; j < string.length; j += limit) {\n        var segment = string.length >= limit ? string.slice(j, j + limit) : string;\n        var arr = [];\n\n        for (var i = 0; i < segment.length; ++i) {\n            var c = segment.charCodeAt(i);\n            if (\n                c === 0x2D // -\n                || c === 0x2E // .\n                || c === 0x5F // _\n                || c === 0x7E // ~\n                || (c >= 0x30 && c <= 0x39) // 0-9\n                || (c >= 0x41 && c <= 0x5A) // a-z\n                || (c >= 0x61 && c <= 0x7A) // A-Z\n                || (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( )\n            ) {\n                arr[arr.length] = segment.charAt(i);\n                continue;\n            }\n\n            if (c < 0x80) {\n                arr[arr.length] = hexTable[c];\n                continue;\n            }\n\n            if (c < 0x800) {\n                arr[arr.length] = hexTable[0xC0 | (c >> 6)]\n                    + hexTable[0x80 | (c & 0x3F)];\n                continue;\n            }\n\n            if (c < 0xD800 || c >= 0xE000) {\n                arr[arr.length] = hexTable[0xE0 | (c >> 12)]\n                    + hexTable[0x80 | ((c >> 6) & 0x3F)]\n                    + hexTable[0x80 | (c & 0x3F)];\n                continue;\n            }\n\n            i += 1;\n            c = 0x10000 + (((c & 0x3FF) << 10) | (segment.charCodeAt(i) & 0x3FF));\n\n            arr[arr.length] = hexTable[0xF0 | (c >> 18)]\n                + hexTable[0x80 | ((c >> 12) & 0x3F)]\n                + hexTable[0x80 | ((c >> 6) & 0x3F)]\n                + hexTable[0x80 | (c & 0x3F)];\n        }\n\n        out += arr.join('');\n    }\n\n    return out;\n};\n\nvar compact = function compact(value) {\n    var queue = [{ obj: { o: value }, prop: 'o' }];\n    var refs = [];\n\n    for (var i = 0; i < queue.length; ++i) {\n        var item = queue[i];\n        var obj = item.obj[item.prop];\n\n        var keys = Object.keys(obj);\n        for (var j = 0; j < keys.length; ++j) {\n            var key = keys[j];\n            var val = obj[key];\n            if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {\n                queue.push({ obj: obj, prop: key });\n                refs.push(val);\n            }\n        }\n    }\n\n    compactQueue(queue);\n\n    return value;\n};\n\nvar isRegExp = function isRegExp(obj) {\n    return Object.prototype.toString.call(obj) === '[object RegExp]';\n};\n\nvar isBuffer = function isBuffer(obj) {\n    if (!obj || typeof obj !== 'object') {\n        return false;\n    }\n\n    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));\n};\n\nvar combine = function combine(a, b) {\n    return [].concat(a, b);\n};\n\nvar maybeMap = function maybeMap(val, fn) {\n    if (isArray(val)) {\n        var mapped = [];\n        for (var i = 0; i < val.length; i += 1) {\n            mapped.push(fn(val[i]));\n        }\n        return mapped;\n    }\n    return fn(val);\n};\n\nmodule.exports = {\n    arrayToObject: arrayToObject,\n    assign: assign,\n    combine: combine,\n    compact: compact,\n    decode: decode,\n    encode: encode,\n    isBuffer: isBuffer,\n    isRegExp: isRegExp,\n    maybeMap: maybeMap,\n    merge: merge\n};\n"],"sourceRoot":""}