@common.js/query-string 8.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @common.js/query-string
+
+The [query-string](https://www.npmjs.com/package/query-string) package exported as CommonJS modules.
+
+Exported from [query-string@8.1.0](https://www.npmjs.com/package/query-string/v/8.1.0) using https://github.com/etienne-martin/common.js.

package/base.d.ts

@@ -0,0 +1,562 @@
+export type ParseOptions = {
+	/**
+	Decode the keys and values. URI components are decoded with [`decode-uri-component`](https://github.com/SamVerschueren/decode-uri-component).
+
+	@default true
+	*/
+	readonly decode?: boolean;
+
+	/**
+	@default 'none'
+
+	- `bracket`: Parse arrays with bracket representation:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo[]=1&foo[]=2&foo[]=3', {arrayFormat: 'bracket'});
+		//=> {foo: ['1', '2', '3']}
+		```
+
+	- `index`: Parse arrays with index representation:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo[0]=1&foo[1]=2&foo[3]=3', {arrayFormat: 'index'});
+		//=> {foo: ['1', '2', '3']}
+		```
+
+	- `comma`: Parse arrays with elements separated by comma:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo=1,2,3', {arrayFormat: 'comma'});
+		//=> {foo: ['1', '2', '3']}
+		```
+
+	- `separator`: Parse arrays with elements separated by a custom character:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo=1|2|3', {arrayFormat: 'separator', arrayFormatSeparator: '|'});
+		//=> {foo: ['1', '2', '3']}
+		```
+
+	- `bracket-separator`: Parse arrays (that are explicitly marked with brackets) with elements separated by a custom character:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo[]', {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> {foo: []}
+
+		queryString.parse('foo[]=', {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> {foo: ['']}
+
+		queryString.parse('foo[]=1', {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+	 	//=> {foo: ['1']}
+
+		queryString.parse('foo[]=1|2|3', {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> {foo: ['1', '2', '3']}
+
+		queryString.parse('foo[]=1||3|||6', {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> {foo: ['1', '', 3, '', '', '6']}
+
+		queryString.parse('foo[]=1|2|3&bar=fluffy&baz[]=4', {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> {foo: ['1', '2', '3'], bar: 'fluffy', baz:['4']}
+		```
+
+	- `colon-list-separator`: Parse arrays with parameter names that are explicitly marked with `:list`:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo:list=one&foo:list=two', {arrayFormat: 'colon-list-separator'});
+		//=> {foo: ['one', 'two']}
+		```
+
+	- `none`: Parse arrays with elements using duplicate keys:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.parse('foo=1&foo=2&foo=3');
+		//=> {foo: ['1', '2', '3']}
+		```
+	*/
+	readonly arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'bracket-separator' | 'colon-list-separator' | 'none';
+
+	/**
+	The character used to separate array elements when using `{arrayFormat: 'separator'}`.
+
+	@default ,
+	*/
+	readonly arrayFormatSeparator?: string;
+
+	/**
+	Supports both `Function` as a custom sorting function or `false` to disable sorting.
+
+	If omitted, keys are sorted using `Array#sort`, which means, converting them to strings and comparing strings in Unicode code point order.
+
+	@default true
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	const order = ['c', 'a', 'b'];
+
+	queryString.parse('?a=one&b=two&c=three', {
+		sort: (itemLeft, itemRight) => order.indexOf(itemLeft) - order.indexOf(itemRight)
+	});
+	//=> {c: 'three', a: 'one', b: 'two'}
+	```
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.parse('?a=one&c=three&b=two', {sort: false});
+	//=> {a: 'one', c: 'three', b: 'two'}
+	```
+	*/
+	readonly sort?: ((itemLeft: string, itemRight: string) => number) | false;
+
+	/**
+	Parse the value as a number type instead of string type if it's a number.
+
+	@default false
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.parse('foo=1', {parseNumbers: true});
+	//=> {foo: 1}
+	```
+	*/
+	readonly parseNumbers?: boolean;
+
+	/**
+	Parse the value as a boolean type instead of string type if it's a boolean.
+
+	@default false
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.parse('foo=true', {parseBooleans: true});
+	//=> {foo: true}
+	```
+	*/
+	readonly parseBooleans?: boolean;
+
+	/**
+	Parse the fragment identifier from the URL and add it to result object.
+
+	@default false
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.parseUrl('https://foo.bar?foo=bar#xyz', {parseFragmentIdentifier: true});
+	//=> {url: 'https://foo.bar', query: {foo: 'bar'}, fragmentIdentifier: 'xyz'}
+	```
+	*/
+	readonly parseFragmentIdentifier?: boolean;
+};
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type ParsedQuery<T = string> = Record<string, T | null | Array<T | null>>;
+
+/**
+Parse a query string into an object. Leading `?` or `#` are ignored, so you can pass `location.search` or `location.hash` directly.
+
+The returned object is created with [`Object.create(null)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create) and thus does not have a `prototype`.
+
+@param query - The query string to parse.
+*/
+export function parse(query: string, options: {parseBooleans: true; parseNumbers: true} & ParseOptions): ParsedQuery<string | boolean | number>;
+export function parse(query: string, options: {parseBooleans: true} & ParseOptions): ParsedQuery<string | boolean>;
+export function parse(query: string, options: {parseNumbers: true} & ParseOptions): ParsedQuery<string | number>;
+export function parse(query: string, options?: ParseOptions): ParsedQuery;
+
+export type ParsedUrl = {
+	readonly url: string;
+	readonly query: ParsedQuery;
+
+	/**
+	The fragment identifier of the URL.
+
+	Present when the `parseFragmentIdentifier` option is `true`.
+	*/
+	readonly fragmentIdentifier?: string;
+};
+
+/**
+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.
+
+@example
+```
+import queryString from 'query-string';
+
+queryString.parseUrl('https://foo.bar?foo=bar');
+//=> {url: 'https://foo.bar', query: {foo: 'bar'}}
+
+queryString.parseUrl('https://foo.bar?foo=bar#xyz', {parseFragmentIdentifier: true});
+//=> {url: 'https://foo.bar', query: {foo: 'bar'}, fragmentIdentifier: 'xyz'}
+```
+*/
+export function parseUrl(url: string, options?: ParseOptions): ParsedUrl;
+
+export type StringifyOptions = {
+	/**
+	Strictly encode URI components with [`strict-uri-encode`](https://github.com/kevva/strict-uri-encode). It uses [`encodeURIComponent`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent) if set to `false`. You probably [don't care](https://github.com/sindresorhus/query-string/issues/42) about this option.
+
+	@default true
+	*/
+	readonly strict?: boolean;
+
+	/**
+	[URL encode](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent) the keys and values.
+
+	@default true
+	*/
+	readonly encode?: boolean;
+
+	/**
+	@default 'none'
+
+	- `bracket`: Serialize arrays using bracket representation:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: [1, 2, 3]}, {arrayFormat: 'bracket'});
+		//=> 'foo[]=1&foo[]=2&foo[]=3'
+		```
+
+	- `index`: Serialize arrays using index representation:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: [1, 2, 3]}, {arrayFormat: 'index'});
+		//=> 'foo[0]=1&foo[1]=2&foo[2]=3'
+		```
+
+	- `comma`: Serialize arrays by separating elements with comma:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: [1, 2, 3]}, {arrayFormat: 'comma'});
+		//=> 'foo=1,2,3'
+
+		queryString.stringify({foo: [1, null, '']}, {arrayFormat: 'comma'});
+		//=> 'foo=1,,'
+		// Note that typing information for null values is lost
+		// and `.parse('foo=1,,')` would return `{foo: [1, '', '']}`.
+		```
+
+	- `separator`: Serialize arrays by separating elements with character:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: [1, 2, 3]}, {arrayFormat: 'separator', arrayFormatSeparator: '|'});
+		//=> 'foo=1|2|3'
+		```
+
+	- `bracket-separator`: Serialize arrays by explicitly post-fixing array names with brackets and separating elements with a custom character:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: []}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> 'foo[]'
+
+		queryString.stringify({foo: ['']}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> 'foo[]='
+
+		queryString.stringify({foo: [1]}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> 'foo[]=1'
+
+		queryString.stringify({foo: [1, 2, 3]}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> 'foo[]=1|2|3'
+
+		queryString.stringify({foo: [1, '', 3, null, null, 6]}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> 'foo[]=1||3|||6'
+
+		queryString.stringify({foo: [1, '', 3, null, null, 6]}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|', skipNull: true});
+		//=> 'foo[]=1||3|6'
+
+		queryString.stringify({foo: [1, 2, 3], bar: 'fluffy', baz: [4]}, {arrayFormat: 'bracket-separator', arrayFormatSeparator: '|'});
+		//=> 'foo[]=1|2|3&bar=fluffy&baz[]=4'
+		```
+
+	- `colon-list-separator`: Serialize arrays with parameter names that are explicitly marked with `:list`:
+
+		```js
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: ['one', 'two']}, {arrayFormat: 'colon-list-separator'});
+		//=> 'foo:list=one&foo:list=two'
+		```
+
+	- `none`: Serialize arrays by using duplicate keys:
+
+		```
+		import queryString from 'query-string';
+
+		queryString.stringify({foo: [1, 2, 3]});
+		//=> 'foo=1&foo=2&foo=3'
+		```
+	*/
+	readonly arrayFormat?: 'bracket' | 'index' | 'comma' | 'separator' | 'bracket-separator' | 'colon-list-separator' | 'none';
+
+	/**
+	The character used to separate array elements when using `{arrayFormat: 'separator'}`.
+
+	@default ,
+	*/
+	readonly arrayFormatSeparator?: string;
+
+	/**
+	Supports both `Function` as a custom sorting function or `false` to disable sorting.
+
+	If omitted, keys are sorted using `Array#sort`, which means, converting them to strings and comparing strings in Unicode code point order.
+
+	@default true
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	const order = ['c', 'a', 'b'];
+
+	queryString.stringify({a: 1, b: 2, c: 3}, {
+		sort: (itemLeft, itemRight) => order.indexOf(itemLeft) - order.indexOf(itemRight)
+	});
+	//=> 'c=3&a=1&b=2'
+	```
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.stringify({b: 1, c: 2, a: 3}, {sort: false});
+	//=> 'b=1&c=2&a=3'
+	```
+	*/
+	readonly sort?: ((itemLeft: string, itemRight: string) => number) | false;
+
+	/**
+	Skip keys with `null` as the value.
+
+	Note that keys with `undefined` as the value are always skipped.
+
+	@default false
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.stringify({a: 1, b: undefined, c: null, d: 4}, {
+		skipNull: true
+	});
+	//=> 'a=1&d=4'
+
+	queryString.stringify({a: undefined, b: null}, {
+		skipNull: true
+	});
+	//=> ''
+	```
+	*/
+	readonly skipNull?: boolean;
+
+	/**
+	Skip keys with an empty string as the value.
+
+	@default false
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.stringify({a: 1, b: '', c: '', d: 4}, {
+		skipEmptyString: true
+	});
+	//=> 'a=1&d=4'
+	```
+
+	@example
+	```
+	import queryString from 'query-string';
+
+	queryString.stringify({a: '', b: ''}, {
+		skipEmptyString: true
+	});
+	//=> ''
+	```
+	*/
+	readonly skipEmptyString?: boolean;
+};
+
+export type Stringifiable = string | boolean | number | null | undefined; // eslint-disable-line @typescript-eslint/ban-types
+
+export type StringifiableRecord = Record<
+string,
+Stringifiable | readonly Stringifiable[]
+>;
+
+/**
+Stringify an object into a query string and sort the keys.
+*/
+export function stringify(
+	// TODO: Use the below instead when the following TS issues are fixed:
+	// - https://github.com/microsoft/TypeScript/issues/15300
+	// - https://github.com/microsoft/TypeScript/issues/42021
+	// Context: https://github.com/sindresorhus/query-string/issues/298
+	// object: StringifiableRecord,
+	object: Record<string, any>,
+	options?: StringifyOptions
+): string;
+
+/**
+Extract a query string from a URL that can be passed into `.parse()`.
+
+Note: This behaviour can be changed with the `skipNull` option.
+*/
+export function extract(url: string): string;
+
+export type UrlObject = {
+	readonly url: string;
+
+	/**
+	Overrides queries in the `url` property.
+	*/
+	readonly query?: StringifiableRecord;
+
+	/**
+	Overrides the fragment identifier in the `url` property.
+	*/
+	readonly fragmentIdentifier?: string;
+};
+
+/**
+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)
+
+Query items in the `query` property overrides queries in the `url` property.
+
+The `fragmentIdentifier` property overrides the fragment identifier in the `url` property.
+
+@example
+```
+queryString.stringifyUrl({url: 'https://foo.bar', query: {foo: 'bar'}});
+//=> 'https://foo.bar?foo=bar'
+
+queryString.stringifyUrl({url: 'https://foo.bar?foo=baz', query: {foo: 'bar'}});
+//=> 'https://foo.bar?foo=bar'
+
+queryString.stringifyUrl({
+	url: 'https://foo.bar',
+	query: {
+		top: 'foo'
+	},
+	fragmentIdentifier: 'bar'
+});
+//=> 'https://foo.bar?top=foo#bar'
+```
+*/
+export function stringifyUrl(
+	object: UrlObject,
+	options?: StringifyOptions
+): string;
+
+/**
+Pick query parameters from a URL.
+
+@param url - The URL containing the query parameters to pick.
+@param keys - The names of the query parameters to keep. All other query parameters will be removed from the URL.
+@param filter - A filter predicate that will be provided the name of each query parameter and its value. The `parseNumbers` and `parseBooleans` options also affect `value`.
+
+@returns The URL with the picked query parameters.
+
+@example
+```
+queryString.pick('https://foo.bar?foo=1&bar=2#hello', ['foo']);
+//=> 'https://foo.bar?foo=1#hello'
+
+queryString.pick('https://foo.bar?foo=1&bar=2#hello', (name, value) => value === 2, {parseNumbers: true});
+//=> 'https://foo.bar?bar=2#hello'
+```
+*/
+export function pick(
+	url: string,
+	keys: readonly string[],
+	options?: ParseOptions & StringifyOptions
+): string;
+export function pick(
+	url: string,
+	filter: (key: string, value: string | boolean | number) => boolean,
+	options?: {parseBooleans: true; parseNumbers: true} & ParseOptions & StringifyOptions
+): string;
+export function pick(
+	url: string,
+	filter: (key: string, value: string | boolean) => boolean,
+	options?: {parseBooleans: true} & ParseOptions & StringifyOptions
+): string;
+export function pick(
+	url: string,
+	filter: (key: string, value: string | number) => boolean,
+	options?: {parseNumbers: true} & ParseOptions & StringifyOptions
+): string;
+
+/**
+Exclude query parameters from a URL. Like `.pick()` but reversed.
+
+@param url - The URL containing the query parameters to exclude.
+@param keys - The names of the query parameters to remove. All other query parameters will remain in the URL.
+@param filter - A filter predicate that will be provided the name of each query parameter and its value. The `parseNumbers` and `parseBooleans` options also affect `value`.
+
+@returns The URL without the excluded the query parameters.
+
+@example
+```
+queryString.exclude('https://foo.bar?foo=1&bar=2#hello', ['foo']);
+//=> 'https://foo.bar?bar=2#hello'
+
+queryString.exclude('https://foo.bar?foo=1&bar=2#hello', (name, value) => value === 2, {parseNumbers: true});
+//=> 'https://foo.bar?foo=1#hello'
+```
+*/
+export function exclude(
+	url: string,
+	keys: readonly string[],
+	options?: ParseOptions & StringifyOptions
+): string;
+export function exclude(
+	url: string,
+	filter: (key: string, value: string | boolean | number) => boolean,
+	options?: {parseBooleans: true; parseNumbers: true} & ParseOptions & StringifyOptions
+): string;
+export function exclude(
+	url: string,
+	filter: (key: string, value: string | boolean) => boolean,
+	options?: {parseBooleans: true} & ParseOptions & StringifyOptions
+): string;
+export function exclude(
+	url: string,
+	filter: (key: string, value: string | number) => boolean,
+	options?: {parseNumbers: true} & ParseOptions & StringifyOptions
+): string;

package/base.js

@@ -0,0 +1,673 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    extract: function() {
+        return extract;
+    },
+    parse: function() {
+        return parse;
+    },
+    stringify: function() {
+        return stringify;
+    },
+    parseUrl: function() {
+        return parseUrl;
+    },
+    stringifyUrl: function() {
+        return stringifyUrl;
+    },
+    pick: function() {
+        return pick;
+    },
+    exclude: function() {
+        return exclude;
+    }
+});
+var _decodeUriComponent = /*#__PURE__*/ _interopRequireDefault(require("decode-uri-component"));
+var _splitOnFirst = /*#__PURE__*/ _interopRequireDefault(require("split-on-first"));
+var _filterObj = require("filter-obj");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+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, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? 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;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return 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);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var isNullOrUndefined = function(value) {
+    return value === null || value === undefined;
+};
+// eslint-disable-next-line unicorn/prefer-code-point
+var strictUriEncode = function(string) {
+    return encodeURIComponent(string).replace(/[!'()*]/g, function(x) {
+        return "%".concat(x.charCodeAt(0).toString(16).toUpperCase());
+    });
+};
+var encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
+function encoderForArrayFormat(options) {
+    switch(options.arrayFormat){
+        case "index":
+            {
+                return function(key) {
+                    return function(result, value) {
+                        var index = result.length;
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === "") {
+                            return result;
+                        }
+                        if (value === null) {
+                            return _toConsumableArray(result).concat([
+                                [
+                                    encode(key, options),
+                                    "[",
+                                    index,
+                                    "]"
+                                ].join(""), 
+                            ]);
+                        }
+                        return _toConsumableArray(result).concat([
+                            [
+                                encode(key, options),
+                                "[",
+                                encode(index, options),
+                                "]=",
+                                encode(value, options)
+                            ].join(""), 
+                        ]);
+                    };
+                };
+            }
+        case "bracket":
+            {
+                return function(key) {
+                    return function(result, value) {
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === "") {
+                            return result;
+                        }
+                        if (value === null) {
+                            return _toConsumableArray(result).concat([
+                                [
+                                    encode(key, options),
+                                    "[]"
+                                ].join(""), 
+                            ]);
+                        }
+                        return _toConsumableArray(result).concat([
+                            [
+                                encode(key, options),
+                                "[]=",
+                                encode(value, options)
+                            ].join(""), 
+                        ]);
+                    };
+                };
+            }
+        case "colon-list-separator":
+            {
+                return function(key) {
+                    return function(result, value) {
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === "") {
+                            return result;
+                        }
+                        if (value === null) {
+                            return _toConsumableArray(result).concat([
+                                [
+                                    encode(key, options),
+                                    ":list="
+                                ].join(""), 
+                            ]);
+                        }
+                        return _toConsumableArray(result).concat([
+                            [
+                                encode(key, options),
+                                ":list=",
+                                encode(value, options)
+                            ].join(""), 
+                        ]);
+                    };
+                };
+            }
+        case "comma":
+        case "separator":
+        case "bracket-separator":
+            {
+                var keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
+                return function(key) {
+                    return function(result, value) {
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === "") {
+                            return result;
+                        }
+                        // 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),
+                                    keyValueSep,
+                                    encode(value, options)
+                                ].join("")
+                            ];
+                        }
+                        return [
+                            [
+                                result,
+                                encode(value, options)
+                            ].join(options.arrayFormatSeparator)
+                        ];
+                    };
+                };
+            }
+        default:
+            {
+                return function(key) {
+                    return function(result, value) {
+                        if (value === undefined || options.skipNull && value === null || options.skipEmptyString && value === "") {
+                            return result;
+                        }
+                        if (value === null) {
+                            return _toConsumableArray(result).concat([
+                                encode(key, options), 
+                            ]);
+                        }
+                        return _toConsumableArray(result).concat([
+                            [
+                                encode(key, options),
+                                "=",
+                                encode(value, options)
+                            ].join(""), 
+                        ]);
+                    };
+                };
+            }
+    }
+}
+function parserForArrayFormat(options) {
+    var result;
+    switch(options.arrayFormat){
+        case "index":
+            {
+                return function(key, value, accumulator) {
+                    result = /\[(\d*)]$/.exec(key);
+                    key = key.replace(/\[\d*]$/, "");
+                    if (!result) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = {};
+                    }
+                    accumulator[key][result[1]] = value;
+                };
+            }
+        case "bracket":
+            {
+                return function(key, value, accumulator) {
+                    result = /(\[])$/.exec(key);
+                    key = key.replace(/\[]$/, "");
+                    if (!result) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = [
+                            value
+                        ];
+                        return;
+                    }
+                    accumulator[key] = _toConsumableArray(accumulator[key]).concat([
+                        value
+                    ]);
+                };
+            }
+        case "colon-list-separator":
+            {
+                return function(key, value, accumulator) {
+                    result = /(:list)$/.exec(key);
+                    key = key.replace(/:list$/, "");
+                    if (!result) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = [
+                            value
+                        ];
+                        return;
+                    }
+                    accumulator[key] = _toConsumableArray(accumulator[key]).concat([
+                        value
+                    ]);
+                };
+            }
+        case "comma":
+        case "separator":
+            {
+                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) {
+                        return decode(item, options);
+                    }) : value === null ? value : decode(value, options);
+                    accumulator[key] = newValue;
+                };
+            }
+        case "bracket-separator":
+            {
+                return function(key, value, accumulator) {
+                    var isArray = /(\[])$/.test(key);
+                    key = key.replace(/\[]$/, "");
+                    if (!isArray) {
+                        accumulator[key] = value ? decode(value, options) : value;
+                        return;
+                    }
+                    var arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map(function(item) {
+                        return decode(item, options);
+                    });
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = arrayValue;
+                        return;
+                    }
+                    accumulator[key] = _toConsumableArray(accumulator[key]).concat(_toConsumableArray(arrayValue));
+                };
+            }
+        default:
+            {
+                return function(key, value, accumulator) {
+                    if (accumulator[key] === undefined) {
+                        accumulator[key] = value;
+                        return;
+                    }
+                    accumulator[key] = _toConsumableArray([
+                        accumulator[key]
+                    ].flat()).concat([
+                        value
+                    ]);
+                };
+            }
+    }
+}
+function validateArrayFormatSeparator(value) {
+    if (typeof value !== "string" || value.length !== 1) {
+        throw new TypeError("arrayFormatSeparator must be single character string");
+    }
+}
+function encode(value, options) {
+    if (options.encode) {
+        return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+    }
+    return value;
+}
+function decode(value, options) {
+    if (options.decode) {
+        return (0, _decodeUriComponent.default)(value);
+    }
+    return value;
+}
+function keysSorter(input) {
+    if (Array.isArray(input)) {
+        return input.sort();
+    }
+    if (typeof input === "object") {
+        return keysSorter(Object.keys(input)).sort(function(a, b) {
+            return Number(a) - Number(b);
+        }).map(function(key) {
+            return input[key];
+        });
+    }
+    return input;
+}
+function removeHash(input) {
+    var hashStart = input.indexOf("#");
+    if (hashStart !== -1) {
+        input = input.slice(0, hashStart);
+    }
+    return input;
+}
+function getHash(url) {
+    var hash = "";
+    var hashStart = url.indexOf("#");
+    if (hashStart !== -1) {
+        hash = url.slice(hashStart);
+    }
+    return hash;
+}
+function parseValue(value, options) {
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === "string" && value.trim() !== "") {
+        value = Number(value);
+    } else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+        value = value.toLowerCase() === "true";
+    }
+    return value;
+}
+function extract(input) {
+    input = removeHash(input);
+    var queryStart = input.indexOf("?");
+    if (queryStart === -1) {
+        return "";
+    }
+    return input.slice(queryStart + 1);
+}
+function parse(query, options) {
+    options = _objectSpread({
+        decode: true,
+        sort: true,
+        arrayFormat: "none",
+        arrayFormatSeparator: ",",
+        parseNumbers: false,
+        parseBooleans: false
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    var formatter = parserForArrayFormat(options);
+    // Create an object with no prototype
+    var returnValue = Object.create(null);
+    if (typeof query !== "string") {
+        return returnValue;
+    }
+    query = query.trim().replace(/^[?#&]/, "");
+    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.replace(/\+/g, " ") : 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);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = 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];
+            if (typeof value1 === "object" && value1 !== null) {
+                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = 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];
+                        value1[key2] = parseValue(value2, options);
+                    }
+                } catch (err) {
+                    _didIteratorError2 = true;
+                    _iteratorError2 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                            _iterator2.return();
+                        }
+                    } finally{
+                        if (_didIteratorError2) {
+                            throw _iteratorError2;
+                        }
+                    }
+                }
+            } else {
+                returnValue[key1] = parseValue(value1, options);
+            }
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+    if (options.sort === false) {
+        return returnValue;
+    }
+    // TODO: Remove the use of `reduce`.
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return (options.sort === true ? Object.keys(returnValue).sort() : Object.keys(returnValue).sort(options.sort)).reduce(function(result, key) {
+        var value = returnValue[key];
+        if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
+            // Sort object keys, not values
+            result[key] = keysSorter(value);
+        } else {
+            result[key] = value;
+        }
+        return result;
+    }, Object.create(null));
+}
+function stringify(object, options) {
+    if (!object) {
+        return "";
+    }
+    options = _objectSpread({
+        encode: true,
+        strict: true,
+        arrayFormat: "none",
+        arrayFormatSeparator: ","
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    var shouldFilter = function(key) {
+        return options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
+    };
+    var formatter = encoderForArrayFormat(options);
+    var objectCopy = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(object)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+            if (!shouldFilter(key)) {
+                objectCopy[key] = value;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var keys = Object.keys(objectCopy);
+    if (options.sort !== false) {
+        keys.sort(options.sort);
+    }
+    return keys.map(function(key) {
+        var value = object[key];
+        if (value === undefined) {
+            return "";
+        }
+        if (value === null) {
+            return encode(key, options);
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0 && options.arrayFormat === "bracket-separator") {
+                return encode(key, options) + "[]";
+            }
+            return value.reduce(formatter(key), []).join("&");
+        }
+        return encode(key, options) + "=" + encode(value, options);
+    }).filter(function(x) {
+        return x.length > 0;
+    }).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];
+    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 : "",
+        query: parse(extract(url), options)
+    }, options && options.parseFragmentIdentifier && hash ? {
+        fragmentIdentifier: decode(hash, options)
+    } : {});
+}
+function stringifyUrl(object, options) {
+    options = _objectSpread(_defineProperty({
+        encode: true,
+        strict: true
+    }, encodeFragmentIdentifier, true), options);
+    var url = removeHash(object.url).split("?")[0] || "";
+    var queryFromUrl = extract(object.url);
+    var query = _objectSpread({}, parse(queryFromUrl, {
+        sort: false
+    }), object.query);
+    var queryString = stringify(query, options);
+    if (queryString) {
+        queryString = "?".concat(queryString);
+    }
+    var hash = getHash(object.url);
+    if (object.fragmentIdentifier) {
+        var urlObjectForFragmentEncode = new URL(url);
+        urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
+        hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : "#".concat(object.fragmentIdentifier);
+    }
+    return "".concat(url).concat(queryString).concat(hash);
+}
+function pick(input, filter, options) {
+    options = _objectSpread(_defineProperty({
+        parseFragmentIdentifier: true
+    }, encodeFragmentIdentifier, false), options);
+    var ref = parseUrl(input, options), url = ref.url, query = ref.query, fragmentIdentifier = ref.fragmentIdentifier;
+    return stringifyUrl({
+        url: url,
+        query: (0, _filterObj.includeKeys)(query, filter),
+        fragmentIdentifier: fragmentIdentifier
+    }, options);
+}
+function exclude(input, filter, options) {
+    var exclusionFilter = Array.isArray(filter) ? function(key) {
+        return !filter.includes(key);
+    } : function(key, value) {
+        return !filter(key, value);
+    };
+    return pick(input, exclusionFilter, options);
+}

package/index.d.ts

@@ -0,0 +1,16 @@
+/// export * as default from './base.js';
+
+// Workaround for TS missing feature.
+import * as queryString from './base.js';
+
+export default queryString;
+
+export {
+	type ParseOptions,
+	type ParsedQuery,
+	type ParsedUrl,
+	type StringifyOptions,
+	type Stringifiable,
+	type StringifiableRecord,
+	type UrlObject,
+} from './base.js';

package/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _baseJs = /*#__PURE__*/ _interopRequireWildcard(require("./base.js"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _default = _baseJs;

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@common.js/query-string",
+  "version": "8.1.0",
+  "description": "query-string package exported as CommonJS modules",
+  "license": "MIT",
+  "repository": "etienne-martin/common.js",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=14.16"
+  },
+  "scripts": {
+    "benchmark": "node benchmark.js",
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "base.js",
+    "base.d.ts"
+  ],
+  "dependencies": {
+    "@common.js/decode-uri-component": "^0.4.1",
+    "@common.js/filter-obj": "^5.1.0",
+    "@common.js/split-on-first": "^3.0.0"
+  },
+  "devDependencies": {
+    "ava": "^5.1.0",
+    "benchmark": "^2.1.4",
+    "deep-equal": "^2.1.0",
+    "fast-check": "^3.4.0",
+    "tsd": "^0.25.0",
+    "xo": "^0.53.1"
+  },
+  "tsd": {
+    "compilerOptions": {
+      "module": "node16"
+    }
+  },
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "types": "./index.d.ts",
+  "main": "./index.js"
+}