{"version":3,"file":"commons-app-parse.js.0936fc5978249b760bb0.js","mappings":"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","sources":["webpack://grfanclub-webview/./node_modules/qs/lib/parse.js"],"sourcesContent":["'use strict';\n\nvar utils = require('./utils');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar defaults = {\n    allowDots: false,\n    allowPrototypes: false,\n    allowSparse: false,\n    arrayLimit: 20,\n    charset: 'utf-8',\n    charsetSentinel: false,\n    comma: false,\n    decoder: utils.decode,\n    delimiter: '&',\n    depth: 5,\n    ignoreQueryPrefix: false,\n    interpretNumericEntities: false,\n    parameterLimit: 1000,\n    parseArrays: true,\n    plainObjects: 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 = {};\n    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, '') : str;\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, 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(val);\n        }\n\n        if (part.indexOf('[]=') > -1) {\n            val = isArray(val) ? [val] : val;\n        }\n\n        if (has.call(obj, key)) {\n            obj[key] = utils.combine(obj[key], val);\n        } else {\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 = [].concat(leaf);\n        } else {\n            obj = options.plainObjects ? Object.create(null) : {};\n            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;\n            var index = parseInt(cleanRoot, 10);\n            if (!options.parseArrays && cleanRoot === '') {\n                obj = { 0: leaf };\n            } else if (\n                !isNaN(index)\n                && root !== cleanRoot\n                && String(index) === cleanRoot\n                && index >= 0\n                && (options.parseArrays && index <= options.arrayLimit)\n            ) {\n                obj = [];\n                obj[index] = leaf;\n            } else if (cleanRoot !== '__proto__') {\n                obj[cleanRoot] = 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, just add whatever is left\n\n    if (segment) {\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 (opts.decoder !== null && 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    return {\n        allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,\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        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        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        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 ? Object.create(null) : {};\n    }\n\n    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;\n    var obj = options.plainObjects ? Object.create(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"],"names":["utils","has","Object","prototype","hasOwnProperty","isArray","Array","defaults","allowDots","allowPrototypes","allowSparse","arrayLimit","charset","charsetSentinel","comma","decoder","decode","delimiter","depth","ignoreQueryPrefix","interpretNumericEntities","parameterLimit","parseArrays","plainObjects","strictNullHandling","str","replace","$0","numberStr","String","fromCharCode","parseInt","parseArrayValue","val","options","indexOf","split","parseKeys","givenKey","valuesParsed","key","child","segment","exec","parent","slice","index","keys","call","push","i","chain","leaf","length","obj","root","concat","create","cleanRoot","charAt","isNaN","parseObject","module","exports","opts","undefined","TypeError","isRegExp","normalizeParseOptions","tempObj","cleanStr","limit","Infinity","parts","skipIndex","part","bracketEqualsPos","pos","maybeMap","encodedVal","combine","parseValues","newObj","merge","compact"],"sourceRoot":""}