Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/core-js/modules/web.url-search-params.constructor.js
f646e1f695a7paginated-inlines

web.url-search-params.constructor.js
View Options

			'use strict';
			// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
			require('../modules/es.array.iterator');
			var $ = require('../internals/export');
			var global = require('../internals/global');
			var call = require('../internals/function-call');
			var uncurryThis = require('../internals/function-uncurry-this');
			var DESCRIPTORS = require('../internals/descriptors');
			var USE_NATIVE_URL = require('../internals/url-constructor-detection');
			var defineBuiltIn = require('../internals/define-built-in');
			var defineBuiltIns = require('../internals/define-built-ins');
			var setToStringTag = require('../internals/set-to-string-tag');
			var createIteratorConstructor = require('../internals/iterator-create-constructor');
			var InternalStateModule = require('../internals/internal-state');
			var anInstance = require('../internals/an-instance');
			var isCallable = require('../internals/is-callable');
			var hasOwn = require('../internals/has-own-property');
			var bind = require('../internals/function-bind-context');
			var classof = require('../internals/classof');
			var anObject = require('../internals/an-object');
			var isObject = require('../internals/is-object');
			var $toString = require('../internals/to-string');
			var create = require('../internals/object-create');
			var createPropertyDescriptor = require('../internals/create-property-descriptor');
			var getIterator = require('../internals/get-iterator');
			var getIteratorMethod = require('../internals/get-iterator-method');
			var validateArgumentsLength = require('../internals/validate-arguments-length');
			var wellKnownSymbol = require('../internals/well-known-symbol');
			var arraySort = require('../internals/array-sort');

			var ITERATOR = wellKnownSymbol('iterator');
			var URL_SEARCH_PARAMS = 'URLSearchParams';
			var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
			var setInternalState = InternalStateModule.set;
			var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
			var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
			// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
			var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;

			// Avoid NodeJS experimental warning
			var safeGetBuiltIn = function (name) {
			if (!DESCRIPTORS) return global[name];
			var descriptor = getOwnPropertyDescriptor(global, name);
			return descriptor && descriptor.value;
			};

			var nativeFetch = safeGetBuiltIn('fetch');
			var NativeRequest = safeGetBuiltIn('Request');
			var Headers = safeGetBuiltIn('Headers');
			var RequestPrototype = NativeRequest && NativeRequest.prototype;
			var HeadersPrototype = Headers && Headers.prototype;
			var RegExp = global.RegExp;
			var TypeError = global.TypeError;
			var decodeURIComponent = global.decodeURIComponent;
			var encodeURIComponent = global.encodeURIComponent;
			var charAt = uncurryThis(''.charAt);
			var join = uncurryThis([].join);
			var push = uncurryThis([].push);
			var replace = uncurryThis(''.replace);
			var shift = uncurryThis([].shift);
			var splice = uncurryThis([].splice);
			var split = uncurryThis(''.split);
			var stringSlice = uncurryThis(''.slice);

			var plus = /\+/g;
			var sequences = Array(4);

			var percentSequence = function (bytes) {
			return sequences[bytes - 1] \|\| (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
			};

			var percentDecode = function (sequence) {
			try {
			return decodeURIComponent(sequence);
			} catch (error) {
			return sequence;
			}
			};

			var deserialize = function (it) {
			var result = replace(it, plus, ' ');
			var bytes = 4;
			try {
			return decodeURIComponent(result);
			} catch (error) {
			while (bytes) {
			result = replace(result, percentSequence(bytes--), percentDecode);
			}
			return result;
			}
			};

			var find = /[!'()~]\|%20/g;

			var replacements = {
			'!': '%21',
			"'": '%27',
			'(': '%28',
			')': '%29',
			'~': '%7E',
			'%20': '+'
			};

			var replacer = function (match) {
			return replacements[match];
			};

			var serialize = function (it) {
			return replace(encodeURIComponent(it), find, replacer);
			};

			var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
			setInternalState(this, {
			type: URL_SEARCH_PARAMS_ITERATOR,
			iterator: getIterator(getInternalParamsState(params).entries),
			kind: kind
			});
			}, 'Iterator', function next() {
			var state = getInternalIteratorState(this);
			var kind = state.kind;
			var step = state.iterator.next();
			var entry = step.value;
			if (!step.done) {
			step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
			} return step;
			}, true);

			var URLSearchParamsState = function (init) {
			this.entries = [];
			this.url = null;

			if (init !== undefined) {
			if (isObject(init)) this.parseObject(init);
			else this.parseQuery(typeof init == 'string' ? charAt(init, 0) === '?' ? stringSlice(init, 1) : init : $toString(init));
			}
			};

			URLSearchParamsState.prototype = {
			type: URL_SEARCH_PARAMS,
			bindURL: function (url) {
			this.url = url;
			this.update();
			},
			parseObject: function (object) {
			var iteratorMethod = getIteratorMethod(object);
			var iterator, next, step, entryIterator, entryNext, first, second;

			if (iteratorMethod) {
			iterator = getIterator(object, iteratorMethod);
			next = iterator.next;
			while (!(step = call(next, iterator)).done) {
			entryIterator = getIterator(anObject(step.value));
			entryNext = entryIterator.next;
			if (
			(first = call(entryNext, entryIterator)).done \|\|
			(second = call(entryNext, entryIterator)).done \|\|
			!call(entryNext, entryIterator).done
			) throw TypeError('Expected sequence with length 2');
			push(this.entries, { key: $toString(first.value), value: $toString(second.value) });
			}
			} else for (var key in object) if (hasOwn(object, key)) {
			push(this.entries, { key: key, value: $toString(object[key]) });
			}
			},
			parseQuery: function (query) {
			if (query) {
			var attributes = split(query, '&');
			var index = 0;
			var attribute, entry;
			while (index < attributes.length) {
			attribute = attributes[index++];
			if (attribute.length) {
			entry = split(attribute, '=');
			push(this.entries, {
			key: deserialize(shift(entry)),
			value: deserialize(join(entry, '='))
			});
			}
			}
			}
			},
			serialize: function () {
			var entries = this.entries;
			var result = [];
			var index = 0;
			var entry;
			while (index < entries.length) {
			entry = entries[index++];
			push(result, serialize(entry.key) + '=' + serialize(entry.value));
			} return join(result, '&');
			},
			update: function () {
			this.entries.length = 0;
			this.parseQuery(this.url.query);
			},
			updateURL: function () {
			if (this.url) this.url.update();
			}
			};

			// `URLSearchParams` constructor
			// https://url.spec.whatwg.org/#interface-urlsearchparams
			var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
			anInstance(this, URLSearchParamsPrototype);
			var init = arguments.length > 0 ? arguments[0] : undefined;
			setInternalState(this, new URLSearchParamsState(init));
			};

			var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;

			defineBuiltIns(URLSearchParamsPrototype, {
			// `URLSearchParams.prototype.append` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-append
			append: function append(name, value) {
			validateArgumentsLength(arguments.length, 2);
			var state = getInternalParamsState(this);
			push(state.entries, { key: $toString(name), value: $toString(value) });
			state.updateURL();
			},
			// `URLSearchParams.prototype.delete` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
			'delete': function (name) {
			validateArgumentsLength(arguments.length, 1);
			var state = getInternalParamsState(this);
			var entries = state.entries;
			var key = $toString(name);
			var index = 0;
			while (index < entries.length) {
			if (entries[index].key === key) splice(entries, index, 1);
			else index++;
			}
			state.updateURL();
			},
			// `URLSearchParams.prototype.get` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-get
			get: function get(name) {
			validateArgumentsLength(arguments.length, 1);
			var entries = getInternalParamsState(this).entries;
			var key = $toString(name);
			var index = 0;
			for (; index < entries.length; index++) {
			if (entries[index].key === key) return entries[index].value;
			}
			return null;
			},
			// `URLSearchParams.prototype.getAll` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
			getAll: function getAll(name) {
			validateArgumentsLength(arguments.length, 1);
			var entries = getInternalParamsState(this).entries;
			var key = $toString(name);
			var result = [];
			var index = 0;
			for (; index < entries.length; index++) {
			if (entries[index].key === key) push(result, entries[index].value);
			}
			return result;
			},
			// `URLSearchParams.prototype.has` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-has
			has: function has(name) {
			validateArgumentsLength(arguments.length, 1);
			var entries = getInternalParamsState(this).entries;
			var key = $toString(name);
			var index = 0;
			while (index < entries.length) {
			if (entries[index++].key === key) return true;
			}
			return false;
			},
			// `URLSearchParams.prototype.set` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-set
			set: function set(name, value) {
			validateArgumentsLength(arguments.length, 1);
			var state = getInternalParamsState(this);
			var entries = state.entries;
			var found = false;
			var key = $toString(name);
			var val = $toString(value);
			var index = 0;
			var entry;
			for (; index < entries.length; index++) {
			entry = entries[index];
			if (entry.key === key) {
			if (found) splice(entries, index--, 1);
			else {
			found = true;
			entry.value = val;
			}
			}
			}
			if (!found) push(entries, { key: key, value: val });
			state.updateURL();
			},
			// `URLSearchParams.prototype.sort` method
			// https://url.spec.whatwg.org/#dom-urlsearchparams-sort
			sort: function sort() {
			var state = getInternalParamsState(this);
			arraySort(state.entries, function (a, b) {
			return a.key > b.key ? 1 : -1;
			});
			state.updateURL();
			},
			// `URLSearchParams.prototype.forEach` method
			forEach: function forEach(callback /* , thisArg */) {
			var entries = getInternalParamsState(this).entries;
			var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined);
			var index = 0;
			var entry;
			while (index < entries.length) {
			entry = entries[index++];
			boundFunction(entry.value, entry.key, this);
			}
			},
			// `URLSearchParams.prototype.keys` method
			keys: function keys() {
			return new URLSearchParamsIterator(this, 'keys');
			},
			// `URLSearchParams.prototype.values` method
			values: function values() {
			return new URLSearchParamsIterator(this, 'values');
			},
			// `URLSearchParams.prototype.entries` method
			entries: function entries() {
			return new URLSearchParamsIterator(this, 'entries');
			}
			}, { enumerable: true });

			// `URLSearchParams.prototype[@@iterator]` method
			defineBuiltIn(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries, { name: 'entries' });

			// `URLSearchParams.prototype.toString` method
			// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
			defineBuiltIn(URLSearchParamsPrototype, 'toString', function toString() {
			return getInternalParamsState(this).serialize();
			}, { enumerable: true });

			setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);

			$({ global: true, constructor: true, forced: !USE_NATIVE_URL }, {
			URLSearchParams: URLSearchParamsConstructor
			});

			// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
			if (!USE_NATIVE_URL && isCallable(Headers)) {
			var headersHas = uncurryThis(HeadersPrototype.has);
			var headersSet = uncurryThis(HeadersPrototype.set);

			var wrapRequestOptions = function (init) {
			if (isObject(init)) {
			var body = init.body;
			var headers;
			if (classof(body) === URL_SEARCH_PARAMS) {
			headers = init.headers ? new Headers(init.headers) : new Headers();
			if (!headersHas(headers, 'content-type')) {
			headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
			}
			return create(init, {
			body: createPropertyDescriptor(0, $toString(body)),
			headers: createPropertyDescriptor(0, headers)
			});
			}
			} return init;
			};

			if (isCallable(nativeFetch)) {
			$({ global: true, enumerable: true, dontCallGetSet: true, forced: true }, {
			fetch: function fetch(input /* , init */) {
			return nativeFetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
			}
			});
			}

			if (isCallable(NativeRequest)) {
			var RequestConstructor = function Request(input /* , init */) {
			anInstance(this, RequestPrototype);
			return new NativeRequest(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
			};

			RequestPrototype.constructor = RequestConstructor;
			RequestConstructor.prototype = RequestPrototype;

			$({ global: true, constructor: true, dontCallGetSet: true, forced: true }, {
			Request: RequestConstructor
			});
			}
			}

			module.exports = {
			URLSearchParams: URLSearchParamsConstructor,
			getState: getInternalParamsState
			};