| (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){ |
| module.exports = { |
| VERSION: '%KARMA_VERSION%', |
| KARMA_URL_ROOT: '%KARMA_URL_ROOT%', |
| KARMA_PROXY_PATH: '%KARMA_PROXY_PATH%', |
| BROWSER_SOCKET_TIMEOUT: '%BROWSER_SOCKET_TIMEOUT%', |
| CONTEXT_URL: 'context.html' |
| } |
| |
| },{}],2:[function(require,module,exports){ |
| var stringify = require('../common/stringify') |
| var constant = require('./constants') |
| var util = require('../common/util') |
| |
| function Karma (socket, iframe, opener, navigator, location) { |
| var startEmitted = false |
| var reloadingContext = false |
| var self = this |
| var queryParams = util.parseQueryParams(location.search) |
| var browserId = queryParams.id || util.generateId('manual-') |
| var displayName = queryParams.displayName |
| var returnUrl = queryParams['return_url' + ''] || null |
| |
| var resultsBufferLimit = 50 |
| var resultsBuffer = [] |
| |
| // This variable will be set to "true" whenever the socket lost connection and was able to |
| // reconnect to the Karma server. This will be passed to the Karma server then, so that |
| // Karma can differentiate between a socket client reconnect and a full browser reconnect. |
| var socketReconnect = false |
| |
| this.VERSION = constant.VERSION |
| this.config = {} |
| |
| // Expose for testing purposes as there is no global socket.io |
| // registry anymore. |
| this.socket = socket |
| |
| // Set up postMessage bindings for current window |
| // DEV: These are to allow windows in separate processes execute local tasks |
| // Electron is one of these environments |
| if (window.addEventListener) { |
| window.addEventListener('message', function handleMessage (evt) { |
| // Resolve the origin of our message |
| var origin = evt.origin || evt.originalEvent.origin |
| |
| // If the message isn't from our host, then reject it |
| if (origin !== window.location.origin) { |
| return |
| } |
| |
| // Take action based on the message type |
| var method = evt.data.__karmaMethod |
| if (method) { |
| if (!self[method]) { |
| self.error('Received `postMessage` for "' + method + '" but the method doesn\'t exist') |
| return |
| } |
| self[method].apply(self, evt.data.__karmaArguments) |
| } |
| }, false) |
| } |
| |
| var childWindow = null |
| function navigateContextTo (url) { |
| if (self.config.useIframe === false) { |
| // run in new window |
| if (self.config.runInParent === false) { |
| // If there is a window already open, then close it |
| // DEV: In some environments (e.g. Electron), we don't have setter access for location |
| if (childWindow !== null && childWindow.closed !== true) { |
| childWindow.close() |
| } |
| childWindow = opener(url) |
| // run context on parent element (client_with_context) |
| // using window.__karma__.scriptUrls to get the html element strings and load them dynamically |
| } else if (url !== 'about:blank') { |
| var loadScript = function (idx) { |
| if (idx < window.__karma__.scriptUrls.length) { |
| var parser = new DOMParser() |
| // Revert escaped characters with special roles in HTML before parsing |
| var string = window.__karma__.scriptUrls[idx] |
| .replace(/\\x3C/g, '<') |
| .replace(/\\x3E/g, '>') |
| var doc = parser.parseFromString(string, 'text/html') |
| var ele = doc.head.firstChild || doc.body.firstChild |
| // script elements created by DomParser are marked as unexecutable, |
| // create a new script element manually and copy necessary properties |
| // so it is executable |
| if (ele.tagName && ele.tagName.toLowerCase() === 'script') { |
| var tmp = ele |
| ele = document.createElement('script') |
| ele.src = tmp.src |
| ele.crossOrigin = tmp.crossOrigin |
| } |
| ele.onload = function () { |
| loadScript(idx + 1) |
| } |
| document.body.appendChild(ele) |
| } else { |
| window.__karma__.loaded() |
| } |
| } |
| loadScript(0) |
| } |
| // run in iframe |
| } else { |
| iframe.src = url |
| } |
| } |
| |
| this.onbeforeunload = function () { |
| if (!reloadingContext) { |
| // TODO(vojta): show what test (with explanation about jasmine.UPDATE_INTERVAL) |
| self.error('Some of your tests did a full page reload!') |
| } |
| } |
| |
| this.log = function (type, args) { |
| var values = [] |
| |
| for (var i = 0; i < args.length; i++) { |
| values.push(this.stringify(args[i], 3)) |
| } |
| |
| this.info({ log: values.join(', '), type: type }) |
| } |
| |
| this.stringify = stringify |
| |
| function clearContext () { |
| reloadingContext = true |
| |
| navigateContextTo('about:blank') |
| } |
| |
| function getLocation (url, lineno, colno) { |
| var location = '' |
| |
| if (url !== undefined) { |
| location += url |
| } |
| |
| if (lineno !== undefined) { |
| location += ':' + lineno |
| } |
| |
| if (colno !== undefined) { |
| location += ':' + colno |
| } |
| |
| return location |
| } |
| |
| // error during js file loading (most likely syntax error) |
| // we are not going to execute at all. `window.onerror` callback. |
| this.error = function (messageOrEvent, source, lineno, colno, error) { |
| var message |
| if (typeof messageOrEvent === 'string') { |
| message = messageOrEvent |
| |
| var location = getLocation(source, lineno, colno) |
| if (location !== '') { |
| message += '\nat ' + location |
| } |
| if (error && error.stack) { |
| message += '\n\n' + error.stack |
| } |
| } else { |
| // create an object with the string representation of the message to |
| // ensure all its content is properly transferred to the console log |
| message = { message: messageOrEvent, str: messageOrEvent.toString() } |
| } |
| |
| socket.emit('karma_error', message) |
| this.complete() |
| return false |
| } |
| |
| this.result = function (originalResult) { |
| var convertedResult = {} |
| |
| // Convert all array-like objects to real arrays. |
| for (var propertyName in originalResult) { |
| if (originalResult.hasOwnProperty(propertyName)) { |
| var propertyValue = originalResult[propertyName] |
| |
| if (Object.prototype.toString.call(propertyValue) === '[object Array]') { |
| convertedResult[propertyName] = Array.prototype.slice.call(propertyValue) |
| } else { |
| convertedResult[propertyName] = propertyValue |
| } |
| } |
| } |
| |
| if (!startEmitted) { |
| socket.emit('start', { total: null }) |
| startEmitted = true |
| } |
| |
| if (resultsBufferLimit === 1) { |
| return socket.emit('result', convertedResult) |
| } |
| |
| resultsBuffer.push(convertedResult) |
| |
| if (resultsBuffer.length === resultsBufferLimit) { |
| socket.emit('result', resultsBuffer) |
| resultsBuffer = [] |
| } |
| } |
| |
| this.complete = function (result) { |
| if (resultsBuffer.length) { |
| socket.emit('result', resultsBuffer) |
| resultsBuffer = [] |
| } |
| |
| if (self.config.clearContext) { |
| // give the browser some time to breath, there could be a page reload, but because a bunch of |
| // tests could run in the same event loop, we wouldn't notice. |
| setTimeout(function () { |
| clearContext() |
| }, 0) |
| } |
| |
| socket.emit('complete', result || {}, function () { |
| if (returnUrl) { |
| location.href = returnUrl |
| } |
| }) |
| } |
| |
| this.info = function (info) { |
| // TODO(vojta): introduce special API for this |
| if (!startEmitted && util.isDefined(info.total)) { |
| socket.emit('start', info) |
| startEmitted = true |
| } else { |
| socket.emit('info', info) |
| } |
| } |
| |
| socket.on('execute', function (cfg) { |
| // reset startEmitted and reload the iframe |
| startEmitted = false |
| self.config = cfg |
| // if not clearing context, reloadingContext always true to prevent beforeUnload error |
| reloadingContext = !self.config.clearContext |
| navigateContextTo(constant.CONTEXT_URL) |
| |
| // clear the console before run |
| // works only on FF (Safari, Chrome do not allow to clear console from js source) |
| if (window.console && window.console.clear) { |
| window.console.clear() |
| } |
| }) |
| socket.on('stop', function () { |
| this.complete() |
| }.bind(this)) |
| |
| // Report the browser name and Id. Note that this event can also fire if the connection has |
| // been temporarily lost, but the socket reconnected automatically. Read more in the docs: |
| // https://socket.io/docs/client-api/#Event-%E2%80%98connect%E2%80%99 |
| socket.on('connect', function () { |
| socket.io.engine.on('upgrade', function () { |
| resultsBufferLimit = 1 |
| }) |
| var info = { |
| name: navigator.userAgent, |
| id: browserId, |
| isSocketReconnect: socketReconnect |
| } |
| if (displayName) { |
| info.displayName = displayName |
| } |
| socket.emit('register', info) |
| }) |
| |
| socket.on('reconnect', function () { |
| socketReconnect = true |
| }) |
| } |
| |
| module.exports = Karma |
| |
| },{"../common/stringify":5,"../common/util":6,"./constants":1}],3:[function(require,module,exports){ |
| /* global io */ |
| /* eslint-disable no-new */ |
| |
| require('core-js/stable') |
| var Karma = require('./karma') |
| var StatusUpdater = require('./updater') |
| var util = require('../common/util') |
| var constants = require('./constants') |
| |
| var KARMA_URL_ROOT = constants.KARMA_URL_ROOT |
| var KARMA_PROXY_PATH = constants.KARMA_PROXY_PATH |
| var BROWSER_SOCKET_TIMEOUT = constants.BROWSER_SOCKET_TIMEOUT |
| |
| // Connect to the server using socket.io http://socket.io |
| var socket = io(location.host, { |
| reconnectionDelay: 500, |
| reconnectionDelayMax: Infinity, |
| timeout: BROWSER_SOCKET_TIMEOUT, |
| path: KARMA_PROXY_PATH + KARMA_URL_ROOT.substr(1) + 'socket.io', |
| 'sync disconnect on unload': true |
| }) |
| |
| // instantiate the updater of the view |
| new StatusUpdater(socket, util.elm('title'), util.elm('banner'), util.elm('browsers')) |
| window.karma = new Karma(socket, util.elm('context'), window.open, |
| window.navigator, window.location) |
| |
| },{"../common/util":6,"./constants":1,"./karma":2,"./updater":4,"core-js/stable":363}],4:[function(require,module,exports){ |
| var VERSION = require('./constants').VERSION |
| |
| function StatusUpdater (socket, titleElement, bannerElement, browsersElement) { |
| function updateBrowsersInfo (browsers) { |
| if (!browsersElement) { |
| return |
| } |
| var items = [] |
| var status |
| for (var i = 0; i < browsers.length; i++) { |
| status = browsers[i].isConnected ? 'idle' : 'executing' |
| items.push('<li class="' + status + '">' + browsers[i].name + ' is ' + status + '</li>') |
| } |
| browsersElement.innerHTML = items.join('\n') |
| } |
| |
| function updateBanner (status) { |
| return function (param) { |
| if (!titleElement || !bannerElement) { |
| return |
| } |
| var paramStatus = param ? status.replace('$', param) : status |
| titleElement.innerHTML = 'Karma v' + VERSION + ' - ' + paramStatus |
| bannerElement.className = status === 'connected' ? 'online' : 'offline' |
| } |
| } |
| |
| socket.on('connect', updateBanner('connected')) |
| socket.on('disconnect', updateBanner('disconnected')) |
| socket.on('reconnecting', updateBanner('reconnecting in $ seconds...')) |
| socket.on('reconnect', updateBanner('connected')) |
| socket.on('reconnect_failed', updateBanner('failed to reconnect')) |
| socket.on('info', updateBrowsersInfo) |
| socket.on('disconnect', function () { |
| updateBrowsersInfo([]) |
| }) |
| } |
| |
| module.exports = StatusUpdater |
| |
| },{"./constants":1}],5:[function(require,module,exports){ |
| var serialize = require('dom-serialize') |
| var instanceOf = require('./util').instanceOf |
| |
| function isNode (obj) { |
| return (obj.tagName || obj.nodeName) && obj.nodeType |
| } |
| |
| function stringify (obj, depth) { |
| if (depth === 0) { |
| return '...' |
| } |
| |
| if (obj === null) { |
| return 'null' |
| } |
| |
| switch (typeof obj) { |
| case 'symbol': |
| return obj.toString() |
| case 'string': |
| return "'" + obj + "'" |
| case 'undefined': |
| return 'undefined' |
| case 'function': |
| try { |
| // function abc(a, b, c) { /* code goes here */ } |
| // -> function abc(a, b, c) { ... } |
| return obj.toString().replace(/\{[\s\S]*\}/, '{ ... }') |
| } catch (err) { |
| if (err instanceof TypeError) { |
| // Support older browsers |
| return 'function ' + (obj.name || '') + '() { ... }' |
| } else { |
| throw err |
| } |
| } |
| case 'boolean': |
| return obj ? 'true' : 'false' |
| case 'object': |
| var strs = [] |
| if (instanceOf(obj, 'Array')) { |
| strs.push('[') |
| for (var i = 0, ii = obj.length; i < ii; i++) { |
| if (i) { |
| strs.push(', ') |
| } |
| strs.push(stringify(obj[i], depth - 1)) |
| } |
| strs.push(']') |
| } else if (instanceOf(obj, 'Date')) { |
| return obj.toString() |
| } else if (instanceOf(obj, 'Text')) { |
| return obj.nodeValue |
| } else if (instanceOf(obj, 'Comment')) { |
| return '<!--' + obj.nodeValue + '-->' |
| } else if (obj.outerHTML) { |
| return obj.outerHTML |
| } else if (isNode(obj)) { |
| return serialize(obj) |
| } else if (instanceOf(obj, 'Error')) { |
| return obj.toString() + '\n' + obj.stack |
| } else { |
| var constructor = 'Object' |
| if (obj.constructor && typeof obj.constructor === 'function') { |
| constructor = obj.constructor.name |
| } |
| |
| strs.push(constructor) |
| strs.push('{') |
| var first = true |
| for (var key in obj) { |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { |
| if (first) { |
| first = false |
| } else { |
| strs.push(', ') |
| } |
| |
| strs.push(key + ': ' + stringify(obj[key], depth - 1)) |
| } |
| } |
| strs.push('}') |
| } |
| return strs.join('') |
| default: |
| return obj |
| } |
| } |
| |
| module.exports = stringify |
| |
| },{"./util":6,"dom-serialize":365}],6:[function(require,module,exports){ |
| exports.instanceOf = function (value, constructorName) { |
| return Object.prototype.toString.apply(value) === '[object ' + constructorName + ']' |
| } |
| |
| exports.elm = function (id) { |
| return document.getElementById(id) |
| } |
| |
| exports.generateId = function (prefix) { |
| return prefix + Math.floor(Math.random() * 10000) |
| } |
| |
| exports.isUndefined = function (value) { |
| return typeof value === 'undefined' |
| } |
| |
| exports.isDefined = function (value) { |
| return !exports.isUndefined(value) |
| } |
| |
| exports.parseQueryParams = function (locationSearch) { |
| var params = {} |
| var pairs = locationSearch.substr(1).split('&') |
| var keyValue |
| |
| for (var i = 0; i < pairs.length; i++) { |
| keyValue = pairs[i].split('=') |
| params[decodeURIComponent(keyValue[0])] = decodeURIComponent(keyValue[1]) |
| } |
| |
| return params |
| } |
| |
| },{}],7:[function(require,module,exports){ |
| require('../modules/es.symbol'); |
| require('../modules/es.symbol.async-iterator'); |
| require('../modules/es.symbol.description'); |
| require('../modules/es.symbol.has-instance'); |
| require('../modules/es.symbol.is-concat-spreadable'); |
| require('../modules/es.symbol.iterator'); |
| require('../modules/es.symbol.match'); |
| require('../modules/es.symbol.match-all'); |
| require('../modules/es.symbol.replace'); |
| require('../modules/es.symbol.search'); |
| require('../modules/es.symbol.species'); |
| require('../modules/es.symbol.split'); |
| require('../modules/es.symbol.to-primitive'); |
| require('../modules/es.symbol.to-string-tag'); |
| require('../modules/es.symbol.unscopables'); |
| require('../modules/es.object.assign'); |
| require('../modules/es.object.create'); |
| require('../modules/es.object.define-property'); |
| require('../modules/es.object.define-properties'); |
| require('../modules/es.object.entries'); |
| require('../modules/es.object.freeze'); |
| require('../modules/es.object.from-entries'); |
| require('../modules/es.object.get-own-property-descriptor'); |
| require('../modules/es.object.get-own-property-descriptors'); |
| require('../modules/es.object.get-own-property-names'); |
| require('../modules/es.object.get-prototype-of'); |
| require('../modules/es.object.is'); |
| require('../modules/es.object.is-extensible'); |
| require('../modules/es.object.is-frozen'); |
| require('../modules/es.object.is-sealed'); |
| require('../modules/es.object.keys'); |
| require('../modules/es.object.prevent-extensions'); |
| require('../modules/es.object.seal'); |
| require('../modules/es.object.set-prototype-of'); |
| require('../modules/es.object.values'); |
| require('../modules/es.object.to-string'); |
| require('../modules/es.object.define-getter'); |
| require('../modules/es.object.define-setter'); |
| require('../modules/es.object.lookup-getter'); |
| require('../modules/es.object.lookup-setter'); |
| require('../modules/es.function.bind'); |
| require('../modules/es.function.name'); |
| require('../modules/es.function.has-instance'); |
| require('../modules/es.array.from'); |
| require('../modules/es.array.is-array'); |
| require('../modules/es.array.of'); |
| require('../modules/es.array.concat'); |
| require('../modules/es.array.copy-within'); |
| require('../modules/es.array.every'); |
| require('../modules/es.array.fill'); |
| require('../modules/es.array.filter'); |
| require('../modules/es.array.find'); |
| require('../modules/es.array.find-index'); |
| require('../modules/es.array.flat'); |
| require('../modules/es.array.flat-map'); |
| require('../modules/es.array.for-each'); |
| require('../modules/es.array.includes'); |
| require('../modules/es.array.index-of'); |
| require('../modules/es.array.join'); |
| require('../modules/es.array.last-index-of'); |
| require('../modules/es.array.map'); |
| require('../modules/es.array.reduce'); |
| require('../modules/es.array.reduce-right'); |
| require('../modules/es.array.reverse'); |
| require('../modules/es.array.slice'); |
| require('../modules/es.array.some'); |
| require('../modules/es.array.sort'); |
| require('../modules/es.array.splice'); |
| require('../modules/es.array.species'); |
| require('../modules/es.array.unscopables.flat'); |
| require('../modules/es.array.unscopables.flat-map'); |
| require('../modules/es.array.iterator'); |
| require('../modules/es.string.from-code-point'); |
| require('../modules/es.string.raw'); |
| require('../modules/es.string.code-point-at'); |
| require('../modules/es.string.ends-with'); |
| require('../modules/es.string.includes'); |
| require('../modules/es.string.match'); |
| require('../modules/es.string.match-all'); |
| require('../modules/es.string.pad-end'); |
| require('../modules/es.string.pad-start'); |
| require('../modules/es.string.repeat'); |
| require('../modules/es.string.replace'); |
| require('../modules/es.string.search'); |
| require('../modules/es.string.split'); |
| require('../modules/es.string.starts-with'); |
| require('../modules/es.string.trim'); |
| require('../modules/es.string.trim-start'); |
| require('../modules/es.string.trim-end'); |
| require('../modules/es.string.iterator'); |
| require('../modules/es.string.anchor'); |
| require('../modules/es.string.big'); |
| require('../modules/es.string.blink'); |
| require('../modules/es.string.bold'); |
| require('../modules/es.string.fixed'); |
| require('../modules/es.string.fontcolor'); |
| require('../modules/es.string.fontsize'); |
| require('../modules/es.string.italics'); |
| require('../modules/es.string.link'); |
| require('../modules/es.string.small'); |
| require('../modules/es.string.strike'); |
| require('../modules/es.string.sub'); |
| require('../modules/es.string.sup'); |
| require('../modules/es.regexp.constructor'); |
| require('../modules/es.regexp.exec'); |
| require('../modules/es.regexp.flags'); |
| require('../modules/es.regexp.to-string'); |
| require('../modules/es.parse-int'); |
| require('../modules/es.parse-float'); |
| require('../modules/es.number.constructor'); |
| require('../modules/es.number.epsilon'); |
| require('../modules/es.number.is-finite'); |
| require('../modules/es.number.is-integer'); |
| require('../modules/es.number.is-nan'); |
| require('../modules/es.number.is-safe-integer'); |
| require('../modules/es.number.max-safe-integer'); |
| require('../modules/es.number.min-safe-integer'); |
| require('../modules/es.number.parse-float'); |
| require('../modules/es.number.parse-int'); |
| require('../modules/es.number.to-fixed'); |
| require('../modules/es.number.to-precision'); |
| require('../modules/es.math.acosh'); |
| require('../modules/es.math.asinh'); |
| require('../modules/es.math.atanh'); |
| require('../modules/es.math.cbrt'); |
| require('../modules/es.math.clz32'); |
| require('../modules/es.math.cosh'); |
| require('../modules/es.math.expm1'); |
| require('../modules/es.math.fround'); |
| require('../modules/es.math.hypot'); |
| require('../modules/es.math.imul'); |
| require('../modules/es.math.log10'); |
| require('../modules/es.math.log1p'); |
| require('../modules/es.math.log2'); |
| require('../modules/es.math.sign'); |
| require('../modules/es.math.sinh'); |
| require('../modules/es.math.tanh'); |
| require('../modules/es.math.to-string-tag'); |
| require('../modules/es.math.trunc'); |
| require('../modules/es.date.now'); |
| require('../modules/es.date.to-json'); |
| require('../modules/es.date.to-iso-string'); |
| require('../modules/es.date.to-string'); |
| require('../modules/es.date.to-primitive'); |
| require('../modules/es.json.to-string-tag'); |
| require('../modules/es.promise'); |
| require('../modules/es.promise.finally'); |
| require('../modules/es.map'); |
| require('../modules/es.set'); |
| require('../modules/es.weak-map'); |
| require('../modules/es.weak-set'); |
| require('../modules/es.array-buffer.constructor'); |
| require('../modules/es.array-buffer.is-view'); |
| require('../modules/es.array-buffer.slice'); |
| require('../modules/es.data-view'); |
| require('../modules/es.typed-array.int8-array'); |
| require('../modules/es.typed-array.uint8-array'); |
| require('../modules/es.typed-array.uint8-clamped-array'); |
| require('../modules/es.typed-array.int16-array'); |
| require('../modules/es.typed-array.uint16-array'); |
| require('../modules/es.typed-array.int32-array'); |
| require('../modules/es.typed-array.uint32-array'); |
| require('../modules/es.typed-array.float32-array'); |
| require('../modules/es.typed-array.float64-array'); |
| require('../modules/es.typed-array.from'); |
| require('../modules/es.typed-array.of'); |
| require('../modules/es.typed-array.copy-within'); |
| require('../modules/es.typed-array.every'); |
| require('../modules/es.typed-array.fill'); |
| require('../modules/es.typed-array.filter'); |
| require('../modules/es.typed-array.find'); |
| require('../modules/es.typed-array.find-index'); |
| require('../modules/es.typed-array.for-each'); |
| require('../modules/es.typed-array.includes'); |
| require('../modules/es.typed-array.index-of'); |
| require('../modules/es.typed-array.iterator'); |
| require('../modules/es.typed-array.join'); |
| require('../modules/es.typed-array.last-index-of'); |
| require('../modules/es.typed-array.map'); |
| require('../modules/es.typed-array.reduce'); |
| require('../modules/es.typed-array.reduce-right'); |
| require('../modules/es.typed-array.reverse'); |
| require('../modules/es.typed-array.set'); |
| require('../modules/es.typed-array.slice'); |
| require('../modules/es.typed-array.some'); |
| require('../modules/es.typed-array.sort'); |
| require('../modules/es.typed-array.subarray'); |
| require('../modules/es.typed-array.to-locale-string'); |
| require('../modules/es.typed-array.to-string'); |
| require('../modules/es.reflect.apply'); |
| require('../modules/es.reflect.construct'); |
| require('../modules/es.reflect.define-property'); |
| require('../modules/es.reflect.delete-property'); |
| require('../modules/es.reflect.get'); |
| require('../modules/es.reflect.get-own-property-descriptor'); |
| require('../modules/es.reflect.get-prototype-of'); |
| require('../modules/es.reflect.has'); |
| require('../modules/es.reflect.is-extensible'); |
| require('../modules/es.reflect.own-keys'); |
| require('../modules/es.reflect.prevent-extensions'); |
| require('../modules/es.reflect.set'); |
| require('../modules/es.reflect.set-prototype-of'); |
| |
| module.exports = require('../internals/path'); |
| |
| },{"../internals/path":112,"../modules/es.array-buffer.constructor":153,"../modules/es.array-buffer.is-view":154,"../modules/es.array-buffer.slice":155,"../modules/es.array.concat":156,"../modules/es.array.copy-within":157,"../modules/es.array.every":158,"../modules/es.array.fill":159,"../modules/es.array.filter":160,"../modules/es.array.find":162,"../modules/es.array.find-index":161,"../modules/es.array.flat":164,"../modules/es.array.flat-map":163,"../modules/es.array.for-each":165,"../modules/es.array.from":166,"../modules/es.array.includes":167,"../modules/es.array.index-of":168,"../modules/es.array.is-array":169,"../modules/es.array.iterator":170,"../modules/es.array.join":171,"../modules/es.array.last-index-of":172,"../modules/es.array.map":173,"../modules/es.array.of":174,"../modules/es.array.reduce":176,"../modules/es.array.reduce-right":175,"../modules/es.array.reverse":177,"../modules/es.array.slice":178,"../modules/es.array.some":179,"../modules/es.array.sort":180,"../modules/es.array.species":181,"../modules/es.array.splice":182,"../modules/es.array.unscopables.flat":184,"../modules/es.array.unscopables.flat-map":183,"../modules/es.data-view":185,"../modules/es.date.now":186,"../modules/es.date.to-iso-string":187,"../modules/es.date.to-json":188,"../modules/es.date.to-primitive":189,"../modules/es.date.to-string":190,"../modules/es.function.bind":191,"../modules/es.function.has-instance":192,"../modules/es.function.name":193,"../modules/es.json.to-string-tag":194,"../modules/es.map":195,"../modules/es.math.acosh":196,"../modules/es.math.asinh":197,"../modules/es.math.atanh":198,"../modules/es.math.cbrt":199,"../modules/es.math.clz32":200,"../modules/es.math.cosh":201,"../modules/es.math.expm1":202,"../modules/es.math.fround":203,"../modules/es.math.hypot":204,"../modules/es.math.imul":205,"../modules/es.math.log10":206,"../modules/es.math.log1p":207,"../modules/es.math.log2":208,"../modules/es.math.sign":209,"../modules/es.math.sinh":210,"../modules/es.math.tanh":211,"../modules/es.math.to-string-tag":212,"../modules/es.math.trunc":213,"../modules/es.number.constructor":214,"../modules/es.number.epsilon":215,"../modules/es.number.is-finite":216,"../modules/es.number.is-integer":217,"../modules/es.number.is-nan":218,"../modules/es.number.is-safe-integer":219,"../modules/es.number.max-safe-integer":220,"../modules/es.number.min-safe-integer":221,"../modules/es.number.parse-float":222,"../modules/es.number.parse-int":223,"../modules/es.number.to-fixed":224,"../modules/es.number.to-precision":225,"../modules/es.object.assign":226,"../modules/es.object.create":227,"../modules/es.object.define-getter":228,"../modules/es.object.define-properties":229,"../modules/es.object.define-property":230,"../modules/es.object.define-setter":231,"../modules/es.object.entries":232,"../modules/es.object.freeze":233,"../modules/es.object.from-entries":234,"../modules/es.object.get-own-property-descriptor":235,"../modules/es.object.get-own-property-descriptors":236,"../modules/es.object.get-own-property-names":237,"../modules/es.object.get-prototype-of":238,"../modules/es.object.is":242,"../modules/es.object.is-extensible":239,"../modules/es.object.is-frozen":240,"../modules/es.object.is-sealed":241,"../modules/es.object.keys":243,"../modules/es.object.lookup-getter":244,"../modules/es.object.lookup-setter":245,"../modules/es.object.prevent-extensions":246,"../modules/es.object.seal":247,"../modules/es.object.set-prototype-of":248,"../modules/es.object.to-string":249,"../modules/es.object.values":250,"../modules/es.parse-float":251,"../modules/es.parse-int":252,"../modules/es.promise":254,"../modules/es.promise.finally":253,"../modules/es.reflect.apply":255,"../modules/es.reflect.construct":256,"../modules/es.reflect.define-property":257,"../modules/es.reflect.delete-property":258,"../modules/es.reflect.get":261,"../modules/es.reflect.get-own-property-descriptor":259,"../modules/es.reflect.get-prototype-of":260,"../modules/es.reflect.has":262,"../modules/es.reflect.is-extensible":263,"../modules/es.reflect.own-keys":264,"../modules/es.reflect.prevent-extensions":265,"../modules/es.reflect.set":267,"../modules/es.reflect.set-prototype-of":266,"../modules/es.regexp.constructor":268,"../modules/es.regexp.exec":269,"../modules/es.regexp.flags":270,"../modules/es.regexp.to-string":271,"../modules/es.set":272,"../modules/es.string.anchor":273,"../modules/es.string.big":274,"../modules/es.string.blink":275,"../modules/es.string.bold":276,"../modules/es.string.code-point-at":277,"../modules/es.string.ends-with":278,"../modules/es.string.fixed":279,"../modules/es.string.fontcolor":280,"../modules/es.string.fontsize":281,"../modules/es.string.from-code-point":282,"../modules/es.string.includes":283,"../modules/es.string.italics":284,"../modules/es.string.iterator":285,"../modules/es.string.link":286,"../modules/es.string.match":288,"../modules/es.string.match-all":287,"../modules/es.string.pad-end":289,"../modules/es.string.pad-start":290,"../modules/es.string.raw":291,"../modules/es.string.repeat":292,"../modules/es.string.replace":293,"../modules/es.string.search":294,"../modules/es.string.small":295,"../modules/es.string.split":296,"../modules/es.string.starts-with":297,"../modules/es.string.strike":298,"../modules/es.string.sub":299,"../modules/es.string.sup":300,"../modules/es.string.trim":303,"../modules/es.string.trim-end":301,"../modules/es.string.trim-start":302,"../modules/es.symbol":309,"../modules/es.symbol.async-iterator":304,"../modules/es.symbol.description":305,"../modules/es.symbol.has-instance":306,"../modules/es.symbol.is-concat-spreadable":307,"../modules/es.symbol.iterator":308,"../modules/es.symbol.match":311,"../modules/es.symbol.match-all":310,"../modules/es.symbol.replace":312,"../modules/es.symbol.search":313,"../modules/es.symbol.species":314,"../modules/es.symbol.split":315,"../modules/es.symbol.to-primitive":316,"../modules/es.symbol.to-string-tag":317,"../modules/es.symbol.unscopables":318,"../modules/es.typed-array.copy-within":319,"../modules/es.typed-array.every":320,"../modules/es.typed-array.fill":321,"../modules/es.typed-array.filter":322,"../modules/es.typed-array.find":324,"../modules/es.typed-array.find-index":323,"../modules/es.typed-array.float32-array":325,"../modules/es.typed-array.float64-array":326,"../modules/es.typed-array.for-each":327,"../modules/es.typed-array.from":328,"../modules/es.typed-array.includes":329,"../modules/es.typed-array.index-of":330,"../modules/es.typed-array.int16-array":331,"../modules/es.typed-array.int32-array":332,"../modules/es.typed-array.int8-array":333,"../modules/es.typed-array.iterator":334,"../modules/es.typed-array.join":335,"../modules/es.typed-array.last-index-of":336,"../modules/es.typed-array.map":337,"../modules/es.typed-array.of":338,"../modules/es.typed-array.reduce":340,"../modules/es.typed-array.reduce-right":339,"../modules/es.typed-array.reverse":341,"../modules/es.typed-array.set":342,"../modules/es.typed-array.slice":343,"../modules/es.typed-array.some":344,"../modules/es.typed-array.sort":345,"../modules/es.typed-array.subarray":346,"../modules/es.typed-array.to-locale-string":347,"../modules/es.typed-array.to-string":348,"../modules/es.typed-array.uint16-array":349,"../modules/es.typed-array.uint32-array":350,"../modules/es.typed-array.uint8-array":351,"../modules/es.typed-array.uint8-clamped-array":352,"../modules/es.weak-map":353,"../modules/es.weak-set":354}],8:[function(require,module,exports){ |
| module.exports = function (it) { |
| if (typeof it != 'function') { |
| throw TypeError(String(it) + ' is not a function'); |
| } return it; |
| }; |
| |
| },{}],9:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| |
| module.exports = function (it) { |
| if (!isObject(it) && it !== null) { |
| throw TypeError("Can't set " + String(it) + ' as a prototype'); |
| } return it; |
| }; |
| |
| },{"../internals/is-object":77}],10:[function(require,module,exports){ |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var create = require('../internals/object-create'); |
| var hide = require('../internals/hide'); |
| |
| var UNSCOPABLES = wellKnownSymbol('unscopables'); |
| var ArrayPrototype = Array.prototype; |
| |
| // Array.prototype[@@unscopables] |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| if (ArrayPrototype[UNSCOPABLES] == undefined) { |
| hide(ArrayPrototype, UNSCOPABLES, create(null)); |
| } |
| |
| // add a key to Array.prototype[@@unscopables] |
| module.exports = function (key) { |
| ArrayPrototype[UNSCOPABLES][key] = true; |
| }; |
| |
| },{"../internals/hide":65,"../internals/object-create":95,"../internals/well-known-symbol":150}],11:[function(require,module,exports){ |
| 'use strict'; |
| var charAt = require('../internals/string-multibyte').charAt; |
| |
| // `AdvanceStringIndex` abstract operation |
| // https://tc39.github.io/ecma262/#sec-advancestringindex |
| module.exports = function (S, index, unicode) { |
| return index + (unicode ? charAt(S, index).length : 1); |
| }; |
| |
| },{"../internals/string-multibyte":130}],12:[function(require,module,exports){ |
| module.exports = function (it, Constructor, name) { |
| if (!(it instanceof Constructor)) { |
| throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); |
| } return it; |
| }; |
| |
| },{}],13:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| |
| module.exports = function (it) { |
| if (!isObject(it)) { |
| throw TypeError(String(it) + ' is not an object'); |
| } return it; |
| }; |
| |
| },{"../internals/is-object":77}],14:[function(require,module,exports){ |
| 'use strict'; |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var global = require('../internals/global'); |
| var isObject = require('../internals/is-object'); |
| var has = require('../internals/has'); |
| var classof = require('../internals/classof'); |
| var hide = require('../internals/hide'); |
| var redefine = require('../internals/redefine'); |
| var defineProperty = require('../internals/object-define-property').f; |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var setPrototypeOf = require('../internals/object-set-prototype-of'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var uid = require('../internals/uid'); |
| |
| var DataView = global.DataView; |
| var DataViewPrototype = DataView && DataView.prototype; |
| var Int8Array = global.Int8Array; |
| var Int8ArrayPrototype = Int8Array && Int8Array.prototype; |
| var Uint8ClampedArray = global.Uint8ClampedArray; |
| var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; |
| var TypedArray = Int8Array && getPrototypeOf(Int8Array); |
| var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype); |
| var ObjectPrototype = Object.prototype; |
| var isPrototypeOf = ObjectPrototype.isPrototypeOf; |
| |
| var TO_STRING_TAG = wellKnownSymbol('toStringTag'); |
| var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); |
| var NATIVE_ARRAY_BUFFER = !!(global.ArrayBuffer && DataView); |
| var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf; |
| var TYPED_ARRAY_TAG_REQIRED = false; |
| var NAME; |
| |
| var TypedArrayConstructorsList = { |
| Int8Array: 1, |
| Uint8Array: 1, |
| Uint8ClampedArray: 1, |
| Int16Array: 2, |
| Uint16Array: 2, |
| Int32Array: 4, |
| Uint32Array: 4, |
| Float32Array: 4, |
| Float64Array: 8 |
| }; |
| |
| var isView = function isView(it) { |
| var klass = classof(it); |
| return klass === 'DataView' || has(TypedArrayConstructorsList, klass); |
| }; |
| |
| var isTypedArray = function (it) { |
| return isObject(it) && has(TypedArrayConstructorsList, classof(it)); |
| }; |
| |
| var aTypedArray = function (it) { |
| if (isTypedArray(it)) return it; |
| throw TypeError('Target is not a typed array'); |
| }; |
| |
| var aTypedArrayConstructor = function (C) { |
| if (setPrototypeOf) { |
| if (isPrototypeOf.call(TypedArray, C)) return C; |
| } else for (var ARRAY in TypedArrayConstructorsList) if (has(TypedArrayConstructorsList, NAME)) { |
| var TypedArrayConstructor = global[ARRAY]; |
| if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) { |
| return C; |
| } |
| } throw TypeError('Target is not a typed array constructor'); |
| }; |
| |
| var exportProto = function (KEY, property, forced) { |
| if (!DESCRIPTORS) return; |
| if (forced) for (var ARRAY in TypedArrayConstructorsList) { |
| var TypedArrayConstructor = global[ARRAY]; |
| if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) { |
| delete TypedArrayConstructor.prototype[KEY]; |
| } |
| } |
| if (!TypedArrayPrototype[KEY] || forced) { |
| redefine(TypedArrayPrototype, KEY, forced ? property |
| : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property); |
| } |
| }; |
| |
| var exportStatic = function (KEY, property, forced) { |
| var ARRAY, TypedArrayConstructor; |
| if (!DESCRIPTORS) return; |
| if (setPrototypeOf) { |
| if (forced) for (ARRAY in TypedArrayConstructorsList) { |
| TypedArrayConstructor = global[ARRAY]; |
| if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) { |
| delete TypedArrayConstructor[KEY]; |
| } |
| } |
| if (!TypedArray[KEY] || forced) { |
| // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable |
| try { |
| return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array[KEY] || property); |
| } catch (error) { /* empty */ } |
| } else return; |
| } |
| for (ARRAY in TypedArrayConstructorsList) { |
| TypedArrayConstructor = global[ARRAY]; |
| if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { |
| redefine(TypedArrayConstructor, KEY, property); |
| } |
| } |
| }; |
| |
| for (NAME in TypedArrayConstructorsList) { |
| if (!global[NAME]) NATIVE_ARRAY_BUFFER_VIEWS = false; |
| } |
| |
| // WebKit bug - typed arrays constructors prototype is Object.prototype |
| if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) { |
| // eslint-disable-next-line no-shadow |
| TypedArray = function TypedArray() { |
| throw TypeError('Incorrect invocation'); |
| }; |
| if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { |
| if (global[NAME]) setPrototypeOf(global[NAME], TypedArray); |
| } |
| } |
| |
| if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) { |
| TypedArrayPrototype = TypedArray.prototype; |
| if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { |
| if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype); |
| } |
| } |
| |
| // WebKit bug - one more object in Uint8ClampedArray prototype chain |
| if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { |
| setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); |
| } |
| |
| if (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) { |
| TYPED_ARRAY_TAG_REQIRED = true; |
| defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () { |
| return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined; |
| } }); |
| for (NAME in TypedArrayConstructorsList) if (global[NAME]) { |
| hide(global[NAME], TYPED_ARRAY_TAG, NAME); |
| } |
| } |
| |
| // WebKit bug - the same parent prototype for typed arrays and data view |
| if (NATIVE_ARRAY_BUFFER && setPrototypeOf && getPrototypeOf(DataViewPrototype) !== ObjectPrototype) { |
| setPrototypeOf(DataViewPrototype, ObjectPrototype); |
| } |
| |
| module.exports = { |
| NATIVE_ARRAY_BUFFER: NATIVE_ARRAY_BUFFER, |
| NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS, |
| TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG, |
| aTypedArray: aTypedArray, |
| aTypedArrayConstructor: aTypedArrayConstructor, |
| exportProto: exportProto, |
| exportStatic: exportStatic, |
| isView: isView, |
| isTypedArray: isTypedArray, |
| TypedArray: TypedArray, |
| TypedArrayPrototype: TypedArrayPrototype |
| }; |
| |
| },{"../internals/classof":30,"../internals/descriptors":45,"../internals/global":62,"../internals/has":63,"../internals/hide":65,"../internals/is-object":77,"../internals/object-define-property":97,"../internals/object-get-prototype-of":102,"../internals/object-set-prototype-of":106,"../internals/redefine":117,"../internals/uid":147,"../internals/well-known-symbol":150}],15:[function(require,module,exports){ |
| 'use strict'; |
| var global = require('../internals/global'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-view-core').NATIVE_ARRAY_BUFFER; |
| var hide = require('../internals/hide'); |
| var redefineAll = require('../internals/redefine-all'); |
| var fails = require('../internals/fails'); |
| var anInstance = require('../internals/an-instance'); |
| var toInteger = require('../internals/to-integer'); |
| var toLength = require('../internals/to-length'); |
| var toIndex = require('../internals/to-index'); |
| var getOwnPropertyNames = require('../internals/object-get-own-property-names').f; |
| var defineProperty = require('../internals/object-define-property').f; |
| var arrayFill = require('../internals/array-fill'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var InternalStateModule = require('../internals/internal-state'); |
| |
| var getInternalState = InternalStateModule.get; |
| var setInternalState = InternalStateModule.set; |
| var ARRAY_BUFFER = 'ArrayBuffer'; |
| var DATA_VIEW = 'DataView'; |
| var PROTOTYPE = 'prototype'; |
| var WRONG_LENGTH = 'Wrong length'; |
| var WRONG_INDEX = 'Wrong index'; |
| var NativeArrayBuffer = global[ARRAY_BUFFER]; |
| var $ArrayBuffer = NativeArrayBuffer; |
| var $DataView = global[DATA_VIEW]; |
| var Math = global.Math; |
| var RangeError = global.RangeError; |
| // eslint-disable-next-line no-shadow-restricted-names |
| var Infinity = 1 / 0; |
| var abs = Math.abs; |
| var pow = Math.pow; |
| var floor = Math.floor; |
| var log = Math.log; |
| var LN2 = Math.LN2; |
| |
| // IEEE754 conversions based on https://github.com/feross/ieee754 |
| var packIEEE754 = function (number, mantissaLength, bytes) { |
| var buffer = new Array(bytes); |
| var exponentLength = bytes * 8 - mantissaLength - 1; |
| var eMax = (1 << exponentLength) - 1; |
| var eBias = eMax >> 1; |
| var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0; |
| var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0; |
| var index = 0; |
| var exponent, mantissa, c; |
| number = abs(number); |
| // eslint-disable-next-line no-self-compare |
| if (number != number || number === Infinity) { |
| // eslint-disable-next-line no-self-compare |
| mantissa = number != number ? 1 : 0; |
| exponent = eMax; |
| } else { |
| exponent = floor(log(number) / LN2); |
| if (number * (c = pow(2, -exponent)) < 1) { |
| exponent--; |
| c *= 2; |
| } |
| if (exponent + eBias >= 1) { |
| number += rt / c; |
| } else { |
| number += rt * pow(2, 1 - eBias); |
| } |
| if (number * c >= 2) { |
| exponent++; |
| c /= 2; |
| } |
| if (exponent + eBias >= eMax) { |
| mantissa = 0; |
| exponent = eMax; |
| } else if (exponent + eBias >= 1) { |
| mantissa = (number * c - 1) * pow(2, mantissaLength); |
| exponent = exponent + eBias; |
| } else { |
| mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength); |
| exponent = 0; |
| } |
| } |
| for (; mantissaLength >= 8; buffer[index++] = mantissa & 255, mantissa /= 256, mantissaLength -= 8); |
| exponent = exponent << mantissaLength | mantissa; |
| exponentLength += mantissaLength; |
| for (; exponentLength > 0; buffer[index++] = exponent & 255, exponent /= 256, exponentLength -= 8); |
| buffer[--index] |= sign * 128; |
| return buffer; |
| }; |
| |
| var unpackIEEE754 = function (buffer, mantissaLength) { |
| var bytes = buffer.length; |
| var exponentLength = bytes * 8 - mantissaLength - 1; |
| var eMax = (1 << exponentLength) - 1; |
| var eBias = eMax >> 1; |
| var nBits = exponentLength - 7; |
| var index = bytes - 1; |
| var sign = buffer[index--]; |
| var exponent = sign & 127; |
| var mantissa; |
| sign >>= 7; |
| for (; nBits > 0; exponent = exponent * 256 + buffer[index], index--, nBits -= 8); |
| mantissa = exponent & (1 << -nBits) - 1; |
| exponent >>= -nBits; |
| nBits += mantissaLength; |
| for (; nBits > 0; mantissa = mantissa * 256 + buffer[index], index--, nBits -= 8); |
| if (exponent === 0) { |
| exponent = 1 - eBias; |
| } else if (exponent === eMax) { |
| return mantissa ? NaN : sign ? -Infinity : Infinity; |
| } else { |
| mantissa = mantissa + pow(2, mantissaLength); |
| exponent = exponent - eBias; |
| } return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength); |
| }; |
| |
| var unpackInt32 = function (buffer) { |
| return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0]; |
| }; |
| |
| var packInt8 = function (number) { |
| return [number & 0xFF]; |
| }; |
| |
| var packInt16 = function (number) { |
| return [number & 0xFF, number >> 8 & 0xFF]; |
| }; |
| |
| var packInt32 = function (number) { |
| return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF]; |
| }; |
| |
| var packFloat32 = function (number) { |
| return packIEEE754(number, 23, 4); |
| }; |
| |
| var packFloat64 = function (number) { |
| return packIEEE754(number, 52, 8); |
| }; |
| |
| var addGetter = function (Constructor, key) { |
| defineProperty(Constructor[PROTOTYPE], key, { get: function () { return getInternalState(this)[key]; } }); |
| }; |
| |
| var get = function (view, count, index, isLittleEndian) { |
| var numIndex = +index; |
| var intIndex = toIndex(numIndex); |
| var store = getInternalState(view); |
| if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX); |
| var bytes = getInternalState(store.buffer).bytes; |
| var start = intIndex + store.byteOffset; |
| var pack = bytes.slice(start, start + count); |
| return isLittleEndian ? pack : pack.reverse(); |
| }; |
| |
| var set = function (view, count, index, conversion, value, isLittleEndian) { |
| var numIndex = +index; |
| var intIndex = toIndex(numIndex); |
| var store = getInternalState(view); |
| if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX); |
| var bytes = getInternalState(store.buffer).bytes; |
| var start = intIndex + store.byteOffset; |
| var pack = conversion(+value); |
| for (var i = 0; i < count; i++) bytes[start + i] = pack[isLittleEndian ? i : count - i - 1]; |
| }; |
| |
| if (!NATIVE_ARRAY_BUFFER) { |
| $ArrayBuffer = function ArrayBuffer(length) { |
| anInstance(this, $ArrayBuffer, ARRAY_BUFFER); |
| var byteLength = toIndex(length); |
| setInternalState(this, { |
| bytes: arrayFill.call(new Array(byteLength), 0), |
| byteLength: byteLength |
| }); |
| if (!DESCRIPTORS) this.byteLength = byteLength; |
| }; |
| |
| $DataView = function DataView(buffer, byteOffset, byteLength) { |
| anInstance(this, $DataView, DATA_VIEW); |
| anInstance(buffer, $ArrayBuffer, DATA_VIEW); |
| var bufferLength = getInternalState(buffer).byteLength; |
| var offset = toInteger(byteOffset); |
| if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset'); |
| byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength); |
| if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH); |
| setInternalState(this, { |
| buffer: buffer, |
| byteLength: byteLength, |
| byteOffset: offset |
| }); |
| if (!DESCRIPTORS) { |
| this.buffer = buffer; |
| this.byteLength = byteLength; |
| this.byteOffset = offset; |
| } |
| }; |
| |
| if (DESCRIPTORS) { |
| addGetter($ArrayBuffer, 'byteLength'); |
| addGetter($DataView, 'buffer'); |
| addGetter($DataView, 'byteLength'); |
| addGetter($DataView, 'byteOffset'); |
| } |
| |
| redefineAll($DataView[PROTOTYPE], { |
| getInt8: function getInt8(byteOffset) { |
| return get(this, 1, byteOffset)[0] << 24 >> 24; |
| }, |
| getUint8: function getUint8(byteOffset) { |
| return get(this, 1, byteOffset)[0]; |
| }, |
| getInt16: function getInt16(byteOffset /* , littleEndian */) { |
| var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined); |
| return (bytes[1] << 8 | bytes[0]) << 16 >> 16; |
| }, |
| getUint16: function getUint16(byteOffset /* , littleEndian */) { |
| var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined); |
| return bytes[1] << 8 | bytes[0]; |
| }, |
| getInt32: function getInt32(byteOffset /* , littleEndian */) { |
| return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)); |
| }, |
| getUint32: function getUint32(byteOffset /* , littleEndian */) { |
| return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)) >>> 0; |
| }, |
| getFloat32: function getFloat32(byteOffset /* , littleEndian */) { |
| return unpackIEEE754(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 23); |
| }, |
| getFloat64: function getFloat64(byteOffset /* , littleEndian */) { |
| return unpackIEEE754(get(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 52); |
| }, |
| setInt8: function setInt8(byteOffset, value) { |
| set(this, 1, byteOffset, packInt8, value); |
| }, |
| setUint8: function setUint8(byteOffset, value) { |
| set(this, 1, byteOffset, packInt8, value); |
| }, |
| setInt16: function setInt16(byteOffset, value /* , littleEndian */) { |
| set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined); |
| }, |
| setUint16: function setUint16(byteOffset, value /* , littleEndian */) { |
| set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined); |
| }, |
| setInt32: function setInt32(byteOffset, value /* , littleEndian */) { |
| set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined); |
| }, |
| setUint32: function setUint32(byteOffset, value /* , littleEndian */) { |
| set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined); |
| }, |
| setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) { |
| set(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : undefined); |
| }, |
| setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) { |
| set(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : undefined); |
| } |
| }); |
| } else { |
| if (!fails(function () { |
| NativeArrayBuffer(1); |
| }) || !fails(function () { |
| new NativeArrayBuffer(-1); // eslint-disable-line no-new |
| }) || fails(function () { |
| new NativeArrayBuffer(); // eslint-disable-line no-new |
| new NativeArrayBuffer(1.5); // eslint-disable-line no-new |
| new NativeArrayBuffer(NaN); // eslint-disable-line no-new |
| return NativeArrayBuffer.name != ARRAY_BUFFER; |
| })) { |
| $ArrayBuffer = function ArrayBuffer(length) { |
| anInstance(this, $ArrayBuffer); |
| return new NativeArrayBuffer(toIndex(length)); |
| }; |
| var ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE] = NativeArrayBuffer[PROTOTYPE]; |
| for (var keys = getOwnPropertyNames(NativeArrayBuffer), j = 0, key; keys.length > j;) { |
| if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, NativeArrayBuffer[key]); |
| } |
| ArrayBufferPrototype.constructor = $ArrayBuffer; |
| } |
| // iOS Safari 7.x bug |
| var testView = new $DataView(new $ArrayBuffer(2)); |
| var nativeSetInt8 = $DataView[PROTOTYPE].setInt8; |
| testView.setInt8(0, 2147483648); |
| testView.setInt8(1, 2147483649); |
| if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll($DataView[PROTOTYPE], { |
| setInt8: function setInt8(byteOffset, value) { |
| nativeSetInt8.call(this, byteOffset, value << 24 >> 24); |
| }, |
| setUint8: function setUint8(byteOffset, value) { |
| nativeSetInt8.call(this, byteOffset, value << 24 >> 24); |
| } |
| }, { unsafe: true }); |
| } |
| |
| setToStringTag($ArrayBuffer, ARRAY_BUFFER); |
| setToStringTag($DataView, DATA_VIEW); |
| exports[ARRAY_BUFFER] = $ArrayBuffer; |
| exports[DATA_VIEW] = $DataView; |
| |
| },{"../internals/an-instance":12,"../internals/array-buffer-view-core":14,"../internals/array-fill":17,"../internals/descriptors":45,"../internals/fails":50,"../internals/global":62,"../internals/hide":65,"../internals/internal-state":72,"../internals/object-define-property":97,"../internals/object-get-own-property-names":100,"../internals/redefine-all":116,"../internals/set-to-string-tag":125,"../internals/to-index":137,"../internals/to-integer":139,"../internals/to-length":140}],16:[function(require,module,exports){ |
| 'use strict'; |
| var toObject = require('../internals/to-object'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| var toLength = require('../internals/to-length'); |
| |
| var min = Math.min; |
| |
| // `Array.prototype.copyWithin` method implementation |
| // https://tc39.github.io/ecma262/#sec-array.prototype.copywithin |
| module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) { |
| var O = toObject(this); |
| var len = toLength(O.length); |
| var to = toAbsoluteIndex(target, len); |
| var from = toAbsoluteIndex(start, len); |
| var end = arguments.length > 2 ? arguments[2] : undefined; |
| var count = min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to); |
| var inc = 1; |
| if (from < to && to < from + count) { |
| inc = -1; |
| from += count - 1; |
| to += count - 1; |
| } |
| while (count-- > 0) { |
| if (from in O) O[to] = O[from]; |
| else delete O[to]; |
| to += inc; |
| from += inc; |
| } return O; |
| }; |
| |
| },{"../internals/to-absolute-index":136,"../internals/to-length":140,"../internals/to-object":141}],17:[function(require,module,exports){ |
| 'use strict'; |
| var toObject = require('../internals/to-object'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| var toLength = require('../internals/to-length'); |
| |
| // `Array.prototype.fill` method implementation |
| // https://tc39.github.io/ecma262/#sec-array.prototype.fill |
| module.exports = function fill(value /* , start = 0, end = @length */) { |
| var O = toObject(this); |
| var length = toLength(O.length); |
| var argumentsLength = arguments.length; |
| var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); |
| var end = argumentsLength > 2 ? arguments[2] : undefined; |
| var endPos = end === undefined ? length : toAbsoluteIndex(end, length); |
| while (endPos > index) O[index++] = value; |
| return O; |
| }; |
| |
| },{"../internals/to-absolute-index":136,"../internals/to-length":140,"../internals/to-object":141}],18:[function(require,module,exports){ |
| 'use strict'; |
| var $forEach = require('../internals/array-iteration').forEach; |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| // `Array.prototype.forEach` method implementation |
| // https://tc39.github.io/ecma262/#sec-array.prototype.foreach |
| module.exports = sloppyArrayMethod('forEach') ? function forEach(callbackfn /* , thisArg */) { |
| return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } : [].forEach; |
| |
| },{"../internals/array-iteration":21,"../internals/sloppy-array-method":128}],19:[function(require,module,exports){ |
| 'use strict'; |
| var bind = require('../internals/bind-context'); |
| var toObject = require('../internals/to-object'); |
| var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing'); |
| var isArrayIteratorMethod = require('../internals/is-array-iterator-method'); |
| var toLength = require('../internals/to-length'); |
| var createProperty = require('../internals/create-property'); |
| var getIteratorMethod = require('../internals/get-iterator-method'); |
| |
| // `Array.from` method implementation |
| // https://tc39.github.io/ecma262/#sec-array.from |
| module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { |
| var O = toObject(arrayLike); |
| var C = typeof this == 'function' ? this : Array; |
| var argumentsLength = arguments.length; |
| var mapfn = argumentsLength > 1 ? arguments[1] : undefined; |
| var mapping = mapfn !== undefined; |
| var index = 0; |
| var iteratorMethod = getIteratorMethod(O); |
| var length, result, step, iterator; |
| if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2); |
| // if the target is not iterable or it's an array with the default iterator - use a simple case |
| if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) { |
| iterator = iteratorMethod.call(O); |
| result = new C(); |
| for (;!(step = iterator.next()).done; index++) { |
| createProperty(result, index, mapping |
| ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) |
| : step.value |
| ); |
| } |
| } else { |
| length = toLength(O.length); |
| result = new C(length); |
| for (;length > index; index++) { |
| createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]); |
| } |
| } |
| result.length = index; |
| return result; |
| }; |
| |
| },{"../internals/bind-context":26,"../internals/call-with-safe-iteration-closing":27,"../internals/create-property":40,"../internals/get-iterator-method":60,"../internals/is-array-iterator-method":73,"../internals/to-length":140,"../internals/to-object":141}],20:[function(require,module,exports){ |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var toLength = require('../internals/to-length'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| |
| // `Array.prototype.{ indexOf, includes }` methods implementation |
| var createMethod = function (IS_INCLUDES) { |
| return function ($this, el, fromIndex) { |
| var O = toIndexedObject($this); |
| var length = toLength(O.length); |
| var index = toAbsoluteIndex(fromIndex, length); |
| var value; |
| // Array#includes uses SameValueZero equality algorithm |
| // eslint-disable-next-line no-self-compare |
| if (IS_INCLUDES && el != el) while (length > index) { |
| value = O[index++]; |
| // eslint-disable-next-line no-self-compare |
| if (value != value) return true; |
| // Array#indexOf ignores holes, Array#includes - not |
| } else for (;length > index; index++) { |
| if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; |
| } return !IS_INCLUDES && -1; |
| }; |
| }; |
| |
| module.exports = { |
| // `Array.prototype.includes` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.includes |
| includes: createMethod(true), |
| // `Array.prototype.indexOf` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.indexof |
| indexOf: createMethod(false) |
| }; |
| |
| },{"../internals/to-absolute-index":136,"../internals/to-indexed-object":138,"../internals/to-length":140}],21:[function(require,module,exports){ |
| var bind = require('../internals/bind-context'); |
| var IndexedObject = require('../internals/indexed-object'); |
| var toObject = require('../internals/to-object'); |
| var toLength = require('../internals/to-length'); |
| var arraySpeciesCreate = require('../internals/array-species-create'); |
| |
| var push = [].push; |
| |
| // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation |
| var createMethod = function (TYPE) { |
| var IS_MAP = TYPE == 1; |
| var IS_FILTER = TYPE == 2; |
| var IS_SOME = TYPE == 3; |
| var IS_EVERY = TYPE == 4; |
| var IS_FIND_INDEX = TYPE == 6; |
| var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; |
| return function ($this, callbackfn, that, specificCreate) { |
| var O = toObject($this); |
| var self = IndexedObject(O); |
| var boundFunction = bind(callbackfn, that, 3); |
| var length = toLength(self.length); |
| var index = 0; |
| var create = specificCreate || arraySpeciesCreate; |
| var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; |
| var value, result; |
| for (;length > index; index++) if (NO_HOLES || index in self) { |
| value = self[index]; |
| result = boundFunction(value, index, O); |
| if (TYPE) { |
| if (IS_MAP) target[index] = result; // map |
| else if (result) switch (TYPE) { |
| case 3: return true; // some |
| case 5: return value; // find |
| case 6: return index; // findIndex |
| case 2: push.call(target, value); // filter |
| } else if (IS_EVERY) return false; // every |
| } |
| } |
| return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; |
| }; |
| }; |
| |
| module.exports = { |
| // `Array.prototype.forEach` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.foreach |
| forEach: createMethod(0), |
| // `Array.prototype.map` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.map |
| map: createMethod(1), |
| // `Array.prototype.filter` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.filter |
| filter: createMethod(2), |
| // `Array.prototype.some` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.some |
| some: createMethod(3), |
| // `Array.prototype.every` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.every |
| every: createMethod(4), |
| // `Array.prototype.find` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.find |
| find: createMethod(5), |
| // `Array.prototype.findIndex` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex |
| findIndex: createMethod(6) |
| }; |
| |
| },{"../internals/array-species-create":25,"../internals/bind-context":26,"../internals/indexed-object":69,"../internals/to-length":140,"../internals/to-object":141}],22:[function(require,module,exports){ |
| 'use strict'; |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var toInteger = require('../internals/to-integer'); |
| var toLength = require('../internals/to-length'); |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| var min = Math.min; |
| var nativeLastIndexOf = [].lastIndexOf; |
| var NEGATIVE_ZERO = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0; |
| var SLOPPY_METHOD = sloppyArrayMethod('lastIndexOf'); |
| |
| // `Array.prototype.lastIndexOf` method implementation |
| // https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof |
| module.exports = (NEGATIVE_ZERO || SLOPPY_METHOD) ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { |
| // convert -0 to +0 |
| if (NEGATIVE_ZERO) return nativeLastIndexOf.apply(this, arguments) || 0; |
| var O = toIndexedObject(this); |
| var length = toLength(O.length); |
| var index = length - 1; |
| if (arguments.length > 1) index = min(index, toInteger(arguments[1])); |
| if (index < 0) index = length + index; |
| for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0; |
| return -1; |
| } : nativeLastIndexOf; |
| |
| },{"../internals/sloppy-array-method":128,"../internals/to-indexed-object":138,"../internals/to-integer":139,"../internals/to-length":140}],23:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| |
| module.exports = function (METHOD_NAME) { |
| return !fails(function () { |
| var array = []; |
| var constructor = array.constructor = {}; |
| constructor[SPECIES] = function () { |
| return { foo: 1 }; |
| }; |
| return array[METHOD_NAME](Boolean).foo !== 1; |
| }); |
| }; |
| |
| },{"../internals/fails":50,"../internals/well-known-symbol":150}],24:[function(require,module,exports){ |
| var aFunction = require('../internals/a-function'); |
| var toObject = require('../internals/to-object'); |
| var IndexedObject = require('../internals/indexed-object'); |
| var toLength = require('../internals/to-length'); |
| |
| // `Array.prototype.{ reduce, reduceRight }` methods implementation |
| var createMethod = function (IS_RIGHT) { |
| return function (that, callbackfn, argumentsLength, memo) { |
| aFunction(callbackfn); |
| var O = toObject(that); |
| var self = IndexedObject(O); |
| var length = toLength(O.length); |
| var index = IS_RIGHT ? length - 1 : 0; |
| var i = IS_RIGHT ? -1 : 1; |
| if (argumentsLength < 2) while (true) { |
| if (index in self) { |
| memo = self[index]; |
| index += i; |
| break; |
| } |
| index += i; |
| if (IS_RIGHT ? index < 0 : length <= index) { |
| throw TypeError('Reduce of empty array with no initial value'); |
| } |
| } |
| for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) { |
| memo = callbackfn(memo, self[index], index, O); |
| } |
| return memo; |
| }; |
| }; |
| |
| module.exports = { |
| // `Array.prototype.reduce` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.reduce |
| left: createMethod(false), |
| // `Array.prototype.reduceRight` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.reduceright |
| right: createMethod(true) |
| }; |
| |
| },{"../internals/a-function":8,"../internals/indexed-object":69,"../internals/to-length":140,"../internals/to-object":141}],25:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| var isArray = require('../internals/is-array'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| |
| // `ArraySpeciesCreate` abstract operation |
| // https://tc39.github.io/ecma262/#sec-arrayspeciescreate |
| module.exports = function (originalArray, length) { |
| var C; |
| if (isArray(originalArray)) { |
| C = originalArray.constructor; |
| // cross-realm fallback |
| if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; |
| else if (isObject(C)) { |
| C = C[SPECIES]; |
| if (C === null) C = undefined; |
| } |
| } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); |
| }; |
| |
| },{"../internals/is-array":74,"../internals/is-object":77,"../internals/well-known-symbol":150}],26:[function(require,module,exports){ |
| var aFunction = require('../internals/a-function'); |
| |
| // optional / simple context binding |
| module.exports = function (fn, that, length) { |
| aFunction(fn); |
| if (that === undefined) return fn; |
| switch (length) { |
| case 0: return function () { |
| return fn.call(that); |
| }; |
| case 1: return function (a) { |
| return fn.call(that, a); |
| }; |
| case 2: return function (a, b) { |
| return fn.call(that, a, b); |
| }; |
| case 3: return function (a, b, c) { |
| return fn.call(that, a, b, c); |
| }; |
| } |
| return function (/* ...args */) { |
| return fn.apply(that, arguments); |
| }; |
| }; |
| |
| },{"../internals/a-function":8}],27:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| |
| // call something on iterator step with safe closing on error |
| module.exports = function (iterator, fn, value, ENTRIES) { |
| try { |
| return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); |
| // 7.4.6 IteratorClose(iterator, completion) |
| } catch (error) { |
| var returnMethod = iterator['return']; |
| if (returnMethod !== undefined) anObject(returnMethod.call(iterator)); |
| throw error; |
| } |
| }; |
| |
| },{"../internals/an-object":13}],28:[function(require,module,exports){ |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var SAFE_CLOSING = false; |
| |
| try { |
| var called = 0; |
| var iteratorWithReturn = { |
| next: function () { |
| return { done: !!called++ }; |
| }, |
| 'return': function () { |
| SAFE_CLOSING = true; |
| } |
| }; |
| iteratorWithReturn[ITERATOR] = function () { |
| return this; |
| }; |
| // eslint-disable-next-line no-throw-literal |
| Array.from(iteratorWithReturn, function () { throw 2; }); |
| } catch (error) { /* empty */ } |
| |
| module.exports = function (exec, SKIP_CLOSING) { |
| if (!SKIP_CLOSING && !SAFE_CLOSING) return false; |
| var ITERATION_SUPPORT = false; |
| try { |
| var object = {}; |
| object[ITERATOR] = function () { |
| return { |
| next: function () { |
| return { done: ITERATION_SUPPORT = true }; |
| } |
| }; |
| }; |
| exec(object); |
| } catch (error) { /* empty */ } |
| return ITERATION_SUPPORT; |
| }; |
| |
| },{"../internals/well-known-symbol":150}],29:[function(require,module,exports){ |
| var toString = {}.toString; |
| |
| module.exports = function (it) { |
| return toString.call(it).slice(8, -1); |
| }; |
| |
| },{}],30:[function(require,module,exports){ |
| var classofRaw = require('../internals/classof-raw'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var TO_STRING_TAG = wellKnownSymbol('toStringTag'); |
| // ES3 wrong here |
| var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; |
| |
| // fallback for IE11 Script Access Denied error |
| var tryGet = function (it, key) { |
| try { |
| return it[key]; |
| } catch (error) { /* empty */ } |
| }; |
| |
| // getting tag from ES6+ `Object.prototype.toString` |
| module.exports = function (it) { |
| var O, tag, result; |
| return it === undefined ? 'Undefined' : it === null ? 'Null' |
| // @@toStringTag case |
| : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag |
| // builtinTag case |
| : CORRECT_ARGUMENTS ? classofRaw(O) |
| // ES3 arguments fallback |
| : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; |
| }; |
| |
| },{"../internals/classof-raw":29,"../internals/well-known-symbol":150}],31:[function(require,module,exports){ |
| 'use strict'; |
| var defineProperty = require('../internals/object-define-property').f; |
| var create = require('../internals/object-create'); |
| var redefineAll = require('../internals/redefine-all'); |
| var bind = require('../internals/bind-context'); |
| var anInstance = require('../internals/an-instance'); |
| var iterate = require('../internals/iterate'); |
| var defineIterator = require('../internals/define-iterator'); |
| var setSpecies = require('../internals/set-species'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var fastKey = require('../internals/internal-metadata').fastKey; |
| var InternalStateModule = require('../internals/internal-state'); |
| |
| var setInternalState = InternalStateModule.set; |
| var internalStateGetterFor = InternalStateModule.getterFor; |
| |
| module.exports = { |
| getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { |
| var C = wrapper(function (that, iterable) { |
| anInstance(that, C, CONSTRUCTOR_NAME); |
| setInternalState(that, { |
| type: CONSTRUCTOR_NAME, |
| index: create(null), |
| first: undefined, |
| last: undefined, |
| size: 0 |
| }); |
| if (!DESCRIPTORS) that.size = 0; |
| if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); |
| }); |
| |
| var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); |
| |
| var define = function (that, key, value) { |
| var state = getInternalState(that); |
| var entry = getEntry(that, key); |
| var previous, index; |
| // change existing entry |
| if (entry) { |
| entry.value = value; |
| // create new entry |
| } else { |
| state.last = entry = { |
| index: index = fastKey(key, true), |
| key: key, |
| value: value, |
| previous: previous = state.last, |
| next: undefined, |
| removed: false |
| }; |
| if (!state.first) state.first = entry; |
| if (previous) previous.next = entry; |
| if (DESCRIPTORS) state.size++; |
| else that.size++; |
| // add to index |
| if (index !== 'F') state.index[index] = entry; |
| } return that; |
| }; |
| |
| var getEntry = function (that, key) { |
| var state = getInternalState(that); |
| // fast case |
| var index = fastKey(key); |
| var entry; |
| if (index !== 'F') return state.index[index]; |
| // frozen object case |
| for (entry = state.first; entry; entry = entry.next) { |
| if (entry.key == key) return entry; |
| } |
| }; |
| |
| redefineAll(C.prototype, { |
| // 23.1.3.1 Map.prototype.clear() |
| // 23.2.3.2 Set.prototype.clear() |
| clear: function clear() { |
| var that = this; |
| var state = getInternalState(that); |
| var data = state.index; |
| var entry = state.first; |
| while (entry) { |
| entry.removed = true; |
| if (entry.previous) entry.previous = entry.previous.next = undefined; |
| delete data[entry.index]; |
| entry = entry.next; |
| } |
| state.first = state.last = undefined; |
| if (DESCRIPTORS) state.size = 0; |
| else that.size = 0; |
| }, |
| // 23.1.3.3 Map.prototype.delete(key) |
| // 23.2.3.4 Set.prototype.delete(value) |
| 'delete': function (key) { |
| var that = this; |
| var state = getInternalState(that); |
| var entry = getEntry(that, key); |
| if (entry) { |
| var next = entry.next; |
| var prev = entry.previous; |
| delete state.index[entry.index]; |
| entry.removed = true; |
| if (prev) prev.next = next; |
| if (next) next.previous = prev; |
| if (state.first == entry) state.first = next; |
| if (state.last == entry) state.last = prev; |
| if (DESCRIPTORS) state.size--; |
| else that.size--; |
| } return !!entry; |
| }, |
| // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) |
| // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) |
| forEach: function forEach(callbackfn /* , that = undefined */) { |
| var state = getInternalState(this); |
| var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); |
| var entry; |
| while (entry = entry ? entry.next : state.first) { |
| boundFunction(entry.value, entry.key, this); |
| // revert to the last existing entry |
| while (entry && entry.removed) entry = entry.previous; |
| } |
| }, |
| // 23.1.3.7 Map.prototype.has(key) |
| // 23.2.3.7 Set.prototype.has(value) |
| has: function has(key) { |
| return !!getEntry(this, key); |
| } |
| }); |
| |
| redefineAll(C.prototype, IS_MAP ? { |
| // 23.1.3.6 Map.prototype.get(key) |
| get: function get(key) { |
| var entry = getEntry(this, key); |
| return entry && entry.value; |
| }, |
| // 23.1.3.9 Map.prototype.set(key, value) |
| set: function set(key, value) { |
| return define(this, key === 0 ? 0 : key, value); |
| } |
| } : { |
| // 23.2.3.1 Set.prototype.add(value) |
| add: function add(value) { |
| return define(this, value = value === 0 ? 0 : value, value); |
| } |
| }); |
| if (DESCRIPTORS) defineProperty(C.prototype, 'size', { |
| get: function () { |
| return getInternalState(this).size; |
| } |
| }); |
| return C; |
| }, |
| setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) { |
| var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; |
| var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); |
| var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); |
| // add .keys, .values, .entries, [@@iterator] |
| // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 |
| defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) { |
| setInternalState(this, { |
| type: ITERATOR_NAME, |
| target: iterated, |
| state: getInternalCollectionState(iterated), |
| kind: kind, |
| last: undefined |
| }); |
| }, function () { |
| var state = getInternalIteratorState(this); |
| var kind = state.kind; |
| var entry = state.last; |
| // revert to the last existing entry |
| while (entry && entry.removed) entry = entry.previous; |
| // get next entry |
| if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { |
| // or finish the iteration |
| state.target = undefined; |
| return { value: undefined, done: true }; |
| } |
| // return step by kind |
| if (kind == 'keys') return { value: entry.key, done: false }; |
| if (kind == 'values') return { value: entry.value, done: false }; |
| return { value: [entry.key, entry.value], done: false }; |
| }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); |
| |
| // add [@@species], 23.1.2.2, 23.2.2.2 |
| setSpecies(CONSTRUCTOR_NAME); |
| } |
| }; |
| |
| },{"../internals/an-instance":12,"../internals/bind-context":26,"../internals/define-iterator":43,"../internals/descriptors":45,"../internals/internal-metadata":71,"../internals/internal-state":72,"../internals/iterate":80,"../internals/object-create":95,"../internals/object-define-property":97,"../internals/redefine-all":116,"../internals/set-species":124}],32:[function(require,module,exports){ |
| 'use strict'; |
| var redefineAll = require('../internals/redefine-all'); |
| var getWeakData = require('../internals/internal-metadata').getWeakData; |
| var anObject = require('../internals/an-object'); |
| var isObject = require('../internals/is-object'); |
| var anInstance = require('../internals/an-instance'); |
| var iterate = require('../internals/iterate'); |
| var ArrayIterationModule = require('../internals/array-iteration'); |
| var $has = require('../internals/has'); |
| var InternalStateModule = require('../internals/internal-state'); |
| |
| var setInternalState = InternalStateModule.set; |
| var internalStateGetterFor = InternalStateModule.getterFor; |
| var find = ArrayIterationModule.find; |
| var findIndex = ArrayIterationModule.findIndex; |
| var id = 0; |
| |
| // fallback for uncaught frozen keys |
| var uncaughtFrozenStore = function (store) { |
| return store.frozen || (store.frozen = new UncaughtFrozenStore()); |
| }; |
| |
| var UncaughtFrozenStore = function () { |
| this.entries = []; |
| }; |
| |
| var findUncaughtFrozen = function (store, key) { |
| return find(store.entries, function (it) { |
| return it[0] === key; |
| }); |
| }; |
| |
| UncaughtFrozenStore.prototype = { |
| get: function (key) { |
| var entry = findUncaughtFrozen(this, key); |
| if (entry) return entry[1]; |
| }, |
| has: function (key) { |
| return !!findUncaughtFrozen(this, key); |
| }, |
| set: function (key, value) { |
| var entry = findUncaughtFrozen(this, key); |
| if (entry) entry[1] = value; |
| else this.entries.push([key, value]); |
| }, |
| 'delete': function (key) { |
| var index = findIndex(this.entries, function (it) { |
| return it[0] === key; |
| }); |
| if (~index) this.entries.splice(index, 1); |
| return !!~index; |
| } |
| }; |
| |
| module.exports = { |
| getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { |
| var C = wrapper(function (that, iterable) { |
| anInstance(that, C, CONSTRUCTOR_NAME); |
| setInternalState(that, { |
| type: CONSTRUCTOR_NAME, |
| id: id++, |
| frozen: undefined |
| }); |
| if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); |
| }); |
| |
| var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); |
| |
| var define = function (that, key, value) { |
| var state = getInternalState(that); |
| var data = getWeakData(anObject(key), true); |
| if (data === true) uncaughtFrozenStore(state).set(key, value); |
| else data[state.id] = value; |
| return that; |
| }; |
| |
| redefineAll(C.prototype, { |
| // 23.3.3.2 WeakMap.prototype.delete(key) |
| // 23.4.3.3 WeakSet.prototype.delete(value) |
| 'delete': function (key) { |
| var state = getInternalState(this); |
| if (!isObject(key)) return false; |
| var data = getWeakData(key); |
| if (data === true) return uncaughtFrozenStore(state)['delete'](key); |
| return data && $has(data, state.id) && delete data[state.id]; |
| }, |
| // 23.3.3.4 WeakMap.prototype.has(key) |
| // 23.4.3.4 WeakSet.prototype.has(value) |
| has: function has(key) { |
| var state = getInternalState(this); |
| if (!isObject(key)) return false; |
| var data = getWeakData(key); |
| if (data === true) return uncaughtFrozenStore(state).has(key); |
| return data && $has(data, state.id); |
| } |
| }); |
| |
| redefineAll(C.prototype, IS_MAP ? { |
| // 23.3.3.3 WeakMap.prototype.get(key) |
| get: function get(key) { |
| var state = getInternalState(this); |
| if (isObject(key)) { |
| var data = getWeakData(key); |
| if (data === true) return uncaughtFrozenStore(state).get(key); |
| return data ? data[state.id] : undefined; |
| } |
| }, |
| // 23.3.3.5 WeakMap.prototype.set(key, value) |
| set: function set(key, value) { |
| return define(this, key, value); |
| } |
| } : { |
| // 23.4.3.1 WeakSet.prototype.add(value) |
| add: function add(value) { |
| return define(this, value, true); |
| } |
| }); |
| |
| return C; |
| } |
| }; |
| |
| },{"../internals/an-instance":12,"../internals/an-object":13,"../internals/array-iteration":21,"../internals/has":63,"../internals/internal-metadata":71,"../internals/internal-state":72,"../internals/is-object":77,"../internals/iterate":80,"../internals/redefine-all":116}],33:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var global = require('../internals/global'); |
| var isForced = require('../internals/is-forced'); |
| var redefine = require('../internals/redefine'); |
| var InternalMetadataModule = require('../internals/internal-metadata'); |
| var iterate = require('../internals/iterate'); |
| var anInstance = require('../internals/an-instance'); |
| var isObject = require('../internals/is-object'); |
| var fails = require('../internals/fails'); |
| var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var inheritIfRequired = require('../internals/inherit-if-required'); |
| |
| module.exports = function (CONSTRUCTOR_NAME, wrapper, common, IS_MAP, IS_WEAK) { |
| var NativeConstructor = global[CONSTRUCTOR_NAME]; |
| var NativePrototype = NativeConstructor && NativeConstructor.prototype; |
| var Constructor = NativeConstructor; |
| var ADDER = IS_MAP ? 'set' : 'add'; |
| var exported = {}; |
| |
| var fixMethod = function (KEY) { |
| var nativeMethod = NativePrototype[KEY]; |
| redefine(NativePrototype, KEY, |
| KEY == 'add' ? function add(a) { |
| nativeMethod.call(this, a === 0 ? 0 : a); |
| return this; |
| } : KEY == 'delete' ? function (a) { |
| return IS_WEAK && !isObject(a) ? false : nativeMethod.call(this, a === 0 ? 0 : a); |
| } : KEY == 'get' ? function get(a) { |
| return IS_WEAK && !isObject(a) ? undefined : nativeMethod.call(this, a === 0 ? 0 : a); |
| } : KEY == 'has' ? function has(a) { |
| return IS_WEAK && !isObject(a) ? false : nativeMethod.call(this, a === 0 ? 0 : a); |
| } : function set(a, b) { |
| nativeMethod.call(this, a === 0 ? 0 : a, b); |
| return this; |
| } |
| ); |
| }; |
| |
| // eslint-disable-next-line max-len |
| if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { |
| new NativeConstructor().entries().next(); |
| })))) { |
| // create collection constructor |
| Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); |
| InternalMetadataModule.REQUIRED = true; |
| } else if (isForced(CONSTRUCTOR_NAME, true)) { |
| var instance = new Constructor(); |
| // early implementations not supports chaining |
| var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; |
| // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false |
| var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); |
| // most early implementations doesn't supports iterables, most modern - not close it correctly |
| // eslint-disable-next-line no-new |
| var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); |
| // for early implementations -0 and +0 not the same |
| var BUGGY_ZERO = !IS_WEAK && fails(function () { |
| // V8 ~ Chromium 42- fails only with 5+ elements |
| var $instance = new NativeConstructor(); |
| var index = 5; |
| while (index--) $instance[ADDER](index, index); |
| return !$instance.has(-0); |
| }); |
| |
| if (!ACCEPT_ITERABLES) { |
| Constructor = wrapper(function (dummy, iterable) { |
| anInstance(dummy, Constructor, CONSTRUCTOR_NAME); |
| var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); |
| if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); |
| return that; |
| }); |
| Constructor.prototype = NativePrototype; |
| NativePrototype.constructor = Constructor; |
| } |
| |
| if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { |
| fixMethod('delete'); |
| fixMethod('has'); |
| IS_MAP && fixMethod('get'); |
| } |
| |
| if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); |
| |
| // weak collections should not contains .clear method |
| if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; |
| } |
| |
| exported[CONSTRUCTOR_NAME] = Constructor; |
| $({ global: true, forced: Constructor != NativeConstructor }, exported); |
| |
| setToStringTag(Constructor, CONSTRUCTOR_NAME); |
| |
| if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); |
| |
| return Constructor; |
| }; |
| |
| },{"../internals/an-instance":12,"../internals/check-correctness-of-iteration":28,"../internals/export":49,"../internals/fails":50,"../internals/global":62,"../internals/inherit-if-required":70,"../internals/internal-metadata":71,"../internals/is-forced":75,"../internals/is-object":77,"../internals/iterate":80,"../internals/redefine":117,"../internals/set-to-string-tag":125}],34:[function(require,module,exports){ |
| var has = require('../internals/has'); |
| var ownKeys = require('../internals/own-keys'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| |
| module.exports = function (target, source) { |
| var keys = ownKeys(source); |
| var defineProperty = definePropertyModule.f; |
| var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; |
| for (var i = 0; i < keys.length; i++) { |
| var key = keys[i]; |
| if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); |
| } |
| }; |
| |
| },{"../internals/has":63,"../internals/object-define-property":97,"../internals/object-get-own-property-descriptor":98,"../internals/own-keys":109}],35:[function(require,module,exports){ |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var MATCH = wellKnownSymbol('match'); |
| |
| module.exports = function (METHOD_NAME) { |
| var regexp = /./; |
| try { |
| '/./'[METHOD_NAME](regexp); |
| } catch (e) { |
| try { |
| regexp[MATCH] = false; |
| return '/./'[METHOD_NAME](regexp); |
| } catch (f) { /* empty */ } |
| } return false; |
| }; |
| |
| },{"../internals/well-known-symbol":150}],36:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| |
| module.exports = !fails(function () { |
| function F() { /* empty */ } |
| F.prototype.constructor = null; |
| return Object.getPrototypeOf(new F()) !== F.prototype; |
| }); |
| |
| },{"../internals/fails":50}],37:[function(require,module,exports){ |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| |
| var quot = /"/g; |
| |
| // B.2.3.2.1 CreateHTML(string, tag, attribute, value) |
| // https://tc39.github.io/ecma262/#sec-createhtml |
| module.exports = function (string, tag, attribute, value) { |
| var S = String(requireObjectCoercible(string)); |
| var p1 = '<' + tag; |
| if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; |
| return p1 + '>' + S + '</' + tag + '>'; |
| }; |
| |
| },{"../internals/require-object-coercible":121}],38:[function(require,module,exports){ |
| 'use strict'; |
| var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype; |
| var create = require('../internals/object-create'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var Iterators = require('../internals/iterators'); |
| |
| var returnThis = function () { return this; }; |
| |
| module.exports = function (IteratorConstructor, NAME, next) { |
| var TO_STRING_TAG = NAME + ' Iterator'; |
| IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) }); |
| setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); |
| Iterators[TO_STRING_TAG] = returnThis; |
| return IteratorConstructor; |
| }; |
| |
| },{"../internals/create-property-descriptor":39,"../internals/iterators":82,"../internals/iterators-core":81,"../internals/object-create":95,"../internals/set-to-string-tag":125}],39:[function(require,module,exports){ |
| module.exports = function (bitmap, value) { |
| return { |
| enumerable: !(bitmap & 1), |
| configurable: !(bitmap & 2), |
| writable: !(bitmap & 4), |
| value: value |
| }; |
| }; |
| |
| },{}],40:[function(require,module,exports){ |
| 'use strict'; |
| var toPrimitive = require('../internals/to-primitive'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| |
| module.exports = function (object, key, value) { |
| var propertyKey = toPrimitive(key); |
| if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); |
| else object[propertyKey] = value; |
| }; |
| |
| },{"../internals/create-property-descriptor":39,"../internals/object-define-property":97,"../internals/to-primitive":143}],41:[function(require,module,exports){ |
| 'use strict'; |
| var fails = require('../internals/fails'); |
| var padStart = require('../internals/string-pad').start; |
| |
| var abs = Math.abs; |
| var DatePrototype = Date.prototype; |
| var getTime = DatePrototype.getTime; |
| var nativeDateToISOString = DatePrototype.toISOString; |
| |
| // `Date.prototype.toISOString` method implementation |
| // https://tc39.github.io/ecma262/#sec-date.prototype.toisostring |
| // PhantomJS / old WebKit fails here: |
| module.exports = (fails(function () { |
| return nativeDateToISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z'; |
| }) || !fails(function () { |
| nativeDateToISOString.call(new Date(NaN)); |
| })) ? function toISOString() { |
| if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value'); |
| var date = this; |
| var year = date.getUTCFullYear(); |
| var milliseconds = date.getUTCMilliseconds(); |
| var sign = year < 0 ? '-' : year > 9999 ? '+' : ''; |
| return sign + padStart(abs(year), sign ? 6 : 4, 0) + |
| '-' + padStart(date.getUTCMonth() + 1, 2, 0) + |
| '-' + padStart(date.getUTCDate(), 2, 0) + |
| 'T' + padStart(date.getUTCHours(), 2, 0) + |
| ':' + padStart(date.getUTCMinutes(), 2, 0) + |
| ':' + padStart(date.getUTCSeconds(), 2, 0) + |
| '.' + padStart(milliseconds, 3, 0) + |
| 'Z'; |
| } : nativeDateToISOString; |
| |
| },{"../internals/fails":50,"../internals/string-pad":131}],42:[function(require,module,exports){ |
| 'use strict'; |
| var anObject = require('../internals/an-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| |
| module.exports = function (hint) { |
| if (hint !== 'string' && hint !== 'number' && hint !== 'default') { |
| throw TypeError('Incorrect hint'); |
| } return toPrimitive(anObject(this), hint !== 'number'); |
| }; |
| |
| },{"../internals/an-object":13,"../internals/to-primitive":143}],43:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createIteratorConstructor = require('../internals/create-iterator-constructor'); |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var setPrototypeOf = require('../internals/object-set-prototype-of'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var hide = require('../internals/hide'); |
| var redefine = require('../internals/redefine'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var IS_PURE = require('../internals/is-pure'); |
| var Iterators = require('../internals/iterators'); |
| var IteratorsCore = require('../internals/iterators-core'); |
| |
| var IteratorPrototype = IteratorsCore.IteratorPrototype; |
| var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var KEYS = 'keys'; |
| var VALUES = 'values'; |
| var ENTRIES = 'entries'; |
| |
| var returnThis = function () { return this; }; |
| |
| module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { |
| createIteratorConstructor(IteratorConstructor, NAME, next); |
| |
| var getIterationMethod = function (KIND) { |
| if (KIND === DEFAULT && defaultIterator) return defaultIterator; |
| if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND]; |
| switch (KIND) { |
| case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; |
| case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; |
| case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; |
| } return function () { return new IteratorConstructor(this); }; |
| }; |
| |
| var TO_STRING_TAG = NAME + ' Iterator'; |
| var INCORRECT_VALUES_NAME = false; |
| var IterablePrototype = Iterable.prototype; |
| var nativeIterator = IterablePrototype[ITERATOR] |
| || IterablePrototype['@@iterator'] |
| || DEFAULT && IterablePrototype[DEFAULT]; |
| var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); |
| var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; |
| var CurrentIteratorPrototype, methods, KEY; |
| |
| // fix native |
| if (anyNativeIterator) { |
| CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); |
| if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { |
| if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { |
| if (setPrototypeOf) { |
| setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); |
| } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') { |
| hide(CurrentIteratorPrototype, ITERATOR, returnThis); |
| } |
| } |
| // Set @@toStringTag to native iterators |
| setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); |
| if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis; |
| } |
| } |
| |
| // fix Array#{values, @@iterator}.name in V8 / FF |
| if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { |
| INCORRECT_VALUES_NAME = true; |
| defaultIterator = function values() { return nativeIterator.call(this); }; |
| } |
| |
| // define iterator |
| if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { |
| hide(IterablePrototype, ITERATOR, defaultIterator); |
| } |
| Iterators[NAME] = defaultIterator; |
| |
| // export additional methods |
| if (DEFAULT) { |
| methods = { |
| values: getIterationMethod(VALUES), |
| keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), |
| entries: getIterationMethod(ENTRIES) |
| }; |
| if (FORCED) for (KEY in methods) { |
| if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { |
| redefine(IterablePrototype, KEY, methods[KEY]); |
| } |
| } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); |
| } |
| |
| return methods; |
| }; |
| |
| },{"../internals/create-iterator-constructor":38,"../internals/export":49,"../internals/hide":65,"../internals/is-pure":78,"../internals/iterators":82,"../internals/iterators-core":81,"../internals/object-get-prototype-of":102,"../internals/object-set-prototype-of":106,"../internals/redefine":117,"../internals/set-to-string-tag":125,"../internals/well-known-symbol":150}],44:[function(require,module,exports){ |
| var path = require('../internals/path'); |
| var has = require('../internals/has'); |
| var wrappedWellKnownSymbolModule = require('../internals/wrapped-well-known-symbol'); |
| var defineProperty = require('../internals/object-define-property').f; |
| |
| module.exports = function (NAME) { |
| var Symbol = path.Symbol || (path.Symbol = {}); |
| if (!has(Symbol, NAME)) defineProperty(Symbol, NAME, { |
| value: wrappedWellKnownSymbolModule.f(NAME) |
| }); |
| }; |
| |
| },{"../internals/has":63,"../internals/object-define-property":97,"../internals/path":112,"../internals/wrapped-well-known-symbol":152}],45:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| |
| // Thank's IE8 for his funny defineProperty |
| module.exports = !fails(function () { |
| return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; |
| }); |
| |
| },{"../internals/fails":50}],46:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var isObject = require('../internals/is-object'); |
| |
| var document = global.document; |
| // typeof document.createElement is 'object' in old IE |
| var EXISTS = isObject(document) && isObject(document.createElement); |
| |
| module.exports = function (it) { |
| return EXISTS ? document.createElement(it) : {}; |
| }; |
| |
| },{"../internals/global":62,"../internals/is-object":77}],47:[function(require,module,exports){ |
| // iterable DOM collections |
| // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods |
| module.exports = { |
| CSSRuleList: 0, |
| CSSStyleDeclaration: 0, |
| CSSValueList: 0, |
| ClientRectList: 0, |
| DOMRectList: 0, |
| DOMStringList: 0, |
| DOMTokenList: 1, |
| DataTransferItemList: 0, |
| FileList: 0, |
| HTMLAllCollection: 0, |
| HTMLCollection: 0, |
| HTMLFormElement: 0, |
| HTMLSelectElement: 0, |
| MediaList: 0, |
| MimeTypeArray: 0, |
| NamedNodeMap: 0, |
| NodeList: 1, |
| PaintRequestList: 0, |
| Plugin: 0, |
| PluginArray: 0, |
| SVGLengthList: 0, |
| SVGNumberList: 0, |
| SVGPathSegList: 0, |
| SVGPointList: 0, |
| SVGStringList: 0, |
| SVGTransformList: 0, |
| SourceBufferList: 0, |
| StyleSheetList: 0, |
| TextTrackCueList: 0, |
| TextTrackList: 0, |
| TouchList: 0 |
| }; |
| |
| },{}],48:[function(require,module,exports){ |
| // IE8- don't enum bug keys |
| module.exports = [ |
| 'constructor', |
| 'hasOwnProperty', |
| 'isPrototypeOf', |
| 'propertyIsEnumerable', |
| 'toLocaleString', |
| 'toString', |
| 'valueOf' |
| ]; |
| |
| },{}],49:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| var hide = require('../internals/hide'); |
| var redefine = require('../internals/redefine'); |
| var setGlobal = require('../internals/set-global'); |
| var copyConstructorProperties = require('../internals/copy-constructor-properties'); |
| var isForced = require('../internals/is-forced'); |
| |
| /* |
| options.target - name of the target object |
| options.global - target is the global object |
| options.stat - export as static methods of target |
| options.proto - export as prototype methods of target |
| options.real - real prototype method for the `pure` version |
| options.forced - export even if the native feature is available |
| options.bind - bind methods to the target, required for the `pure` version |
| options.wrap - wrap constructors to preventing global pollution, required for the `pure` version |
| options.unsafe - use the simple assignment of property instead of delete + defineProperty |
| options.sham - add a flag to not completely full polyfills |
| options.enumerable - export as enumerable property |
| options.noTargetGet - prevent calling a getter on target |
| */ |
| module.exports = function (options, source) { |
| var TARGET = options.target; |
| var GLOBAL = options.global; |
| var STATIC = options.stat; |
| var FORCED, target, key, targetProperty, sourceProperty, descriptor; |
| if (GLOBAL) { |
| target = global; |
| } else if (STATIC) { |
| target = global[TARGET] || setGlobal(TARGET, {}); |
| } else { |
| target = (global[TARGET] || {}).prototype; |
| } |
| if (target) for (key in source) { |
| sourceProperty = source[key]; |
| if (options.noTargetGet) { |
| descriptor = getOwnPropertyDescriptor(target, key); |
| targetProperty = descriptor && descriptor.value; |
| } else targetProperty = target[key]; |
| FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); |
| // contained in target |
| if (!FORCED && targetProperty !== undefined) { |
| if (typeof sourceProperty === typeof targetProperty) continue; |
| copyConstructorProperties(sourceProperty, targetProperty); |
| } |
| // add a flag to not completely full polyfills |
| if (options.sham || (targetProperty && targetProperty.sham)) { |
| hide(sourceProperty, 'sham', true); |
| } |
| // extend global |
| redefine(target, key, sourceProperty, options); |
| } |
| }; |
| |
| },{"../internals/copy-constructor-properties":34,"../internals/global":62,"../internals/hide":65,"../internals/is-forced":75,"../internals/object-get-own-property-descriptor":98,"../internals/redefine":117,"../internals/set-global":123}],50:[function(require,module,exports){ |
| module.exports = function (exec) { |
| try { |
| return !!exec(); |
| } catch (error) { |
| return true; |
| } |
| }; |
| |
| },{}],51:[function(require,module,exports){ |
| 'use strict'; |
| var hide = require('../internals/hide'); |
| var redefine = require('../internals/redefine'); |
| var fails = require('../internals/fails'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var regexpExec = require('../internals/regexp-exec'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| |
| var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { |
| // #replace needs built-in support for named groups. |
| // #match works fine because it just return the exec results, even if it has |
| // a "grops" property. |
| var re = /./; |
| re.exec = function () { |
| var result = []; |
| result.groups = { a: '7' }; |
| return result; |
| }; |
| return ''.replace(re, '$<a>') !== '7'; |
| }); |
| |
| // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec |
| // Weex JS has frozen built-in prototypes, so use try / catch wrapper |
| var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { |
| var re = /(?:)/; |
| var originalExec = re.exec; |
| re.exec = function () { return originalExec.apply(this, arguments); }; |
| var result = 'ab'.split(re); |
| return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b'; |
| }); |
| |
| module.exports = function (KEY, length, exec, sham) { |
| var SYMBOL = wellKnownSymbol(KEY); |
| |
| var DELEGATES_TO_SYMBOL = !fails(function () { |
| // String methods call symbol-named RegEp methods |
| var O = {}; |
| O[SYMBOL] = function () { return 7; }; |
| return ''[KEY](O) != 7; |
| }); |
| |
| var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { |
| // Symbol-named RegExp methods call .exec |
| var execCalled = false; |
| var re = /a/; |
| re.exec = function () { execCalled = true; return null; }; |
| |
| if (KEY === 'split') { |
| // RegExp[@@split] doesn't call the regex's exec method, but first creates |
| // a new one. We need to return the patched regex when creating the new one. |
| re.constructor = {}; |
| re.constructor[SPECIES] = function () { return re; }; |
| } |
| |
| re[SYMBOL](''); |
| return !execCalled; |
| }); |
| |
| if ( |
| !DELEGATES_TO_SYMBOL || |
| !DELEGATES_TO_EXEC || |
| (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) || |
| (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) |
| ) { |
| var nativeRegExpMethod = /./[SYMBOL]; |
| var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { |
| if (regexp.exec === regexpExec) { |
| if (DELEGATES_TO_SYMBOL && !forceStringMethod) { |
| // The native String method already delegates to @@method (this |
| // polyfilled function), leasing to infinite recursion. |
| // We avoid it by directly calling the native @@method method. |
| return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; |
| } |
| return { done: true, value: nativeMethod.call(str, regexp, arg2) }; |
| } |
| return { done: false }; |
| }); |
| var stringMethod = methods[0]; |
| var regexMethod = methods[1]; |
| |
| redefine(String.prototype, KEY, stringMethod); |
| redefine(RegExp.prototype, SYMBOL, length == 2 |
| // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) |
| // 21.2.5.11 RegExp.prototype[@@split](string, limit) |
| ? function (string, arg) { return regexMethod.call(string, this, arg); } |
| // 21.2.5.6 RegExp.prototype[@@match](string) |
| // 21.2.5.9 RegExp.prototype[@@search](string) |
| : function (string) { return regexMethod.call(string, this); } |
| ); |
| if (sham) hide(RegExp.prototype[SYMBOL], 'sham', true); |
| } |
| }; |
| |
| },{"../internals/fails":50,"../internals/hide":65,"../internals/redefine":117,"../internals/regexp-exec":119,"../internals/well-known-symbol":150}],52:[function(require,module,exports){ |
| 'use strict'; |
| var isArray = require('../internals/is-array'); |
| var toLength = require('../internals/to-length'); |
| var bind = require('../internals/bind-context'); |
| |
| // `FlattenIntoArray` abstract operation |
| // https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray |
| var flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) { |
| var targetIndex = start; |
| var sourceIndex = 0; |
| var mapFn = mapper ? bind(mapper, thisArg, 3) : false; |
| var element; |
| |
| while (sourceIndex < sourceLen) { |
| if (sourceIndex in source) { |
| element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex]; |
| |
| if (depth > 0 && isArray(element)) { |
| targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1; |
| } else { |
| if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length'); |
| target[targetIndex] = element; |
| } |
| |
| targetIndex++; |
| } |
| sourceIndex++; |
| } |
| return targetIndex; |
| }; |
| |
| module.exports = flattenIntoArray; |
| |
| },{"../internals/bind-context":26,"../internals/is-array":74,"../internals/to-length":140}],53:[function(require,module,exports){ |
| 'use strict'; |
| var IS_PURE = require('../internals/is-pure'); |
| var global = require('../internals/global'); |
| var fails = require('../internals/fails'); |
| |
| // Forced replacement object prototype accessors methods |
| module.exports = IS_PURE || !fails(function () { |
| var key = Math.random(); |
| // In FF throws only define methods |
| // eslint-disable-next-line no-undef, no-useless-call |
| __defineSetter__.call(null, key, function () { /* empty */ }); |
| delete global[key]; |
| }); |
| |
| },{"../internals/fails":50,"../internals/global":62,"../internals/is-pure":78}],54:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| |
| // check the existence of a method, lowercase |
| // of a tag and escaping quotes in arguments |
| module.exports = function (METHOD_NAME) { |
| return fails(function () { |
| var test = ''[METHOD_NAME]('"'); |
| return test !== test.toLowerCase() || test.split('"').length > 3; |
| }); |
| }; |
| |
| },{"../internals/fails":50}],55:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| var whitespaces = require('../internals/whitespaces'); |
| |
| var non = '\u200B\u0085\u180E'; |
| |
| // check that a method works with the correct list |
| // of whitespaces and has a correct name |
| module.exports = function (METHOD_NAME) { |
| return fails(function () { |
| return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME; |
| }); |
| }; |
| |
| },{"../internals/fails":50,"../internals/whitespaces":151}],56:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| |
| module.exports = !fails(function () { |
| return Object.isExtensible(Object.preventExtensions({})); |
| }); |
| |
| },{"../internals/fails":50}],57:[function(require,module,exports){ |
| 'use strict'; |
| var aFunction = require('../internals/a-function'); |
| var isObject = require('../internals/is-object'); |
| |
| var slice = [].slice; |
| var factories = {}; |
| |
| var construct = function (C, argsLength, args) { |
| if (!(argsLength in factories)) { |
| for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']'; |
| // eslint-disable-next-line no-new-func |
| factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')'); |
| } return factories[argsLength](C, args); |
| }; |
| |
| // `Function.prototype.bind` method implementation |
| // https://tc39.github.io/ecma262/#sec-function.prototype.bind |
| module.exports = Function.bind || function bind(that /* , ...args */) { |
| var fn = aFunction(this); |
| var partArgs = slice.call(arguments, 1); |
| var boundFunction = function bound(/* args... */) { |
| var args = partArgs.concat(slice.call(arguments)); |
| return this instanceof boundFunction ? construct(fn, args.length, args) : fn.apply(that, args); |
| }; |
| if (isObject(fn.prototype)) boundFunction.prototype = fn.prototype; |
| return boundFunction; |
| }; |
| |
| },{"../internals/a-function":8,"../internals/is-object":77}],58:[function(require,module,exports){ |
| var shared = require('../internals/shared'); |
| |
| module.exports = shared('native-function-to-string', Function.toString); |
| |
| },{"../internals/shared":127}],59:[function(require,module,exports){ |
| var path = require('../internals/path'); |
| var global = require('../internals/global'); |
| |
| var aFunction = function (variable) { |
| return typeof variable == 'function' ? variable : undefined; |
| }; |
| |
| module.exports = function (namespace, method) { |
| return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) |
| : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method]; |
| }; |
| |
| },{"../internals/global":62,"../internals/path":112}],60:[function(require,module,exports){ |
| var classof = require('../internals/classof'); |
| var Iterators = require('../internals/iterators'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| |
| module.exports = function (it) { |
| if (it != undefined) return it[ITERATOR] |
| || it['@@iterator'] |
| || Iterators[classof(it)]; |
| }; |
| |
| },{"../internals/classof":30,"../internals/iterators":82,"../internals/well-known-symbol":150}],61:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| var getIteratorMethod = require('../internals/get-iterator-method'); |
| |
| module.exports = function (it) { |
| var iteratorMethod = getIteratorMethod(it); |
| if (typeof iteratorMethod != 'function') { |
| throw TypeError(String(it) + ' is not iterable'); |
| } return anObject(iteratorMethod.call(it)); |
| }; |
| |
| },{"../internals/an-object":13,"../internals/get-iterator-method":60}],62:[function(require,module,exports){ |
| (function (global){ |
| var O = 'object'; |
| var check = function (it) { |
| return it && it.Math == Math && it; |
| }; |
| |
| // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 |
| module.exports = |
| // eslint-disable-next-line no-undef |
| check(typeof globalThis == O && globalThis) || |
| check(typeof window == O && window) || |
| check(typeof self == O && self) || |
| check(typeof global == O && global) || |
| // eslint-disable-next-line no-new-func |
| Function('return this')(); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],63:[function(require,module,exports){ |
| var hasOwnProperty = {}.hasOwnProperty; |
| |
| module.exports = function (it, key) { |
| return hasOwnProperty.call(it, key); |
| }; |
| |
| },{}],64:[function(require,module,exports){ |
| module.exports = {}; |
| |
| },{}],65:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| |
| module.exports = DESCRIPTORS ? function (object, key, value) { |
| return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); |
| } : function (object, key, value) { |
| object[key] = value; |
| return object; |
| }; |
| |
| },{"../internals/create-property-descriptor":39,"../internals/descriptors":45,"../internals/object-define-property":97}],66:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| |
| module.exports = function (a, b) { |
| var console = global.console; |
| if (console && console.error) { |
| arguments.length === 1 ? console.error(a) : console.error(a, b); |
| } |
| }; |
| |
| },{"../internals/global":62}],67:[function(require,module,exports){ |
| var getBuiltIn = require('../internals/get-built-in'); |
| |
| module.exports = getBuiltIn('document', 'documentElement'); |
| |
| },{"../internals/get-built-in":59}],68:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var fails = require('../internals/fails'); |
| var createElement = require('../internals/document-create-element'); |
| |
| // Thank's IE8 for his funny defineProperty |
| module.exports = !DESCRIPTORS && !fails(function () { |
| return Object.defineProperty(createElement('div'), 'a', { |
| get: function () { return 7; } |
| }).a != 7; |
| }); |
| |
| },{"../internals/descriptors":45,"../internals/document-create-element":46,"../internals/fails":50}],69:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| var classof = require('../internals/classof-raw'); |
| |
| var split = ''.split; |
| |
| // fallback for non-array-like ES3 and non-enumerable old V8 strings |
| module.exports = fails(function () { |
| // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 |
| // eslint-disable-next-line no-prototype-builtins |
| return !Object('z').propertyIsEnumerable(0); |
| }) ? function (it) { |
| return classof(it) == 'String' ? split.call(it, '') : Object(it); |
| } : Object; |
| |
| },{"../internals/classof-raw":29,"../internals/fails":50}],70:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| var setPrototypeOf = require('../internals/object-set-prototype-of'); |
| |
| // makes subclassing work correct for wrapped built-ins |
| module.exports = function ($this, dummy, Wrapper) { |
| var NewTarget, NewTargetPrototype; |
| if ( |
| // it can work only with native `setPrototypeOf` |
| setPrototypeOf && |
| // we haven't completely correct pre-ES6 way for getting `new.target`, so use this |
| typeof (NewTarget = dummy.constructor) == 'function' && |
| NewTarget !== Wrapper && |
| isObject(NewTargetPrototype = NewTarget.prototype) && |
| NewTargetPrototype !== Wrapper.prototype |
| ) setPrototypeOf($this, NewTargetPrototype); |
| return $this; |
| }; |
| |
| },{"../internals/is-object":77,"../internals/object-set-prototype-of":106}],71:[function(require,module,exports){ |
| var hiddenKeys = require('../internals/hidden-keys'); |
| var isObject = require('../internals/is-object'); |
| var has = require('../internals/has'); |
| var defineProperty = require('../internals/object-define-property').f; |
| var uid = require('../internals/uid'); |
| var FREEZING = require('../internals/freezing'); |
| |
| var METADATA = uid('meta'); |
| var id = 0; |
| |
| var isExtensible = Object.isExtensible || function () { |
| return true; |
| }; |
| |
| var setMetadata = function (it) { |
| defineProperty(it, METADATA, { value: { |
| objectID: 'O' + ++id, // object ID |
| weakData: {} // weak collections IDs |
| } }); |
| }; |
| |
| var fastKey = function (it, create) { |
| // return a primitive with prefix |
| if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; |
| if (!has(it, METADATA)) { |
| // can't set metadata to uncaught frozen object |
| if (!isExtensible(it)) return 'F'; |
| // not necessary to add metadata |
| if (!create) return 'E'; |
| // add missing metadata |
| setMetadata(it); |
| // return object ID |
| } return it[METADATA].objectID; |
| }; |
| |
| var getWeakData = function (it, create) { |
| if (!has(it, METADATA)) { |
| // can't set metadata to uncaught frozen object |
| if (!isExtensible(it)) return true; |
| // not necessary to add metadata |
| if (!create) return false; |
| // add missing metadata |
| setMetadata(it); |
| // return the store of weak collections IDs |
| } return it[METADATA].weakData; |
| }; |
| |
| // add metadata on freeze-family methods calling |
| var onFreeze = function (it) { |
| if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); |
| return it; |
| }; |
| |
| var meta = module.exports = { |
| REQUIRED: false, |
| fastKey: fastKey, |
| getWeakData: getWeakData, |
| onFreeze: onFreeze |
| }; |
| |
| hiddenKeys[METADATA] = true; |
| |
| },{"../internals/freezing":56,"../internals/has":63,"../internals/hidden-keys":64,"../internals/is-object":77,"../internals/object-define-property":97,"../internals/uid":147}],72:[function(require,module,exports){ |
| var NATIVE_WEAK_MAP = require('../internals/native-weak-map'); |
| var global = require('../internals/global'); |
| var isObject = require('../internals/is-object'); |
| var hide = require('../internals/hide'); |
| var objectHas = require('../internals/has'); |
| var sharedKey = require('../internals/shared-key'); |
| var hiddenKeys = require('../internals/hidden-keys'); |
| |
| var WeakMap = global.WeakMap; |
| var set, get, has; |
| |
| var enforce = function (it) { |
| return has(it) ? get(it) : set(it, {}); |
| }; |
| |
| var getterFor = function (TYPE) { |
| return function (it) { |
| var state; |
| if (!isObject(it) || (state = get(it)).type !== TYPE) { |
| throw TypeError('Incompatible receiver, ' + TYPE + ' required'); |
| } return state; |
| }; |
| }; |
| |
| if (NATIVE_WEAK_MAP) { |
| var store = new WeakMap(); |
| var wmget = store.get; |
| var wmhas = store.has; |
| var wmset = store.set; |
| set = function (it, metadata) { |
| wmset.call(store, it, metadata); |
| return metadata; |
| }; |
| get = function (it) { |
| return wmget.call(store, it) || {}; |
| }; |
| has = function (it) { |
| return wmhas.call(store, it); |
| }; |
| } else { |
| var STATE = sharedKey('state'); |
| hiddenKeys[STATE] = true; |
| set = function (it, metadata) { |
| hide(it, STATE, metadata); |
| return metadata; |
| }; |
| get = function (it) { |
| return objectHas(it, STATE) ? it[STATE] : {}; |
| }; |
| has = function (it) { |
| return objectHas(it, STATE); |
| }; |
| } |
| |
| module.exports = { |
| set: set, |
| get: get, |
| has: has, |
| enforce: enforce, |
| getterFor: getterFor |
| }; |
| |
| },{"../internals/global":62,"../internals/has":63,"../internals/hidden-keys":64,"../internals/hide":65,"../internals/is-object":77,"../internals/native-weak-map":90,"../internals/shared-key":126}],73:[function(require,module,exports){ |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var Iterators = require('../internals/iterators'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var ArrayPrototype = Array.prototype; |
| |
| // check on default Array iterator |
| module.exports = function (it) { |
| return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); |
| }; |
| |
| },{"../internals/iterators":82,"../internals/well-known-symbol":150}],74:[function(require,module,exports){ |
| var classof = require('../internals/classof-raw'); |
| |
| // `IsArray` abstract operation |
| // https://tc39.github.io/ecma262/#sec-isarray |
| module.exports = Array.isArray || function isArray(arg) { |
| return classof(arg) == 'Array'; |
| }; |
| |
| },{"../internals/classof-raw":29}],75:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| |
| var replacement = /#|\.prototype\./; |
| |
| var isForced = function (feature, detection) { |
| var value = data[normalize(feature)]; |
| return value == POLYFILL ? true |
| : value == NATIVE ? false |
| : typeof detection == 'function' ? fails(detection) |
| : !!detection; |
| }; |
| |
| var normalize = isForced.normalize = function (string) { |
| return String(string).replace(replacement, '.').toLowerCase(); |
| }; |
| |
| var data = isForced.data = {}; |
| var NATIVE = isForced.NATIVE = 'N'; |
| var POLYFILL = isForced.POLYFILL = 'P'; |
| |
| module.exports = isForced; |
| |
| },{"../internals/fails":50}],76:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| |
| var floor = Math.floor; |
| |
| // `Number.isInteger` method implementation |
| // https://tc39.github.io/ecma262/#sec-number.isinteger |
| module.exports = function isInteger(it) { |
| return !isObject(it) && isFinite(it) && floor(it) === it; |
| }; |
| |
| },{"../internals/is-object":77}],77:[function(require,module,exports){ |
| module.exports = function (it) { |
| return typeof it === 'object' ? it !== null : typeof it === 'function'; |
| }; |
| |
| },{}],78:[function(require,module,exports){ |
| module.exports = false; |
| |
| },{}],79:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| var classof = require('../internals/classof-raw'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var MATCH = wellKnownSymbol('match'); |
| |
| // `IsRegExp` abstract operation |
| // https://tc39.github.io/ecma262/#sec-isregexp |
| module.exports = function (it) { |
| var isRegExp; |
| return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp'); |
| }; |
| |
| },{"../internals/classof-raw":29,"../internals/is-object":77,"../internals/well-known-symbol":150}],80:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| var isArrayIteratorMethod = require('../internals/is-array-iterator-method'); |
| var toLength = require('../internals/to-length'); |
| var bind = require('../internals/bind-context'); |
| var getIteratorMethod = require('../internals/get-iterator-method'); |
| var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing'); |
| |
| var Result = function (stopped, result) { |
| this.stopped = stopped; |
| this.result = result; |
| }; |
| |
| var iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) { |
| var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1); |
| var iterator, iterFn, index, length, result, step; |
| |
| if (IS_ITERATOR) { |
| iterator = iterable; |
| } else { |
| iterFn = getIteratorMethod(iterable); |
| if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); |
| // optimisation for array iterators |
| if (isArrayIteratorMethod(iterFn)) { |
| for (index = 0, length = toLength(iterable.length); length > index; index++) { |
| result = AS_ENTRIES |
| ? boundFunction(anObject(step = iterable[index])[0], step[1]) |
| : boundFunction(iterable[index]); |
| if (result && result instanceof Result) return result; |
| } return new Result(false); |
| } |
| iterator = iterFn.call(iterable); |
| } |
| |
| while (!(step = iterator.next()).done) { |
| result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES); |
| if (result && result instanceof Result) return result; |
| } return new Result(false); |
| }; |
| |
| iterate.stop = function (result) { |
| return new Result(true, result); |
| }; |
| |
| },{"../internals/an-object":13,"../internals/bind-context":26,"../internals/call-with-safe-iteration-closing":27,"../internals/get-iterator-method":60,"../internals/is-array-iterator-method":73,"../internals/to-length":140}],81:[function(require,module,exports){ |
| 'use strict'; |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var hide = require('../internals/hide'); |
| var has = require('../internals/has'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var IS_PURE = require('../internals/is-pure'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var BUGGY_SAFARI_ITERATORS = false; |
| |
| var returnThis = function () { return this; }; |
| |
| // `%IteratorPrototype%` object |
| // https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object |
| var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; |
| |
| if ([].keys) { |
| arrayIterator = [].keys(); |
| // Safari 8 has buggy iterators w/o `next` |
| if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; |
| else { |
| PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); |
| if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; |
| } |
| } |
| |
| if (IteratorPrototype == undefined) IteratorPrototype = {}; |
| |
| // 25.1.2.1.1 %IteratorPrototype%[@@iterator]() |
| if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis); |
| |
| module.exports = { |
| IteratorPrototype: IteratorPrototype, |
| BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS |
| }; |
| |
| },{"../internals/has":63,"../internals/hide":65,"../internals/is-pure":78,"../internals/object-get-prototype-of":102,"../internals/well-known-symbol":150}],82:[function(require,module,exports){ |
| arguments[4][64][0].apply(exports,arguments) |
| },{"dup":64}],83:[function(require,module,exports){ |
| var nativeExpm1 = Math.expm1; |
| var exp = Math.exp; |
| |
| // `Math.expm1` method implementation |
| // https://tc39.github.io/ecma262/#sec-math.expm1 |
| module.exports = (!nativeExpm1 |
| // Old FF bug |
| || nativeExpm1(10) > 22025.465794806719 || nativeExpm1(10) < 22025.4657948067165168 |
| // Tor Browser bug |
| || nativeExpm1(-2e-17) != -2e-17 |
| ) ? function expm1(x) { |
| return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : exp(x) - 1; |
| } : nativeExpm1; |
| |
| },{}],84:[function(require,module,exports){ |
| var sign = require('../internals/math-sign'); |
| |
| var abs = Math.abs; |
| var pow = Math.pow; |
| var EPSILON = pow(2, -52); |
| var EPSILON32 = pow(2, -23); |
| var MAX32 = pow(2, 127) * (2 - EPSILON32); |
| var MIN32 = pow(2, -126); |
| |
| var roundTiesToEven = function (n) { |
| return n + 1 / EPSILON - 1 / EPSILON; |
| }; |
| |
| // `Math.fround` method implementation |
| // https://tc39.github.io/ecma262/#sec-math.fround |
| module.exports = Math.fround || function fround(x) { |
| var $abs = abs(x); |
| var $sign = sign(x); |
| var a, result; |
| if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32; |
| a = (1 + EPSILON32 / EPSILON) * $abs; |
| result = a - (a - $abs); |
| // eslint-disable-next-line no-self-compare |
| if (result > MAX32 || result != result) return $sign * Infinity; |
| return $sign * result; |
| }; |
| |
| },{"../internals/math-sign":86}],85:[function(require,module,exports){ |
| var log = Math.log; |
| |
| // `Math.log1p` method implementation |
| // https://tc39.github.io/ecma262/#sec-math.log1p |
| module.exports = Math.log1p || function log1p(x) { |
| return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : log(1 + x); |
| }; |
| |
| },{}],86:[function(require,module,exports){ |
| // `Math.sign` method implementation |
| // https://tc39.github.io/ecma262/#sec-math.sign |
| module.exports = Math.sign || function sign(x) { |
| // eslint-disable-next-line no-self-compare |
| return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; |
| }; |
| |
| },{}],87:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| var classof = require('../internals/classof-raw'); |
| var macrotask = require('../internals/task').set; |
| var userAgent = require('../internals/user-agent'); |
| |
| var MutationObserver = global.MutationObserver || global.WebKitMutationObserver; |
| var process = global.process; |
| var Promise = global.Promise; |
| var IS_NODE = classof(process) == 'process'; |
| // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` |
| var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask'); |
| var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; |
| |
| var flush, head, last, notify, toggle, node, promise; |
| |
| // modern engines have queueMicrotask method |
| if (!queueMicrotask) { |
| flush = function () { |
| var parent, fn; |
| if (IS_NODE && (parent = process.domain)) parent.exit(); |
| while (head) { |
| fn = head.fn; |
| head = head.next; |
| try { |
| fn(); |
| } catch (error) { |
| if (head) notify(); |
| else last = undefined; |
| throw error; |
| } |
| } last = undefined; |
| if (parent) parent.enter(); |
| }; |
| |
| // Node.js |
| if (IS_NODE) { |
| notify = function () { |
| process.nextTick(flush); |
| }; |
| // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 |
| } else if (MutationObserver && !/(iphone|ipod|ipad).*applewebkit/i.test(userAgent)) { |
| toggle = true; |
| node = document.createTextNode(''); |
| new MutationObserver(flush).observe(node, { characterData: true }); // eslint-disable-line no-new |
| notify = function () { |
| node.data = toggle = !toggle; |
| }; |
| // environments with maybe non-completely correct, but existent Promise |
| } else if (Promise && Promise.resolve) { |
| // Promise.resolve without an argument throws an error in LG WebOS 2 |
| promise = Promise.resolve(undefined); |
| notify = function () { |
| promise.then(flush); |
| }; |
| // for other environments - macrotask based on: |
| // - setImmediate |
| // - MessageChannel |
| // - window.postMessag |
| // - onreadystatechange |
| // - setTimeout |
| } else { |
| notify = function () { |
| // strange IE + webpack dev server bug - use .call(global) |
| macrotask.call(global, flush); |
| }; |
| } |
| } |
| |
| module.exports = queueMicrotask || function (fn) { |
| var task = { fn: fn, next: undefined }; |
| if (last) last.next = task; |
| if (!head) { |
| head = task; |
| notify(); |
| } last = task; |
| }; |
| |
| },{"../internals/classof-raw":29,"../internals/global":62,"../internals/object-get-own-property-descriptor":98,"../internals/task":134,"../internals/user-agent":148}],88:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| |
| module.exports = !!Object.getOwnPropertySymbols && !fails(function () { |
| // Chrome 38 Symbol has incorrect toString conversion |
| // eslint-disable-next-line no-undef |
| return !String(Symbol()); |
| }); |
| |
| },{"../internals/fails":50}],89:[function(require,module,exports){ |
| var fails = require('../internals/fails'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var IS_PURE = require('../internals/is-pure'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| |
| module.exports = !fails(function () { |
| var url = new URL('b?e=1', 'http://a'); |
| var searchParams = url.searchParams; |
| url.pathname = 'c%20d'; |
| return (IS_PURE && !url.toJSON) |
| || !searchParams.sort |
| || url.href !== 'http://a/c%20d?e=1' |
| || searchParams.get('e') !== '1' |
| || String(new URLSearchParams('?a=1')) !== 'a=1' |
| || !searchParams[ITERATOR] |
| // throws in Edge |
| || new URL('https://a@b').username !== 'a' |
| || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' |
| // not punycoded in Edge |
| || new URL('http://тест').host !== 'xn--e1aybc' |
| // not escaped in Chrome 62- |
| || new URL('http://a#б').hash !== '#%D0%B1'; |
| }); |
| |
| },{"../internals/fails":50,"../internals/is-pure":78,"../internals/well-known-symbol":150}],90:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var nativeFunctionToString = require('../internals/function-to-string'); |
| |
| var WeakMap = global.WeakMap; |
| |
| module.exports = typeof WeakMap === 'function' && /native code/.test(nativeFunctionToString.call(WeakMap)); |
| |
| },{"../internals/function-to-string":58,"../internals/global":62}],91:[function(require,module,exports){ |
| 'use strict'; |
| var aFunction = require('../internals/a-function'); |
| |
| var PromiseCapability = function (C) { |
| var resolve, reject; |
| this.promise = new C(function ($$resolve, $$reject) { |
| if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); |
| resolve = $$resolve; |
| reject = $$reject; |
| }); |
| this.resolve = aFunction(resolve); |
| this.reject = aFunction(reject); |
| }; |
| |
| // 25.4.1.5 NewPromiseCapability(C) |
| module.exports.f = function (C) { |
| return new PromiseCapability(C); |
| }; |
| |
| },{"../internals/a-function":8}],92:[function(require,module,exports){ |
| var isRegExp = require('../internals/is-regexp'); |
| |
| module.exports = function (it) { |
| if (isRegExp(it)) { |
| throw TypeError("The method doesn't accept regular expressions"); |
| } return it; |
| }; |
| |
| },{"../internals/is-regexp":79}],93:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| |
| var globalIsFinite = global.isFinite; |
| |
| // `Number.isFinite` method |
| // https://tc39.github.io/ecma262/#sec-number.isfinite |
| module.exports = Number.isFinite || function isFinite(it) { |
| return typeof it == 'number' && globalIsFinite(it); |
| }; |
| |
| },{"../internals/global":62}],94:[function(require,module,exports){ |
| 'use strict'; |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var fails = require('../internals/fails'); |
| var objectKeys = require('../internals/object-keys'); |
| var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols'); |
| var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable'); |
| var toObject = require('../internals/to-object'); |
| var IndexedObject = require('../internals/indexed-object'); |
| |
| var nativeAssign = Object.assign; |
| |
| // `Object.assign` method |
| // https://tc39.github.io/ecma262/#sec-object.assign |
| // should work with symbols and should have deterministic property order (V8 bug) |
| module.exports = !nativeAssign || fails(function () { |
| var A = {}; |
| var B = {}; |
| // eslint-disable-next-line no-undef |
| var symbol = Symbol(); |
| var alphabet = 'abcdefghijklmnopqrst'; |
| A[symbol] = 7; |
| alphabet.split('').forEach(function (chr) { B[chr] = chr; }); |
| return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet; |
| }) ? function assign(target, source) { // eslint-disable-line no-unused-vars |
| var T = toObject(target); |
| var argumentsLength = arguments.length; |
| var index = 1; |
| var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; |
| var propertyIsEnumerable = propertyIsEnumerableModule.f; |
| while (argumentsLength > index) { |
| var S = IndexedObject(arguments[index++]); |
| var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S); |
| var length = keys.length; |
| var j = 0; |
| var key; |
| while (length > j) { |
| key = keys[j++]; |
| if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key]; |
| } |
| } return T; |
| } : nativeAssign; |
| |
| },{"../internals/descriptors":45,"../internals/fails":50,"../internals/indexed-object":69,"../internals/object-get-own-property-symbols":101,"../internals/object-keys":104,"../internals/object-property-is-enumerable":105,"../internals/to-object":141}],95:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| var defineProperties = require('../internals/object-define-properties'); |
| var enumBugKeys = require('../internals/enum-bug-keys'); |
| var hiddenKeys = require('../internals/hidden-keys'); |
| var html = require('../internals/html'); |
| var documentCreateElement = require('../internals/document-create-element'); |
| var sharedKey = require('../internals/shared-key'); |
| var IE_PROTO = sharedKey('IE_PROTO'); |
| |
| var PROTOTYPE = 'prototype'; |
| var Empty = function () { /* empty */ }; |
| |
| // Create object with fake `null` prototype: use iframe Object with cleared prototype |
| var createDict = function () { |
| // Thrash, waste and sodomy: IE GC bug |
| var iframe = documentCreateElement('iframe'); |
| var length = enumBugKeys.length; |
| var lt = '<'; |
| var script = 'script'; |
| var gt = '>'; |
| var js = 'java' + script + ':'; |
| var iframeDocument; |
| iframe.style.display = 'none'; |
| html.appendChild(iframe); |
| iframe.src = String(js); |
| iframeDocument = iframe.contentWindow.document; |
| iframeDocument.open(); |
| iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt); |
| iframeDocument.close(); |
| createDict = iframeDocument.F; |
| while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]]; |
| return createDict(); |
| }; |
| |
| // `Object.create` method |
| // https://tc39.github.io/ecma262/#sec-object.create |
| module.exports = Object.create || function create(O, Properties) { |
| var result; |
| if (O !== null) { |
| Empty[PROTOTYPE] = anObject(O); |
| result = new Empty(); |
| Empty[PROTOTYPE] = null; |
| // add "__proto__" for Object.getPrototypeOf polyfill |
| result[IE_PROTO] = O; |
| } else result = createDict(); |
| return Properties === undefined ? result : defineProperties(result, Properties); |
| }; |
| |
| hiddenKeys[IE_PROTO] = true; |
| |
| },{"../internals/an-object":13,"../internals/document-create-element":46,"../internals/enum-bug-keys":48,"../internals/hidden-keys":64,"../internals/html":67,"../internals/object-define-properties":96,"../internals/shared-key":126}],96:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var anObject = require('../internals/an-object'); |
| var objectKeys = require('../internals/object-keys'); |
| |
| // `Object.defineProperties` method |
| // https://tc39.github.io/ecma262/#sec-object.defineproperties |
| module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { |
| anObject(O); |
| var keys = objectKeys(Properties); |
| var length = keys.length; |
| var index = 0; |
| var key; |
| while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]); |
| return O; |
| }; |
| |
| },{"../internals/an-object":13,"../internals/descriptors":45,"../internals/object-define-property":97,"../internals/object-keys":104}],97:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var IE8_DOM_DEFINE = require('../internals/ie8-dom-define'); |
| var anObject = require('../internals/an-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| |
| var nativeDefineProperty = Object.defineProperty; |
| |
| // `Object.defineProperty` method |
| // https://tc39.github.io/ecma262/#sec-object.defineproperty |
| exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) { |
| anObject(O); |
| P = toPrimitive(P, true); |
| anObject(Attributes); |
| if (IE8_DOM_DEFINE) try { |
| return nativeDefineProperty(O, P, Attributes); |
| } catch (error) { /* empty */ } |
| if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); |
| if ('value' in Attributes) O[P] = Attributes.value; |
| return O; |
| }; |
| |
| },{"../internals/an-object":13,"../internals/descriptors":45,"../internals/ie8-dom-define":68,"../internals/to-primitive":143}],98:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var has = require('../internals/has'); |
| var IE8_DOM_DEFINE = require('../internals/ie8-dom-define'); |
| |
| var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; |
| |
| // `Object.getOwnPropertyDescriptor` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor |
| exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { |
| O = toIndexedObject(O); |
| P = toPrimitive(P, true); |
| if (IE8_DOM_DEFINE) try { |
| return nativeGetOwnPropertyDescriptor(O, P); |
| } catch (error) { /* empty */ } |
| if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); |
| }; |
| |
| },{"../internals/create-property-descriptor":39,"../internals/descriptors":45,"../internals/has":63,"../internals/ie8-dom-define":68,"../internals/object-property-is-enumerable":105,"../internals/to-indexed-object":138,"../internals/to-primitive":143}],99:[function(require,module,exports){ |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var nativeGetOwnPropertyNames = require('../internals/object-get-own-property-names').f; |
| |
| var toString = {}.toString; |
| |
| var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames |
| ? Object.getOwnPropertyNames(window) : []; |
| |
| var getWindowNames = function (it) { |
| try { |
| return nativeGetOwnPropertyNames(it); |
| } catch (error) { |
| return windowNames.slice(); |
| } |
| }; |
| |
| // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window |
| module.exports.f = function getOwnPropertyNames(it) { |
| return windowNames && toString.call(it) == '[object Window]' |
| ? getWindowNames(it) |
| : nativeGetOwnPropertyNames(toIndexedObject(it)); |
| }; |
| |
| },{"../internals/object-get-own-property-names":100,"../internals/to-indexed-object":138}],100:[function(require,module,exports){ |
| var internalObjectKeys = require('../internals/object-keys-internal'); |
| var enumBugKeys = require('../internals/enum-bug-keys'); |
| |
| var hiddenKeys = enumBugKeys.concat('length', 'prototype'); |
| |
| // `Object.getOwnPropertyNames` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertynames |
| exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { |
| return internalObjectKeys(O, hiddenKeys); |
| }; |
| |
| },{"../internals/enum-bug-keys":48,"../internals/object-keys-internal":103}],101:[function(require,module,exports){ |
| exports.f = Object.getOwnPropertySymbols; |
| |
| },{}],102:[function(require,module,exports){ |
| var has = require('../internals/has'); |
| var toObject = require('../internals/to-object'); |
| var sharedKey = require('../internals/shared-key'); |
| var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter'); |
| |
| var IE_PROTO = sharedKey('IE_PROTO'); |
| var ObjectPrototype = Object.prototype; |
| |
| // `Object.getPrototypeOf` method |
| // https://tc39.github.io/ecma262/#sec-object.getprototypeof |
| module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) { |
| O = toObject(O); |
| if (has(O, IE_PROTO)) return O[IE_PROTO]; |
| if (typeof O.constructor == 'function' && O instanceof O.constructor) { |
| return O.constructor.prototype; |
| } return O instanceof Object ? ObjectPrototype : null; |
| }; |
| |
| },{"../internals/correct-prototype-getter":36,"../internals/has":63,"../internals/shared-key":126,"../internals/to-object":141}],103:[function(require,module,exports){ |
| var has = require('../internals/has'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var indexOf = require('../internals/array-includes').indexOf; |
| var hiddenKeys = require('../internals/hidden-keys'); |
| |
| module.exports = function (object, names) { |
| var O = toIndexedObject(object); |
| var i = 0; |
| var result = []; |
| var key; |
| for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); |
| // Don't enum bug & hidden keys |
| while (names.length > i) if (has(O, key = names[i++])) { |
| ~indexOf(result, key) || result.push(key); |
| } |
| return result; |
| }; |
| |
| },{"../internals/array-includes":20,"../internals/has":63,"../internals/hidden-keys":64,"../internals/to-indexed-object":138}],104:[function(require,module,exports){ |
| var internalObjectKeys = require('../internals/object-keys-internal'); |
| var enumBugKeys = require('../internals/enum-bug-keys'); |
| |
| // `Object.keys` method |
| // https://tc39.github.io/ecma262/#sec-object.keys |
| module.exports = Object.keys || function keys(O) { |
| return internalObjectKeys(O, enumBugKeys); |
| }; |
| |
| },{"../internals/enum-bug-keys":48,"../internals/object-keys-internal":103}],105:[function(require,module,exports){ |
| 'use strict'; |
| var nativePropertyIsEnumerable = {}.propertyIsEnumerable; |
| var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; |
| |
| // Nashorn ~ JDK8 bug |
| var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); |
| |
| // `Object.prototype.propertyIsEnumerable` method implementation |
| // https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable |
| exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { |
| var descriptor = getOwnPropertyDescriptor(this, V); |
| return !!descriptor && descriptor.enumerable; |
| } : nativePropertyIsEnumerable; |
| |
| },{}],106:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| var aPossiblePrototype = require('../internals/a-possible-prototype'); |
| |
| // `Object.setPrototypeOf` method |
| // https://tc39.github.io/ecma262/#sec-object.setprototypeof |
| // Works with __proto__ only. Old v8 can't work with null proto objects. |
| /* eslint-disable no-proto */ |
| module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { |
| var CORRECT_SETTER = false; |
| var test = {}; |
| var setter; |
| try { |
| setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; |
| setter.call(test, []); |
| CORRECT_SETTER = test instanceof Array; |
| } catch (error) { /* empty */ } |
| return function setPrototypeOf(O, proto) { |
| anObject(O); |
| aPossiblePrototype(proto); |
| if (CORRECT_SETTER) setter.call(O, proto); |
| else O.__proto__ = proto; |
| return O; |
| }; |
| }() : undefined); |
| |
| },{"../internals/a-possible-prototype":9,"../internals/an-object":13}],107:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var objectKeys = require('../internals/object-keys'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var propertyIsEnumerable = require('../internals/object-property-is-enumerable').f; |
| |
| // `Object.{ entries, values }` methods implementation |
| var createMethod = function (TO_ENTRIES) { |
| return function (it) { |
| var O = toIndexedObject(it); |
| var keys = objectKeys(O); |
| var length = keys.length; |
| var i = 0; |
| var result = []; |
| var key; |
| while (length > i) { |
| key = keys[i++]; |
| if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) { |
| result.push(TO_ENTRIES ? [key, O[key]] : O[key]); |
| } |
| } |
| return result; |
| }; |
| }; |
| |
| module.exports = { |
| // `Object.entries` method |
| // https://tc39.github.io/ecma262/#sec-object.entries |
| entries: createMethod(true), |
| // `Object.values` method |
| // https://tc39.github.io/ecma262/#sec-object.values |
| values: createMethod(false) |
| }; |
| |
| },{"../internals/descriptors":45,"../internals/object-keys":104,"../internals/object-property-is-enumerable":105,"../internals/to-indexed-object":138}],108:[function(require,module,exports){ |
| 'use strict'; |
| var classof = require('../internals/classof'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var TO_STRING_TAG = wellKnownSymbol('toStringTag'); |
| var test = {}; |
| |
| test[TO_STRING_TAG] = 'z'; |
| |
| // `Object.prototype.toString` method implementation |
| // https://tc39.github.io/ecma262/#sec-object.prototype.tostring |
| module.exports = String(test) !== '[object z]' ? function toString() { |
| return '[object ' + classof(this) + ']'; |
| } : test.toString; |
| |
| },{"../internals/classof":30,"../internals/well-known-symbol":150}],109:[function(require,module,exports){ |
| var getBuiltIn = require('../internals/get-built-in'); |
| var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names'); |
| var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols'); |
| var anObject = require('../internals/an-object'); |
| |
| // all object keys, includes non-enumerable and symbols |
| module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { |
| var keys = getOwnPropertyNamesModule.f(anObject(it)); |
| var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; |
| return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; |
| }; |
| |
| },{"../internals/an-object":13,"../internals/get-built-in":59,"../internals/object-get-own-property-names":100,"../internals/object-get-own-property-symbols":101}],110:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var trim = require('../internals/string-trim').trim; |
| var whitespaces = require('../internals/whitespaces'); |
| |
| var nativeParseFloat = global.parseFloat; |
| var FORCED = 1 / nativeParseFloat(whitespaces + '-0') !== -Infinity; |
| |
| // `parseFloat` method |
| // https://tc39.github.io/ecma262/#sec-parsefloat-string |
| module.exports = FORCED ? function parseFloat(string) { |
| var trimmedString = trim(String(string)); |
| var result = nativeParseFloat(trimmedString); |
| return result === 0 && trimmedString.charAt(0) == '-' ? -0 : result; |
| } : nativeParseFloat; |
| |
| },{"../internals/global":62,"../internals/string-trim":133,"../internals/whitespaces":151}],111:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var trim = require('../internals/string-trim').trim; |
| var whitespaces = require('../internals/whitespaces'); |
| |
| var nativeParseInt = global.parseInt; |
| var hex = /^[+-]?0[Xx]/; |
| var FORCED = nativeParseInt(whitespaces + '08') !== 8 || nativeParseInt(whitespaces + '0x16') !== 22; |
| |
| // `parseInt` method |
| // https://tc39.github.io/ecma262/#sec-parseint-string-radix |
| module.exports = FORCED ? function parseInt(string, radix) { |
| var S = trim(String(string)); |
| return nativeParseInt(S, (radix >>> 0) || (hex.test(S) ? 16 : 10)); |
| } : nativeParseInt; |
| |
| },{"../internals/global":62,"../internals/string-trim":133,"../internals/whitespaces":151}],112:[function(require,module,exports){ |
| module.exports = require('../internals/global'); |
| |
| },{"../internals/global":62}],113:[function(require,module,exports){ |
| module.exports = function (exec) { |
| try { |
| return { error: false, value: exec() }; |
| } catch (error) { |
| return { error: true, value: error }; |
| } |
| }; |
| |
| },{}],114:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| var isObject = require('../internals/is-object'); |
| var newPromiseCapability = require('../internals/new-promise-capability'); |
| |
| module.exports = function (C, x) { |
| anObject(C); |
| if (isObject(x) && x.constructor === C) return x; |
| var promiseCapability = newPromiseCapability.f(C); |
| var resolve = promiseCapability.resolve; |
| resolve(x); |
| return promiseCapability.promise; |
| }; |
| |
| },{"../internals/an-object":13,"../internals/is-object":77,"../internals/new-promise-capability":91}],115:[function(require,module,exports){ |
| 'use strict'; |
| // based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js |
| var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1 |
| var base = 36; |
| var tMin = 1; |
| var tMax = 26; |
| var skew = 38; |
| var damp = 700; |
| var initialBias = 72; |
| var initialN = 128; // 0x80 |
| var delimiter = '-'; // '\x2D' |
| var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars |
| var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators |
| var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process'; |
| var baseMinusTMin = base - tMin; |
| var floor = Math.floor; |
| var stringFromCharCode = String.fromCharCode; |
| |
| /** |
| * Creates an array containing the numeric code points of each Unicode |
| * character in the string. While JavaScript uses UCS-2 internally, |
| * this function will convert a pair of surrogate halves (each of which |
| * UCS-2 exposes as separate characters) into a single code point, |
| * matching UTF-16. |
| */ |
| var ucs2decode = function (string) { |
| var output = []; |
| var counter = 0; |
| var length = string.length; |
| while (counter < length) { |
| var value = string.charCodeAt(counter++); |
| if (value >= 0xD800 && value <= 0xDBFF && counter < length) { |
| // It's a high surrogate, and there is a next character. |
| var extra = string.charCodeAt(counter++); |
| if ((extra & 0xFC00) == 0xDC00) { // Low surrogate. |
| output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); |
| } else { |
| // It's an unmatched surrogate; only append this code unit, in case the |
| // next code unit is the high surrogate of a surrogate pair. |
| output.push(value); |
| counter--; |
| } |
| } else { |
| output.push(value); |
| } |
| } |
| return output; |
| }; |
| |
| /** |
| * Converts a digit/integer into a basic code point. |
| */ |
| var digitToBasic = function (digit) { |
| // 0..25 map to ASCII a..z or A..Z |
| // 26..35 map to ASCII 0..9 |
| return digit + 22 + 75 * (digit < 26); |
| }; |
| |
| /** |
| * Bias adaptation function as per section 3.4 of RFC 3492. |
| * https://tools.ietf.org/html/rfc3492#section-3.4 |
| */ |
| var adapt = function (delta, numPoints, firstTime) { |
| var k = 0; |
| delta = firstTime ? floor(delta / damp) : delta >> 1; |
| delta += floor(delta / numPoints); |
| for (; delta > baseMinusTMin * tMax >> 1; k += base) { |
| delta = floor(delta / baseMinusTMin); |
| } |
| return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); |
| }; |
| |
| /** |
| * Converts a string of Unicode symbols (e.g. a domain name label) to a |
| * Punycode string of ASCII-only symbols. |
| */ |
| // eslint-disable-next-line max-statements |
| var encode = function (input) { |
| var output = []; |
| |
| // Convert the input in UCS-2 to an array of Unicode code points. |
| input = ucs2decode(input); |
| |
| // Cache the length. |
| var inputLength = input.length; |
| |
| // Initialize the state. |
| var n = initialN; |
| var delta = 0; |
| var bias = initialBias; |
| var i, currentValue; |
| |
| // Handle the basic code points. |
| for (i = 0; i < input.length; i++) { |
| currentValue = input[i]; |
| if (currentValue < 0x80) { |
| output.push(stringFromCharCode(currentValue)); |
| } |
| } |
| |
| var basicLength = output.length; // number of basic code points. |
| var handledCPCount = basicLength; // number of code points that have been handled; |
| |
| // Finish the basic string with a delimiter unless it's empty. |
| if (basicLength) { |
| output.push(delimiter); |
| } |
| |
| // Main encoding loop: |
| while (handledCPCount < inputLength) { |
| // All non-basic code points < n have been handled already. Find the next larger one: |
| var m = maxInt; |
| for (i = 0; i < input.length; i++) { |
| currentValue = input[i]; |
| if (currentValue >= n && currentValue < m) { |
| m = currentValue; |
| } |
| } |
| |
| // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow. |
| var handledCPCountPlusOne = handledCPCount + 1; |
| if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { |
| throw RangeError(OVERFLOW_ERROR); |
| } |
| |
| delta += (m - n) * handledCPCountPlusOne; |
| n = m; |
| |
| for (i = 0; i < input.length; i++) { |
| currentValue = input[i]; |
| if (currentValue < n && ++delta > maxInt) { |
| throw RangeError(OVERFLOW_ERROR); |
| } |
| if (currentValue == n) { |
| // Represent delta as a generalized variable-length integer. |
| var q = delta; |
| for (var k = base; /* no condition */; k += base) { |
| var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); |
| if (q < t) break; |
| var qMinusT = q - t; |
| var baseMinusT = base - t; |
| output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT))); |
| q = floor(qMinusT / baseMinusT); |
| } |
| |
| output.push(stringFromCharCode(digitToBasic(q))); |
| bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); |
| delta = 0; |
| ++handledCPCount; |
| } |
| } |
| |
| ++delta; |
| ++n; |
| } |
| return output.join(''); |
| }; |
| |
| module.exports = function (input) { |
| var encoded = []; |
| var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.'); |
| var i, label; |
| for (i = 0; i < labels.length; i++) { |
| label = labels[i]; |
| encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label); |
| } |
| return encoded.join('.'); |
| }; |
| |
| },{}],116:[function(require,module,exports){ |
| var redefine = require('../internals/redefine'); |
| |
| module.exports = function (target, src, options) { |
| for (var key in src) redefine(target, key, src[key], options); |
| return target; |
| }; |
| |
| },{"../internals/redefine":117}],117:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var shared = require('../internals/shared'); |
| var hide = require('../internals/hide'); |
| var has = require('../internals/has'); |
| var setGlobal = require('../internals/set-global'); |
| var nativeFunctionToString = require('../internals/function-to-string'); |
| var InternalStateModule = require('../internals/internal-state'); |
| |
| var getInternalState = InternalStateModule.get; |
| var enforceInternalState = InternalStateModule.enforce; |
| var TEMPLATE = String(nativeFunctionToString).split('toString'); |
| |
| shared('inspectSource', function (it) { |
| return nativeFunctionToString.call(it); |
| }); |
| |
| (module.exports = function (O, key, value, options) { |
| var unsafe = options ? !!options.unsafe : false; |
| var simple = options ? !!options.enumerable : false; |
| var noTargetGet = options ? !!options.noTargetGet : false; |
| if (typeof value == 'function') { |
| if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key); |
| enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : ''); |
| } |
| if (O === global) { |
| if (simple) O[key] = value; |
| else setGlobal(key, value); |
| return; |
| } else if (!unsafe) { |
| delete O[key]; |
| } else if (!noTargetGet && O[key]) { |
| simple = true; |
| } |
| if (simple) O[key] = value; |
| else hide(O, key, value); |
| // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative |
| })(Function.prototype, 'toString', function toString() { |
| return typeof this == 'function' && getInternalState(this).source || nativeFunctionToString.call(this); |
| }); |
| |
| },{"../internals/function-to-string":58,"../internals/global":62,"../internals/has":63,"../internals/hide":65,"../internals/internal-state":72,"../internals/set-global":123,"../internals/shared":127}],118:[function(require,module,exports){ |
| var classof = require('./classof-raw'); |
| var regexpExec = require('./regexp-exec'); |
| |
| // `RegExpExec` abstract operation |
| // https://tc39.github.io/ecma262/#sec-regexpexec |
| module.exports = function (R, S) { |
| var exec = R.exec; |
| if (typeof exec === 'function') { |
| var result = exec.call(R, S); |
| if (typeof result !== 'object') { |
| throw TypeError('RegExp exec method returned something other than an Object or null'); |
| } |
| return result; |
| } |
| |
| if (classof(R) !== 'RegExp') { |
| throw TypeError('RegExp#exec called on incompatible receiver'); |
| } |
| |
| return regexpExec.call(R, S); |
| }; |
| |
| |
| },{"./classof-raw":29,"./regexp-exec":119}],119:[function(require,module,exports){ |
| 'use strict'; |
| var regexpFlags = require('./regexp-flags'); |
| |
| var nativeExec = RegExp.prototype.exec; |
| // This always refers to the native implementation, because the |
| // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, |
| // which loads this file before patching the method. |
| var nativeReplace = String.prototype.replace; |
| |
| var patchedExec = nativeExec; |
| |
| var UPDATES_LAST_INDEX_WRONG = (function () { |
| var re1 = /a/; |
| var re2 = /b*/g; |
| nativeExec.call(re1, 'a'); |
| nativeExec.call(re2, 'a'); |
| return re1.lastIndex !== 0 || re2.lastIndex !== 0; |
| })(); |
| |
| // nonparticipating capturing group, copied from es5-shim's String#split patch. |
| var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; |
| |
| var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED; |
| |
| if (PATCH) { |
| patchedExec = function exec(str) { |
| var re = this; |
| var lastIndex, reCopy, match, i; |
| |
| if (NPCG_INCLUDED) { |
| reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re)); |
| } |
| if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; |
| |
| match = nativeExec.call(re, str); |
| |
| if (UPDATES_LAST_INDEX_WRONG && match) { |
| re.lastIndex = re.global ? match.index + match[0].length : lastIndex; |
| } |
| if (NPCG_INCLUDED && match && match.length > 1) { |
| // Fix browsers whose `exec` methods don't consistently return `undefined` |
| // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ |
| nativeReplace.call(match[0], reCopy, function () { |
| for (i = 1; i < arguments.length - 2; i++) { |
| if (arguments[i] === undefined) match[i] = undefined; |
| } |
| }); |
| } |
| |
| return match; |
| }; |
| } |
| |
| module.exports = patchedExec; |
| |
| },{"./regexp-flags":120}],120:[function(require,module,exports){ |
| 'use strict'; |
| var anObject = require('../internals/an-object'); |
| |
| // `RegExp.prototype.flags` getter implementation |
| // https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags |
| module.exports = function () { |
| var that = anObject(this); |
| var result = ''; |
| if (that.global) result += 'g'; |
| if (that.ignoreCase) result += 'i'; |
| if (that.multiline) result += 'm'; |
| if (that.dotAll) result += 's'; |
| if (that.unicode) result += 'u'; |
| if (that.sticky) result += 'y'; |
| return result; |
| }; |
| |
| },{"../internals/an-object":13}],121:[function(require,module,exports){ |
| // `RequireObjectCoercible` abstract operation |
| // https://tc39.github.io/ecma262/#sec-requireobjectcoercible |
| module.exports = function (it) { |
| if (it == undefined) throw TypeError("Can't call method on " + it); |
| return it; |
| }; |
| |
| },{}],122:[function(require,module,exports){ |
| // `SameValue` abstract operation |
| // https://tc39.github.io/ecma262/#sec-samevalue |
| module.exports = Object.is || function is(x, y) { |
| // eslint-disable-next-line no-self-compare |
| return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; |
| }; |
| |
| },{}],123:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var hide = require('../internals/hide'); |
| |
| module.exports = function (key, value) { |
| try { |
| hide(global, key, value); |
| } catch (error) { |
| global[key] = value; |
| } return value; |
| }; |
| |
| },{"../internals/global":62,"../internals/hide":65}],124:[function(require,module,exports){ |
| 'use strict'; |
| var getBuiltIn = require('../internals/get-built-in'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| |
| module.exports = function (CONSTRUCTOR_NAME) { |
| var Constructor = getBuiltIn(CONSTRUCTOR_NAME); |
| var defineProperty = definePropertyModule.f; |
| |
| if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { |
| defineProperty(Constructor, SPECIES, { |
| configurable: true, |
| get: function () { return this; } |
| }); |
| } |
| }; |
| |
| },{"../internals/descriptors":45,"../internals/get-built-in":59,"../internals/object-define-property":97,"../internals/well-known-symbol":150}],125:[function(require,module,exports){ |
| var defineProperty = require('../internals/object-define-property').f; |
| var has = require('../internals/has'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var TO_STRING_TAG = wellKnownSymbol('toStringTag'); |
| |
| module.exports = function (it, TAG, STATIC) { |
| if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { |
| defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); |
| } |
| }; |
| |
| },{"../internals/has":63,"../internals/object-define-property":97,"../internals/well-known-symbol":150}],126:[function(require,module,exports){ |
| var shared = require('../internals/shared'); |
| var uid = require('../internals/uid'); |
| |
| var keys = shared('keys'); |
| |
| module.exports = function (key) { |
| return keys[key] || (keys[key] = uid(key)); |
| }; |
| |
| },{"../internals/shared":127,"../internals/uid":147}],127:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var setGlobal = require('../internals/set-global'); |
| var IS_PURE = require('../internals/is-pure'); |
| |
| var SHARED = '__core-js_shared__'; |
| var store = global[SHARED] || setGlobal(SHARED, {}); |
| |
| (module.exports = function (key, value) { |
| return store[key] || (store[key] = value !== undefined ? value : {}); |
| })('versions', []).push({ |
| version: '3.1.3', |
| mode: IS_PURE ? 'pure' : 'global', |
| copyright: '© 2019 Denis Pushkarev (zloirock.ru)' |
| }); |
| |
| },{"../internals/global":62,"../internals/is-pure":78,"../internals/set-global":123}],128:[function(require,module,exports){ |
| 'use strict'; |
| var fails = require('../internals/fails'); |
| |
| module.exports = function (METHOD_NAME, argument) { |
| var method = [][METHOD_NAME]; |
| return !method || !fails(function () { |
| // eslint-disable-next-line no-useless-call,no-throw-literal |
| method.call(null, argument || function () { throw 1; }, 1); |
| }); |
| }; |
| |
| },{"../internals/fails":50}],129:[function(require,module,exports){ |
| var anObject = require('../internals/an-object'); |
| var aFunction = require('../internals/a-function'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| |
| // `SpeciesConstructor` abstract operation |
| // https://tc39.github.io/ecma262/#sec-speciesconstructor |
| module.exports = function (O, defaultConstructor) { |
| var C = anObject(O).constructor; |
| var S; |
| return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S); |
| }; |
| |
| },{"../internals/a-function":8,"../internals/an-object":13,"../internals/well-known-symbol":150}],130:[function(require,module,exports){ |
| var toInteger = require('../internals/to-integer'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| |
| // `String.prototype.{ codePointAt, at }` methods implementation |
| var createMethod = function (CONVERT_TO_STRING) { |
| return function ($this, pos) { |
| var S = String(requireObjectCoercible($this)); |
| var position = toInteger(pos); |
| var size = S.length; |
| var first, second; |
| if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; |
| first = S.charCodeAt(position); |
| return first < 0xD800 || first > 0xDBFF || position + 1 === size |
| || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF |
| ? CONVERT_TO_STRING ? S.charAt(position) : first |
| : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; |
| }; |
| }; |
| |
| module.exports = { |
| // `String.prototype.codePointAt` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat |
| codeAt: createMethod(false), |
| // `String.prototype.at` method |
| // https://github.com/mathiasbynens/String.prototype.at |
| charAt: createMethod(true) |
| }; |
| |
| },{"../internals/require-object-coercible":121,"../internals/to-integer":139}],131:[function(require,module,exports){ |
| // https://github.com/tc39/proposal-string-pad-start-end |
| var toLength = require('../internals/to-length'); |
| var repeat = require('../internals/string-repeat'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| |
| var ceil = Math.ceil; |
| |
| // `String.prototype.{ padStart, padEnd }` methods implementation |
| var createMethod = function (IS_END) { |
| return function ($this, maxLength, fillString) { |
| var S = String(requireObjectCoercible($this)); |
| var stringLength = S.length; |
| var fillStr = fillString === undefined ? ' ' : String(fillString); |
| var intMaxLength = toLength(maxLength); |
| var fillLen, stringFiller; |
| if (intMaxLength <= stringLength || fillStr == '') return S; |
| fillLen = intMaxLength - stringLength; |
| stringFiller = repeat.call(fillStr, ceil(fillLen / fillStr.length)); |
| if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen); |
| return IS_END ? S + stringFiller : stringFiller + S; |
| }; |
| }; |
| |
| module.exports = { |
| // `String.prototype.padStart` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.padstart |
| start: createMethod(false), |
| // `String.prototype.padEnd` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.padend |
| end: createMethod(true) |
| }; |
| |
| },{"../internals/require-object-coercible":121,"../internals/string-repeat":132,"../internals/to-length":140}],132:[function(require,module,exports){ |
| 'use strict'; |
| var toInteger = require('../internals/to-integer'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| |
| // `String.prototype.repeat` method implementation |
| // https://tc39.github.io/ecma262/#sec-string.prototype.repeat |
| module.exports = ''.repeat || function repeat(count) { |
| var str = String(requireObjectCoercible(this)); |
| var result = ''; |
| var n = toInteger(count); |
| if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions'); |
| for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str; |
| return result; |
| }; |
| |
| },{"../internals/require-object-coercible":121,"../internals/to-integer":139}],133:[function(require,module,exports){ |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var whitespaces = require('../internals/whitespaces'); |
| |
| var whitespace = '[' + whitespaces + ']'; |
| var ltrim = RegExp('^' + whitespace + whitespace + '*'); |
| var rtrim = RegExp(whitespace + whitespace + '*$'); |
| |
| // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation |
| var createMethod = function (TYPE) { |
| return function ($this) { |
| var string = String(requireObjectCoercible($this)); |
| if (TYPE & 1) string = string.replace(ltrim, ''); |
| if (TYPE & 2) string = string.replace(rtrim, ''); |
| return string; |
| }; |
| }; |
| |
| module.exports = { |
| // `String.prototype.{ trimLeft, trimStart }` methods |
| // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart |
| start: createMethod(1), |
| // `String.prototype.{ trimRight, trimEnd }` methods |
| // https://tc39.github.io/ecma262/#sec-string.prototype.trimend |
| end: createMethod(2), |
| // `String.prototype.trim` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.trim |
| trim: createMethod(3) |
| }; |
| |
| },{"../internals/require-object-coercible":121,"../internals/whitespaces":151}],134:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var fails = require('../internals/fails'); |
| var classof = require('../internals/classof-raw'); |
| var bind = require('../internals/bind-context'); |
| var html = require('../internals/html'); |
| var createElement = require('../internals/document-create-element'); |
| |
| var location = global.location; |
| var set = global.setImmediate; |
| var clear = global.clearImmediate; |
| var process = global.process; |
| var MessageChannel = global.MessageChannel; |
| var Dispatch = global.Dispatch; |
| var counter = 0; |
| var queue = {}; |
| var ONREADYSTATECHANGE = 'onreadystatechange'; |
| var defer, channel, port; |
| |
| var run = function (id) { |
| // eslint-disable-next-line no-prototype-builtins |
| if (queue.hasOwnProperty(id)) { |
| var fn = queue[id]; |
| delete queue[id]; |
| fn(); |
| } |
| }; |
| |
| var runner = function (id) { |
| return function () { |
| run(id); |
| }; |
| }; |
| |
| var listener = function (event) { |
| run(event.data); |
| }; |
| |
| var post = function (id) { |
| // old engines have not location.origin |
| global.postMessage(id + '', location.protocol + '//' + location.host); |
| }; |
| |
| // Node.js 0.9+ & IE10+ has setImmediate, otherwise: |
| if (!set || !clear) { |
| set = function setImmediate(fn) { |
| var args = []; |
| var i = 1; |
| while (arguments.length > i) args.push(arguments[i++]); |
| queue[++counter] = function () { |
| // eslint-disable-next-line no-new-func |
| (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args); |
| }; |
| defer(counter); |
| return counter; |
| }; |
| clear = function clearImmediate(id) { |
| delete queue[id]; |
| }; |
| // Node.js 0.8- |
| if (classof(process) == 'process') { |
| defer = function (id) { |
| process.nextTick(runner(id)); |
| }; |
| // Sphere (JS game engine) Dispatch API |
| } else if (Dispatch && Dispatch.now) { |
| defer = function (id) { |
| Dispatch.now(runner(id)); |
| }; |
| // Browsers with MessageChannel, includes WebWorkers |
| } else if (MessageChannel) { |
| channel = new MessageChannel(); |
| port = channel.port2; |
| channel.port1.onmessage = listener; |
| defer = bind(port.postMessage, port, 1); |
| // Browsers with postMessage, skip WebWorkers |
| // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' |
| } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts && !fails(post)) { |
| defer = post; |
| global.addEventListener('message', listener, false); |
| // IE8- |
| } else if (ONREADYSTATECHANGE in createElement('script')) { |
| defer = function (id) { |
| html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { |
| html.removeChild(this); |
| run(id); |
| }; |
| }; |
| // Rest old browsers |
| } else { |
| defer = function (id) { |
| setTimeout(runner(id), 0); |
| }; |
| } |
| } |
| |
| module.exports = { |
| set: set, |
| clear: clear |
| }; |
| |
| },{"../internals/bind-context":26,"../internals/classof-raw":29,"../internals/document-create-element":46,"../internals/fails":50,"../internals/global":62,"../internals/html":67}],135:[function(require,module,exports){ |
| var classof = require('../internals/classof-raw'); |
| |
| // `thisNumberValue` abstract operation |
| // https://tc39.github.io/ecma262/#sec-thisnumbervalue |
| module.exports = function (value) { |
| if (typeof value != 'number' && classof(value) != 'Number') { |
| throw TypeError('Incorrect invocation'); |
| } |
| return +value; |
| }; |
| |
| },{"../internals/classof-raw":29}],136:[function(require,module,exports){ |
| var toInteger = require('../internals/to-integer'); |
| |
| var max = Math.max; |
| var min = Math.min; |
| |
| // Helper for a popular repeating case of the spec: |
| // Let integer be ? ToInteger(index). |
| // If integer < 0, let result be max((length + integer), 0); else let result be min(length, length). |
| module.exports = function (index, length) { |
| var integer = toInteger(index); |
| return integer < 0 ? max(integer + length, 0) : min(integer, length); |
| }; |
| |
| },{"../internals/to-integer":139}],137:[function(require,module,exports){ |
| var toInteger = require('../internals/to-integer'); |
| var toLength = require('../internals/to-length'); |
| |
| // `ToIndex` abstract operation |
| // https://tc39.github.io/ecma262/#sec-toindex |
| module.exports = function (it) { |
| if (it === undefined) return 0; |
| var number = toInteger(it); |
| var length = toLength(number); |
| if (number !== length) throw RangeError('Wrong length or index'); |
| return length; |
| }; |
| |
| },{"../internals/to-integer":139,"../internals/to-length":140}],138:[function(require,module,exports){ |
| // toObject with fallback for non-array-like ES3 strings |
| var IndexedObject = require('../internals/indexed-object'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| |
| module.exports = function (it) { |
| return IndexedObject(requireObjectCoercible(it)); |
| }; |
| |
| },{"../internals/indexed-object":69,"../internals/require-object-coercible":121}],139:[function(require,module,exports){ |
| var ceil = Math.ceil; |
| var floor = Math.floor; |
| |
| // `ToInteger` abstract operation |
| // https://tc39.github.io/ecma262/#sec-tointeger |
| module.exports = function (argument) { |
| return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); |
| }; |
| |
| },{}],140:[function(require,module,exports){ |
| var toInteger = require('../internals/to-integer'); |
| |
| var min = Math.min; |
| |
| // `ToLength` abstract operation |
| // https://tc39.github.io/ecma262/#sec-tolength |
| module.exports = function (argument) { |
| return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 |
| }; |
| |
| },{"../internals/to-integer":139}],141:[function(require,module,exports){ |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| |
| // `ToObject` abstract operation |
| // https://tc39.github.io/ecma262/#sec-toobject |
| module.exports = function (argument) { |
| return Object(requireObjectCoercible(argument)); |
| }; |
| |
| },{"../internals/require-object-coercible":121}],142:[function(require,module,exports){ |
| var toInteger = require('../internals/to-integer'); |
| |
| module.exports = function (it, BYTES) { |
| var offset = toInteger(it); |
| if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset'); |
| return offset; |
| }; |
| |
| },{"../internals/to-integer":139}],143:[function(require,module,exports){ |
| var isObject = require('../internals/is-object'); |
| |
| // `ToPrimitive` abstract operation |
| // https://tc39.github.io/ecma262/#sec-toprimitive |
| // instead of the ES6 spec version, we didn't implement @@toPrimitive case |
| // and the second argument - flag - preferred type is a string |
| module.exports = function (input, PREFERRED_STRING) { |
| if (!isObject(input)) return input; |
| var fn, val; |
| if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; |
| if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val; |
| if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; |
| throw TypeError("Can't convert object to primitive value"); |
| }; |
| |
| },{"../internals/is-object":77}],144:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var global = require('../internals/global'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-arrays-constructors-requires-wrappers'); |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var ArrayBufferModule = require('../internals/array-buffer'); |
| var anInstance = require('../internals/an-instance'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| var hide = require('../internals/hide'); |
| var toLength = require('../internals/to-length'); |
| var toIndex = require('../internals/to-index'); |
| var toOffset = require('../internals/to-offset'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var has = require('../internals/has'); |
| var classof = require('../internals/classof'); |
| var isObject = require('../internals/is-object'); |
| var create = require('../internals/object-create'); |
| var setPrototypeOf = require('../internals/object-set-prototype-of'); |
| var getOwnPropertyNames = require('../internals/object-get-own-property-names').f; |
| var typedArrayFrom = require('../internals/typed-array-from'); |
| var forEach = require('../internals/array-iteration').forEach; |
| var setSpecies = require('../internals/set-species'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| var InternalStateModule = require('../internals/internal-state'); |
| |
| var getInternalState = InternalStateModule.get; |
| var setInternalState = InternalStateModule.set; |
| var nativeDefineProperty = definePropertyModule.f; |
| var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; |
| var round = Math.round; |
| var RangeError = global.RangeError; |
| var ArrayBuffer = ArrayBufferModule.ArrayBuffer; |
| var DataView = ArrayBufferModule.DataView; |
| var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; |
| var TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG; |
| var TypedArray = ArrayBufferViewCore.TypedArray; |
| var TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype; |
| var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; |
| var isTypedArray = ArrayBufferViewCore.isTypedArray; |
| var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; |
| var WRONG_LENGTH = 'Wrong length'; |
| |
| var fromList = function (C, list) { |
| var index = 0; |
| var length = list.length; |
| var result = new (aTypedArrayConstructor(C))(length); |
| while (length > index) result[index] = list[index++]; |
| return result; |
| }; |
| |
| var addGetter = function (it, key) { |
| nativeDefineProperty(it, key, { get: function () { |
| return getInternalState(this)[key]; |
| } }); |
| }; |
| |
| var isArrayBuffer = function (it) { |
| var klass; |
| return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer'; |
| }; |
| |
| var isTypedArrayIndex = function (target, key) { |
| return isTypedArray(target) |
| && typeof key != 'symbol' |
| && key in target |
| && String(+key) == String(key); |
| }; |
| |
| var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) { |
| return isTypedArrayIndex(target, key = toPrimitive(key, true)) |
| ? createPropertyDescriptor(2, target[key]) |
| : nativeGetOwnPropertyDescriptor(target, key); |
| }; |
| |
| var wrappedDefineProperty = function defineProperty(target, key, descriptor) { |
| if (isTypedArrayIndex(target, key = toPrimitive(key, true)) |
| && isObject(descriptor) |
| && has(descriptor, 'value') |
| && !has(descriptor, 'get') |
| && !has(descriptor, 'set') |
| // TODO: add validation descriptor w/o calling accessors |
| && !descriptor.configurable |
| && (!has(descriptor, 'writable') || descriptor.writable) |
| && (!has(descriptor, 'enumerable') || descriptor.enumerable) |
| ) { |
| target[key] = descriptor.value; |
| return target; |
| } return nativeDefineProperty(target, key, descriptor); |
| }; |
| |
| if (DESCRIPTORS) { |
| if (!NATIVE_ARRAY_BUFFER_VIEWS) { |
| getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor; |
| definePropertyModule.f = wrappedDefineProperty; |
| addGetter(TypedArrayPrototype, 'buffer'); |
| addGetter(TypedArrayPrototype, 'byteOffset'); |
| addGetter(TypedArrayPrototype, 'byteLength'); |
| addGetter(TypedArrayPrototype, 'length'); |
| } |
| |
| $({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { |
| getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor, |
| defineProperty: wrappedDefineProperty |
| }); |
| |
| // eslint-disable-next-line max-statements |
| module.exports = function (TYPE, BYTES, wrapper, CLAMPED) { |
| var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array'; |
| var GETTER = 'get' + TYPE; |
| var SETTER = 'set' + TYPE; |
| var NativeTypedArrayConstructor = global[CONSTRUCTOR_NAME]; |
| var TypedArrayConstructor = NativeTypedArrayConstructor; |
| var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype; |
| var exported = {}; |
| |
| var getter = function (that, index) { |
| var data = getInternalState(that); |
| return data.view[GETTER](index * BYTES + data.byteOffset, true); |
| }; |
| |
| var setter = function (that, index, value) { |
| var data = getInternalState(that); |
| if (CLAMPED) value = (value = round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF; |
| data.view[SETTER](index * BYTES + data.byteOffset, value, true); |
| }; |
| |
| var addElement = function (that, index) { |
| nativeDefineProperty(that, index, { |
| get: function () { |
| return getter(this, index); |
| }, |
| set: function (value) { |
| return setter(this, index, value); |
| }, |
| enumerable: true |
| }); |
| }; |
| |
| if (!NATIVE_ARRAY_BUFFER_VIEWS) { |
| TypedArrayConstructor = wrapper(function (that, data, offset, $length) { |
| anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME); |
| var index = 0; |
| var byteOffset = 0; |
| var buffer, byteLength, length; |
| if (!isObject(data)) { |
| length = toIndex(data); |
| byteLength = length * BYTES; |
| buffer = new ArrayBuffer(byteLength); |
| } else if (isArrayBuffer(data)) { |
| buffer = data; |
| byteOffset = toOffset(offset, BYTES); |
| var $len = data.byteLength; |
| if ($length === undefined) { |
| if ($len % BYTES) throw RangeError(WRONG_LENGTH); |
| byteLength = $len - byteOffset; |
| if (byteLength < 0) throw RangeError(WRONG_LENGTH); |
| } else { |
| byteLength = toLength($length) * BYTES; |
| if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH); |
| } |
| length = byteLength / BYTES; |
| } else if (isTypedArray(data)) { |
| return fromList(TypedArrayConstructor, data); |
| } else { |
| return typedArrayFrom.call(TypedArrayConstructor, data); |
| } |
| setInternalState(that, { |
| buffer: buffer, |
| byteOffset: byteOffset, |
| byteLength: byteLength, |
| length: length, |
| view: new DataView(buffer) |
| }); |
| while (index < length) addElement(that, index++); |
| }); |
| |
| if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray); |
| TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype); |
| } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) { |
| TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) { |
| anInstance(dummy, TypedArrayConstructor, CONSTRUCTOR_NAME); |
| if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data)); |
| if (isArrayBuffer(data)) return $length !== undefined |
| ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length) |
| : typedArrayOffset !== undefined |
| ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES)) |
| : new NativeTypedArrayConstructor(data); |
| if (isTypedArray(data)) return fromList(TypedArrayConstructor, data); |
| return typedArrayFrom.call(TypedArrayConstructor, data); |
| }); |
| |
| if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray); |
| forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) { |
| if (!(key in TypedArrayConstructor)) hide(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]); |
| }); |
| TypedArrayConstructor.prototype = TypedArrayConstructorPrototype; |
| } |
| |
| if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) { |
| hide(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor); |
| } |
| |
| if (TYPED_ARRAY_TAG) hide(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME); |
| |
| exported[CONSTRUCTOR_NAME] = TypedArrayConstructor; |
| |
| $({ |
| global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS |
| }, exported); |
| |
| if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) { |
| hide(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES); |
| } |
| |
| if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) { |
| hide(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES); |
| } |
| |
| setSpecies(CONSTRUCTOR_NAME); |
| }; |
| } else module.exports = function () { /* empty */ }; |
| |
| },{"../internals/an-instance":12,"../internals/array-buffer":15,"../internals/array-buffer-view-core":14,"../internals/array-iteration":21,"../internals/classof":30,"../internals/create-property-descriptor":39,"../internals/descriptors":45,"../internals/export":49,"../internals/global":62,"../internals/has":63,"../internals/hide":65,"../internals/internal-state":72,"../internals/is-object":77,"../internals/object-create":95,"../internals/object-define-property":97,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-own-property-names":100,"../internals/object-set-prototype-of":106,"../internals/set-species":124,"../internals/to-index":137,"../internals/to-length":140,"../internals/to-offset":142,"../internals/to-primitive":143,"../internals/typed-array-from":145,"../internals/typed-arrays-constructors-requires-wrappers":146}],145:[function(require,module,exports){ |
| var toObject = require('../internals/to-object'); |
| var toLength = require('../internals/to-length'); |
| var getIteratorMethod = require('../internals/get-iterator-method'); |
| var isArrayIteratorMethod = require('../internals/is-array-iterator-method'); |
| var bind = require('../internals/bind-context'); |
| var aTypedArrayConstructor = require('../internals/array-buffer-view-core').aTypedArrayConstructor; |
| |
| module.exports = function from(source /* , mapfn, thisArg */) { |
| var O = toObject(source); |
| var argumentsLength = arguments.length; |
| var mapfn = argumentsLength > 1 ? arguments[1] : undefined; |
| var mapping = mapfn !== undefined; |
| var iteratorMethod = getIteratorMethod(O); |
| var i, length, result, step, iterator; |
| if (iteratorMethod != undefined && !isArrayIteratorMethod(iteratorMethod)) { |
| iterator = iteratorMethod.call(O); |
| O = []; |
| while (!(step = iterator.next()).done) { |
| O.push(step.value); |
| } |
| } |
| if (mapping && argumentsLength > 2) { |
| mapfn = bind(mapfn, arguments[2], 2); |
| } |
| length = toLength(O.length); |
| result = new (aTypedArrayConstructor(this))(length); |
| for (i = 0; length > i; i++) { |
| result[i] = mapping ? mapfn(O[i], i) : O[i]; |
| } |
| return result; |
| }; |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/bind-context":26,"../internals/get-iterator-method":60,"../internals/is-array-iterator-method":73,"../internals/to-length":140,"../internals/to-object":141}],146:[function(require,module,exports){ |
| /* eslint-disable no-new */ |
| var global = require('../internals/global'); |
| var fails = require('../internals/fails'); |
| var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration'); |
| var NATIVE_ARRAY_BUFFER_VIEWS = require('../internals/array-buffer-view-core').NATIVE_ARRAY_BUFFER_VIEWS; |
| |
| var ArrayBuffer = global.ArrayBuffer; |
| var Int8Array = global.Int8Array; |
| |
| module.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () { |
| Int8Array(1); |
| }) || !fails(function () { |
| new Int8Array(-1); |
| }) || !checkCorrectnessOfIteration(function (iterable) { |
| new Int8Array(); |
| new Int8Array(null); |
| new Int8Array(1.5); |
| new Int8Array(iterable); |
| }, true) || fails(function () { |
| // Safari 11 bug |
| return new Int8Array(new ArrayBuffer(2), 1, undefined).length !== 1; |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/check-correctness-of-iteration":28,"../internals/fails":50,"../internals/global":62}],147:[function(require,module,exports){ |
| var id = 0; |
| var postfix = Math.random(); |
| |
| module.exports = function (key) { |
| return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36); |
| }; |
| |
| },{}],148:[function(require,module,exports){ |
| var getBuiltIn = require('../internals/get-built-in'); |
| |
| module.exports = getBuiltIn('navigator', 'userAgent') || ''; |
| |
| },{"../internals/get-built-in":59}],149:[function(require,module,exports){ |
| // https://github.com/zloirock/core-js/issues/280 |
| var userAgent = require('../internals/user-agent'); |
| |
| // eslint-disable-next-line unicorn/no-unsafe-regex |
| module.exports = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent); |
| |
| },{"../internals/user-agent":148}],150:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var shared = require('../internals/shared'); |
| var uid = require('../internals/uid'); |
| var NATIVE_SYMBOL = require('../internals/native-symbol'); |
| |
| var Symbol = global.Symbol; |
| var store = shared('wks'); |
| |
| module.exports = function (name) { |
| return store[name] || (store[name] = NATIVE_SYMBOL && Symbol[name] |
| || (NATIVE_SYMBOL ? Symbol : uid)('Symbol.' + name)); |
| }; |
| |
| },{"../internals/global":62,"../internals/native-symbol":88,"../internals/shared":127,"../internals/uid":147}],151:[function(require,module,exports){ |
| // a string of all valid unicode whitespaces |
| // eslint-disable-next-line max-len |
| module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; |
| |
| },{}],152:[function(require,module,exports){ |
| exports.f = require('../internals/well-known-symbol'); |
| |
| },{"../internals/well-known-symbol":150}],153:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var global = require('../internals/global'); |
| var arrayBufferModule = require('../internals/array-buffer'); |
| var setSpecies = require('../internals/set-species'); |
| |
| var ARRAY_BUFFER = 'ArrayBuffer'; |
| var ArrayBuffer = arrayBufferModule[ARRAY_BUFFER]; |
| var NativeArrayBuffer = global[ARRAY_BUFFER]; |
| |
| // `ArrayBuffer` constructor |
| // https://tc39.github.io/ecma262/#sec-arraybuffer-constructor |
| $({ global: true, forced: NativeArrayBuffer !== ArrayBuffer }, { |
| ArrayBuffer: ArrayBuffer |
| }); |
| |
| setSpecies(ARRAY_BUFFER); |
| |
| },{"../internals/array-buffer":15,"../internals/export":49,"../internals/global":62,"../internals/set-species":124}],154:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| |
| var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; |
| |
| // `ArrayBuffer.isView` method |
| // https://tc39.github.io/ecma262/#sec-arraybuffer.isview |
| $({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { |
| isView: ArrayBufferViewCore.isView |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/export":49}],155:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var ArrayBufferModule = require('../internals/array-buffer'); |
| var anObject = require('../internals/an-object'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| var toLength = require('../internals/to-length'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| |
| var ArrayBuffer = ArrayBufferModule.ArrayBuffer; |
| var DataView = ArrayBufferModule.DataView; |
| var nativeArrayBufferSlice = ArrayBuffer.prototype.slice; |
| |
| var INCORRECT_SLICE = fails(function () { |
| return !new ArrayBuffer(2).slice(1, undefined).byteLength; |
| }); |
| |
| // `ArrayBuffer.prototype.slice` method |
| // https://tc39.github.io/ecma262/#sec-arraybuffer.prototype.slice |
| $({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, { |
| slice: function slice(start, end) { |
| if (nativeArrayBufferSlice !== undefined && end === undefined) { |
| return nativeArrayBufferSlice.call(anObject(this), start); // FF fix |
| } |
| var length = anObject(this).byteLength; |
| var first = toAbsoluteIndex(start, length); |
| var fin = toAbsoluteIndex(end === undefined ? length : end, length); |
| var result = new (speciesConstructor(this, ArrayBuffer))(toLength(fin - first)); |
| var viewSource = new DataView(this); |
| var viewTarget = new DataView(result); |
| var index = 0; |
| while (first < fin) { |
| viewTarget.setUint8(index++, viewSource.getUint8(first++)); |
| } return result; |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/array-buffer":15,"../internals/export":49,"../internals/fails":50,"../internals/species-constructor":129,"../internals/to-absolute-index":136,"../internals/to-length":140}],156:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var isArray = require('../internals/is-array'); |
| var isObject = require('../internals/is-object'); |
| var toObject = require('../internals/to-object'); |
| var toLength = require('../internals/to-length'); |
| var createProperty = require('../internals/create-property'); |
| var arraySpeciesCreate = require('../internals/array-species-create'); |
| var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); |
| var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; |
| var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded'; |
| |
| var IS_CONCAT_SPREADABLE_SUPPORT = !fails(function () { |
| var array = []; |
| array[IS_CONCAT_SPREADABLE] = false; |
| return array.concat()[0] !== array; |
| }); |
| |
| var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat'); |
| |
| var isConcatSpreadable = function (O) { |
| if (!isObject(O)) return false; |
| var spreadable = O[IS_CONCAT_SPREADABLE]; |
| return spreadable !== undefined ? !!spreadable : isArray(O); |
| }; |
| |
| var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; |
| |
| // `Array.prototype.concat` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.concat |
| // with adding support of @@isConcatSpreadable and @@species |
| $({ target: 'Array', proto: true, forced: FORCED }, { |
| concat: function concat(arg) { // eslint-disable-line no-unused-vars |
| var O = toObject(this); |
| var A = arraySpeciesCreate(O, 0); |
| var n = 0; |
| var i, k, length, len, E; |
| for (i = -1, length = arguments.length; i < length; i++) { |
| E = i === -1 ? O : arguments[i]; |
| if (isConcatSpreadable(E)) { |
| len = toLength(E.length); |
| if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); |
| for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]); |
| } else { |
| if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); |
| createProperty(A, n++, E); |
| } |
| } |
| A.length = n; |
| return A; |
| } |
| }); |
| |
| },{"../internals/array-method-has-species-support":23,"../internals/array-species-create":25,"../internals/create-property":40,"../internals/export":49,"../internals/fails":50,"../internals/is-array":74,"../internals/is-object":77,"../internals/to-length":140,"../internals/to-object":141,"../internals/well-known-symbol":150}],157:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var copyWithin = require('../internals/array-copy-within'); |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| // `Array.prototype.copyWithin` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.copywithin |
| $({ target: 'Array', proto: true }, { |
| copyWithin: copyWithin |
| }); |
| |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| addToUnscopables('copyWithin'); |
| |
| },{"../internals/add-to-unscopables":10,"../internals/array-copy-within":16,"../internals/export":49}],158:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $every = require('../internals/array-iteration').every; |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| // `Array.prototype.every` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.every |
| $({ target: 'Array', proto: true, forced: sloppyArrayMethod('every') }, { |
| every: function every(callbackfn /* , thisArg */) { |
| return $every(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-iteration":21,"../internals/export":49,"../internals/sloppy-array-method":128}],159:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fill = require('../internals/array-fill'); |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| // `Array.prototype.fill` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.fill |
| $({ target: 'Array', proto: true }, { |
| fill: fill |
| }); |
| |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| addToUnscopables('fill'); |
| |
| },{"../internals/add-to-unscopables":10,"../internals/array-fill":17,"../internals/export":49}],160:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $filter = require('../internals/array-iteration').filter; |
| var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support'); |
| |
| // `Array.prototype.filter` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.filter |
| // with adding support of @@species |
| $({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('filter') }, { |
| filter: function filter(callbackfn /* , thisArg */) { |
| return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-iteration":21,"../internals/array-method-has-species-support":23,"../internals/export":49}],161:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $findIndex = require('../internals/array-iteration').findIndex; |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| var FIND_INDEX = 'findIndex'; |
| var SKIPS_HOLES = true; |
| |
| // Shouldn't skip holes |
| if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; }); |
| |
| // `Array.prototype.findIndex` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.findindex |
| $({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { |
| findIndex: function findIndex(callbackfn /* , that = undefined */) { |
| return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| addToUnscopables(FIND_INDEX); |
| |
| },{"../internals/add-to-unscopables":10,"../internals/array-iteration":21,"../internals/export":49}],162:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $find = require('../internals/array-iteration').find; |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| var FIND = 'find'; |
| var SKIPS_HOLES = true; |
| |
| // Shouldn't skip holes |
| if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; }); |
| |
| // `Array.prototype.find` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.find |
| $({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { |
| find: function find(callbackfn /* , that = undefined */) { |
| return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| addToUnscopables(FIND); |
| |
| },{"../internals/add-to-unscopables":10,"../internals/array-iteration":21,"../internals/export":49}],163:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var flattenIntoArray = require('../internals/flatten-into-array'); |
| var toObject = require('../internals/to-object'); |
| var toLength = require('../internals/to-length'); |
| var aFunction = require('../internals/a-function'); |
| var arraySpeciesCreate = require('../internals/array-species-create'); |
| |
| // `Array.prototype.flatMap` method |
| // https://github.com/tc39/proposal-flatMap |
| $({ target: 'Array', proto: true }, { |
| flatMap: function flatMap(callbackfn /* , thisArg */) { |
| var O = toObject(this); |
| var sourceLen = toLength(O.length); |
| var A; |
| aFunction(callbackfn); |
| A = arraySpeciesCreate(O, 0); |
| A.length = flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| return A; |
| } |
| }); |
| |
| },{"../internals/a-function":8,"../internals/array-species-create":25,"../internals/export":49,"../internals/flatten-into-array":52,"../internals/to-length":140,"../internals/to-object":141}],164:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var flattenIntoArray = require('../internals/flatten-into-array'); |
| var toObject = require('../internals/to-object'); |
| var toLength = require('../internals/to-length'); |
| var toInteger = require('../internals/to-integer'); |
| var arraySpeciesCreate = require('../internals/array-species-create'); |
| |
| // `Array.prototype.flat` method |
| // https://github.com/tc39/proposal-flatMap |
| $({ target: 'Array', proto: true }, { |
| flat: function flat(/* depthArg = 1 */) { |
| var depthArg = arguments.length ? arguments[0] : undefined; |
| var O = toObject(this); |
| var sourceLen = toLength(O.length); |
| var A = arraySpeciesCreate(O, 0); |
| A.length = flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg)); |
| return A; |
| } |
| }); |
| |
| },{"../internals/array-species-create":25,"../internals/export":49,"../internals/flatten-into-array":52,"../internals/to-integer":139,"../internals/to-length":140,"../internals/to-object":141}],165:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var forEach = require('../internals/array-for-each'); |
| |
| // `Array.prototype.forEach` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.foreach |
| $({ target: 'Array', proto: true, forced: [].forEach != forEach }, { |
| forEach: forEach |
| }); |
| |
| },{"../internals/array-for-each":18,"../internals/export":49}],166:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var from = require('../internals/array-from'); |
| var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration'); |
| |
| var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { |
| Array.from(iterable); |
| }); |
| |
| // `Array.from` method |
| // https://tc39.github.io/ecma262/#sec-array.from |
| $({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { |
| from: from |
| }); |
| |
| },{"../internals/array-from":19,"../internals/check-correctness-of-iteration":28,"../internals/export":49}],167:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $includes = require('../internals/array-includes').includes; |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| // `Array.prototype.includes` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.includes |
| $({ target: 'Array', proto: true }, { |
| includes: function includes(el /* , fromIndex = 0 */) { |
| return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| addToUnscopables('includes'); |
| |
| },{"../internals/add-to-unscopables":10,"../internals/array-includes":20,"../internals/export":49}],168:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $indexOf = require('../internals/array-includes').indexOf; |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| var nativeIndexOf = [].indexOf; |
| |
| var NEGATIVE_ZERO = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0; |
| var SLOPPY_METHOD = sloppyArrayMethod('indexOf'); |
| |
| // `Array.prototype.indexOf` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.indexof |
| $({ target: 'Array', proto: true, forced: NEGATIVE_ZERO || SLOPPY_METHOD }, { |
| indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { |
| return NEGATIVE_ZERO |
| // convert -0 to +0 |
| ? nativeIndexOf.apply(this, arguments) || 0 |
| : $indexOf(this, searchElement, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-includes":20,"../internals/export":49,"../internals/sloppy-array-method":128}],169:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var isArray = require('../internals/is-array'); |
| |
| // `Array.isArray` method |
| // https://tc39.github.io/ecma262/#sec-array.isarray |
| $({ target: 'Array', stat: true }, { |
| isArray: isArray |
| }); |
| |
| },{"../internals/export":49,"../internals/is-array":74}],170:[function(require,module,exports){ |
| 'use strict'; |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| var Iterators = require('../internals/iterators'); |
| var InternalStateModule = require('../internals/internal-state'); |
| var defineIterator = require('../internals/define-iterator'); |
| |
| var ARRAY_ITERATOR = 'Array Iterator'; |
| var setInternalState = InternalStateModule.set; |
| var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); |
| |
| // `Array.prototype.entries` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.entries |
| // `Array.prototype.keys` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.keys |
| // `Array.prototype.values` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.values |
| // `Array.prototype[@@iterator]` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator |
| // `CreateArrayIterator` internal method |
| // https://tc39.github.io/ecma262/#sec-createarrayiterator |
| module.exports = defineIterator(Array, 'Array', function (iterated, kind) { |
| setInternalState(this, { |
| type: ARRAY_ITERATOR, |
| target: toIndexedObject(iterated), // target |
| index: 0, // next index |
| kind: kind // kind |
| }); |
| // `%ArrayIteratorPrototype%.next` method |
| // https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next |
| }, function () { |
| var state = getInternalState(this); |
| var target = state.target; |
| var kind = state.kind; |
| var index = state.index++; |
| if (!target || index >= target.length) { |
| state.target = undefined; |
| return { value: undefined, done: true }; |
| } |
| if (kind == 'keys') return { value: index, done: false }; |
| if (kind == 'values') return { value: target[index], done: false }; |
| return { value: [index, target[index]], done: false }; |
| }, 'values'); |
| |
| // argumentsList[@@iterator] is %ArrayProto_values% |
| // https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject |
| // https://tc39.github.io/ecma262/#sec-createmappedargumentsobject |
| Iterators.Arguments = Iterators.Array; |
| |
| // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables |
| addToUnscopables('keys'); |
| addToUnscopables('values'); |
| addToUnscopables('entries'); |
| |
| },{"../internals/add-to-unscopables":10,"../internals/define-iterator":43,"../internals/internal-state":72,"../internals/iterators":82,"../internals/to-indexed-object":138}],171:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var IndexedObject = require('../internals/indexed-object'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| var nativeJoin = [].join; |
| |
| var ES3_STRINGS = IndexedObject != Object; |
| var SLOPPY_METHOD = sloppyArrayMethod('join', ','); |
| |
| // `Array.prototype.join` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.join |
| $({ target: 'Array', proto: true, forced: ES3_STRINGS || SLOPPY_METHOD }, { |
| join: function join(separator) { |
| return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/indexed-object":69,"../internals/sloppy-array-method":128,"../internals/to-indexed-object":138}],172:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var lastIndexOf = require('../internals/array-last-index-of'); |
| |
| // `Array.prototype.lastIndexOf` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof |
| $({ target: 'Array', proto: true, forced: lastIndexOf !== [].lastIndexOf }, { |
| lastIndexOf: lastIndexOf |
| }); |
| |
| },{"../internals/array-last-index-of":22,"../internals/export":49}],173:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $map = require('../internals/array-iteration').map; |
| var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support'); |
| |
| // `Array.prototype.map` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.map |
| // with adding support of @@species |
| $({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('map') }, { |
| map: function map(callbackfn /* , thisArg */) { |
| return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-iteration":21,"../internals/array-method-has-species-support":23,"../internals/export":49}],174:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var createProperty = require('../internals/create-property'); |
| |
| var ISNT_GENERIC = fails(function () { |
| function F() { /* empty */ } |
| return !(Array.of.call(F) instanceof F); |
| }); |
| |
| // `Array.of` method |
| // https://tc39.github.io/ecma262/#sec-array.of |
| // WebKit Array.of isn't generic |
| $({ target: 'Array', stat: true, forced: ISNT_GENERIC }, { |
| of: function of(/* ...args */) { |
| var index = 0; |
| var argumentsLength = arguments.length; |
| var result = new (typeof this == 'function' ? this : Array)(argumentsLength); |
| while (argumentsLength > index) createProperty(result, index, arguments[index++]); |
| result.length = argumentsLength; |
| return result; |
| } |
| }); |
| |
| },{"../internals/create-property":40,"../internals/export":49,"../internals/fails":50}],175:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $reduceRight = require('../internals/array-reduce').right; |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| // `Array.prototype.reduceRight` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.reduceright |
| $({ target: 'Array', proto: true, forced: sloppyArrayMethod('reduceRight') }, { |
| reduceRight: function reduceRight(callbackfn /* , initialValue */) { |
| return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-reduce":24,"../internals/export":49,"../internals/sloppy-array-method":128}],176:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $reduce = require('../internals/array-reduce').left; |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| // `Array.prototype.reduce` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.reduce |
| $({ target: 'Array', proto: true, forced: sloppyArrayMethod('reduce') }, { |
| reduce: function reduce(callbackfn /* , initialValue */) { |
| return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-reduce":24,"../internals/export":49,"../internals/sloppy-array-method":128}],177:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var isArray = require('../internals/is-array'); |
| |
| var nativeReverse = [].reverse; |
| var test = [1, 2]; |
| |
| // `Array.prototype.reverse` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.reverse |
| // fix for Safari 12.0 bug |
| // https://bugs.webkit.org/show_bug.cgi?id=188794 |
| $({ target: 'Array', proto: true, forced: String(test) === String(test.reverse()) }, { |
| reverse: function reverse() { |
| if (isArray(this)) this.length = this.length; |
| return nativeReverse.call(this); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/is-array":74}],178:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var isObject = require('../internals/is-object'); |
| var isArray = require('../internals/is-array'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| var toLength = require('../internals/to-length'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var createProperty = require('../internals/create-property'); |
| var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| var nativeSlice = [].slice; |
| var max = Math.max; |
| |
| // `Array.prototype.slice` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.slice |
| // fallback for not array-like ES3 strings and DOM objects |
| $({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('slice') }, { |
| slice: function slice(start, end) { |
| var O = toIndexedObject(this); |
| var length = toLength(O.length); |
| var k = toAbsoluteIndex(start, length); |
| var fin = toAbsoluteIndex(end === undefined ? length : end, length); |
| // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible |
| var Constructor, result, n; |
| if (isArray(O)) { |
| Constructor = O.constructor; |
| // cross-realm fallback |
| if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { |
| Constructor = undefined; |
| } else if (isObject(Constructor)) { |
| Constructor = Constructor[SPECIES]; |
| if (Constructor === null) Constructor = undefined; |
| } |
| if (Constructor === Array || Constructor === undefined) { |
| return nativeSlice.call(O, k, fin); |
| } |
| } |
| result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0)); |
| for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); |
| result.length = n; |
| return result; |
| } |
| }); |
| |
| },{"../internals/array-method-has-species-support":23,"../internals/create-property":40,"../internals/export":49,"../internals/is-array":74,"../internals/is-object":77,"../internals/to-absolute-index":136,"../internals/to-indexed-object":138,"../internals/to-length":140,"../internals/well-known-symbol":150}],179:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $some = require('../internals/array-iteration').some; |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| // `Array.prototype.some` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.some |
| $({ target: 'Array', proto: true, forced: sloppyArrayMethod('some') }, { |
| some: function some(callbackfn /* , thisArg */) { |
| return $some(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/array-iteration":21,"../internals/export":49,"../internals/sloppy-array-method":128}],180:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var aFunction = require('../internals/a-function'); |
| var toObject = require('../internals/to-object'); |
| var fails = require('../internals/fails'); |
| var sloppyArrayMethod = require('../internals/sloppy-array-method'); |
| |
| var nativeSort = [].sort; |
| var test = [1, 2, 3]; |
| |
| // IE8- |
| var FAILS_ON_UNDEFINED = fails(function () { |
| test.sort(undefined); |
| }); |
| // V8 bug |
| var FAILS_ON_NULL = fails(function () { |
| test.sort(null); |
| }); |
| // Old WebKit |
| var SLOPPY_METHOD = sloppyArrayMethod('sort'); |
| |
| var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || SLOPPY_METHOD; |
| |
| // `Array.prototype.sort` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.sort |
| $({ target: 'Array', proto: true, forced: FORCED }, { |
| sort: function sort(comparefn) { |
| return comparefn === undefined |
| ? nativeSort.call(toObject(this)) |
| : nativeSort.call(toObject(this), aFunction(comparefn)); |
| } |
| }); |
| |
| },{"../internals/a-function":8,"../internals/export":49,"../internals/fails":50,"../internals/sloppy-array-method":128,"../internals/to-object":141}],181:[function(require,module,exports){ |
| var setSpecies = require('../internals/set-species'); |
| |
| // `Array[@@species]` getter |
| // https://tc39.github.io/ecma262/#sec-get-array-@@species |
| setSpecies('Array'); |
| |
| },{"../internals/set-species":124}],182:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| var toInteger = require('../internals/to-integer'); |
| var toLength = require('../internals/to-length'); |
| var toObject = require('../internals/to-object'); |
| var arraySpeciesCreate = require('../internals/array-species-create'); |
| var createProperty = require('../internals/create-property'); |
| var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support'); |
| |
| var max = Math.max; |
| var min = Math.min; |
| var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; |
| var MAXIMUM_ALLOWED_LENGTH_EXCEEDED = 'Maximum allowed length exceeded'; |
| |
| // `Array.prototype.splice` method |
| // https://tc39.github.io/ecma262/#sec-array.prototype.splice |
| // with adding support of @@species |
| $({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('splice') }, { |
| splice: function splice(start, deleteCount /* , ...items */) { |
| var O = toObject(this); |
| var len = toLength(O.length); |
| var actualStart = toAbsoluteIndex(start, len); |
| var argumentsLength = arguments.length; |
| var insertCount, actualDeleteCount, A, k, from, to; |
| if (argumentsLength === 0) { |
| insertCount = actualDeleteCount = 0; |
| } else if (argumentsLength === 1) { |
| insertCount = 0; |
| actualDeleteCount = len - actualStart; |
| } else { |
| insertCount = argumentsLength - 2; |
| actualDeleteCount = min(max(toInteger(deleteCount), 0), len - actualStart); |
| } |
| if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER) { |
| throw TypeError(MAXIMUM_ALLOWED_LENGTH_EXCEEDED); |
| } |
| A = arraySpeciesCreate(O, actualDeleteCount); |
| for (k = 0; k < actualDeleteCount; k++) { |
| from = actualStart + k; |
| if (from in O) createProperty(A, k, O[from]); |
| } |
| A.length = actualDeleteCount; |
| if (insertCount < actualDeleteCount) { |
| for (k = actualStart; k < len - actualDeleteCount; k++) { |
| from = k + actualDeleteCount; |
| to = k + insertCount; |
| if (from in O) O[to] = O[from]; |
| else delete O[to]; |
| } |
| for (k = len; k > len - actualDeleteCount + insertCount; k--) delete O[k - 1]; |
| } else if (insertCount > actualDeleteCount) { |
| for (k = len - actualDeleteCount; k > actualStart; k--) { |
| from = k + actualDeleteCount - 1; |
| to = k + insertCount - 1; |
| if (from in O) O[to] = O[from]; |
| else delete O[to]; |
| } |
| } |
| for (k = 0; k < insertCount; k++) { |
| O[k + actualStart] = arguments[k + 2]; |
| } |
| O.length = len - actualDeleteCount + insertCount; |
| return A; |
| } |
| }); |
| |
| },{"../internals/array-method-has-species-support":23,"../internals/array-species-create":25,"../internals/create-property":40,"../internals/export":49,"../internals/to-absolute-index":136,"../internals/to-integer":139,"../internals/to-length":140,"../internals/to-object":141}],183:[function(require,module,exports){ |
| // this method was added to unscopables after implementation |
| // in popular engines, so it's moved to a separate module |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| addToUnscopables('flatMap'); |
| |
| },{"../internals/add-to-unscopables":10}],184:[function(require,module,exports){ |
| // this method was added to unscopables after implementation |
| // in popular engines, so it's moved to a separate module |
| var addToUnscopables = require('../internals/add-to-unscopables'); |
| |
| addToUnscopables('flat'); |
| |
| },{"../internals/add-to-unscopables":10}],185:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var ArrayBufferModule = require('../internals/array-buffer'); |
| var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-view-core').NATIVE_ARRAY_BUFFER; |
| |
| // `DataView` constructor |
| // https://tc39.github.io/ecma262/#sec-dataview-constructor |
| $({ global: true, forced: !NATIVE_ARRAY_BUFFER }, { |
| DataView: ArrayBufferModule.DataView |
| }); |
| |
| },{"../internals/array-buffer":15,"../internals/array-buffer-view-core":14,"../internals/export":49}],186:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| // `Date.now` method |
| // https://tc39.github.io/ecma262/#sec-date.now |
| $({ target: 'Date', stat: true }, { |
| now: function now() { |
| return new Date().getTime(); |
| } |
| }); |
| |
| },{"../internals/export":49}],187:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var toISOString = require('../internals/date-to-iso-string'); |
| |
| // `Date.prototype.toISOString` method |
| // https://tc39.github.io/ecma262/#sec-date.prototype.toisostring |
| // PhantomJS / old WebKit has a broken implementations |
| $({ target: 'Date', proto: true, forced: Date.prototype.toISOString !== toISOString }, { |
| toISOString: toISOString |
| }); |
| |
| },{"../internals/date-to-iso-string":41,"../internals/export":49}],188:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var toObject = require('../internals/to-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| |
| var FORCED = fails(function () { |
| return new Date(NaN).toJSON() !== null |
| || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1; |
| }); |
| |
| // `Date.prototype.toJSON` method |
| // https://tc39.github.io/ecma262/#sec-date.prototype.tojson |
| $({ target: 'Date', proto: true, forced: FORCED }, { |
| // eslint-disable-next-line no-unused-vars |
| toJSON: function toJSON(key) { |
| var O = toObject(this); |
| var pv = toPrimitive(O); |
| return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString(); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/to-object":141,"../internals/to-primitive":143}],189:[function(require,module,exports){ |
| var hide = require('../internals/hide'); |
| var dateToPrimitive = require('../internals/date-to-primitive'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); |
| var DatePrototype = Date.prototype; |
| |
| // `Date.prototype[@@toPrimitive]` method |
| // https://tc39.github.io/ecma262/#sec-date.prototype-@@toprimitive |
| if (!(TO_PRIMITIVE in DatePrototype)) hide(DatePrototype, TO_PRIMITIVE, dateToPrimitive); |
| |
| },{"../internals/date-to-primitive":42,"../internals/hide":65,"../internals/well-known-symbol":150}],190:[function(require,module,exports){ |
| var redefine = require('../internals/redefine'); |
| |
| var DatePrototype = Date.prototype; |
| var INVALID_DATE = 'Invalid Date'; |
| var TO_STRING = 'toString'; |
| var nativeDateToString = DatePrototype[TO_STRING]; |
| var getTime = DatePrototype.getTime; |
| |
| // `Date.prototype.toString` method |
| // https://tc39.github.io/ecma262/#sec-date.prototype.tostring |
| if (new Date(NaN) + '' != INVALID_DATE) { |
| redefine(DatePrototype, TO_STRING, function toString() { |
| var value = getTime.call(this); |
| // eslint-disable-next-line no-self-compare |
| return value === value ? nativeDateToString.call(this) : INVALID_DATE; |
| }); |
| } |
| |
| },{"../internals/redefine":117}],191:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var bind = require('../internals/function-bind'); |
| |
| // `Function.prototype.bind` method |
| // https://tc39.github.io/ecma262/#sec-function.prototype.bind |
| $({ target: 'Function', proto: true }, { |
| bind: bind |
| }); |
| |
| },{"../internals/export":49,"../internals/function-bind":57}],192:[function(require,module,exports){ |
| 'use strict'; |
| var isObject = require('../internals/is-object'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var HAS_INSTANCE = wellKnownSymbol('hasInstance'); |
| var FunctionPrototype = Function.prototype; |
| |
| // `Function.prototype[@@hasInstance]` method |
| // https://tc39.github.io/ecma262/#sec-function.prototype-@@hasinstance |
| if (!(HAS_INSTANCE in FunctionPrototype)) { |
| definePropertyModule.f(FunctionPrototype, HAS_INSTANCE, { value: function (O) { |
| if (typeof this != 'function' || !isObject(O)) return false; |
| if (!isObject(this.prototype)) return O instanceof this; |
| // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this: |
| while (O = getPrototypeOf(O)) if (this.prototype === O) return true; |
| return false; |
| } }); |
| } |
| |
| },{"../internals/is-object":77,"../internals/object-define-property":97,"../internals/object-get-prototype-of":102,"../internals/well-known-symbol":150}],193:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var defineProperty = require('../internals/object-define-property').f; |
| |
| var FunctionPrototype = Function.prototype; |
| var FunctionPrototypeToString = FunctionPrototype.toString; |
| var nameRE = /^\s*function ([^ (]*)/; |
| var NAME = 'name'; |
| |
| // Function instances `.name` property |
| // https://tc39.github.io/ecma262/#sec-function-instances-name |
| if (DESCRIPTORS && !(NAME in FunctionPrototype)) { |
| defineProperty(FunctionPrototype, NAME, { |
| configurable: true, |
| get: function () { |
| try { |
| return FunctionPrototypeToString.call(this).match(nameRE)[1]; |
| } catch (error) { |
| return ''; |
| } |
| } |
| }); |
| } |
| |
| },{"../internals/descriptors":45,"../internals/object-define-property":97}],194:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| |
| // JSON[@@toStringTag] property |
| // https://tc39.github.io/ecma262/#sec-json-@@tostringtag |
| setToStringTag(global.JSON, 'JSON', true); |
| |
| },{"../internals/global":62,"../internals/set-to-string-tag":125}],195:[function(require,module,exports){ |
| 'use strict'; |
| var collection = require('../internals/collection'); |
| var collectionStrong = require('../internals/collection-strong'); |
| |
| // `Map` constructor |
| // https://tc39.github.io/ecma262/#sec-map-objects |
| module.exports = collection('Map', function (get) { |
| return function Map() { return get(this, arguments.length ? arguments[0] : undefined); }; |
| }, collectionStrong, true); |
| |
| },{"../internals/collection":33,"../internals/collection-strong":31}],196:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var log1p = require('../internals/math-log1p'); |
| |
| var nativeAcosh = Math.acosh; |
| var log = Math.log; |
| var sqrt = Math.sqrt; |
| var LN2 = Math.LN2; |
| |
| var FORCED = !nativeAcosh |
| // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509 |
| || Math.floor(nativeAcosh(Number.MAX_VALUE)) != 710 |
| // Tor Browser bug: Math.acosh(Infinity) -> NaN |
| || nativeAcosh(Infinity) != Infinity; |
| |
| // `Math.acosh` method |
| // https://tc39.github.io/ecma262/#sec-math.acosh |
| $({ target: 'Math', stat: true, forced: FORCED }, { |
| acosh: function acosh(x) { |
| return (x = +x) < 1 ? NaN : x > 94906265.62425156 |
| ? log(x) + LN2 |
| : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1)); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/math-log1p":85}],197:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var nativeAsinh = Math.asinh; |
| var log = Math.log; |
| var sqrt = Math.sqrt; |
| |
| function asinh(x) { |
| return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log(x + sqrt(x * x + 1)); |
| } |
| |
| // `Math.asinh` method |
| // https://tc39.github.io/ecma262/#sec-math.asinh |
| // Tor Browser bug: Math.asinh(0) -> -0 |
| $({ target: 'Math', stat: true, forced: !(nativeAsinh && 1 / nativeAsinh(0) > 0) }, { |
| asinh: asinh |
| }); |
| |
| },{"../internals/export":49}],198:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var nativeAtanh = Math.atanh; |
| var log = Math.log; |
| |
| // `Math.atanh` method |
| // https://tc39.github.io/ecma262/#sec-math.atanh |
| // Tor Browser bug: Math.atanh(-0) -> 0 |
| $({ target: 'Math', stat: true, forced: !(nativeAtanh && 1 / nativeAtanh(-0) < 0) }, { |
| atanh: function atanh(x) { |
| return (x = +x) == 0 ? x : log((1 + x) / (1 - x)) / 2; |
| } |
| }); |
| |
| },{"../internals/export":49}],199:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var sign = require('../internals/math-sign'); |
| |
| var abs = Math.abs; |
| var pow = Math.pow; |
| |
| // `Math.cbrt` method |
| // https://tc39.github.io/ecma262/#sec-math.cbrt |
| $({ target: 'Math', stat: true }, { |
| cbrt: function cbrt(x) { |
| return sign(x = +x) * pow(abs(x), 1 / 3); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/math-sign":86}],200:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var floor = Math.floor; |
| var log = Math.log; |
| var LOG2E = Math.LOG2E; |
| |
| // `Math.clz32` method |
| // https://tc39.github.io/ecma262/#sec-math.clz32 |
| $({ target: 'Math', stat: true }, { |
| clz32: function clz32(x) { |
| return (x >>>= 0) ? 31 - floor(log(x + 0.5) * LOG2E) : 32; |
| } |
| }); |
| |
| },{"../internals/export":49}],201:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var expm1 = require('../internals/math-expm1'); |
| |
| var nativeCosh = Math.cosh; |
| var abs = Math.abs; |
| var E = Math.E; |
| |
| // `Math.cosh` method |
| // https://tc39.github.io/ecma262/#sec-math.cosh |
| $({ target: 'Math', stat: true, forced: !nativeCosh || nativeCosh(710) === Infinity }, { |
| cosh: function cosh(x) { |
| var t = expm1(abs(x) - 1) + 1; |
| return (t + 1 / (t * E * E)) * (E / 2); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/math-expm1":83}],202:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var expm1 = require('../internals/math-expm1'); |
| |
| // `Math.expm1` method |
| // https://tc39.github.io/ecma262/#sec-math.expm1 |
| $({ target: 'Math', stat: true, forced: expm1 != Math.expm1 }, { expm1: expm1 }); |
| |
| },{"../internals/export":49,"../internals/math-expm1":83}],203:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fround = require('../internals/math-fround'); |
| |
| // `Math.fround` method |
| // https://tc39.github.io/ecma262/#sec-math.fround |
| $({ target: 'Math', stat: true }, { fround: fround }); |
| |
| },{"../internals/export":49,"../internals/math-fround":84}],204:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var abs = Math.abs; |
| var sqrt = Math.sqrt; |
| |
| // `Math.hypot` method |
| // https://tc39.github.io/ecma262/#sec-math.hypot |
| $({ target: 'Math', stat: true }, { |
| hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars |
| var sum = 0; |
| var i = 0; |
| var aLen = arguments.length; |
| var larg = 0; |
| var arg, div; |
| while (i < aLen) { |
| arg = abs(arguments[i++]); |
| if (larg < arg) { |
| div = larg / arg; |
| sum = sum * div * div + 1; |
| larg = arg; |
| } else if (arg > 0) { |
| div = arg / larg; |
| sum += div * div; |
| } else sum += arg; |
| } |
| return larg === Infinity ? Infinity : larg * sqrt(sum); |
| } |
| }); |
| |
| },{"../internals/export":49}],205:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| |
| var nativeImul = Math.imul; |
| |
| var FORCED = fails(function () { |
| return nativeImul(0xFFFFFFFF, 5) != -5 || nativeImul.length != 2; |
| }); |
| |
| // `Math.imul` method |
| // https://tc39.github.io/ecma262/#sec-math.imul |
| // some WebKit versions fails with big numbers, some has wrong arity |
| $({ target: 'Math', stat: true, forced: FORCED }, { |
| imul: function imul(x, y) { |
| var UINT16 = 0xFFFF; |
| var xn = +x; |
| var yn = +y; |
| var xl = UINT16 & xn; |
| var yl = UINT16 & yn; |
| return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50}],206:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var log = Math.log; |
| var LOG10E = Math.LOG10E; |
| |
| // `Math.log10` method |
| // https://tc39.github.io/ecma262/#sec-math.log10 |
| $({ target: 'Math', stat: true }, { |
| log10: function log10(x) { |
| return log(x) * LOG10E; |
| } |
| }); |
| |
| },{"../internals/export":49}],207:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var log1p = require('../internals/math-log1p'); |
| |
| // `Math.log1p` method |
| // https://tc39.github.io/ecma262/#sec-math.log1p |
| $({ target: 'Math', stat: true }, { log1p: log1p }); |
| |
| },{"../internals/export":49,"../internals/math-log1p":85}],208:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var log = Math.log; |
| var LN2 = Math.LN2; |
| |
| // `Math.log2` method |
| // https://tc39.github.io/ecma262/#sec-math.log2 |
| $({ target: 'Math', stat: true }, { |
| log2: function log2(x) { |
| return log(x) / LN2; |
| } |
| }); |
| |
| },{"../internals/export":49}],209:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var sign = require('../internals/math-sign'); |
| |
| // `Math.sign` method |
| // https://tc39.github.io/ecma262/#sec-math.sign |
| $({ target: 'Math', stat: true }, { |
| sign: sign |
| }); |
| |
| },{"../internals/export":49,"../internals/math-sign":86}],210:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var expm1 = require('../internals/math-expm1'); |
| |
| var abs = Math.abs; |
| var exp = Math.exp; |
| var E = Math.E; |
| |
| var FORCED = fails(function () { |
| return Math.sinh(-2e-17) != -2e-17; |
| }); |
| |
| // `Math.sinh` method |
| // https://tc39.github.io/ecma262/#sec-math.sinh |
| // V8 near Chromium 38 has a problem with very small numbers |
| $({ target: 'Math', stat: true, forced: FORCED }, { |
| sinh: function sinh(x) { |
| return abs(x = +x) < 1 ? (expm1(x) - expm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E / 2); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/math-expm1":83}],211:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var expm1 = require('../internals/math-expm1'); |
| |
| var exp = Math.exp; |
| |
| // `Math.tanh` method |
| // https://tc39.github.io/ecma262/#sec-math.tanh |
| $({ target: 'Math', stat: true }, { |
| tanh: function tanh(x) { |
| var a = expm1(x = +x); |
| var b = expm1(-x); |
| return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x)); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/math-expm1":83}],212:[function(require,module,exports){ |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| |
| // Math[@@toStringTag] property |
| // https://tc39.github.io/ecma262/#sec-math-@@tostringtag |
| setToStringTag(Math, 'Math', true); |
| |
| },{"../internals/set-to-string-tag":125}],213:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| var ceil = Math.ceil; |
| var floor = Math.floor; |
| |
| // `Math.trunc` method |
| // https://tc39.github.io/ecma262/#sec-math.trunc |
| $({ target: 'Math', stat: true }, { |
| trunc: function trunc(it) { |
| return (it > 0 ? floor : ceil)(it); |
| } |
| }); |
| |
| },{"../internals/export":49}],214:[function(require,module,exports){ |
| 'use strict'; |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var global = require('../internals/global'); |
| var isForced = require('../internals/is-forced'); |
| var redefine = require('../internals/redefine'); |
| var has = require('../internals/has'); |
| var classof = require('../internals/classof-raw'); |
| var inheritIfRequired = require('../internals/inherit-if-required'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var fails = require('../internals/fails'); |
| var create = require('../internals/object-create'); |
| var getOwnPropertyNames = require('../internals/object-get-own-property-names').f; |
| var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| var defineProperty = require('../internals/object-define-property').f; |
| var trim = require('../internals/string-trim').trim; |
| |
| var NUMBER = 'Number'; |
| var NativeNumber = global[NUMBER]; |
| var NumberPrototype = NativeNumber.prototype; |
| |
| // Opera ~12 has broken Object#toString |
| var BROKEN_CLASSOF = classof(create(NumberPrototype)) == NUMBER; |
| |
| // `ToNumber` abstract operation |
| // https://tc39.github.io/ecma262/#sec-tonumber |
| var toNumber = function (argument) { |
| var it = toPrimitive(argument, false); |
| var first, third, radix, maxCode, digits, length, index, code; |
| if (typeof it == 'string' && it.length > 2) { |
| it = trim(it); |
| first = it.charCodeAt(0); |
| if (first === 43 || first === 45) { |
| third = it.charCodeAt(2); |
| if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix |
| } else if (first === 48) { |
| switch (it.charCodeAt(1)) { |
| case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i |
| case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i |
| default: return +it; |
| } |
| digits = it.slice(2); |
| length = digits.length; |
| for (index = 0; index < length; index++) { |
| code = digits.charCodeAt(index); |
| // parseInt parses a string to a first unavailable symbol |
| // but ToNumber should return NaN if a string contains unavailable symbols |
| if (code < 48 || code > maxCode) return NaN; |
| } return parseInt(digits, radix); |
| } |
| } return +it; |
| }; |
| |
| // `Number` constructor |
| // https://tc39.github.io/ecma262/#sec-number-constructor |
| if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { |
| var NumberWrapper = function Number(value) { |
| var it = arguments.length < 1 ? 0 : value; |
| var dummy = this; |
| return dummy instanceof NumberWrapper |
| // check on 1..constructor(foo) case |
| && (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(dummy); }) : classof(dummy) != NUMBER) |
| ? inheritIfRequired(new NativeNumber(toNumber(it)), dummy, NumberWrapper) : toNumber(it); |
| }; |
| for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : ( |
| // ES3: |
| 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + |
| // ES2015 (in case, if modules with ES2015 Number statics required before): |
| 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + |
| 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger' |
| ).split(','), j = 0, key; keys.length > j; j++) { |
| if (has(NativeNumber, key = keys[j]) && !has(NumberWrapper, key)) { |
| defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key)); |
| } |
| } |
| NumberWrapper.prototype = NumberPrototype; |
| NumberPrototype.constructor = NumberWrapper; |
| redefine(global, NUMBER, NumberWrapper); |
| } |
| |
| },{"../internals/classof-raw":29,"../internals/descriptors":45,"../internals/fails":50,"../internals/global":62,"../internals/has":63,"../internals/inherit-if-required":70,"../internals/is-forced":75,"../internals/object-create":95,"../internals/object-define-property":97,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-own-property-names":100,"../internals/redefine":117,"../internals/string-trim":133,"../internals/to-primitive":143}],215:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| // `Number.EPSILON` constant |
| // https://tc39.github.io/ecma262/#sec-number.epsilon |
| $({ target: 'Number', stat: true }, { |
| EPSILON: Math.pow(2, -52) |
| }); |
| |
| },{"../internals/export":49}],216:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var numberIsFinite = require('../internals/number-is-finite'); |
| |
| // `Number.isFinite` method |
| // https://tc39.github.io/ecma262/#sec-number.isfinite |
| $({ target: 'Number', stat: true }, { isFinite: numberIsFinite }); |
| |
| },{"../internals/export":49,"../internals/number-is-finite":93}],217:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var isInteger = require('../internals/is-integer'); |
| |
| // `Number.isInteger` method |
| // https://tc39.github.io/ecma262/#sec-number.isinteger |
| $({ target: 'Number', stat: true }, { |
| isInteger: isInteger |
| }); |
| |
| },{"../internals/export":49,"../internals/is-integer":76}],218:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| // `Number.isNaN` method |
| // https://tc39.github.io/ecma262/#sec-number.isnan |
| $({ target: 'Number', stat: true }, { |
| isNaN: function isNaN(number) { |
| // eslint-disable-next-line no-self-compare |
| return number != number; |
| } |
| }); |
| |
| },{"../internals/export":49}],219:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var isInteger = require('../internals/is-integer'); |
| |
| var abs = Math.abs; |
| |
| // `Number.isSafeInteger` method |
| // https://tc39.github.io/ecma262/#sec-number.issafeinteger |
| $({ target: 'Number', stat: true }, { |
| isSafeInteger: function isSafeInteger(number) { |
| return isInteger(number) && abs(number) <= 0x1FFFFFFFFFFFFF; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/is-integer":76}],220:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| // `Number.MAX_SAFE_INTEGER` constant |
| // https://tc39.github.io/ecma262/#sec-number.max_safe_integer |
| $({ target: 'Number', stat: true }, { |
| MAX_SAFE_INTEGER: 0x1FFFFFFFFFFFFF |
| }); |
| |
| },{"../internals/export":49}],221:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| // `Number.MIN_SAFE_INTEGER` constant |
| // https://tc39.github.io/ecma262/#sec-number.min_safe_integer |
| $({ target: 'Number', stat: true }, { |
| MIN_SAFE_INTEGER: -0x1FFFFFFFFFFFFF |
| }); |
| |
| },{"../internals/export":49}],222:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var parseFloat = require('../internals/parse-float'); |
| |
| // `Number.parseFloat` method |
| // https://tc39.github.io/ecma262/#sec-number.parseFloat |
| $({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, { |
| parseFloat: parseFloat |
| }); |
| |
| },{"../internals/export":49,"../internals/parse-float":110}],223:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var parseInt = require('../internals/parse-int'); |
| |
| // `Number.parseInt` method |
| // https://tc39.github.io/ecma262/#sec-number.parseint |
| $({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, { |
| parseInt: parseInt |
| }); |
| |
| },{"../internals/export":49,"../internals/parse-int":111}],224:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var toInteger = require('../internals/to-integer'); |
| var thisNumberValue = require('../internals/this-number-value'); |
| var repeat = require('../internals/string-repeat'); |
| var fails = require('../internals/fails'); |
| |
| var nativeToFixed = 1.0.toFixed; |
| var floor = Math.floor; |
| |
| var pow = function (x, n, acc) { |
| return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); |
| }; |
| |
| var log = function (x) { |
| var n = 0; |
| var x2 = x; |
| while (x2 >= 4096) { |
| n += 12; |
| x2 /= 4096; |
| } |
| while (x2 >= 2) { |
| n += 1; |
| x2 /= 2; |
| } return n; |
| }; |
| |
| var FORCED = nativeToFixed && ( |
| 0.00008.toFixed(3) !== '0.000' || |
| 0.9.toFixed(0) !== '1' || |
| 1.255.toFixed(2) !== '1.25' || |
| 1000000000000000128.0.toFixed(0) !== '1000000000000000128' |
| ) || !fails(function () { |
| // V8 ~ Android 4.3- |
| nativeToFixed.call({}); |
| }); |
| |
| // `Number.prototype.toFixed` method |
| // https://tc39.github.io/ecma262/#sec-number.prototype.tofixed |
| $({ target: 'Number', proto: true, forced: FORCED }, { |
| // eslint-disable-next-line max-statements |
| toFixed: function toFixed(fractionDigits) { |
| var number = thisNumberValue(this); |
| var fractDigits = toInteger(fractionDigits); |
| var data = [0, 0, 0, 0, 0, 0]; |
| var sign = ''; |
| var result = '0'; |
| var e, z, j, k; |
| |
| var multiply = function (n, c) { |
| var index = -1; |
| var c2 = c; |
| while (++index < 6) { |
| c2 += n * data[index]; |
| data[index] = c2 % 1e7; |
| c2 = floor(c2 / 1e7); |
| } |
| }; |
| |
| var divide = function (n) { |
| var index = 6; |
| var c = 0; |
| while (--index >= 0) { |
| c += data[index]; |
| data[index] = floor(c / n); |
| c = (c % n) * 1e7; |
| } |
| }; |
| |
| var dataToString = function () { |
| var index = 6; |
| var s = ''; |
| while (--index >= 0) { |
| if (s !== '' || index === 0 || data[index] !== 0) { |
| var t = String(data[index]); |
| s = s === '' ? t : s + repeat.call('0', 7 - t.length) + t; |
| } |
| } return s; |
| }; |
| |
| if (fractDigits < 0 || fractDigits > 20) throw RangeError('Incorrect fraction digits'); |
| // eslint-disable-next-line no-self-compare |
| if (number != number) return 'NaN'; |
| if (number <= -1e21 || number >= 1e21) return String(number); |
| if (number < 0) { |
| sign = '-'; |
| number = -number; |
| } |
| if (number > 1e-21) { |
| e = log(number * pow(2, 69, 1)) - 69; |
| z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1); |
| z *= 0x10000000000000; |
| e = 52 - e; |
| if (e > 0) { |
| multiply(0, z); |
| j = fractDigits; |
| while (j >= 7) { |
| multiply(1e7, 0); |
| j -= 7; |
| } |
| multiply(pow(10, j, 1), 0); |
| j = e - 1; |
| while (j >= 23) { |
| divide(1 << 23); |
| j -= 23; |
| } |
| divide(1 << j); |
| multiply(1, 1); |
| divide(2); |
| result = dataToString(); |
| } else { |
| multiply(0, z); |
| multiply(1 << -e, 0); |
| result = dataToString() + repeat.call('0', fractDigits); |
| } |
| } |
| if (fractDigits > 0) { |
| k = result.length; |
| result = sign + (k <= fractDigits |
| ? '0.' + repeat.call('0', fractDigits - k) + result |
| : result.slice(0, k - fractDigits) + '.' + result.slice(k - fractDigits)); |
| } else { |
| result = sign + result; |
| } return result; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/string-repeat":132,"../internals/this-number-value":135,"../internals/to-integer":139}],225:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var thisNumberValue = require('../internals/this-number-value'); |
| |
| var nativeToPrecision = 1.0.toPrecision; |
| |
| var FORCED = fails(function () { |
| // IE7- |
| return nativeToPrecision.call(1, undefined) !== '1'; |
| }) || !fails(function () { |
| // V8 ~ Android 4.3- |
| nativeToPrecision.call({}); |
| }); |
| |
| // `Number.prototype.toPrecision` method |
| // https://tc39.github.io/ecma262/#sec-number.prototype.toprecision |
| $({ target: 'Number', proto: true, forced: FORCED }, { |
| toPrecision: function toPrecision(precision) { |
| return precision === undefined |
| ? nativeToPrecision.call(thisNumberValue(this)) |
| : nativeToPrecision.call(thisNumberValue(this), precision); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/this-number-value":135}],226:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var assign = require('../internals/object-assign'); |
| |
| // `Object.assign` method |
| // https://tc39.github.io/ecma262/#sec-object.assign |
| $({ target: 'Object', stat: true, forced: Object.assign !== assign }, { |
| assign: assign |
| }); |
| |
| },{"../internals/export":49,"../internals/object-assign":94}],227:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var create = require('../internals/object-create'); |
| |
| // `Object.create` method |
| // https://tc39.github.io/ecma262/#sec-object.create |
| $({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { |
| create: create |
| }); |
| |
| },{"../internals/descriptors":45,"../internals/export":49,"../internals/object-create":95}],228:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var FORCED = require('../internals/forced-object-prototype-accessors-methods'); |
| var toObject = require('../internals/to-object'); |
| var aFunction = require('../internals/a-function'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| |
| // `Object.prototype.__defineGetter__` method |
| // https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__ |
| if (DESCRIPTORS) { |
| $({ target: 'Object', proto: true, forced: FORCED }, { |
| __defineGetter__: function __defineGetter__(P, getter) { |
| definePropertyModule.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true }); |
| } |
| }); |
| } |
| |
| },{"../internals/a-function":8,"../internals/descriptors":45,"../internals/export":49,"../internals/forced-object-prototype-accessors-methods":53,"../internals/object-define-property":97,"../internals/to-object":141}],229:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var defineProperties = require('../internals/object-define-properties'); |
| |
| // `Object.defineProperties` method |
| // https://tc39.github.io/ecma262/#sec-object.defineproperties |
| $({ target: 'Object', stat: true, forced: !DESCRIPTORS, sham: !DESCRIPTORS }, { |
| defineProperties: defineProperties |
| }); |
| |
| },{"../internals/descriptors":45,"../internals/export":49,"../internals/object-define-properties":96}],230:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var objectDefinePropertyModile = require('../internals/object-define-property'); |
| |
| // `Object.defineProperty` method |
| // https://tc39.github.io/ecma262/#sec-object.defineproperty |
| $({ target: 'Object', stat: true, forced: !DESCRIPTORS, sham: !DESCRIPTORS }, { |
| defineProperty: objectDefinePropertyModile.f |
| }); |
| |
| },{"../internals/descriptors":45,"../internals/export":49,"../internals/object-define-property":97}],231:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var FORCED = require('../internals/forced-object-prototype-accessors-methods'); |
| var toObject = require('../internals/to-object'); |
| var aFunction = require('../internals/a-function'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| |
| // `Object.prototype.__defineSetter__` method |
| // https://tc39.github.io/ecma262/#sec-object.prototype.__defineSetter__ |
| if (DESCRIPTORS) { |
| $({ target: 'Object', proto: true, forced: FORCED }, { |
| __defineSetter__: function __defineSetter__(P, setter) { |
| definePropertyModule.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true }); |
| } |
| }); |
| } |
| |
| },{"../internals/a-function":8,"../internals/descriptors":45,"../internals/export":49,"../internals/forced-object-prototype-accessors-methods":53,"../internals/object-define-property":97,"../internals/to-object":141}],232:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var $entries = require('../internals/object-to-array').entries; |
| |
| // `Object.entries` method |
| // https://tc39.github.io/ecma262/#sec-object.entries |
| $({ target: 'Object', stat: true }, { |
| entries: function entries(O) { |
| return $entries(O); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/object-to-array":107}],233:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var FREEZING = require('../internals/freezing'); |
| var fails = require('../internals/fails'); |
| var isObject = require('../internals/is-object'); |
| var onFreeze = require('../internals/internal-metadata').onFreeze; |
| |
| var nativeFreeze = Object.freeze; |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeFreeze(1); }); |
| |
| // `Object.freeze` method |
| // https://tc39.github.io/ecma262/#sec-object.freeze |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { |
| freeze: function freeze(it) { |
| return nativeFreeze && isObject(it) ? nativeFreeze(onFreeze(it)) : it; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/freezing":56,"../internals/internal-metadata":71,"../internals/is-object":77}],234:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var iterate = require('../internals/iterate'); |
| var createProperty = require('../internals/create-property'); |
| |
| // `Object.fromEntries` method |
| // https://github.com/tc39/proposal-object-from-entries |
| $({ target: 'Object', stat: true }, { |
| fromEntries: function fromEntries(iterable) { |
| var obj = {}; |
| iterate(iterable, function (k, v) { |
| createProperty(obj, k, v); |
| }, undefined, true); |
| return obj; |
| } |
| }); |
| |
| },{"../internals/create-property":40,"../internals/export":49,"../internals/iterate":80}],235:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var nativeGetOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| var DESCRIPTORS = require('../internals/descriptors'); |
| |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeGetOwnPropertyDescriptor(1); }); |
| var FORCED = !DESCRIPTORS || FAILS_ON_PRIMITIVES; |
| |
| // `Object.getOwnPropertyDescriptor` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor |
| $({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, { |
| getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { |
| return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key); |
| } |
| }); |
| |
| },{"../internals/descriptors":45,"../internals/export":49,"../internals/fails":50,"../internals/object-get-own-property-descriptor":98,"../internals/to-indexed-object":138}],236:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var ownKeys = require('../internals/own-keys'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| var createProperty = require('../internals/create-property'); |
| |
| // `Object.getOwnPropertyDescriptors` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors |
| $({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { |
| getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) { |
| var O = toIndexedObject(object); |
| var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; |
| var keys = ownKeys(O); |
| var result = {}; |
| var index = 0; |
| var key, descriptor; |
| while (keys.length > index) { |
| descriptor = getOwnPropertyDescriptor(O, key = keys[index++]); |
| if (descriptor !== undefined) createProperty(result, key, descriptor); |
| } |
| return result; |
| } |
| }); |
| |
| },{"../internals/create-property":40,"../internals/descriptors":45,"../internals/export":49,"../internals/object-get-own-property-descriptor":98,"../internals/own-keys":109,"../internals/to-indexed-object":138}],237:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var nativeGetOwnPropertyNames = require('../internals/object-get-own-property-names-external').f; |
| |
| var FAILS_ON_PRIMITIVES = fails(function () { return !Object.getOwnPropertyNames(1); }); |
| |
| // `Object.getOwnPropertyNames` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertynames |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { |
| getOwnPropertyNames: nativeGetOwnPropertyNames |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/object-get-own-property-names-external":99}],238:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var toObject = require('../internals/to-object'); |
| var nativeGetPrototypeOf = require('../internals/object-get-prototype-of'); |
| var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter'); |
| |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeGetPrototypeOf(1); }); |
| |
| // `Object.getPrototypeOf` method |
| // https://tc39.github.io/ecma262/#sec-object.getprototypeof |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !CORRECT_PROTOTYPE_GETTER }, { |
| getPrototypeOf: function getPrototypeOf(it) { |
| return nativeGetPrototypeOf(toObject(it)); |
| } |
| }); |
| |
| |
| },{"../internals/correct-prototype-getter":36,"../internals/export":49,"../internals/fails":50,"../internals/object-get-prototype-of":102,"../internals/to-object":141}],239:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var isObject = require('../internals/is-object'); |
| |
| var nativeIsExtensible = Object.isExtensible; |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeIsExtensible(1); }); |
| |
| // `Object.isExtensible` method |
| // https://tc39.github.io/ecma262/#sec-object.isextensible |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { |
| isExtensible: function isExtensible(it) { |
| return isObject(it) ? nativeIsExtensible ? nativeIsExtensible(it) : true : false; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/is-object":77}],240:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var isObject = require('../internals/is-object'); |
| |
| var nativeIsFrozen = Object.isFrozen; |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeIsFrozen(1); }); |
| |
| // `Object.isFrozen` method |
| // https://tc39.github.io/ecma262/#sec-object.isfrozen |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { |
| isFrozen: function isFrozen(it) { |
| return isObject(it) ? nativeIsFrozen ? nativeIsFrozen(it) : false : true; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/is-object":77}],241:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var fails = require('../internals/fails'); |
| var isObject = require('../internals/is-object'); |
| |
| var nativeIsSealed = Object.isSealed; |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeIsSealed(1); }); |
| |
| // `Object.isSealed` method |
| // https://tc39.github.io/ecma262/#sec-object.issealed |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { |
| isSealed: function isSealed(it) { |
| return isObject(it) ? nativeIsSealed ? nativeIsSealed(it) : false : true; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/is-object":77}],242:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var is = require('../internals/same-value'); |
| |
| // `Object.is` method |
| // https://tc39.github.io/ecma262/#sec-object.is |
| $({ target: 'Object', stat: true }, { |
| is: is |
| }); |
| |
| },{"../internals/export":49,"../internals/same-value":122}],243:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var toObject = require('../internals/to-object'); |
| var nativeKeys = require('../internals/object-keys'); |
| var fails = require('../internals/fails'); |
| |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); }); |
| |
| // `Object.keys` method |
| // https://tc39.github.io/ecma262/#sec-object.keys |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { |
| keys: function keys(it) { |
| return nativeKeys(toObject(it)); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/object-keys":104,"../internals/to-object":141}],244:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var FORCED = require('../internals/forced-object-prototype-accessors-methods'); |
| var toObject = require('../internals/to-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| |
| // `Object.prototype.__lookupGetter__` method |
| // https://tc39.github.io/ecma262/#sec-object.prototype.__lookupGetter__ |
| if (DESCRIPTORS) { |
| $({ target: 'Object', proto: true, forced: FORCED }, { |
| __lookupGetter__: function __lookupGetter__(P) { |
| var O = toObject(this); |
| var key = toPrimitive(P, true); |
| var desc; |
| do { |
| if (desc = getOwnPropertyDescriptor(O, key)) return desc.get; |
| } while (O = getPrototypeOf(O)); |
| } |
| }); |
| } |
| |
| },{"../internals/descriptors":45,"../internals/export":49,"../internals/forced-object-prototype-accessors-methods":53,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-prototype-of":102,"../internals/to-object":141,"../internals/to-primitive":143}],245:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var FORCED = require('../internals/forced-object-prototype-accessors-methods'); |
| var toObject = require('../internals/to-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| |
| // `Object.prototype.__lookupSetter__` method |
| // https://tc39.github.io/ecma262/#sec-object.prototype.__lookupSetter__ |
| if (DESCRIPTORS) { |
| $({ target: 'Object', proto: true, forced: FORCED }, { |
| __lookupSetter__: function __lookupSetter__(P) { |
| var O = toObject(this); |
| var key = toPrimitive(P, true); |
| var desc; |
| do { |
| if (desc = getOwnPropertyDescriptor(O, key)) return desc.set; |
| } while (O = getPrototypeOf(O)); |
| } |
| }); |
| } |
| |
| },{"../internals/descriptors":45,"../internals/export":49,"../internals/forced-object-prototype-accessors-methods":53,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-prototype-of":102,"../internals/to-object":141,"../internals/to-primitive":143}],246:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var isObject = require('../internals/is-object'); |
| var onFreeze = require('../internals/internal-metadata').onFreeze; |
| var FREEZING = require('../internals/freezing'); |
| var fails = require('../internals/fails'); |
| |
| var nativePreventExtensions = Object.preventExtensions; |
| var FAILS_ON_PRIMITIVES = fails(function () { nativePreventExtensions(1); }); |
| |
| // `Object.preventExtensions` method |
| // https://tc39.github.io/ecma262/#sec-object.preventextensions |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { |
| preventExtensions: function preventExtensions(it) { |
| return nativePreventExtensions && isObject(it) ? nativePreventExtensions(onFreeze(it)) : it; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/freezing":56,"../internals/internal-metadata":71,"../internals/is-object":77}],247:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var isObject = require('../internals/is-object'); |
| var onFreeze = require('../internals/internal-metadata').onFreeze; |
| var FREEZING = require('../internals/freezing'); |
| var fails = require('../internals/fails'); |
| |
| var nativeSeal = Object.seal; |
| var FAILS_ON_PRIMITIVES = fails(function () { nativeSeal(1); }); |
| |
| // `Object.seal` method |
| // https://tc39.github.io/ecma262/#sec-object.seal |
| $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { |
| seal: function seal(it) { |
| return nativeSeal && isObject(it) ? nativeSeal(onFreeze(it)) : it; |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/fails":50,"../internals/freezing":56,"../internals/internal-metadata":71,"../internals/is-object":77}],248:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var setPrototypeOf = require('../internals/object-set-prototype-of'); |
| |
| // `Object.setPrototypeOf` method |
| // https://tc39.github.io/ecma262/#sec-object.setprototypeof |
| $({ target: 'Object', stat: true }, { |
| setPrototypeOf: setPrototypeOf |
| }); |
| |
| },{"../internals/export":49,"../internals/object-set-prototype-of":106}],249:[function(require,module,exports){ |
| var redefine = require('../internals/redefine'); |
| var toString = require('../internals/object-to-string'); |
| |
| var ObjectPrototype = Object.prototype; |
| |
| // `Object.prototype.toString` method |
| // https://tc39.github.io/ecma262/#sec-object.prototype.tostring |
| if (toString !== ObjectPrototype.toString) { |
| redefine(ObjectPrototype, 'toString', toString, { unsafe: true }); |
| } |
| |
| },{"../internals/object-to-string":108,"../internals/redefine":117}],250:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var $values = require('../internals/object-to-array').values; |
| |
| // `Object.values` method |
| // https://tc39.github.io/ecma262/#sec-object.values |
| $({ target: 'Object', stat: true }, { |
| values: function values(O) { |
| return $values(O); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/object-to-array":107}],251:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var parseFloatImplementation = require('../internals/parse-float'); |
| |
| // `parseFloat` method |
| // https://tc39.github.io/ecma262/#sec-parsefloat-string |
| $({ global: true, forced: parseFloat != parseFloatImplementation }, { |
| parseFloat: parseFloatImplementation |
| }); |
| |
| },{"../internals/export":49,"../internals/parse-float":110}],252:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var parseIntImplementation = require('../internals/parse-int'); |
| |
| // `parseInt` method |
| // https://tc39.github.io/ecma262/#sec-parseint-string-radix |
| $({ global: true, forced: parseInt != parseIntImplementation }, { |
| parseInt: parseIntImplementation |
| }); |
| |
| },{"../internals/export":49,"../internals/parse-int":111}],253:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var getBuiltIn = require('../internals/get-built-in'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| var promiseResolve = require('../internals/promise-resolve'); |
| |
| // `Promise.prototype.finally` method |
| // https://tc39.github.io/ecma262/#sec-promise.prototype.finally |
| $({ target: 'Promise', proto: true, real: true }, { |
| 'finally': function (onFinally) { |
| var C = speciesConstructor(this, getBuiltIn('Promise')); |
| var isFunction = typeof onFinally == 'function'; |
| return this.then( |
| isFunction ? function (x) { |
| return promiseResolve(C, onFinally()).then(function () { return x; }); |
| } : onFinally, |
| isFunction ? function (e) { |
| return promiseResolve(C, onFinally()).then(function () { throw e; }); |
| } : onFinally |
| ); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/get-built-in":59,"../internals/promise-resolve":114,"../internals/species-constructor":129}],254:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var IS_PURE = require('../internals/is-pure'); |
| var global = require('../internals/global'); |
| var path = require('../internals/path'); |
| var redefineAll = require('../internals/redefine-all'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var setSpecies = require('../internals/set-species'); |
| var isObject = require('../internals/is-object'); |
| var aFunction = require('../internals/a-function'); |
| var anInstance = require('../internals/an-instance'); |
| var classof = require('../internals/classof-raw'); |
| var iterate = require('../internals/iterate'); |
| var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| var task = require('../internals/task').set; |
| var microtask = require('../internals/microtask'); |
| var promiseResolve = require('../internals/promise-resolve'); |
| var hostReportErrors = require('../internals/host-report-errors'); |
| var newPromiseCapabilityModule = require('../internals/new-promise-capability'); |
| var perform = require('../internals/perform'); |
| var userAgent = require('../internals/user-agent'); |
| var InternalStateModule = require('../internals/internal-state'); |
| var isForced = require('../internals/is-forced'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| var PROMISE = 'Promise'; |
| var getInternalState = InternalStateModule.get; |
| var setInternalState = InternalStateModule.set; |
| var getInternalPromiseState = InternalStateModule.getterFor(PROMISE); |
| var PromiseConstructor = global[PROMISE]; |
| var TypeError = global.TypeError; |
| var document = global.document; |
| var process = global.process; |
| var $fetch = global.fetch; |
| var versions = process && process.versions; |
| var v8 = versions && versions.v8 || ''; |
| var newPromiseCapability = newPromiseCapabilityModule.f; |
| var newGenericPromiseCapability = newPromiseCapability; |
| var IS_NODE = classof(process) == 'process'; |
| var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent); |
| var UNHANDLED_REJECTION = 'unhandledrejection'; |
| var REJECTION_HANDLED = 'rejectionhandled'; |
| var PENDING = 0; |
| var FULFILLED = 1; |
| var REJECTED = 2; |
| var HANDLED = 1; |
| var UNHANDLED = 2; |
| var Internal, OwnPromiseCapability, PromiseWrapper; |
| |
| var FORCED = isForced(PROMISE, function () { |
| // correct subclassing with @@species support |
| var promise = PromiseConstructor.resolve(1); |
| var empty = function () { /* empty */ }; |
| var FakePromise = (promise.constructor = {})[SPECIES] = function (exec) { |
| exec(empty, empty); |
| }; |
| // unhandled rejections tracking support, NodeJS Promise without it fails @@species test |
| return !((IS_NODE || typeof PromiseRejectionEvent == 'function') |
| && (!IS_PURE || promise['finally']) |
| && promise.then(empty) instanceof FakePromise |
| // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables |
| // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 |
| // we can't detect it synchronously, so just check versions |
| && v8.indexOf('6.6') !== 0 |
| && userAgent.indexOf('Chrome/66') === -1); |
| }); |
| |
| var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) { |
| PromiseConstructor.all(iterable)['catch'](function () { /* empty */ }); |
| }); |
| |
| // helpers |
| var isThenable = function (it) { |
| var then; |
| return isObject(it) && typeof (then = it.then) == 'function' ? then : false; |
| }; |
| |
| var notify = function (promise, state, isReject) { |
| if (state.notified) return; |
| state.notified = true; |
| var chain = state.reactions; |
| microtask(function () { |
| var value = state.value; |
| var ok = state.state == FULFILLED; |
| var index = 0; |
| // variable length - can't use forEach |
| while (chain.length > index) { |
| var reaction = chain[index++]; |
| var handler = ok ? reaction.ok : reaction.fail; |
| var resolve = reaction.resolve; |
| var reject = reaction.reject; |
| var domain = reaction.domain; |
| var result, then, exited; |
| try { |
| if (handler) { |
| if (!ok) { |
| if (state.rejection === UNHANDLED) onHandleUnhandled(promise, state); |
| state.rejection = HANDLED; |
| } |
| if (handler === true) result = value; |
| else { |
| if (domain) domain.enter(); |
| result = handler(value); // can throw |
| if (domain) { |
| domain.exit(); |
| exited = true; |
| } |
| } |
| if (result === reaction.promise) { |
| reject(TypeError('Promise-chain cycle')); |
| } else if (then = isThenable(result)) { |
| then.call(result, resolve, reject); |
| } else resolve(result); |
| } else reject(value); |
| } catch (error) { |
| if (domain && !exited) domain.exit(); |
| reject(error); |
| } |
| } |
| state.reactions = []; |
| state.notified = false; |
| if (isReject && !state.rejection) onUnhandled(promise, state); |
| }); |
| }; |
| |
| var dispatchEvent = function (name, promise, reason) { |
| var event, handler; |
| if (DISPATCH_EVENT) { |
| event = document.createEvent('Event'); |
| event.promise = promise; |
| event.reason = reason; |
| event.initEvent(name, false, true); |
| global.dispatchEvent(event); |
| } else event = { promise: promise, reason: reason }; |
| if (handler = global['on' + name]) handler(event); |
| else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); |
| }; |
| |
| var onUnhandled = function (promise, state) { |
| task.call(global, function () { |
| var value = state.value; |
| var IS_UNHANDLED = isUnhandled(state); |
| var result; |
| if (IS_UNHANDLED) { |
| result = perform(function () { |
| if (IS_NODE) { |
| process.emit('unhandledRejection', value, promise); |
| } else dispatchEvent(UNHANDLED_REJECTION, promise, value); |
| }); |
| // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should |
| state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; |
| if (result.error) throw result.value; |
| } |
| }); |
| }; |
| |
| var isUnhandled = function (state) { |
| return state.rejection !== HANDLED && !state.parent; |
| }; |
| |
| var onHandleUnhandled = function (promise, state) { |
| task.call(global, function () { |
| if (IS_NODE) { |
| process.emit('rejectionHandled', promise); |
| } else dispatchEvent(REJECTION_HANDLED, promise, state.value); |
| }); |
| }; |
| |
| var bind = function (fn, promise, state, unwrap) { |
| return function (value) { |
| fn(promise, state, value, unwrap); |
| }; |
| }; |
| |
| var internalReject = function (promise, state, value, unwrap) { |
| if (state.done) return; |
| state.done = true; |
| if (unwrap) state = unwrap; |
| state.value = value; |
| state.state = REJECTED; |
| notify(promise, state, true); |
| }; |
| |
| var internalResolve = function (promise, state, value, unwrap) { |
| if (state.done) return; |
| state.done = true; |
| if (unwrap) state = unwrap; |
| try { |
| if (promise === value) throw TypeError("Promise can't be resolved itself"); |
| var then = isThenable(value); |
| if (then) { |
| microtask(function () { |
| var wrapper = { done: false }; |
| try { |
| then.call(value, |
| bind(internalResolve, promise, wrapper, state), |
| bind(internalReject, promise, wrapper, state) |
| ); |
| } catch (error) { |
| internalReject(promise, wrapper, error, state); |
| } |
| }); |
| } else { |
| state.value = value; |
| state.state = FULFILLED; |
| notify(promise, state, false); |
| } |
| } catch (error) { |
| internalReject(promise, { done: false }, error, state); |
| } |
| }; |
| |
| // constructor polyfill |
| if (FORCED) { |
| // 25.4.3.1 Promise(executor) |
| PromiseConstructor = function Promise(executor) { |
| anInstance(this, PromiseConstructor, PROMISE); |
| aFunction(executor); |
| Internal.call(this); |
| var state = getInternalState(this); |
| try { |
| executor(bind(internalResolve, this, state), bind(internalReject, this, state)); |
| } catch (error) { |
| internalReject(this, state, error); |
| } |
| }; |
| // eslint-disable-next-line no-unused-vars |
| Internal = function Promise(executor) { |
| setInternalState(this, { |
| type: PROMISE, |
| done: false, |
| notified: false, |
| parent: false, |
| reactions: [], |
| rejection: false, |
| state: PENDING, |
| value: undefined |
| }); |
| }; |
| Internal.prototype = redefineAll(PromiseConstructor.prototype, { |
| // `Promise.prototype.then` method |
| // https://tc39.github.io/ecma262/#sec-promise.prototype.then |
| then: function then(onFulfilled, onRejected) { |
| var state = getInternalPromiseState(this); |
| var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor)); |
| reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; |
| reaction.fail = typeof onRejected == 'function' && onRejected; |
| reaction.domain = IS_NODE ? process.domain : undefined; |
| state.parent = true; |
| state.reactions.push(reaction); |
| if (state.state != PENDING) notify(this, state, false); |
| return reaction.promise; |
| }, |
| // `Promise.prototype.catch` method |
| // https://tc39.github.io/ecma262/#sec-promise.prototype.catch |
| 'catch': function (onRejected) { |
| return this.then(undefined, onRejected); |
| } |
| }); |
| OwnPromiseCapability = function () { |
| var promise = new Internal(); |
| var state = getInternalState(promise); |
| this.promise = promise; |
| this.resolve = bind(internalResolve, promise, state); |
| this.reject = bind(internalReject, promise, state); |
| }; |
| newPromiseCapabilityModule.f = newPromiseCapability = function (C) { |
| return C === PromiseConstructor || C === PromiseWrapper |
| ? new OwnPromiseCapability(C) |
| : newGenericPromiseCapability(C); |
| }; |
| |
| // wrap fetch result |
| if (!IS_PURE && typeof $fetch == 'function') $({ global: true, enumerable: true, forced: true }, { |
| // eslint-disable-next-line no-unused-vars |
| fetch: function fetch(input) { |
| return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments)); |
| } |
| }); |
| } |
| |
| $({ global: true, wrap: true, forced: FORCED }, { |
| Promise: PromiseConstructor |
| }); |
| |
| setToStringTag(PromiseConstructor, PROMISE, false, true); |
| setSpecies(PROMISE); |
| |
| PromiseWrapper = path[PROMISE]; |
| |
| // statics |
| $({ target: PROMISE, stat: true, forced: FORCED }, { |
| // `Promise.reject` method |
| // https://tc39.github.io/ecma262/#sec-promise.reject |
| reject: function reject(r) { |
| var capability = newPromiseCapability(this); |
| capability.reject.call(undefined, r); |
| return capability.promise; |
| } |
| }); |
| |
| $({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, { |
| // `Promise.resolve` method |
| // https://tc39.github.io/ecma262/#sec-promise.resolve |
| resolve: function resolve(x) { |
| return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x); |
| } |
| }); |
| |
| $({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, { |
| // `Promise.all` method |
| // https://tc39.github.io/ecma262/#sec-promise.all |
| all: function all(iterable) { |
| var C = this; |
| var capability = newPromiseCapability(C); |
| var resolve = capability.resolve; |
| var reject = capability.reject; |
| var result = perform(function () { |
| var $promiseResolve = aFunction(C.resolve); |
| var values = []; |
| var counter = 0; |
| var remaining = 1; |
| iterate(iterable, function (promise) { |
| var index = counter++; |
| var alreadyCalled = false; |
| values.push(undefined); |
| remaining++; |
| $promiseResolve.call(C, promise).then(function (value) { |
| if (alreadyCalled) return; |
| alreadyCalled = true; |
| values[index] = value; |
| --remaining || resolve(values); |
| }, reject); |
| }); |
| --remaining || resolve(values); |
| }); |
| if (result.error) reject(result.value); |
| return capability.promise; |
| }, |
| // `Promise.race` method |
| // https://tc39.github.io/ecma262/#sec-promise.race |
| race: function race(iterable) { |
| var C = this; |
| var capability = newPromiseCapability(C); |
| var reject = capability.reject; |
| var result = perform(function () { |
| var $promiseResolve = aFunction(C.resolve); |
| iterate(iterable, function (promise) { |
| $promiseResolve.call(C, promise).then(capability.resolve, reject); |
| }); |
| }); |
| if (result.error) reject(result.value); |
| return capability.promise; |
| } |
| }); |
| |
| },{"../internals/a-function":8,"../internals/an-instance":12,"../internals/check-correctness-of-iteration":28,"../internals/classof-raw":29,"../internals/export":49,"../internals/global":62,"../internals/host-report-errors":66,"../internals/internal-state":72,"../internals/is-forced":75,"../internals/is-object":77,"../internals/is-pure":78,"../internals/iterate":80,"../internals/microtask":87,"../internals/new-promise-capability":91,"../internals/path":112,"../internals/perform":113,"../internals/promise-resolve":114,"../internals/redefine-all":116,"../internals/set-species":124,"../internals/set-to-string-tag":125,"../internals/species-constructor":129,"../internals/task":134,"../internals/user-agent":148,"../internals/well-known-symbol":150}],255:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var getBuiltIn = require('../internals/get-built-in'); |
| var aFunction = require('../internals/a-function'); |
| var anObject = require('../internals/an-object'); |
| var fails = require('../internals/fails'); |
| |
| var nativeApply = getBuiltIn('Reflect', 'apply'); |
| var functionApply = Function.apply; |
| |
| // MS Edge argumentsList argument is optional |
| var OPTIONAL_ARGUMENTS_LIST = !fails(function () { |
| nativeApply(function () { /* empty */ }); |
| }); |
| |
| // `Reflect.apply` method |
| // https://tc39.github.io/ecma262/#sec-reflect.apply |
| $({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, { |
| apply: function apply(target, thisArgument, argumentsList) { |
| aFunction(target); |
| anObject(argumentsList); |
| return nativeApply |
| ? nativeApply(target, thisArgument, argumentsList) |
| : functionApply.call(target, thisArgument, argumentsList); |
| } |
| }); |
| |
| },{"../internals/a-function":8,"../internals/an-object":13,"../internals/export":49,"../internals/fails":50,"../internals/get-built-in":59}],256:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var getBuiltIn = require('../internals/get-built-in'); |
| var aFunction = require('../internals/a-function'); |
| var anObject = require('../internals/an-object'); |
| var isObject = require('../internals/is-object'); |
| var create = require('../internals/object-create'); |
| var bind = require('../internals/function-bind'); |
| var fails = require('../internals/fails'); |
| |
| var nativeConstruct = getBuiltIn('Reflect', 'construct'); |
| |
| // `Reflect.construct` method |
| // https://tc39.github.io/ecma262/#sec-reflect.construct |
| // MS Edge supports only 2 arguments and argumentsList argument is optional |
| // FF Nightly sets third argument as `new.target`, but does not create `this` from it |
| var NEW_TARGET_BUG = fails(function () { |
| function F() { /* empty */ } |
| return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F); |
| }); |
| var ARGS_BUG = !fails(function () { |
| nativeConstruct(function () { /* empty */ }); |
| }); |
| var FORCED = NEW_TARGET_BUG || ARGS_BUG; |
| |
| $({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, { |
| construct: function construct(Target, args /* , newTarget */) { |
| aFunction(Target); |
| anObject(args); |
| var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]); |
| if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget); |
| if (Target == newTarget) { |
| // w/o altered newTarget, optimization for 0-4 arguments |
| switch (args.length) { |
| case 0: return new Target(); |
| case 1: return new Target(args[0]); |
| case 2: return new Target(args[0], args[1]); |
| case 3: return new Target(args[0], args[1], args[2]); |
| case 4: return new Target(args[0], args[1], args[2], args[3]); |
| } |
| // w/o altered newTarget, lot of arguments case |
| var $args = [null]; |
| $args.push.apply($args, args); |
| return new (bind.apply(Target, $args))(); |
| } |
| // with altered newTarget, not support built-in constructors |
| var proto = newTarget.prototype; |
| var instance = create(isObject(proto) ? proto : Object.prototype); |
| var result = Function.apply.call(Target, instance, args); |
| return isObject(result) ? result : instance; |
| } |
| }); |
| |
| },{"../internals/a-function":8,"../internals/an-object":13,"../internals/export":49,"../internals/fails":50,"../internals/function-bind":57,"../internals/get-built-in":59,"../internals/is-object":77,"../internals/object-create":95}],257:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var anObject = require('../internals/an-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var fails = require('../internals/fails'); |
| |
| // MS Edge has broken Reflect.defineProperty - throwing instead of returning false |
| var ERROR_INSTEAD_OF_FALSE = fails(function () { |
| // eslint-disable-next-line no-undef |
| Reflect.defineProperty(definePropertyModule.f({}, 1, { value: 1 }), 1, { value: 2 }); |
| }); |
| |
| // `Reflect.defineProperty` method |
| // https://tc39.github.io/ecma262/#sec-reflect.defineproperty |
| $({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !DESCRIPTORS }, { |
| defineProperty: function defineProperty(target, propertyKey, attributes) { |
| anObject(target); |
| var key = toPrimitive(propertyKey, true); |
| anObject(attributes); |
| try { |
| definePropertyModule.f(target, key, attributes); |
| return true; |
| } catch (error) { |
| return false; |
| } |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/descriptors":45,"../internals/export":49,"../internals/fails":50,"../internals/object-define-property":97,"../internals/to-primitive":143}],258:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var anObject = require('../internals/an-object'); |
| var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; |
| |
| // `Reflect.deleteProperty` method |
| // https://tc39.github.io/ecma262/#sec-reflect.deleteproperty |
| $({ target: 'Reflect', stat: true }, { |
| deleteProperty: function deleteProperty(target, propertyKey) { |
| var descriptor = getOwnPropertyDescriptor(anObject(target), propertyKey); |
| return descriptor && !descriptor.configurable ? false : delete target[propertyKey]; |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/export":49,"../internals/object-get-own-property-descriptor":98}],259:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var anObject = require('../internals/an-object'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| |
| // `Reflect.getOwnPropertyDescriptor` method |
| // https://tc39.github.io/ecma262/#sec-reflect.getownpropertydescriptor |
| $({ target: 'Reflect', stat: true, sham: !DESCRIPTORS }, { |
| getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) { |
| return getOwnPropertyDescriptorModule.f(anObject(target), propertyKey); |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/descriptors":45,"../internals/export":49,"../internals/object-get-own-property-descriptor":98}],260:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var anObject = require('../internals/an-object'); |
| var objectGetPrototypeOf = require('../internals/object-get-prototype-of'); |
| var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter'); |
| |
| // `Reflect.getPrototypeOf` method |
| // https://tc39.github.io/ecma262/#sec-reflect.getprototypeof |
| $({ target: 'Reflect', stat: true, sham: !CORRECT_PROTOTYPE_GETTER }, { |
| getPrototypeOf: function getPrototypeOf(target) { |
| return objectGetPrototypeOf(anObject(target)); |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/correct-prototype-getter":36,"../internals/export":49,"../internals/object-get-prototype-of":102}],261:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var isObject = require('../internals/is-object'); |
| var anObject = require('../internals/an-object'); |
| var has = require('../internals/has'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| |
| // `Reflect.get` method |
| // https://tc39.github.io/ecma262/#sec-reflect.get |
| function get(target, propertyKey /* , receiver */) { |
| var receiver = arguments.length < 3 ? target : arguments[2]; |
| var descriptor, prototype; |
| if (anObject(target) === receiver) return target[propertyKey]; |
| if (descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey)) return has(descriptor, 'value') |
| ? descriptor.value |
| : descriptor.get === undefined |
| ? undefined |
| : descriptor.get.call(receiver); |
| if (isObject(prototype = getPrototypeOf(target))) return get(prototype, propertyKey, receiver); |
| } |
| |
| $({ target: 'Reflect', stat: true }, { |
| get: get |
| }); |
| |
| },{"../internals/an-object":13,"../internals/export":49,"../internals/has":63,"../internals/is-object":77,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-prototype-of":102}],262:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| |
| // `Reflect.has` method |
| // https://tc39.github.io/ecma262/#sec-reflect.has |
| $({ target: 'Reflect', stat: true }, { |
| has: function has(target, propertyKey) { |
| return propertyKey in target; |
| } |
| }); |
| |
| },{"../internals/export":49}],263:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var anObject = require('../internals/an-object'); |
| |
| var objectIsExtensible = Object.isExtensible; |
| |
| // `Reflect.isExtensible` method |
| // https://tc39.github.io/ecma262/#sec-reflect.isextensible |
| $({ target: 'Reflect', stat: true }, { |
| isExtensible: function isExtensible(target) { |
| anObject(target); |
| return objectIsExtensible ? objectIsExtensible(target) : true; |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/export":49}],264:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var ownKeys = require('../internals/own-keys'); |
| |
| // `Reflect.ownKeys` method |
| // https://tc39.github.io/ecma262/#sec-reflect.ownkeys |
| $({ target: 'Reflect', stat: true }, { |
| ownKeys: ownKeys |
| }); |
| |
| },{"../internals/export":49,"../internals/own-keys":109}],265:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var getBuiltIn = require('../internals/get-built-in'); |
| var anObject = require('../internals/an-object'); |
| var FREEZING = require('../internals/freezing'); |
| |
| // `Reflect.preventExtensions` method |
| // https://tc39.github.io/ecma262/#sec-reflect.preventextensions |
| $({ target: 'Reflect', stat: true, sham: !FREEZING }, { |
| preventExtensions: function preventExtensions(target) { |
| anObject(target); |
| try { |
| var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions'); |
| if (objectPreventExtensions) objectPreventExtensions(target); |
| return true; |
| } catch (error) { |
| return false; |
| } |
| } |
| }); |
| |
| },{"../internals/an-object":13,"../internals/export":49,"../internals/freezing":56,"../internals/get-built-in":59}],266:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var anObject = require('../internals/an-object'); |
| var aPossiblePrototype = require('../internals/a-possible-prototype'); |
| var objectSetPrototypeOf = require('../internals/object-set-prototype-of'); |
| |
| // `Reflect.setPrototypeOf` method |
| // https://tc39.github.io/ecma262/#sec-reflect.setprototypeof |
| if (objectSetPrototypeOf) $({ target: 'Reflect', stat: true }, { |
| setPrototypeOf: function setPrototypeOf(target, proto) { |
| anObject(target); |
| aPossiblePrototype(proto); |
| try { |
| objectSetPrototypeOf(target, proto); |
| return true; |
| } catch (error) { |
| return false; |
| } |
| } |
| }); |
| |
| },{"../internals/a-possible-prototype":9,"../internals/an-object":13,"../internals/export":49,"../internals/object-set-prototype-of":106}],267:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var anObject = require('../internals/an-object'); |
| var isObject = require('../internals/is-object'); |
| var has = require('../internals/has'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| var getPrototypeOf = require('../internals/object-get-prototype-of'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| |
| // `Reflect.set` method |
| // https://tc39.github.io/ecma262/#sec-reflect.set |
| function set(target, propertyKey, V /* , receiver */) { |
| var receiver = arguments.length < 4 ? target : arguments[3]; |
| var ownDescriptor = getOwnPropertyDescriptorModule.f(anObject(target), propertyKey); |
| var existingDescriptor, prototype; |
| if (!ownDescriptor) { |
| if (isObject(prototype = getPrototypeOf(target))) { |
| return set(prototype, propertyKey, V, receiver); |
| } |
| ownDescriptor = createPropertyDescriptor(0); |
| } |
| if (has(ownDescriptor, 'value')) { |
| if (ownDescriptor.writable === false || !isObject(receiver)) return false; |
| if (existingDescriptor = getOwnPropertyDescriptorModule.f(receiver, propertyKey)) { |
| if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false; |
| existingDescriptor.value = V; |
| definePropertyModule.f(receiver, propertyKey, existingDescriptor); |
| } else definePropertyModule.f(receiver, propertyKey, createPropertyDescriptor(0, V)); |
| return true; |
| } |
| return ownDescriptor.set === undefined ? false : (ownDescriptor.set.call(receiver, V), true); |
| } |
| |
| $({ target: 'Reflect', stat: true }, { |
| set: set |
| }); |
| |
| },{"../internals/an-object":13,"../internals/create-property-descriptor":39,"../internals/export":49,"../internals/has":63,"../internals/is-object":77,"../internals/object-define-property":97,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-prototype-of":102}],268:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var global = require('../internals/global'); |
| var isForced = require('../internals/is-forced'); |
| var inheritIfRequired = require('../internals/inherit-if-required'); |
| var defineProperty = require('../internals/object-define-property').f; |
| var getOwnPropertyNames = require('../internals/object-get-own-property-names').f; |
| var isRegExp = require('../internals/is-regexp'); |
| var getFlags = require('../internals/regexp-flags'); |
| var redefine = require('../internals/redefine'); |
| var fails = require('../internals/fails'); |
| var setSpecies = require('../internals/set-species'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var MATCH = wellKnownSymbol('match'); |
| var NativeRegExp = global.RegExp; |
| var RegExpPrototype = NativeRegExp.prototype; |
| var re1 = /a/g; |
| var re2 = /a/g; |
| |
| // "new" should create a new object, old webkit bug |
| var CORRECT_NEW = new NativeRegExp(re1) !== re1; |
| |
| var FORCED = DESCRIPTORS && isForced('RegExp', (!CORRECT_NEW || fails(function () { |
| re2[MATCH] = false; |
| // RegExp constructor can alter flags and IsRegExp works correct with @@match |
| return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i'; |
| }))); |
| |
| // `RegExp` constructor |
| // https://tc39.github.io/ecma262/#sec-regexp-constructor |
| if (FORCED) { |
| var RegExpWrapper = function RegExp(pattern, flags) { |
| var thisIsRegExp = this instanceof RegExpWrapper; |
| var patternIsRegExp = isRegExp(pattern); |
| var flagsAreUndefined = flags === undefined; |
| return !thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined ? pattern |
| : inheritIfRequired(CORRECT_NEW |
| ? new NativeRegExp(patternIsRegExp && !flagsAreUndefined ? pattern.source : pattern, flags) |
| : NativeRegExp((patternIsRegExp = pattern instanceof RegExpWrapper) |
| ? pattern.source |
| : pattern, patternIsRegExp && flagsAreUndefined ? getFlags.call(pattern) : flags) |
| , thisIsRegExp ? this : RegExpPrototype, RegExpWrapper); |
| }; |
| var proxy = function (key) { |
| key in RegExpWrapper || defineProperty(RegExpWrapper, key, { |
| configurable: true, |
| get: function () { return NativeRegExp[key]; }, |
| set: function (it) { NativeRegExp[key] = it; } |
| }); |
| }; |
| var keys = getOwnPropertyNames(NativeRegExp); |
| var index = 0; |
| while (keys.length > index) proxy(keys[index++]); |
| RegExpPrototype.constructor = RegExpWrapper; |
| RegExpWrapper.prototype = RegExpPrototype; |
| redefine(global, 'RegExp', RegExpWrapper); |
| } |
| |
| // https://tc39.github.io/ecma262/#sec-get-regexp-@@species |
| setSpecies('RegExp'); |
| |
| },{"../internals/descriptors":45,"../internals/fails":50,"../internals/global":62,"../internals/inherit-if-required":70,"../internals/is-forced":75,"../internals/is-regexp":79,"../internals/object-define-property":97,"../internals/object-get-own-property-names":100,"../internals/redefine":117,"../internals/regexp-flags":120,"../internals/set-species":124,"../internals/well-known-symbol":150}],269:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var exec = require('../internals/regexp-exec'); |
| |
| $({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, { |
| exec: exec |
| }); |
| |
| },{"../internals/export":49,"../internals/regexp-exec":119}],270:[function(require,module,exports){ |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var objectDefinePropertyModule = require('../internals/object-define-property'); |
| var regExpFlags = require('../internals/regexp-flags'); |
| |
| // `RegExp.prototype.flags` getter |
| // https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags |
| if (DESCRIPTORS && /./g.flags != 'g') { |
| objectDefinePropertyModule.f(RegExp.prototype, 'flags', { |
| configurable: true, |
| get: regExpFlags |
| }); |
| } |
| |
| },{"../internals/descriptors":45,"../internals/object-define-property":97,"../internals/regexp-flags":120}],271:[function(require,module,exports){ |
| 'use strict'; |
| var redefine = require('../internals/redefine'); |
| var anObject = require('../internals/an-object'); |
| var fails = require('../internals/fails'); |
| var flags = require('../internals/regexp-flags'); |
| |
| var TO_STRING = 'toString'; |
| var RegExpPrototype = RegExp.prototype; |
| var nativeToString = RegExpPrototype[TO_STRING]; |
| |
| var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; }); |
| // FF44- RegExp#toString has a wrong name |
| var INCORRECT_NAME = nativeToString.name != TO_STRING; |
| |
| // `RegExp.prototype.toString` method |
| // https://tc39.github.io/ecma262/#sec-regexp.prototype.tostring |
| if (NOT_GENERIC || INCORRECT_NAME) { |
| redefine(RegExp.prototype, TO_STRING, function toString() { |
| var R = anObject(this); |
| var p = String(R.source); |
| var rf = R.flags; |
| var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? flags.call(R) : rf); |
| return '/' + p + '/' + f; |
| }, { unsafe: true }); |
| } |
| |
| },{"../internals/an-object":13,"../internals/fails":50,"../internals/redefine":117,"../internals/regexp-flags":120}],272:[function(require,module,exports){ |
| 'use strict'; |
| var collection = require('../internals/collection'); |
| var collectionStrong = require('../internals/collection-strong'); |
| |
| // `Set` constructor |
| // https://tc39.github.io/ecma262/#sec-set-objects |
| module.exports = collection('Set', function (get) { |
| return function Set() { return get(this, arguments.length ? arguments[0] : undefined); }; |
| }, collectionStrong); |
| |
| },{"../internals/collection":33,"../internals/collection-strong":31}],273:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.anchor` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.anchor |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('anchor') }, { |
| anchor: function anchor(name) { |
| return createHTML(this, 'a', 'name', name); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],274:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.big` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.big |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('big') }, { |
| big: function big() { |
| return createHTML(this, 'big', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],275:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.blink` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.blink |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('blink') }, { |
| blink: function blink() { |
| return createHTML(this, 'blink', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],276:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.bold` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.bold |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('bold') }, { |
| bold: function bold() { |
| return createHTML(this, 'b', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],277:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var codeAt = require('../internals/string-multibyte').codeAt; |
| |
| // `String.prototype.codePointAt` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat |
| $({ target: 'String', proto: true }, { |
| codePointAt: function codePointAt(pos) { |
| return codeAt(this, pos); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/string-multibyte":130}],278:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var toLength = require('../internals/to-length'); |
| var notARegExp = require('../internals/not-a-regexp'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic'); |
| |
| var nativeEndsWith = ''.endsWith; |
| var min = Math.min; |
| |
| // `String.prototype.endsWith` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.endswith |
| $({ target: 'String', proto: true, forced: !correctIsRegExpLogic('endsWith') }, { |
| endsWith: function endsWith(searchString /* , endPosition = @length */) { |
| var that = String(requireObjectCoercible(this)); |
| notARegExp(searchString); |
| var endPosition = arguments.length > 1 ? arguments[1] : undefined; |
| var len = toLength(that.length); |
| var end = endPosition === undefined ? len : min(toLength(endPosition), len); |
| var search = String(searchString); |
| return nativeEndsWith |
| ? nativeEndsWith.call(that, search, end) |
| : that.slice(end - search.length, end) === search; |
| } |
| }); |
| |
| },{"../internals/correct-is-regexp-logic":35,"../internals/export":49,"../internals/not-a-regexp":92,"../internals/require-object-coercible":121,"../internals/to-length":140}],279:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.fixed` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.fixed |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fixed') }, { |
| fixed: function fixed() { |
| return createHTML(this, 'tt', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],280:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.fontcolor` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.fontcolor |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontcolor') }, { |
| fontcolor: function fontcolor(color) { |
| return createHTML(this, 'font', 'color', color); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],281:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.fontsize` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.fontsize |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontsize') }, { |
| fontsize: function fontsize(size) { |
| return createHTML(this, 'font', 'size', size); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],282:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| |
| var fromCharCode = String.fromCharCode; |
| var nativeFromCodePoint = String.fromCodePoint; |
| |
| // length should be 1, old FF problem |
| var INCORRECT_LENGTH = !!nativeFromCodePoint && nativeFromCodePoint.length != 1; |
| |
| // `String.fromCodePoint` method |
| // https://tc39.github.io/ecma262/#sec-string.fromcodepoint |
| $({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, { |
| fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars |
| var elements = []; |
| var length = arguments.length; |
| var i = 0; |
| var code; |
| while (length > i) { |
| code = +arguments[i++]; |
| if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError(code + ' is not a valid code point'); |
| elements.push(code < 0x10000 |
| ? fromCharCode(code) |
| : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00) |
| ); |
| } return elements.join(''); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/to-absolute-index":136}],283:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var notARegExp = require('../internals/not-a-regexp'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic'); |
| |
| // `String.prototype.includes` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.includes |
| $({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, { |
| includes: function includes(searchString /* , position = 0 */) { |
| return !!~String(requireObjectCoercible(this)) |
| .indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/correct-is-regexp-logic":35,"../internals/export":49,"../internals/not-a-regexp":92,"../internals/require-object-coercible":121}],284:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.italics` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.italics |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('italics') }, { |
| italics: function italics() { |
| return createHTML(this, 'i', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],285:[function(require,module,exports){ |
| 'use strict'; |
| var charAt = require('../internals/string-multibyte').charAt; |
| var InternalStateModule = require('../internals/internal-state'); |
| var defineIterator = require('../internals/define-iterator'); |
| |
| var STRING_ITERATOR = 'String Iterator'; |
| var setInternalState = InternalStateModule.set; |
| var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); |
| |
| // `String.prototype[@@iterator]` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator |
| defineIterator(String, 'String', function (iterated) { |
| setInternalState(this, { |
| type: STRING_ITERATOR, |
| string: String(iterated), |
| index: 0 |
| }); |
| // `%StringIteratorPrototype%.next` method |
| // https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next |
| }, function next() { |
| var state = getInternalState(this); |
| var string = state.string; |
| var index = state.index; |
| var point; |
| if (index >= string.length) return { value: undefined, done: true }; |
| point = charAt(string, index); |
| state.index += point.length; |
| return { value: point, done: false }; |
| }); |
| |
| },{"../internals/define-iterator":43,"../internals/internal-state":72,"../internals/string-multibyte":130}],286:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.link` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.link |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, { |
| link: function link(url) { |
| return createHTML(this, 'a', 'href', url); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],287:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createIteratorConstructor = require('../internals/create-iterator-constructor'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var toLength = require('../internals/to-length'); |
| var aFunction = require('../internals/a-function'); |
| var anObject = require('../internals/an-object'); |
| var classof = require('../internals/classof'); |
| var getFlags = require('../internals/regexp-flags'); |
| var hide = require('../internals/hide'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| var advanceStringIndex = require('../internals/advance-string-index'); |
| var InternalStateModule = require('../internals/internal-state'); |
| var IS_PURE = require('../internals/is-pure'); |
| |
| var MATCH_ALL = wellKnownSymbol('matchAll'); |
| var REGEXP_STRING = 'RegExp String'; |
| var REGEXP_STRING_ITERATOR = REGEXP_STRING + ' Iterator'; |
| var setInternalState = InternalStateModule.set; |
| var getInternalState = InternalStateModule.getterFor(REGEXP_STRING_ITERATOR); |
| var RegExpPrototype = RegExp.prototype; |
| var regExpBuiltinExec = RegExpPrototype.exec; |
| |
| var regExpExec = function (R, S) { |
| var exec = R.exec; |
| var result; |
| if (typeof exec == 'function') { |
| result = exec.call(R, S); |
| if (typeof result != 'object') throw TypeError('Incorrect exec result'); |
| return result; |
| } return regExpBuiltinExec.call(R, S); |
| }; |
| |
| // eslint-disable-next-line max-len |
| var $RegExpStringIterator = createIteratorConstructor(function RegExpStringIterator(regexp, string, global, fullUnicode) { |
| setInternalState(this, { |
| type: REGEXP_STRING_ITERATOR, |
| regexp: regexp, |
| string: string, |
| global: global, |
| unicode: fullUnicode, |
| done: false |
| }); |
| }, REGEXP_STRING, function next() { |
| var state = getInternalState(this); |
| if (state.done) return { value: undefined, done: true }; |
| var R = state.regexp; |
| var S = state.string; |
| var match = regExpExec(R, S); |
| if (match === null) return { value: undefined, done: state.done = true }; |
| if (state.global) { |
| if (String(match[0]) == '') R.lastIndex = advanceStringIndex(S, toLength(R.lastIndex), state.unicode); |
| return { value: match, done: false }; |
| } |
| state.done = true; |
| return { value: match, done: false }; |
| }); |
| |
| var $matchAll = function (string) { |
| var R = anObject(this); |
| var S = String(string); |
| var C, flagsValue, flags, matcher, global, fullUnicode; |
| C = speciesConstructor(R, RegExp); |
| flagsValue = R.flags; |
| if (flagsValue === undefined && R instanceof RegExp && !('flags' in RegExpPrototype)) { |
| flagsValue = getFlags.call(R); |
| } |
| flags = flagsValue === undefined ? '' : String(flagsValue); |
| matcher = new C(C === RegExp ? R.source : R, flags); |
| global = !!~flags.indexOf('g'); |
| fullUnicode = !!~flags.indexOf('u'); |
| matcher.lastIndex = toLength(R.lastIndex); |
| return new $RegExpStringIterator(matcher, S, global, fullUnicode); |
| }; |
| |
| // `String.prototype.matchAll` method |
| // https://github.com/tc39/proposal-string-matchall |
| $({ target: 'String', proto: true }, { |
| matchAll: function matchAll(regexp) { |
| var O = requireObjectCoercible(this); |
| var S, matcher, rx; |
| if (regexp != null) { |
| matcher = regexp[MATCH_ALL]; |
| if (matcher === undefined && IS_PURE && classof(regexp) == 'RegExp') matcher = $matchAll; |
| if (matcher != null) return aFunction(matcher).call(regexp, O); |
| } |
| S = String(O); |
| rx = new RegExp(regexp, 'g'); |
| return IS_PURE ? $matchAll.call(rx, S) : rx[MATCH_ALL](S); |
| } |
| }); |
| |
| IS_PURE || MATCH_ALL in RegExpPrototype || hide(RegExpPrototype, MATCH_ALL, $matchAll); |
| |
| },{"../internals/a-function":8,"../internals/advance-string-index":11,"../internals/an-object":13,"../internals/classof":30,"../internals/create-iterator-constructor":38,"../internals/export":49,"../internals/hide":65,"../internals/internal-state":72,"../internals/is-pure":78,"../internals/regexp-flags":120,"../internals/require-object-coercible":121,"../internals/species-constructor":129,"../internals/to-length":140,"../internals/well-known-symbol":150}],288:[function(require,module,exports){ |
| 'use strict'; |
| var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic'); |
| var anObject = require('../internals/an-object'); |
| var toLength = require('../internals/to-length'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var advanceStringIndex = require('../internals/advance-string-index'); |
| var regExpExec = require('../internals/regexp-exec-abstract'); |
| |
| // @@match logic |
| fixRegExpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) { |
| return [ |
| // `String.prototype.match` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.match |
| function match(regexp) { |
| var O = requireObjectCoercible(this); |
| var matcher = regexp == undefined ? undefined : regexp[MATCH]; |
| return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); |
| }, |
| // `RegExp.prototype[@@match]` method |
| // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match |
| function (regexp) { |
| var res = maybeCallNative(nativeMatch, regexp, this); |
| if (res.done) return res.value; |
| |
| var rx = anObject(regexp); |
| var S = String(this); |
| |
| if (!rx.global) return regExpExec(rx, S); |
| |
| var fullUnicode = rx.unicode; |
| rx.lastIndex = 0; |
| var A = []; |
| var n = 0; |
| var result; |
| while ((result = regExpExec(rx, S)) !== null) { |
| var matchStr = String(result[0]); |
| A[n] = matchStr; |
| if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); |
| n++; |
| } |
| return n === 0 ? null : A; |
| } |
| ]; |
| }); |
| |
| },{"../internals/advance-string-index":11,"../internals/an-object":13,"../internals/fix-regexp-well-known-symbol-logic":51,"../internals/regexp-exec-abstract":118,"../internals/require-object-coercible":121,"../internals/to-length":140}],289:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $padEnd = require('../internals/string-pad').end; |
| var WEBKIT_BUG = require('../internals/webkit-string-pad-bug'); |
| |
| // `String.prototype.padEnd` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.padend |
| $({ target: 'String', proto: true, forced: WEBKIT_BUG }, { |
| padEnd: function padEnd(maxLength /* , fillString = ' ' */) { |
| return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/string-pad":131,"../internals/webkit-string-pad-bug":149}],290:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $padStart = require('../internals/string-pad').start; |
| var WEBKIT_BUG = require('../internals/webkit-string-pad-bug'); |
| |
| // `String.prototype.padStart` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.padstart |
| $({ target: 'String', proto: true, forced: WEBKIT_BUG }, { |
| padStart: function padStart(maxLength /* , fillString = ' ' */) { |
| return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/string-pad":131,"../internals/webkit-string-pad-bug":149}],291:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var toLength = require('../internals/to-length'); |
| |
| // `String.raw` method |
| // https://tc39.github.io/ecma262/#sec-string.raw |
| $({ target: 'String', stat: true }, { |
| raw: function raw(template) { |
| var rawTemplate = toIndexedObject(template.raw); |
| var literalSegments = toLength(rawTemplate.length); |
| var argumentsLength = arguments.length; |
| var elements = []; |
| var i = 0; |
| while (literalSegments > i) { |
| elements.push(String(rawTemplate[i++])); |
| if (i < argumentsLength) elements.push(String(arguments[i])); |
| } return elements.join(''); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/to-indexed-object":138,"../internals/to-length":140}],292:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var repeat = require('../internals/string-repeat'); |
| |
| // `String.prototype.repeat` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.repeat |
| $({ target: 'String', proto: true }, { |
| repeat: repeat |
| }); |
| |
| },{"../internals/export":49,"../internals/string-repeat":132}],293:[function(require,module,exports){ |
| 'use strict'; |
| var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic'); |
| var anObject = require('../internals/an-object'); |
| var toObject = require('../internals/to-object'); |
| var toLength = require('../internals/to-length'); |
| var toInteger = require('../internals/to-integer'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var advanceStringIndex = require('../internals/advance-string-index'); |
| var regExpExec = require('../internals/regexp-exec-abstract'); |
| |
| var max = Math.max; |
| var min = Math.min; |
| var floor = Math.floor; |
| var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d\d?|<[^>]*>)/g; |
| var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d\d?)/g; |
| |
| var maybeToString = function (it) { |
| return it === undefined ? it : String(it); |
| }; |
| |
| // @@replace logic |
| fixRegExpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative) { |
| return [ |
| // `String.prototype.replace` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.replace |
| function replace(searchValue, replaceValue) { |
| var O = requireObjectCoercible(this); |
| var replacer = searchValue == undefined ? undefined : searchValue[REPLACE]; |
| return replacer !== undefined |
| ? replacer.call(searchValue, O, replaceValue) |
| : nativeReplace.call(String(O), searchValue, replaceValue); |
| }, |
| // `RegExp.prototype[@@replace]` method |
| // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace |
| function (regexp, replaceValue) { |
| var res = maybeCallNative(nativeReplace, regexp, this, replaceValue); |
| if (res.done) return res.value; |
| |
| var rx = anObject(regexp); |
| var S = String(this); |
| |
| var functionalReplace = typeof replaceValue === 'function'; |
| if (!functionalReplace) replaceValue = String(replaceValue); |
| |
| var global = rx.global; |
| if (global) { |
| var fullUnicode = rx.unicode; |
| rx.lastIndex = 0; |
| } |
| var results = []; |
| while (true) { |
| var result = regExpExec(rx, S); |
| if (result === null) break; |
| |
| results.push(result); |
| if (!global) break; |
| |
| var matchStr = String(result[0]); |
| if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); |
| } |
| |
| var accumulatedResult = ''; |
| var nextSourcePosition = 0; |
| for (var i = 0; i < results.length; i++) { |
| result = results[i]; |
| |
| var matched = String(result[0]); |
| var position = max(min(toInteger(result.index), S.length), 0); |
| var captures = []; |
| // NOTE: This is equivalent to |
| // captures = result.slice(1).map(maybeToString) |
| // but for some reason `nativeSlice.call(result, 1, result.length)` (called in |
| // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and |
| // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. |
| for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); |
| var namedCaptures = result.groups; |
| if (functionalReplace) { |
| var replacerArgs = [matched].concat(captures, position, S); |
| if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); |
| var replacement = String(replaceValue.apply(undefined, replacerArgs)); |
| } else { |
| replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); |
| } |
| if (position >= nextSourcePosition) { |
| accumulatedResult += S.slice(nextSourcePosition, position) + replacement; |
| nextSourcePosition = position + matched.length; |
| } |
| } |
| return accumulatedResult + S.slice(nextSourcePosition); |
| } |
| ]; |
| |
| // https://tc39.github.io/ecma262/#sec-getsubstitution |
| function getSubstitution(matched, str, position, captures, namedCaptures, replacement) { |
| var tailPos = position + matched.length; |
| var m = captures.length; |
| var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; |
| if (namedCaptures !== undefined) { |
| namedCaptures = toObject(namedCaptures); |
| symbols = SUBSTITUTION_SYMBOLS; |
| } |
| return nativeReplace.call(replacement, symbols, function (match, ch) { |
| var capture; |
| switch (ch.charAt(0)) { |
| case '$': return '$'; |
| case '&': return matched; |
| case '`': return str.slice(0, position); |
| case "'": return str.slice(tailPos); |
| case '<': |
| capture = namedCaptures[ch.slice(1, -1)]; |
| break; |
| default: // \d\d? |
| var n = +ch; |
| if (n === 0) return match; |
| if (n > m) { |
| var f = floor(n / 10); |
| if (f === 0) return match; |
| if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); |
| return match; |
| } |
| capture = captures[n - 1]; |
| } |
| return capture === undefined ? '' : capture; |
| }); |
| } |
| }); |
| |
| },{"../internals/advance-string-index":11,"../internals/an-object":13,"../internals/fix-regexp-well-known-symbol-logic":51,"../internals/regexp-exec-abstract":118,"../internals/require-object-coercible":121,"../internals/to-integer":139,"../internals/to-length":140,"../internals/to-object":141}],294:[function(require,module,exports){ |
| 'use strict'; |
| var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic'); |
| var anObject = require('../internals/an-object'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var sameValue = require('../internals/same-value'); |
| var regExpExec = require('../internals/regexp-exec-abstract'); |
| |
| // @@search logic |
| fixRegExpWellKnownSymbolLogic('search', 1, function (SEARCH, nativeSearch, maybeCallNative) { |
| return [ |
| // `String.prototype.search` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.search |
| function search(regexp) { |
| var O = requireObjectCoercible(this); |
| var searcher = regexp == undefined ? undefined : regexp[SEARCH]; |
| return searcher !== undefined ? searcher.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O)); |
| }, |
| // `RegExp.prototype[@@search]` method |
| // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search |
| function (regexp) { |
| var res = maybeCallNative(nativeSearch, regexp, this); |
| if (res.done) return res.value; |
| |
| var rx = anObject(regexp); |
| var S = String(this); |
| |
| var previousLastIndex = rx.lastIndex; |
| if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0; |
| var result = regExpExec(rx, S); |
| if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; |
| return result === null ? -1 : result.index; |
| } |
| ]; |
| }); |
| |
| },{"../internals/an-object":13,"../internals/fix-regexp-well-known-symbol-logic":51,"../internals/regexp-exec-abstract":118,"../internals/require-object-coercible":121,"../internals/same-value":122}],295:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.small` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.small |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('small') }, { |
| small: function small() { |
| return createHTML(this, 'small', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],296:[function(require,module,exports){ |
| 'use strict'; |
| var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic'); |
| var isRegExp = require('../internals/is-regexp'); |
| var anObject = require('../internals/an-object'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| var advanceStringIndex = require('../internals/advance-string-index'); |
| var toLength = require('../internals/to-length'); |
| var callRegExpExec = require('../internals/regexp-exec-abstract'); |
| var regexpExec = require('../internals/regexp-exec'); |
| var fails = require('../internals/fails'); |
| |
| var arrayPush = [].push; |
| var min = Math.min; |
| var MAX_UINT32 = 0xFFFFFFFF; |
| |
| // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError |
| var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); }); |
| |
| // @@split logic |
| fixRegExpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) { |
| var internalSplit; |
| if ( |
| 'abbc'.split(/(b)*/)[1] == 'c' || |
| 'test'.split(/(?:)/, -1).length != 4 || |
| 'ab'.split(/(?:ab)*/).length != 2 || |
| '.'.split(/(.?)(.?)/).length != 4 || |
| '.'.split(/()()/).length > 1 || |
| ''.split(/.?/).length |
| ) { |
| // based on es5-shim implementation, need to rework it |
| internalSplit = function (separator, limit) { |
| var string = String(requireObjectCoercible(this)); |
| var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; |
| if (lim === 0) return []; |
| if (separator === undefined) return [string]; |
| // If `separator` is not a regex, use native split |
| if (!isRegExp(separator)) { |
| return nativeSplit.call(string, separator, lim); |
| } |
| var output = []; |
| var flags = (separator.ignoreCase ? 'i' : '') + |
| (separator.multiline ? 'm' : '') + |
| (separator.unicode ? 'u' : '') + |
| (separator.sticky ? 'y' : ''); |
| var lastLastIndex = 0; |
| // Make `global` and avoid `lastIndex` issues by working with a copy |
| var separatorCopy = new RegExp(separator.source, flags + 'g'); |
| var match, lastIndex, lastLength; |
| while (match = regexpExec.call(separatorCopy, string)) { |
| lastIndex = separatorCopy.lastIndex; |
| if (lastIndex > lastLastIndex) { |
| output.push(string.slice(lastLastIndex, match.index)); |
| if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1)); |
| lastLength = match[0].length; |
| lastLastIndex = lastIndex; |
| if (output.length >= lim) break; |
| } |
| if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop |
| } |
| if (lastLastIndex === string.length) { |
| if (lastLength || !separatorCopy.test('')) output.push(''); |
| } else output.push(string.slice(lastLastIndex)); |
| return output.length > lim ? output.slice(0, lim) : output; |
| }; |
| // Chakra, V8 |
| } else if ('0'.split(undefined, 0).length) { |
| internalSplit = function (separator, limit) { |
| return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit); |
| }; |
| } else internalSplit = nativeSplit; |
| |
| return [ |
| // `String.prototype.split` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.split |
| function split(separator, limit) { |
| var O = requireObjectCoercible(this); |
| var splitter = separator == undefined ? undefined : separator[SPLIT]; |
| return splitter !== undefined |
| ? splitter.call(separator, O, limit) |
| : internalSplit.call(String(O), separator, limit); |
| }, |
| // `RegExp.prototype[@@split]` method |
| // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split |
| // |
| // NOTE: This cannot be properly polyfilled in engines that don't support |
| // the 'y' flag. |
| function (regexp, limit) { |
| var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== nativeSplit); |
| if (res.done) return res.value; |
| |
| var rx = anObject(regexp); |
| var S = String(this); |
| var C = speciesConstructor(rx, RegExp); |
| |
| var unicodeMatching = rx.unicode; |
| var flags = (rx.ignoreCase ? 'i' : '') + |
| (rx.multiline ? 'm' : '') + |
| (rx.unicode ? 'u' : '') + |
| (SUPPORTS_Y ? 'y' : 'g'); |
| |
| // ^(? + rx + ) is needed, in combination with some S slicing, to |
| // simulate the 'y' flag. |
| var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags); |
| var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; |
| if (lim === 0) return []; |
| if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : []; |
| var p = 0; |
| var q = 0; |
| var A = []; |
| while (q < S.length) { |
| splitter.lastIndex = SUPPORTS_Y ? q : 0; |
| var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q)); |
| var e; |
| if ( |
| z === null || |
| (e = min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p |
| ) { |
| q = advanceStringIndex(S, q, unicodeMatching); |
| } else { |
| A.push(S.slice(p, q)); |
| if (A.length === lim) return A; |
| for (var i = 1; i <= z.length - 1; i++) { |
| A.push(z[i]); |
| if (A.length === lim) return A; |
| } |
| q = p = e; |
| } |
| } |
| A.push(S.slice(p)); |
| return A; |
| } |
| ]; |
| }, !SUPPORTS_Y); |
| |
| },{"../internals/advance-string-index":11,"../internals/an-object":13,"../internals/fails":50,"../internals/fix-regexp-well-known-symbol-logic":51,"../internals/is-regexp":79,"../internals/regexp-exec":119,"../internals/regexp-exec-abstract":118,"../internals/require-object-coercible":121,"../internals/species-constructor":129,"../internals/to-length":140}],297:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var toLength = require('../internals/to-length'); |
| var notARegExp = require('../internals/not-a-regexp'); |
| var requireObjectCoercible = require('../internals/require-object-coercible'); |
| var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic'); |
| |
| var nativeStartsWith = ''.startsWith; |
| var min = Math.min; |
| |
| // `String.prototype.startsWith` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.startswith |
| $({ target: 'String', proto: true, forced: !correctIsRegExpLogic('startsWith') }, { |
| startsWith: function startsWith(searchString /* , position = 0 */) { |
| var that = String(requireObjectCoercible(this)); |
| notARegExp(searchString); |
| var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length)); |
| var search = String(searchString); |
| return nativeStartsWith |
| ? nativeStartsWith.call(that, search, index) |
| : that.slice(index, index + search.length) === search; |
| } |
| }); |
| |
| },{"../internals/correct-is-regexp-logic":35,"../internals/export":49,"../internals/not-a-regexp":92,"../internals/require-object-coercible":121,"../internals/to-length":140}],298:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.strike` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.strike |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('strike') }, { |
| strike: function strike() { |
| return createHTML(this, 'strike', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],299:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.sub` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.sub |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sub') }, { |
| sub: function sub() { |
| return createHTML(this, 'sub', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],300:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var createHTML = require('../internals/create-html'); |
| var forcedStringHTMLMethod = require('../internals/forced-string-html-method'); |
| |
| // `String.prototype.sup` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.sup |
| $({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sup') }, { |
| sup: function sup() { |
| return createHTML(this, 'sup', '', ''); |
| } |
| }); |
| |
| },{"../internals/create-html":37,"../internals/export":49,"../internals/forced-string-html-method":54}],301:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $trimEnd = require('../internals/string-trim').end; |
| var forcedStringTrimMethod = require('../internals/forced-string-trim-method'); |
| |
| var FORCED = forcedStringTrimMethod('trimEnd'); |
| |
| var trimEnd = FORCED ? function trimEnd() { |
| return $trimEnd(this); |
| } : ''.trimEnd; |
| |
| // `String.prototype.{ trimEnd, trimRight }` methods |
| // https://github.com/tc39/ecmascript-string-left-right-trim |
| $({ target: 'String', proto: true, forced: FORCED }, { |
| trimEnd: trimEnd, |
| trimRight: trimEnd |
| }); |
| |
| },{"../internals/export":49,"../internals/forced-string-trim-method":55,"../internals/string-trim":133}],302:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $trimStart = require('../internals/string-trim').start; |
| var forcedStringTrimMethod = require('../internals/forced-string-trim-method'); |
| |
| var FORCED = forcedStringTrimMethod('trimStart'); |
| |
| var trimStart = FORCED ? function trimStart() { |
| return $trimStart(this); |
| } : ''.trimStart; |
| |
| // `String.prototype.{ trimStart, trimLeft }` methods |
| // https://github.com/tc39/ecmascript-string-left-right-trim |
| $({ target: 'String', proto: true, forced: FORCED }, { |
| trimStart: trimStart, |
| trimLeft: trimStart |
| }); |
| |
| },{"../internals/export":49,"../internals/forced-string-trim-method":55,"../internals/string-trim":133}],303:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var $trim = require('../internals/string-trim').trim; |
| var forcedStringTrimMethod = require('../internals/forced-string-trim-method'); |
| |
| // `String.prototype.trim` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.trim |
| $({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { |
| trim: function trim() { |
| return $trim(this); |
| } |
| }); |
| |
| },{"../internals/export":49,"../internals/forced-string-trim-method":55,"../internals/string-trim":133}],304:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.asyncIterator` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.asynciterator |
| defineWellKnownSymbol('asyncIterator'); |
| |
| },{"../internals/define-well-known-symbol":44}],305:[function(require,module,exports){ |
| // `Symbol.prototype.description` getter |
| // https://tc39.github.io/ecma262/#sec-symbol.prototype.description |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var global = require('../internals/global'); |
| var has = require('../internals/has'); |
| var isObject = require('../internals/is-object'); |
| var defineProperty = require('../internals/object-define-property').f; |
| var copyConstructorProperties = require('../internals/copy-constructor-properties'); |
| |
| var NativeSymbol = global.Symbol; |
| |
| if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || |
| // Safari 12 bug |
| NativeSymbol().description !== undefined |
| )) { |
| var EmptyStringDescriptionStore = {}; |
| // wrap Symbol constructor for correct work with undefined description |
| var SymbolWrapper = function Symbol() { |
| var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]); |
| var result = this instanceof SymbolWrapper |
| ? new NativeSymbol(description) |
| // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' |
| : description === undefined ? NativeSymbol() : NativeSymbol(description); |
| if (description === '') EmptyStringDescriptionStore[result] = true; |
| return result; |
| }; |
| copyConstructorProperties(SymbolWrapper, NativeSymbol); |
| var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype; |
| symbolPrototype.constructor = SymbolWrapper; |
| |
| var symbolToString = symbolPrototype.toString; |
| var native = String(NativeSymbol('test')) == 'Symbol(test)'; |
| var regexp = /^Symbol\((.*)\)[^)]+$/; |
| defineProperty(symbolPrototype, 'description', { |
| configurable: true, |
| get: function description() { |
| var symbol = isObject(this) ? this.valueOf() : this; |
| var string = symbolToString.call(symbol); |
| if (has(EmptyStringDescriptionStore, symbol)) return ''; |
| var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1'); |
| return desc === '' ? undefined : desc; |
| } |
| }); |
| |
| $({ global: true, forced: true }, { |
| Symbol: SymbolWrapper |
| }); |
| } |
| |
| },{"../internals/copy-constructor-properties":34,"../internals/descriptors":45,"../internals/export":49,"../internals/global":62,"../internals/has":63,"../internals/is-object":77,"../internals/object-define-property":97}],306:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.hasInstance` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.hasinstance |
| defineWellKnownSymbol('hasInstance'); |
| |
| },{"../internals/define-well-known-symbol":44}],307:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.isConcatSpreadable` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.isconcatspreadable |
| defineWellKnownSymbol('isConcatSpreadable'); |
| |
| },{"../internals/define-well-known-symbol":44}],308:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.iterator` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.iterator |
| defineWellKnownSymbol('iterator'); |
| |
| },{"../internals/define-well-known-symbol":44}],309:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| var global = require('../internals/global'); |
| var IS_PURE = require('../internals/is-pure'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var NATIVE_SYMBOL = require('../internals/native-symbol'); |
| var fails = require('../internals/fails'); |
| var has = require('../internals/has'); |
| var isArray = require('../internals/is-array'); |
| var isObject = require('../internals/is-object'); |
| var anObject = require('../internals/an-object'); |
| var toObject = require('../internals/to-object'); |
| var toIndexedObject = require('../internals/to-indexed-object'); |
| var toPrimitive = require('../internals/to-primitive'); |
| var createPropertyDescriptor = require('../internals/create-property-descriptor'); |
| var nativeObjectCreate = require('../internals/object-create'); |
| var objectKeys = require('../internals/object-keys'); |
| var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names'); |
| var getOwnPropertyNamesExternal = require('../internals/object-get-own-property-names-external'); |
| var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols'); |
| var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); |
| var definePropertyModule = require('../internals/object-define-property'); |
| var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable'); |
| var hide = require('../internals/hide'); |
| var redefine = require('../internals/redefine'); |
| var shared = require('../internals/shared'); |
| var sharedKey = require('../internals/shared-key'); |
| var hiddenKeys = require('../internals/hidden-keys'); |
| var uid = require('../internals/uid'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var wrappedWellKnownSymbolModule = require('../internals/wrapped-well-known-symbol'); |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var InternalStateModule = require('../internals/internal-state'); |
| var $forEach = require('../internals/array-iteration').forEach; |
| |
| var HIDDEN = sharedKey('hidden'); |
| var SYMBOL = 'Symbol'; |
| var PROTOTYPE = 'prototype'; |
| var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); |
| var setInternalState = InternalStateModule.set; |
| var getInternalState = InternalStateModule.getterFor(SYMBOL); |
| var ObjectPrototype = Object[PROTOTYPE]; |
| var $Symbol = global.Symbol; |
| var JSON = global.JSON; |
| var nativeJSONStringify = JSON && JSON.stringify; |
| var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; |
| var nativeDefineProperty = definePropertyModule.f; |
| var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f; |
| var nativePropertyIsEnumerable = propertyIsEnumerableModule.f; |
| var AllSymbols = shared('symbols'); |
| var ObjectPrototypeSymbols = shared('op-symbols'); |
| var StringToSymbolRegistry = shared('string-to-symbol-registry'); |
| var SymbolToStringRegistry = shared('symbol-to-string-registry'); |
| var WellKnownSymbolsStore = shared('wks'); |
| var QObject = global.QObject; |
| // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 |
| var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; |
| |
| // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 |
| var setSymbolDescriptor = DESCRIPTORS && fails(function () { |
| return nativeObjectCreate(nativeDefineProperty({}, 'a', { |
| get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; } |
| })).a != 7; |
| }) ? function (O, P, Attributes) { |
| var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P); |
| if (ObjectPrototypeDescriptor) delete ObjectPrototype[P]; |
| nativeDefineProperty(O, P, Attributes); |
| if (ObjectPrototypeDescriptor && O !== ObjectPrototype) { |
| nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor); |
| } |
| } : nativeDefineProperty; |
| |
| var wrap = function (tag, description) { |
| var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]); |
| setInternalState(symbol, { |
| type: SYMBOL, |
| tag: tag, |
| description: description |
| }); |
| if (!DESCRIPTORS) symbol.description = description; |
| return symbol; |
| }; |
| |
| var isSymbol = NATIVE_SYMBOL && typeof $Symbol.iterator == 'symbol' ? function (it) { |
| return typeof it == 'symbol'; |
| } : function (it) { |
| return Object(it) instanceof $Symbol; |
| }; |
| |
| var $defineProperty = function defineProperty(O, P, Attributes) { |
| if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes); |
| anObject(O); |
| var key = toPrimitive(P, true); |
| anObject(Attributes); |
| if (has(AllSymbols, key)) { |
| if (!Attributes.enumerable) { |
| if (!has(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {})); |
| O[HIDDEN][key] = true; |
| } else { |
| if (has(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false; |
| Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) }); |
| } return setSymbolDescriptor(O, key, Attributes); |
| } return nativeDefineProperty(O, key, Attributes); |
| }; |
| |
| var $defineProperties = function defineProperties(O, Properties) { |
| anObject(O); |
| var properties = toIndexedObject(Properties); |
| var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties)); |
| $forEach(keys, function (key) { |
| if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]); |
| }); |
| return O; |
| }; |
| |
| var $create = function create(O, Properties) { |
| return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties); |
| }; |
| |
| var $propertyIsEnumerable = function propertyIsEnumerable(V) { |
| var P = toPrimitive(V, true); |
| var enumerable = nativePropertyIsEnumerable.call(this, P); |
| if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) return false; |
| return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true; |
| }; |
| |
| var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) { |
| var it = toIndexedObject(O); |
| var key = toPrimitive(P, true); |
| if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return; |
| var descriptor = nativeGetOwnPropertyDescriptor(it, key); |
| if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) { |
| descriptor.enumerable = true; |
| } |
| return descriptor; |
| }; |
| |
| var $getOwnPropertyNames = function getOwnPropertyNames(O) { |
| var names = nativeGetOwnPropertyNames(toIndexedObject(O)); |
| var result = []; |
| $forEach(names, function (key) { |
| if (!has(AllSymbols, key) && !has(hiddenKeys, key)) result.push(key); |
| }); |
| return result; |
| }; |
| |
| var $getOwnPropertySymbols = function getOwnPropertySymbols(O) { |
| var IS_OBJECT_PROTOTYPE = O === ObjectPrototype; |
| var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O)); |
| var result = []; |
| $forEach(names, function (key) { |
| if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) { |
| result.push(AllSymbols[key]); |
| } |
| }); |
| return result; |
| }; |
| |
| // `Symbol` constructor |
| // https://tc39.github.io/ecma262/#sec-symbol-constructor |
| if (!NATIVE_SYMBOL) { |
| $Symbol = function Symbol() { |
| if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor'); |
| var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]); |
| var tag = uid(description); |
| var setter = function (value) { |
| if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value); |
| if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; |
| setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value)); |
| }; |
| if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter }); |
| return wrap(tag, description); |
| }; |
| |
| redefine($Symbol[PROTOTYPE], 'toString', function toString() { |
| return getInternalState(this).tag; |
| }); |
| |
| propertyIsEnumerableModule.f = $propertyIsEnumerable; |
| definePropertyModule.f = $defineProperty; |
| getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor; |
| getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames; |
| getOwnPropertySymbolsModule.f = $getOwnPropertySymbols; |
| |
| if (DESCRIPTORS) { |
| // https://github.com/tc39/proposal-Symbol-description |
| nativeDefineProperty($Symbol[PROTOTYPE], 'description', { |
| configurable: true, |
| get: function description() { |
| return getInternalState(this).description; |
| } |
| }); |
| if (!IS_PURE) { |
| redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); |
| } |
| } |
| |
| wrappedWellKnownSymbolModule.f = function (name) { |
| return wrap(wellKnownSymbol(name), name); |
| }; |
| } |
| |
| $({ global: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, { |
| Symbol: $Symbol |
| }); |
| |
| $forEach(objectKeys(WellKnownSymbolsStore), function (name) { |
| defineWellKnownSymbol(name); |
| }); |
| |
| $({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, { |
| // `Symbol.for` method |
| // https://tc39.github.io/ecma262/#sec-symbol.for |
| 'for': function (key) { |
| var string = String(key); |
| if (has(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; |
| var symbol = $Symbol(string); |
| StringToSymbolRegistry[string] = symbol; |
| SymbolToStringRegistry[symbol] = string; |
| return symbol; |
| }, |
| // `Symbol.keyFor` method |
| // https://tc39.github.io/ecma262/#sec-symbol.keyfor |
| keyFor: function keyFor(sym) { |
| if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol'); |
| if (has(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym]; |
| }, |
| useSetter: function () { USE_SETTER = true; }, |
| useSimple: function () { USE_SETTER = false; } |
| }); |
| |
| $({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, { |
| // `Object.create` method |
| // https://tc39.github.io/ecma262/#sec-object.create |
| create: $create, |
| // `Object.defineProperty` method |
| // https://tc39.github.io/ecma262/#sec-object.defineproperty |
| defineProperty: $defineProperty, |
| // `Object.defineProperties` method |
| // https://tc39.github.io/ecma262/#sec-object.defineproperties |
| defineProperties: $defineProperties, |
| // `Object.getOwnPropertyDescriptor` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors |
| getOwnPropertyDescriptor: $getOwnPropertyDescriptor |
| }); |
| |
| $({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, { |
| // `Object.getOwnPropertyNames` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertynames |
| getOwnPropertyNames: $getOwnPropertyNames, |
| // `Object.getOwnPropertySymbols` method |
| // https://tc39.github.io/ecma262/#sec-object.getownpropertysymbols |
| getOwnPropertySymbols: $getOwnPropertySymbols |
| }); |
| |
| // Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives |
| // https://bugs.chromium.org/p/v8/issues/detail?id=3443 |
| $({ target: 'Object', stat: true, forced: fails(function () { getOwnPropertySymbolsModule.f(1); }) }, { |
| getOwnPropertySymbols: function getOwnPropertySymbols(it) { |
| return getOwnPropertySymbolsModule.f(toObject(it)); |
| } |
| }); |
| |
| // `JSON.stringify` method behavior with symbols |
| // https://tc39.github.io/ecma262/#sec-json.stringify |
| JSON && $({ target: 'JSON', stat: true, forced: !NATIVE_SYMBOL || fails(function () { |
| var symbol = $Symbol(); |
| // MS Edge converts symbol values to JSON as {} |
| return nativeJSONStringify([symbol]) != '[null]' |
| // WebKit converts symbol values to JSON as null |
| || nativeJSONStringify({ a: symbol }) != '{}' |
| // V8 throws on boxed symbols |
| || nativeJSONStringify(Object(symbol)) != '{}'; |
| }) }, { |
| stringify: function stringify(it) { |
| var args = [it]; |
| var index = 1; |
| var replacer, $replacer; |
| while (arguments.length > index) args.push(arguments[index++]); |
| $replacer = replacer = args[1]; |
| if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined |
| if (!isArray(replacer)) replacer = function (key, value) { |
| if (typeof $replacer == 'function') value = $replacer.call(this, key, value); |
| if (!isSymbol(value)) return value; |
| }; |
| args[1] = replacer; |
| return nativeJSONStringify.apply(JSON, args); |
| } |
| }); |
| |
| // `Symbol.prototype[@@toPrimitive]` method |
| // https://tc39.github.io/ecma262/#sec-symbol.prototype-@@toprimitive |
| if (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) hide($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); |
| // `Symbol.prototype[@@toStringTag]` property |
| // https://tc39.github.io/ecma262/#sec-symbol.prototype-@@tostringtag |
| setToStringTag($Symbol, SYMBOL); |
| |
| hiddenKeys[HIDDEN] = true; |
| |
| },{"../internals/an-object":13,"../internals/array-iteration":21,"../internals/create-property-descriptor":39,"../internals/define-well-known-symbol":44,"../internals/descriptors":45,"../internals/export":49,"../internals/fails":50,"../internals/global":62,"../internals/has":63,"../internals/hidden-keys":64,"../internals/hide":65,"../internals/internal-state":72,"../internals/is-array":74,"../internals/is-object":77,"../internals/is-pure":78,"../internals/native-symbol":88,"../internals/object-create":95,"../internals/object-define-property":97,"../internals/object-get-own-property-descriptor":98,"../internals/object-get-own-property-names":100,"../internals/object-get-own-property-names-external":99,"../internals/object-get-own-property-symbols":101,"../internals/object-keys":104,"../internals/object-property-is-enumerable":105,"../internals/redefine":117,"../internals/set-to-string-tag":125,"../internals/shared":127,"../internals/shared-key":126,"../internals/to-indexed-object":138,"../internals/to-object":141,"../internals/to-primitive":143,"../internals/uid":147,"../internals/well-known-symbol":150,"../internals/wrapped-well-known-symbol":152}],310:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.matchAll` well-known symbol |
| defineWellKnownSymbol('matchAll'); |
| |
| },{"../internals/define-well-known-symbol":44}],311:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.match` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.match |
| defineWellKnownSymbol('match'); |
| |
| },{"../internals/define-well-known-symbol":44}],312:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.replace` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.replace |
| defineWellKnownSymbol('replace'); |
| |
| },{"../internals/define-well-known-symbol":44}],313:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.search` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.search |
| defineWellKnownSymbol('search'); |
| |
| },{"../internals/define-well-known-symbol":44}],314:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.species` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.species |
| defineWellKnownSymbol('species'); |
| |
| },{"../internals/define-well-known-symbol":44}],315:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.split` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.split |
| defineWellKnownSymbol('split'); |
| |
| },{"../internals/define-well-known-symbol":44}],316:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.toPrimitive` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.toprimitive |
| defineWellKnownSymbol('toPrimitive'); |
| |
| },{"../internals/define-well-known-symbol":44}],317:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.toStringTag` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.tostringtag |
| defineWellKnownSymbol('toStringTag'); |
| |
| },{"../internals/define-well-known-symbol":44}],318:[function(require,module,exports){ |
| var defineWellKnownSymbol = require('../internals/define-well-known-symbol'); |
| |
| // `Symbol.unscopables` well-known symbol |
| // https://tc39.github.io/ecma262/#sec-symbol.unscopables |
| defineWellKnownSymbol('unscopables'); |
| |
| },{"../internals/define-well-known-symbol":44}],319:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $copyWithin = require('../internals/array-copy-within'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.copyWithin` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.copywithin |
| ArrayBufferViewCore.exportProto('copyWithin', function copyWithin(target, start /* , end */) { |
| return $copyWithin.call(aTypedArray(this), target, start, arguments.length > 2 ? arguments[2] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-copy-within":16}],320:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $every = require('../internals/array-iteration').every; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.every` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.every |
| ArrayBufferViewCore.exportProto('every', function every(callbackfn /* , thisArg */) { |
| return $every(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21}],321:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $fill = require('../internals/array-fill'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.fill` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill |
| // eslint-disable-next-line no-unused-vars |
| ArrayBufferViewCore.exportProto('fill', function fill(value /* , start, end */) { |
| return $fill.apply(aTypedArray(this), arguments); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-fill":17}],322:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $filter = require('../internals/array-iteration').filter; |
| var speciesConstructor = require('../internals/species-constructor'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; |
| |
| // `%TypedArray%.prototype.filter` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.filter |
| ArrayBufferViewCore.exportProto('filter', function filter(callbackfn /* , thisArg */) { |
| var list = $filter(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| var C = speciesConstructor(this, this.constructor); |
| var index = 0; |
| var length = list.length; |
| var result = new (aTypedArrayConstructor(C))(length); |
| while (length > index) result[index] = list[index++]; |
| return result; |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21,"../internals/species-constructor":129}],323:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $findIndex = require('../internals/array-iteration').findIndex; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.findIndex` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.findindex |
| ArrayBufferViewCore.exportProto('findIndex', function findIndex(predicate /* , thisArg */) { |
| return $findIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21}],324:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $find = require('../internals/array-iteration').find; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.find` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.find |
| ArrayBufferViewCore.exportProto('find', function find(predicate /* , thisArg */) { |
| return $find(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21}],325:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Float32Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Float32', 4, function (init) { |
| return function Float32Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],326:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Float64Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Float64', 8, function (init) { |
| return function Float64Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],327:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $forEach = require('../internals/array-iteration').forEach; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.forEach` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.foreach |
| ArrayBufferViewCore.exportProto('forEach', function forEach(callbackfn /* , thisArg */) { |
| $forEach(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21}],328:[function(require,module,exports){ |
| 'use strict'; |
| var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-arrays-constructors-requires-wrappers'); |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var typedArrayFrom = require('../internals/typed-array-from'); |
| |
| // `%TypedArray%.from` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.from |
| ArrayBufferViewCore.exportStatic('from', typedArrayFrom, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/typed-array-from":145,"../internals/typed-arrays-constructors-requires-wrappers":146}],329:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $includes = require('../internals/array-includes').includes; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.includes` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.includes |
| ArrayBufferViewCore.exportProto('includes', function includes(searchElement /* , fromIndex */) { |
| return $includes(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-includes":20}],330:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $indexOf = require('../internals/array-includes').indexOf; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.indexOf` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.indexof |
| ArrayBufferViewCore.exportProto('indexOf', function indexOf(searchElement /* , fromIndex */) { |
| return $indexOf(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-includes":20}],331:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Int16Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Int16', 2, function (init) { |
| return function Int16Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],332:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Int32Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Int32', 4, function (init) { |
| return function Int32Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],333:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Int8Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Int8', 1, function (init) { |
| return function Int8Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],334:[function(require,module,exports){ |
| 'use strict'; |
| var global = require('../internals/global'); |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var ArrayIterators = require('../modules/es.array.iterator'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var Uint8Array = global.Uint8Array; |
| var arrayValues = ArrayIterators.values; |
| var arrayKeys = ArrayIterators.keys; |
| var arrayEntries = ArrayIterators.entries; |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var exportProto = ArrayBufferViewCore.exportProto; |
| var nativeTypedArrayIterator = Uint8Array && Uint8Array.prototype[ITERATOR]; |
| |
| var CORRECT_ITER_NAME = !!nativeTypedArrayIterator |
| && (nativeTypedArrayIterator.name == 'values' || nativeTypedArrayIterator.name == undefined); |
| |
| var typedArrayValues = function values() { |
| return arrayValues.call(aTypedArray(this)); |
| }; |
| |
| // `%TypedArray%.prototype.entries` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.entries |
| exportProto('entries', function entries() { |
| return arrayEntries.call(aTypedArray(this)); |
| }); |
| // `%TypedArray%.prototype.keys` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.keys |
| exportProto('keys', function keys() { |
| return arrayKeys.call(aTypedArray(this)); |
| }); |
| // `%TypedArray%.prototype.values` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.values |
| exportProto('values', typedArrayValues, !CORRECT_ITER_NAME); |
| // `%TypedArray%.prototype[@@iterator]` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype-@@iterator |
| exportProto(ITERATOR, typedArrayValues, !CORRECT_ITER_NAME); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/global":62,"../internals/well-known-symbol":150,"../modules/es.array.iterator":170}],335:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var $join = [].join; |
| |
| // `%TypedArray%.prototype.join` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join |
| // eslint-disable-next-line no-unused-vars |
| ArrayBufferViewCore.exportProto('join', function join(separator) { |
| return $join.apply(aTypedArray(this), arguments); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14}],336:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $lastIndexOf = require('../internals/array-last-index-of'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.lastIndexOf` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.lastindexof |
| // eslint-disable-next-line no-unused-vars |
| ArrayBufferViewCore.exportProto('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) { |
| return $lastIndexOf.apply(aTypedArray(this), arguments); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-last-index-of":22}],337:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $map = require('../internals/array-iteration').map; |
| var speciesConstructor = require('../internals/species-constructor'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; |
| |
| // `%TypedArray%.prototype.map` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.map |
| ArrayBufferViewCore.exportProto('map', function map(mapfn /* , thisArg */) { |
| return $map(aTypedArray(this), mapfn, arguments.length > 1 ? arguments[1] : undefined, function (O, length) { |
| return new (aTypedArrayConstructor(speciesConstructor(O, O.constructor)))(length); |
| }); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21,"../internals/species-constructor":129}],338:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-arrays-constructors-requires-wrappers'); |
| |
| var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; |
| |
| // `%TypedArray%.of` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.of |
| ArrayBufferViewCore.exportStatic('of', function of(/* ...items */) { |
| var index = 0; |
| var length = arguments.length; |
| var result = new (aTypedArrayConstructor(this))(length); |
| while (length > index) result[index] = arguments[index++]; |
| return result; |
| }, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/typed-arrays-constructors-requires-wrappers":146}],339:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $reduceRight = require('../internals/array-reduce').right; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.reduceRicht` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduceright |
| ArrayBufferViewCore.exportProto('reduceRight', function reduceRight(callbackfn /* , initialValue */) { |
| return $reduceRight(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-reduce":24}],340:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $reduce = require('../internals/array-reduce').left; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.reduce` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduce |
| ArrayBufferViewCore.exportProto('reduce', function reduce(callbackfn /* , initialValue */) { |
| return $reduce(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-reduce":24}],341:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var floor = Math.floor; |
| |
| // `%TypedArray%.prototype.reverse` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reverse |
| ArrayBufferViewCore.exportProto('reverse', function reverse() { |
| var that = this; |
| var length = aTypedArray(that).length; |
| var middle = floor(length / 2); |
| var index = 0; |
| var value; |
| while (index < middle) { |
| value = that[index]; |
| that[index++] = that[--length]; |
| that[length] = value; |
| } return that; |
| }); |
| |
| },{"../internals/array-buffer-view-core":14}],342:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var toLength = require('../internals/to-length'); |
| var toOffset = require('../internals/to-offset'); |
| var toObject = require('../internals/to-object'); |
| var fails = require('../internals/fails'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| var FORCED = fails(function () { |
| // eslint-disable-next-line no-undef |
| new Int8Array(1).set({}); |
| }); |
| |
| // `%TypedArray%.prototype.set` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.set |
| ArrayBufferViewCore.exportProto('set', function set(arrayLike /* , offset */) { |
| aTypedArray(this); |
| var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1); |
| var length = this.length; |
| var src = toObject(arrayLike); |
| var len = toLength(src.length); |
| var index = 0; |
| if (len + offset > length) throw RangeError('Wrong length'); |
| while (index < len) this[offset + index] = src[index++]; |
| }, FORCED); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/fails":50,"../internals/to-length":140,"../internals/to-object":141,"../internals/to-offset":142}],343:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| var fails = require('../internals/fails'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; |
| var $slice = [].slice; |
| |
| var FORCED = fails(function () { |
| // eslint-disable-next-line no-undef |
| new Int8Array(1).slice(); |
| }); |
| |
| // `%TypedArray%.prototype.slice` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.slice |
| ArrayBufferViewCore.exportProto('slice', function slice(start, end) { |
| var list = $slice.call(aTypedArray(this), start, end); |
| var C = speciesConstructor(this, this.constructor); |
| var index = 0; |
| var length = list.length; |
| var result = new (aTypedArrayConstructor(C))(length); |
| while (length > index) result[index] = list[index++]; |
| return result; |
| }, FORCED); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/fails":50,"../internals/species-constructor":129}],344:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var $some = require('../internals/array-iteration').some; |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.some` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.some |
| ArrayBufferViewCore.exportProto('some', function some(callbackfn /* , thisArg */) { |
| return $some(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/array-iteration":21}],345:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var $sort = [].sort; |
| |
| // `%TypedArray%.prototype.sort` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort |
| ArrayBufferViewCore.exportProto('sort', function sort(comparefn) { |
| return $sort.call(aTypedArray(this), comparefn); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14}],346:[function(require,module,exports){ |
| 'use strict'; |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var toLength = require('../internals/to-length'); |
| var toAbsoluteIndex = require('../internals/to-absolute-index'); |
| var speciesConstructor = require('../internals/species-constructor'); |
| |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| |
| // `%TypedArray%.prototype.subarray` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.subarray |
| ArrayBufferViewCore.exportProto('subarray', function subarray(begin, end) { |
| var O = aTypedArray(this); |
| var length = O.length; |
| var beginIndex = toAbsoluteIndex(begin, length); |
| return new (speciesConstructor(O, O.constructor))( |
| O.buffer, |
| O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, |
| toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) |
| ); |
| }); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/species-constructor":129,"../internals/to-absolute-index":136,"../internals/to-length":140}],347:[function(require,module,exports){ |
| 'use strict'; |
| var global = require('../internals/global'); |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var fails = require('../internals/fails'); |
| |
| var Int8Array = global.Int8Array; |
| var aTypedArray = ArrayBufferViewCore.aTypedArray; |
| var $toLocaleString = [].toLocaleString; |
| var $slice = [].slice; |
| |
| // iOS Safari 6.x fails here |
| var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () { |
| $toLocaleString.call(new Int8Array(1)); |
| }); |
| |
| var FORCED = fails(function () { |
| return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString(); |
| }) || !fails(function () { |
| Int8Array.prototype.toLocaleString.call([1, 2]); |
| }); |
| |
| // `%TypedArray%.prototype.toLocaleString` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring |
| ArrayBufferViewCore.exportProto('toLocaleString', function toLocaleString() { |
| return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments); |
| }, FORCED); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/fails":50,"../internals/global":62}],348:[function(require,module,exports){ |
| 'use strict'; |
| var global = require('../internals/global'); |
| var ArrayBufferViewCore = require('../internals/array-buffer-view-core'); |
| var fails = require('../internals/fails'); |
| |
| var Uint8Array = global.Uint8Array; |
| var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype; |
| var arrayToString = [].toString; |
| var arrayJoin = [].join; |
| |
| if (fails(function () { arrayToString.call({}); })) { |
| arrayToString = function toString() { |
| return arrayJoin.call(this); |
| }; |
| } |
| |
| // `%TypedArray%.prototype.toString` method |
| // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tostring |
| ArrayBufferViewCore.exportProto('toString', arrayToString, (Uint8ArrayPrototype || {}).toString != arrayToString); |
| |
| },{"../internals/array-buffer-view-core":14,"../internals/fails":50,"../internals/global":62}],349:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Uint16Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Uint16', 2, function (init) { |
| return function Uint16Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],350:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Uint32Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Uint32', 4, function (init) { |
| return function Uint32Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],351:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Uint8Array` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Uint8', 1, function (init) { |
| return function Uint8Array(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }); |
| |
| },{"../internals/typed-array-constructor":144}],352:[function(require,module,exports){ |
| var typedArrayConstructor = require('../internals/typed-array-constructor'); |
| |
| // `Uint8ClampedArray` constructor |
| // https://tc39.github.io/ecma262/#sec-typedarray-objects |
| typedArrayConstructor('Uint8', 1, function (init) { |
| return function Uint8ClampedArray(data, byteOffset, length) { |
| return init(this, data, byteOffset, length); |
| }; |
| }, true); |
| |
| },{"../internals/typed-array-constructor":144}],353:[function(require,module,exports){ |
| 'use strict'; |
| var global = require('../internals/global'); |
| var redefineAll = require('../internals/redefine-all'); |
| var InternalMetadataModule = require('../internals/internal-metadata'); |
| var collection = require('../internals/collection'); |
| var collectionWeak = require('../internals/collection-weak'); |
| var isObject = require('../internals/is-object'); |
| var enforceIternalState = require('../internals/internal-state').enforce; |
| var NATIVE_WEAK_MAP = require('../internals/native-weak-map'); |
| |
| var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global; |
| var isExtensible = Object.isExtensible; |
| var InternalWeakMap; |
| |
| var wrapper = function (get) { |
| return function WeakMap() { |
| return get(this, arguments.length ? arguments[0] : undefined); |
| }; |
| }; |
| |
| // `WeakMap` constructor |
| // https://tc39.github.io/ecma262/#sec-weakmap-constructor |
| var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak, true, true); |
| |
| // IE11 WeakMap frozen keys fix |
| // We can't use feature detection because it crash some old IE builds |
| // https://github.com/zloirock/core-js/issues/485 |
| if (NATIVE_WEAK_MAP && IS_IE11) { |
| InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); |
| InternalMetadataModule.REQUIRED = true; |
| var WeakMapPrototype = $WeakMap.prototype; |
| var nativeDelete = WeakMapPrototype['delete']; |
| var nativeHas = WeakMapPrototype.has; |
| var nativeGet = WeakMapPrototype.get; |
| var nativeSet = WeakMapPrototype.set; |
| redefineAll(WeakMapPrototype, { |
| 'delete': function (key) { |
| if (isObject(key) && !isExtensible(key)) { |
| var state = enforceIternalState(this); |
| if (!state.frozen) state.frozen = new InternalWeakMap(); |
| return nativeDelete.call(this, key) || state.frozen['delete'](key); |
| } return nativeDelete.call(this, key); |
| }, |
| has: function has(key) { |
| if (isObject(key) && !isExtensible(key)) { |
| var state = enforceIternalState(this); |
| if (!state.frozen) state.frozen = new InternalWeakMap(); |
| return nativeHas.call(this, key) || state.frozen.has(key); |
| } return nativeHas.call(this, key); |
| }, |
| get: function get(key) { |
| if (isObject(key) && !isExtensible(key)) { |
| var state = enforceIternalState(this); |
| if (!state.frozen) state.frozen = new InternalWeakMap(); |
| return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); |
| } return nativeGet.call(this, key); |
| }, |
| set: function set(key, value) { |
| if (isObject(key) && !isExtensible(key)) { |
| var state = enforceIternalState(this); |
| if (!state.frozen) state.frozen = new InternalWeakMap(); |
| nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); |
| } else nativeSet.call(this, key, value); |
| return this; |
| } |
| }); |
| } |
| |
| },{"../internals/collection":33,"../internals/collection-weak":32,"../internals/global":62,"../internals/internal-metadata":71,"../internals/internal-state":72,"../internals/is-object":77,"../internals/native-weak-map":90,"../internals/redefine-all":116}],354:[function(require,module,exports){ |
| 'use strict'; |
| var collection = require('../internals/collection'); |
| var collectionWeak = require('../internals/collection-weak'); |
| |
| // `WeakSet` constructor |
| // https://tc39.github.io/ecma262/#sec-weakset-constructor |
| collection('WeakSet', function (get) { |
| return function WeakSet() { return get(this, arguments.length ? arguments[0] : undefined); }; |
| }, collectionWeak, false, true); |
| |
| },{"../internals/collection":33,"../internals/collection-weak":32}],355:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var DOMIterables = require('../internals/dom-iterables'); |
| var forEach = require('../internals/array-for-each'); |
| var hide = require('../internals/hide'); |
| |
| for (var COLLECTION_NAME in DOMIterables) { |
| var Collection = global[COLLECTION_NAME]; |
| var CollectionPrototype = Collection && Collection.prototype; |
| // some Chrome versions have non-configurable methods on DOMTokenList |
| if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { |
| hide(CollectionPrototype, 'forEach', forEach); |
| } catch (error) { |
| CollectionPrototype.forEach = forEach; |
| } |
| } |
| |
| },{"../internals/array-for-each":18,"../internals/dom-iterables":47,"../internals/global":62,"../internals/hide":65}],356:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var DOMIterables = require('../internals/dom-iterables'); |
| var ArrayIteratorMethods = require('../modules/es.array.iterator'); |
| var hide = require('../internals/hide'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var TO_STRING_TAG = wellKnownSymbol('toStringTag'); |
| var ArrayValues = ArrayIteratorMethods.values; |
| |
| for (var COLLECTION_NAME in DOMIterables) { |
| var Collection = global[COLLECTION_NAME]; |
| var CollectionPrototype = Collection && Collection.prototype; |
| if (CollectionPrototype) { |
| // some Chrome versions have non-configurable methods on DOMTokenList |
| if (CollectionPrototype[ITERATOR] !== ArrayValues) try { |
| hide(CollectionPrototype, ITERATOR, ArrayValues); |
| } catch (error) { |
| CollectionPrototype[ITERATOR] = ArrayValues; |
| } |
| if (!CollectionPrototype[TO_STRING_TAG]) hide(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME); |
| if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { |
| // some Chrome versions have non-configurable methods on DOMTokenList |
| if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { |
| hide(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); |
| } catch (error) { |
| CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; |
| } |
| } |
| } |
| } |
| |
| },{"../internals/dom-iterables":47,"../internals/global":62,"../internals/hide":65,"../internals/well-known-symbol":150,"../modules/es.array.iterator":170}],357:[function(require,module,exports){ |
| var global = require('../internals/global'); |
| var task = require('../internals/task'); |
| |
| var FORCED = !global.setImmediate || !global.clearImmediate; |
| |
| // http://w3c.github.io/setImmediate/ |
| require('../internals/export')({ global: true, bind: true, enumerable: true, forced: FORCED }, { |
| // `setImmediate` method |
| // http://w3c.github.io/setImmediate/#si-setImmediate |
| setImmediate: task.set, |
| // `clearImmediate` method |
| // http://w3c.github.io/setImmediate/#si-clearImmediate |
| clearImmediate: task.clear |
| }); |
| |
| },{"../internals/export":49,"../internals/global":62,"../internals/task":134}],358:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var global = require('../internals/global'); |
| var microtask = require('../internals/microtask'); |
| var classof = require('../internals/classof-raw'); |
| |
| var process = global.process; |
| var isNode = classof(process) == 'process'; |
| |
| // `queueMicrotask` method |
| // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask |
| $({ global: true, enumerable: true, noTargetGet: true }, { |
| queueMicrotask: function queueMicrotask(fn) { |
| var domain = isNode && process.domain; |
| microtask(domain ? domain.bind(fn) : fn); |
| } |
| }); |
| |
| },{"../internals/classof-raw":29,"../internals/export":49,"../internals/global":62,"../internals/microtask":87}],359:[function(require,module,exports){ |
| var $ = require('../internals/export'); |
| var global = require('../internals/global'); |
| var userAgent = require('../internals/user-agent'); |
| |
| var slice = [].slice; |
| var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check |
| |
| var wrap = function (scheduler) { |
| return function (handler, timeout /* , ...arguments */) { |
| var boundArgs = arguments.length > 2; |
| var args = boundArgs ? slice.call(arguments, 2) : undefined; |
| return scheduler(boundArgs ? function () { |
| // eslint-disable-next-line no-new-func |
| (typeof handler == 'function' ? handler : Function(handler)).apply(this, args); |
| } : handler, timeout); |
| }; |
| }; |
| |
| // ie9- setTimeout & setInterval additional parameters fix |
| // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers |
| $({ global: true, bind: true, forced: MSIE }, { |
| // `setTimeout` method |
| // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout |
| setTimeout: wrap(global.setTimeout), |
| // `setInterval` method |
| // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval |
| setInterval: wrap(global.setInterval) |
| }); |
| |
| },{"../internals/export":49,"../internals/global":62,"../internals/user-agent":148}],360:[function(require,module,exports){ |
| 'use strict'; |
| // TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` |
| require('../modules/es.array.iterator'); |
| var $ = require('../internals/export'); |
| var USE_NATIVE_URL = require('../internals/native-url'); |
| var redefine = require('../internals/redefine'); |
| var redefineAll = require('../internals/redefine-all'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var createIteratorConstructor = require('../internals/create-iterator-constructor'); |
| var InternalStateModule = require('../internals/internal-state'); |
| var anInstance = require('../internals/an-instance'); |
| var hasOwn = require('../internals/has'); |
| var bind = require('../internals/bind-context'); |
| var anObject = require('../internals/an-object'); |
| var isObject = require('../internals/is-object'); |
| var getIterator = require('../internals/get-iterator'); |
| var getIteratorMethod = require('../internals/get-iterator-method'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| |
| var ITERATOR = wellKnownSymbol('iterator'); |
| var URL_SEARCH_PARAMS = 'URLSearchParams'; |
| var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator'; |
| var setInternalState = InternalStateModule.set; |
| var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS); |
| var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR); |
| |
| var plus = /\+/g; |
| var sequences = Array(4); |
| |
| var percentSequence = function (bytes) { |
| return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi')); |
| }; |
| |
| var percentDecode = function (sequence) { |
| try { |
| return decodeURIComponent(sequence); |
| } catch (error) { |
| return sequence; |
| } |
| }; |
| |
| var deserialize = function (it) { |
| var result = it.replace(plus, ' '); |
| var bytes = 4; |
| try { |
| return decodeURIComponent(result); |
| } catch (error) { |
| while (bytes) { |
| result = result.replace(percentSequence(bytes--), percentDecode); |
| } |
| return result; |
| } |
| }; |
| |
| var find = /[!'()~]|%20/g; |
| |
| var replace = { |
| '!': '%21', |
| "'": '%27', |
| '(': '%28', |
| ')': '%29', |
| '~': '%7E', |
| '%20': '+' |
| }; |
| |
| var replacer = function (match) { |
| return replace[match]; |
| }; |
| |
| var serialize = function (it) { |
| return encodeURIComponent(it).replace(find, replacer); |
| }; |
| |
| var parseSearchParams = function (result, query) { |
| if (query) { |
| var attributes = query.split('&'); |
| var index = 0; |
| var attribute, entry; |
| while (index < attributes.length) { |
| attribute = attributes[index++]; |
| if (attribute.length) { |
| entry = attribute.split('='); |
| result.push({ |
| key: deserialize(entry.shift()), |
| value: deserialize(entry.join('=')) |
| }); |
| } |
| } |
| } |
| }; |
| |
| var updateSearchParams = function (query) { |
| this.entries.length = 0; |
| parseSearchParams(this.entries, query); |
| }; |
| |
| var validateArgumentsLength = function (passed, required) { |
| if (passed < required) throw TypeError('Not enough arguments'); |
| }; |
| |
| var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) { |
| setInternalState(this, { |
| type: URL_SEARCH_PARAMS_ITERATOR, |
| iterator: getIterator(getInternalParamsState(params).entries), |
| kind: kind |
| }); |
| }, 'Iterator', function next() { |
| var state = getInternalIteratorState(this); |
| var kind = state.kind; |
| var step = state.iterator.next(); |
| var entry = step.value; |
| if (!step.done) { |
| step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value]; |
| } return step; |
| }); |
| |
| // `URLSearchParams` constructor |
| // https://url.spec.whatwg.org/#interface-urlsearchparams |
| var URLSearchParamsConstructor = function URLSearchParams(/* init */) { |
| anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS); |
| var init = arguments.length > 0 ? arguments[0] : undefined; |
| var that = this; |
| var entries = []; |
| var iteratorMethod, iterator, step, entryIterator, first, second, key; |
| |
| setInternalState(that, { |
| type: URL_SEARCH_PARAMS, |
| entries: entries, |
| updateURL: function () { /* empty */ }, |
| updateSearchParams: updateSearchParams |
| }); |
| |
| if (init !== undefined) { |
| if (isObject(init)) { |
| iteratorMethod = getIteratorMethod(init); |
| if (typeof iteratorMethod === 'function') { |
| iterator = iteratorMethod.call(init); |
| while (!(step = iterator.next()).done) { |
| entryIterator = getIterator(anObject(step.value)); |
| if ( |
| (first = entryIterator.next()).done || |
| (second = entryIterator.next()).done || |
| !entryIterator.next().done |
| ) throw TypeError('Expected sequence with length 2'); |
| entries.push({ key: first.value + '', value: second.value + '' }); |
| } |
| } else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' }); |
| } else { |
| parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + ''); |
| } |
| } |
| }; |
| |
| var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype; |
| |
| redefineAll(URLSearchParamsPrototype, { |
| // `URLSearchParams.prototype.appent` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-append |
| append: function append(name, value) { |
| validateArgumentsLength(arguments.length, 2); |
| var state = getInternalParamsState(this); |
| state.entries.push({ key: name + '', value: value + '' }); |
| state.updateURL(); |
| }, |
| // `URLSearchParams.prototype.delete` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-delete |
| 'delete': function (name) { |
| validateArgumentsLength(arguments.length, 1); |
| var state = getInternalParamsState(this); |
| var entries = state.entries; |
| var key = name + ''; |
| var index = 0; |
| while (index < entries.length) { |
| if (entries[index].key === key) entries.splice(index, 1); |
| else index++; |
| } |
| state.updateURL(); |
| }, |
| // `URLSearchParams.prototype.get` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-get |
| get: function get(name) { |
| validateArgumentsLength(arguments.length, 1); |
| var entries = getInternalParamsState(this).entries; |
| var key = name + ''; |
| var index = 0; |
| for (; index < entries.length; index++) { |
| if (entries[index].key === key) return entries[index].value; |
| } |
| return null; |
| }, |
| // `URLSearchParams.prototype.getAll` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-getall |
| getAll: function getAll(name) { |
| validateArgumentsLength(arguments.length, 1); |
| var entries = getInternalParamsState(this).entries; |
| var key = name + ''; |
| var result = []; |
| var index = 0; |
| for (; index < entries.length; index++) { |
| if (entries[index].key === key) result.push(entries[index].value); |
| } |
| return result; |
| }, |
| // `URLSearchParams.prototype.has` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-has |
| has: function has(name) { |
| validateArgumentsLength(arguments.length, 1); |
| var entries = getInternalParamsState(this).entries; |
| var key = name + ''; |
| var index = 0; |
| while (index < entries.length) { |
| if (entries[index++].key === key) return true; |
| } |
| return false; |
| }, |
| // `URLSearchParams.prototype.set` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-set |
| set: function set(name, value) { |
| validateArgumentsLength(arguments.length, 1); |
| var state = getInternalParamsState(this); |
| var entries = state.entries; |
| var found = false; |
| var key = name + ''; |
| var val = value + ''; |
| var index = 0; |
| var entry; |
| for (; index < entries.length; index++) { |
| entry = entries[index]; |
| if (entry.key === key) { |
| if (found) entries.splice(index--, 1); |
| else { |
| found = true; |
| entry.value = val; |
| } |
| } |
| } |
| if (!found) entries.push({ key: key, value: val }); |
| state.updateURL(); |
| }, |
| // `URLSearchParams.prototype.sort` method |
| // https://url.spec.whatwg.org/#dom-urlsearchparams-sort |
| sort: function sort() { |
| var state = getInternalParamsState(this); |
| var entries = state.entries; |
| // Array#sort is not stable in some engines |
| var slice = entries.slice(); |
| var entry, entriesIndex, sliceIndex; |
| entries.length = 0; |
| for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) { |
| entry = slice[sliceIndex]; |
| for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) { |
| if (entries[entriesIndex].key > entry.key) { |
| entries.splice(entriesIndex, 0, entry); |
| break; |
| } |
| } |
| if (entriesIndex === sliceIndex) entries.push(entry); |
| } |
| state.updateURL(); |
| }, |
| // `URLSearchParams.prototype.forEach` method |
| forEach: function forEach(callback /* , thisArg */) { |
| var entries = getInternalParamsState(this).entries; |
| var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3); |
| var index = 0; |
| var entry; |
| while (index < entries.length) { |
| entry = entries[index++]; |
| boundFunction(entry.value, entry.key, this); |
| } |
| }, |
| // `URLSearchParams.prototype.keys` method |
| keys: function keys() { |
| return new URLSearchParamsIterator(this, 'keys'); |
| }, |
| // `URLSearchParams.prototype.values` method |
| values: function values() { |
| return new URLSearchParamsIterator(this, 'values'); |
| }, |
| // `URLSearchParams.prototype.entries` method |
| entries: function entries() { |
| return new URLSearchParamsIterator(this, 'entries'); |
| } |
| }, { enumerable: true }); |
| |
| // `URLSearchParams.prototype[@@iterator]` method |
| redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries); |
| |
| // `URLSearchParams.prototype.toString` method |
| // https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior |
| redefine(URLSearchParamsPrototype, 'toString', function toString() { |
| var entries = getInternalParamsState(this).entries; |
| var result = []; |
| var index = 0; |
| var entry; |
| while (index < entries.length) { |
| entry = entries[index++]; |
| result.push(serialize(entry.key) + '=' + serialize(entry.value)); |
| } return result.join('&'); |
| }, { enumerable: true }); |
| |
| setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS); |
| |
| $({ global: true, forced: !USE_NATIVE_URL }, { |
| URLSearchParams: URLSearchParamsConstructor |
| }); |
| |
| module.exports = { |
| URLSearchParams: URLSearchParamsConstructor, |
| getState: getInternalParamsState |
| }; |
| |
| },{"../internals/an-instance":12,"../internals/an-object":13,"../internals/bind-context":26,"../internals/create-iterator-constructor":38,"../internals/export":49,"../internals/get-iterator":61,"../internals/get-iterator-method":60,"../internals/has":63,"../internals/internal-state":72,"../internals/is-object":77,"../internals/native-url":89,"../internals/redefine":117,"../internals/redefine-all":116,"../internals/set-to-string-tag":125,"../internals/well-known-symbol":150,"../modules/es.array.iterator":170}],361:[function(require,module,exports){ |
| 'use strict'; |
| // TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` |
| require('../modules/es.string.iterator'); |
| var $ = require('../internals/export'); |
| var DESCRIPTORS = require('../internals/descriptors'); |
| var USE_NATIVE_URL = require('../internals/native-url'); |
| var global = require('../internals/global'); |
| var defineProperties = require('../internals/object-define-properties'); |
| var redefine = require('../internals/redefine'); |
| var anInstance = require('../internals/an-instance'); |
| var has = require('../internals/has'); |
| var assign = require('../internals/object-assign'); |
| var arrayFrom = require('../internals/array-from'); |
| var codeAt = require('../internals/string-multibyte').codeAt; |
| var toASCII = require('../internals/punycode-to-ascii'); |
| var setToStringTag = require('../internals/set-to-string-tag'); |
| var URLSearchParamsModule = require('../modules/web.url-search-params'); |
| var InternalStateModule = require('../internals/internal-state'); |
| |
| var NativeURL = global.URL; |
| var URLSearchParams = URLSearchParamsModule.URLSearchParams; |
| var getInternalSearchParamsState = URLSearchParamsModule.getState; |
| var setInternalState = InternalStateModule.set; |
| var getInternalURLState = InternalStateModule.getterFor('URL'); |
| var floor = Math.floor; |
| var pow = Math.pow; |
| |
| var INVALID_AUTHORITY = 'Invalid authority'; |
| var INVALID_SCHEME = 'Invalid scheme'; |
| var INVALID_HOST = 'Invalid host'; |
| var INVALID_PORT = 'Invalid port'; |
| |
| var ALPHA = /[A-Za-z]/; |
| var ALPHANUMERIC = /[\d+\-.A-Za-z]/; |
| var DIGIT = /\d/; |
| var HEX_START = /^(0x|0X)/; |
| var OCT = /^[0-7]+$/; |
| var DEC = /^\d+$/; |
| var HEX = /^[\dA-Fa-f]+$/; |
| // eslint-disable-next-line no-control-regex |
| var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/; |
| // eslint-disable-next-line no-control-regex |
| var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/; |
| // eslint-disable-next-line no-control-regex |
| var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g; |
| // eslint-disable-next-line no-control-regex |
| var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g; |
| var EOF; |
| |
| var parseHost = function (url, input) { |
| var result, codePoints, index; |
| if (input.charAt(0) == '[') { |
| if (input.charAt(input.length - 1) != ']') return INVALID_HOST; |
| result = parseIPv6(input.slice(1, -1)); |
| if (!result) return INVALID_HOST; |
| url.host = result; |
| // opaque host |
| } else if (!isSpecial(url)) { |
| if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST; |
| result = ''; |
| codePoints = arrayFrom(input); |
| for (index = 0; index < codePoints.length; index++) { |
| result += percentEncode(codePoints[index], C0ControlPercentEncodeSet); |
| } |
| url.host = result; |
| } else { |
| input = toASCII(input); |
| if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST; |
| result = parseIPv4(input); |
| if (result === null) return INVALID_HOST; |
| url.host = result; |
| } |
| }; |
| |
| var parseIPv4 = function (input) { |
| var parts = input.split('.'); |
| var partsLength, numbers, index, part, radix, number, ipv4; |
| if (parts.length && parts[parts.length - 1] == '') { |
| parts.pop(); |
| } |
| partsLength = parts.length; |
| if (partsLength > 4) return input; |
| numbers = []; |
| for (index = 0; index < partsLength; index++) { |
| part = parts[index]; |
| if (part == '') return input; |
| radix = 10; |
| if (part.length > 1 && part.charAt(0) == '0') { |
| radix = HEX_START.test(part) ? 16 : 8; |
| part = part.slice(radix == 8 ? 1 : 2); |
| } |
| if (part === '') { |
| number = 0; |
| } else { |
| if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input; |
| number = parseInt(part, radix); |
| } |
| numbers.push(number); |
| } |
| for (index = 0; index < partsLength; index++) { |
| number = numbers[index]; |
| if (index == partsLength - 1) { |
| if (number >= pow(256, 5 - partsLength)) return null; |
| } else if (number > 255) return null; |
| } |
| ipv4 = numbers.pop(); |
| for (index = 0; index < numbers.length; index++) { |
| ipv4 += numbers[index] * pow(256, 3 - index); |
| } |
| return ipv4; |
| }; |
| |
| // eslint-disable-next-line max-statements |
| var parseIPv6 = function (input) { |
| var address = [0, 0, 0, 0, 0, 0, 0, 0]; |
| var pieceIndex = 0; |
| var compress = null; |
| var pointer = 0; |
| var value, length, numbersSeen, ipv4Piece, number, swaps, swap; |
| |
| var char = function () { |
| return input.charAt(pointer); |
| }; |
| |
| if (char() == ':') { |
| if (input.charAt(1) != ':') return; |
| pointer += 2; |
| pieceIndex++; |
| compress = pieceIndex; |
| } |
| while (char()) { |
| if (pieceIndex == 8) return; |
| if (char() == ':') { |
| if (compress !== null) return; |
| pointer++; |
| pieceIndex++; |
| compress = pieceIndex; |
| continue; |
| } |
| value = length = 0; |
| while (length < 4 && HEX.test(char())) { |
| value = value * 16 + parseInt(char(), 16); |
| pointer++; |
| length++; |
| } |
| if (char() == '.') { |
| if (length == 0) return; |
| pointer -= length; |
| if (pieceIndex > 6) return; |
| numbersSeen = 0; |
| while (char()) { |
| ipv4Piece = null; |
| if (numbersSeen > 0) { |
| if (char() == '.' && numbersSeen < 4) pointer++; |
| else return; |
| } |
| if (!DIGIT.test(char())) return; |
| while (DIGIT.test(char())) { |
| number = parseInt(char(), 10); |
| if (ipv4Piece === null) ipv4Piece = number; |
| else if (ipv4Piece == 0) return; |
| else ipv4Piece = ipv4Piece * 10 + number; |
| if (ipv4Piece > 255) return; |
| pointer++; |
| } |
| address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; |
| numbersSeen++; |
| if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++; |
| } |
| if (numbersSeen != 4) return; |
| break; |
| } else if (char() == ':') { |
| pointer++; |
| if (!char()) return; |
| } else if (char()) return; |
| address[pieceIndex++] = value; |
| } |
| if (compress !== null) { |
| swaps = pieceIndex - compress; |
| pieceIndex = 7; |
| while (pieceIndex != 0 && swaps > 0) { |
| swap = address[pieceIndex]; |
| address[pieceIndex--] = address[compress + swaps - 1]; |
| address[compress + --swaps] = swap; |
| } |
| } else if (pieceIndex != 8) return; |
| return address; |
| }; |
| |
| var findLongestZeroSequence = function (ipv6) { |
| var maxIndex = null; |
| var maxLength = 1; |
| var currStart = null; |
| var currLength = 0; |
| var index = 0; |
| for (; index < 8; index++) { |
| if (ipv6[index] !== 0) { |
| if (currLength > maxLength) { |
| maxIndex = currStart; |
| maxLength = currLength; |
| } |
| currStart = null; |
| currLength = 0; |
| } else { |
| if (currStart === null) currStart = index; |
| ++currLength; |
| } |
| } |
| if (currLength > maxLength) { |
| maxIndex = currStart; |
| maxLength = currLength; |
| } |
| return maxIndex; |
| }; |
| |
| var serializeHost = function (host) { |
| var result, index, compress, ignore0; |
| // ipv4 |
| if (typeof host == 'number') { |
| result = []; |
| for (index = 0; index < 4; index++) { |
| result.unshift(host % 256); |
| host = floor(host / 256); |
| } return result.join('.'); |
| // ipv6 |
| } else if (typeof host == 'object') { |
| result = ''; |
| compress = findLongestZeroSequence(host); |
| for (index = 0; index < 8; index++) { |
| if (ignore0 && host[index] === 0) continue; |
| if (ignore0) ignore0 = false; |
| if (compress === index) { |
| result += index ? ':' : '::'; |
| ignore0 = true; |
| } else { |
| result += host[index].toString(16); |
| if (index < 7) result += ':'; |
| } |
| } |
| return '[' + result + ']'; |
| } return host; |
| }; |
| |
| var C0ControlPercentEncodeSet = {}; |
| var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, { |
| ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1 |
| }); |
| var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, { |
| '#': 1, '?': 1, '{': 1, '}': 1 |
| }); |
| var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, { |
| '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1 |
| }); |
| |
| var percentEncode = function (char, set) { |
| var code = codeAt(char, 0); |
| return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char); |
| }; |
| |
| var specialSchemes = { |
| ftp: 21, |
| file: null, |
| gopher: 70, |
| http: 80, |
| https: 443, |
| ws: 80, |
| wss: 443 |
| }; |
| |
| var isSpecial = function (url) { |
| return has(specialSchemes, url.scheme); |
| }; |
| |
| var includesCredentials = function (url) { |
| return url.username != '' || url.password != ''; |
| }; |
| |
| var cannotHaveUsernamePasswordPort = function (url) { |
| return !url.host || url.cannotBeABaseURL || url.scheme == 'file'; |
| }; |
| |
| var isWindowsDriveLetter = function (string, normalized) { |
| var second; |
| return string.length == 2 && ALPHA.test(string.charAt(0)) |
| && ((second = string.charAt(1)) == ':' || (!normalized && second == '|')); |
| }; |
| |
| var startsWithWindowsDriveLetter = function (string) { |
| var third; |
| return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && ( |
| string.length == 2 || |
| ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#') |
| ); |
| }; |
| |
| var shortenURLsPath = function (url) { |
| var path = url.path; |
| var pathSize = path.length; |
| if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) { |
| path.pop(); |
| } |
| }; |
| |
| var isSingleDot = function (segment) { |
| return segment === '.' || segment.toLowerCase() === '%2e'; |
| }; |
| |
| var isDoubleDot = function (segment) { |
| segment = segment.toLowerCase(); |
| return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e'; |
| }; |
| |
| // States: |
| var SCHEME_START = {}; |
| var SCHEME = {}; |
| var NO_SCHEME = {}; |
| var SPECIAL_RELATIVE_OR_AUTHORITY = {}; |
| var PATH_OR_AUTHORITY = {}; |
| var RELATIVE = {}; |
| var RELATIVE_SLASH = {}; |
| var SPECIAL_AUTHORITY_SLASHES = {}; |
| var SPECIAL_AUTHORITY_IGNORE_SLASHES = {}; |
| var AUTHORITY = {}; |
| var HOST = {}; |
| var HOSTNAME = {}; |
| var PORT = {}; |
| var FILE = {}; |
| var FILE_SLASH = {}; |
| var FILE_HOST = {}; |
| var PATH_START = {}; |
| var PATH = {}; |
| var CANNOT_BE_A_BASE_URL_PATH = {}; |
| var QUERY = {}; |
| var FRAGMENT = {}; |
| |
| // eslint-disable-next-line max-statements |
| var parseURL = function (url, input, stateOverride, base) { |
| var state = stateOverride || SCHEME_START; |
| var pointer = 0; |
| var buffer = ''; |
| var seenAt = false; |
| var seenBracket = false; |
| var seenPasswordToken = false; |
| var codePoints, char, bufferCodePoints, failure; |
| |
| if (!stateOverride) { |
| url.scheme = ''; |
| url.username = ''; |
| url.password = ''; |
| url.host = null; |
| url.port = null; |
| url.path = []; |
| url.query = null; |
| url.fragment = null; |
| url.cannotBeABaseURL = false; |
| input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, ''); |
| } |
| |
| input = input.replace(TAB_AND_NEW_LINE, ''); |
| |
| codePoints = arrayFrom(input); |
| |
| while (pointer <= codePoints.length) { |
| char = codePoints[pointer]; |
| switch (state) { |
| case SCHEME_START: |
| if (char && ALPHA.test(char)) { |
| buffer += char.toLowerCase(); |
| state = SCHEME; |
| } else if (!stateOverride) { |
| state = NO_SCHEME; |
| continue; |
| } else return INVALID_SCHEME; |
| break; |
| |
| case SCHEME: |
| if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) { |
| buffer += char.toLowerCase(); |
| } else if (char == ':') { |
| if (stateOverride && ( |
| (isSpecial(url) != has(specialSchemes, buffer)) || |
| (buffer == 'file' && (includesCredentials(url) || url.port !== null)) || |
| (url.scheme == 'file' && !url.host) |
| )) return; |
| url.scheme = buffer; |
| if (stateOverride) { |
| if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null; |
| return; |
| } |
| buffer = ''; |
| if (url.scheme == 'file') { |
| state = FILE; |
| } else if (isSpecial(url) && base && base.scheme == url.scheme) { |
| state = SPECIAL_RELATIVE_OR_AUTHORITY; |
| } else if (isSpecial(url)) { |
| state = SPECIAL_AUTHORITY_SLASHES; |
| } else if (codePoints[pointer + 1] == '/') { |
| state = PATH_OR_AUTHORITY; |
| pointer++; |
| } else { |
| url.cannotBeABaseURL = true; |
| url.path.push(''); |
| state = CANNOT_BE_A_BASE_URL_PATH; |
| } |
| } else if (!stateOverride) { |
| buffer = ''; |
| state = NO_SCHEME; |
| pointer = 0; |
| continue; |
| } else return INVALID_SCHEME; |
| break; |
| |
| case NO_SCHEME: |
| if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME; |
| if (base.cannotBeABaseURL && char == '#') { |
| url.scheme = base.scheme; |
| url.path = base.path.slice(); |
| url.query = base.query; |
| url.fragment = ''; |
| url.cannotBeABaseURL = true; |
| state = FRAGMENT; |
| break; |
| } |
| state = base.scheme == 'file' ? FILE : RELATIVE; |
| continue; |
| |
| case SPECIAL_RELATIVE_OR_AUTHORITY: |
| if (char == '/' && codePoints[pointer + 1] == '/') { |
| state = SPECIAL_AUTHORITY_IGNORE_SLASHES; |
| pointer++; |
| } else { |
| state = RELATIVE; |
| continue; |
| } break; |
| |
| case PATH_OR_AUTHORITY: |
| if (char == '/') { |
| state = AUTHORITY; |
| break; |
| } else { |
| state = PATH; |
| continue; |
| } |
| |
| case RELATIVE: |
| url.scheme = base.scheme; |
| if (char == EOF) { |
| url.username = base.username; |
| url.password = base.password; |
| url.host = base.host; |
| url.port = base.port; |
| url.path = base.path.slice(); |
| url.query = base.query; |
| } else if (char == '/' || (char == '\\' && isSpecial(url))) { |
| state = RELATIVE_SLASH; |
| } else if (char == '?') { |
| url.username = base.username; |
| url.password = base.password; |
| url.host = base.host; |
| url.port = base.port; |
| url.path = base.path.slice(); |
| url.query = ''; |
| state = QUERY; |
| } else if (char == '#') { |
| url.username = base.username; |
| url.password = base.password; |
| url.host = base.host; |
| url.port = base.port; |
| url.path = base.path.slice(); |
| url.query = base.query; |
| url.fragment = ''; |
| state = FRAGMENT; |
| } else { |
| url.username = base.username; |
| url.password = base.password; |
| url.host = base.host; |
| url.port = base.port; |
| url.path = base.path.slice(); |
| url.path.pop(); |
| state = PATH; |
| continue; |
| } break; |
| |
| case RELATIVE_SLASH: |
| if (isSpecial(url) && (char == '/' || char == '\\')) { |
| state = SPECIAL_AUTHORITY_IGNORE_SLASHES; |
| } else if (char == '/') { |
| state = AUTHORITY; |
| } else { |
| url.username = base.username; |
| url.password = base.password; |
| url.host = base.host; |
| url.port = base.port; |
| state = PATH; |
| continue; |
| } break; |
| |
| case SPECIAL_AUTHORITY_SLASHES: |
| state = SPECIAL_AUTHORITY_IGNORE_SLASHES; |
| if (char != '/' || buffer.charAt(pointer + 1) != '/') continue; |
| pointer++; |
| break; |
| |
| case SPECIAL_AUTHORITY_IGNORE_SLASHES: |
| if (char != '/' && char != '\\') { |
| state = AUTHORITY; |
| continue; |
| } break; |
| |
| case AUTHORITY: |
| if (char == '@') { |
| if (seenAt) buffer = '%40' + buffer; |
| seenAt = true; |
| bufferCodePoints = arrayFrom(buffer); |
| for (var i = 0; i < bufferCodePoints.length; i++) { |
| var codePoint = bufferCodePoints[i]; |
| if (codePoint == ':' && !seenPasswordToken) { |
| seenPasswordToken = true; |
| continue; |
| } |
| var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet); |
| if (seenPasswordToken) url.password += encodedCodePoints; |
| else url.username += encodedCodePoints; |
| } |
| buffer = ''; |
| } else if ( |
| char == EOF || char == '/' || char == '?' || char == '#' || |
| (char == '\\' && isSpecial(url)) |
| ) { |
| if (seenAt && buffer == '') return INVALID_AUTHORITY; |
| pointer -= arrayFrom(buffer).length + 1; |
| buffer = ''; |
| state = HOST; |
| } else buffer += char; |
| break; |
| |
| case HOST: |
| case HOSTNAME: |
| if (stateOverride && url.scheme == 'file') { |
| state = FILE_HOST; |
| continue; |
| } else if (char == ':' && !seenBracket) { |
| if (buffer == '') return INVALID_HOST; |
| failure = parseHost(url, buffer); |
| if (failure) return failure; |
| buffer = ''; |
| state = PORT; |
| if (stateOverride == HOSTNAME) return; |
| } else if ( |
| char == EOF || char == '/' || char == '?' || char == '#' || |
| (char == '\\' && isSpecial(url)) |
| ) { |
| if (isSpecial(url) && buffer == '') return INVALID_HOST; |
| if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return; |
| failure = parseHost(url, buffer); |
| if (failure) return failure; |
| buffer = ''; |
| state = PATH_START; |
| if (stateOverride) return; |
| continue; |
| } else { |
| if (char == '[') seenBracket = true; |
| else if (char == ']') seenBracket = false; |
| buffer += char; |
| } break; |
| |
| case PORT: |
| if (DIGIT.test(char)) { |
| buffer += char; |
| } else if ( |
| char == EOF || char == '/' || char == '?' || char == '#' || |
| (char == '\\' && isSpecial(url)) || |
| stateOverride |
| ) { |
| if (buffer != '') { |
| var port = parseInt(buffer, 10); |
| if (port > 0xFFFF) return INVALID_PORT; |
| url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port; |
| buffer = ''; |
| } |
| if (stateOverride) return; |
| state = PATH_START; |
| continue; |
| } else return INVALID_PORT; |
| break; |
| |
| case FILE: |
| url.scheme = 'file'; |
| if (char == '/' || char == '\\') state = FILE_SLASH; |
| else if (base && base.scheme == 'file') { |
| if (char == EOF) { |
| url.host = base.host; |
| url.path = base.path.slice(); |
| url.query = base.query; |
| } else if (char == '?') { |
| url.host = base.host; |
| url.path = base.path.slice(); |
| url.query = ''; |
| state = QUERY; |
| } else if (char == '#') { |
| url.host = base.host; |
| url.path = base.path.slice(); |
| url.query = base.query; |
| url.fragment = ''; |
| state = FRAGMENT; |
| } else { |
| if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { |
| url.host = base.host; |
| url.path = base.path.slice(); |
| shortenURLsPath(url); |
| } |
| state = PATH; |
| continue; |
| } |
| } else { |
| state = PATH; |
| continue; |
| } break; |
| |
| case FILE_SLASH: |
| if (char == '/' || char == '\\') { |
| state = FILE_HOST; |
| break; |
| } |
| if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { |
| if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]); |
| else url.host = base.host; |
| } |
| state = PATH; |
| continue; |
| |
| case FILE_HOST: |
| if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') { |
| if (!stateOverride && isWindowsDriveLetter(buffer)) { |
| state = PATH; |
| } else if (buffer == '') { |
| url.host = ''; |
| if (stateOverride) return; |
| state = PATH_START; |
| } else { |
| failure = parseHost(url, buffer); |
| if (failure) return failure; |
| if (url.host == 'localhost') url.host = ''; |
| if (stateOverride) return; |
| buffer = ''; |
| state = PATH_START; |
| } continue; |
| } else buffer += char; |
| break; |
| |
| case PATH_START: |
| if (isSpecial(url)) { |
| state = PATH; |
| if (char != '/' && char != '\\') continue; |
| } else if (!stateOverride && char == '?') { |
| url.query = ''; |
| state = QUERY; |
| } else if (!stateOverride && char == '#') { |
| url.fragment = ''; |
| state = FRAGMENT; |
| } else if (char != EOF) { |
| state = PATH; |
| if (char != '/') continue; |
| } break; |
| |
| case PATH: |
| if ( |
| char == EOF || char == '/' || |
| (char == '\\' && isSpecial(url)) || |
| (!stateOverride && (char == '?' || char == '#')) |
| ) { |
| if (isDoubleDot(buffer)) { |
| shortenURLsPath(url); |
| if (char != '/' && !(char == '\\' && isSpecial(url))) { |
| url.path.push(''); |
| } |
| } else if (isSingleDot(buffer)) { |
| if (char != '/' && !(char == '\\' && isSpecial(url))) { |
| url.path.push(''); |
| } |
| } else { |
| if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) { |
| if (url.host) url.host = ''; |
| buffer = buffer.charAt(0) + ':'; // normalize windows drive letter |
| } |
| url.path.push(buffer); |
| } |
| buffer = ''; |
| if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) { |
| while (url.path.length > 1 && url.path[0] === '') { |
| url.path.shift(); |
| } |
| } |
| if (char == '?') { |
| url.query = ''; |
| state = QUERY; |
| } else if (char == '#') { |
| url.fragment = ''; |
| state = FRAGMENT; |
| } |
| } else { |
| buffer += percentEncode(char, pathPercentEncodeSet); |
| } break; |
| |
| case CANNOT_BE_A_BASE_URL_PATH: |
| if (char == '?') { |
| url.query = ''; |
| state = QUERY; |
| } else if (char == '#') { |
| url.fragment = ''; |
| state = FRAGMENT; |
| } else if (char != EOF) { |
| url.path[0] += percentEncode(char, C0ControlPercentEncodeSet); |
| } break; |
| |
| case QUERY: |
| if (!stateOverride && char == '#') { |
| url.fragment = ''; |
| state = FRAGMENT; |
| } else if (char != EOF) { |
| if (char == "'" && isSpecial(url)) url.query += '%27'; |
| else if (char == '#') url.query += '%23'; |
| else url.query += percentEncode(char, C0ControlPercentEncodeSet); |
| } break; |
| |
| case FRAGMENT: |
| if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet); |
| break; |
| } |
| |
| pointer++; |
| } |
| }; |
| |
| // `URL` constructor |
| // https://url.spec.whatwg.org/#url-class |
| var URLConstructor = function URL(url /* , base */) { |
| var that = anInstance(this, URLConstructor, 'URL'); |
| var base = arguments.length > 1 ? arguments[1] : undefined; |
| var urlString = String(url); |
| var state = setInternalState(that, { type: 'URL' }); |
| var baseState, failure; |
| if (base !== undefined) { |
| if (base instanceof URLConstructor) baseState = getInternalURLState(base); |
| else { |
| failure = parseURL(baseState = {}, String(base)); |
| if (failure) throw TypeError(failure); |
| } |
| } |
| failure = parseURL(state, urlString, null, baseState); |
| if (failure) throw TypeError(failure); |
| var searchParams = state.searchParams = new URLSearchParams(); |
| var searchParamsState = getInternalSearchParamsState(searchParams); |
| searchParamsState.updateSearchParams(state.query); |
| searchParamsState.updateURL = function () { |
| state.query = String(searchParams) || null; |
| }; |
| if (!DESCRIPTORS) { |
| that.href = serializeURL.call(that); |
| that.origin = getOrigin.call(that); |
| that.protocol = getProtocol.call(that); |
| that.username = getUsername.call(that); |
| that.password = getPassword.call(that); |
| that.host = getHost.call(that); |
| that.hostname = getHostname.call(that); |
| that.port = getPort.call(that); |
| that.pathname = getPathname.call(that); |
| that.search = getSearch.call(that); |
| that.searchParams = getSearchParams.call(that); |
| that.hash = getHash.call(that); |
| } |
| }; |
| |
| var URLPrototype = URLConstructor.prototype; |
| |
| var serializeURL = function () { |
| var url = getInternalURLState(this); |
| var scheme = url.scheme; |
| var username = url.username; |
| var password = url.password; |
| var host = url.host; |
| var port = url.port; |
| var path = url.path; |
| var query = url.query; |
| var fragment = url.fragment; |
| var output = scheme + ':'; |
| if (host !== null) { |
| output += '//'; |
| if (includesCredentials(url)) { |
| output += username + (password ? ':' + password : '') + '@'; |
| } |
| output += serializeHost(host); |
| if (port !== null) output += ':' + port; |
| } else if (scheme == 'file') output += '//'; |
| output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; |
| if (query !== null) output += '?' + query; |
| if (fragment !== null) output += '#' + fragment; |
| return output; |
| }; |
| |
| var getOrigin = function () { |
| var url = getInternalURLState(this); |
| var scheme = url.scheme; |
| var port = url.port; |
| if (scheme == 'blob') try { |
| return new URL(scheme.path[0]).origin; |
| } catch (error) { |
| return 'null'; |
| } |
| if (scheme == 'file' || !isSpecial(url)) return 'null'; |
| return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : ''); |
| }; |
| |
| var getProtocol = function () { |
| return getInternalURLState(this).scheme + ':'; |
| }; |
| |
| var getUsername = function () { |
| return getInternalURLState(this).username; |
| }; |
| |
| var getPassword = function () { |
| return getInternalURLState(this).password; |
| }; |
| |
| var getHost = function () { |
| var url = getInternalURLState(this); |
| var host = url.host; |
| var port = url.port; |
| return host === null ? '' |
| : port === null ? serializeHost(host) |
| : serializeHost(host) + ':' + port; |
| }; |
| |
| var getHostname = function () { |
| var host = getInternalURLState(this).host; |
| return host === null ? '' : serializeHost(host); |
| }; |
| |
| var getPort = function () { |
| var port = getInternalURLState(this).port; |
| return port === null ? '' : String(port); |
| }; |
| |
| var getPathname = function () { |
| var url = getInternalURLState(this); |
| var path = url.path; |
| return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; |
| }; |
| |
| var getSearch = function () { |
| var query = getInternalURLState(this).query; |
| return query ? '?' + query : ''; |
| }; |
| |
| var getSearchParams = function () { |
| return getInternalURLState(this).searchParams; |
| }; |
| |
| var getHash = function () { |
| var fragment = getInternalURLState(this).fragment; |
| return fragment ? '#' + fragment : ''; |
| }; |
| |
| var accessorDescriptor = function (getter, setter) { |
| return { get: getter, set: setter, configurable: true, enumerable: true }; |
| }; |
| |
| if (DESCRIPTORS) { |
| defineProperties(URLPrototype, { |
| // `URL.prototype.href` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-href |
| href: accessorDescriptor(serializeURL, function (href) { |
| var url = getInternalURLState(this); |
| var urlString = String(href); |
| var failure = parseURL(url, urlString); |
| if (failure) throw TypeError(failure); |
| getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); |
| }), |
| // `URL.prototype.origin` getter |
| // https://url.spec.whatwg.org/#dom-url-origin |
| origin: accessorDescriptor(getOrigin), |
| // `URL.prototype.protocol` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-protocol |
| protocol: accessorDescriptor(getProtocol, function (protocol) { |
| var url = getInternalURLState(this); |
| parseURL(url, String(protocol) + ':', SCHEME_START); |
| }), |
| // `URL.prototype.username` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-username |
| username: accessorDescriptor(getUsername, function (username) { |
| var url = getInternalURLState(this); |
| var codePoints = arrayFrom(String(username)); |
| if (cannotHaveUsernamePasswordPort(url)) return; |
| url.username = ''; |
| for (var i = 0; i < codePoints.length; i++) { |
| url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet); |
| } |
| }), |
| // `URL.prototype.password` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-password |
| password: accessorDescriptor(getPassword, function (password) { |
| var url = getInternalURLState(this); |
| var codePoints = arrayFrom(String(password)); |
| if (cannotHaveUsernamePasswordPort(url)) return; |
| url.password = ''; |
| for (var i = 0; i < codePoints.length; i++) { |
| url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet); |
| } |
| }), |
| // `URL.prototype.host` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-host |
| host: accessorDescriptor(getHost, function (host) { |
| var url = getInternalURLState(this); |
| if (url.cannotBeABaseURL) return; |
| parseURL(url, String(host), HOST); |
| }), |
| // `URL.prototype.hostname` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-hostname |
| hostname: accessorDescriptor(getHostname, function (hostname) { |
| var url = getInternalURLState(this); |
| if (url.cannotBeABaseURL) return; |
| parseURL(url, String(hostname), HOSTNAME); |
| }), |
| // `URL.prototype.port` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-port |
| port: accessorDescriptor(getPort, function (port) { |
| var url = getInternalURLState(this); |
| if (cannotHaveUsernamePasswordPort(url)) return; |
| port = String(port); |
| if (port == '') url.port = null; |
| else parseURL(url, port, PORT); |
| }), |
| // `URL.prototype.pathname` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-pathname |
| pathname: accessorDescriptor(getPathname, function (pathname) { |
| var url = getInternalURLState(this); |
| if (url.cannotBeABaseURL) return; |
| url.path = []; |
| parseURL(url, pathname + '', PATH_START); |
| }), |
| // `URL.prototype.search` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-search |
| search: accessorDescriptor(getSearch, function (search) { |
| var url = getInternalURLState(this); |
| search = String(search); |
| if (search == '') { |
| url.query = null; |
| } else { |
| if ('?' == search.charAt(0)) search = search.slice(1); |
| url.query = ''; |
| parseURL(url, search, QUERY); |
| } |
| getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); |
| }), |
| // `URL.prototype.searchParams` getter |
| // https://url.spec.whatwg.org/#dom-url-searchparams |
| searchParams: accessorDescriptor(getSearchParams), |
| // `URL.prototype.hash` accessors pair |
| // https://url.spec.whatwg.org/#dom-url-hash |
| hash: accessorDescriptor(getHash, function (hash) { |
| var url = getInternalURLState(this); |
| hash = String(hash); |
| if (hash == '') { |
| url.fragment = null; |
| return; |
| } |
| if ('#' == hash.charAt(0)) hash = hash.slice(1); |
| url.fragment = ''; |
| parseURL(url, hash, FRAGMENT); |
| }) |
| }); |
| } |
| |
| // `URL.prototype.toJSON` method |
| // https://url.spec.whatwg.org/#dom-url-tojson |
| redefine(URLPrototype, 'toJSON', function toJSON() { |
| return serializeURL.call(this); |
| }, { enumerable: true }); |
| |
| // `URL.prototype.toString` method |
| // https://url.spec.whatwg.org/#URL-stringification-behavior |
| redefine(URLPrototype, 'toString', function toString() { |
| return serializeURL.call(this); |
| }, { enumerable: true }); |
| |
| if (NativeURL) { |
| var nativeCreateObjectURL = NativeURL.createObjectURL; |
| var nativeRevokeObjectURL = NativeURL.revokeObjectURL; |
| // `URL.createObjectURL` method |
| // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL |
| // eslint-disable-next-line no-unused-vars |
| if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) { |
| return nativeCreateObjectURL.apply(NativeURL, arguments); |
| }); |
| // `URL.revokeObjectURL` method |
| // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL |
| // eslint-disable-next-line no-unused-vars |
| if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) { |
| return nativeRevokeObjectURL.apply(NativeURL, arguments); |
| }); |
| } |
| |
| setToStringTag(URLConstructor, 'URL'); |
| |
| $({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, { |
| URL: URLConstructor |
| }); |
| |
| },{"../internals/an-instance":12,"../internals/array-from":19,"../internals/descriptors":45,"../internals/export":49,"../internals/global":62,"../internals/has":63,"../internals/internal-state":72,"../internals/native-url":89,"../internals/object-assign":94,"../internals/object-define-properties":96,"../internals/punycode-to-ascii":115,"../internals/redefine":117,"../internals/set-to-string-tag":125,"../internals/string-multibyte":130,"../modules/es.string.iterator":285,"../modules/web.url-search-params":360}],362:[function(require,module,exports){ |
| 'use strict'; |
| var $ = require('../internals/export'); |
| |
| // `URL.prototype.toJSON` method |
| // https://url.spec.whatwg.org/#dom-url-tojson |
| $({ target: 'URL', proto: true, enumerable: true }, { |
| toJSON: function toJSON() { |
| return URL.prototype.toString.call(this); |
| } |
| }); |
| |
| },{"../internals/export":49}],363:[function(require,module,exports){ |
| require('../es'); |
| require('../web'); |
| |
| module.exports = require('../internals/path'); |
| |
| },{"../es":7,"../internals/path":112,"../web":364}],364:[function(require,module,exports){ |
| require('../modules/web.dom-collections.for-each'); |
| require('../modules/web.dom-collections.iterator'); |
| require('../modules/web.immediate'); |
| require('../modules/web.queue-microtask'); |
| require('../modules/web.timers'); |
| require('../modules/web.url'); |
| require('../modules/web.url.to-json'); |
| require('../modules/web.url-search-params'); |
| |
| module.exports = require('../internals/path'); |
| |
| },{"../internals/path":112,"../modules/web.dom-collections.for-each":355,"../modules/web.dom-collections.iterator":356,"../modules/web.immediate":357,"../modules/web.queue-microtask":358,"../modules/web.timers":359,"../modules/web.url":361,"../modules/web.url-search-params":360,"../modules/web.url.to-json":362}],365:[function(require,module,exports){ |
| |
| /** |
| * Module dependencies. |
| */ |
| |
| var extend = require('extend'); |
| var encode = require('ent/encode'); |
| var CustomEvent = require('custom-event'); |
| var voidElements = require('void-elements'); |
| |
| /** |
| * Module exports. |
| */ |
| |
| exports = module.exports = serialize; |
| exports.serializeElement = serializeElement; |
| exports.serializeAttribute = serializeAttribute; |
| exports.serializeText = serializeText; |
| exports.serializeComment = serializeComment; |
| exports.serializeDocument = serializeDocument; |
| exports.serializeDoctype = serializeDoctype; |
| exports.serializeDocumentFragment = serializeDocumentFragment; |
| exports.serializeNodeList = serializeNodeList; |
| |
| /** |
| * Serializes any DOM node. Returns a string. |
| * |
| * @param {Node} node - DOM Node to serialize |
| * @param {String} [context] - optional arbitrary "context" string to use (useful for event listeners) |
| * @param {Function} [fn] - optional callback function to use in the "serialize" event for this call |
| * @param {EventTarget} [eventTarget] - optional EventTarget instance to emit the "serialize" event on (defaults to `node`) |
| * return {String} |
| * @public |
| */ |
| |
| function serialize (node, context, fn, eventTarget) { |
| if (!node) return ''; |
| if ('function' === typeof context) { |
| fn = context; |
| context = null; |
| } |
| if (!context) context = null; |
| |
| var rtn; |
| var nodeType = node.nodeType; |
| |
| if (!nodeType && 'number' === typeof node.length) { |
| // assume it's a NodeList or Array of Nodes |
| rtn = exports.serializeNodeList(node, context, fn); |
| } else { |
| |
| if ('function' === typeof fn) { |
| // one-time "serialize" event listener |
| node.addEventListener('serialize', fn, false); |
| } |
| |
| // emit a custom "serialize" event on `node`, in case there |
| // are event listeners for custom serialization of this node |
| var e = new CustomEvent('serialize', { |
| bubbles: true, |
| cancelable: true, |
| detail: { |
| serialize: null, |
| context: context |
| } |
| }); |
| |
| e.serializeTarget = node; |
| |
| var target = eventTarget || node; |
| var cancelled = !target.dispatchEvent(e); |
| |
| // `e.detail.serialize` can be set to a: |
| // String - returned directly |
| // Node - goes through serializer logic instead of `node` |
| // Anything else - get Stringified first, and then returned directly |
| var s = e.detail.serialize; |
| if (s != null) { |
| if ('string' === typeof s) { |
| rtn = s; |
| } else if ('number' === typeof s.nodeType) { |
| // make it go through the serialization logic |
| rtn = serialize(s, context, null, target); |
| } else { |
| rtn = String(s); |
| } |
| } else if (!cancelled) { |
| // default serialization logic |
| switch (nodeType) { |
| case 1 /* element */: |
| rtn = exports.serializeElement(node, context, eventTarget); |
| break; |
| case 2 /* attribute */: |
| rtn = exports.serializeAttribute(node); |
| break; |
| case 3 /* text */: |
| rtn = exports.serializeText(node); |
| break; |
| case 8 /* comment */: |
| rtn = exports.serializeComment(node); |
| break; |
| case 9 /* document */: |
| rtn = exports.serializeDocument(node, context, eventTarget); |
| break; |
| case 10 /* doctype */: |
| rtn = exports.serializeDoctype(node); |
| break; |
| case 11 /* document fragment */: |
| rtn = exports.serializeDocumentFragment(node, context, eventTarget); |
| break; |
| } |
| } |
| |
| if ('function' === typeof fn) { |
| node.removeEventListener('serialize', fn, false); |
| } |
| } |
| |
| return rtn || ''; |
| } |
| |
| /** |
| * Serialize an Attribute node. |
| */ |
| |
| function serializeAttribute (node, opts) { |
| return node.name + '="' + encode(node.value, extend({ |
| named: true |
| }, opts)) + '"'; |
| } |
| |
| /** |
| * Serialize a DOM element. |
| */ |
| |
| function serializeElement (node, context, eventTarget) { |
| var c, i, l; |
| var name = node.nodeName.toLowerCase(); |
| |
| // opening tag |
| var r = '<' + name; |
| |
| // attributes |
| for (i = 0, c = node.attributes, l = c.length; i < l; i++) { |
| r += ' ' + exports.serializeAttribute(c[i]); |
| } |
| |
| r += '>'; |
| |
| // child nodes |
| r += exports.serializeNodeList(node.childNodes, context, null, eventTarget); |
| |
| // closing tag, only for non-void elements |
| if (!voidElements[name]) { |
| r += '</' + name + '>'; |
| } |
| |
| return r; |
| } |
| |
| /** |
| * Serialize a text node. |
| */ |
| |
| function serializeText (node, opts) { |
| return encode(node.nodeValue, extend({ |
| named: true, |
| special: { '<': true, '>': true, '&': true } |
| }, opts)); |
| } |
| |
| /** |
| * Serialize a comment node. |
| */ |
| |
| function serializeComment (node) { |
| return '<!--' + node.nodeValue + '-->'; |
| } |
| |
| /** |
| * Serialize a Document node. |
| */ |
| |
| function serializeDocument (node, context, eventTarget) { |
| return exports.serializeNodeList(node.childNodes, context, null, eventTarget); |
| } |
| |
| /** |
| * Serialize a DOCTYPE node. |
| * See: http://stackoverflow.com/a/10162353 |
| */ |
| |
| function serializeDoctype (node) { |
| var r = '<!DOCTYPE ' + node.name; |
| |
| if (node.publicId) { |
| r += ' PUBLIC "' + node.publicId + '"'; |
| } |
| |
| if (!node.publicId && node.systemId) { |
| r += ' SYSTEM'; |
| } |
| |
| if (node.systemId) { |
| r += ' "' + node.systemId + '"'; |
| } |
| |
| r += '>'; |
| return r; |
| } |
| |
| /** |
| * Serialize a DocumentFragment instance. |
| */ |
| |
| function serializeDocumentFragment (node, context, eventTarget) { |
| return exports.serializeNodeList(node.childNodes, context, null, eventTarget); |
| } |
| |
| /** |
| * Serialize a NodeList/Array of nodes. |
| */ |
| |
| function serializeNodeList (list, context, fn, eventTarget) { |
| var r = ''; |
| for (var i = 0, l = list.length; i < l; i++) { |
| r += serialize(list[i], context, fn, eventTarget); |
| } |
| return r; |
| } |
| |
| },{"custom-event":366,"ent/encode":367,"extend":369,"void-elements":370}],366:[function(require,module,exports){ |
| (function (global){ |
| |
| var NativeCustomEvent = global.CustomEvent; |
| |
| function useNative () { |
| try { |
| var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } }); |
| return 'cat' === p.type && 'bar' === p.detail.foo; |
| } catch (e) { |
| } |
| return false; |
| } |
| |
| /** |
| * Cross-browser `CustomEvent` constructor. |
| * |
| * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent |
| * |
| * @public |
| */ |
| |
| module.exports = useNative() ? NativeCustomEvent : |
| |
| // IE >= 9 |
| 'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) { |
| var e = document.createEvent('CustomEvent'); |
| if (params) { |
| e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail); |
| } else { |
| e.initCustomEvent(type, false, false, void 0); |
| } |
| return e; |
| } : |
| |
| // IE <= 8 |
| function CustomEvent (type, params) { |
| var e = document.createEventObject(); |
| e.type = type; |
| if (params) { |
| e.bubbles = Boolean(params.bubbles); |
| e.cancelable = Boolean(params.cancelable); |
| e.detail = params.detail; |
| } else { |
| e.bubbles = false; |
| e.cancelable = false; |
| e.detail = void 0; |
| } |
| return e; |
| } |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}],367:[function(require,module,exports){ |
| var punycode = require('punycode'); |
| var revEntities = require('./reversed.json'); |
| |
| module.exports = encode; |
| |
| function encode (str, opts) { |
| if (typeof str !== 'string') { |
| throw new TypeError('Expected a String'); |
| } |
| if (!opts) opts = {}; |
| |
| var numeric = true; |
| if (opts.named) numeric = false; |
| if (opts.numeric !== undefined) numeric = opts.numeric; |
| |
| var special = opts.special || { |
| '"': true, "'": true, |
| '<': true, '>': true, |
| '&': true |
| }; |
| |
| var codePoints = punycode.ucs2.decode(str); |
| var chars = []; |
| for (var i = 0; i < codePoints.length; i++) { |
| var cc = codePoints[i]; |
| var c = punycode.ucs2.encode([ cc ]); |
| var e = revEntities[cc]; |
| if (e && (cc >= 127 || special[c]) && !numeric) { |
| chars.push('&' + (/;$/.test(e) ? e : e + ';')); |
| } |
| else if (cc < 32 || cc >= 127 || special[c]) { |
| chars.push('&#' + cc + ';'); |
| } |
| else { |
| chars.push(c); |
| } |
| } |
| return chars.join(''); |
| } |
| |
| },{"./reversed.json":368,"punycode":371}],368:[function(require,module,exports){ |
| module.exports={ |
| "9": "Tab;", |
| "10": "NewLine;", |
| "33": "excl;", |
| "34": "quot;", |
| "35": "num;", |
| "36": "dollar;", |
| "37": "percnt;", |
| "38": "amp;", |
| "39": "apos;", |
| "40": "lpar;", |
| "41": "rpar;", |
| "42": "midast;", |
| "43": "plus;", |
| "44": "comma;", |
| "46": "period;", |
| "47": "sol;", |
| "58": "colon;", |
| "59": "semi;", |
| "60": "lt;", |
| "61": "equals;", |
| "62": "gt;", |
| "63": "quest;", |
| "64": "commat;", |
| "91": "lsqb;", |
| "92": "bsol;", |
| "93": "rsqb;", |
| "94": "Hat;", |
| "95": "UnderBar;", |
| "96": "grave;", |
| "123": "lcub;", |
| "124": "VerticalLine;", |
| "125": "rcub;", |
| "160": "NonBreakingSpace;", |
| "161": "iexcl;", |
| "162": "cent;", |
| "163": "pound;", |
| "164": "curren;", |
| "165": "yen;", |
| "166": "brvbar;", |
| "167": "sect;", |
| "168": "uml;", |
| "169": "copy;", |
| "170": "ordf;", |
| "171": "laquo;", |
| "172": "not;", |
| "173": "shy;", |
| "174": "reg;", |
| "175": "strns;", |
| "176": "deg;", |
| "177": "pm;", |
| "178": "sup2;", |
| "179": "sup3;", |
| "180": "DiacriticalAcute;", |
| "181": "micro;", |
| "182": "para;", |
| "183": "middot;", |
| "184": "Cedilla;", |
| "185": "sup1;", |
| "186": "ordm;", |
| "187": "raquo;", |
| "188": "frac14;", |
| "189": "half;", |
| "190": "frac34;", |
| "191": "iquest;", |
| "192": "Agrave;", |
| "193": "Aacute;", |
| "194": "Acirc;", |
| "195": "Atilde;", |
| "196": "Auml;", |
| "197": "Aring;", |
| "198": "AElig;", |
| "199": "Ccedil;", |
| "200": "Egrave;", |
| "201": "Eacute;", |
| "202": "Ecirc;", |
| "203": "Euml;", |
| "204": "Igrave;", |
| "205": "Iacute;", |
| "206": "Icirc;", |
| "207": "Iuml;", |
| "208": "ETH;", |
| "209": "Ntilde;", |
| "210": "Ograve;", |
| "211": "Oacute;", |
| "212": "Ocirc;", |
| "213": "Otilde;", |
| "214": "Ouml;", |
| "215": "times;", |
| "216": "Oslash;", |
| "217": "Ugrave;", |
| "218": "Uacute;", |
| "219": "Ucirc;", |
| "220": "Uuml;", |
| "221": "Yacute;", |
| "222": "THORN;", |
| "223": "szlig;", |
| "224": "agrave;", |
| "225": "aacute;", |
| "226": "acirc;", |
| "227": "atilde;", |
| "228": "auml;", |
| "229": "aring;", |
| "230": "aelig;", |
| "231": "ccedil;", |
| "232": "egrave;", |
| "233": "eacute;", |
| "234": "ecirc;", |
| "235": "euml;", |
| "236": "igrave;", |
| "237": "iacute;", |
| "238": "icirc;", |
| "239": "iuml;", |
| "240": "eth;", |
| "241": "ntilde;", |
| "242": "ograve;", |
| "243": "oacute;", |
| "244": "ocirc;", |
| "245": "otilde;", |
| "246": "ouml;", |
| "247": "divide;", |
| "248": "oslash;", |
| "249": "ugrave;", |
| "250": "uacute;", |
| "251": "ucirc;", |
| "252": "uuml;", |
| "253": "yacute;", |
| "254": "thorn;", |
| "255": "yuml;", |
| "256": "Amacr;", |
| "257": "amacr;", |
| "258": "Abreve;", |
| "259": "abreve;", |
| "260": "Aogon;", |
| "261": "aogon;", |
| "262": "Cacute;", |
| "263": "cacute;", |
| "264": "Ccirc;", |
| "265": "ccirc;", |
| "266": "Cdot;", |
| "267": "cdot;", |
| "268": "Ccaron;", |
| "269": "ccaron;", |
| "270": "Dcaron;", |
| "271": "dcaron;", |
| "272": "Dstrok;", |
| "273": "dstrok;", |
| "274": "Emacr;", |
| "275": "emacr;", |
| "278": "Edot;", |
| "279": "edot;", |
| "280": "Eogon;", |
| "281": "eogon;", |
| "282": "Ecaron;", |
| "283": "ecaron;", |
| "284": "Gcirc;", |
| "285": "gcirc;", |
| "286": "Gbreve;", |
| "287": "gbreve;", |
| "288": "Gdot;", |
| "289": "gdot;", |
| "290": "Gcedil;", |
| "292": "Hcirc;", |
| "293": "hcirc;", |
| "294": "Hstrok;", |
| "295": "hstrok;", |
| "296": "Itilde;", |
| "297": "itilde;", |
| "298": "Imacr;", |
| "299": "imacr;", |
| "302": "Iogon;", |
| "303": "iogon;", |
| "304": "Idot;", |
| "305": "inodot;", |
| "306": "IJlig;", |
| "307": "ijlig;", |
| "308": "Jcirc;", |
| "309": "jcirc;", |
| "310": "Kcedil;", |
| "311": "kcedil;", |
| "312": "kgreen;", |
| "313": "Lacute;", |
| "314": "lacute;", |
| "315": "Lcedil;", |
| "316": "lcedil;", |
| "317": "Lcaron;", |
| "318": "lcaron;", |
| "319": "Lmidot;", |
| "320": "lmidot;", |
| "321": "Lstrok;", |
| "322": "lstrok;", |
| "323": "Nacute;", |
| "324": "nacute;", |
| "325": "Ncedil;", |
| "326": "ncedil;", |
| "327": "Ncaron;", |
| "328": "ncaron;", |
| "329": "napos;", |
| "330": "ENG;", |
| "331": "eng;", |
| "332": "Omacr;", |
| "333": "omacr;", |
| "336": "Odblac;", |
| "337": "odblac;", |
| "338": "OElig;", |
| "339": "oelig;", |
| "340": "Racute;", |
| "341": "racute;", |
| "342": "Rcedil;", |
| "343": "rcedil;", |
| "344": "Rcaron;", |
| "345": "rcaron;", |
| "346": "Sacute;", |
| "347": "sacute;", |
| "348": "Scirc;", |
| "349": "scirc;", |
| "350": "Scedil;", |
| "351": "scedil;", |
| "352": "Scaron;", |
| "353": "scaron;", |
| "354": "Tcedil;", |
| "355": "tcedil;", |
| "356": "Tcaron;", |
| "357": "tcaron;", |
| "358": "Tstrok;", |
| "359": "tstrok;", |
| "360": "Utilde;", |
| "361": "utilde;", |
| "362": "Umacr;", |
| "363": "umacr;", |
| "364": "Ubreve;", |
| "365": "ubreve;", |
| "366": "Uring;", |
| "367": "uring;", |
| "368": "Udblac;", |
| "369": "udblac;", |
| "370": "Uogon;", |
| "371": "uogon;", |
| "372": "Wcirc;", |
| "373": "wcirc;", |
| "374": "Ycirc;", |
| "375": "ycirc;", |
| "376": "Yuml;", |
| "377": "Zacute;", |
| "378": "zacute;", |
| "379": "Zdot;", |
| "380": "zdot;", |
| "381": "Zcaron;", |
| "382": "zcaron;", |
| "402": "fnof;", |
| "437": "imped;", |
| "501": "gacute;", |
| "567": "jmath;", |
| "710": "circ;", |
| "711": "Hacek;", |
| "728": "breve;", |
| "729": "dot;", |
| "730": "ring;", |
| "731": "ogon;", |
| "732": "tilde;", |
| "733": "DiacriticalDoubleAcute;", |
| "785": "DownBreve;", |
| "913": "Alpha;", |
| "914": "Beta;", |
| "915": "Gamma;", |
| "916": "Delta;", |
| "917": "Epsilon;", |
| "918": "Zeta;", |
| "919": "Eta;", |
| "920": "Theta;", |
| "921": "Iota;", |
| "922": "Kappa;", |
| "923": "Lambda;", |
| "924": "Mu;", |
| "925": "Nu;", |
| "926": "Xi;", |
| "927": "Omicron;", |
| "928": "Pi;", |
| "929": "Rho;", |
| "931": "Sigma;", |
| "932": "Tau;", |
| "933": "Upsilon;", |
| "934": "Phi;", |
| "935": "Chi;", |
| "936": "Psi;", |
| "937": "Omega;", |
| "945": "alpha;", |
| "946": "beta;", |
| "947": "gamma;", |
| "948": "delta;", |
| "949": "epsilon;", |
| "950": "zeta;", |
| "951": "eta;", |
| "952": "theta;", |
| "953": "iota;", |
| "954": "kappa;", |
| "955": "lambda;", |
| "956": "mu;", |
| "957": "nu;", |
| "958": "xi;", |
| "959": "omicron;", |
| "960": "pi;", |
| "961": "rho;", |
| "962": "varsigma;", |
| "963": "sigma;", |
| "964": "tau;", |
| "965": "upsilon;", |
| "966": "phi;", |
| "967": "chi;", |
| "968": "psi;", |
| "969": "omega;", |
| "977": "vartheta;", |
| "978": "upsih;", |
| "981": "varphi;", |
| "982": "varpi;", |
| "988": "Gammad;", |
| "989": "gammad;", |
| "1008": "varkappa;", |
| "1009": "varrho;", |
| "1013": "varepsilon;", |
| "1014": "bepsi;", |
| "1025": "IOcy;", |
| "1026": "DJcy;", |
| "1027": "GJcy;", |
| "1028": "Jukcy;", |
| "1029": "DScy;", |
| "1030": "Iukcy;", |
| "1031": "YIcy;", |
| "1032": "Jsercy;", |
| "1033": "LJcy;", |
| "1034": "NJcy;", |
| "1035": "TSHcy;", |
| "1036": "KJcy;", |
| "1038": "Ubrcy;", |
| "1039": "DZcy;", |
| "1040": "Acy;", |
| "1041": "Bcy;", |
| "1042": "Vcy;", |
| "1043": "Gcy;", |
| "1044": "Dcy;", |
| "1045": "IEcy;", |
| "1046": "ZHcy;", |
| "1047": "Zcy;", |
| "1048": "Icy;", |
| "1049": "Jcy;", |
| "1050": "Kcy;", |
| "1051": "Lcy;", |
| "1052": "Mcy;", |
| "1053": "Ncy;", |
| "1054": "Ocy;", |
| "1055": "Pcy;", |
| "1056": "Rcy;", |
| "1057": "Scy;", |
| "1058": "Tcy;", |
| "1059": "Ucy;", |
| "1060": "Fcy;", |
| "1061": "KHcy;", |
| "1062": "TScy;", |
| "1063": "CHcy;", |
| "1064": "SHcy;", |
| "1065": "SHCHcy;", |
| "1066": "HARDcy;", |
| "1067": "Ycy;", |
| "1068": "SOFTcy;", |
| "1069": "Ecy;", |
| "1070": "YUcy;", |
| "1071": "YAcy;", |
| "1072": "acy;", |
| "1073": "bcy;", |
| "1074": "vcy;", |
| "1075": "gcy;", |
| "1076": "dcy;", |
| "1077": "iecy;", |
| "1078": "zhcy;", |
| "1079": "zcy;", |
| "1080": "icy;", |
| "1081": "jcy;", |
| "1082": "kcy;", |
| "1083": "lcy;", |
| "1084": "mcy;", |
| "1085": "ncy;", |
| "1086": "ocy;", |
| "1087": "pcy;", |
| "1088": "rcy;", |
| "1089": "scy;", |
| "1090": "tcy;", |
| "1091": "ucy;", |
| "1092": "fcy;", |
| "1093": "khcy;", |
| "1094": "tscy;", |
| "1095": "chcy;", |
| "1096": "shcy;", |
| "1097": "shchcy;", |
| "1098": "hardcy;", |
| "1099": "ycy;", |
| "1100": "softcy;", |
| "1101": "ecy;", |
| "1102": "yucy;", |
| "1103": "yacy;", |
| "1105": "iocy;", |
| "1106": "djcy;", |
| "1107": "gjcy;", |
| "1108": "jukcy;", |
| "1109": "dscy;", |
| "1110": "iukcy;", |
| "1111": "yicy;", |
| "1112": "jsercy;", |
| "1113": "ljcy;", |
| "1114": "njcy;", |
| "1115": "tshcy;", |
| "1116": "kjcy;", |
| "1118": "ubrcy;", |
| "1119": "dzcy;", |
| "8194": "ensp;", |
| "8195": "emsp;", |
| "8196": "emsp13;", |
| "8197": "emsp14;", |
| "8199": "numsp;", |
| "8200": "puncsp;", |
| "8201": "ThinSpace;", |
| "8202": "VeryThinSpace;", |
| "8203": "ZeroWidthSpace;", |
| "8204": "zwnj;", |
| "8205": "zwj;", |
| "8206": "lrm;", |
| "8207": "rlm;", |
| "8208": "hyphen;", |
| "8211": "ndash;", |
| "8212": "mdash;", |
| "8213": "horbar;", |
| "8214": "Vert;", |
| "8216": "OpenCurlyQuote;", |
| "8217": "rsquor;", |
| "8218": "sbquo;", |
| "8220": "OpenCurlyDoubleQuote;", |
| "8221": "rdquor;", |
| "8222": "ldquor;", |
| "8224": "dagger;", |
| "8225": "ddagger;", |
| "8226": "bullet;", |
| "8229": "nldr;", |
| "8230": "mldr;", |
| "8240": "permil;", |
| "8241": "pertenk;", |
| "8242": "prime;", |
| "8243": "Prime;", |
| "8244": "tprime;", |
| "8245": "bprime;", |
| "8249": "lsaquo;", |
| "8250": "rsaquo;", |
| "8254": "OverBar;", |
| "8257": "caret;", |
| "8259": "hybull;", |
| "8260": "frasl;", |
| "8271": "bsemi;", |
| "8279": "qprime;", |
| "8287": "MediumSpace;", |
| "8288": "NoBreak;", |
| "8289": "ApplyFunction;", |
| "8290": "it;", |
| "8291": "InvisibleComma;", |
| "8364": "euro;", |
| "8411": "TripleDot;", |
| "8412": "DotDot;", |
| "8450": "Copf;", |
| "8453": "incare;", |
| "8458": "gscr;", |
| "8459": "Hscr;", |
| "8460": "Poincareplane;", |
| "8461": "quaternions;", |
| "8462": "planckh;", |
| "8463": "plankv;", |
| "8464": "Iscr;", |
| "8465": "imagpart;", |
| "8466": "Lscr;", |
| "8467": "ell;", |
| "8469": "Nopf;", |
| "8470": "numero;", |
| "8471": "copysr;", |
| "8472": "wp;", |
| "8473": "primes;", |
| "8474": "rationals;", |
| "8475": "Rscr;", |
| "8476": "Rfr;", |
| "8477": "Ropf;", |
| "8478": "rx;", |
| "8482": "trade;", |
| "8484": "Zopf;", |
| "8487": "mho;", |
| "8488": "Zfr;", |
| "8489": "iiota;", |
| "8492": "Bscr;", |
| "8493": "Cfr;", |
| "8495": "escr;", |
| "8496": "expectation;", |
| "8497": "Fscr;", |
| "8499": "phmmat;", |
| "8500": "oscr;", |
| "8501": "aleph;", |
| "8502": "beth;", |
| "8503": "gimel;", |
| "8504": "daleth;", |
| "8517": "DD;", |
| "8518": "DifferentialD;", |
| "8519": "exponentiale;", |
| "8520": "ImaginaryI;", |
| "8531": "frac13;", |
| "8532": "frac23;", |
| "8533": "frac15;", |
| "8534": "frac25;", |
| "8535": "frac35;", |
| "8536": "frac45;", |
| "8537": "frac16;", |
| "8538": "frac56;", |
| "8539": "frac18;", |
| "8540": "frac38;", |
| "8541": "frac58;", |
| "8542": "frac78;", |
| "8592": "slarr;", |
| "8593": "uparrow;", |
| "8594": "srarr;", |
| "8595": "ShortDownArrow;", |
| "8596": "leftrightarrow;", |
| "8597": "varr;", |
| "8598": "UpperLeftArrow;", |
| "8599": "UpperRightArrow;", |
| "8600": "searrow;", |
| "8601": "swarrow;", |
| "8602": "nleftarrow;", |
| "8603": "nrightarrow;", |
| "8605": "rightsquigarrow;", |
| "8606": "twoheadleftarrow;", |
| "8607": "Uarr;", |
| "8608": "twoheadrightarrow;", |
| "8609": "Darr;", |
| "8610": "leftarrowtail;", |
| "8611": "rightarrowtail;", |
| "8612": "mapstoleft;", |
| "8613": "UpTeeArrow;", |
| "8614": "RightTeeArrow;", |
| "8615": "mapstodown;", |
| "8617": "larrhk;", |
| "8618": "rarrhk;", |
| "8619": "looparrowleft;", |
| "8620": "rarrlp;", |
| "8621": "leftrightsquigarrow;", |
| "8622": "nleftrightarrow;", |
| "8624": "lsh;", |
| "8625": "rsh;", |
| "8626": "ldsh;", |
| "8627": "rdsh;", |
| "8629": "crarr;", |
| "8630": "curvearrowleft;", |
| "8631": "curvearrowright;", |
| "8634": "olarr;", |
| "8635": "orarr;", |
| "8636": "lharu;", |
| "8637": "lhard;", |
| "8638": "upharpoonright;", |
| "8639": "upharpoonleft;", |
| "8640": "RightVector;", |
| "8641": "rightharpoondown;", |
| "8642": "RightDownVector;", |
| "8643": "LeftDownVector;", |
| "8644": "rlarr;", |
| "8645": "UpArrowDownArrow;", |
| "8646": "lrarr;", |
| "8647": "llarr;", |
| "8648": "uuarr;", |
| "8649": "rrarr;", |
| "8650": "downdownarrows;", |
| "8651": "ReverseEquilibrium;", |
| "8652": "rlhar;", |
| "8653": "nLeftarrow;", |
| "8654": "nLeftrightarrow;", |
| "8655": "nRightarrow;", |
| "8656": "Leftarrow;", |
| "8657": "Uparrow;", |
| "8658": "Rightarrow;", |
| "8659": "Downarrow;", |
| "8660": "Leftrightarrow;", |
| "8661": "vArr;", |
| "8662": "nwArr;", |
| "8663": "neArr;", |
| "8664": "seArr;", |
| "8665": "swArr;", |
| "8666": "Lleftarrow;", |
| "8667": "Rrightarrow;", |
| "8669": "zigrarr;", |
| "8676": "LeftArrowBar;", |
| "8677": "RightArrowBar;", |
| "8693": "duarr;", |
| "8701": "loarr;", |
| "8702": "roarr;", |
| "8703": "hoarr;", |
| "8704": "forall;", |
| "8705": "complement;", |
| "8706": "PartialD;", |
| "8707": "Exists;", |
| "8708": "NotExists;", |
| "8709": "varnothing;", |
| "8711": "nabla;", |
| "8712": "isinv;", |
| "8713": "notinva;", |
| "8715": "SuchThat;", |
| "8716": "NotReverseElement;", |
| "8719": "Product;", |
| "8720": "Coproduct;", |
| "8721": "sum;", |
| "8722": "minus;", |
| "8723": "mp;", |
| "8724": "plusdo;", |
| "8726": "ssetmn;", |
| "8727": "lowast;", |
| "8728": "SmallCircle;", |
| "8730": "Sqrt;", |
| "8733": "vprop;", |
| "8734": "infin;", |
| "8735": "angrt;", |
| "8736": "angle;", |
| "8737": "measuredangle;", |
| "8738": "angsph;", |
| "8739": "VerticalBar;", |
| "8740": "nsmid;", |
| "8741": "spar;", |
| "8742": "nspar;", |
| "8743": "wedge;", |
| "8744": "vee;", |
| "8745": "cap;", |
| "8746": "cup;", |
| "8747": "Integral;", |
| "8748": "Int;", |
| "8749": "tint;", |
| "8750": "oint;", |
| "8751": "DoubleContourIntegral;", |
| "8752": "Cconint;", |
| "8753": "cwint;", |
| "8754": "cwconint;", |
| "8755": "CounterClockwiseContourIntegral;", |
| "8756": "therefore;", |
| "8757": "because;", |
| "8758": "ratio;", |
| "8759": "Proportion;", |
| "8760": "minusd;", |
| "8762": "mDDot;", |
| "8763": "homtht;", |
| "8764": "Tilde;", |
| "8765": "bsim;", |
| "8766": "mstpos;", |
| "8767": "acd;", |
| "8768": "wreath;", |
| "8769": "nsim;", |
| "8770": "esim;", |
| "8771": "TildeEqual;", |
| "8772": "nsimeq;", |
| "8773": "TildeFullEqual;", |
| "8774": "simne;", |
| "8775": "NotTildeFullEqual;", |
| "8776": "TildeTilde;", |
| "8777": "NotTildeTilde;", |
| "8778": "approxeq;", |
| "8779": "apid;", |
| "8780": "bcong;", |
| "8781": "CupCap;", |
| "8782": "HumpDownHump;", |
| "8783": "HumpEqual;", |
| "8784": "esdot;", |
| "8785": "eDot;", |
| "8786": "fallingdotseq;", |
| "8787": "risingdotseq;", |
| "8788": "coloneq;", |
| "8789": "eqcolon;", |
| "8790": "eqcirc;", |
| "8791": "cire;", |
| "8793": "wedgeq;", |
| "8794": "veeeq;", |
| "8796": "trie;", |
| "8799": "questeq;", |
| "8800": "NotEqual;", |
| "8801": "equiv;", |
| "8802": "NotCongruent;", |
| "8804": "leq;", |
| "8805": "GreaterEqual;", |
| "8806": "LessFullEqual;", |
| "8807": "GreaterFullEqual;", |
| "8808": "lneqq;", |
| "8809": "gneqq;", |
| "8810": "NestedLessLess;", |
| "8811": "NestedGreaterGreater;", |
| "8812": "twixt;", |
| "8813": "NotCupCap;", |
| "8814": "NotLess;", |
| "8815": "NotGreater;", |
| "8816": "NotLessEqual;", |
| "8817": "NotGreaterEqual;", |
| "8818": "lsim;", |
| "8819": "gtrsim;", |
| "8820": "NotLessTilde;", |
| "8821": "NotGreaterTilde;", |
| "8822": "lg;", |
| "8823": "gtrless;", |
| "8824": "ntlg;", |
| "8825": "ntgl;", |
| "8826": "Precedes;", |
| "8827": "Succeeds;", |
| "8828": "PrecedesSlantEqual;", |
| "8829": "SucceedsSlantEqual;", |
| "8830": "prsim;", |
| "8831": "succsim;", |
| "8832": "nprec;", |
| "8833": "nsucc;", |
| "8834": "subset;", |
| "8835": "supset;", |
| "8836": "nsub;", |
| "8837": "nsup;", |
| "8838": "SubsetEqual;", |
| "8839": "supseteq;", |
| "8840": "nsubseteq;", |
| "8841": "nsupseteq;", |
| "8842": "subsetneq;", |
| "8843": "supsetneq;", |
| "8845": "cupdot;", |
| "8846": "uplus;", |
| "8847": "SquareSubset;", |
| "8848": "SquareSuperset;", |
| "8849": "SquareSubsetEqual;", |
| "8850": "SquareSupersetEqual;", |
| "8851": "SquareIntersection;", |
| "8852": "SquareUnion;", |
| "8853": "oplus;", |
| "8854": "ominus;", |
| "8855": "otimes;", |
| "8856": "osol;", |
| "8857": "odot;", |
| "8858": "ocir;", |
| "8859": "oast;", |
| "8861": "odash;", |
| "8862": "plusb;", |
| "8863": "minusb;", |
| "8864": "timesb;", |
| "8865": "sdotb;", |
| "8866": "vdash;", |
| "8867": "LeftTee;", |
| "8868": "top;", |
| "8869": "UpTee;", |
| "8871": "models;", |
| "8872": "vDash;", |
| "8873": "Vdash;", |
| "8874": "Vvdash;", |
| "8875": "VDash;", |
| "8876": "nvdash;", |
| "8877": "nvDash;", |
| "8878": "nVdash;", |
| "8879": "nVDash;", |
| "8880": "prurel;", |
| "8882": "vltri;", |
| "8883": "vrtri;", |
| "8884": "trianglelefteq;", |
| "8885": "trianglerighteq;", |
| "8886": "origof;", |
| "8887": "imof;", |
| "8888": "mumap;", |
| "8889": "hercon;", |
| "8890": "intercal;", |
| "8891": "veebar;", |
| "8893": "barvee;", |
| "8894": "angrtvb;", |
| "8895": "lrtri;", |
| "8896": "xwedge;", |
| "8897": "xvee;", |
| "8898": "xcap;", |
| "8899": "xcup;", |
| "8900": "diamond;", |
| "8901": "sdot;", |
| "8902": "Star;", |
| "8903": "divonx;", |
| "8904": "bowtie;", |
| "8905": "ltimes;", |
| "8906": "rtimes;", |
| "8907": "lthree;", |
| "8908": "rthree;", |
| "8909": "bsime;", |
| "8910": "cuvee;", |
| "8911": "cuwed;", |
| "8912": "Subset;", |
| "8913": "Supset;", |
| "8914": "Cap;", |
| "8915": "Cup;", |
| "8916": "pitchfork;", |
| "8917": "epar;", |
| "8918": "ltdot;", |
| "8919": "gtrdot;", |
| "8920": "Ll;", |
| "8921": "ggg;", |
| "8922": "LessEqualGreater;", |
| "8923": "gtreqless;", |
| "8926": "curlyeqprec;", |
| "8927": "curlyeqsucc;", |
| "8928": "nprcue;", |
| "8929": "nsccue;", |
| "8930": "nsqsube;", |
| "8931": "nsqsupe;", |
| "8934": "lnsim;", |
| "8935": "gnsim;", |
| "8936": "prnsim;", |
| "8937": "succnsim;", |
| "8938": "ntriangleleft;", |
| "8939": "ntriangleright;", |
| "8940": "ntrianglelefteq;", |
| "8941": "ntrianglerighteq;", |
| "8942": "vellip;", |
| "8943": "ctdot;", |
| "8944": "utdot;", |
| "8945": "dtdot;", |
| "8946": "disin;", |
| "8947": "isinsv;", |
| "8948": "isins;", |
| "8949": "isindot;", |
| "8950": "notinvc;", |
| "8951": "notinvb;", |
| "8953": "isinE;", |
| "8954": "nisd;", |
| "8955": "xnis;", |
| "8956": "nis;", |
| "8957": "notnivc;", |
| "8958": "notnivb;", |
| "8965": "barwedge;", |
| "8966": "doublebarwedge;", |
| "8968": "LeftCeiling;", |
| "8969": "RightCeiling;", |
| "8970": "lfloor;", |
| "8971": "RightFloor;", |
| "8972": "drcrop;", |
| "8973": "dlcrop;", |
| "8974": "urcrop;", |
| "8975": "ulcrop;", |
| "8976": "bnot;", |
| "8978": "profline;", |
| "8979": "profsurf;", |
| "8981": "telrec;", |
| "8982": "target;", |
| "8988": "ulcorner;", |
| "8989": "urcorner;", |
| "8990": "llcorner;", |
| "8991": "lrcorner;", |
| "8994": "sfrown;", |
| "8995": "ssmile;", |
| "9005": "cylcty;", |
| "9006": "profalar;", |
| "9014": "topbot;", |
| "9021": "ovbar;", |
| "9023": "solbar;", |
| "9084": "angzarr;", |
| "9136": "lmoustache;", |
| "9137": "rmoustache;", |
| "9140": "tbrk;", |
| "9141": "UnderBracket;", |
| "9142": "bbrktbrk;", |
| "9180": "OverParenthesis;", |
| "9181": "UnderParenthesis;", |
| "9182": "OverBrace;", |
| "9183": "UnderBrace;", |
| "9186": "trpezium;", |
| "9191": "elinters;", |
| "9251": "blank;", |
| "9416": "oS;", |
| "9472": "HorizontalLine;", |
| "9474": "boxv;", |
| "9484": "boxdr;", |
| "9488": "boxdl;", |
| "9492": "boxur;", |
| "9496": "boxul;", |
| "9500": "boxvr;", |
| "9508": "boxvl;", |
| "9516": "boxhd;", |
| "9524": "boxhu;", |
| "9532": "boxvh;", |
| "9552": "boxH;", |
| "9553": "boxV;", |
| "9554": "boxdR;", |
| "9555": "boxDr;", |
| "9556": "boxDR;", |
| "9557": "boxdL;", |
| "9558": "boxDl;", |
| "9559": "boxDL;", |
| "9560": "boxuR;", |
| "9561": "boxUr;", |
| "9562": "boxUR;", |
| "9563": "boxuL;", |
| "9564": "boxUl;", |
| "9565": "boxUL;", |
| "9566": "boxvR;", |
| "9567": "boxVr;", |
| "9568": "boxVR;", |
| "9569": "boxvL;", |
| "9570": "boxVl;", |
| "9571": "boxVL;", |
| "9572": "boxHd;", |
| "9573": "boxhD;", |
| "9574": "boxHD;", |
| "9575": "boxHu;", |
| "9576": "boxhU;", |
| "9577": "boxHU;", |
| "9578": "boxvH;", |
| "9579": "boxVh;", |
| "9580": "boxVH;", |
| "9600": "uhblk;", |
| "9604": "lhblk;", |
| "9608": "block;", |
| "9617": "blk14;", |
| "9618": "blk12;", |
| "9619": "blk34;", |
| "9633": "square;", |
| "9642": "squf;", |
| "9643": "EmptyVerySmallSquare;", |
| "9645": "rect;", |
| "9646": "marker;", |
| "9649": "fltns;", |
| "9651": "xutri;", |
| "9652": "utrif;", |
| "9653": "utri;", |
| "9656": "rtrif;", |
| "9657": "triangleright;", |
| "9661": "xdtri;", |
| "9662": "dtrif;", |
| "9663": "triangledown;", |
| "9666": "ltrif;", |
| "9667": "triangleleft;", |
| "9674": "lozenge;", |
| "9675": "cir;", |
| "9708": "tridot;", |
| "9711": "xcirc;", |
| "9720": "ultri;", |
| "9721": "urtri;", |
| "9722": "lltri;", |
| "9723": "EmptySmallSquare;", |
| "9724": "FilledSmallSquare;", |
| "9733": "starf;", |
| "9734": "star;", |
| "9742": "phone;", |
| "9792": "female;", |
| "9794": "male;", |
| "9824": "spadesuit;", |
| "9827": "clubsuit;", |
| "9829": "heartsuit;", |
| "9830": "diams;", |
| "9834": "sung;", |
| "9837": "flat;", |
| "9838": "natural;", |
| "9839": "sharp;", |
| "10003": "checkmark;", |
| "10007": "cross;", |
| "10016": "maltese;", |
| "10038": "sext;", |
| "10072": "VerticalSeparator;", |
| "10098": "lbbrk;", |
| "10099": "rbbrk;", |
| "10184": "bsolhsub;", |
| "10185": "suphsol;", |
| "10214": "lobrk;", |
| "10215": "robrk;", |
| "10216": "LeftAngleBracket;", |
| "10217": "RightAngleBracket;", |
| "10218": "Lang;", |
| "10219": "Rang;", |
| "10220": "loang;", |
| "10221": "roang;", |
| "10229": "xlarr;", |
| "10230": "xrarr;", |
| "10231": "xharr;", |
| "10232": "xlArr;", |
| "10233": "xrArr;", |
| "10234": "xhArr;", |
| "10236": "xmap;", |
| "10239": "dzigrarr;", |
| "10498": "nvlArr;", |
| "10499": "nvrArr;", |
| "10500": "nvHarr;", |
| "10501": "Map;", |
| "10508": "lbarr;", |
| "10509": "rbarr;", |
| "10510": "lBarr;", |
| "10511": "rBarr;", |
| "10512": "RBarr;", |
| "10513": "DDotrahd;", |
| "10514": "UpArrowBar;", |
| "10515": "DownArrowBar;", |
| "10518": "Rarrtl;", |
| "10521": "latail;", |
| "10522": "ratail;", |
| "10523": "lAtail;", |
| "10524": "rAtail;", |
| "10525": "larrfs;", |
| "10526": "rarrfs;", |
| "10527": "larrbfs;", |
| "10528": "rarrbfs;", |
| "10531": "nwarhk;", |
| "10532": "nearhk;", |
| "10533": "searhk;", |
| "10534": "swarhk;", |
| "10535": "nwnear;", |
| "10536": "toea;", |
| "10537": "tosa;", |
| "10538": "swnwar;", |
| "10547": "rarrc;", |
| "10549": "cudarrr;", |
| "10550": "ldca;", |
| "10551": "rdca;", |
| "10552": "cudarrl;", |
| "10553": "larrpl;", |
| "10556": "curarrm;", |
| "10557": "cularrp;", |
| "10565": "rarrpl;", |
| "10568": "harrcir;", |
| "10569": "Uarrocir;", |
| "10570": "lurdshar;", |
| "10571": "ldrushar;", |
| "10574": "LeftRightVector;", |
| "10575": "RightUpDownVector;", |
| "10576": "DownLeftRightVector;", |
| "10577": "LeftUpDownVector;", |
| "10578": "LeftVectorBar;", |
| "10579": "RightVectorBar;", |
| "10580": "RightUpVectorBar;", |
| "10581": "RightDownVectorBar;", |
| "10582": "DownLeftVectorBar;", |
| "10583": "DownRightVectorBar;", |
| "10584": "LeftUpVectorBar;", |
| "10585": "LeftDownVectorBar;", |
| "10586": "LeftTeeVector;", |
| "10587": "RightTeeVector;", |
| "10588": "RightUpTeeVector;", |
| "10589": "RightDownTeeVector;", |
| "10590": "DownLeftTeeVector;", |
| "10591": "DownRightTeeVector;", |
| "10592": "LeftUpTeeVector;", |
| "10593": "LeftDownTeeVector;", |
| "10594": "lHar;", |
| "10595": "uHar;", |
| "10596": "rHar;", |
| "10597": "dHar;", |
| "10598": "luruhar;", |
| "10599": "ldrdhar;", |
| "10600": "ruluhar;", |
| "10601": "rdldhar;", |
| "10602": "lharul;", |
| "10603": "llhard;", |
| "10604": "rharul;", |
| "10605": "lrhard;", |
| "10606": "UpEquilibrium;", |
| "10607": "ReverseUpEquilibrium;", |
| "10608": "RoundImplies;", |
| "10609": "erarr;", |
| "10610": "simrarr;", |
| "10611": "larrsim;", |
| "10612": "rarrsim;", |
| "10613": "rarrap;", |
| "10614": "ltlarr;", |
| "10616": "gtrarr;", |
| "10617": "subrarr;", |
| "10619": "suplarr;", |
| "10620": "lfisht;", |
| "10621": "rfisht;", |
| "10622": "ufisht;", |
| "10623": "dfisht;", |
| "10629": "lopar;", |
| "10630": "ropar;", |
| "10635": "lbrke;", |
| "10636": "rbrke;", |
| "10637": "lbrkslu;", |
| "10638": "rbrksld;", |
| "10639": "lbrksld;", |
| "10640": "rbrkslu;", |
| "10641": "langd;", |
| "10642": "rangd;", |
| "10643": "lparlt;", |
| "10644": "rpargt;", |
| "10645": "gtlPar;", |
| "10646": "ltrPar;", |
| "10650": "vzigzag;", |
| "10652": "vangrt;", |
| "10653": "angrtvbd;", |
| "10660": "ange;", |
| "10661": "range;", |
| "10662": "dwangle;", |
| "10663": "uwangle;", |
| "10664": "angmsdaa;", |
| "10665": "angmsdab;", |
| "10666": "angmsdac;", |
| "10667": "angmsdad;", |
| "10668": "angmsdae;", |
| "10669": "angmsdaf;", |
| "10670": "angmsdag;", |
| "10671": "angmsdah;", |
| "10672": "bemptyv;", |
| "10673": "demptyv;", |
| "10674": "cemptyv;", |
| "10675": "raemptyv;", |
| "10676": "laemptyv;", |
| "10677": "ohbar;", |
| "10678": "omid;", |
| "10679": "opar;", |
| "10681": "operp;", |
| "10683": "olcross;", |
| "10684": "odsold;", |
| "10686": "olcir;", |
| "10687": "ofcir;", |
| "10688": "olt;", |
| "10689": "ogt;", |
| "10690": "cirscir;", |
| "10691": "cirE;", |
| "10692": "solb;", |
| "10693": "bsolb;", |
| "10697": "boxbox;", |
| "10701": "trisb;", |
| "10702": "rtriltri;", |
| "10703": "LeftTriangleBar;", |
| "10704": "RightTriangleBar;", |
| "10716": "iinfin;", |
| "10717": "infintie;", |
| "10718": "nvinfin;", |
| "10723": "eparsl;", |
| "10724": "smeparsl;", |
| "10725": "eqvparsl;", |
| "10731": "lozf;", |
| "10740": "RuleDelayed;", |
| "10742": "dsol;", |
| "10752": "xodot;", |
| "10753": "xoplus;", |
| "10754": "xotime;", |
| "10756": "xuplus;", |
| "10758": "xsqcup;", |
| "10764": "qint;", |
| "10765": "fpartint;", |
| "10768": "cirfnint;", |
| "10769": "awint;", |
| "10770": "rppolint;", |
| "10771": "scpolint;", |
| "10772": "npolint;", |
| "10773": "pointint;", |
| "10774": "quatint;", |
| "10775": "intlarhk;", |
| "10786": "pluscir;", |
| "10787": "plusacir;", |
| "10788": "simplus;", |
| "10789": "plusdu;", |
| "10790": "plussim;", |
| "10791": "plustwo;", |
| "10793": "mcomma;", |
| "10794": "minusdu;", |
| "10797": "loplus;", |
| "10798": "roplus;", |
| "10799": "Cross;", |
| "10800": "timesd;", |
| "10801": "timesbar;", |
| "10803": "smashp;", |
| "10804": "lotimes;", |
| "10805": "rotimes;", |
| "10806": "otimesas;", |
| "10807": "Otimes;", |
| "10808": "odiv;", |
| "10809": "triplus;", |
| "10810": "triminus;", |
| "10811": "tritime;", |
| "10812": "iprod;", |
| "10815": "amalg;", |
| "10816": "capdot;", |
| "10818": "ncup;", |
| "10819": "ncap;", |
| "10820": "capand;", |
| "10821": "cupor;", |
| "10822": "cupcap;", |
| "10823": "capcup;", |
| "10824": "cupbrcap;", |
| "10825": "capbrcup;", |
| "10826": "cupcup;", |
| "10827": "capcap;", |
| "10828": "ccups;", |
| "10829": "ccaps;", |
| "10832": "ccupssm;", |
| "10835": "And;", |
| "10836": "Or;", |
| "10837": "andand;", |
| "10838": "oror;", |
| "10839": "orslope;", |
| "10840": "andslope;", |
| "10842": "andv;", |
| "10843": "orv;", |
| "10844": "andd;", |
| "10845": "ord;", |
| "10847": "wedbar;", |
| "10854": "sdote;", |
| "10858": "simdot;", |
| "10861": "congdot;", |
| "10862": "easter;", |
| "10863": "apacir;", |
| "10864": "apE;", |
| "10865": "eplus;", |
| "10866": "pluse;", |
| "10867": "Esim;", |
| "10868": "Colone;", |
| "10869": "Equal;", |
| "10871": "eDDot;", |
| "10872": "equivDD;", |
| "10873": "ltcir;", |
| "10874": "gtcir;", |
| "10875": "ltquest;", |
| "10876": "gtquest;", |
| "10877": "LessSlantEqual;", |
| "10878": "GreaterSlantEqual;", |
| "10879": "lesdot;", |
| "10880": "gesdot;", |
| "10881": "lesdoto;", |
| "10882": "gesdoto;", |
| "10883": "lesdotor;", |
| "10884": "gesdotol;", |
| "10885": "lessapprox;", |
| "10886": "gtrapprox;", |
| "10887": "lneq;", |
| "10888": "gneq;", |
| "10889": "lnapprox;", |
| "10890": "gnapprox;", |
| "10891": "lesseqqgtr;", |
| "10892": "gtreqqless;", |
| "10893": "lsime;", |
| "10894": "gsime;", |
| "10895": "lsimg;", |
| "10896": "gsiml;", |
| "10897": "lgE;", |
| "10898": "glE;", |
| "10899": "lesges;", |
| "10900": "gesles;", |
| "10901": "eqslantless;", |
| "10902": "eqslantgtr;", |
| "10903": "elsdot;", |
| "10904": "egsdot;", |
| "10905": "el;", |
| "10906": "eg;", |
| "10909": "siml;", |
| "10910": "simg;", |
| "10911": "simlE;", |
| "10912": "simgE;", |
| "10913": "LessLess;", |
| "10914": "GreaterGreater;", |
| "10916": "glj;", |
| "10917": "gla;", |
| "10918": "ltcc;", |
| "10919": "gtcc;", |
| "10920": "lescc;", |
| "10921": "gescc;", |
| "10922": "smt;", |
| "10923": "lat;", |
| "10924": "smte;", |
| "10925": "late;", |
| "10926": "bumpE;", |
| "10927": "preceq;", |
| "10928": "succeq;", |
| "10931": "prE;", |
| "10932": "scE;", |
| "10933": "prnE;", |
| "10934": "succneqq;", |
| "10935": "precapprox;", |
| "10936": "succapprox;", |
| "10937": "prnap;", |
| "10938": "succnapprox;", |
| "10939": "Pr;", |
| "10940": "Sc;", |
| "10941": "subdot;", |
| "10942": "supdot;", |
| "10943": "subplus;", |
| "10944": "supplus;", |
| "10945": "submult;", |
| "10946": "supmult;", |
| "10947": "subedot;", |
| "10948": "supedot;", |
| "10949": "subseteqq;", |
| "10950": "supseteqq;", |
| "10951": "subsim;", |
| "10952": "supsim;", |
| "10955": "subsetneqq;", |
| "10956": "supsetneqq;", |
| "10959": "csub;", |
| "10960": "csup;", |
| "10961": "csube;", |
| "10962": "csupe;", |
| "10963": "subsup;", |
| "10964": "supsub;", |
| "10965": "subsub;", |
| "10966": "supsup;", |
| "10967": "suphsub;", |
| "10968": "supdsub;", |
| "10969": "forkv;", |
| "10970": "topfork;", |
| "10971": "mlcp;", |
| "10980": "DoubleLeftTee;", |
| "10982": "Vdashl;", |
| "10983": "Barv;", |
| "10984": "vBar;", |
| "10985": "vBarv;", |
| "10987": "Vbar;", |
| "10988": "Not;", |
| "10989": "bNot;", |
| "10990": "rnmid;", |
| "10991": "cirmid;", |
| "10992": "midcir;", |
| "10993": "topcir;", |
| "10994": "nhpar;", |
| "10995": "parsim;", |
| "11005": "parsl;", |
| "64256": "fflig;", |
| "64257": "filig;", |
| "64258": "fllig;", |
| "64259": "ffilig;", |
| "64260": "ffllig;" |
| } |
| },{}],369:[function(require,module,exports){ |
| 'use strict'; |
| |
| var hasOwn = Object.prototype.hasOwnProperty; |
| var toStr = Object.prototype.toString; |
| var defineProperty = Object.defineProperty; |
| var gOPD = Object.getOwnPropertyDescriptor; |
| |
| var isArray = function isArray(arr) { |
| if (typeof Array.isArray === 'function') { |
| return Array.isArray(arr); |
| } |
| |
| return toStr.call(arr) === '[object Array]'; |
| }; |
| |
| var isPlainObject = function isPlainObject(obj) { |
| if (!obj || toStr.call(obj) !== '[object Object]') { |
| return false; |
| } |
| |
| var hasOwnConstructor = hasOwn.call(obj, 'constructor'); |
| var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); |
| // Not own constructor property must be Object |
| if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { |
| return false; |
| } |
| |
| // Own properties are enumerated firstly, so to speed up, |
| // if last one is own, then all properties are own. |
| var key; |
| for (key in obj) { /**/ } |
| |
| return typeof key === 'undefined' || hasOwn.call(obj, key); |
| }; |
| |
| // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target |
| var setProperty = function setProperty(target, options) { |
| if (defineProperty && options.name === '__proto__') { |
| defineProperty(target, options.name, { |
| enumerable: true, |
| configurable: true, |
| value: options.newValue, |
| writable: true |
| }); |
| } else { |
| target[options.name] = options.newValue; |
| } |
| }; |
| |
| // Return undefined instead of __proto__ if '__proto__' is not an own property |
| var getProperty = function getProperty(obj, name) { |
| if (name === '__proto__') { |
| if (!hasOwn.call(obj, name)) { |
| return void 0; |
| } else if (gOPD) { |
| // In early versions of node, obj['__proto__'] is buggy when obj has |
| // __proto__ as an own property. Object.getOwnPropertyDescriptor() works. |
| return gOPD(obj, name).value; |
| } |
| } |
| |
| return obj[name]; |
| }; |
| |
| module.exports = function extend() { |
| var options, name, src, copy, copyIsArray, clone; |
| var target = arguments[0]; |
| var i = 1; |
| var length = arguments.length; |
| var deep = false; |
| |
| // Handle a deep copy situation |
| if (typeof target === 'boolean') { |
| deep = target; |
| target = arguments[1] || {}; |
| // skip the boolean and the target |
| i = 2; |
| } |
| if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { |
| target = {}; |
| } |
| |
| for (; i < length; ++i) { |
| options = arguments[i]; |
| // Only deal with non-null/undefined values |
| if (options != null) { |
| // Extend the base object |
| for (name in options) { |
| src = getProperty(target, name); |
| copy = getProperty(options, name); |
| |
| // Prevent never-ending loop |
| if (target !== copy) { |
| // Recurse if we're merging plain objects or arrays |
| if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { |
| if (copyIsArray) { |
| copyIsArray = false; |
| clone = src && isArray(src) ? src : []; |
| } else { |
| clone = src && isPlainObject(src) ? src : {}; |
| } |
| |
| // Never move original objects, clone them |
| setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); |
| |
| // Don't bring in undefined values |
| } else if (typeof copy !== 'undefined') { |
| setProperty(target, { name: name, newValue: copy }); |
| } |
| } |
| } |
| } |
| } |
| |
| // Return the modified object |
| return target; |
| }; |
| |
| },{}],370:[function(require,module,exports){ |
| /** |
| * This file automatically generated from `pre-publish.js`. |
| * Do not manually edit. |
| */ |
| |
| module.exports = { |
| "area": true, |
| "base": true, |
| "br": true, |
| "col": true, |
| "embed": true, |
| "hr": true, |
| "img": true, |
| "input": true, |
| "keygen": true, |
| "link": true, |
| "menuitem": true, |
| "meta": true, |
| "param": true, |
| "source": true, |
| "track": true, |
| "wbr": true |
| }; |
| |
| },{}],371:[function(require,module,exports){ |
| (function (global){ |
| /*! https://mths.be/punycode v1.4.1 by @mathias */ |
| ;(function(root) { |
| |
| /** Detect free variables */ |
| var freeExports = typeof exports == 'object' && exports && |
| !exports.nodeType && exports; |
| var freeModule = typeof module == 'object' && module && |
| !module.nodeType && module; |
| var freeGlobal = typeof global == 'object' && global; |
| if ( |
| freeGlobal.global === freeGlobal || |
| freeGlobal.window === freeGlobal || |
| freeGlobal.self === freeGlobal |
| ) { |
| root = freeGlobal; |
| } |
| |
| /** |
| * The `punycode` object. |
| * @name punycode |
| * @type Object |
| */ |
| var punycode, |
| |
| /** Highest positive signed 32-bit float value */ |
| maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 |
| |
| /** Bootstring parameters */ |
| base = 36, |
| tMin = 1, |
| tMax = 26, |
| skew = 38, |
| damp = 700, |
| initialBias = 72, |
| initialN = 128, // 0x80 |
| delimiter = '-', // '\x2D' |
| |
| /** Regular expressions */ |
| regexPunycode = /^xn--/, |
| regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars |
| regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators |
| |
| /** Error messages */ |
| errors = { |
| 'overflow': 'Overflow: input needs wider integers to process', |
| 'not-basic': 'Illegal input >= 0x80 (not a basic code point)', |
| 'invalid-input': 'Invalid input' |
| }, |
| |
| /** Convenience shortcuts */ |
| baseMinusTMin = base - tMin, |
| floor = Math.floor, |
| stringFromCharCode = String.fromCharCode, |
| |
| /** Temporary variable */ |
| key; |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| /** |
| * A generic error utility function. |
| * @private |
| * @param {String} type The error type. |
| * @returns {Error} Throws a `RangeError` with the applicable error message. |
| */ |
| function error(type) { |
| throw new RangeError(errors[type]); |
| } |
| |
| /** |
| * A generic `Array#map` utility function. |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} callback The function that gets called for every array |
| * item. |
| * @returns {Array} A new array of values returned by the callback function. |
| */ |
| function map(array, fn) { |
| var length = array.length; |
| var result = []; |
| while (length--) { |
| result[length] = fn(array[length]); |
| } |
| return result; |
| } |
| |
| /** |
| * A simple `Array#map`-like wrapper to work with domain name strings or email |
| * addresses. |
| * @private |
| * @param {String} domain The domain name or email address. |
| * @param {Function} callback The function that gets called for every |
| * character. |
| * @returns {Array} A new string of characters returned by the callback |
| * function. |
| */ |
| function mapDomain(string, fn) { |
| var parts = string.split('@'); |
| var result = ''; |
| if (parts.length > 1) { |
| // In email addresses, only the domain name should be punycoded. Leave |
| // the local part (i.e. everything up to `@`) intact. |
| result = parts[0] + '@'; |
| string = parts[1]; |
| } |
| // Avoid `split(regex)` for IE8 compatibility. See #17. |
| string = string.replace(regexSeparators, '\x2E'); |
| var labels = string.split('.'); |
| var encoded = map(labels, fn).join('.'); |
| return result + encoded; |
| } |
| |
| /** |
| * Creates an array containing the numeric code points of each Unicode |
| * character in the string. While JavaScript uses UCS-2 internally, |
| * this function will convert a pair of surrogate halves (each of which |
| * UCS-2 exposes as separate characters) into a single code point, |
| * matching UTF-16. |
| * @see `punycode.ucs2.encode` |
| * @see <https://mathiasbynens.be/notes/javascript-encoding> |
| * @memberOf punycode.ucs2 |
| * @name decode |
| * @param {String} string The Unicode input string (UCS-2). |
| * @returns {Array} The new array of code points. |
| */ |
| function ucs2decode(string) { |
| var output = [], |
| counter = 0, |
| length = string.length, |
| value, |
| extra; |
| while (counter < length) { |
| value = string.charCodeAt(counter++); |
| if (value >= 0xD800 && value <= 0xDBFF && counter < length) { |
| // high surrogate, and there is a next character |
| extra = string.charCodeAt(counter++); |
| if ((extra & 0xFC00) == 0xDC00) { // low surrogate |
| output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); |
| } else { |
| // unmatched surrogate; only append this code unit, in case the next |
| // code unit is the high surrogate of a surrogate pair |
| output.push(value); |
| counter--; |
| } |
| } else { |
| output.push(value); |
| } |
| } |
| return output; |
| } |
| |
| /** |
| * Creates a string based on an array of numeric code points. |
| * @see `punycode.ucs2.decode` |
| * @memberOf punycode.ucs2 |
| * @name encode |
| * @param {Array} codePoints The array of numeric code points. |
| * @returns {String} The new Unicode string (UCS-2). |
| */ |
| function ucs2encode(array) { |
| return map(array, function(value) { |
| var output = ''; |
| if (value > 0xFFFF) { |
| value -= 0x10000; |
| output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); |
| value = 0xDC00 | value & 0x3FF; |
| } |
| output += stringFromCharCode(value); |
| return output; |
| }).join(''); |
| } |
| |
| /** |
| * Converts a basic code point into a digit/integer. |
| * @see `digitToBasic()` |
| * @private |
| * @param {Number} codePoint The basic numeric code point value. |
| * @returns {Number} The numeric value of a basic code point (for use in |
| * representing integers) in the range `0` to `base - 1`, or `base` if |
| * the code point does not represent a value. |
| */ |
| function basicToDigit(codePoint) { |
| if (codePoint - 48 < 10) { |
| return codePoint - 22; |
| } |
| if (codePoint - 65 < 26) { |
| return codePoint - 65; |
| } |
| if (codePoint - 97 < 26) { |
| return codePoint - 97; |
| } |
| return base; |
| } |
| |
| /** |
| * Converts a digit/integer into a basic code point. |
| * @see `basicToDigit()` |
| * @private |
| * @param {Number} digit The numeric value of a basic code point. |
| * @returns {Number} The basic code point whose value (when used for |
| * representing integers) is `digit`, which needs to be in the range |
| * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is |
| * used; else, the lowercase form is used. The behavior is undefined |
| * if `flag` is non-zero and `digit` has no uppercase form. |
| */ |
| function digitToBasic(digit, flag) { |
| // 0..25 map to ASCII a..z or A..Z |
| // 26..35 map to ASCII 0..9 |
| return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); |
| } |
| |
| /** |
| * Bias adaptation function as per section 3.4 of RFC 3492. |
| * https://tools.ietf.org/html/rfc3492#section-3.4 |
| * @private |
| */ |
| function adapt(delta, numPoints, firstTime) { |
| var k = 0; |
| delta = firstTime ? floor(delta / damp) : delta >> 1; |
| delta += floor(delta / numPoints); |
| for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { |
| delta = floor(delta / baseMinusTMin); |
| } |
| return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); |
| } |
| |
| /** |
| * Converts a Punycode string of ASCII-only symbols to a string of Unicode |
| * symbols. |
| * @memberOf punycode |
| * @param {String} input The Punycode string of ASCII-only symbols. |
| * @returns {String} The resulting string of Unicode symbols. |
| */ |
| function decode(input) { |
| // Don't use UCS-2 |
| var output = [], |
| inputLength = input.length, |
| out, |
| i = 0, |
| n = initialN, |
| bias = initialBias, |
| basic, |
| j, |
| index, |
| oldi, |
| w, |
| k, |
| digit, |
| t, |
| /** Cached calculation results */ |
| baseMinusT; |
| |
| // Handle the basic code points: let `basic` be the number of input code |
| // points before the last delimiter, or `0` if there is none, then copy |
| // the first basic code points to the output. |
| |
| basic = input.lastIndexOf(delimiter); |
| if (basic < 0) { |
| basic = 0; |
| } |
| |
| for (j = 0; j < basic; ++j) { |
| // if it's not a basic code point |
| if (input.charCodeAt(j) >= 0x80) { |
| error('not-basic'); |
| } |
| output.push(input.charCodeAt(j)); |
| } |
| |
| // Main decoding loop: start just after the last delimiter if any basic code |
| // points were copied; start at the beginning otherwise. |
| |
| for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { |
| |
| // `index` is the index of the next character to be consumed. |
| // Decode a generalized variable-length integer into `delta`, |
| // which gets added to `i`. The overflow checking is easier |
| // if we increase `i` as we go, then subtract off its starting |
| // value at the end to obtain `delta`. |
| for (oldi = i, w = 1, k = base; /* no condition */; k += base) { |
| |
| if (index >= inputLength) { |
| error('invalid-input'); |
| } |
| |
| digit = basicToDigit(input.charCodeAt(index++)); |
| |
| if (digit >= base || digit > floor((maxInt - i) / w)) { |
| error('overflow'); |
| } |
| |
| i += digit * w; |
| t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); |
| |
| if (digit < t) { |
| break; |
| } |
| |
| baseMinusT = base - t; |
| if (w > floor(maxInt / baseMinusT)) { |
| error('overflow'); |
| } |
| |
| w *= baseMinusT; |
| |
| } |
| |
| out = output.length + 1; |
| bias = adapt(i - oldi, out, oldi == 0); |
| |
| // `i` was supposed to wrap around from `out` to `0`, |
| // incrementing `n` each time, so we'll fix that now: |
| if (floor(i / out) > maxInt - n) { |
| error('overflow'); |
| } |
| |
| n += floor(i / out); |
| i %= out; |
| |
| // Insert `n` at position `i` of the output |
| output.splice(i++, 0, n); |
| |
| } |
| |
| return ucs2encode(output); |
| } |
| |
| /** |
| * Converts a string of Unicode symbols (e.g. a domain name label) to a |
| * Punycode string of ASCII-only symbols. |
| * @memberOf punycode |
| * @param {String} input The string of Unicode symbols. |
| * @returns {String} The resulting Punycode string of ASCII-only symbols. |
| */ |
| function encode(input) { |
| var n, |
| delta, |
| handledCPCount, |
| basicLength, |
| bias, |
| j, |
| m, |
| q, |
| k, |
| t, |
| currentValue, |
| output = [], |
| /** `inputLength` will hold the number of code points in `input`. */ |
| inputLength, |
| /** Cached calculation results */ |
| handledCPCountPlusOne, |
| baseMinusT, |
| qMinusT; |
| |
| // Convert the input in UCS-2 to Unicode |
| input = ucs2decode(input); |
| |
| // Cache the length |
| inputLength = input.length; |
| |
| // Initialize the state |
| n = initialN; |
| delta = 0; |
| bias = initialBias; |
| |
| // Handle the basic code points |
| for (j = 0; j < inputLength; ++j) { |
| currentValue = input[j]; |
| if (currentValue < 0x80) { |
| output.push(stringFromCharCode(currentValue)); |
| } |
| } |
| |
| handledCPCount = basicLength = output.length; |
| |
| // `handledCPCount` is the number of code points that have been handled; |
| // `basicLength` is the number of basic code points. |
| |
| // Finish the basic string - if it is not empty - with a delimiter |
| if (basicLength) { |
| output.push(delimiter); |
| } |
| |
| // Main encoding loop: |
| while (handledCPCount < inputLength) { |
| |
| // All non-basic code points < n have been handled already. Find the next |
| // larger one: |
| for (m = maxInt, j = 0; j < inputLength; ++j) { |
| currentValue = input[j]; |
| if (currentValue >= n && currentValue < m) { |
| m = currentValue; |
| } |
| } |
| |
| // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, |
| // but guard against overflow |
| handledCPCountPlusOne = handledCPCount + 1; |
| if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { |
| error('overflow'); |
| } |
| |
| delta += (m - n) * handledCPCountPlusOne; |
| n = m; |
| |
| for (j = 0; j < inputLength; ++j) { |
| currentValue = input[j]; |
| |
| if (currentValue < n && ++delta > maxInt) { |
| error('overflow'); |
| } |
| |
| if (currentValue == n) { |
| // Represent delta as a generalized variable-length integer |
| for (q = delta, k = base; /* no condition */; k += base) { |
| t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); |
| if (q < t) { |
| break; |
| } |
| qMinusT = q - t; |
| baseMinusT = base - t; |
| output.push( |
| stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) |
| ); |
| q = floor(qMinusT / baseMinusT); |
| } |
| |
| output.push(stringFromCharCode(digitToBasic(q, 0))); |
| bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); |
| delta = 0; |
| ++handledCPCount; |
| } |
| } |
| |
| ++delta; |
| ++n; |
| |
| } |
| return output.join(''); |
| } |
| |
| /** |
| * Converts a Punycode string representing a domain name or an email address |
| * to Unicode. Only the Punycoded parts of the input will be converted, i.e. |
| * it doesn't matter if you call it on a string that has already been |
| * converted to Unicode. |
| * @memberOf punycode |
| * @param {String} input The Punycoded domain name or email address to |
| * convert to Unicode. |
| * @returns {String} The Unicode representation of the given Punycode |
| * string. |
| */ |
| function toUnicode(input) { |
| return mapDomain(input, function(string) { |
| return regexPunycode.test(string) |
| ? decode(string.slice(4).toLowerCase()) |
| : string; |
| }); |
| } |
| |
| /** |
| * Converts a Unicode string representing a domain name or an email address to |
| * Punycode. Only the non-ASCII parts of the domain name will be converted, |
| * i.e. it doesn't matter if you call it with a domain that's already in |
| * ASCII. |
| * @memberOf punycode |
| * @param {String} input The domain name or email address to convert, as a |
| * Unicode string. |
| * @returns {String} The Punycode representation of the given domain name or |
| * email address. |
| */ |
| function toASCII(input) { |
| return mapDomain(input, function(string) { |
| return regexNonASCII.test(string) |
| ? 'xn--' + encode(string) |
| : string; |
| }); |
| } |
| |
| /*--------------------------------------------------------------------------*/ |
| |
| /** Define the public API */ |
| punycode = { |
| /** |
| * A string representing the current Punycode.js version number. |
| * @memberOf punycode |
| * @type String |
| */ |
| 'version': '1.4.1', |
| /** |
| * An object of methods to convert from JavaScript's internal character |
| * representation (UCS-2) to Unicode code points, and back. |
| * @see <https://mathiasbynens.be/notes/javascript-encoding> |
| * @memberOf punycode |
| * @type Object |
| */ |
| 'ucs2': { |
| 'decode': ucs2decode, |
| 'encode': ucs2encode |
| }, |
| 'decode': decode, |
| 'encode': encode, |
| 'toASCII': toASCII, |
| 'toUnicode': toUnicode |
| }; |
| |
| /** Expose `punycode` */ |
| // Some AMD build optimizers, like r.js, check for specific condition patterns |
| // like the following: |
| if ( |
| typeof define == 'function' && |
| typeof define.amd == 'object' && |
| define.amd |
| ) { |
| define('punycode', function() { |
| return punycode; |
| }); |
| } else if (freeExports && freeModule) { |
| if (module.exports == freeExports) { |
| // in Node.js, io.js, or RingoJS v0.8.0+ |
| freeModule.exports = punycode; |
| } else { |
| // in Narwhal or RingoJS v0.7.0- |
| for (key in punycode) { |
| punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]); |
| } |
| } |
| } else { |
| // in Rhino or a web browser |
| root.punycode = punycode; |
| } |
| |
| }(this)); |
| |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{}]},{},[3]); |
