Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: node_modules/qs/dist/qs.js@ d24f17c

main

Last change on this file since d24f17c was d24f17c, checked in by Aleksandar Panovski <apano77@…>, 15 months ago
Initial commit
Property mode set to `100644`
File size: 67.5 KB

Line
1	(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Qs = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n\|\|r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2	'use strict';
3
4	var replace = String.prototype.replace;
5	var percentTwenties = /%20/g;
6
7	var Format = {
8	RFC1738: 'RFC1738',
9	RFC3986: 'RFC3986'
10	};
11
12	module.exports = {
13	'default': Format.RFC3986,
14	formatters: {
15	RFC1738: function (value) {
16	return replace.call(value, percentTwenties, '+');
17	},
18	RFC3986: function (value) {
19	return String(value);
20	}
21	},
22	RFC1738: Format.RFC1738,
23	RFC3986: Format.RFC3986
24	};
25
26	},{}],2:[function(require,module,exports){
27	'use strict';
28
29	var stringify = require('./stringify');
30	var parse = require('./parse');
31	var formats = require('./formats');
32
33	module.exports = {
34	formats: formats,
35	parse: parse,
36	stringify: stringify
37	};
38
39	},{"./formats":1,"./parse":3,"./stringify":4}],3:[function(require,module,exports){
40	'use strict';
41
42	var utils = require('./utils');
43
44	var has = Object.prototype.hasOwnProperty;
45	var isArray = Array.isArray;
46
47	var defaults = {
48	allowDots: false,
49	allowPrototypes: false,
50	allowSparse: false,
51	arrayLimit: 20,
52	charset: 'utf-8',
53	charsetSentinel: false,
54	comma: false,
55	decoder: utils.decode,
56	delimiter: '&',
57	depth: 5,
58	ignoreQueryPrefix: false,
59	interpretNumericEntities: false,
60	parameterLimit: 1000,
61	parseArrays: true,
62	plainObjects: false,
63	strictNullHandling: false
64	};
65
66	var interpretNumericEntities = function (str) {
67	return str.replace(/&#(\d+);/g, function ($0, numberStr) {
68	return String.fromCharCode(parseInt(numberStr, 10));
69	});
70	};
71
72	var parseArrayValue = function (val, options) {
73	if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
74	return val.split(',');
75	}
76
77	return val;
78	};
79
80	// This is what browsers will submit when the ✓ character occurs in an
81	// application/x-www-form-urlencoded body and the encoding of the page containing
82	// the form is iso-8859-1, or when the submitted form has an accept-charset
83	// attribute of iso-8859-1. Presumably also with other charsets that do not contain
84	// the ✓ character, such as us-ascii.
85	var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')
86
87	// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
88	var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')
89
90	var parseValues = function parseQueryStringValues(str, options) {
91	var obj = {};
92	var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
93	var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
94	var parts = cleanStr.split(options.delimiter, limit);
95	var skipIndex = -1; // Keep track of where the utf8 sentinel was found
96	var i;
97
98	var charset = options.charset;
99	if (options.charsetSentinel) {
100	for (i = 0; i < parts.length; ++i) {
101	if (parts[i].indexOf('utf8=') === 0) {
102	if (parts[i] === charsetSentinel) {
103	charset = 'utf-8';
104	} else if (parts[i] === isoSentinel) {
105	charset = 'iso-8859-1';
106	}
107	skipIndex = i;
108	i = parts.length; // The eslint settings do not allow break;
109	}
110	}
111	}
112
113	for (i = 0; i < parts.length; ++i) {
114	if (i === skipIndex) {
115	continue;
116	}
117	var part = parts[i];
118
119	var bracketEqualsPos = part.indexOf(']=');
120	var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
121
122	var key, val;
123	if (pos === -1) {
124	key = options.decoder(part, defaults.decoder, charset, 'key');
125	val = options.strictNullHandling ? null : '';
126	} else {
127	key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
128	val = utils.maybeMap(
129	parseArrayValue(part.slice(pos + 1), options),
130	function (encodedVal) {
131	return options.decoder(encodedVal, defaults.decoder, charset, 'value');
132	}
133	);
134	}
135
136	if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
137	val = interpretNumericEntities(val);
138	}
139
140	if (part.indexOf('[]=') > -1) {
141	val = isArray(val) ? [val] : val;
142	}
143
144	if (has.call(obj, key)) {
145	obj[key] = utils.combine(obj[key], val);
146	} else {
147	obj[key] = val;
148	}
149	}
150
151	return obj;
152	};
153
154	var parseObject = function (chain, val, options, valuesParsed) {
155	var leaf = valuesParsed ? val : parseArrayValue(val, options);
156
157	for (var i = chain.length - 1; i >= 0; --i) {
158	var obj;
159	var root = chain[i];
160
161	if (root === '[]' && options.parseArrays) {
162	obj = [].concat(leaf);
163	} else {
164	obj = options.plainObjects ? Object.create(null) : {};
165	var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
166	var index = parseInt(cleanRoot, 10);
167	if (!options.parseArrays && cleanRoot === '') {
168	obj = { 0: leaf };
169	} else if (
170	!isNaN(index)
171	&& root !== cleanRoot
172	&& String(index) === cleanRoot
173	&& index >= 0
174	&& (options.parseArrays && index <= options.arrayLimit)
175	) {
176	obj = [];
177	obj[index] = leaf;
178	} else if (cleanRoot !== '__proto__') {
179	obj[cleanRoot] = leaf;
180	}
181	}
182
183	leaf = obj;
184	}
185
186	return leaf;
187	};
188
189	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
190	if (!givenKey) {
191	return;
192	}
193
194	// Transform dot notation to bracket notation
195	var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
196
197	// The regex chunks
198
199	var brackets = /(\[[^[\]]*])/;
200	var child = /(\[[^[\]]*])/g;
201
202	// Get the parent
203
204	var segment = options.depth > 0 && brackets.exec(key);
205	var parent = segment ? key.slice(0, segment.index) : key;
206
207	// Stash the parent if it exists
208
209	var keys = [];
210	if (parent) {
211	// If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
212	if (!options.plainObjects && has.call(Object.prototype, parent)) {
213	if (!options.allowPrototypes) {
214	return;
215	}
216	}
217
218	keys.push(parent);
219	}
220
221	// Loop through children appending to the array until we hit depth
222
223	var i = 0;
224	while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
225	i += 1;
226	if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
227	if (!options.allowPrototypes) {
228	return;
229	}
230	}
231	keys.push(segment[1]);
232	}
233
234	// If there's a remainder, just add whatever is left
235
236	if (segment) {
237	keys.push('[' + key.slice(segment.index) + ']');
238	}
239
240	return parseObject(keys, val, options, valuesParsed);
241	};
242
243	var normalizeParseOptions = function normalizeParseOptions(opts) {
244	if (!opts) {
245	return defaults;
246	}
247
248	if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') {
249	throw new TypeError('Decoder has to be a function.');
250	}
251
252	if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
253	throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
254	}
255	var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;
256
257	return {
258	allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,
259	allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
260	allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse,
261	arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
262	charset: charset,
263	charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
264	comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
265	decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
266	delimiter: typeof opts.delimiter === 'string' \|\| utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
267	// eslint-disable-next-line no-implicit-coercion, no-extra-parens
268	depth: (typeof opts.depth === 'number' \|\| opts.depth === false) ? +opts.depth : defaults.depth,
269	ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
270	interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
271	parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
272	parseArrays: opts.parseArrays !== false,
273	plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
274	strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
275	};
276	};
277
278	module.exports = function (str, opts) {
279	var options = normalizeParseOptions(opts);
280
281	if (str === '' \|\| str === null \|\| typeof str === 'undefined') {
282	return options.plainObjects ? Object.create(null) : {};
283	}
284
285	var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
286	var obj = options.plainObjects ? Object.create(null) : {};
287
288	// Iterate over the keys and setup the new object
289
290	var keys = Object.keys(tempObj);
291	for (var i = 0; i < keys.length; ++i) {
292	var key = keys[i];
293	var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');
294	obj = utils.merge(obj, newObj, options);
295	}
296
297	if (options.allowSparse === true) {
298	return obj;
299	}
300
301	return utils.compact(obj);
302	};
303
304	},{"./utils":5}],4:[function(require,module,exports){
305	'use strict';
306
307	var getSideChannel = require('side-channel');
308	var utils = require('./utils');
309	var formats = require('./formats');
310	var has = Object.prototype.hasOwnProperty;
311
312	var arrayPrefixGenerators = {
313	brackets: function brackets(prefix) {
314	return prefix + '[]';
315	},
316	comma: 'comma',
317	indices: function indices(prefix, key) {
318	return prefix + '[' + key + ']';
319	},
320	repeat: function repeat(prefix) {
321	return prefix;
322	}
323	};
324
325	var isArray = Array.isArray;
326	var split = String.prototype.split;
327	var push = Array.prototype.push;
328	var pushToArray = function (arr, valueOrArray) {
329	push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
330	};
331
332	var toISO = Date.prototype.toISOString;
333
334	var defaultFormat = formats['default'];
335	var defaults = {
336	addQueryPrefix: false,
337	allowDots: false,
338	charset: 'utf-8',
339	charsetSentinel: false,
340	delimiter: '&',
341	encode: true,
342	encoder: utils.encode,
343	encodeValuesOnly: false,
344	format: defaultFormat,
345	formatter: formats.formatters[defaultFormat],
346	// deprecated
347	indices: false,
348	serializeDate: function serializeDate(date) {
349	return toISO.call(date);
350	},
351	skipNulls: false,
352	strictNullHandling: false
353	};
354
355	var isNonNullishPrimitive = function isNonNullishPrimitive(v) {
356	return typeof v === 'string'
357	\|\| typeof v === 'number'
358	\|\| typeof v === 'boolean'
359	\|\| typeof v === 'symbol'
360	\|\| typeof v === 'bigint';
361	};
362
363	var sentinel = {};
364
365	var stringify = function stringify(
366	object,
367	prefix,
368	generateArrayPrefix,
369	commaRoundTrip,
370	strictNullHandling,
371	skipNulls,
372	encoder,
373	filter,
374	sort,
375	allowDots,
376	serializeDate,
377	format,
378	formatter,
379	encodeValuesOnly,
380	charset,
381	sideChannel
382	) {
383	var obj = object;
384
385	var tmpSc = sideChannel;
386	var step = 0;
387	var findFlag = false;
388	while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) {
389	// Where object last appeared in the ref tree
390	var pos = tmpSc.get(object);
391	step += 1;
392	if (typeof pos !== 'undefined') {
393	if (pos === step) {
394	throw new RangeError('Cyclic object value');
395	} else {
396	findFlag = true; // Break while
397	}
398	}
399	if (typeof tmpSc.get(sentinel) === 'undefined') {
400	step = 0;
401	}
402	}
403
404	if (typeof filter === 'function') {
405	obj = filter(prefix, obj);
406	} else if (obj instanceof Date) {
407	obj = serializeDate(obj);
408	} else if (generateArrayPrefix === 'comma' && isArray(obj)) {
409	obj = utils.maybeMap(obj, function (value) {
410	if (value instanceof Date) {
411	return serializeDate(value);
412	}
413	return value;
414	});
415	}
416
417	if (obj === null) {
418	if (strictNullHandling) {
419	return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;
420	}
421
422	obj = '';
423	}
424
425	if (isNonNullishPrimitive(obj) \|\| utils.isBuffer(obj)) {
426	if (encoder) {
427	var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);
428	if (generateArrayPrefix === 'comma' && encodeValuesOnly) {
429	var valuesArray = split.call(String(obj), ',');
430	var valuesJoined = '';
431	for (var i = 0; i < valuesArray.length; ++i) {
432	valuesJoined += (i === 0 ? '' : ',') + formatter(encoder(valuesArray[i], defaults.encoder, charset, 'value', format));
433	}
434	return [formatter(keyValue) + (commaRoundTrip && isArray(obj) && valuesArray.length === 1 ? '[]' : '') + '=' + valuesJoined];
435	}
436	return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];
437	}
438	return [formatter(prefix) + '=' + formatter(String(obj))];
439	}
440
441	var values = [];
442
443	if (typeof obj === 'undefined') {
444	return values;
445	}
446
447	var objKeys;
448	if (generateArrayPrefix === 'comma' && isArray(obj)) {
449	// we need to join elements in
450	objKeys = [{ value: obj.length > 0 ? obj.join(',') \|\| null : void undefined }];
451	} else if (isArray(filter)) {
452	objKeys = filter;
453	} else {
454	var keys = Object.keys(obj);
455	objKeys = sort ? keys.sort(sort) : keys;
456	}
457
458	var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? prefix + '[]' : prefix;
459
460	for (var j = 0; j < objKeys.length; ++j) {
461	var key = objKeys[j];
462	var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key];
463
464	if (skipNulls && value === null) {
465	continue;
466	}
467
468	var keyPrefix = isArray(obj)
469	? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, key) : adjustedPrefix
470	: adjustedPrefix + (allowDots ? '.' + key : '[' + key + ']');
471
472	sideChannel.set(object, step);
473	var valueSideChannel = getSideChannel();
474	valueSideChannel.set(sentinel, sideChannel);
475	pushToArray(values, stringify(
476	value,
477	keyPrefix,
478	generateArrayPrefix,
479	commaRoundTrip,
480	strictNullHandling,
481	skipNulls,
482	encoder,
483	filter,
484	sort,
485	allowDots,
486	serializeDate,
487	format,
488	formatter,
489	encodeValuesOnly,
490	charset,
491	valueSideChannel
492	));
493	}
494
495	return values;
496	};
497
498	var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
499	if (!opts) {
500	return defaults;
501	}
502
503	if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
504	throw new TypeError('Encoder has to be a function.');
505	}
506
507	var charset = opts.charset \|\| defaults.charset;
508	if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
509	throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
510	}
511
512	var format = formats['default'];
513	if (typeof opts.format !== 'undefined') {
514	if (!has.call(formats.formatters, opts.format)) {
515	throw new TypeError('Unknown format option provided.');
516	}
517	format = opts.format;
518	}
519	var formatter = formats.formatters[format];
520
521	var filter = defaults.filter;
522	if (typeof opts.filter === 'function' \|\| isArray(opts.filter)) {
523	filter = opts.filter;
524	}
525
526	return {
527	addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
528	allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,
529	charset: charset,
530	charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
531	delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
532	encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
533	encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
534	encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
535	filter: filter,
536	format: format,
537	formatter: formatter,
538	serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
539	skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
540	sort: typeof opts.sort === 'function' ? opts.sort : null,
541	strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
542	};
543	};
544
545	module.exports = function (object, opts) {
546	var obj = object;
547	var options = normalizeStringifyOptions(opts);
548
549	var objKeys;
550	var filter;
551
552	if (typeof options.filter === 'function') {
553	filter = options.filter;
554	obj = filter('', obj);
555	} else if (isArray(options.filter)) {
556	filter = options.filter;
557	objKeys = filter;
558	}
559
560	var keys = [];
561
562	if (typeof obj !== 'object' \|\| obj === null) {
563	return '';
564	}
565
566	var arrayFormat;
567	if (opts && opts.arrayFormat in arrayPrefixGenerators) {
568	arrayFormat = opts.arrayFormat;
569	} else if (opts && 'indices' in opts) {
570	arrayFormat = opts.indices ? 'indices' : 'repeat';
571	} else {
572	arrayFormat = 'indices';
573	}
574
575	var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
576	if (opts && 'commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
577	throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
578	}
579	var commaRoundTrip = generateArrayPrefix === 'comma' && opts && opts.commaRoundTrip;
580
581	if (!objKeys) {
582	objKeys = Object.keys(obj);
583	}
584
585	if (options.sort) {
586	objKeys.sort(options.sort);
587	}
588
589	var sideChannel = getSideChannel();
590	for (var i = 0; i < objKeys.length; ++i) {
591	var key = objKeys[i];
592
593	if (options.skipNulls && obj[key] === null) {
594	continue;
595	}
596	pushToArray(keys, stringify(
597	obj[key],
598	key,
599	generateArrayPrefix,
600	commaRoundTrip,
601	options.strictNullHandling,
602	options.skipNulls,
603	options.encode ? options.encoder : null,
604	options.filter,
605	options.sort,
606	options.allowDots,
607	options.serializeDate,
608	options.format,
609	options.formatter,
610	options.encodeValuesOnly,
611	options.charset,
612	sideChannel
613	));
614	}
615
616	var joined = keys.join(options.delimiter);
617	var prefix = options.addQueryPrefix === true ? '?' : '';
618
619	if (options.charsetSentinel) {
620	if (options.charset === 'iso-8859-1') {
621	// encodeURIComponent('✓'), the "numeric entity" representation of a checkmark
622	prefix += 'utf8=%26%2310003%3B&';
623	} else {
624	// encodeURIComponent('✓')
625	prefix += 'utf8=%E2%9C%93&';
626	}
627	}
628
629	return joined.length > 0 ? prefix + joined : '';
630	};
631
632	},{"./formats":1,"./utils":5,"side-channel":16}],5:[function(require,module,exports){
633	'use strict';
634
635	var formats = require('./formats');
636
637	var has = Object.prototype.hasOwnProperty;
638	var isArray = Array.isArray;
639
640	var hexTable = (function () {
641	var array = [];
642	for (var i = 0; i < 256; ++i) {
643	array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
644	}
645
646	return array;
647	}());
648
649	var compactQueue = function compactQueue(queue) {
650	while (queue.length > 1) {
651	var item = queue.pop();
652	var obj = item.obj[item.prop];
653
654	if (isArray(obj)) {
655	var compacted = [];
656
657	for (var j = 0; j < obj.length; ++j) {
658	if (typeof obj[j] !== 'undefined') {
659	compacted.push(obj[j]);
660	}
661	}
662
663	item.obj[item.prop] = compacted;
664	}
665	}
666	};
667
668	var arrayToObject = function arrayToObject(source, options) {
669	var obj = options && options.plainObjects ? Object.create(null) : {};
670	for (var i = 0; i < source.length; ++i) {
671	if (typeof source[i] !== 'undefined') {
672	obj[i] = source[i];
673	}
674	}
675
676	return obj;
677	};
678
679	var merge = function merge(target, source, options) {
680	/* eslint no-param-reassign: 0 */
681	if (!source) {
682	return target;
683	}
684
685	if (typeof source !== 'object') {
686	if (isArray(target)) {
687	target.push(source);
688	} else if (target && typeof target === 'object') {
689	if ((options && (options.plainObjects \|\| options.allowPrototypes)) \|\| !has.call(Object.prototype, source)) {
690	target[source] = true;
691	}
692	} else {
693	return [target, source];
694	}
695
696	return target;
697	}
698
699	if (!target \|\| typeof target !== 'object') {
700	return [target].concat(source);
701	}
702
703	var mergeTarget = target;
704	if (isArray(target) && !isArray(source)) {
705	mergeTarget = arrayToObject(target, options);
706	}
707
708	if (isArray(target) && isArray(source)) {
709	source.forEach(function (item, i) {
710	if (has.call(target, i)) {
711	var targetItem = target[i];
712	if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
713	target[i] = merge(targetItem, item, options);
714	} else {
715	target.push(item);
716	}
717	} else {
718	target[i] = item;
719	}
720	});
721	return target;
722	}
723
724	return Object.keys(source).reduce(function (acc, key) {
725	var value = source[key];
726
727	if (has.call(acc, key)) {
728	acc[key] = merge(acc[key], value, options);
729	} else {
730	acc[key] = value;
731	}
732	return acc;
733	}, mergeTarget);
734	};
735
736	var assign = function assignSingleSource(target, source) {
737	return Object.keys(source).reduce(function (acc, key) {
738	acc[key] = source[key];
739	return acc;
740	}, target);
741	};
742
743	var decode = function (str, decoder, charset) {
744	var strWithoutPlus = str.replace(/\+/g, ' ');
745	if (charset === 'iso-8859-1') {
746	// unescape never throws, no try...catch needed:
747	return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
748	}
749	// utf-8
750	try {
751	return decodeURIComponent(strWithoutPlus);
752	} catch (e) {
753	return strWithoutPlus;
754	}
755	};
756
757	var encode = function encode(str, defaultEncoder, charset, kind, format) {
758	// This code was originally written by Brian White (mscdex) for the io.js core querystring library.
759	// It has been adapted here for stricter adherence to RFC 3986
760	if (str.length === 0) {
761	return str;
762	}
763
764	var string = str;
765	if (typeof str === 'symbol') {
766	string = Symbol.prototype.toString.call(str);
767	} else if (typeof str !== 'string') {
768	string = String(str);
769	}
770
771	if (charset === 'iso-8859-1') {
772	return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
773	return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
774	});
775	}
776
777	var out = '';
778	for (var i = 0; i < string.length; ++i) {
779	var c = string.charCodeAt(i);
780
781	if (
782	c === 0x2D // -
783	\|\| c === 0x2E // .
784	\|\| c === 0x5F // _
785	\|\| c === 0x7E // ~
786	\|\| (c >= 0x30 && c <= 0x39) // 0-9
787	\|\| (c >= 0x41 && c <= 0x5A) // a-z
788	\|\| (c >= 0x61 && c <= 0x7A) // A-Z
789	\|\| (format === formats.RFC1738 && (c === 0x28 \|\| c === 0x29)) // ( )
790	) {
791	out += string.charAt(i);
792	continue;
793	}
794
795	if (c < 0x80) {
796	out = out + hexTable[c];
797	continue;
798	}
799
800	if (c < 0x800) {
801	out = out + (hexTable[0xC0 \| (c >> 6)] + hexTable[0x80 \| (c & 0x3F)]);
802	continue;
803	}
804
805	if (c < 0xD800 \|\| c >= 0xE000) {
806	out = out + (hexTable[0xE0 \| (c >> 12)] + hexTable[0x80 \| ((c >> 6) & 0x3F)] + hexTable[0x80 \| (c & 0x3F)]);
807	continue;
808	}
809
810	i += 1;
811	c = 0x10000 + (((c & 0x3FF) << 10) \| (string.charCodeAt(i) & 0x3FF));
812	/* eslint operator-linebreak: [2, "before"] */
813	out += hexTable[0xF0 \| (c >> 18)]
814	+ hexTable[0x80 \| ((c >> 12) & 0x3F)]
815	+ hexTable[0x80 \| ((c >> 6) & 0x3F)]
816	+ hexTable[0x80 \| (c & 0x3F)];
817	}
818
819	return out;
820	};
821
822	var compact = function compact(value) {
823	var queue = [{ obj: { o: value }, prop: 'o' }];
824	var refs = [];
825
826	for (var i = 0; i < queue.length; ++i) {
827	var item = queue[i];
828	var obj = item.obj[item.prop];
829
830	var keys = Object.keys(obj);
831	for (var j = 0; j < keys.length; ++j) {
832	var key = keys[j];
833	var val = obj[key];
834	if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
835	queue.push({ obj: obj, prop: key });
836	refs.push(val);
837	}
838	}
839	}
840
841	compactQueue(queue);
842
843	return value;
844	};
845
846	var isRegExp = function isRegExp(obj) {
847	return Object.prototype.toString.call(obj) === '[object RegExp]';
848	};
849
850	var isBuffer = function isBuffer(obj) {
851	if (!obj \|\| typeof obj !== 'object') {
852	return false;
853	}
854
855	return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
856	};
857
858	var combine = function combine(a, b) {
859	return [].concat(a, b);
860	};
861
862	var maybeMap = function maybeMap(val, fn) {
863	if (isArray(val)) {
864	var mapped = [];
865	for (var i = 0; i < val.length; i += 1) {
866	mapped.push(fn(val[i]));
867	}
868	return mapped;
869	}
870	return fn(val);
871	};
872
873	module.exports = {
874	arrayToObject: arrayToObject,
875	assign: assign,
876	combine: combine,
877	compact: compact,
878	decode: decode,
879	encode: encode,
880	isBuffer: isBuffer,
881	isRegExp: isRegExp,
882	maybeMap: maybeMap,
883	merge: merge
884	};
885
886	},{"./formats":1}],6:[function(require,module,exports){
887
888	},{}],7:[function(require,module,exports){
889	'use strict';
890
891	var GetIntrinsic = require('get-intrinsic');
892
893	var callBind = require('./');
894
895	var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
896
897	module.exports = function callBoundIntrinsic(name, allowMissing) {
898	var intrinsic = GetIntrinsic(name, !!allowMissing);
899	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
900	return callBind(intrinsic);
901	}
902	return intrinsic;
903	};
904
905	},{"./":8,"get-intrinsic":11}],8:[function(require,module,exports){
906	'use strict';
907
908	var bind = require('function-bind');
909	var GetIntrinsic = require('get-intrinsic');
910
911	var $apply = GetIntrinsic('%Function.prototype.apply%');
912	var $call = GetIntrinsic('%Function.prototype.call%');
913	var $reflectApply = GetIntrinsic('%Reflect.apply%', true) \|\| bind.call($call, $apply);
914
915	var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
916	var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
917	var $max = GetIntrinsic('%Math.max%');
918
919	if ($defineProperty) {
920	try {
921	$defineProperty({}, 'a', { value: 1 });
922	} catch (e) {
923	// IE 8 has a broken defineProperty
924	$defineProperty = null;
925	}
926	}
927
928	module.exports = function callBind(originalFunction) {
929	var func = $reflectApply(bind, $call, arguments);
930	if ($gOPD && $defineProperty) {
931	var desc = $gOPD(func, 'length');
932	if (desc.configurable) {
933	// original length, plus the receiver, minus any additional arguments (after the receiver)
934	$defineProperty(
935	func,
936	'length',
937	{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
938	);
939	}
940	}
941	return func;
942	};
943
944	var applyBind = function applyBind() {
945	return $reflectApply(bind, $apply, arguments);
946	};
947
948	if ($defineProperty) {
949	$defineProperty(module.exports, 'apply', { value: applyBind });
950	} else {
951	module.exports.apply = applyBind;
952	}
953
954	},{"function-bind":10,"get-intrinsic":11}],9:[function(require,module,exports){
955	'use strict';
956
957	/* eslint no-invalid-this: 1 */
958
959	var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
960	var slice = Array.prototype.slice;
961	var toStr = Object.prototype.toString;
962	var funcType = '[object Function]';
963
964	module.exports = function bind(that) {
965	var target = this;
966	if (typeof target !== 'function' \|\| toStr.call(target) !== funcType) {
967	throw new TypeError(ERROR_MESSAGE + target);
968	}
969	var args = slice.call(arguments, 1);
970
971	var bound;
972	var binder = function () {
973	if (this instanceof bound) {
974	var result = target.apply(
975	this,
976	args.concat(slice.call(arguments))
977	);
978	if (Object(result) === result) {
979	return result;
980	}
981	return this;
982	} else {
983	return target.apply(
984	that,
985	args.concat(slice.call(arguments))
986	);
987	}
988	};
989
990	var boundLength = Math.max(0, target.length - args.length);
991	var boundArgs = [];
992	for (var i = 0; i < boundLength; i++) {
993	boundArgs.push('$' + i);
994	}
995
996	bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
997
998	if (target.prototype) {
999	var Empty = function Empty() {};
1000	Empty.prototype = target.prototype;
1001	bound.prototype = new Empty();
1002	Empty.prototype = null;
1003	}
1004
1005	return bound;
1006	};
1007
1008	},{}],10:[function(require,module,exports){
1009	'use strict';
1010
1011	var implementation = require('./implementation');
1012
1013	module.exports = Function.prototype.bind \|\| implementation;
1014
1015	},{"./implementation":9}],11:[function(require,module,exports){
1016	'use strict';
1017
1018	var undefined;
1019
1020	var $SyntaxError = SyntaxError;
1021	var $Function = Function;
1022	var $TypeError = TypeError;
1023
1024	// eslint-disable-next-line consistent-return
1025	var getEvalledConstructor = function (expressionSyntax) {
1026	try {
1027	return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
1028	} catch (e) {}
1029	};
1030
1031	var $gOPD = Object.getOwnPropertyDescriptor;
1032	if ($gOPD) {
1033	try {
1034	$gOPD({}, '');
1035	} catch (e) {
1036	$gOPD = null; // this is IE 8, which has a broken gOPD
1037	}
1038	}
1039
1040	var throwTypeError = function () {
1041	throw new $TypeError();
1042	};
1043	var ThrowTypeError = $gOPD
1044	? (function () {
1045	try {
1046	// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
1047	arguments.callee; // IE 8 does not throw here
1048	return throwTypeError;
1049	} catch (calleeThrows) {
1050	try {
1051	// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
1052	return $gOPD(arguments, 'callee').get;
1053	} catch (gOPDthrows) {
1054	return throwTypeError;
1055	}
1056	}
1057	}())
1058	: throwTypeError;
1059
1060	var hasSymbols = require('has-symbols')();
1061
1062	var getProto = Object.getPrototypeOf \|\| function (x) { return x.__proto__; }; // eslint-disable-line no-proto
1063
1064	var needsEval = {};
1065
1066	var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
1067
1068	var INTRINSICS = {
1069	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
1070	'%Array%': Array,
1071	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
1072	'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
1073	'%AsyncFromSyncIteratorPrototype%': undefined,
1074	'%AsyncFunction%': needsEval,
1075	'%AsyncGenerator%': needsEval,
1076	'%AsyncGeneratorFunction%': needsEval,
1077	'%AsyncIteratorPrototype%': needsEval,
1078	'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
1079	'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
1080	'%Boolean%': Boolean,
1081	'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
1082	'%Date%': Date,
1083	'%decodeURI%': decodeURI,
1084	'%decodeURIComponent%': decodeURIComponent,
1085	'%encodeURI%': encodeURI,
1086	'%encodeURIComponent%': encodeURIComponent,
1087	'%Error%': Error,
1088	'%eval%': eval, // eslint-disable-line no-eval
1089	'%EvalError%': EvalError,
1090	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
1091	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
1092	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
1093	'%Function%': $Function,
1094	'%GeneratorFunction%': needsEval,
1095	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
1096	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
1097	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
1098	'%isFinite%': isFinite,
1099	'%isNaN%': isNaN,
1100	'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
1101	'%JSON%': typeof JSON === 'object' ? JSON : undefined,
1102	'%Map%': typeof Map === 'undefined' ? undefined : Map,
1103	'%MapIteratorPrototype%': typeof Map === 'undefined' \|\| !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
1104	'%Math%': Math,
1105	'%Number%': Number,
1106	'%Object%': Object,
1107	'%parseFloat%': parseFloat,
1108	'%parseInt%': parseInt,
1109	'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
1110	'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
1111	'%RangeError%': RangeError,
1112	'%ReferenceError%': ReferenceError,
1113	'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
1114	'%RegExp%': RegExp,
1115	'%Set%': typeof Set === 'undefined' ? undefined : Set,
1116	'%SetIteratorPrototype%': typeof Set === 'undefined' \|\| !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
1117	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
1118	'%String%': String,
1119	'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
1120	'%Symbol%': hasSymbols ? Symbol : undefined,
1121	'%SyntaxError%': $SyntaxError,
1122	'%ThrowTypeError%': ThrowTypeError,
1123	'%TypedArray%': TypedArray,
1124	'%TypeError%': $TypeError,
1125	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
1126	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
1127	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
1128	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
1129	'%URIError%': URIError,
1130	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
1131	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
1132	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
1133	};
1134
1135	var doEval = function doEval(name) {
1136	var value;
1137	if (name === '%AsyncFunction%') {
1138	value = getEvalledConstructor('async function () {}');
1139	} else if (name === '%GeneratorFunction%') {
1140	value = getEvalledConstructor('function* () {}');
1141	} else if (name === '%AsyncGeneratorFunction%') {
1142	value = getEvalledConstructor('async function* () {}');
1143	} else if (name === '%AsyncGenerator%') {
1144	var fn = doEval('%AsyncGeneratorFunction%');
1145	if (fn) {
1146	value = fn.prototype;
1147	}
1148	} else if (name === '%AsyncIteratorPrototype%') {
1149	var gen = doEval('%AsyncGenerator%');
1150	if (gen) {
1151	value = getProto(gen.prototype);
1152	}
1153	}
1154
1155	INTRINSICS[name] = value;
1156
1157	return value;
1158	};
1159
1160	var LEGACY_ALIASES = {
1161	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
1162	'%ArrayPrototype%': ['Array', 'prototype'],
1163	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
1164	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
1165	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
1166	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
1167	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
1168	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
1169	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
1170	'%BooleanPrototype%': ['Boolean', 'prototype'],
1171	'%DataViewPrototype%': ['DataView', 'prototype'],
1172	'%DatePrototype%': ['Date', 'prototype'],
1173	'%ErrorPrototype%': ['Error', 'prototype'],
1174	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
1175	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
1176	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
1177	'%FunctionPrototype%': ['Function', 'prototype'],
1178	'%Generator%': ['GeneratorFunction', 'prototype'],
1179	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
1180	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
1181	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
1182	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
1183	'%JSONParse%': ['JSON', 'parse'],
1184	'%JSONStringify%': ['JSON', 'stringify'],
1185	'%MapPrototype%': ['Map', 'prototype'],
1186	'%NumberPrototype%': ['Number', 'prototype'],
1187	'%ObjectPrototype%': ['Object', 'prototype'],
1188	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
1189	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
1190	'%PromisePrototype%': ['Promise', 'prototype'],
1191	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
1192	'%Promise_all%': ['Promise', 'all'],
1193	'%Promise_reject%': ['Promise', 'reject'],
1194	'%Promise_resolve%': ['Promise', 'resolve'],
1195	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
1196	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
1197	'%RegExpPrototype%': ['RegExp', 'prototype'],
1198	'%SetPrototype%': ['Set', 'prototype'],
1199	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
1200	'%StringPrototype%': ['String', 'prototype'],
1201	'%SymbolPrototype%': ['Symbol', 'prototype'],
1202	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
1203	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
1204	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
1205	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
1206	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
1207	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
1208	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
1209	'%URIErrorPrototype%': ['URIError', 'prototype'],
1210	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
1211	'%WeakSetPrototype%': ['WeakSet', 'prototype']
1212	};
1213
1214	var bind = require('function-bind');
1215	var hasOwn = require('has');
1216	var $concat = bind.call(Function.call, Array.prototype.concat);
1217	var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
1218	var $replace = bind.call(Function.call, String.prototype.replace);
1219	var $strSlice = bind.call(Function.call, String.prototype.slice);
1220
1221	/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
1222	var rePropName = /[^%.[\]]+\|\[(?:(-?\d+(?:\.\d+)?)\|(["'])((?:(?!\2)[^\\]\|\\.)*?)\2)\]\|(?=(?:\.\|\[\])(?:\.\|\[\]\|%$))/g;
1223	var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
1224	var stringToPath = function stringToPath(string) {
1225	var first = $strSlice(string, 0, 1);
1226	var last = $strSlice(string, -1);
1227	if (first === '%' && last !== '%') {
1228	throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
1229	} else if (last === '%' && first !== '%') {
1230	throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
1231	}
1232	var result = [];
1233	$replace(string, rePropName, function (match, number, quote, subString) {
1234	result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number \|\| match;
1235	});
1236	return result;
1237	};
1238	/* end adaptation */
1239
1240	var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
1241	var intrinsicName = name;
1242	var alias;
1243	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
1244	alias = LEGACY_ALIASES[intrinsicName];
1245	intrinsicName = '%' + alias[0] + '%';
1246	}
1247
1248	if (hasOwn(INTRINSICS, intrinsicName)) {
1249	var value = INTRINSICS[intrinsicName];
1250	if (value === needsEval) {
1251	value = doEval(intrinsicName);
1252	}
1253	if (typeof value === 'undefined' && !allowMissing) {
1254	throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
1255	}
1256
1257	return {
1258	alias: alias,
1259	name: intrinsicName,
1260	value: value
1261	};
1262	}
1263
1264	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
1265	};
1266
1267	module.exports = function GetIntrinsic(name, allowMissing) {
1268	if (typeof name !== 'string' \|\| name.length === 0) {
1269	throw new $TypeError('intrinsic name must be a non-empty string');
1270	}
1271	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
1272	throw new $TypeError('"allowMissing" argument must be a boolean');
1273	}
1274
1275	var parts = stringToPath(name);
1276	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
1277
1278	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
1279	var intrinsicRealName = intrinsic.name;
1280	var value = intrinsic.value;
1281	var skipFurtherCaching = false;
1282
1283	var alias = intrinsic.alias;
1284	if (alias) {
1285	intrinsicBaseName = alias[0];
1286	$spliceApply(parts, $concat([0, 1], alias));
1287	}
1288
1289	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
1290	var part = parts[i];
1291	var first = $strSlice(part, 0, 1);
1292	var last = $strSlice(part, -1);
1293	if (
1294	(
1295	(first === '"' \|\| first === "'" \|\| first === '`')
1296	\|\| (last === '"' \|\| last === "'" \|\| last === '`')
1297	)
1298	&& first !== last
1299	) {
1300	throw new $SyntaxError('property names with quotes must have matching quotes');
1301	}
1302	if (part === 'constructor' \|\| !isOwn) {
1303	skipFurtherCaching = true;
1304	}
1305
1306	intrinsicBaseName += '.' + part;
1307	intrinsicRealName = '%' + intrinsicBaseName + '%';
1308
1309	if (hasOwn(INTRINSICS, intrinsicRealName)) {
1310	value = INTRINSICS[intrinsicRealName];
1311	} else if (value != null) {
1312	if (!(part in value)) {
1313	if (!allowMissing) {
1314	throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
1315	}
1316	return void undefined;
1317	}
1318	if ($gOPD && (i + 1) >= parts.length) {
1319	var desc = $gOPD(value, part);
1320	isOwn = !!desc;
1321
1322	// By convention, when a data property is converted to an accessor
1323	// property to emulate a data property that does not suffer from
1324	// the override mistake, that accessor's getter is marked with
1325	// an `originalValue` property. Here, when we detect this, we
1326	// uphold the illusion by pretending to see that original data
1327	// property, i.e., returning the value rather than the getter
1328	// itself.
1329	if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
1330	value = desc.get;
1331	} else {
1332	value = value[part];
1333	}
1334	} else {
1335	isOwn = hasOwn(value, part);
1336	value = value[part];
1337	}
1338
1339	if (isOwn && !skipFurtherCaching) {
1340	INTRINSICS[intrinsicRealName] = value;
1341	}
1342	}
1343	}
1344	return value;
1345	};
1346
1347	},{"function-bind":10,"has":14,"has-symbols":12}],12:[function(require,module,exports){
1348	'use strict';
1349
1350	var origSymbol = typeof Symbol !== 'undefined' && Symbol;
1351	var hasSymbolSham = require('./shams');
1352
1353	module.exports = function hasNativeSymbols() {
1354	if (typeof origSymbol !== 'function') { return false; }
1355	if (typeof Symbol !== 'function') { return false; }
1356	if (typeof origSymbol('foo') !== 'symbol') { return false; }
1357	if (typeof Symbol('bar') !== 'symbol') { return false; }
1358
1359	return hasSymbolSham();
1360	};
1361
1362	},{"./shams":13}],13:[function(require,module,exports){
1363	'use strict';
1364
1365	/* eslint complexity: [2, 18], max-statements: [2, 33] */
1366	module.exports = function hasSymbols() {
1367	if (typeof Symbol !== 'function' \|\| typeof Object.getOwnPropertySymbols !== 'function') { return false; }
1368	if (typeof Symbol.iterator === 'symbol') { return true; }
1369
1370	var obj = {};
1371	var sym = Symbol('test');
1372	var symObj = Object(sym);
1373	if (typeof sym === 'string') { return false; }
1374
1375	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
1376	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
1377
1378	// temp disabled per https://github.com/ljharb/object.assign/issues/17
1379	// if (sym instanceof Symbol) { return false; }
1380	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
1381	// if (!(symObj instanceof Symbol)) { return false; }
1382
1383	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
1384	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
1385
1386	var symVal = 42;
1387	obj[sym] = symVal;
1388	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
1389	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
1390
1391	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
1392
1393	var syms = Object.getOwnPropertySymbols(obj);
1394	if (syms.length !== 1 \|\| syms[0] !== sym) { return false; }
1395
1396	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
1397
1398	if (typeof Object.getOwnPropertyDescriptor === 'function') {
1399	var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
1400	if (descriptor.value !== symVal \|\| descriptor.enumerable !== true) { return false; }
1401	}
1402
1403	return true;
1404	};
1405
1406	},{}],14:[function(require,module,exports){
1407	'use strict';
1408
1409	var bind = require('function-bind');
1410
1411	module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
1412
1413	},{"function-bind":10}],15:[function(require,module,exports){
1414	var hasMap = typeof Map === 'function' && Map.prototype;
1415	var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
1416	var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
1417	var mapForEach = hasMap && Map.prototype.forEach;
1418	var hasSet = typeof Set === 'function' && Set.prototype;
1419	var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
1420	var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
1421	var setForEach = hasSet && Set.prototype.forEach;
1422	var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
1423	var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
1424	var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
1425	var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
1426	var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
1427	var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
1428	var booleanValueOf = Boolean.prototype.valueOf;
1429	var objectToString = Object.prototype.toString;
1430	var functionToString = Function.prototype.toString;
1431	var $match = String.prototype.match;
1432	var $slice = String.prototype.slice;
1433	var $replace = String.prototype.replace;
1434	var $toUpperCase = String.prototype.toUpperCase;
1435	var $toLowerCase = String.prototype.toLowerCase;
1436	var $test = RegExp.prototype.test;
1437	var $concat = Array.prototype.concat;
1438	var $join = Array.prototype.join;
1439	var $arrSlice = Array.prototype.slice;
1440	var $floor = Math.floor;
1441	var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
1442	var gOPS = Object.getOwnPropertySymbols;
1443	var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
1444	var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';
1445	// ie, `has-tostringtag/shams
1446	var toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')
1447	? Symbol.toStringTag
1448	: null;
1449	var isEnumerable = Object.prototype.propertyIsEnumerable;
1450
1451	var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) \|\| (
1452	[].__proto__ === Array.prototype // eslint-disable-line no-proto
1453	? function (O) {
1454	return O.__proto__; // eslint-disable-line no-proto
1455	}
1456	: null
1457	);
1458
1459	function addNumericSeparator(num, str) {
1460	if (
1461	num === Infinity
1462	\|\| num === -Infinity
1463	\|\| num !== num
1464	\|\| (num && num > -1000 && num < 1000)
1465	\|\| $test.call(/e/, str)
1466	) {
1467	return str;
1468	}
1469	var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
1470	if (typeof num === 'number') {
1471	var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
1472	if (int !== num) {
1473	var intStr = String(int);
1474	var dec = $slice.call(str, intStr.length + 1);
1475	return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');
1476	}
1477	}
1478	return $replace.call(str, sepRegex, '$&_');
1479	}
1480
1481	var utilInspect = require('./util.inspect');
1482	var inspectCustom = utilInspect.custom;
1483	var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
1484
1485	module.exports = function inspect_(obj, options, depth, seen) {
1486	var opts = options \|\| {};
1487
1488	if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
1489	throw new TypeError('option "quoteStyle" must be "single" or "double"');
1490	}
1491	if (
1492	has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
1493	? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
1494	: opts.maxStringLength !== null
1495	)
1496	) {
1497	throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
1498	}
1499	var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;
1500	if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
1501	throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`');
1502	}
1503
1504	if (
1505	has(opts, 'indent')
1506	&& opts.indent !== null
1507	&& opts.indent !== '\t'
1508	&& !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
1509	) {
1510	throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
1511	}
1512	if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {
1513	throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
1514	}
1515	var numericSeparator = opts.numericSeparator;
1516
1517	if (typeof obj === 'undefined') {
1518	return 'undefined';
1519	}
1520	if (obj === null) {
1521	return 'null';
1522	}
1523	if (typeof obj === 'boolean') {
1524	return obj ? 'true' : 'false';
1525	}
1526
1527	if (typeof obj === 'string') {
1528	return inspectString(obj, opts);
1529	}
1530	if (typeof obj === 'number') {
1531	if (obj === 0) {
1532	return Infinity / obj > 0 ? '0' : '-0';
1533	}
1534	var str = String(obj);
1535	return numericSeparator ? addNumericSeparator(obj, str) : str;
1536	}
1537	if (typeof obj === 'bigint') {
1538	var bigIntStr = String(obj) + 'n';
1539	return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
1540	}
1541
1542	var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
1543	if (typeof depth === 'undefined') { depth = 0; }
1544	if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
1545	return isArray(obj) ? '[Array]' : '[Object]';
1546	}
1547
1548	var indent = getIndent(opts, depth);
1549
1550	if (typeof seen === 'undefined') {
1551	seen = [];
1552	} else if (indexOf(seen, obj) >= 0) {
1553	return '[Circular]';
1554	}
1555
1556	function inspect(value, from, noIndent) {
1557	if (from) {
1558	seen = $arrSlice.call(seen);
1559	seen.push(from);
1560	}
1561	if (noIndent) {
1562	var newOpts = {
1563	depth: opts.depth
1564	};
1565	if (has(opts, 'quoteStyle')) {
1566	newOpts.quoteStyle = opts.quoteStyle;
1567	}
1568	return inspect_(value, newOpts, depth + 1, seen);
1569	}
1570	return inspect_(value, opts, depth + 1, seen);
1571	}
1572
1573	if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable
1574	var name = nameOf(obj);
1575	var keys = arrObjKeys(obj, inspect);
1576	return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');
1577	}
1578	if (isSymbol(obj)) {
1579	var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.\))_[^)]$/, '$1') : symToString.call(obj);
1580	return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;
1581	}
1582	if (isElement(obj)) {
1583	var s = '<' + $toLowerCase.call(String(obj.nodeName));
1584	var attrs = obj.attributes \|\| [];
1585	for (var i = 0; i < attrs.length; i++) {
1586	s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
1587	}
1588	s += '>';
1589	if (obj.childNodes && obj.childNodes.length) { s += '...'; }
1590	s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';
1591	return s;
1592	}
1593	if (isArray(obj)) {
1594	if (obj.length === 0) { return '[]'; }
1595	var xs = arrObjKeys(obj, inspect);
1596	if (indent && !singleLineValues(xs)) {
1597	return '[' + indentedJoin(xs, indent) + ']';
1598	}
1599	return '[ ' + $join.call(xs, ', ') + ' ]';
1600	}
1601	if (isError(obj)) {
1602	var parts = arrObjKeys(obj, inspect);
1603	if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) {
1604	return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';
1605	}
1606	if (parts.length === 0) { return '[' + String(obj) + ']'; }
1607	return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';
1608	}
1609	if (typeof obj === 'object' && customInspect) {
1610	if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) {
1611	return utilInspect(obj, { depth: maxDepth - depth });
1612	} else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {
1613	return obj.inspect();
1614	}
1615	}
1616	if (isMap(obj)) {
1617	var mapParts = [];
1618	mapForEach.call(obj, function (value, key) {
1619	mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
1620	});
1621	return collectionOf('Map', mapSize.call(obj), mapParts, indent);
1622	}
1623	if (isSet(obj)) {
1624	var setParts = [];
1625	setForEach.call(obj, function (value) {
1626	setParts.push(inspect(value, obj));
1627	});
1628	return collectionOf('Set', setSize.call(obj), setParts, indent);
1629	}
1630	if (isWeakMap(obj)) {
1631	return weakCollectionOf('WeakMap');
1632	}
1633	if (isWeakSet(obj)) {
1634	return weakCollectionOf('WeakSet');
1635	}
1636	if (isWeakRef(obj)) {
1637	return weakCollectionOf('WeakRef');
1638	}
1639	if (isNumber(obj)) {
1640	return markBoxed(inspect(Number(obj)));
1641	}
1642	if (isBigInt(obj)) {
1643	return markBoxed(inspect(bigIntValueOf.call(obj)));
1644	}
1645	if (isBoolean(obj)) {
1646	return markBoxed(booleanValueOf.call(obj));
1647	}
1648	if (isString(obj)) {
1649	return markBoxed(inspect(String(obj)));
1650	}
1651	if (!isDate(obj) && !isRegExp(obj)) {
1652	var ys = arrObjKeys(obj, inspect);
1653	var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object \|\| obj.constructor === Object;
1654	var protoTag = obj instanceof Object ? '' : 'null prototype';
1655	var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';
1656	var constructorTag = isPlainObject \|\| typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
1657	var tag = constructorTag + (stringTag \|\| protoTag ? '[' + $join.call($concat.call([], stringTag \|\| [], protoTag \|\| []), ': ') + '] ' : '');
1658	if (ys.length === 0) { return tag + '{}'; }
1659	if (indent) {
1660	return tag + '{' + indentedJoin(ys, indent) + '}';
1661	}
1662	return tag + '{ ' + $join.call(ys, ', ') + ' }';
1663	}
1664	return String(obj);
1665	};
1666
1667	function wrapQuotes(s, defaultStyle, opts) {
1668	var quoteChar = (opts.quoteStyle \|\| defaultStyle) === 'double' ? '"' : "'";
1669	return quoteChar + s + quoteChar;
1670	}
1671
1672	function quote(s) {
1673	return $replace.call(String(s), /"/g, '"');
1674	}
1675
1676	function isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1677	function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1678	function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1679	function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1680	function isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1681	function isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1682	function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag \|\| !(typeof obj === 'object' && toStringTag in obj)); }
1683
1684	// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
1685	function isSymbol(obj) {
1686	if (hasShammedSymbols) {
1687	return obj && typeof obj === 'object' && obj instanceof Symbol;
1688	}
1689	if (typeof obj === 'symbol') {
1690	return true;
1691	}
1692	if (!obj \|\| typeof obj !== 'object' \|\| !symToString) {
1693	return false;
1694	}
1695	try {
1696	symToString.call(obj);
1697	return true;
1698	} catch (e) {}
1699	return false;
1700	}
1701
1702	function isBigInt(obj) {
1703	if (!obj \|\| typeof obj !== 'object' \|\| !bigIntValueOf) {
1704	return false;
1705	}
1706	try {
1707	bigIntValueOf.call(obj);
1708	return true;
1709	} catch (e) {}
1710	return false;
1711	}
1712
1713	var hasOwn = Object.prototype.hasOwnProperty \|\| function (key) { return key in this; };
1714	function has(obj, key) {
1715	return hasOwn.call(obj, key);
1716	}
1717
1718	function toStr(obj) {
1719	return objectToString.call(obj);
1720	}
1721
1722	function nameOf(f) {
1723	if (f.name) { return f.name; }
1724	var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
1725	if (m) { return m[1]; }
1726	return null;
1727	}
1728
1729	function indexOf(xs, x) {
1730	if (xs.indexOf) { return xs.indexOf(x); }
1731	for (var i = 0, l = xs.length; i < l; i++) {
1732	if (xs[i] === x) { return i; }
1733	}
1734	return -1;
1735	}
1736
1737	function isMap(x) {
1738	if (!mapSize \|\| !x \|\| typeof x !== 'object') {
1739	return false;
1740	}
1741	try {
1742	mapSize.call(x);
1743	try {
1744	setSize.call(x);
1745	} catch (s) {
1746	return true;
1747	}
1748	return x instanceof Map; // core-js workaround, pre-v2.5.0
1749	} catch (e) {}
1750	return false;
1751	}
1752
1753	function isWeakMap(x) {
1754	if (!weakMapHas \|\| !x \|\| typeof x !== 'object') {
1755	return false;
1756	}
1757	try {
1758	weakMapHas.call(x, weakMapHas);
1759	try {
1760	weakSetHas.call(x, weakSetHas);
1761	} catch (s) {
1762	return true;
1763	}
1764	return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
1765	} catch (e) {}
1766	return false;
1767	}
1768
1769	function isWeakRef(x) {
1770	if (!weakRefDeref \|\| !x \|\| typeof x !== 'object') {
1771	return false;
1772	}
1773	try {
1774	weakRefDeref.call(x);
1775	return true;
1776	} catch (e) {}
1777	return false;
1778	}
1779
1780	function isSet(x) {
1781	if (!setSize \|\| !x \|\| typeof x !== 'object') {
1782	return false;
1783	}
1784	try {
1785	setSize.call(x);
1786	try {
1787	mapSize.call(x);
1788	} catch (m) {
1789	return true;
1790	}
1791	return x instanceof Set; // core-js workaround, pre-v2.5.0
1792	} catch (e) {}
1793	return false;
1794	}
1795
1796	function isWeakSet(x) {
1797	if (!weakSetHas \|\| !x \|\| typeof x !== 'object') {
1798	return false;
1799	}
1800	try {
1801	weakSetHas.call(x, weakSetHas);
1802	try {
1803	weakMapHas.call(x, weakMapHas);
1804	} catch (s) {
1805	return true;
1806	}
1807	return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
1808	} catch (e) {}
1809	return false;
1810	}
1811
1812	function isElement(x) {
1813	if (!x \|\| typeof x !== 'object') { return false; }
1814	if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
1815	return true;
1816	}
1817	return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
1818	}
1819
1820	function inspectString(str, opts) {
1821	if (str.length > opts.maxStringLength) {
1822	var remaining = str.length - opts.maxStringLength;
1823	var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
1824	return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
1825	}
1826	// eslint-disable-next-line no-control-regex
1827	var s = $replace.call($replace.call(str, /(['\\])/g, '\\$1'), /[\x00-\x1f]/g, lowbyte);
1828	return wrapQuotes(s, 'single', opts);
1829	}
1830
1831	function lowbyte(c) {
1832	var n = c.charCodeAt(0);
1833	var x = {
1834	8: 'b',
1835	9: 't',
1836	10: 'n',
1837	12: 'f',
1838	13: 'r'
1839	}[n];
1840	if (x) { return '\\' + x; }
1841	return '\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));
1842	}
1843
1844	function markBoxed(str) {
1845	return 'Object(' + str + ')';
1846	}
1847
1848	function weakCollectionOf(type) {
1849	return type + ' { ? }';
1850	}
1851
1852	function collectionOf(type, size, entries, indent) {
1853	var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');
1854	return type + ' (' + size + ') {' + joinedEntries + '}';
1855	}
1856
1857	function singleLineValues(xs) {
1858	for (var i = 0; i < xs.length; i++) {
1859	if (indexOf(xs[i], '\n') >= 0) {
1860	return false;
1861	}
1862	}
1863	return true;
1864	}
1865
1866	function getIndent(opts, depth) {
1867	var baseIndent;
1868	if (opts.indent === '\t') {
1869	baseIndent = '\t';
1870	} else if (typeof opts.indent === 'number' && opts.indent > 0) {
1871	baseIndent = $join.call(Array(opts.indent + 1), ' ');
1872	} else {
1873	return null;
1874	}
1875	return {
1876	base: baseIndent,
1877	prev: $join.call(Array(depth + 1), baseIndent)
1878	};
1879	}
1880
1881	function indentedJoin(xs, indent) {
1882	if (xs.length === 0) { return ''; }
1883	var lineJoiner = '\n' + indent.prev + indent.base;
1884	return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev;
1885	}
1886
1887	function arrObjKeys(obj, inspect) {
1888	var isArr = isArray(obj);
1889	var xs = [];
1890	if (isArr) {
1891	xs.length = obj.length;
1892	for (var i = 0; i < obj.length; i++) {
1893	xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
1894	}
1895	}
1896	var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
1897	var symMap;
1898	if (hasShammedSymbols) {
1899	symMap = {};
1900	for (var k = 0; k < syms.length; k++) {
1901	symMap['$' + syms[k]] = syms[k];
1902	}
1903	}
1904
1905	for (var key in obj) { // eslint-disable-line no-restricted-syntax
1906	if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
1907	if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
1908	if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
1909	// this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
1910	continue; // eslint-disable-line no-restricted-syntax, no-continue
1911	} else if ($test.call(/[^\w$]/, key)) {
1912	xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
1913	} else {
1914	xs.push(key + ': ' + inspect(obj[key], obj));
1915	}
1916	}
1917	if (typeof gOPS === 'function') {
1918	for (var j = 0; j < syms.length; j++) {
1919	if (isEnumerable.call(obj, syms[j])) {
1920	xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
1921	}
1922	}
1923	}
1924	return xs;
1925	}
1926
1927	},{"./util.inspect":6}],16:[function(require,module,exports){
1928	'use strict';
1929
1930	var GetIntrinsic = require('get-intrinsic');
1931	var callBound = require('call-bind/callBound');
1932	var inspect = require('object-inspect');
1933
1934	var $TypeError = GetIntrinsic('%TypeError%');
1935	var $WeakMap = GetIntrinsic('%WeakMap%', true);
1936	var $Map = GetIntrinsic('%Map%', true);
1937
1938	var $weakMapGet = callBound('WeakMap.prototype.get', true);
1939	var $weakMapSet = callBound('WeakMap.prototype.set', true);
1940	var $weakMapHas = callBound('WeakMap.prototype.has', true);
1941	var $mapGet = callBound('Map.prototype.get', true);
1942	var $mapSet = callBound('Map.prototype.set', true);
1943	var $mapHas = callBound('Map.prototype.has', true);
1944
1945	/*
1946	* This function traverses the list returning the node corresponding to the
1947	* given key.
1948	*
1949	* That node is also moved to the head of the list, so that if it's accessed
1950	* again we don't need to traverse the whole list. By doing so, all the recently
1951	* used nodes can be accessed relatively quickly.
1952	*/
1953	var listGetNode = function (list, key) { // eslint-disable-line consistent-return
1954	for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
1955	if (curr.key === key) {
1956	prev.next = curr.next;
1957	curr.next = list.next;
1958	list.next = curr; // eslint-disable-line no-param-reassign
1959	return curr;
1960	}
1961	}
1962	};
1963
1964	var listGet = function (objects, key) {
1965	var node = listGetNode(objects, key);
1966	return node && node.value;
1967	};
1968	var listSet = function (objects, key, value) {
1969	var node = listGetNode(objects, key);
1970	if (node) {
1971	node.value = value;
1972	} else {
1973	// Prepend the new node to the beginning of the list
1974	objects.next = { // eslint-disable-line no-param-reassign
1975	key: key,
1976	next: objects.next,
1977	value: value
1978	};
1979	}
1980	};
1981	var listHas = function (objects, key) {
1982	return !!listGetNode(objects, key);
1983	};
1984
1985	module.exports = function getSideChannel() {
1986	var $wm;
1987	var $m;
1988	var $o;
1989	var channel = {
1990	assert: function (key) {
1991	if (!channel.has(key)) {
1992	throw new $TypeError('Side channel does not contain ' + inspect(key));
1993	}
1994	},
1995	get: function (key) { // eslint-disable-line consistent-return
1996	if ($WeakMap && key && (typeof key === 'object' \|\| typeof key === 'function')) {
1997	if ($wm) {
1998	return $weakMapGet($wm, key);
1999	}
2000	} else if ($Map) {
2001	if ($m) {
2002	return $mapGet($m, key);
2003	}
2004	} else {
2005	if ($o) { // eslint-disable-line no-lonely-if
2006	return listGet($o, key);
2007	}
2008	}
2009	},
2010	has: function (key) {
2011	if ($WeakMap && key && (typeof key === 'object' \|\| typeof key === 'function')) {
2012	if ($wm) {
2013	return $weakMapHas($wm, key);
2014	}
2015	} else if ($Map) {
2016	if ($m) {
2017	return $mapHas($m, key);
2018	}
2019	} else {
2020	if ($o) { // eslint-disable-line no-lonely-if
2021	return listHas($o, key);
2022	}
2023	}
2024	return false;
2025	},
2026	set: function (key, value) {
2027	if ($WeakMap && key && (typeof key === 'object' \|\| typeof key === 'function')) {
2028	if (!$wm) {
2029	$wm = new $WeakMap();
2030	}
2031	$weakMapSet($wm, key, value);
2032	} else if ($Map) {
2033	if (!$m) {
2034	$m = new $Map();
2035	}
2036	$mapSet($m, key, value);
2037	} else {
2038	if (!$o) {
2039	/*
2040	* Initialize the linked list as an empty node, so that we don't have
2041	* to special-case handling of the first node: we can always refer to
2042	* it as (previous node).next, instead of something like (list).head
2043	*/
2044	$o = { key: {}, next: null };
2045	}
2046	listSet($o, key, value);
2047	}
2048	}
2049	};
2050	return channel;
2051	};
2052
2053	},{"call-bind/callBound":7,"get-intrinsic":11,"object-inspect":15}]},{},[2])(2)
2054	});

Note: See TracBrowser for help on using the repository browser.

Download in other formats: