1'use strict';
  2
  3var has = Object.prototype.hasOwnProperty;
  4
  5//
  6// We store our EE objects in a plain object whose properties are event names.
  7// If `Object.create(null)` is not supported we prefix the event names with a
  8// `~` to make sure that the built-in object properties are not overridden or
  9// used as an attack vector.
 10// We also assume that `Object.create(null)` is available when the event name
 11// is an ES6 Symbol.
 12//
 13var prefix = typeof Object.create !== 'function' ? '~' : false;
 14
 15/**
 16 * Representation of a single EventEmitter function.
 17 *
 18 * @param {Function} fn Event handler to be called.
 19 * @param {Mixed} context Context for function execution.
 20 * @param {Boolean} [once=false] Only emit once
 21 * @api private
 22 */
 23function EE(fn, context, once) {
 24  this.fn = fn;
 25  this.context = context;
 26  this.once = once || false;
 27}
 28
 29/**
 30 * Minimal EventEmitter interface that is molded against the Node.js
 31 * EventEmitter interface.
 32 *
 33 * @constructor
 34 * @api public
 35 */
 36function EventEmitter() { /* Nothing to set */ }
 37
 38/**
 39 * Hold the assigned EventEmitters by name.
 40 *
 41 * @type {Object}
 42 * @private
 43 */
 44EventEmitter.prototype._events = undefined;
 45
 46/**
 47 * Return an array listing the events for which the emitter has registered
 48 * listeners.
 49 *
 50 * @returns {Array}
 51 * @api public
 52 */
 53EventEmitter.prototype.eventNames = function eventNames() {
 54  var events = this._events
 55    , names = []
 56    , name;
 57
 58  if (!events) return names;
 59
 60  for (name in events) {
 61    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
 62  }
 63
 64  if (Object.getOwnPropertySymbols) {
 65    return names.concat(Object.getOwnPropertySymbols(events));
 66  }
 67
 68  return names;
 69};
 70
 71/**
 72 * Return a list of assigned event listeners.
 73 *
 74 * @param {String} event The events that should be listed.
 75 * @param {Boolean} exists We only need to know if there are listeners.
 76 * @returns {Array|Boolean}
 77 * @api public
 78 */
 79EventEmitter.prototype.listeners = function listeners(event, exists) {
 80  var evt = prefix ? prefix + event : event
 81    , available = this._events && this._events[evt];
 82
 83  if (exists) return !!available;
 84  if (!available) return [];
 85  if (available.fn) return [available.fn];
 86
 87  for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {
 88    ee[i] = available[i].fn;
 89  }
 90
 91  return ee;
 92};
 93
 94/**
 95 * Emit an event to all registered event listeners.
 96 *
 97 * @param {String} event The name of the event.
 98 * @returns {Boolean} Indication if we've emitted an event.
 99 * @api public
100 */
101EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
102  var evt = prefix ? prefix + event : event;
103
104  if (!this._events || !this._events[evt]) return false;
105
106  var listeners = this._events[evt]
107    , len = arguments.length
108    , args
109    , i;
110
111  if ('function' === typeof listeners.fn) {
112    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
113
114    switch (len) {
115      case 1: return listeners.fn.call(listeners.context), true;
116      case 2: return listeners.fn.call(listeners.context, a1), true;
117      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
118      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
119      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
120      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
121    }
122
123    for (i = 1, args = new Array(len -1); i < len; i++) {
124      args[i - 1] = arguments[i];
125    }
126
127    listeners.fn.apply(listeners.context, args);
128  } else {
129    var length = listeners.length
130      , j;
131
132    for (i = 0; i < length; i++) {
133      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
134
135      switch (len) {
136        case 1: listeners[i].fn.call(listeners[i].context); break;
137        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
138        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
139        default:
140          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
141            args[j - 1] = arguments[j];
142          }
143
144          listeners[i].fn.apply(listeners[i].context, args);
145      }
146    }
147  }
148
149  return true;
150};
151
152/**
153 * Register a new EventListener for the given event.
154 *
155 * @param {String} event Name of the event.
156 * @param {Function} fn Callback function.
157 * @param {Mixed} [context=this] The context of the function.
158 * @api public
159 */
160EventEmitter.prototype.on = function on(event, fn, context) {
161  var listener = new EE(fn, context || this)
162    , evt = prefix ? prefix + event : event;
163
164  if (!this._events) this._events = prefix ? {} : Object.create(null);
165  if (!this._events[evt]) this._events[evt] = listener;
166  else {
167    if (!this._events[evt].fn) this._events[evt].push(listener);
168    else this._events[evt] = [
169      this._events[evt], listener
170    ];
171  }
172
173  return this;
174};
175
176/**
177 * Add an EventListener that's only called once.
178 *
179 * @param {String} event Name of the event.
180 * @param {Function} fn Callback function.
181 * @param {Mixed} [context=this] The context of the function.
182 * @api public
183 */
184EventEmitter.prototype.once = function once(event, fn, context) {
185  var listener = new EE(fn, context || this, true)
186    , evt = prefix ? prefix + event : event;
187
188  if (!this._events) this._events = prefix ? {} : Object.create(null);
189  if (!this._events[evt]) this._events[evt] = listener;
190  else {
191    if (!this._events[evt].fn) this._events[evt].push(listener);
192    else this._events[evt] = [
193      this._events[evt], listener
194    ];
195  }
196
197  return this;
198};
199
200/**
201 * Remove event listeners.
202 *
203 * @param {String} event The event we want to remove.
204 * @param {Function} fn The listener that we need to find.
205 * @param {Mixed} context Only remove listeners matching this context.
206 * @param {Boolean} once Only remove once listeners.
207 * @api public
208 */
209EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
210  var evt = prefix ? prefix + event : event;
211
212  if (!this._events || !this._events[evt]) return this;
213
214  var listeners = this._events[evt]
215    , events = [];
216
217  if (fn) {
218    if (listeners.fn) {
219      if (
220           listeners.fn !== fn
221        || (once && !listeners.once)
222        || (context && listeners.context !== context)
223      ) {
224        events.push(listeners);
225      }
226    } else {
227      for (var i = 0, length = listeners.length; i < length; i++) {
228        if (
229             listeners[i].fn !== fn
230          || (once && !listeners[i].once)
231          || (context && listeners[i].context !== context)
232        ) {
233          events.push(listeners[i]);
234        }
235      }
236    }
237  }
238
239  //
240  // Reset the array, or remove it completely if we have no more listeners.
241  //
242  if (events.length) {
243    this._events[evt] = events.length === 1 ? events[0] : events;
244  } else {
245    delete this._events[evt];
246  }
247
248  return this;
249};
250
251/**
252 * Remove all listeners or only the listeners for the specified event.
253 *
254 * @param {String} event The event want to remove all listeners for.
255 * @api public
256 */
257EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
258  if (!this._events) return this;
259
260  if (event) delete this._events[prefix ? prefix + event : event];
261  else this._events = prefix ? {} : Object.create(null);
262
263  return this;
264};
265
266//
267// Alias methods names because people roll like that.
268//
269EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
270EventEmitter.prototype.addListener = EventEmitter.prototype.on;
271
272//
273// This function doesn't apply anymore.
274//
275EventEmitter.prototype.setMaxListeners = function setMaxListeners() {
276  return this;
277};
278
279//
280// Expose the prefix.
281//
282EventEmitter.prefixed = prefix;
283
284//
285// Expose the module.
286//
287if ('undefined' !== typeof module) {
288  module.exports = EventEmitter;
289}