1/*!
  2 * clipboard.js v2.0.11
  3 * https://clipboardjs.com/
  4 *
  5 * Licensed MIT © Zeno Rocha
  6 */
  7(function webpackUniversalModuleDefinition(root, factory) {
  8	if(typeof exports === 'object' && typeof module === 'object')
  9		module.exports = factory();
 10	else if(typeof define === 'function' && define.amd)
 11		define([], factory);
 12	else if(typeof exports === 'object')
 13		exports["ClipboardJS"] = factory();
 14	else
 15		root["ClipboardJS"] = factory();
 16})(this, function() {
 17return /******/ (function() { // webpackBootstrap
 18/******/ 	var __webpack_modules__ = ({
 19
 20/***/ 686:
 21/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 22
 23"use strict";
 24
 25// EXPORTS
 26__webpack_require__.d(__webpack_exports__, {
 27  "default": function() { return /* binding */ clipboard; }
 28});
 29
 30// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js
 31var tiny_emitter = __webpack_require__(279);
 32var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);
 33// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
 34var listen = __webpack_require__(370);
 35var listen_default = /*#__PURE__*/__webpack_require__.n(listen);
 36// EXTERNAL MODULE: ./node_modules/select/src/select.js
 37var src_select = __webpack_require__(817);
 38var select_default = /*#__PURE__*/__webpack_require__.n(src_select);
 39;// CONCATENATED MODULE: ./src/common/command.js
 40/**
 41 * Executes a given operation type.
 42 * @param {String} type
 43 * @return {Boolean}
 44 */
 45function command(type) {
 46  try {
 47    return document.execCommand(type);
 48  } catch (err) {
 49    return false;
 50  }
 51}
 52;// CONCATENATED MODULE: ./src/actions/cut.js
 53
 54
 55/**
 56 * Cut action wrapper.
 57 * @param {String|HTMLElement} target
 58 * @return {String}
 59 */
 60
 61var ClipboardActionCut = function ClipboardActionCut(target) {
 62  var selectedText = select_default()(target);
 63  command('cut');
 64  return selectedText;
 65};
 66
 67/* harmony default export */ var actions_cut = (ClipboardActionCut);
 68;// CONCATENATED MODULE: ./src/common/create-fake-element.js
 69/**
 70 * Creates a fake textarea element with a value.
 71 * @param {String} value
 72 * @return {HTMLElement}
 73 */
 74function createFakeElement(value) {
 75  var isRTL = document.documentElement.getAttribute('dir') === 'rtl';
 76  var fakeElement = document.createElement('textarea'); // Prevent zooming on iOS
 77
 78  fakeElement.style.fontSize = '12pt'; // Reset box model
 79
 80  fakeElement.style.border = '0';
 81  fakeElement.style.padding = '0';
 82  fakeElement.style.margin = '0'; // Move element out of screen horizontally
 83
 84  fakeElement.style.position = 'absolute';
 85  fakeElement.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically
 86
 87  var yPosition = window.pageYOffset || document.documentElement.scrollTop;
 88  fakeElement.style.top = "".concat(yPosition, "px");
 89  fakeElement.setAttribute('readonly', '');
 90  fakeElement.value = value;
 91  return fakeElement;
 92}
 93;// CONCATENATED MODULE: ./src/actions/copy.js
 94
 95
 96
 97/**
 98 * Create fake copy action wrapper using a fake element.
 99 * @param {String} target
100 * @param {Object} options
101 * @return {String}
102 */
103
104var fakeCopyAction = function fakeCopyAction(value, options) {
105  var fakeElement = createFakeElement(value);
106  options.container.appendChild(fakeElement);
107  var selectedText = select_default()(fakeElement);
108  command('copy');
109  fakeElement.remove();
110  return selectedText;
111};
112/**
113 * Copy action wrapper.
114 * @param {String|HTMLElement} target
115 * @param {Object} options
116 * @return {String}
117 */
118
119
120var ClipboardActionCopy = function ClipboardActionCopy(target) {
121  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
122    container: document.body
123  };
124  var selectedText = '';
125
126  if (typeof target === 'string') {
127    selectedText = fakeCopyAction(target, options);
128  } else if (target instanceof HTMLInputElement && !['text', 'search', 'url', 'tel', 'password'].includes(target === null || target === void 0 ? void 0 : target.type)) {
129    // If input type doesn't support `setSelectionRange`. Simulate it. https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/setSelectionRange
130    selectedText = fakeCopyAction(target.value, options);
131  } else {
132    selectedText = select_default()(target);
133    command('copy');
134  }
135
136  return selectedText;
137};
138
139/* harmony default export */ var actions_copy = (ClipboardActionCopy);
140;// CONCATENATED MODULE: ./src/actions/default.js
141function _typeof(obj) { "@babel/helpers - typeof"; 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); }
142
143
144
145/**
146 * Inner function which performs selection from either `text` or `target`
147 * properties and then executes copy or cut operations.
148 * @param {Object} options
149 */
150
151var ClipboardActionDefault = function ClipboardActionDefault() {
152  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
153  // Defines base properties passed from constructor.
154  var _options$action = options.action,
155      action = _options$action === void 0 ? 'copy' : _options$action,
156      container = options.container,
157      target = options.target,
158      text = options.text; // Sets the `action` to be performed which can be either 'copy' or 'cut'.
159
160  if (action !== 'copy' && action !== 'cut') {
161    throw new Error('Invalid "action" value, use either "copy" or "cut"');
162  } // Sets the `target` property using an element that will be have its content copied.
163
164
165  if (target !== undefined) {
166    if (target && _typeof(target) === 'object' && target.nodeType === 1) {
167      if (action === 'copy' && target.hasAttribute('disabled')) {
168        throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
169      }
170
171      if (action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
172        throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
173      }
174    } else {
175      throw new Error('Invalid "target" value, use a valid Element');
176    }
177  } // Define selection strategy based on `text` property.
178
179
180  if (text) {
181    return actions_copy(text, {
182      container: container
183    });
184  } // Defines which selection strategy based on `target` property.
185
186
187  if (target) {
188    return action === 'cut' ? actions_cut(target) : actions_copy(target, {
189      container: container
190    });
191  }
192};
193
194/* harmony default export */ var actions_default = (ClipboardActionDefault);
195;// CONCATENATED MODULE: ./src/clipboard.js
196function clipboard_typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { clipboard_typeof = function _typeof(obj) { return typeof obj; }; } else { clipboard_typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return clipboard_typeof(obj); }
197
198function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
199
200function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
201
202function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
203
204function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
205
206function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
207
208function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
209
210function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
211
212function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
213
214function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
215
216function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
217
218
219
220
221
222
223/**
224 * Helper function to retrieve attribute value.
225 * @param {String} suffix
226 * @param {Element} element
227 */
228
229function getAttributeValue(suffix, element) {
230  var attribute = "data-clipboard-".concat(suffix);
231
232  if (!element.hasAttribute(attribute)) {
233    return;
234  }
235
236  return element.getAttribute(attribute);
237}
238/**
239 * Base class which takes one or more elements, adds event listeners to them,
240 * and instantiates a new `ClipboardAction` on each click.
241 */
242
243
244var Clipboard = /*#__PURE__*/function (_Emitter) {
245  _inherits(Clipboard, _Emitter);
246
247  var _super = _createSuper(Clipboard);
248
249  /**
250   * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
251   * @param {Object} options
252   */
253  function Clipboard(trigger, options) {
254    var _this;
255
256    _classCallCheck(this, Clipboard);
257
258    _this = _super.call(this);
259
260    _this.resolveOptions(options);
261
262    _this.listenClick(trigger);
263
264    return _this;
265  }
266  /**
267   * Defines if attributes would be resolved using internal setter functions
268   * or custom functions that were passed in the constructor.
269   * @param {Object} options
270   */
271
272
273  _createClass(Clipboard, [{
274    key: "resolveOptions",
275    value: function resolveOptions() {
276      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
277      this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
278      this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
279      this.text = typeof options.text === 'function' ? options.text : this.defaultText;
280      this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
281    }
282    /**
283     * Adds a click event listener to the passed trigger.
284     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
285     */
286
287  }, {
288    key: "listenClick",
289    value: function listenClick(trigger) {
290      var _this2 = this;
291
292      this.listener = listen_default()(trigger, 'click', function (e) {
293        return _this2.onClick(e);
294      });
295    }
296    /**
297     * Defines a new `ClipboardAction` on each click event.
298     * @param {Event} e
299     */
300
301  }, {
302    key: "onClick",
303    value: function onClick(e) {
304      var trigger = e.delegateTarget || e.currentTarget;
305      var action = this.action(trigger) || 'copy';
306      var text = actions_default({
307        action: action,
308        container: this.container,
309        target: this.target(trigger),
310        text: this.text(trigger)
311      }); // Fires an event based on the copy operation result.
312
313      this.emit(text ? 'success' : 'error', {
314        action: action,
315        text: text,
316        trigger: trigger,
317        clearSelection: function clearSelection() {
318          if (trigger) {
319            trigger.focus();
320          }
321
322          window.getSelection().removeAllRanges();
323        }
324      });
325    }
326    /**
327     * Default `action` lookup function.
328     * @param {Element} trigger
329     */
330
331  }, {
332    key: "defaultAction",
333    value: function defaultAction(trigger) {
334      return getAttributeValue('action', trigger);
335    }
336    /**
337     * Default `target` lookup function.
338     * @param {Element} trigger
339     */
340
341  }, {
342    key: "defaultTarget",
343    value: function defaultTarget(trigger) {
344      var selector = getAttributeValue('target', trigger);
345
346      if (selector) {
347        return document.querySelector(selector);
348      }
349    }
350    /**
351     * Allow fire programmatically a copy action
352     * @param {String|HTMLElement} target
353     * @param {Object} options
354     * @returns Text copied.
355     */
356
357  }, {
358    key: "defaultText",
359
360    /**
361     * Default `text` lookup function.
362     * @param {Element} trigger
363     */
364    value: function defaultText(trigger) {
365      return getAttributeValue('text', trigger);
366    }
367    /**
368     * Destroy lifecycle.
369     */
370
371  }, {
372    key: "destroy",
373    value: function destroy() {
374      this.listener.destroy();
375    }
376  }], [{
377    key: "copy",
378    value: function copy(target) {
379      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
380        container: document.body
381      };
382      return actions_copy(target, options);
383    }
384    /**
385     * Allow fire programmatically a cut action
386     * @param {String|HTMLElement} target
387     * @returns Text cutted.
388     */
389
390  }, {
391    key: "cut",
392    value: function cut(target) {
393      return actions_cut(target);
394    }
395    /**
396     * Returns the support of the given action, or all actions if no action is
397     * given.
398     * @param {String} [action]
399     */
400
401  }, {
402    key: "isSupported",
403    value: function isSupported() {
404      var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
405      var actions = typeof action === 'string' ? [action] : action;
406      var support = !!document.queryCommandSupported;
407      actions.forEach(function (action) {
408        support = support && !!document.queryCommandSupported(action);
409      });
410      return support;
411    }
412  }]);
413
414  return Clipboard;
415}((tiny_emitter_default()));
416
417/* harmony default export */ var clipboard = (Clipboard);
418
419/***/ }),
420
421/***/ 828:
422/***/ (function(module) {
423
424var DOCUMENT_NODE_TYPE = 9;
425
426/**
427 * A polyfill for Element.matches()
428 */
429if (typeof Element !== 'undefined' && !Element.prototype.matches) {
430    var proto = Element.prototype;
431
432    proto.matches = proto.matchesSelector ||
433                    proto.mozMatchesSelector ||
434                    proto.msMatchesSelector ||
435                    proto.oMatchesSelector ||
436                    proto.webkitMatchesSelector;
437}
438
439/**
440 * Finds the closest parent that matches a selector.
441 *
442 * @param {Element} element
443 * @param {String} selector
444 * @return {Function}
445 */
446function closest (element, selector) {
447    while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
448        if (typeof element.matches === 'function' &&
449            element.matches(selector)) {
450          return element;
451        }
452        element = element.parentNode;
453    }
454}
455
456module.exports = closest;
457
458
459/***/ }),
460
461/***/ 438:
462/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
463
464var closest = __webpack_require__(828);
465
466/**
467 * Delegates event to a selector.
468 *
469 * @param {Element} element
470 * @param {String} selector
471 * @param {String} type
472 * @param {Function} callback
473 * @param {Boolean} useCapture
474 * @return {Object}
475 */
476function _delegate(element, selector, type, callback, useCapture) {
477    var listenerFn = listener.apply(this, arguments);
478
479    element.addEventListener(type, listenerFn, useCapture);
480
481    return {
482        destroy: function() {
483            element.removeEventListener(type, listenerFn, useCapture);
484        }
485    }
486}
487
488/**
489 * Delegates event to a selector.
490 *
491 * @param {Element|String|Array} [elements]
492 * @param {String} selector
493 * @param {String} type
494 * @param {Function} callback
495 * @param {Boolean} useCapture
496 * @return {Object}
497 */
498function delegate(elements, selector, type, callback, useCapture) {
499    // Handle the regular Element usage
500    if (typeof elements.addEventListener === 'function') {
501        return _delegate.apply(null, arguments);
502    }
503
504    // Handle Element-less usage, it defaults to global delegation
505    if (typeof type === 'function') {
506        // Use `document` as the first parameter, then apply arguments
507        // This is a short way to .unshift `arguments` without running into deoptimizations
508        return _delegate.bind(null, document).apply(null, arguments);
509    }
510
511    // Handle Selector-based usage
512    if (typeof elements === 'string') {
513        elements = document.querySelectorAll(elements);
514    }
515
516    // Handle Array-like based usage
517    return Array.prototype.map.call(elements, function (element) {
518        return _delegate(element, selector, type, callback, useCapture);
519    });
520}
521
522/**
523 * Finds closest match and invokes callback.
524 *
525 * @param {Element} element
526 * @param {String} selector
527 * @param {String} type
528 * @param {Function} callback
529 * @return {Function}
530 */
531function listener(element, selector, type, callback) {
532    return function(e) {
533        e.delegateTarget = closest(e.target, selector);
534
535        if (e.delegateTarget) {
536            callback.call(element, e);
537        }
538    }
539}
540
541module.exports = delegate;
542
543
544/***/ }),
545
546/***/ 879:
547/***/ (function(__unused_webpack_module, exports) {
548
549/**
550 * Check if argument is a HTML element.
551 *
552 * @param {Object} value
553 * @return {Boolean}
554 */
555exports.node = function(value) {
556    return value !== undefined
557        && value instanceof HTMLElement
558        && value.nodeType === 1;
559};
560
561/**
562 * Check if argument is a list of HTML elements.
563 *
564 * @param {Object} value
565 * @return {Boolean}
566 */
567exports.nodeList = function(value) {
568    var type = Object.prototype.toString.call(value);
569
570    return value !== undefined
571        && (type === '[object NodeList]' || type === '[object HTMLCollection]')
572        && ('length' in value)
573        && (value.length === 0 || exports.node(value[0]));
574};
575
576/**
577 * Check if argument is a string.
578 *
579 * @param {Object} value
580 * @return {Boolean}
581 */
582exports.string = function(value) {
583    return typeof value === 'string'
584        || value instanceof String;
585};
586
587/**
588 * Check if argument is a function.
589 *
590 * @param {Object} value
591 * @return {Boolean}
592 */
593exports.fn = function(value) {
594    var type = Object.prototype.toString.call(value);
595
596    return type === '[object Function]';
597};
598
599
600/***/ }),
601
602/***/ 370:
603/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
604
605var is = __webpack_require__(879);
606var delegate = __webpack_require__(438);
607
608/**
609 * Validates all params and calls the right
610 * listener function based on its target type.
611 *
612 * @param {String|HTMLElement|HTMLCollection|NodeList} target
613 * @param {String} type
614 * @param {Function} callback
615 * @return {Object}
616 */
617function listen(target, type, callback) {
618    if (!target && !type && !callback) {
619        throw new Error('Missing required arguments');
620    }
621
622    if (!is.string(type)) {
623        throw new TypeError('Second argument must be a String');
624    }
625
626    if (!is.fn(callback)) {
627        throw new TypeError('Third argument must be a Function');
628    }
629
630    if (is.node(target)) {
631        return listenNode(target, type, callback);
632    }
633    else if (is.nodeList(target)) {
634        return listenNodeList(target, type, callback);
635    }
636    else if (is.string(target)) {
637        return listenSelector(target, type, callback);
638    }
639    else {
640        throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
641    }
642}
643
644/**
645 * Adds an event listener to a HTML element
646 * and returns a remove listener function.
647 *
648 * @param {HTMLElement} node
649 * @param {String} type
650 * @param {Function} callback
651 * @return {Object}
652 */
653function listenNode(node, type, callback) {
654    node.addEventListener(type, callback);
655
656    return {
657        destroy: function() {
658            node.removeEventListener(type, callback);
659        }
660    }
661}
662
663/**
664 * Add an event listener to a list of HTML elements
665 * and returns a remove listener function.
666 *
667 * @param {NodeList|HTMLCollection} nodeList
668 * @param {String} type
669 * @param {Function} callback
670 * @return {Object}
671 */
672function listenNodeList(nodeList, type, callback) {
673    Array.prototype.forEach.call(nodeList, function(node) {
674        node.addEventListener(type, callback);
675    });
676
677    return {
678        destroy: function() {
679            Array.prototype.forEach.call(nodeList, function(node) {
680                node.removeEventListener(type, callback);
681            });
682        }
683    }
684}
685
686/**
687 * Add an event listener to a selector
688 * and returns a remove listener function.
689 *
690 * @param {String} selector
691 * @param {String} type
692 * @param {Function} callback
693 * @return {Object}
694 */
695function listenSelector(selector, type, callback) {
696    return delegate(document.body, selector, type, callback);
697}
698
699module.exports = listen;
700
701
702/***/ }),
703
704/***/ 817:
705/***/ (function(module) {
706
707function select(element) {
708    var selectedText;
709
710    if (element.nodeName === 'SELECT') {
711        element.focus();
712
713        selectedText = element.value;
714    }
715    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
716        var isReadOnly = element.hasAttribute('readonly');
717
718        if (!isReadOnly) {
719            element.setAttribute('readonly', '');
720        }
721
722        element.select();
723        element.setSelectionRange(0, element.value.length);
724
725        if (!isReadOnly) {
726            element.removeAttribute('readonly');
727        }
728
729        selectedText = element.value;
730    }
731    else {
732        if (element.hasAttribute('contenteditable')) {
733            element.focus();
734        }
735
736        var selection = window.getSelection();
737        var range = document.createRange();
738
739        range.selectNodeContents(element);
740        selection.removeAllRanges();
741        selection.addRange(range);
742
743        selectedText = selection.toString();
744    }
745
746    return selectedText;
747}
748
749module.exports = select;
750
751
752/***/ }),
753
754/***/ 279:
755/***/ (function(module) {
756
757function E () {
758  // Keep this empty so it's easier to inherit from
759  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
760}
761
762E.prototype = {
763  on: function (name, callback, ctx) {
764    var e = this.e || (this.e = {});
765
766    (e[name] || (e[name] = [])).push({
767      fn: callback,
768      ctx: ctx
769    });
770
771    return this;
772  },
773
774  once: function (name, callback, ctx) {
775    var self = this;
776    function listener () {
777      self.off(name, listener);
778      callback.apply(ctx, arguments);
779    };
780
781    listener._ = callback
782    return this.on(name, listener, ctx);
783  },
784
785  emit: function (name) {
786    var data = [].slice.call(arguments, 1);
787    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
788    var i = 0;
789    var len = evtArr.length;
790
791    for (i; i < len; i++) {
792      evtArr[i].fn.apply(evtArr[i].ctx, data);
793    }
794
795    return this;
796  },
797
798  off: function (name, callback) {
799    var e = this.e || (this.e = {});
800    var evts = e[name];
801    var liveEvents = [];
802
803    if (evts && callback) {
804      for (var i = 0, len = evts.length; i < len; i++) {
805        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
806          liveEvents.push(evts[i]);
807      }
808    }
809
810    // Remove event from queue to prevent memory leak
811    // Suggested by https://github.com/lazd
812    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
813
814    (liveEvents.length)
815      ? e[name] = liveEvents
816      : delete e[name];
817
818    return this;
819  }
820};
821
822module.exports = E;
823module.exports.TinyEmitter = E;
824
825
826/***/ })
827
828/******/ 	});
829/************************************************************************/
830/******/ 	// The module cache
831/******/ 	var __webpack_module_cache__ = {};
832/******/ 	
833/******/ 	// The require function
834/******/ 	function __webpack_require__(moduleId) {
835/******/ 		// Check if module is in cache
836/******/ 		if(__webpack_module_cache__[moduleId]) {
837/******/ 			return __webpack_module_cache__[moduleId].exports;
838/******/ 		}
839/******/ 		// Create a new module (and put it into the cache)
840/******/ 		var module = __webpack_module_cache__[moduleId] = {
841/******/ 			// no module.id needed
842/******/ 			// no module.loaded needed
843/******/ 			exports: {}
844/******/ 		};
845/******/ 	
846/******/ 		// Execute the module function
847/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
848/******/ 	
849/******/ 		// Return the exports of the module
850/******/ 		return module.exports;
851/******/ 	}
852/******/ 	
853/************************************************************************/
854/******/ 	/* webpack/runtime/compat get default export */
855/******/ 	!function() {
856/******/ 		// getDefaultExport function for compatibility with non-harmony modules
857/******/ 		__webpack_require__.n = function(module) {
858/******/ 			var getter = module && module.__esModule ?
859/******/ 				function() { return module['default']; } :
860/******/ 				function() { return module; };
861/******/ 			__webpack_require__.d(getter, { a: getter });
862/******/ 			return getter;
863/******/ 		};
864/******/ 	}();
865/******/ 	
866/******/ 	/* webpack/runtime/define property getters */
867/******/ 	!function() {
868/******/ 		// define getter functions for harmony exports
869/******/ 		__webpack_require__.d = function(exports, definition) {
870/******/ 			for(var key in definition) {
871/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
872/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
873/******/ 				}
874/******/ 			}
875/******/ 		};
876/******/ 	}();
877/******/ 	
878/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
879/******/ 	!function() {
880/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
881/******/ 	}();
882/******/ 	
883/************************************************************************/
884/******/ 	// module exports must be returned from runtime so entry inlining is disabled
885/******/ 	// startup
886/******/ 	// Load entry module and return exports
887/******/ 	return __webpack_require__(686);
888/******/ })()
889.default;
890});