@common.js/query-string 9.1.0 → 9.4.1

package/README.md

@@ -2,4 +2,4 @@
 
 The [query-string](https://www.npmjs.com/package/query-string) package exported as CommonJS modules.
 
-Exported from [query-string@9.1.0](https://www.npmjs.com/package/query-string/v/9.1.0) using https://github.com/etienne-martin/common.js.
+Exported from [query-string@9.4.1](https://www.npmjs.com/package/query-string/v/9.4.1) using https://github.com/etienne-martin/common.js.

package/base.d.ts

@@ -178,18 +178,18 @@ export type ParseOptions = {
 	readonly parseFragmentIdentifier?: boolean;
 
 	/**
-	Specify a pre-defined schema to be used when parsing values. The types specified will take precedence over options such as: `parseNumber`, `parseBooleans`, and `arrayFormat`.
+	Specifies a schema for parsing query values with explicit type declarations. When defined, the types provided here take precedence over general parsing options such as `parseNumbers`, `parseBooleans`, and `arrayFormat`.
 
-	Use this feature to override the type of a value. This can be useful when the type is ambiguous such as a phone number (see example 1 and 2).
+	Use this option to explicitly define the type of a specific parameter—particularly useful in cases where the type might otherwise be ambiguous (e.g., phone numbers or IDs).
 
-	It is possible to provide a custom function as the parameter type. The parameter's value will equal the function's return value (see example 4).
+	You can also provide a custom function to transform the value. The function will receive the raw string and should return the desired parsed result. When used with array formats (like `comma`, `separator`, `bracket`, etc.), the function is applied to each array element individually.
 
-	NOTE: Array types (`string[]` and `number[]`) will have no effect if `arrayFormat` is set to `none` (see example 5).
+	NOTE: Array types (`string[]`, `number[]`) are ignored if `arrayFormat` is set to `'none'`.
 
 	@default {}
 
 	@example
-	Parse `phoneNumber` as a string, overriding the `parseNumber` option:
+	Parse `phoneNumber` as a string, overriding the `parseNumbers` option:
 	```
 	import queryString from 'query-string';
 
@@ -203,12 +203,12 @@ export type ParseOptions = {
 	```
 
 	@example
-	Parse `items` as an array of strings, overriding the `parseNumber` option:
+	Parse `items` as an array of strings, overriding the `parseNumbers` option:
 	```
 	import queryString from 'query-string';
 
 	queryString.parse('?age=20&items=1%2C2%2C3', {
-		parseNumber: true,
+		parseNumbers: true,
 		types: {
 			items: 'string[]',
 		}
@@ -217,7 +217,7 @@ export type ParseOptions = {
 	```
 
 	@example
-	Parse `age` as a number, even when `parseNumber` is false:
+	Force `age` to be parsed as a number even when `parseNumbers` is false:
 	```
 	import queryString from 'query-string';
 
@@ -226,24 +226,39 @@ export type ParseOptions = {
 			age: 'number',
 		}
 	});
-	//=> {age: 20, id: '01234', zipcode: '90210 }
+	//=> {age: 20, id: '01234', zipcode: '90210'}
 	```
 
 	@example
-	Parse `age` using a custom value parser:
+	Use a custom parser function to transform the value of `age`:
 	```
 	import queryString from 'query-string';
 
 	queryString.parse('?age=20&id=01234&zipcode=90210', {
 		types: {
-			age: (value) => value * 2,
+			age: value => value * 2,
+		}
+	});
+	//=> {age: 40, id: '01234', zipcode: '90210'}
+	```
+
+	@example
+	Custom functions are applied to each array element when using array formats:
+	```
+	import queryString from 'query-string';
+
+	// With arrays, the function is applied to each element
+	queryString.parse('?scores=10,20,30', {
+		arrayFormat: 'comma',
+		types: {
+			scores: value => Number(value) * 2,
 		}
 	});
-	//=> {age: 40, id: '01234', zipcode: '90210 }
+	//=> {scores: [20, 40, 60]}
 	```
 
 	@example
-	Array types will have no effect when `arrayFormat` is set to `none`
+	Array types are ignored when `arrayFormat` is set to `'none'`:
 	```
 	queryString.parse('ids=001%2C002%2C003&foods=apple%2Corange%2Cmango', {
 		arrayFormat: 'none',
@@ -256,7 +271,7 @@ export type ParseOptions = {
 	```
 
 	@example
-	Parse a query utilizing all types:
+	Parse a query using multiple type definitions:
 	```
 	import queryString from 'query-string';
 
@@ -267,16 +282,31 @@ export type ParseOptions = {
 			items: 'string[]',
 			price: 'string',
 			numbers: 'number[]',
-			double: (value) => value * 2,
+			double: value => value * 2,
 			number: 'number',
 		},
 	});
 	//=> {ids: '001,002,003', items: ['1', '2', '3'], price: '22.00', numbers: [1, 2, 3], double: 10, number: 20}
 	```
+
+	@example
+	Force `flagged` to be parsed as a boolean even when `parseBooleans` is false:
+	```
+	queryString.parse('?isAdmin=true&flagged=true&isOkay=0', {
+			parseBooleans: false,
+			types: {
+					flagged: 'boolean',
+					isOkay: 'boolean',
+			},
+	});
+	//=> {isAdmin: 'true', flagged: true, isOkay: false}
+	```
+
+	Note: The `'boolean'` type also converts `'0'` and `'1'` to booleans, and treats valueless keys (e.g. `?flag`) as `true`.
 	*/
 	readonly types?: Record<
 	string,
-	'number' | 'string' | 'string[]' | 'number[]' | ((value: string) => unknown)
+	'boolean' | 'number' | 'string' | 'string[]' | 'number[]' | ((value: string) => unknown)
 	>;
 };
 
@@ -310,9 +340,10 @@ export type ParsedUrl = {
 /**
 Extract the URL and the query string as an object.
 
-If the `parseFragmentIdentifier` option is `true`, the object will also contain a `fragmentIdentifier` property.
-
 @param url - The URL to parse.
+@returns An object with a `url` and `query` property.
+
+If the `parseFragmentIdentifier` option is `true`, the object will also contain a `fragmentIdentifier` property.
 
 @example
 ```
@@ -519,17 +550,80 @@ export type StringifyOptions = {
 	```
 	*/
 	readonly skipEmptyString?: boolean;
+
+	/**
+	A function that transforms key-value pairs before stringification.
+
+	Similar to the `replacer` parameter of `JSON.stringify()`, this function is called for each key-value pair and can be used to transform values before they are stringified.
+
+	The function receives the key and value, and should return the transformed value. Returning `undefined` will omit the key-value pair from the resulting query string.
+
+	This is useful for custom serialization of non-primitive types like `Date`:
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.stringify({
+		date: new Date('2024-01-15T10:30:00Z'),
+		name: 'John'
+	}, {
+		replacer: (key, value) => {
+			if (value instanceof Date) {
+				return value.toISOString();
+			}
+
+			return value;
+		}
+	});
+	//=> 'date=2024-01-15T10%3A30%3A00.000Z&name=John'
+	```
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	// Omit keys with null values using replacer instead of skipNull
+	queryString.stringify({
+		a: 1,
+		b: null,
+		c: 3
+	}, {
+		replacer: (key, value) => value === null ? undefined : value
+	});
+	//=> 'a=1&c=3'
+	```
+	*/
+	readonly replacer?: (key: string, value: unknown) => unknown;
 };
 
+/**
+Supported value types for query string parameters.
+
+Note: `Symbol`, functions, and objects (except arrays) are not supported and will throw an error when stringified.
+*/
 export type Stringifiable = string | boolean | number | bigint | null | undefined; // eslint-disable-line @typescript-eslint/ban-types
 
+/**
+A record of stringifiable values.
+*/
 export type StringifiableRecord = Record<
 string,
 Stringifiable | readonly Stringifiable[]
 >;
 
 /**
-Stringify an object into a query string and sort the keys.
+Stringify an object into a query string and sorting the keys.
+
+@param object - Object to stringify. Supported value types are: `string`, `number`, `bigint`, `boolean`, `null`, `undefined`, and arrays of these types. Other types like `Symbol`, functions, or objects (except arrays) will throw an error.
+
+@example
+```
+import queryString from 'query-string';
+
+queryString.stringify({foo: 'bar', baz: 42, qux: true});
+//=> 'baz=42&foo=bar&qux=true'
+```
 */
 export function stringify(
 	// TODO: Use the below instead when the following TS issues are fixed:
@@ -544,7 +638,13 @@ export function stringify(
 /**
 Extract a query string from a URL that can be passed into `.parse()`.
 
-Note: This behaviour can be changed with the `skipNull` option.
+@example
+```
+import queryString from 'query-string';
+
+queryString.extract('https://foo.bar?foo=bar');
+//=> 'foo=bar'
+```
 */
 export function extract(url: string): string;
 
@@ -565,6 +665,10 @@ export type UrlObject = {
 /**
 Stringify an object into a URL with a query string and sorting the keys. The inverse of [`.parseUrl()`](https://github.com/sindresorhus/query-string#parseurlstring-options)
 
+The `options` are the same as for `.stringify()`.
+
+@returns A string with the URL and a query string.
+
 Query items in the `query` property overrides queries in the `url` property.
 
 The `fragmentIdentifier` property overrides the fragment identifier in the `url` property.

package/base.js

@@ -42,9 +42,6 @@ function _arrayLikeToArray(arr, len) {
 function _arrayWithHoles(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
 function _defineProperty(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -63,9 +60,6 @@ function _interopRequireDefault(obj) {
         default: obj
     };
 }
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
 function _iterableToArrayLimit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -93,9 +87,6 @@ function _iterableToArrayLimit(arr, i) {
 function _nonIterableRest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
 function _objectSpread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -114,9 +105,6 @@ function _objectSpread(target) {
 function _slicedToArray(arr, i) {
     return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
 function _unsupportedIterableToArray(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -146,24 +134,22 @@ function encoderForArrayFormat(options) {
                             return result;
                         }
                         if (value === null) {
-                            return _toConsumableArray(result).concat([
-                                [
-                                    encode(key, options),
-                                    "[",
-                                    index,
-                                    "]"
-                                ].join(""), 
-                            ]);
-                        }
-                        return _toConsumableArray(result).concat([
-                            [
+                            result.push([
                                 encode(key, options),
                                 "[",
-                                encode(index, options),
-                                "]=",
-                                encode(value, options)
-                            ].join(""), 
-                        ]);
+                                index,
+                                "]"
+                            ].join(""));
+                            return result;
+                        }
+                        result.push([
+                            encode(key, options),
+                            "[",
+                            encode(index, options),
+                            "]=",
+                            encode(value, options)
+                        ].join(""));
+                        return result;
                     };
                 };
             }
@@ -175,20 +161,18 @@ function encoderForArrayFormat(options) {
                             return result;
                         }
                         if (value === null) {
-                            return _toConsumableArray(result).concat([
-                                [
-                                    encode(key, options),
-                                    "[]"
-                                ].join(""), 
-                            ]);
-                        }
-                        return _toConsumableArray(result).concat([
-                            [
+                            result.push([
                                 encode(key, options),
-                                "[]=",
-                                encode(value, options)
-                            ].join(""), 
-                        ]);
+                                "[]"
+                            ].join(""));
+                            return result;
+                        }
+                        result.push([
+                            encode(key, options),
+                            "[]=",
+                            encode(value, options)
+                        ].join(""));
+                        return result;
                     };
                 };
             }
@@ -200,20 +184,18 @@ function encoderForArrayFormat(options) {
                             return result;
                         }
                         if (value === null) {
-                            return _toConsumableArray(result).concat([
-                                [
-                                    encode(key, options),
-                                    ":list="
-                                ].join(""), 
-                            ]);
-                        }
-                        return _toConsumableArray(result).concat([
-                            [
+                            result.push([
                                 encode(key, options),
-                                ":list=",
-                                encode(value, options)
-                            ].join(""), 
-                        ]);
+                                ":list="
+                            ].join(""));
+                            return result;
+                        }
+                        result.push([
+                            encode(key, options),
+                            ":list=",
+                            encode(value, options)
+                        ].join(""));
+                        return result;
                     };
                 };
             }
@@ -230,20 +212,15 @@ function encoderForArrayFormat(options) {
                         // Translate null to an empty string so that it doesn't serialize as 'null'
                         value = value === null ? "" : value;
                         if (result.length === 0) {
-                            return [
-                                [
-                                    encode(key, options),
-                                    keyValueSeparator,
-                                    encode(value, options)
-                                ].join("")
-                            ];
-                        }
-                        return [
-                            [
-                                result,
+                            result.push([
+                                encode(key, options),
+                                keyValueSeparator,
                                 encode(value, options)
-                            ].join(options.arrayFormatSeparator)
-                        ];
+                            ].join(""));
+                            return result;
+                        }
+                        result.push(encode(value, options));
+                        return result;
                     };
                 };
             }
@@ -255,17 +232,15 @@ function encoderForArrayFormat(options) {
                             return result;
                         }
                         if (value === null) {
-                            return _toConsumableArray(result).concat([
-                                encode(key, options), 
-                            ]);
+                            result.push(encode(key, options));
+                            return result;
                         }
-                        return _toConsumableArray(result).concat([
-                            [
-                                encode(key, options),
-                                "=",
-                                encode(value, options)
-                            ].join(""), 
-                        ]);
+                        result.push([
+                            encode(key, options),
+                            "=",
+                            encode(value, options)
+                        ].join(""));
+                        return result;
                     };
                 };
             }
@@ -304,9 +279,14 @@ function parserForArrayFormat(options) {
                         ];
                         return;
                     }
-                    accumulator[key] = _toConsumableArray(accumulator[key]).concat([
-                        value
-                    ]);
+                    if (!Array.isArray(accumulator[key])) {
+                        accumulator[key] = [
+                            accumulator[key],
+                            value
+                        ];
+                        return;
+                    }
+                    accumulator[key].push(value);
                 };
             }
         case "colon-list-separator":
@@ -324,9 +304,14 @@ function parserForArrayFormat(options) {
                         ];
                         return;
                     }
-                    accumulator[key] = _toConsumableArray(accumulator[key]).concat([
-                        value
-                    ]);
+                    if (!Array.isArray(accumulator[key])) {
+                        accumulator[key] = [
+                            accumulator[key],
+                            value
+                        ];
+                        return;
+                    }
+                    accumulator[key].push(value);
                 };
             }
         case "comma":
@@ -334,9 +319,7 @@ function parserForArrayFormat(options) {
             {
                 return function(key, value, accumulator) {
                     var isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
-                    var isEncodedArray = typeof value === "string" && !isArray && decode(value, options).includes(options.arrayFormatSeparator);
-                    value = isEncodedArray ? decode(value, options) : value;
-                    var newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(function(item) {
+                    var newValue = isArray ? value.split(options.arrayFormatSeparator).map(function(item) {
                         return decode(item, options);
                     }) : value === null ? value : decode(value, options);
                     accumulator[key] = newValue;
@@ -351,14 +334,36 @@ function parserForArrayFormat(options) {
                         accumulator[key] = value ? decode(value, options) : value;
                         return;
                     }
-                    var arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map(function(item) {
-                        return decode(item, options);
-                    });
+                    var arrayValue = value === null ? [] : decode(value, options).split(options.arrayFormatSeparator);
                     if (accumulator[key] === undefined) {
                         accumulator[key] = arrayValue;
                         return;
                     }
-                    accumulator[key] = _toConsumableArray(accumulator[key]).concat(_toConsumableArray(arrayValue));
+                    if (!Array.isArray(accumulator[key])) {
+                        accumulator[key] = [
+                            accumulator[key]
+                        ];
+                    }
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = arrayValue[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var item = _step.value;
+                            accumulator[key].push(item);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
                 };
             }
         default:
@@ -368,11 +373,14 @@ function parserForArrayFormat(options) {
                         accumulator[key] = value;
                         return;
                     }
-                    accumulator[key] = _toConsumableArray([
-                        accumulator[key]
-                    ].flat()).concat([
+                    if (Array.isArray(accumulator[key])) {
+                        accumulator[key].push(value);
+                        return;
+                    }
+                    accumulator[key] = [
+                        accumulator[key],
                         value
-                    ]);
+                    ];
                 };
             }
     }
@@ -422,6 +430,11 @@ function getHash(url) {
     }
     return hash;
 }
+function getUrlWithoutQuery(url) {
+    // Avoid `split('?')` so query-heavy URLs don't allocate large arrays.
+    var queryStart = url.indexOf("?");
+    return queryStart === -1 ? url : url.slice(0, queryStart);
+}
 function parseValue(value, options, type) {
     if (type === "string" && typeof value === "string") {
         return value;
@@ -429,12 +442,31 @@ function parseValue(value, options, type) {
     if (typeof type === "function" && typeof value === "string") {
         return type(value);
     }
-    if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+    if (type === "boolean" && value === null) {
+        return true;
+    }
+    if (type === "boolean" && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
         return value.toLowerCase() === "true";
     }
+    if (type === "boolean" && value !== null && (value.toLowerCase() === "1" || value.toLowerCase() === "0")) {
+        return value.toLowerCase() === "1";
+    }
+    if (type === "string[]" && options.arrayFormat !== "none" && typeof value === "string") {
+        return [
+            value
+        ];
+    }
+    if (type === "number[]" && options.arrayFormat !== "none" && !Number.isNaN(Number(value)) && typeof value === "string" && value.trim() !== "") {
+        return [
+            Number(value)
+        ];
+    }
     if (type === "number" && !Number.isNaN(Number(value)) && typeof value === "string" && value.trim() !== "") {
         return Number(value);
     }
+    if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+        return value.toLowerCase() === "true";
+    }
     if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === "string" && value.trim() !== "") {
         return Number(value);
     }
@@ -469,64 +501,56 @@ function parse(query, options) {
     if (!query) {
         return returnValue;
     }
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = query.split("&")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var parameter = _step.value;
-            if (parameter === "") {
-                continue;
-            }
-            var parameter_ = options.decode ? parameter.replaceAll("+", " ") : parameter;
-            var ref = _slicedToArray((0, _splitOnFirst.default)(parameter_, "="), 2), key = ref[0], value = ref[1];
-            if (key === undefined) {
-                key = parameter_;
-            }
-            // Missing `=` should be `null`:
-            // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
-            value = value === undefined ? null : [
-                "comma",
-                "separator",
-                "bracket-separator"
-            ].includes(options.arrayFormat) ? value : decode(value, options);
-            formatter(decode(key, options), value, returnValue);
+    // Avoid `split('&')` so separator-heavy inputs don't allocate large arrays of empty strings.
+    var parameterStart = 0;
+    for(var index = 0; index <= query.length; index++){
+        if (index < query.length && query[index] !== "&") {
+            continue;
         }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
+        if (index === parameterStart) {
+            parameterStart = index + 1;
+            continue;
         }
+        var parameter = query.slice(parameterStart, index);
+        parameterStart = index + 1;
+        var parameter_ = options.decode ? parameter.replaceAll("+", " ") : parameter;
+        var ref = _slicedToArray((0, _splitOnFirst.default)(parameter_, "="), 2), key = ref[0], value = ref[1];
+        if (key === undefined) {
+            key = parameter_;
+        }
+        // Missing `=` should be `null`:
+        // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+        value = value === undefined ? null : [
+            "comma",
+            "separator",
+            "bracket-separator"
+        ].includes(options.arrayFormat) ? value : decode(value, options);
+        formatter(decode(key, options), value, returnValue);
     }
-    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator1 = Object.entries(returnValue)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-            var _value = _slicedToArray(_step1.value, 2), key1 = _value[0], value1 = _value[1];
+        for(var _iterator = Object.entries(returnValue)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key1 = _value[0], value1 = _value[1];
             if (typeof value1 === "object" && value1 !== null && options.types[key1] !== "string") {
-                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                 try {
-                    for(var _iterator2 = Object.entries(value1)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                        var _value1 = _slicedToArray(_step2.value, 2), key2 = _value1[0], value2 = _value1[1];
-                        var type = options.types[key1] ? options.types[key1].replace("[]", "") : undefined;
+                    for(var _iterator1 = Object.entries(value1)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var _value1 = _slicedToArray(_step1.value, 2), key2 = _value1[0], value2 = _value1[1];
+                        var typeOption = options.types[key1];
+                        var type = typeof typeOption === "function" ? typeOption : typeOption ? typeOption.replace("[]", "") : undefined;
                         value1[key2] = parseValue(value2, options, type);
                     }
                 } catch (err) {
-                    _didIteratorError2 = true;
-                    _iteratorError2 = err;
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
                 } finally{
                     try {
-                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                            _iterator2.return();
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
                         }
                     } finally{
-                        if (_didIteratorError2) {
-                            throw _iteratorError2;
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
                         }
                     }
                 }
@@ -537,16 +561,16 @@ function parse(query, options) {
             }
         }
     } catch (err) {
-        _didIteratorError1 = true;
-        _iteratorError1 = err;
+        _didIteratorError = true;
+        _iteratorError = err;
     } finally{
         try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
             }
         } finally{
-            if (_didIteratorError1) {
-                throw _iteratorError1;
+            if (_didIteratorError) {
+                throw _iteratorError;
             }
         }
     }
@@ -605,6 +629,14 @@ function stringify(object, options) {
     }
     return keys.map(function(key) {
         var value = object[key];
+        // Apply replacer function if provided
+        if (options.replacer) {
+            value = options.replacer(key, value);
+            // If replacer returns undefined, skip this key
+            if (value === undefined) {
+                return "";
+            }
+        }
         if (value === undefined) {
             return "";
         }
@@ -615,7 +647,23 @@ function stringify(object, options) {
             if (value.length === 0 && options.arrayFormat === "bracket-separator") {
                 return encode(key, options) + "[]";
             }
-            return value.reduce(formatter(key), []).join("&");
+            // Apply replacer to array elements if provided
+            // Note: We don't re-apply replacer to the array itself, only to elements
+            var processedArray = value;
+            if (options.replacer) {
+                processedArray = value.map(function(item, index) {
+                    return options.replacer("".concat(key, "[").concat(index, "]"), item);
+                }).filter(function(item) {
+                    return item !== undefined;
+                });
+            }
+            var result = processedArray.reduce(formatter(key), []);
+            var arrayFormatSeparator = [
+                "comma",
+                "separator",
+                "bracket-separator"
+            ].includes(options.arrayFormat) ? options.arrayFormatSeparator : "&";
+            return result.join(arrayFormatSeparator);
         }
         return encode(key, options) + "=" + encode(value, options);
     }).filter(function(x) {
@@ -623,17 +671,15 @@ function stringify(object, options) {
     }).join("&");
 }
 function parseUrl(url, options) {
-    var ref;
     options = _objectSpread({
         decode: true
     }, options);
-    var ref1 = _slicedToArray((0, _splitOnFirst.default)(url, "#"), 2), url_ = ref1[0], hash = ref1[1];
+    var ref = _slicedToArray((0, _splitOnFirst.default)(url, "#"), 2), url_ = ref[0], hash = ref[1];
     if (url_ === undefined) {
         url_ = url;
     }
-    var ref2;
     return _objectSpread({
-        url: (ref2 = (ref = url_ === null || url_ === void 0 ? void 0 : url_.split("?")) === null || ref === void 0 ? void 0 : ref[0]) !== null && ref2 !== void 0 ? ref2 : "",
+        url: getUrlWithoutQuery(url_ !== null && url_ !== void 0 ? url_ : ""),
         query: parse(extract(url), options)
     }, options && options.parseFragmentIdentifier && hash ? {
         fragmentIdentifier: decode(hash, options)
@@ -644,16 +690,16 @@ function stringifyUrl(object, options) {
         encode: true,
         strict: true
     }, encodeFragmentIdentifier, true), options);
-    var url = removeHash(object.url).split("?")[0] || "";
+    var url = getUrlWithoutQuery(removeHash(object.url)) || "";
     var queryFromUrl = extract(object.url);
-    var query = _objectSpread({}, parse(queryFromUrl, {
+    var query = _objectSpread({}, parse(queryFromUrl, _objectSpread({
         sort: false
-    }), object.query);
+    }, options)), object.query);
     var queryString = stringify(query, options);
     queryString && (queryString = "?".concat(queryString));
     var hash = getHash(object.url);
     if (typeof object.fragmentIdentifier === "string") {
-        var urlObjectForFragmentEncode = new URL(url);
+        var urlObjectForFragmentEncode = new URL(url, "https://query-string.invalid");
         urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
         hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : "#".concat(object.fragmentIdentifier);
     }
@@ -671,10 +717,13 @@ function pick(input, filter, options) {
     }, options);
 }
 function exclude(input, filter, options) {
-    var exclusionFilter = Array.isArray(filter) ? function(key) {
-        return !filter.includes(key);
-    } : function(key, value) {
+    if (Array.isArray(filter)) {
+        var filterSet = new Set(filter);
+        return pick(input, function(key) {
+            return !filterSet.has(key);
+        }, options);
+    }
+    return pick(input, function(key, value) {
         return !filter(key, value);
-    };
-    return pick(input, exclusionFilter, options);
+    }, options);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@common.js/query-string",
-  "version": "9.1.0",
+  "version": "9.4.1",
   "description": "query-string package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
@@ -39,6 +39,6 @@
     }
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
-  "types": "./index.d.ts",
-  "main": "./index.js"
+  "main": "./index.js",
+  "types": "./index.d.ts"
 }