https://sudreporter.org/wp-content/themes/sudreporter/js/clipboard.js?ver=1.0.0

1/*!
2 * clipboard.js v2.0.8
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/***/ 747:
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/clipboard-action-cut.js
53
54
55/**
56 * Cut action wrapper.
57 * @param {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 clipboard_action_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/clipboard-action-copy.js
94
95
96
97/**
98 * Copy action wrapper.
99 * @param {String|HTMLElement} target
100 * @param {Object} options
101 * @return {String}
102 */
103
104var ClipboardActionCopy = function ClipboardActionCopy(target) {
105  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
106    container: document.body
107  };
108  var selectedText = '';
109
110  if (typeof target === 'string') {
111    var fakeElement = createFakeElement(target);
112    options.container.appendChild(fakeElement);
113    selectedText = select_default()(fakeElement);
114    command('copy');
115    fakeElement.remove();
116  } else {
117    selectedText = select_default()(target);
118    command('copy');
119  }
120
121  return selectedText;
122};
123
124/* harmony default export */ var clipboard_action_copy = (ClipboardActionCopy);
125;// CONCATENATED MODULE: ./src/clipboard-action-default.js
126function _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); }
127
128
129
130/**
131 * Inner function which performs selection from either `text` or `target`
132 * properties and then executes copy or cut operations.
133 * @param {Object} options
134 */
135
136var ClipboardActionDefault = function ClipboardActionDefault() {
137  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
138  // Defines base properties passed from constructor.
139  var _options$action = options.action,
140      action = _options$action === void 0 ? 'copy' : _options$action,
141      container = options.container,
142      target = options.target,
143      text = options.text; // Sets the `action` to be performed which can be either 'copy' or 'cut'.
144
145  if (action !== 'copy' && action !== 'cut') {
146    throw new Error('Invalid "action" value, use either "copy" or "cut"');
147  } // Sets the `target` property using an element that will be have its content copied.
148
149
150  if (target !== undefined) {
151    if (target && _typeof(target) === 'object' && target.nodeType === 1) {
152      if (action === 'copy' && target.hasAttribute('disabled')) {
153        throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
154      }
155
156      if (action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
157        throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
158      }
159    } else {
160      throw new Error('Invalid "target" value, use a valid Element');
161    }
162  } // Define selection strategy based on `text` property.
163
164
165  if (text) {
166    return clipboard_action_copy(text, {
167      container: container
168    });
169  } // Defines which selection strategy based on `target` property.
170
171
172  if (target) {
173    return action === 'cut' ? clipboard_action_cut(target) : clipboard_action_copy(target, {
174      container: container
175    });
176  }
177};
178
179/* harmony default export */ var clipboard_action_default = (ClipboardActionDefault);
180;// CONCATENATED MODULE: ./src/clipboard.js
181function 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); }
182
183function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
184
185function _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); } }
186
187function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
188
189function _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); }
190
191function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
192
193function _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); }; }
194
195function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
196
197function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
198
199function _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; } }
200

201function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
202
203
204
205
206
207
208/**
209 * Helper function to retrieve attribute value.
210 * @param {String} suffix
211 * @param {Element} element
212 */
213
214function getAttributeValue(suffix, element) {
215  var attribute = "data-clipboard-".concat(suffix);
216
217  if (!element.hasAttribute(attribute)) {
218    return;
219  }
220
221  return element.getAttribute(attribute);
222}
223/**
224 * Base class which takes one or more elements, adds event listeners to them,
225 * and instantiates a new `ClipboardAction` on each click.
226 */
227
228
229var Clipboard = /*#__PURE__*/function (_Emitter) {
230  _inherits(Clipboard, _Emitter);
231
232  var _super = _createSuper(Clipboard);
233
234  /**
235   * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
236   * @param {Object} options
237   */
238  function Clipboard(trigger, options) {
239    var _this;
240
241    _classCallCheck(this, Clipboard);
242
243    _this = _super.call(this);
244    _this.ClipboardActionCut = clipboard_action_cut.bind(_assertThisInitialized(_this));
245    _this.ClipboardActionCopy = clipboard_action_copy.bind(_assertThisInitialized(_this));
246
247    _this.resolveOptions(options);
248
249    _this.listenClick(trigger);
250
251    return _this;
252  }
253  /**
254   * Defines if attributes would be resolved using internal setter functions
255   * or custom functions that were passed in the constructor.
256   * @param {Object} options
257   */
258
259
260  _createClass(Clipboard, [{
261    key: "resolveOptions",
262    value: function resolveOptions() {
263      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
264      this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
265      this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
266      this.text = typeof options.text === 'function' ? options.text : this.defaultText;
267      this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
268    }
269    /**
270     * Adds a click event listener to the passed trigger.
271     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
272     */
273
274  }, {
275    key: "listenClick",
276    value: function listenClick(trigger) {
277      var _this2 = this;
278
279      this.listener = listen_default()(trigger, 'click', function (e) {
280        return _this2.onClick(e);
281      });
282    }
283    /**
284     * Defines a new `ClipboardAction` on each click event.
285     * @param {Event} e
286     */
287
288  }, {
289    key: "onClick",
290    value: function onClick(e) {
291      var trigger = e.delegateTarget || e.currentTarget;
292      var selectedText = clipboard_action_default({
293        action: this.action(trigger),
294        container: this.container,
295        target: this.target(trigger),
296        text: this.text(trigger)
297      }); // Fires an event based on the copy operation result.
298
299      this.emit(selectedText ? 'success' : 'error', {
300        action: this.action,
301        text: selectedText,
302        trigger: trigger,
303        clearSelection: function clearSelection() {
304          if (trigger) {
305            trigger.focus();
306          }
307
308          document.activeElement.blur();
309          window.getSelection().removeAllRanges();
310        }
311      });
312    }
313    /**
314     * Default `action` lookup function.
315     * @param {Element} trigger
316     */
317
318  }, {
319    key: "defaultAction",
320    value: function defaultAction(trigger) {
321      return getAttributeValue('action', trigger);
322    }
323    /**
324     * Default `target` lookup function.
325     * @param {Element} trigger
326     */
327
328  }, {
329    key: "defaultTarget",
330    value: function defaultTarget(trigger) {
331      var selector = getAttributeValue('target', trigger);
332
333      if (selector) {
334        return document.querySelector(selector);
335      }
336    }
337  }, {
338    key: "defaultText",
339
340    /**
341     * Default `text` lookup function.
342     * @param {Element} trigger
343     */
344    value: function defaultText(trigger) {
345      return getAttributeValue('text', trigger);
346    }
347    /**
348     * Destroy lifecycle.
349     */
350
351  }, {

352    key: "destroy",
353    value: function destroy() {
354      this.listener.destroy();
355    }
356  }], [{
357    key: "copy",
358    value: function copy(target) {
359      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
360        container: document.body
361      };
362      return clipboard_action_copy(target, options);
363    }
364  }, {
365    key: "cut",
366    value: function cut(target) {
367      return clipboard_action_cut(target);
368    }
369    /**
370     * Returns the support of the given action, or all actions if no action is
371     * given.
372     * @param {String} [action]
373     */
374
375  }, {
376    key: "isSupported",
377    value: function isSupported() {
378      var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
379      var actions = typeof action === 'string' ? [action] : action;
380      var support = !!document.queryCommandSupported;
381      actions.forEach(function (action) {
382        support = support && !!document.queryCommandSupported(action);
383      });
384      return support;
385    }
386  }]);
387
388  return Clipboard;
389}((tiny_emitter_default()));
390
391/* harmony default export */ var clipboard = (Clipboard);
392
393/***/ }),
394
395/***/ 828:
396/***/ (function(module) {
397
398var DOCUMENT_NODE_TYPE = 9;
399
400/**
401 * A polyfill for Element.matches()
402 */
403if (typeof Element !== 'undefined' && !Element.prototype.matches) {
404    var proto = Element.prototype;
405
406    proto.matches = proto.matchesSelector ||
407                    proto.mozMatchesSelector ||
408                    proto.msMatchesSelector ||
409                    proto.oMatchesSelector ||
410                    proto.webkitMatchesSelector;
411}
412
413/**
414 * Finds the closest parent that matches a selector.
415 *
416 * @param {Element} element
417 * @param {String} selector
418 * @return {Function}
419 */
420function closest (element, selector) {
421    while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
422        if (typeof element.matches === 'function' &&
423            element.matches(selector)) {
424          return element;
425        }
426        element = element.parentNode;
427    }
428}
429
430module.exports = closest;
431
432
433/***/ }),
434
435/***/ 438:
436/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
437
438var closest = __webpack_require__(828);
439
440/**
441 * Delegates event to a selector.
442 *
443 * @param {Element} element
444 * @param {String} selector
445 * @param {String} type
446 * @param {Function} callback
447 * @param {Boolean} useCapture
448 * @return {Object}
449 */
450function _delegate(element, selector, type, callback, useCapture) {
451    var listenerFn = listener.apply(this, arguments);
452
453    element.addEventListener(type, listenerFn, useCapture);
454
455    return {
456        destroy: function() {
457            element.removeEventListener(type, listenerFn, useCapture);
458        }
459    }
460}
461
462/**
463 * Delegates event to a selector.
464 *
465 * @param {Element|String|Array} [elements]
466 * @param {String} selector
467 * @param {String} type
468 * @param {Function} callback
469 * @param {Boolean} useCapture
470 * @return {Object}
471 */
472function delegate(elements, selector, type, callback, useCapture) {
473    // Handle the regular Element usage
474    if (typeof elements.addEventListener === 'function') {
475        return _delegate.apply(null, arguments);
476    }
477
478    // Handle Element-less usage, it defaults to global delegation
479    if (typeof type === 'function') {
480        // Use `document` as the first parameter, then apply arguments
481        // This is a short way to .unshift `arguments` without running into deoptimizations
482        return _delegate.bind(null, document).apply(null, arguments);
483    }
484
485    // Handle Selector-based usage
486    if (typeof elements === 'string') {
487        elements = document.querySelectorAll(elements);
488    }
489
490    // Handle Array-like based usage
491    return Array.prototype.map.call(elements, function (element) {
492        return _delegate(element, selector, type, callback, useCapture);
493    });
494}
495
496/**
497 * Finds closest match and invokes callback.
498 *
499 * @param {Element} element
500 * @param {String} selector
501 * @param {String} type
502 * @param {Function} callback
503 * @return {Function}
504 */
505function listener(element, selector, type, callback) {
506    return function(e) {
507        e.delegateTarget = closest(e.target, selector);
508
509        if (e.delegateTarget) {
510            callback.call(element, e);
511        }
512    }
513}
514
515module.exports = delegate;
516
517
518/***/ }),
519
520/***/ 879:
521/***/ (function(__unused_webpack_module, exports) {
522
523/**
524 * Check if argument is a HTML element.
525 *
526 * @param {Object} value
527 * @return {Boolean}
528 */
529exports.node = function(value) {
530    return value !== undefined
531        && value instanceof HTMLElement
532        && value.nodeType === 1;
533};
534
535/**
536 * Check if argument is a list of HTML elements.
537 *
538 * @param {Object} value
539 * @return {Boolean}
540 */
541exports.nodeList = function(value) {
542    var type = Object.prototype.toString.call(value);
543
544    return value !== undefined
545        && (type === '[object NodeList]' || type === '[object HTMLCollection]')
546        && ('length' in value)
547        && (value.length === 0 || exports.node(value[0]));
548};
549
550/**
551 * Check if argument is a string.
552 *
553 * @param {Object} value
554 * @return {Boolean}
555 */
556exports.string = function(value) {
557    return typeof value === 'string'
558        || value instanceof String;
559};
560
561/**
562 * Check if argument is a function.
563 *
564 * @param {Object} value
565 * @return {Boolean}
566 */
567exports.fn = function(value) {
568    var type = Object.prototype.toString.call(value);
569
570    return type === '[object Function]';
571};
572
573
574/***/ }),
575
576/***/ 370:
577/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
578
579var is = __webpack_require__(879);
580var delegate = __webpack_require__(438);
581
582/**
583 * Validates all params and calls the right
584 * listener function based on its target type.
585 *
586 * @param {String|HTMLElement|HTMLCollection|NodeList} target
587 * @param {String} type
588 * @param {Function} callback
589 * @return {Object}
590 */
591function listen(target, type, callback) {
592    if (!target && !type && !callback) {
593        throw new Error('Missing required arguments');
594    }
595
596    if (!is.string(type)) {
597        throw new TypeError('Second argument must be a String');
598    }
599
600    if (!is.fn(callback)) {
601        throw new TypeError('Third argument must be a Function');
602    }
603
604    if (is.node(target)) {
605        return listenNode(target, type, callback);
606    }
607    else if (is.nodeList(target)) {
608        return listenNodeList(target, type, callback);
609    }
610    else if (is.string(target)) {
611        return listenSelector(target, type, callback);
612    }
613    else {
614        throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
615    }
616}
617
618/**
619 * Adds an event listener to a HTML element
620 * and returns a remove listener function.
621 *
622 * @param {HTMLElement} node
623 * @param {String} type
624 * @param {Function} callback
625 * @return {Object}
626 */
627function listenNode(node, type, callback) {
628    node.addEventListener(type, callback);
629
630    return {
631        destroy: function() {
632            node.removeEventListener(type, callback);
633        }
634    }
635}
636
637/**
638 * Add an event listener to a list of HTML elements
639 * and returns a remove listener function.
640 *
641 * @param {NodeList|HTMLCollection} nodeList
642 * @param {String} type
643 * @param {Function} callback
644 * @return {Object}
645 */
646function listenNodeList(nodeList, type, callback) {
647    Array.prototype.forEach.call(nodeList, function(node) {
648        node.addEventListener(type, callback);
649    });
650
651    return {
652        destroy: function() {
653            Array.prototype.forEach.call(nodeList, function(node) {
654                node.removeEventListener(type, callback);
655            });
656        }
657    }
658}
659
660/**
661 * Add an event listener to a selector
662 * and returns a remove listener function.
663 *
664 * @param {String} selector
665 * @param {String} type
666 * @param {Function} callback
667 * @return {Object}
668 */
669function listenSelector(selector, type, callback) {
670    return delegate(document.body, selector, type, callback);
671}
672
673module.exports = listen;
674
675
676/***/ }),
677
678/***/ 817:
679/***/ (function(module) {
680
681function select(element) {
682    var selectedText;
683
684    if (element.nodeName === 'SELECT') {
685        element.focus();
686
687        selectedText = element.value;
688    }
689    else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
690        var isReadOnly = element.hasAttribute('readonly');
691
692        if (!isReadOnly) {
693            element.setAttribute('readonly', '');
694        }
695
696        element.select();
697        element.setSelectionRange(0, element.value.length);
698
699        if (!isReadOnly) {
700            element.removeAttribute('readonly');
701        }
702
703        selectedText = element.value;
704    }
705    else {
706        if (element.hasAttribute('contenteditable')) {
707            element.focus();
708        }
709
710        var selection = window.getSelection();
711        var range = document.createRange();
712
713        range.selectNodeContents(element);
714        selection.removeAllRanges();
715        selection.addRange(range);
716
717        selectedText = selection.toString();
718    }
719
720    return selectedText;
721}
722
723module.exports = select;
724
725
726/***/ }),
727
728/***/ 279:
729/***/ (function(module) {
730
731function E () {
732  // Keep this empty so it's easier to inherit from
733  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
734}
735
736E.prototype = {
737  on: function (name, callback, ctx) {
738    var e = this.e || (this.e = {});
739
740    (e[name] || (e[name] = [])).push({
741      fn: callback,
742      ctx: ctx
743    });
744
745    return this;
746  },
747
748  once: function (name, callback, ctx) {
749    var self = this;
750    function listener () {
751      self.off(name, listener);
752      callback.apply(ctx, arguments);
753    };
754
755    listener._ = callback
756    return this.on(name, listener, ctx);
757  },
758
759  emit: function (name) {
760    var data = [].slice.call(arguments, 1);
761    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
762    var i = 0;
763    var len = evtArr.length;
764
765    for (i; i < len; i++) {
766      evtArr[i].fn.apply(evtArr[i].ctx, data);
767    }
768
769    return this;
770  },
771
772  off: function (name, callback) {
773    var e = this.e || (this.e = {});
774    var evts = e[name];
775    var liveEvents = [];
776
777    if (evts && callback) {
778      for (var i = 0, len = evts.length; i < len; i++) {
779        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
780          liveEvents.push(evts[i]);
781      }
782    }
783
784    // Remove event from queue to prevent memory leak
785    // Suggested by https://github.com/lazd
786    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
787
788    (liveEvents.length)
789      ? e[name] = liveEvents
790      : delete e[name];
791
792    return this;
793  }
794};
795
796module.exports = E;
797module.exports.TinyEmitter = E;
798
799
800/***/ })
801
802/******/ 	});
803/************************************************************************/
804/******/ 	// The module cache
805/******/ 	var __webpack_module_cache__ = {};
806/******/ 	
807/******/ 	// The require function
808/******/ 	function __webpack_require__(moduleId) {
809/******/ 		// Check if module is in cache
810/******/ 		if(__webpack_module_cache__[moduleId]) {
811/******/ 			return __webpack_module_cache__[moduleId].exports;
812/******/ 		}
813/******/ 		// Create a new module (and put it into the cache)
814/******/ 		var module = __webpack_module_cache__[moduleId] = {
815/******/ 			// no module.id needed
816/******/ 			// no module.loaded needed
817/******/ 			exports: {}
818/******/ 		};
819/******/ 	
820/******/ 		// Execute the module function
821/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
822/******/ 	
823/******/ 		// Return the exports of the module
824/******/ 		return module.exports;
825/******/ 	}
826/******/ 	
827/************************************************************************/
828/******/ 	/* webpack/runtime/compat get default export */
829/******/ 	!function() {
830/******/ 		// getDefaultExport function for compatibility with non-harmony modules
831/******/ 		__webpack_require__.n = function(module) {