https://bafagolu.org/assets/gallery/assets/vendor/images-loaded/imagesloaded.js

66ontaining bar and baz. But only if you have either defined them with defineEvent or added some listeners to them.
67     * Each property in the object response is an array of listener functions.
68     *
69     * @param {String|RegExp} evt Name of the event to return the listeners from.
70     * @return {Function[]|Object} All listener functions for the event.
71     */
72    proto.getListeners = function getListeners(evt) {
73        var events = this._getEvents();
74        var response;
75        var key;
76
77        // Return a concatenated array of all matching events if
78        // the selector is a regular expression.
79        if (typeof evt === 'object') {
80            response = {};
81            for (key in events) {
82                if (events.hasOwnProperty(key) && evt.test(key)) {
83                    response[key] = events[key];
84                }
85            }
86        }
87        else {
88            response = events[evt] || (events[evt] = []);
89        }
90
91        return response;
92    };
93
94    /**
95     * Takes a list of listener objects and flattens it into a list of listener functions.
96     *
97     * @param {Object[]} listeners Raw listener objects.
98     * @return {Function[]} Just the listener functions.
99     */
100    proto.flattenListeners = function flattenListeners(listeners) {
101        var flatListeners = [];
102        var i;
103
104        for (i = 0; i < listeners.length; i += 1) {
105            flatListeners.push(listeners[i].listener);
106        }
107
108        return flatListeners;
109    };
110
111    /**
112     * Fetches the requested listeners via getListeners but will always return the results inside an object. This is mainly for internal use but others may find it useful.
113     *
114     * @param {String|RegExp} evt Name of the event to return the listeners from.
115     * @return {Object} All listener functions for an event in an object.
116     */
117    proto.getListenersAsObject = function getListenersAsObject(evt) {
118        var listeners = this.getListeners(evt);
119        var response;
120
121        if (listeners instanceof Array) {
122            response = {};
123            response[evt] = listeners;
124        }
125
126        return response || listeners;
127    };
128
129    /**
130     * Adds a listener function to the specified event.
131     * The listener will not be added if it is a duplicate.
132     * If the listener returns true then it will be removed after it is called.
133     * If you pass a regular expression as the event name then the listener will be added to all events that match it.
134     *
135     * @param {String|RegExp} evt Name of the event to attach the listener to.
136     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
137     * @return {Object} Current instance of EventEmitter for chaining.
138     */
139    proto.addListener = function addListener(evt, listener) {
140        var listeners = this.getListenersAsObject(evt);
141        var listenerIsWrapped = typeof listener === 'object';
142        var key;
143
144        for (key in listeners) {
145            if (listeners.hasOwnProperty(key) && indexOfListener(listeners[key], listener) === -1) {
146                listeners[key].push(listenerIsWrapped ? listener : {
147                    listener: listener,
148                    once: false
149                });
150            }
151        }
152
153        return this;
154    };
155
156    /**
157     * Alias of addListener
158     */
159    proto.on = alias('addListener');
160
161    /**
162     * Semi-alias of addListener. It will add a listener that will be
163     * automatically removed after it's first execution.
164     *
165     * @param {String|RegExp} evt Name of the event to attach the listener to.
166     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
167     * @return {Object} Current instance of EventEmitter for chaining.
168     */
169    proto.addOnceListener = function addOnceListener(evt, listener) {
170        return this.addListener(evt, {
171            listener: listener,
172            once: true
173        });
174    };
175
176    /**
177     * Alias of addOnceListener.
178     */
179    proto.once = alias('addOnceListener');
180
181    /**
182     * Defines an event name. This is required if you want to use a regex to add a listener to multiple events at once. If you don't do this then how do you expect it to know what event to add to? Should it just add to every possible match for a regex? No. That is scary and bad.
183     * You need to tell it what event names should be matched by a regex.
184     *
185     * @param {String} evt Name of the event to create.
186     * @return {Object} Current instance of EventEmitter for chaining.
187     */
188    proto.defineEvent = function defineEvent(evt) {
189        this.getListeners(evt);
190        return this;
191    };
192
193    /**
194     * Uses defineEvent to define multiple events.
195     *
196     * @param {String[]} evts An array of event names to define.
197     * @return {Object} Current instance of EventEmitter for chaining.
198     */
199    proto.defineEvents = function defineEvents(evts) {
200        for (var i = 0; i < evts.length; i += 1) {
201            this.defineEvent(evts[i]);
202        }
203        return this;
204    };
205
206    /**
207     * Removes a listener function from the specified event.
208     * When passed a regular expression as the event name, it will remove the listener from all events that match it.
209     *
210     * @param {String|RegExp} evt Name of the event to remove the listener from.
211     * @param {Function} listener Method to remove from the event.
212     * @return {Object} Current instance of EventEmitter for chaining.
213     */
214    proto.removeListener = function removeListener(evt, listener) {
215        var listeners = this.getListenersAsObject(evt);
216        var index;
217        var key;
218
219        for (key in listeners) {
220            if (listeners.hasOwnProperty(key)) {
221                index = indexOfListener(listeners[key], listener);
222
223                if (index !== -1) {
224                    listeners[key].splice(index, 1);
225                }
226            }
227        }
228
229        return this;
230    };
231
232    /**
233     * Alias of removeListener
234     */
235    proto.off = alias('removeListener');
236
237    /**
238     * Adds listeners in bulk using the manipulateListeners method.
239     * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. You can also pass it an event name and an array of listeners to be added.
240     * You can also pass it a regular expression to add the array of listeners to all events that match it.
241     * Yeah, this function does quite a bit. That's probably a bad thing.
242     *
243     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.
244     * @param {Function[]} [listeners] An optional array of listener functions to add.
245     * @return {Object} Current instance of EventEmitter for chaining.
246     */
247    proto.addListeners = function addListeners(evt, listeners) {
248        // Pass through to manipulateListeners
249        return this.manipulateListeners(false, evt, listeners);
250    };
251
252    /**
253     * Removes listeners in bulk using the manipulateListeners method.
254     * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
255     * You can also pass it an event name and an array of listeners to be removed.
256     * You can also pass it a regular expression to remove the listeners from all events that match it.
257     *
258     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.
259     * @param {Function[]} [listeners] An optional array of listener functions to remove.
260     * @return {Object} Current instance of EventEmitter for chaining.
261     */
262    proto.removeListeners = function removeListeners(evt, listeners) {
263        // Pass through to manipulateListeners
264        return this.manipulateListeners(true, evt, listeners);
265    };
266
267    /**
268     * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.
269     * The first argument will determine if the listeners are removed (true) or added (false).
270     * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
271     * You can also pass it an event name and an array of listeners to be added/removed.
272     * You can also pass it a regular expression to manipulate the listeners of all events that match it.
273     *
274     * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
275     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.
276     * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
277     * @return {Object} Current instance of EventEmitter for chaining.
278     */
279    proto.manipulateListeners = function manipulateListeners(remove, evt, listeners) {
280        var i;
281        var value;
282        var single = remove ? this.removeListener : this.addListener;
283        var multiple = remove ? this.removeListeners : this.addListeners;
284
285        // If evt is an object then pass each of it's properties to this method
286        if (typeof evt === 'object' && !(evt instanceof RegExp)) {
287            for (i in evt) {
288                if (evt.hasOwnProperty(i) && (value = evt[i])) {
289                    // Pass the single listener straight through to the singular method
290                    if (typeof value === 'function') {
291                        single.call(this, i, value);
292                    }
293                    else {
294                        // Otherwise pass back to the multiple function
295                        multiple.call(this, i, value);
296                    }
297                }
298            }
299        }
300        else {
301            // So evt must be a string
302            // And listeners must be an array of listeners
303            // Loop over it and pass each one to the multiple method
304            i = listeners.length;
305            while (i--) {
306                single.call(this, evt, listeners[i]);
307            }
308        }
309
310        return this;
311    };
312
313    /**
314     * Removes all listeners from a specified event.
315     * If you do not specify an event then all listeners will be removed.
316     * That means every event will be emptied.
317     * You can also pass a regex to remove all events that match it.
318     *
319     * @param {String|RegExp} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.
320     * @return {Object} Current instance of EventEmitter for chaining.
321     */
322    proto.removeEvent = function removeEvent(evt) {
323        var type = typeof evt;
324        var events = this._getEvents();
325        var key;
326
327        // Remove different things depending on the state of evt
328        if (type === 'string') {
329            // Remove all listeners for the specified event
330            delete events[evt];
331        }
332        else if (type === 'object') {
333            // Remove all events matching the regex.
334            for (key in events) {
335                if (events.hasOwnProperty(key) && evt.test(key)) {
336                    delete events[key];
337                }
338            }
339        }
340        else {
341            // Remove all listeners in all events
342            delete this._events;
343        }
344
345        return this;
346    };
347
348    /**
349     * Alias of removeEvent.
350     *
351     * Added to mirror the node API.
352     */
353    proto.removeAllListeners = alias('removeEvent');
354
355    /**
356     * Emits an event of your choice.
357     * When emitted, every listener attached to that event will be executed.
358     * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
359     * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
360     * So they will not arrive within the array on the other side, they will be separate.
361     * You can also pass a regular expression to emit to all events that match it.
362     *
363     * @param {String|RegExp} evt Name of the event to emit and execute listeners for.
364     * @param {Array} [args] Optional array of arguments to be passed to each listener.
365     * @return {Object} Current instance of EventEmitter for chaining.
366     */
367    proto.emitEvent = function emitEvent(evt, args) {
368        var listeners = this.getListenersAsObject(evt);
369        var listener;
370        var i;
371        var key;
372        var response;
373
374        for (key in listeners) {
375            if (listeners.hasOwnProperty(key)) {
376                i = listeners[key].length;
377
378                while (i--) {
379                    // If the listener returns true then it shall be removed from the event
380                    // The function is executed either with a basic call or an apply if there is an args array
381                    listener = listeners[key][i];
382
383                    if (listener.once === true) {
384                        this.removeListener(evt, listener.listener);
385                    }
386
387                    response = listener.listener.apply(this, args || []);
388
389                    if (response === this._getOnceReturnValue()) {
390                        this.removeListener(evt, listener.listener);
391                    }
392                }
393            }
394        }
395
396        return this;
397    };
398
399    /**
400     * Alias of emitEvent
401     */
402    proto.trigger = alias('emitEvent');
403
404    /**
405     * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as opposed to taking a single array of arguments to pass on.
406     * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.
407     *
408     * @param {String|RegExp} evt Name of the event to emit and execute listeners for.
409     * @param {...*} Optional additional arguments to be passed to each listener.
410     * @return {Object} Current instance of EventEmitter for chaining.
411     */
412    proto.emit = function emit(evt) {
413        var args = Array.prototype.slice.call(arguments, 1);
414        return this.emitEvent(evt, args);
415    };
416
417    /**
418     * Sets the current value to check against when executing listeners. If a
419     * listeners return value matches the one set here then it will be removed
420     * after execution. This value defaults to true.
421     *
422     * @param {*} value The new value to check for when executing listeners.
423     * @return {Object} Current instance of EventEmitter for chaining.
424     */
425    proto.setOnceReturnValue = function setOnceReturnValue(value) {
426        this._onceReturnValue = value;
427        return this;
428    };
429
430    /**
431     * Fetches the current value to check against when executing listeners. If
432     * the listeners return value matches this one then it should be removed
433     * automatically. It will return true by default.
434     *
435     * @return {*|Boolean} The current value to check for or the default, true.
436     * @api private
437     */
438    proto._getOnceReturnValue = function _getOnceReturnValue() {
439        if (this.hasOwnProperty('_onceReturnValue')) {
440            return this._onceReturnValue;
441        }
442        else {
443            return true;
444        }
445    };
446
447    /**
448     * Fetches the events object and creates one if required.
449     *
450     * @return {Object} The events storage object.
451     * @api private
452     */
453    proto._getEvents = function _getEvents() {
454        return this._events || (this._events = {});
455    };
456
457    /**
458     * Reverts the global {@link EventEmitter} to its previous value and returns a reference to this version.
459     *
460     * @return {Function} Non conflicting EventEmitter class.
461     */
462    EventEmitter.noConflict = function noConflict() {
463        exports.EventEmitter = originalGlobalValue;
464        return EventEmitter;
465    };
466
467    // Expose the class either via AMD, CommonJS or the global object
468    if (typeof define === 'function' && define.amd) {
469        define('eventEmitter/EventEmitter',[],function () {
470            return EventEmitter;
471