node_modules/qs/lib/parse.js - devtools/devtools-frontend - Git at Google

 'use strict';

 var utils = require('./utils');

 var has = Object.prototype.hasOwnProperty;
 var isArray = Array.isArray;

 var defaults = {
     allowDots: false,
     allowEmptyArrays: false,
     allowPrototypes: false,
     allowSparse: false,
     arrayLimit: 20,
     charset: 'utf-8',
     charsetSentinel: false,
     comma: false,
     decodeDotInKeys: false,
     decoder: utils.decode,
     delimiter: '&',
     depth: 5,
     duplicates: 'combine',
     ignoreQueryPrefix: false,
     interpretNumericEntities: false,
     parameterLimit: 1000,
     parseArrays: true,
     plainObjects: false,
     strictDepth: false,
     strictNullHandling: false,
     throwOnLimitExceeded: false
 };

 var interpretNumericEntities = function (str) {
     return str.replace(/&#(\d+);/g, function ($0, numberStr) {
         return String.fromCharCode(parseInt(numberStr, 10));
     });
 };

 var parseArrayValue = function (val, options, currentArrayLength) {
     if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
         return val.split(',');
     }

     if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
         throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
     }

     return val;
 };

 // This is what browsers will submit when the ✓ character occurs in an
 // application/x-www-form-urlencoded body and the encoding of the page containing
 // the form is iso-8859-1, or when the submitted form has an accept-charset
 // attribute of iso-8859-1. Presumably also with other charsets that do not contain
 // the ✓ character, such as us-ascii.
 var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('&#10003;')

 // These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
 var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')

 var parseValues = function parseQueryStringValues(str, options) {
     var obj = { __proto__: null };

     var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
     cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');

     var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
     var parts = cleanStr.split(
         options.delimiter,
         options.throwOnLimitExceeded ? limit + 1 : limit
     );

     if (options.throwOnLimitExceeded && parts.length > limit) {
         throw new RangeError('Parameter limit exceeded. Only ' + limit + ' parameter' + (limit === 1 ? '' : 's') + ' allowed.');
     }

     var skipIndex = -1; // Keep track of where the utf8 sentinel was found
     var i;

     var charset = options.charset;
     if (options.charsetSentinel) {
         for (i = 0; i < parts.length; ++i) {
             if (parts[i].indexOf('utf8=') === 0) {
                 if (parts[i] === charsetSentinel) {
                     charset = 'utf-8';
                 } else if (parts[i] === isoSentinel) {
                     charset = 'iso-8859-1';
                 }
                 skipIndex = i;
                 i = parts.length; // The eslint settings do not allow break;
             }
         }
     }

     for (i = 0; i < parts.length; ++i) {
         if (i === skipIndex) {
             continue;
         }
         var part = parts[i];

         var bracketEqualsPos = part.indexOf(']=');
         var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;

         var key;
         var val;
         if (pos === -1) {
             key = options.decoder(part, defaults.decoder, charset, 'key');
             val = options.strictNullHandling ? null : '';
         } else {
             key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');

             if (key !== null) {
                 val = utils.maybeMap(
                     parseArrayValue(
                         part.slice(pos + 1),
                         options,
                         isArray(obj[key]) ? obj[key].length : 0
                     ),
                     function (encodedVal) {
                         return options.decoder(encodedVal, defaults.decoder, charset, 'value');
                     }
                 );
             }
         }

         if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
             val = interpretNumericEntities(String(val));
         }

         if (part.indexOf('[]=') > -1) {
             val = isArray(val) ? [val] : val;
         }

         if (key !== null) {
             var existing = has.call(obj, key);
             if (existing && options.duplicates === 'combine') {
                 obj[key] = utils.combine(
                     obj[key],
                     val,
                     options.arrayLimit,
                     options.plainObjects
                 );
             } else if (!existing || options.duplicates === 'last') {
                 obj[key] = val;
             }
         }
     }

     return obj;
 };

 var parseObject = function (chain, val, options, valuesParsed) {
     var currentArrayLength = 0;
     if (chain.length > 0 && chain[chain.length - 1] === '[]') {
         var parentKey = chain.slice(0, -1).join('');
         currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
     }

     var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);

     for (var i = chain.length - 1; i >= 0; --i) {
         var obj;
         var root = chain[i];

         if (root === '[]' && options.parseArrays) {
             if (utils.isOverflow(leaf)) {
                 // leaf is already an overflow object, preserve it
                 obj = leaf;
             } else {
                 obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
                     ? []
                     : utils.combine(
                         [],
                         leaf,
                         options.arrayLimit,
                         options.plainObjects
                     );
             }
         } else {
             obj = options.plainObjects ? { __proto__: null } : {};
             var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
             var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;
             var index = parseInt(decodedRoot, 10);
             if (!options.parseArrays && decodedRoot === '') {
                 obj = { 0: leaf };
             } else if (
                 !isNaN(index)
                 && root !== decodedRoot
                 && String(index) === decodedRoot
                 && index >= 0
                 && (options.parseArrays && index <= options.arrayLimit)
             ) {
                 obj = [];
                 obj[index] = leaf;
             } else if (decodedRoot !== '__proto__') {
                 obj[decodedRoot] = leaf;
             }
         }

         leaf = obj;
     }

     return leaf;
 };

 var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
     var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;

     if (options.depth <= 0) {
         if (!options.plainObjects && has.call(Object.prototype, key)) {
             if (!options.allowPrototypes) {
                 return;
             }
         }

         return [key];
     }

     var brackets = /(\[[^[\]]*])/;
     var child = /(\[[^[\]]*])/g;

     var segment = brackets.exec(key);
     var parent = segment ? key.slice(0, segment.index) : key;

     var keys = [];

     if (parent) {
         if (!options.plainObjects && has.call(Object.prototype, parent)) {
             if (!options.allowPrototypes) {
                 return;
             }
         }

         keys.push(parent);
     }

     var i = 0;
     while ((segment = child.exec(key)) !== null && i < options.depth) {
         i += 1;

         var segmentContent = segment[1].slice(1, -1);
         if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
             if (!options.allowPrototypes) {
                 return;
             }
         }

         keys.push(segment[1]);
     }

     if (segment) {
         if (options.strictDepth === true) {
             throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
         }

         keys.push('[' + key.slice(segment.index) + ']');
     }

     return keys;
 };

 var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
     if (!givenKey) {
         return;
     }

     var keys = splitKeyIntoSegments(givenKey, options);

     if (!keys) {
         return;
     }

     return parseObject(keys, val, options, valuesParsed);
 };

 var normalizeParseOptions = function normalizeParseOptions(opts) {
     if (!opts) {
         return defaults;
     }

     if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
         throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
     }

     if (typeof opts.decodeDotInKeys !== 'undefined' && typeof opts.decodeDotInKeys !== 'boolean') {
         throw new TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');
     }

     if (opts.decoder !== null && typeof opts.decoder !== 'undefined' && typeof opts.decoder !== 'function') {
         throw new TypeError('Decoder has to be a function.');
     }

     if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
         throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
     }

     if (typeof opts.throwOnLimitExceeded !== 'undefined' && typeof opts.throwOnLimitExceeded !== 'boolean') {
         throw new TypeError('`throwOnLimitExceeded` option must be a boolean');
     }

     var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;

     var duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;

     if (duplicates !== 'combine' && duplicates !== 'first' && duplicates !== 'last') {
         throw new TypeError('The duplicates option must be either combine, first, or last');
     }

     var allowDots = typeof opts.allowDots === 'undefined' ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;

     return {
         allowDots: allowDots,
         allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
         allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
         allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,
         arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
         charset: charset,
         charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
         comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
         decodeDotInKeys: typeof opts.decodeDotInKeys === 'boolean' ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
         decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
         delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
         // eslint-disable-next-line no-implicit-coercion, no-extra-parens
         depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,
         duplicates: duplicates,
         ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
         interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
         parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
         parseArrays: opts.parseArrays !== false,
         plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
         strictDepth: typeof opts.strictDepth === 'boolean' ? !!opts.strictDepth : defaults.strictDepth,
         strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
         throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === 'boolean' ? opts.throwOnLimitExceeded : false
     };
 };

 module.exports = function (str, opts) {
     var options = normalizeParseOptions(opts);

     if (str === '' || str === null || typeof str === 'undefined') {
         return options.plainObjects ? { __proto__: null } : {};
     }

     var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
     var obj = options.plainObjects ? { __proto__: null } : {};

     // Iterate over the keys and setup the new object

     var keys = Object.keys(tempObj);
     for (var i = 0; i < keys.length; ++i) {
         var key = keys[i];
         var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');
         obj = utils.merge(obj, newObj, options);
     }

     if (options.allowSparse === true) {
         return obj;
     }

     return utils.compact(obj);
 };
	'use strict';

	var utils = require('./utils');

	var has = Object.prototype.hasOwnProperty;
	var isArray = Array.isArray;

	var defaults = {
	allowDots: false,
	allowEmptyArrays: false,
	allowPrototypes: false,
	allowSparse: false,
	arrayLimit: 20,
	charset: 'utf-8',
	charsetSentinel: false,
	comma: false,
	decodeDotInKeys: false,
	decoder: utils.decode,
	delimiter: '&',
	depth: 5,
	duplicates: 'combine',
	ignoreQueryPrefix: false,
	interpretNumericEntities: false,
	parameterLimit: 1000,
	parseArrays: true,
	plainObjects: false,
	strictDepth: false,
	strictNullHandling: false,
	throwOnLimitExceeded: false
	};

	var interpretNumericEntities = function (str) {
	return str.replace(/&#(\d+);/g, function ($0, numberStr) {
	return String.fromCharCode(parseInt(numberStr, 10));
	});
	};

	var parseArrayValue = function (val, options, currentArrayLength) {
	if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
	return val.split(',');
	}

	if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
	throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
	}

	return val;
	};

	// This is what browsers will submit when the ✓ character occurs in an
	// application/x-www-form-urlencoded body and the encoding of the page containing
	// the form is iso-8859-1, or when the submitted form has an accept-charset
	// attribute of iso-8859-1. Presumably also with other charsets that do not contain
	// the ✓ character, such as us-ascii.
	var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')

	// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
	var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')

	var parseValues = function parseQueryStringValues(str, options) {
	var obj = { __proto__: null };

	var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
	cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');

	var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
	var parts = cleanStr.split(
	options.delimiter,
	options.throwOnLimitExceeded ? limit + 1 : limit
	);

	if (options.throwOnLimitExceeded && parts.length > limit) {
	throw new RangeError('Parameter limit exceeded. Only ' + limit + ' parameter' + (limit === 1 ? '' : 's') + ' allowed.');
	}

	var skipIndex = -1; // Keep track of where the utf8 sentinel was found
	var i;

	var charset = options.charset;
	if (options.charsetSentinel) {
	for (i = 0; i < parts.length; ++i) {
	if (parts[i].indexOf('utf8=') === 0) {
	if (parts[i] === charsetSentinel) {
	charset = 'utf-8';
	} else if (parts[i] === isoSentinel) {
	charset = 'iso-8859-1';
	}
	skipIndex = i;
	i = parts.length; // The eslint settings do not allow break;
	}
	}
	}

	for (i = 0; i < parts.length; ++i) {
	if (i === skipIndex) {
	continue;
	}
	var part = parts[i];

	var bracketEqualsPos = part.indexOf(']=');
	var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;

	var key;
	var val;
	if (pos === -1) {
	key = options.decoder(part, defaults.decoder, charset, 'key');
	val = options.strictNullHandling ? null : '';
	} else {
	key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');

	if (key !== null) {
	val = utils.maybeMap(
	parseArrayValue(
	part.slice(pos + 1),
	options,
	isArray(obj[key]) ? obj[key].length : 0
	),
	function (encodedVal) {
	return options.decoder(encodedVal, defaults.decoder, charset, 'value');
	}
	);
	}
	}

	if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
	val = interpretNumericEntities(String(val));
	}

	if (part.indexOf('[]=') > -1) {
	val = isArray(val) ? [val] : val;
	}

	if (key !== null) {
	var existing = has.call(obj, key);
	if (existing && options.duplicates === 'combine') {
	obj[key] = utils.combine(
	obj[key],
	val,
	options.arrayLimit,
	options.plainObjects
	);
	} else if (!existing \|\| options.duplicates === 'last') {
	obj[key] = val;
	}
	}
	}

	return obj;
	};

	var parseObject = function (chain, val, options, valuesParsed) {
	var currentArrayLength = 0;
	if (chain.length > 0 && chain[chain.length - 1] === '[]') {
	var parentKey = chain.slice(0, -1).join('');
	currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
	}

	var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);

	for (var i = chain.length - 1; i >= 0; --i) {
	var obj;
	var root = chain[i];

	if (root === '[]' && options.parseArrays) {
	if (utils.isOverflow(leaf)) {
	// leaf is already an overflow object, preserve it
	obj = leaf;
	} else {
	obj = options.allowEmptyArrays && (leaf === '' \|\| (options.strictNullHandling && leaf === null))
	? []
	: utils.combine(
	[],
	leaf,
	options.arrayLimit,
	options.plainObjects
	);
	}
	} else {
	obj = options.plainObjects ? { __proto__: null } : {};
	var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
	var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;
	var index = parseInt(decodedRoot, 10);
	if (!options.parseArrays && decodedRoot === '') {
	obj = { 0: leaf };
	} else if (
	!isNaN(index)
	&& root !== decodedRoot
	&& String(index) === decodedRoot
	&& index >= 0
	&& (options.parseArrays && index <= options.arrayLimit)
	) {
	obj = [];
	obj[index] = leaf;
	} else if (decodedRoot !== '__proto__') {
	obj[decodedRoot] = leaf;
	}
	}

	leaf = obj;
	}

	return leaf;
	};

	var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
	var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;

	if (options.depth <= 0) {
	if (!options.plainObjects && has.call(Object.prototype, key)) {
	if (!options.allowPrototypes) {
	return;
	}
	}

	return [key];
	}

	var brackets = /(\[[^[\]]*])/;
	var child = /(\[[^[\]]*])/g;

	var segment = brackets.exec(key);
	var parent = segment ? key.slice(0, segment.index) : key;

	var keys = [];

	if (parent) {
	if (!options.plainObjects && has.call(Object.prototype, parent)) {
	if (!options.allowPrototypes) {
	return;
	}
	}

	keys.push(parent);
	}

	var i = 0;
	while ((segment = child.exec(key)) !== null && i < options.depth) {
	i += 1;

	var segmentContent = segment[1].slice(1, -1);
	if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
	if (!options.allowPrototypes) {
	return;
	}
	}

	keys.push(segment[1]);
	}

	if (segment) {
	if (options.strictDepth === true) {
	throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
	}

	keys.push('[' + key.slice(segment.index) + ']');
	}

	return keys;
	};

	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
	if (!givenKey) {
	return;
	}

	var keys = splitKeyIntoSegments(givenKey, options);

	if (!keys) {
	return;
	}

	return parseObject(keys, val, options, valuesParsed);
	};

	var normalizeParseOptions = function normalizeParseOptions(opts) {
	if (!opts) {
	return defaults;
	}

	if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
	throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
	}

	if (typeof opts.decodeDotInKeys !== 'undefined' && typeof opts.decodeDotInKeys !== 'boolean') {
	throw new TypeError('`decodeDotInKeys` option can only be `true` or `false`, when provided');
	}

	if (opts.decoder !== null && typeof opts.decoder !== 'undefined' && typeof opts.decoder !== 'function') {
	throw new TypeError('Decoder has to be a function.');
	}

	if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
	throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
	}

	if (typeof opts.throwOnLimitExceeded !== 'undefined' && typeof opts.throwOnLimitExceeded !== 'boolean') {
	throw new TypeError('`throwOnLimitExceeded` option must be a boolean');
	}

	var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;

	var duplicates = typeof opts.duplicates === 'undefined' ? defaults.duplicates : opts.duplicates;

	if (duplicates !== 'combine' && duplicates !== 'first' && duplicates !== 'last') {
	throw new TypeError('The duplicates option must be either combine, first, or last');
	}

	var allowDots = typeof opts.allowDots === 'undefined' ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;

	return {
	allowDots: allowDots,
	allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
	allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
	allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,
	arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
	charset: charset,
	charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
	comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
	decodeDotInKeys: typeof opts.decodeDotInKeys === 'boolean' ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
	decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
	delimiter: typeof opts.delimiter === 'string' \|\| utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
	// eslint-disable-next-line no-implicit-coercion, no-extra-parens
	depth: (typeof opts.depth === 'number' \|\| opts.depth === false) ? +opts.depth : defaults.depth,
	duplicates: duplicates,
	ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
	interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
	parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
	parseArrays: opts.parseArrays !== false,
	plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
	strictDepth: typeof opts.strictDepth === 'boolean' ? !!opts.strictDepth : defaults.strictDepth,
	strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
	throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === 'boolean' ? opts.throwOnLimitExceeded : false
	};
	};

	module.exports = function (str, opts) {
	var options = normalizeParseOptions(opts);

	if (str === '' \|\| str === null \|\| typeof str === 'undefined') {
	return options.plainObjects ? { __proto__: null } : {};
	}

	var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
	var obj = options.plainObjects ? { __proto__: null } : {};

	// Iterate over the keys and setup the new object

	var keys = Object.keys(tempObj);
	for (var i = 0; i < keys.length; ++i) {
	var key = keys[i];
	var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');
	obj = utils.merge(obj, newObj, options);
	}

	if (options.allowSparse === true) {
	return obj;
	}

	return utils.compact(obj);
	};