| (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){ |
| 'use strict'; |
| |
| var replace = String.prototype.replace; |
| var percentTwenties = /%20/g; |
| |
| var Format = { |
| RFC1738: 'RFC1738', |
| RFC3986: 'RFC3986' |
| }; |
| |
| module.exports = { |
| 'default': Format.RFC3986, |
| formatters: { |
| RFC1738: function (value) { |
| return replace.call(value, percentTwenties, '+'); |
| }, |
| RFC3986: function (value) { |
| return String(value); |
| } |
| }, |
| RFC1738: Format.RFC1738, |
| RFC3986: Format.RFC3986 |
| }; |
| |
| },{}],2:[function(require,module,exports){ |
| 'use strict'; |
| |
| var stringify = require('./stringify'); |
| var parse = require('./parse'); |
| var formats = require('./formats'); |
| |
| module.exports = { |
| formats: formats, |
| parse: parse, |
| stringify: stringify |
| }; |
| |
| },{"./formats":1,"./parse":3,"./stringify":4}],3:[function(require,module,exports){ |
| 'use strict'; |
| |
| var utils = require('./utils'); |
| |
| var has = Object.prototype.hasOwnProperty; |
| var isArray = Array.isArray; |
| |
| var defaults = { |
| allowDots: false, |
| allowPrototypes: false, |
| allowSparse: false, |
| arrayLimit: 20, |
| charset: 'utf-8', |
| charsetSentinel: false, |
| comma: false, |
| decoder: utils.decode, |
| delimiter: '&', |
| depth: 5, |
| ignoreQueryPrefix: false, |
| interpretNumericEntities: false, |
| parameterLimit: 1000, |
| parseArrays: true, |
| plainObjects: false, |
| strictNullHandling: false |
| }; |
| |
| var interpretNumericEntities = function (str) { |
| return str.replace(/&#(\d+);/g, function ($0, numberStr) { |
| return String.fromCharCode(parseInt(numberStr, 10)); |
| }); |
| }; |
| |
| var parseArrayValue = function (val, options) { |
| if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) { |
| return val.split(','); |
| } |
| |
| return val; |
| }; |
| |
| // This is what browsers will submit when the ✓ character occurs in an |
| // application/x-www-form-urlencoded body and the encoding of the page containing |
| // the form is iso-8859-1, or when the submitted form has an accept-charset |
| // attribute of iso-8859-1. Presumably also with other charsets that do not contain |
| // the ✓ character, such as us-ascii. |
| var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓') |
| |
| // These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded. |
| var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓') |
| |
| var parseValues = function parseQueryStringValues(str, options) { |
| var obj = {}; |
| var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str; |
| var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit; |
| var parts = cleanStr.split(options.delimiter, limit); |
| var skipIndex = -1; // Keep track of where the utf8 sentinel was found |
| var i; |
| |
| var charset = options.charset; |
| if (options.charsetSentinel) { |
| for (i = 0; i < parts.length; ++i) { |
| if (parts[i].indexOf('utf8=') === 0) { |
| if (parts[i] === charsetSentinel) { |
| charset = 'utf-8'; |
| } else if (parts[i] === isoSentinel) { |
| charset = 'iso-8859-1'; |
| } |
| skipIndex = i; |
| i = parts.length; // The eslint settings do not allow break; |
| } |
| } |
| } |
| |
| for (i = 0; i < parts.length; ++i) { |
| if (i === skipIndex) { |
| continue; |
| } |
| var part = parts[i]; |
| |
| var bracketEqualsPos = part.indexOf(']='); |
| var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1; |
| |
| var key, val; |
| if (pos === -1) { |
| key = options.decoder(part, defaults.decoder, charset, 'key'); |
| val = options.strictNullHandling ? null : ''; |
| } else { |
| key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key'); |
| val = utils.maybeMap( |
| parseArrayValue(part.slice(pos + 1), options), |
| function (encodedVal) { |
| return options.decoder(encodedVal, defaults.decoder, charset, 'value'); |
| } |
| ); |
| } |
| |
| if (val && options.interpretNumericEntities && charset === 'iso-8859-1') { |
| val = interpretNumericEntities(val); |
| } |
| |
| if (part.indexOf('[]=') > -1) { |
| val = isArray(val) ? [val] : val; |
| } |
| |
| if (has.call(obj, key)) { |
| obj[key] = utils.combine(obj[key], val); |
| } else { |
| obj[key] = val; |
| } |
| } |
| |
| return obj; |
| }; |
| |
| var parseObject = function (chain, val, options, valuesParsed) { |
| var leaf = valuesParsed ? val : parseArrayValue(val, options); |
| |
| for (var i = chain.length - 1; i >= 0; --i) { |
| var obj; |
| var root = chain[i]; |
| |
| if (root === '[]' && options.parseArrays) { |
| obj = [].concat(leaf); |
| } else { |
| obj = options.plainObjects ? Object.create(null) : {}; |
| var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root; |
| var index = parseInt(cleanRoot, 10); |
| if (!options.parseArrays && cleanRoot === '') { |
| obj = { 0: leaf }; |
| } else if ( |
| !isNaN(index) |
| && root !== cleanRoot |
| && String(index) === cleanRoot |
| && index >= 0 |
| && (options.parseArrays && index <= options.arrayLimit) |
| ) { |
| obj = []; |
| obj[index] = leaf; |
| } else if (cleanRoot !== '__proto__') { |
| obj[cleanRoot] = leaf; |
| } |
| } |
| |
| leaf = obj; |
| } |
| |
| return leaf; |
| }; |
| |
| var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) { |
| if (!givenKey) { |
| return; |
| } |
| |
| // Transform dot notation to bracket notation |
| var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey; |
| |
| // The regex chunks |
| |
| var brackets = /(\[[^[\]]*])/; |
| var child = /(\[[^[\]]*])/g; |
| |
| // Get the parent |
| |
| var segment = options.depth > 0 && brackets.exec(key); |
| var parent = segment ? key.slice(0, segment.index) : key; |
| |
| // Stash the parent if it exists |
| |
| var keys = []; |
| if (parent) { |
| // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties |
| if (!options.plainObjects && has.call(Object.prototype, parent)) { |
| if (!options.allowPrototypes) { |
| return; |
| } |
| } |
| |
| keys.push(parent); |
| } |
| |
| // Loop through children appending to the array until we hit depth |
| |
| var i = 0; |
| while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) { |
| i += 1; |
| if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) { |
| if (!options.allowPrototypes) { |
| return; |
| } |
| } |
| keys.push(segment[1]); |
| } |
| |
| // If there's a remainder, just add whatever is left |
| |
| if (segment) { |
| keys.push('[' + key.slice(segment.index) + ']'); |
| } |
| |
| return parseObject(keys, val, options, valuesParsed); |
| }; |
| |
| var normalizeParseOptions = function normalizeParseOptions(opts) { |
| if (!opts) { |
| return defaults; |
| } |
| |
| if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') { |
| throw new TypeError('Decoder has to be a function.'); |
| } |
| |
| if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') { |
| throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined'); |
| } |
| var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset; |
| |
| return { |
| allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots, |
| allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes, |
| allowSparse: typeof opts.allowSparse === 'boolean' ? opts.allowSparse : defaults.allowSparse, |
| arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit, |
| charset: charset, |
| charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel, |
| comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma, |
| decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder, |
| delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter, |
| // eslint-disable-next-line no-implicit-coercion, no-extra-parens |
| depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth, |
| ignoreQueryPrefix: opts.ignoreQueryPrefix === true, |
| interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities, |
| parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit, |
| parseArrays: opts.parseArrays !== false, |
| plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects, |
| strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling |
| }; |
| }; |
| |
| module.exports = function (str, opts) { |
| var options = normalizeParseOptions(opts); |
| |
| if (str === '' || str === null || typeof str === 'undefined') { |
| return options.plainObjects ? Object.create(null) : {}; |
| } |
| |
| var tempObj = typeof str === 'string' ? parseValues(str, options) : str; |
| var obj = options.plainObjects ? Object.create(null) : {}; |
| |
| // Iterate over the keys and setup the new object |
| |
| var keys = Object.keys(tempObj); |
| for (var i = 0; i < keys.length; ++i) { |
| var key = keys[i]; |
| var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string'); |
| obj = utils.merge(obj, newObj, options); |
| } |
| |
| if (options.allowSparse === true) { |
| return obj; |
| } |
| |
| return utils.compact(obj); |
| }; |
| |
| },{"./utils":5}],4:[function(require,module,exports){ |
| 'use strict'; |
| |
| var getSideChannel = require('side-channel'); |
| var utils = require('./utils'); |
| var formats = require('./formats'); |
| var has = Object.prototype.hasOwnProperty; |
| |
| var arrayPrefixGenerators = { |
| brackets: function brackets(prefix) { |
| return prefix + '[]'; |
| }, |
| comma: 'comma', |
| indices: function indices(prefix, key) { |
| return prefix + '[' + key + ']'; |
| }, |
| repeat: function repeat(prefix) { |
| return prefix; |
| } |
| }; |
| |
| var isArray = Array.isArray; |
| var split = String.prototype.split; |
| var push = Array.prototype.push; |
| var pushToArray = function (arr, valueOrArray) { |
| push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]); |
| }; |
| |
| var toISO = Date.prototype.toISOString; |
| |
| var defaultFormat = formats['default']; |
| var defaults = { |
| addQueryPrefix: false, |
| allowDots: false, |
| charset: 'utf-8', |
| charsetSentinel: false, |
| delimiter: '&', |
| encode: true, |
| encoder: utils.encode, |
| encodeValuesOnly: false, |
| format: defaultFormat, |
| formatter: formats.formatters[defaultFormat], |
| // deprecated |
| indices: false, |
| serializeDate: function serializeDate(date) { |
| return toISO.call(date); |
| }, |
| skipNulls: false, |
| strictNullHandling: false |
| }; |
| |
| var isNonNullishPrimitive = function isNonNullishPrimitive(v) { |
| return typeof v === 'string' |
| || typeof v === 'number' |
| || typeof v === 'boolean' |
| || typeof v === 'symbol' |
| || typeof v === 'bigint'; |
| }; |
| |
| var sentinel = {}; |
| |
| var stringify = function stringify( |
| object, |
| prefix, |
| generateArrayPrefix, |
| commaRoundTrip, |
| strictNullHandling, |
| skipNulls, |
| encoder, |
| filter, |
| sort, |
| allowDots, |
| serializeDate, |
| format, |
| formatter, |
| encodeValuesOnly, |
| charset, |
| sideChannel |
| ) { |
| var obj = object; |
| |
| var tmpSc = sideChannel; |
| var step = 0; |
| var findFlag = false; |
| while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) { |
| // Where object last appeared in the ref tree |
| var pos = tmpSc.get(object); |
| step += 1; |
| if (typeof pos !== 'undefined') { |
| if (pos === step) { |
| throw new RangeError('Cyclic object value'); |
| } else { |
| findFlag = true; // Break while |
| } |
| } |
| if (typeof tmpSc.get(sentinel) === 'undefined') { |
| step = 0; |
| } |
| } |
| |
| if (typeof filter === 'function') { |
| obj = filter(prefix, obj); |
| } else if (obj instanceof Date) { |
| obj = serializeDate(obj); |
| } else if (generateArrayPrefix === 'comma' && isArray(obj)) { |
| obj = utils.maybeMap(obj, function (value) { |
| if (value instanceof Date) { |
| return serializeDate(value); |
| } |
| return value; |
| }); |
| } |
| |
| if (obj === null) { |
| if (strictNullHandling) { |
| return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix; |
| } |
| |
| obj = ''; |
| } |
| |
| if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) { |
| if (encoder) { |
| var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format); |
| if (generateArrayPrefix === 'comma' && encodeValuesOnly) { |
| var valuesArray = split.call(String(obj), ','); |
| var valuesJoined = ''; |
| for (var i = 0; i < valuesArray.length; ++i) { |
| valuesJoined += (i === 0 ? '' : ',') + formatter(encoder(valuesArray[i], defaults.encoder, charset, 'value', format)); |
| } |
| return [formatter(keyValue) + (commaRoundTrip && isArray(obj) && valuesArray.length === 1 ? '[]' : '') + '=' + valuesJoined]; |
| } |
| return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))]; |
| } |
| return [formatter(prefix) + '=' + formatter(String(obj))]; |
| } |
| |
| var values = []; |
| |
| if (typeof obj === 'undefined') { |
| return values; |
| } |
| |
| var objKeys; |
| if (generateArrayPrefix === 'comma' && isArray(obj)) { |
| // we need to join elements in |
| objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }]; |
| } else if (isArray(filter)) { |
| objKeys = filter; |
| } else { |
| var keys = Object.keys(obj); |
| objKeys = sort ? keys.sort(sort) : keys; |
| } |
| |
| var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? prefix + '[]' : prefix; |
| |
| for (var j = 0; j < objKeys.length; ++j) { |
| var key = objKeys[j]; |
| var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key]; |
| |
| if (skipNulls && value === null) { |
| continue; |
| } |
| |
| var keyPrefix = isArray(obj) |
| ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, key) : adjustedPrefix |
| : adjustedPrefix + (allowDots ? '.' + key : '[' + key + ']'); |
| |
| sideChannel.set(object, step); |
| var valueSideChannel = getSideChannel(); |
| valueSideChannel.set(sentinel, sideChannel); |
| pushToArray(values, stringify( |
| value, |
| keyPrefix, |
| generateArrayPrefix, |
| commaRoundTrip, |
| strictNullHandling, |
| skipNulls, |
| encoder, |
| filter, |
| sort, |
| allowDots, |
| serializeDate, |
| format, |
| formatter, |
| encodeValuesOnly, |
| charset, |
| valueSideChannel |
| )); |
| } |
| |
| return values; |
| }; |
| |
| var normalizeStringifyOptions = function normalizeStringifyOptions(opts) { |
| if (!opts) { |
| return defaults; |
| } |
| |
| if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') { |
| throw new TypeError('Encoder has to be a function.'); |
| } |
| |
| var charset = opts.charset || defaults.charset; |
| if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') { |
| throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined'); |
| } |
| |
| var format = formats['default']; |
| if (typeof opts.format !== 'undefined') { |
| if (!has.call(formats.formatters, opts.format)) { |
| throw new TypeError('Unknown format option provided.'); |
| } |
| format = opts.format; |
| } |
| var formatter = formats.formatters[format]; |
| |
| var filter = defaults.filter; |
| if (typeof opts.filter === 'function' || isArray(opts.filter)) { |
| filter = opts.filter; |
| } |
| |
| return { |
| addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix, |
| allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots, |
| charset: charset, |
| charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel, |
| delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter, |
| encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode, |
| encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder, |
| encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly, |
| filter: filter, |
| format: format, |
| formatter: formatter, |
| serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate, |
| skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls, |
| sort: typeof opts.sort === 'function' ? opts.sort : null, |
| strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling |
| }; |
| }; |
| |
| module.exports = function (object, opts) { |
| var obj = object; |
| var options = normalizeStringifyOptions(opts); |
| |
| var objKeys; |
| var filter; |
| |
| if (typeof options.filter === 'function') { |
| filter = options.filter; |
| obj = filter('', obj); |
| } else if (isArray(options.filter)) { |
| filter = options.filter; |
| objKeys = filter; |
| } |
| |
| var keys = []; |
| |
| if (typeof obj !== 'object' || obj === null) { |
| return ''; |
| } |
| |
| var arrayFormat; |
| if (opts && opts.arrayFormat in arrayPrefixGenerators) { |
| arrayFormat = opts.arrayFormat; |
| } else if (opts && 'indices' in opts) { |
| arrayFormat = opts.indices ? 'indices' : 'repeat'; |
| } else { |
| arrayFormat = 'indices'; |
| } |
| |
| var generateArrayPrefix = arrayPrefixGenerators[arrayFormat]; |
| if (opts && 'commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') { |
| throw new TypeError('`commaRoundTrip` must be a boolean, or absent'); |
| } |
| var commaRoundTrip = generateArrayPrefix === 'comma' && opts && opts.commaRoundTrip; |
| |
| if (!objKeys) { |
| objKeys = Object.keys(obj); |
| } |
| |
| if (options.sort) { |
| objKeys.sort(options.sort); |
| } |
| |
| var sideChannel = getSideChannel(); |
| for (var i = 0; i < objKeys.length; ++i) { |
| var key = objKeys[i]; |
| |
| if (options.skipNulls && obj[key] === null) { |
| continue; |
| } |
| pushToArray(keys, stringify( |
| obj[key], |
| key, |
| generateArrayPrefix, |
| commaRoundTrip, |
| options.strictNullHandling, |
| options.skipNulls, |
| options.encode ? options.encoder : null, |
| options.filter, |
| options.sort, |
| options.allowDots, |
| options.serializeDate, |
| options.format, |
| options.formatter, |
| options.encodeValuesOnly, |
| options.charset, |
| sideChannel |
| )); |
| } |
| |
| var joined = keys.join(options.delimiter); |
| var prefix = options.addQueryPrefix === true ? '?' : ''; |
| |
| if (options.charsetSentinel) { |
| if (options.charset === 'iso-8859-1') { |
| // encodeURIComponent('✓'), the "numeric entity" representation of a checkmark |
| prefix += 'utf8=%26%2310003%3B&'; |
| } else { |
| // encodeURIComponent('✓') |
| prefix += 'utf8=%E2%9C%93&'; |
| } |
| } |
| |
| return joined.length > 0 ? prefix + joined : ''; |
| }; |
| |
| },{"./formats":1,"./utils":5,"side-channel":16}],5:[function(require,module,exports){ |
| 'use strict'; |
| |
| var formats = require('./formats'); |
| |
| var has = Object.prototype.hasOwnProperty; |
| var isArray = Array.isArray; |
| |
| var hexTable = (function () { |
| var array = []; |
| for (var i = 0; i < 256; ++i) { |
| array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase()); |
| } |
| |
| return array; |
| }()); |
| |
| var compactQueue = function compactQueue(queue) { |
| while (queue.length > 1) { |
| var item = queue.pop(); |
| var obj = item.obj[item.prop]; |
| |
| if (isArray(obj)) { |
| var compacted = []; |
| |
| for (var j = 0; j < obj.length; ++j) { |
| if (typeof obj[j] !== 'undefined') { |
| compacted.push(obj[j]); |
| } |
| } |
| |
| item.obj[item.prop] = compacted; |
| } |
| } |
| }; |
| |
| var arrayToObject = function arrayToObject(source, options) { |
| var obj = options && options.plainObjects ? Object.create(null) : {}; |
| for (var i = 0; i < source.length; ++i) { |
| if (typeof source[i] !== 'undefined') { |
| obj[i] = source[i]; |
| } |
| } |
| |
| return obj; |
| }; |
| |
| var merge = function merge(target, source, options) { |
| /* eslint no-param-reassign: 0 */ |
| if (!source) { |
| return target; |
| } |
| |
| if (typeof source !== 'object') { |
| if (isArray(target)) { |
| target.push(source); |
| } else if (target && typeof target === 'object') { |
| if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) { |
| target[source] = true; |
| } |
| } else { |
| return [target, source]; |
| } |
| |
| return target; |
| } |
| |
| if (!target || typeof target !== 'object') { |
| return [target].concat(source); |
| } |
| |
| var mergeTarget = target; |
| if (isArray(target) && !isArray(source)) { |
| mergeTarget = arrayToObject(target, options); |
| } |
| |
| if (isArray(target) && isArray(source)) { |
| source.forEach(function (item, i) { |
| if (has.call(target, i)) { |
| var targetItem = target[i]; |
| if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') { |
| target[i] = merge(targetItem, item, options); |
| } else { |
| target.push(item); |
| } |
| } else { |
| target[i] = item; |
| } |
| }); |
| return target; |
| } |
| |
| return Object.keys(source).reduce(function (acc, key) { |
| var value = source[key]; |
| |
| if (has.call(acc, key)) { |
| acc[key] = merge(acc[key], value, options); |
| } else { |
| acc[key] = value; |
| } |
| return acc; |
| }, mergeTarget); |
| }; |
| |
| var assign = function assignSingleSource(target, source) { |
| return Object.keys(source).reduce(function (acc, key) { |
| acc[key] = source[key]; |
| return acc; |
| }, target); |
| }; |
| |
| var decode = function (str, decoder, charset) { |
| var strWithoutPlus = str.replace(/\+/g, ' '); |
| if (charset === 'iso-8859-1') { |
| // unescape never throws, no try...catch needed: |
| return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape); |
| } |
| // utf-8 |
| try { |
| return decodeURIComponent(strWithoutPlus); |
| } catch (e) { |
| return strWithoutPlus; |
| } |
| }; |
| |
| var encode = function encode(str, defaultEncoder, charset, kind, format) { |
| // This code was originally written by Brian White (mscdex) for the io.js core querystring library. |
| // It has been adapted here for stricter adherence to RFC 3986 |
| if (str.length === 0) { |
| return str; |
| } |
| |
| var string = str; |
| if (typeof str === 'symbol') { |
| string = Symbol.prototype.toString.call(str); |
| } else if (typeof str !== 'string') { |
| string = String(str); |
| } |
| |
| if (charset === 'iso-8859-1') { |
| return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) { |
| return '%26%23' + parseInt($0.slice(2), 16) + '%3B'; |
| }); |
| } |
| |
| var out = ''; |
| for (var i = 0; i < string.length; ++i) { |
| var c = string.charCodeAt(i); |
| |
| if ( |
| c === 0x2D // - |
| || c === 0x2E // . |
| || c === 0x5F // _ |
| || c === 0x7E // ~ |
| || (c >= 0x30 && c <= 0x39) // 0-9 |
| || (c >= 0x41 && c <= 0x5A) // a-z |
| || (c >= 0x61 && c <= 0x7A) // A-Z |
| || (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( ) |
| ) { |
| out += string.charAt(i); |
| continue; |
| } |
| |
| if (c < 0x80) { |
| out = out + hexTable[c]; |
| continue; |
| } |
| |
| if (c < 0x800) { |
| out = out + (hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)]); |
| continue; |
| } |
| |
| if (c < 0xD800 || c >= 0xE000) { |
| out = out + (hexTable[0xE0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)]); |
| continue; |
| } |
| |
| i += 1; |
| c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF)); |
| /* eslint operator-linebreak: [2, "before"] */ |
| out += hexTable[0xF0 | (c >> 18)] |
| + hexTable[0x80 | ((c >> 12) & 0x3F)] |
| + hexTable[0x80 | ((c >> 6) & 0x3F)] |
| + hexTable[0x80 | (c & 0x3F)]; |
| } |
| |
| return out; |
| }; |
| |
| var compact = function compact(value) { |
| var queue = [{ obj: { o: value }, prop: 'o' }]; |
| var refs = []; |
| |
| for (var i = 0; i < queue.length; ++i) { |
| var item = queue[i]; |
| var obj = item.obj[item.prop]; |
| |
| var keys = Object.keys(obj); |
| for (var j = 0; j < keys.length; ++j) { |
| var key = keys[j]; |
| var val = obj[key]; |
| if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) { |
| queue.push({ obj: obj, prop: key }); |
| refs.push(val); |
| } |
| } |
| } |
| |
| compactQueue(queue); |
| |
| return value; |
| }; |
| |
| var isRegExp = function isRegExp(obj) { |
| return Object.prototype.toString.call(obj) === '[object RegExp]'; |
| }; |
| |
| var isBuffer = function isBuffer(obj) { |
| if (!obj || typeof obj !== 'object') { |
| return false; |
| } |
| |
| return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); |
| }; |
| |
| var combine = function combine(a, b) { |
| return [].concat(a, b); |
| }; |
| |
| var maybeMap = function maybeMap(val, fn) { |
| if (isArray(val)) { |
| var mapped = []; |
| for (var i = 0; i < val.length; i += 1) { |
| mapped.push(fn(val[i])); |
| } |
| return mapped; |
| } |
| return fn(val); |
| }; |
| |
| module.exports = { |
| arrayToObject: arrayToObject, |
| assign: assign, |
| combine: combine, |
| compact: compact, |
| decode: decode, |
| encode: encode, |
| isBuffer: isBuffer, |
| isRegExp: isRegExp, |
| maybeMap: maybeMap, |
| merge: merge |
| }; |
| |
| },{"./formats":1}],6:[function(require,module,exports){ |
| |
| },{}],7:[function(require,module,exports){ |
| 'use strict'; |
| |
| var GetIntrinsic = require('get-intrinsic'); |
| |
| var callBind = require('./'); |
| |
| var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf')); |
| |
| module.exports = function callBoundIntrinsic(name, allowMissing) { |
| var intrinsic = GetIntrinsic(name, !!allowMissing); |
| if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { |
| return callBind(intrinsic); |
| } |
| return intrinsic; |
| }; |
| |
| },{"./":8,"get-intrinsic":11}],8:[function(require,module,exports){ |
| 'use strict'; |
| |
| var bind = require('function-bind'); |
| var GetIntrinsic = require('get-intrinsic'); |
| |
| var $apply = GetIntrinsic('%Function.prototype.apply%'); |
| var $call = GetIntrinsic('%Function.prototype.call%'); |
| var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply); |
| |
| var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true); |
| var $defineProperty = GetIntrinsic('%Object.defineProperty%', true); |
| var $max = GetIntrinsic('%Math.max%'); |
| |
| if ($defineProperty) { |
| try { |
| $defineProperty({}, 'a', { value: 1 }); |
| } catch (e) { |
| // IE 8 has a broken defineProperty |
| $defineProperty = null; |
| } |
| } |
| |
| module.exports = function callBind(originalFunction) { |
| var func = $reflectApply(bind, $call, arguments); |
| if ($gOPD && $defineProperty) { |
| var desc = $gOPD(func, 'length'); |
| if (desc.configurable) { |
| // original length, plus the receiver, minus any additional arguments (after the receiver) |
| $defineProperty( |
| func, |
| 'length', |
| { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) } |
| ); |
| } |
| } |
| return func; |
| }; |
| |
| var applyBind = function applyBind() { |
| return $reflectApply(bind, $apply, arguments); |
| }; |
| |
| if ($defineProperty) { |
| $defineProperty(module.exports, 'apply', { value: applyBind }); |
| } else { |
| module.exports.apply = applyBind; |
| } |
| |
| },{"function-bind":10,"get-intrinsic":11}],9:[function(require,module,exports){ |
| 'use strict'; |
| |
| /* eslint no-invalid-this: 1 */ |
| |
| var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; |
| var slice = Array.prototype.slice; |
| var toStr = Object.prototype.toString; |
| var funcType = '[object Function]'; |
| |
| module.exports = function bind(that) { |
| var target = this; |
| if (typeof target !== 'function' || toStr.call(target) !== funcType) { |
| throw new TypeError(ERROR_MESSAGE + target); |
| } |
| var args = slice.call(arguments, 1); |
| |
| var bound; |
| var binder = function () { |
| if (this instanceof bound) { |
| var result = target.apply( |
| this, |
| args.concat(slice.call(arguments)) |
| ); |
| if (Object(result) === result) { |
| return result; |
| } |
| return this; |
| } else { |
| return target.apply( |
| that, |
| args.concat(slice.call(arguments)) |
| ); |
| } |
| }; |
| |
| var boundLength = Math.max(0, target.length - args.length); |
| var boundArgs = []; |
| for (var i = 0; i < boundLength; i++) { |
| boundArgs.push('$' + i); |
| } |
| |
| bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder); |
| |
| if (target.prototype) { |
| var Empty = function Empty() {}; |
| Empty.prototype = target.prototype; |
| bound.prototype = new Empty(); |
| Empty.prototype = null; |
| } |
| |
| return bound; |
| }; |
| |
| },{}],10:[function(require,module,exports){ |
| 'use strict'; |
| |
| var implementation = require('./implementation'); |
| |
| module.exports = Function.prototype.bind || implementation; |
| |
| },{"./implementation":9}],11:[function(require,module,exports){ |
| 'use strict'; |
| |
| var undefined; |
| |
| var $SyntaxError = SyntaxError; |
| var $Function = Function; |
| var $TypeError = TypeError; |
| |
| // eslint-disable-next-line consistent-return |
| var getEvalledConstructor = function (expressionSyntax) { |
| try { |
| return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')(); |
| } catch (e) {} |
| }; |
| |
| var $gOPD = Object.getOwnPropertyDescriptor; |
| if ($gOPD) { |
| try { |
| $gOPD({}, ''); |
| } catch (e) { |
| $gOPD = null; // this is IE 8, which has a broken gOPD |
| } |
| } |
| |
| var throwTypeError = function () { |
| throw new $TypeError(); |
| }; |
| var ThrowTypeError = $gOPD |
| ? (function () { |
| try { |
| // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties |
| arguments.callee; // IE 8 does not throw here |
| return throwTypeError; |
| } catch (calleeThrows) { |
| try { |
| // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '') |
| return $gOPD(arguments, 'callee').get; |
| } catch (gOPDthrows) { |
| return throwTypeError; |
| } |
| } |
| }()) |
| : throwTypeError; |
| |
| var hasSymbols = require('has-symbols')(); |
| |
| var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto |
| |
| var needsEval = {}; |
| |
| var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array); |
| |
| var INTRINSICS = { |
| '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError, |
| '%Array%': Array, |
| '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, |
| '%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined, |
| '%AsyncFromSyncIteratorPrototype%': undefined, |
| '%AsyncFunction%': needsEval, |
| '%AsyncGenerator%': needsEval, |
| '%AsyncGeneratorFunction%': needsEval, |
| '%AsyncIteratorPrototype%': needsEval, |
| '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, |
| '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt, |
| '%Boolean%': Boolean, |
| '%DataView%': typeof DataView === 'undefined' ? undefined : DataView, |
| '%Date%': Date, |
| '%decodeURI%': decodeURI, |
| '%decodeURIComponent%': decodeURIComponent, |
| '%encodeURI%': encodeURI, |
| '%encodeURIComponent%': encodeURIComponent, |
| '%Error%': Error, |
| '%eval%': eval, // eslint-disable-line no-eval |
| '%EvalError%': EvalError, |
| '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, |
| '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, |
| '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry, |
| '%Function%': $Function, |
| '%GeneratorFunction%': needsEval, |
| '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, |
| '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, |
| '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, |
| '%isFinite%': isFinite, |
| '%isNaN%': isNaN, |
| '%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined, |
| '%JSON%': typeof JSON === 'object' ? JSON : undefined, |
| '%Map%': typeof Map === 'undefined' ? undefined : Map, |
| '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()), |
| '%Math%': Math, |
| '%Number%': Number, |
| '%Object%': Object, |
| '%parseFloat%': parseFloat, |
| '%parseInt%': parseInt, |
| '%Promise%': typeof Promise === 'undefined' ? undefined : Promise, |
| '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, |
| '%RangeError%': RangeError, |
| '%ReferenceError%': ReferenceError, |
| '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, |
| '%RegExp%': RegExp, |
| '%Set%': typeof Set === 'undefined' ? undefined : Set, |
| '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()), |
| '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, |
| '%String%': String, |
| '%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined, |
| '%Symbol%': hasSymbols ? Symbol : undefined, |
| '%SyntaxError%': $SyntaxError, |
| '%ThrowTypeError%': ThrowTypeError, |
| '%TypedArray%': TypedArray, |
| '%TypeError%': $TypeError, |
| '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, |
| '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, |
| '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, |
| '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, |
| '%URIError%': URIError, |
| '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, |
| '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef, |
| '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet |
| }; |
| |
| var doEval = function doEval(name) { |
| var value; |
| if (name === '%AsyncFunction%') { |
| value = getEvalledConstructor('async function () {}'); |
| } else if (name === '%GeneratorFunction%') { |
| value = getEvalledConstructor('function* () {}'); |
| } else if (name === '%AsyncGeneratorFunction%') { |
| value = getEvalledConstructor('async function* () {}'); |
| } else if (name === '%AsyncGenerator%') { |
| var fn = doEval('%AsyncGeneratorFunction%'); |
| if (fn) { |
| value = fn.prototype; |
| } |
| } else if (name === '%AsyncIteratorPrototype%') { |
| var gen = doEval('%AsyncGenerator%'); |
| if (gen) { |
| value = getProto(gen.prototype); |
| } |
| } |
| |
| INTRINSICS[name] = value; |
| |
| return value; |
| }; |
| |
| var LEGACY_ALIASES = { |
| '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'], |
| '%ArrayPrototype%': ['Array', 'prototype'], |
| '%ArrayProto_entries%': ['Array', 'prototype', 'entries'], |
| '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'], |
| '%ArrayProto_keys%': ['Array', 'prototype', 'keys'], |
| '%ArrayProto_values%': ['Array', 'prototype', 'values'], |
| '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'], |
| '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'], |
| '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'], |
| '%BooleanPrototype%': ['Boolean', 'prototype'], |
| '%DataViewPrototype%': ['DataView', 'prototype'], |
| '%DatePrototype%': ['Date', 'prototype'], |
| '%ErrorPrototype%': ['Error', 'prototype'], |
| '%EvalErrorPrototype%': ['EvalError', 'prototype'], |
| '%Float32ArrayPrototype%': ['Float32Array', 'prototype'], |
| '%Float64ArrayPrototype%': ['Float64Array', 'prototype'], |
| '%FunctionPrototype%': ['Function', 'prototype'], |
| '%Generator%': ['GeneratorFunction', 'prototype'], |
| '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'], |
| '%Int8ArrayPrototype%': ['Int8Array', 'prototype'], |
| '%Int16ArrayPrototype%': ['Int16Array', 'prototype'], |
| '%Int32ArrayPrototype%': ['Int32Array', 'prototype'], |
| '%JSONParse%': ['JSON', 'parse'], |
| '%JSONStringify%': ['JSON', 'stringify'], |
| '%MapPrototype%': ['Map', 'prototype'], |
| '%NumberPrototype%': ['Number', 'prototype'], |
| '%ObjectPrototype%': ['Object', 'prototype'], |
| '%ObjProto_toString%': ['Object', 'prototype', 'toString'], |
| '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'], |
| '%PromisePrototype%': ['Promise', 'prototype'], |
| '%PromiseProto_then%': ['Promise', 'prototype', 'then'], |
| '%Promise_all%': ['Promise', 'all'], |
| '%Promise_reject%': ['Promise', 'reject'], |
| '%Promise_resolve%': ['Promise', 'resolve'], |
| '%RangeErrorPrototype%': ['RangeError', 'prototype'], |
| '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'], |
| '%RegExpPrototype%': ['RegExp', 'prototype'], |
| '%SetPrototype%': ['Set', 'prototype'], |
| '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'], |
| '%StringPrototype%': ['String', 'prototype'], |
| '%SymbolPrototype%': ['Symbol', 'prototype'], |
| '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'], |
| '%TypedArrayPrototype%': ['TypedArray', 'prototype'], |
| '%TypeErrorPrototype%': ['TypeError', 'prototype'], |
| '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'], |
| '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'], |
| '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'], |
| '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'], |
| '%URIErrorPrototype%': ['URIError', 'prototype'], |
| '%WeakMapPrototype%': ['WeakMap', 'prototype'], |
| '%WeakSetPrototype%': ['WeakSet', 'prototype'] |
| }; |
| |
| var bind = require('function-bind'); |
| var hasOwn = require('has'); |
| var $concat = bind.call(Function.call, Array.prototype.concat); |
| var $spliceApply = bind.call(Function.apply, Array.prototype.splice); |
| var $replace = bind.call(Function.call, String.prototype.replace); |
| var $strSlice = bind.call(Function.call, String.prototype.slice); |
| |
| /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ |
| var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; |
| var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ |
| var stringToPath = function stringToPath(string) { |
| var first = $strSlice(string, 0, 1); |
| var last = $strSlice(string, -1); |
| if (first === '%' && last !== '%') { |
| throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`'); |
| } else if (last === '%' && first !== '%') { |
| throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`'); |
| } |
| var result = []; |
| $replace(string, rePropName, function (match, number, quote, subString) { |
| result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match; |
| }); |
| return result; |
| }; |
| /* end adaptation */ |
| |
| var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { |
| var intrinsicName = name; |
| var alias; |
| if (hasOwn(LEGACY_ALIASES, intrinsicName)) { |
| alias = LEGACY_ALIASES[intrinsicName]; |
| intrinsicName = '%' + alias[0] + '%'; |
| } |
| |
| if (hasOwn(INTRINSICS, intrinsicName)) { |
| var value = INTRINSICS[intrinsicName]; |
| if (value === needsEval) { |
| value = doEval(intrinsicName); |
| } |
| if (typeof value === 'undefined' && !allowMissing) { |
| throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); |
| } |
| |
| return { |
| alias: alias, |
| name: intrinsicName, |
| value: value |
| }; |
| } |
| |
| throw new $SyntaxError('intrinsic ' + name + ' does not exist!'); |
| }; |
| |
| module.exports = function GetIntrinsic(name, allowMissing) { |
| if (typeof name !== 'string' || name.length === 0) { |
| throw new $TypeError('intrinsic name must be a non-empty string'); |
| } |
| if (arguments.length > 1 && typeof allowMissing !== 'boolean') { |
| throw new $TypeError('"allowMissing" argument must be a boolean'); |
| } |
| |
| var parts = stringToPath(name); |
| var intrinsicBaseName = parts.length > 0 ? parts[0] : ''; |
| |
| var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing); |
| var intrinsicRealName = intrinsic.name; |
| var value = intrinsic.value; |
| var skipFurtherCaching = false; |
| |
| var alias = intrinsic.alias; |
| if (alias) { |
| intrinsicBaseName = alias[0]; |
| $spliceApply(parts, $concat([0, 1], alias)); |
| } |
| |
| for (var i = 1, isOwn = true; i < parts.length; i += 1) { |
| var part = parts[i]; |
| var first = $strSlice(part, 0, 1); |
| var last = $strSlice(part, -1); |
| if ( |
| ( |
| (first === '"' || first === "'" || first === '`') |
| || (last === '"' || last === "'" || last === '`') |
| ) |
| && first !== last |
| ) { |
| throw new $SyntaxError('property names with quotes must have matching quotes'); |
| } |
| if (part === 'constructor' || !isOwn) { |
| skipFurtherCaching = true; |
| } |
| |
| intrinsicBaseName += '.' + part; |
| intrinsicRealName = '%' + intrinsicBaseName + '%'; |
| |
| if (hasOwn(INTRINSICS, intrinsicRealName)) { |
| value = INTRINSICS[intrinsicRealName]; |
| } else if (value != null) { |
| if (!(part in value)) { |
| if (!allowMissing) { |
| throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.'); |
| } |
| return void undefined; |
| } |
| if ($gOPD && (i + 1) >= parts.length) { |
| var desc = $gOPD(value, part); |
| isOwn = !!desc; |
| |
| // By convention, when a data property is converted to an accessor |
| // property to emulate a data property that does not suffer from |
| // the override mistake, that accessor's getter is marked with |
| // an `originalValue` property. Here, when we detect this, we |
| // uphold the illusion by pretending to see that original data |
| // property, i.e., returning the value rather than the getter |
| // itself. |
| if (isOwn && 'get' in desc && !('originalValue' in desc.get)) { |
| value = desc.get; |
| } else { |
| value = value[part]; |
| } |
| } else { |
| isOwn = hasOwn(value, part); |
| value = value[part]; |
| } |
| |
| if (isOwn && !skipFurtherCaching) { |
| INTRINSICS[intrinsicRealName] = value; |
| } |
| } |
| } |
| return value; |
| }; |
| |
| },{"function-bind":10,"has":14,"has-symbols":12}],12:[function(require,module,exports){ |
| 'use strict'; |
| |
| var origSymbol = typeof Symbol !== 'undefined' && Symbol; |
| var hasSymbolSham = require('./shams'); |
| |
| module.exports = function hasNativeSymbols() { |
| if (typeof origSymbol !== 'function') { return false; } |
| if (typeof Symbol !== 'function') { return false; } |
| if (typeof origSymbol('foo') !== 'symbol') { return false; } |
| if (typeof Symbol('bar') !== 'symbol') { return false; } |
| |
| return hasSymbolSham(); |
| }; |
| |
| },{"./shams":13}],13:[function(require,module,exports){ |
| 'use strict'; |
| |
| /* eslint complexity: [2, 18], max-statements: [2, 33] */ |
| module.exports = function hasSymbols() { |
| if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } |
| if (typeof Symbol.iterator === 'symbol') { return true; } |
| |
| var obj = {}; |
| var sym = Symbol('test'); |
| var symObj = Object(sym); |
| if (typeof sym === 'string') { return false; } |
| |
| if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } |
| if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } |
| |
| // temp disabled per https://github.com/ljharb/object.assign/issues/17 |
| // if (sym instanceof Symbol) { return false; } |
| // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 |
| // if (!(symObj instanceof Symbol)) { return false; } |
| |
| // if (typeof Symbol.prototype.toString !== 'function') { return false; } |
| // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } |
| |
| var symVal = 42; |
| obj[sym] = symVal; |
| for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop |
| if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } |
| |
| if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } |
| |
| var syms = Object.getOwnPropertySymbols(obj); |
| if (syms.length !== 1 || syms[0] !== sym) { return false; } |
| |
| if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } |
| |
| if (typeof Object.getOwnPropertyDescriptor === 'function') { |
| var descriptor = Object.getOwnPropertyDescriptor(obj, sym); |
| if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } |
| } |
| |
| return true; |
| }; |
| |
| },{}],14:[function(require,module,exports){ |
| 'use strict'; |
| |
| var bind = require('function-bind'); |
| |
| module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); |
| |
| },{"function-bind":10}],15:[function(require,module,exports){ |
| var hasMap = typeof Map === 'function' && Map.prototype; |
| var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null; |
| var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null; |
| var mapForEach = hasMap && Map.prototype.forEach; |
| var hasSet = typeof Set === 'function' && Set.prototype; |
| var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null; |
| var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null; |
| var setForEach = hasSet && Set.prototype.forEach; |
| var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype; |
| var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null; |
| var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype; |
| var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null; |
| var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype; |
| var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null; |
| var booleanValueOf = Boolean.prototype.valueOf; |
| var objectToString = Object.prototype.toString; |
| var functionToString = Function.prototype.toString; |
| var $match = String.prototype.match; |
| var $slice = String.prototype.slice; |
| var $replace = String.prototype.replace; |
| var $toUpperCase = String.prototype.toUpperCase; |
| var $toLowerCase = String.prototype.toLowerCase; |
| var $test = RegExp.prototype.test; |
| var $concat = Array.prototype.concat; |
| var $join = Array.prototype.join; |
| var $arrSlice = Array.prototype.slice; |
| var $floor = Math.floor; |
| var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null; |
| var gOPS = Object.getOwnPropertySymbols; |
| var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null; |
| var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object'; |
| // ie, `has-tostringtag/shams |
| var toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol') |
| ? Symbol.toStringTag |
| : null; |
| var isEnumerable = Object.prototype.propertyIsEnumerable; |
| |
| var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ( |
| [].__proto__ === Array.prototype // eslint-disable-line no-proto |
| ? function (O) { |
| return O.__proto__; // eslint-disable-line no-proto |
| } |
| : null |
| ); |
| |
| function addNumericSeparator(num, str) { |
| if ( |
| num === Infinity |
| || num === -Infinity |
| || num !== num |
| || (num && num > -1000 && num < 1000) |
| || $test.call(/e/, str) |
| ) { |
| return str; |
| } |
| var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g; |
| if (typeof num === 'number') { |
| var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num) |
| if (int !== num) { |
| var intStr = String(int); |
| var dec = $slice.call(str, intStr.length + 1); |
| return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, ''); |
| } |
| } |
| return $replace.call(str, sepRegex, '$&_'); |
| } |
| |
| var utilInspect = require('./util.inspect'); |
| var inspectCustom = utilInspect.custom; |
| var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null; |
| |
| module.exports = function inspect_(obj, options, depth, seen) { |
| var opts = options || {}; |
| |
| if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) { |
| throw new TypeError('option "quoteStyle" must be "single" or "double"'); |
| } |
| if ( |
| has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number' |
| ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity |
| : opts.maxStringLength !== null |
| ) |
| ) { |
| throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`'); |
| } |
| var customInspect = has(opts, 'customInspect') ? opts.customInspect : true; |
| if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') { |
| throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`'); |
| } |
| |
| if ( |
| has(opts, 'indent') |
| && opts.indent !== null |
| && opts.indent !== '\t' |
| && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0) |
| ) { |
| throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`'); |
| } |
| if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') { |
| throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`'); |
| } |
| var numericSeparator = opts.numericSeparator; |
| |
| if (typeof obj === 'undefined') { |
| return 'undefined'; |
| } |
| if (obj === null) { |
| return 'null'; |
| } |
| if (typeof obj === 'boolean') { |
| return obj ? 'true' : 'false'; |
| } |
| |
| if (typeof obj === 'string') { |
| return inspectString(obj, opts); |
| } |
| if (typeof obj === 'number') { |
| if (obj === 0) { |
| return Infinity / obj > 0 ? '0' : '-0'; |
| } |
| var str = String(obj); |
| return numericSeparator ? addNumericSeparator(obj, str) : str; |
| } |
| if (typeof obj === 'bigint') { |
| var bigIntStr = String(obj) + 'n'; |
| return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr; |
| } |
| |
| var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth; |
| if (typeof depth === 'undefined') { depth = 0; } |
| if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') { |
| return isArray(obj) ? '[Array]' : '[Object]'; |
| } |
| |
| var indent = getIndent(opts, depth); |
| |
| if (typeof seen === 'undefined') { |
| seen = []; |
| } else if (indexOf(seen, obj) >= 0) { |
| return '[Circular]'; |
| } |
| |
| function inspect(value, from, noIndent) { |
| if (from) { |
| seen = $arrSlice.call(seen); |
| seen.push(from); |
| } |
| if (noIndent) { |
| var newOpts = { |
| depth: opts.depth |
| }; |
| if (has(opts, 'quoteStyle')) { |
| newOpts.quoteStyle = opts.quoteStyle; |
| } |
| return inspect_(value, newOpts, depth + 1, seen); |
| } |
| return inspect_(value, opts, depth + 1, seen); |
| } |
| |
| if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable |
| var name = nameOf(obj); |
| var keys = arrObjKeys(obj, inspect); |
| return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : ''); |
| } |
| if (isSymbol(obj)) { |
| var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, '$1') : symToString.call(obj); |
| return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString; |
| } |
| if (isElement(obj)) { |
| var s = '<' + $toLowerCase.call(String(obj.nodeName)); |
| var attrs = obj.attributes || []; |
| for (var i = 0; i < attrs.length; i++) { |
| s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts); |
| } |
| s += '>'; |
| if (obj.childNodes && obj.childNodes.length) { s += '...'; } |
| s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>'; |
| return s; |
| } |
| if (isArray(obj)) { |
| if (obj.length === 0) { return '[]'; } |
| var xs = arrObjKeys(obj, inspect); |
| if (indent && !singleLineValues(xs)) { |
| return '[' + indentedJoin(xs, indent) + ']'; |
| } |
| return '[ ' + $join.call(xs, ', ') + ' ]'; |
| } |
| if (isError(obj)) { |
| var parts = arrObjKeys(obj, inspect); |
| if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) { |
| return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }'; |
| } |
| if (parts.length === 0) { return '[' + String(obj) + ']'; } |
| return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }'; |
| } |
| if (typeof obj === 'object' && customInspect) { |
| if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) { |
| return utilInspect(obj, { depth: maxDepth - depth }); |
| } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') { |
| return obj.inspect(); |
| } |
| } |
| if (isMap(obj)) { |
| var mapParts = []; |
| mapForEach.call(obj, function (value, key) { |
| mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj)); |
| }); |
| return collectionOf('Map', mapSize.call(obj), mapParts, indent); |
| } |
| if (isSet(obj)) { |
| var setParts = []; |
| setForEach.call(obj, function (value) { |
| setParts.push(inspect(value, obj)); |
| }); |
| return collectionOf('Set', setSize.call(obj), setParts, indent); |
| } |
| if (isWeakMap(obj)) { |
| return weakCollectionOf('WeakMap'); |
| } |
| if (isWeakSet(obj)) { |
| return weakCollectionOf('WeakSet'); |
| } |
| if (isWeakRef(obj)) { |
| return weakCollectionOf('WeakRef'); |
| } |
| if (isNumber(obj)) { |
| return markBoxed(inspect(Number(obj))); |
| } |
| if (isBigInt(obj)) { |
| return markBoxed(inspect(bigIntValueOf.call(obj))); |
| } |
| if (isBoolean(obj)) { |
| return markBoxed(booleanValueOf.call(obj)); |
| } |
| if (isString(obj)) { |
| return markBoxed(inspect(String(obj))); |
| } |
| if (!isDate(obj) && !isRegExp(obj)) { |
| var ys = arrObjKeys(obj, inspect); |
| var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object; |
| var protoTag = obj instanceof Object ? '' : 'null prototype'; |
| var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : ''; |
| var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : ''; |
| var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : ''); |
| if (ys.length === 0) { return tag + '{}'; } |
| if (indent) { |
| return tag + '{' + indentedJoin(ys, indent) + '}'; |
| } |
| return tag + '{ ' + $join.call(ys, ', ') + ' }'; |
| } |
| return String(obj); |
| }; |
| |
| function wrapQuotes(s, defaultStyle, opts) { |
| var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'"; |
| return quoteChar + s + quoteChar; |
| } |
| |
| function quote(s) { |
| return $replace.call(String(s), /"/g, '"'); |
| } |
| |
| function isArray(obj) { return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| function isDate(obj) { return toStr(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| function isRegExp(obj) { return toStr(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| function isError(obj) { return toStr(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| function isString(obj) { return toStr(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| function isNumber(obj) { return toStr(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| function isBoolean(obj) { return toStr(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); } |
| |
| // Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives |
| function isSymbol(obj) { |
| if (hasShammedSymbols) { |
| return obj && typeof obj === 'object' && obj instanceof Symbol; |
| } |
| if (typeof obj === 'symbol') { |
| return true; |
| } |
| if (!obj || typeof obj !== 'object' || !symToString) { |
| return false; |
| } |
| try { |
| symToString.call(obj); |
| return true; |
| } catch (e) {} |
| return false; |
| } |
| |
| function isBigInt(obj) { |
| if (!obj || typeof obj !== 'object' || !bigIntValueOf) { |
| return false; |
| } |
| try { |
| bigIntValueOf.call(obj); |
| return true; |
| } catch (e) {} |
| return false; |
| } |
| |
| var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; }; |
| function has(obj, key) { |
| return hasOwn.call(obj, key); |
| } |
| |
| function toStr(obj) { |
| return objectToString.call(obj); |
| } |
| |
| function nameOf(f) { |
| if (f.name) { return f.name; } |
| var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/); |
| if (m) { return m[1]; } |
| return null; |
| } |
| |
| function indexOf(xs, x) { |
| if (xs.indexOf) { return xs.indexOf(x); } |
| for (var i = 0, l = xs.length; i < l; i++) { |
| if (xs[i] === x) { return i; } |
| } |
| return -1; |
| } |
| |
| function isMap(x) { |
| if (!mapSize || !x || typeof x !== 'object') { |
| return false; |
| } |
| try { |
| mapSize.call(x); |
| try { |
| setSize.call(x); |
| } catch (s) { |
| return true; |
| } |
| return x instanceof Map; // core-js workaround, pre-v2.5.0 |
| } catch (e) {} |
| return false; |
| } |
| |
| function isWeakMap(x) { |
| if (!weakMapHas || !x || typeof x !== 'object') { |
| return false; |
| } |
| try { |
| weakMapHas.call(x, weakMapHas); |
| try { |
| weakSetHas.call(x, weakSetHas); |
| } catch (s) { |
| return true; |
| } |
| return x instanceof WeakMap; // core-js workaround, pre-v2.5.0 |
| } catch (e) {} |
| return false; |
| } |
| |
| function isWeakRef(x) { |
| if (!weakRefDeref || !x || typeof x !== 'object') { |
| return false; |
| } |
| try { |
| weakRefDeref.call(x); |
| return true; |
| } catch (e) {} |
| return false; |
| } |
| |
| function isSet(x) { |
| if (!setSize || !x || typeof x !== 'object') { |
| return false; |
| } |
| try { |
| setSize.call(x); |
| try { |
| mapSize.call(x); |
| } catch (m) { |
| return true; |
| } |
| return x instanceof Set; // core-js workaround, pre-v2.5.0 |
| } catch (e) {} |
| return false; |
| } |
| |
| function isWeakSet(x) { |
| if (!weakSetHas || !x || typeof x !== 'object') { |
| return false; |
| } |
| try { |
| weakSetHas.call(x, weakSetHas); |
| try { |
| weakMapHas.call(x, weakMapHas); |
| } catch (s) { |
| return true; |
| } |
| return x instanceof WeakSet; // core-js workaround, pre-v2.5.0 |
| } catch (e) {} |
| return false; |
| } |
| |
| function isElement(x) { |
| if (!x || typeof x !== 'object') { return false; } |
| if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) { |
| return true; |
| } |
| return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function'; |
| } |
| |
| function inspectString(str, opts) { |
| if (str.length > opts.maxStringLength) { |
| var remaining = str.length - opts.maxStringLength; |
| var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : ''); |
| return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer; |
| } |
| // eslint-disable-next-line no-control-regex |
| var s = $replace.call($replace.call(str, /(['\\])/g, '\\$1'), /[\x00-\x1f]/g, lowbyte); |
| return wrapQuotes(s, 'single', opts); |
| } |
| |
| function lowbyte(c) { |
| var n = c.charCodeAt(0); |
| var x = { |
| 8: 'b', |
| 9: 't', |
| 10: 'n', |
| 12: 'f', |
| 13: 'r' |
| }[n]; |
| if (x) { return '\\' + x; } |
| return '\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16)); |
| } |
| |
| function markBoxed(str) { |
| return 'Object(' + str + ')'; |
| } |
| |
| function weakCollectionOf(type) { |
| return type + ' { ? }'; |
| } |
| |
| function collectionOf(type, size, entries, indent) { |
| var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', '); |
| return type + ' (' + size + ') {' + joinedEntries + '}'; |
| } |
| |
| function singleLineValues(xs) { |
| for (var i = 0; i < xs.length; i++) { |
| if (indexOf(xs[i], '\n') >= 0) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| function getIndent(opts, depth) { |
| var baseIndent; |
| if (opts.indent === '\t') { |
| baseIndent = '\t'; |
| } else if (typeof opts.indent === 'number' && opts.indent > 0) { |
| baseIndent = $join.call(Array(opts.indent + 1), ' '); |
| } else { |
| return null; |
| } |
| return { |
| base: baseIndent, |
| prev: $join.call(Array(depth + 1), baseIndent) |
| }; |
| } |
| |
| function indentedJoin(xs, indent) { |
| if (xs.length === 0) { return ''; } |
| var lineJoiner = '\n' + indent.prev + indent.base; |
| return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev; |
| } |
| |
| function arrObjKeys(obj, inspect) { |
| var isArr = isArray(obj); |
| var xs = []; |
| if (isArr) { |
| xs.length = obj.length; |
| for (var i = 0; i < obj.length; i++) { |
| xs[i] = has(obj, i) ? inspect(obj[i], obj) : ''; |
| } |
| } |
| var syms = typeof gOPS === 'function' ? gOPS(obj) : []; |
| var symMap; |
| if (hasShammedSymbols) { |
| symMap = {}; |
| for (var k = 0; k < syms.length; k++) { |
| symMap['$' + syms[k]] = syms[k]; |
| } |
| } |
| |
| for (var key in obj) { // eslint-disable-line no-restricted-syntax |
| if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue |
| if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue |
| if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) { |
| // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section |
| continue; // eslint-disable-line no-restricted-syntax, no-continue |
| } else if ($test.call(/[^\w$]/, key)) { |
| xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj)); |
| } else { |
| xs.push(key + ': ' + inspect(obj[key], obj)); |
| } |
| } |
| if (typeof gOPS === 'function') { |
| for (var j = 0; j < syms.length; j++) { |
| if (isEnumerable.call(obj, syms[j])) { |
| xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj)); |
| } |
| } |
| } |
| return xs; |
| } |
| |
| },{"./util.inspect":6}],16:[function(require,module,exports){ |
| 'use strict'; |
| |
| var GetIntrinsic = require('get-intrinsic'); |
| var callBound = require('call-bind/callBound'); |
| var inspect = require('object-inspect'); |
| |
| var $TypeError = GetIntrinsic('%TypeError%'); |
| var $WeakMap = GetIntrinsic('%WeakMap%', true); |
| var $Map = GetIntrinsic('%Map%', true); |
| |
| var $weakMapGet = callBound('WeakMap.prototype.get', true); |
| var $weakMapSet = callBound('WeakMap.prototype.set', true); |
| var $weakMapHas = callBound('WeakMap.prototype.has', true); |
| var $mapGet = callBound('Map.prototype.get', true); |
| var $mapSet = callBound('Map.prototype.set', true); |
| var $mapHas = callBound('Map.prototype.has', true); |
| |
| /* |
| * This function traverses the list returning the node corresponding to the |
| * given key. |
| * |
| * That node is also moved to the head of the list, so that if it's accessed |
| * again we don't need to traverse the whole list. By doing so, all the recently |
| * used nodes can be accessed relatively quickly. |
| */ |
| var listGetNode = function (list, key) { // eslint-disable-line consistent-return |
| for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) { |
| if (curr.key === key) { |
| prev.next = curr.next; |
| curr.next = list.next; |
| list.next = curr; // eslint-disable-line no-param-reassign |
| return curr; |
| } |
| } |
| }; |
| |
| var listGet = function (objects, key) { |
| var node = listGetNode(objects, key); |
| return node && node.value; |
| }; |
| var listSet = function (objects, key, value) { |
| var node = listGetNode(objects, key); |
| if (node) { |
| node.value = value; |
| } else { |
| // Prepend the new node to the beginning of the list |
| objects.next = { // eslint-disable-line no-param-reassign |
| key: key, |
| next: objects.next, |
| value: value |
| }; |
| } |
| }; |
| var listHas = function (objects, key) { |
| return !!listGetNode(objects, key); |
| }; |
| |
| module.exports = function getSideChannel() { |
| var $wm; |
| var $m; |
| var $o; |
| var channel = { |
| assert: function (key) { |
| if (!channel.has(key)) { |
| throw new $TypeError('Side channel does not contain ' + inspect(key)); |
| } |
| }, |
| get: function (key) { // eslint-disable-line consistent-return |
| if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) { |
| if ($wm) { |
| return $weakMapGet($wm, key); |
| } |
| } else if ($Map) { |
| if ($m) { |
| return $mapGet($m, key); |
| } |
| } else { |
| if ($o) { // eslint-disable-line no-lonely-if |
| return listGet($o, key); |
| } |
| } |
| }, |
| has: function (key) { |
| if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) { |
| if ($wm) { |
| return $weakMapHas($wm, key); |
| } |
| } else if ($Map) { |
| if ($m) { |
| return $mapHas($m, key); |
| } |
| } else { |
| if ($o) { // eslint-disable-line no-lonely-if |
| return listHas($o, key); |
| } |
| } |
| return false; |
| }, |
| set: function (key, value) { |
| if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) { |
| if (!$wm) { |
| $wm = new $WeakMap(); |
| } |
| $weakMapSet($wm, key, value); |
| } else if ($Map) { |
| if (!$m) { |
| $m = new $Map(); |
| } |
| $mapSet($m, key, value); |
| } else { |
| if (!$o) { |
| /* |
| * Initialize the linked list as an empty node, so that we don't have |
| * to special-case handling of the first node: we can always refer to |
| * it as (previous node).next, instead of something like (list).head |
| */ |
| $o = { key: {}, next: null }; |
| } |
| listSet($o, key, value); |
| } |
| } |
| }; |
| return channel; |
| }; |
| |
| },{"call-bind/callBound":7,"get-intrinsic":11,"object-inspect":15}]},{},[2])(2) |
| }); |
