{“ast”:null,“code”:“// Copyright Joyent, Inc. and other Node contributors.n//n// Permission is hereby granted, free of charge, to any person obtaining an// copy of this software and associated documentation files (then// "Software"), to deal in the Software without restriction, includingn// without limitation the rights to use, copy, modify, merge, publish,n// distribute, sublicense, and/or sell copies of the Software, and to permitn// persons to whom the Software is furnished to do so, subject to then// following conditions:n//n// The above copyright notice and this permission notice shall be includedn// in all copies or substantial portions of the Software.n//n// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESSn// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OFn// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. INn// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT ORn// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THEn// USE OR OTHER DEALINGS IN THE SOFTWARE.n'use strict';nnfunction _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }nnvar R = (typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === 'object' ? Reflect : null;nvar ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) {n return Function.prototype.apply.call(target, receiver, args);n};nvar ReflectOwnKeys;nnif (R && typeof R.ownKeys === 'function') {n ReflectOwnKeys = R.ownKeys;n} else if (Object.getOwnPropertySymbols) {n ReflectOwnKeys = function ReflectOwnKeys(target) {n return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));n };n} else {n ReflectOwnKeys = function ReflectOwnKeys(target) {n return Object.getOwnPropertyNames(target);n };n}nnfunction ProcessEmitWarning(warning) {n if (console && console.warn) console.warn(warning);n}nnvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {n return value !== value;n};nnfunction EventEmitter() {n EventEmitter.init.call(this);n}nnmodule.exports = EventEmitter; // Backwards-compat with node 0.10.xnnEventEmitter.EventEmitter = EventEmitter;nEventEmitter.prototype._events = undefined;nEventEmitter.prototype._eventsCount = 0;nEventEmitter.prototype._maxListeners = undefined; // By default EventEmitters will print a warning if more than 10 listeners aren// added to it. This is a useful default which helps finding memory leaks.nnvar defaultMaxListeners = 10;nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {n enumerable: true,n get: function get() {n return defaultMaxListeners;n },n set: function set(arg) {n if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {n throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');n }nn defaultMaxListeners = arg;n }n});nnEventEmitter.init = function () {n if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {n this._events = Object.create(null);n this._eventsCount = 0;n }nn this._maxListeners = this._maxListeners || undefined;n}; // Obviously not all Emitters should be limited to 10. This function allowsn// that to be increased. Set to zero for unlimited.nnnEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {n if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {n throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');n }nn this._maxListeners = n;n return this;n};nnfunction $getMaxListeners(that) {n if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;n return that._maxListeners;n}nnEventEmitter.prototype.getMaxListeners = function getMaxListeners() {n return $getMaxListeners(this);n};nnEventEmitter.prototype.emit = function emit(type) {n var args = [];nn for (var i = 1; i < arguments.length; i++) {n args.push(arguments);n }nn var doError = type === 'error';n var events = this._events;n if (events !== undefined) doError = doError && events.error === undefined;else if (!doError) return false; // If there is no 'error' event listener then throw.nn if (doError) {n var er;n if (args.length > 0) er = args;nn if (er instanceof Error) {n // Note: The comments on the `throw` lines are intentional, they shown // up in Node's output if this results in an unhandled exception.n throw er; // Unhandled 'error' eventn } // At least give some kind of context to the usernnn var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));n err.context = er;n throw err; // Unhandled 'error' eventn }nn var handler = events;n if (handler === undefined) return false;nn if (typeof handler === 'function') {n ReflectApply(handler, this, args);n } else {n var len = handler.length;n var listeners = arrayClone(handler, len);nn for (var i = 0; i < len; ++i) {n ReflectApply(listeners, this, args);n }n }nn return true;n};nnfunction _addListener(target, type, listener, prepend) {n var m;n var events;n var existing;nn if (typeof listener !== 'function') {n throw new TypeError('The "listener" argument must be of type Function
. Received type ' + _typeof(listener));n }nn events = target._events;nn if (events === undefined) {n events = target._events = Object.create(null);n target._eventsCount = 0;n } else {n // To avoid recursion in the case that type === "newListener"! Beforen // adding it to the listeners, first emit "newListener".n if (events.newListener !== undefined) {n target.emit('newListener', type, listener.listener ? listener.listener : listener); // Re-assign `events` because a newListener handler could have caused then // this._events to be assigned to a new objectnn events = target._events;n }nn existing = events;n }nn if (existing === undefined) {n // Optimize the case of one listener. Don't need the extra array object.n existing = events = listener;n ++target._eventsCount;n } else {n if (typeof existing === 'function') {n // Adding the second element, need to change to array.n existing = events = prepend ? [listener, existing] : [existing, listener]; // If we've already got an array, just append.n } else if (prepend) {n existing.unshift(listener);n } else {n existing.push(listener);n } // Check for listener leaknnn m = $getMaxListeners(target);nn if (m > 0 && existing.length > m && !existing.warned) {n existing.warned = true; // No error code for this since it is a Warningn // eslint-disable-next-line no-restricted-syntaxnn var w = new Error('Possible EventEmitter memory leak detected. ' + existing.length + ' ' + String(type) + ' listeners ' + 'added. Use emitter.setMaxListeners() to ' + 'increase limit');n w.name = 'MaxListenersExceededWarning';n w.emitter = target;n w.type = type;n w.count = existing.length;n ProcessEmitWarning(w);n }n }nn return target;n}nnEventEmitter.prototype.addListener = function addListener(type, listener) {n return _addListener(this, type, listener, false);n};nnEventEmitter.prototype.on = EventEmitter.prototype.addListener;nnEventEmitter.prototype.prependListener = function prependListener(type, listener) {n return _addListener(this, type, listener, true);n};nnfunction onceWrapper() {n var args = [];nn for (var i = 0; i < arguments.length; i++) {n args.push(arguments);n }nn if (!this.fired) {n this.target.removeListener(this.type, this.wrapFn);n this.fired = true;n ReflectApply(this.listener, this.target, args);n }n}nnfunction _onceWrap(target, type, listener) {n var state = {n fired: false,n wrapFn: undefined,n target: target,n type: type,n listener: listenern };n var wrapped = onceWrapper.bind(state);n wrapped.listener = listener;n state.wrapFn = wrapped;n return wrapped;n}nnEventEmitter.prototype.once = function once(type, listener) {n if (typeof listener !== 'function') {n throw new TypeError('The "listener" argument must be of type Function
. Received type ' + _typeof(listener));n }nn this.on(type, _onceWrap(this, type, listener));n return this;n};nnEventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {n if (typeof listener !== 'function') {n throw new TypeError('The "listener" argument must be of type Function
. Received type ' + _typeof(listener));n }nn this.prependListener(type, _onceWrap(this, type, listener));n return this;n}; // Emits a 'removeListener' event if and only if the listener was removed.nnnEventEmitter.prototype.removeListener = function removeListener(type, listener) {n var list, events, position, i, originalListener;nn if (typeof listener !== 'function') {n throw new TypeError('The "listener" argument must be of type Function
. Received type ' + _typeof(listener));n }nn events = this._events;n if (events === undefined) return this;n list = events;n if (list === undefined) return this;nn if (list === listener || list.listener === listener) {n if (–this._eventsCount === 0) this._events = Object.create(null);else {n delete events;n if (events.removeListener) this.emit('removeListener', type, list.listener || listener);n }n } else if (typeof list !== 'function') {n position = -1;nn for (i = list.length - 1; i >= 0; i–) {n if (list === listener || list.listener === listener) {n originalListener = list.listener;n position = i;n break;n }n }nn if (position < 0) return this;n if (position === 0) list.shift();else {n spliceOne(list, position);n }n if (list.length === 1) events = list;n if (events.removeListener !== undefined) this.emit('removeListener', type, originalListener || listener);n }nn return this;n};nnEventEmitter.prototype.off = EventEmitter.prototype.removeListener;nnEventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {n var listeners, events, i;n events = this._events;n if (events === undefined) return this; // not listening for removeListener, no need to emitnn if (events.removeListener === undefined) {n if (arguments.length === 0) {n this._events = Object.create(null);n this._eventsCount = 0;n } else if (events !== undefined) {n if (–this._eventsCount === 0) this._events = Object.create(null);else delete events;n }nn return this;n } // emit removeListener for all listeners on all eventsnnn if (arguments.length === 0) {n var keys = Object.keys(events);n var key;nn for (i = 0; i < keys.length; ++i) {n key = keys;n if (key === 'removeListener') continue;n this.removeAllListeners(key);n }nn this.removeAllListeners('removeListener');n this._events = Object.create(null);n this._eventsCount = 0;n return this;n }nn listeners = events;nn if (typeof listeners === 'function') {n this.removeListener(type, listeners);n } else if (listeners !== undefined) {n // LIFO ordern for (i = listeners.length - 1; i >= 0; i–) {n this.removeListener(type, listeners);n }n }nn return this;n};nnfunction _listeners(target, type, unwrap) {n var events = target._events;n if (events === undefined) return [];n var evlistener = events;n if (evlistener === undefined) return [];n if (typeof evlistener === 'function') return unwrap ? [evlistener.listener || evlistener] : [evlistener];n return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);n}nnEventEmitter.prototype.listeners = function listeners(type) {n return _listeners(this, type, true);n};nnEventEmitter.prototype.rawListeners = function rawListeners(type) {n return _listeners(this, type, false);n};nnEventEmitter.listenerCount = function (emitter, type) {n if (typeof emitter.listenerCount === 'function') {n return emitter.listenerCount(type);n } else {n return listenerCount.call(emitter, type);n }n};nnEventEmitter.prototype.listenerCount = listenerCount;nnfunction listenerCount(type) {n var events = this._events;nn if (events !== undefined) {n var evlistener = events;nn if (typeof evlistener === 'function') {n return 1;n } else if (evlistener !== undefined) {n return evlistener.length;n }n }nn return 0;n}nnEventEmitter.prototype.eventNames = function eventNames() {n return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];n};nnfunction arrayClone(arr, n) {n var copy = new Array(n);nn for (var i = 0; i < n; ++i) {n copy = arr;n }nn return copy;n}nnfunction spliceOne(list, index) {n for (; index + 1 < list.length; index++) {n list = list[index + 1];n }nn list.pop();n}nnfunction unwrapListeners(arr) {n var ret = new Array(arr.length);nn for (var i = 0; i < ret.length; ++i) {n ret = arr.listener || arr;n }nn return ret;n}”,“map”:null,“metadata”:{},“sourceType”:“module”}