* clipboard.js v2.0.8

 *

return /******/ (function() { // webpackBootstrap

/******/ 	var __webpack_modules__ = ({

/***/ 134:

/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

  "default": function() { return /* binding */ clipboard; }

});

// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js

var tiny_emitter = __webpack_require__(279);

var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);

// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js

var listen = __webpack_require__(370);

var listen_default = /*#__PURE__*/__webpack_require__.n(listen);

// EXTERNAL MODULE: ./node_modules/select/src/select.js

var src_select = __webpack_require__(817);

var select_default = /*#__PURE__*/__webpack_require__.n(src_select);

;// CONCATENATED MODULE: ./src/clipboard-action.js

function _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); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _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); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

/**

 * Inner class which performs selection from either `text` or `target`

 * properties and then executes copy or cut operations.

 */

var ClipboardAction = /*#__PURE__*/function () {

  /**

   * @param {Object} options

   */

  function ClipboardAction(options) {

    _classCallCheck(this, ClipboardAction);

    this.resolveOptions(options);

    this.initSelection();

  }

  /**

   * Defines base properties passed from constructor.

   * @param {Object} options

   */

  _createClass(ClipboardAction, [{

    key: "resolveOptions",

    value: function resolveOptions() {

      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      this.action = options.action;

      this.container = options.container;

      this.emitter = options.emitter;

      this.target = options.target;

      this.text = options.text;

      this.trigger = options.trigger;

      this.selectedText = '';

    }

    /**

     * Decides which selection strategy is going to be applied based

     * on the existence of `text` and `target` properties.

     */

  }, {

    key: "initSelection",

    value: function initSelection() {

      if (this.text) {

        this.selectFake();

      } else if (this.target) {

        this.selectTarget();

      }

    }

    /**

     * Creates a fake textarea element, sets its value from `text` property,

     */

  }, {

    key: "createFakeElement",

    value: function createFakeElement() {

      var isRTL = document.documentElement.getAttribute('dir') === 'rtl';

      this.fakeElem = document.createElement('textarea'); // Prevent zooming on iOS

      this.fakeElem.style.fontSize = '12pt'; // Reset box model

      this.fakeElem.style.border = '0';

      this.fakeElem.style.padding = '0';

      this.fakeElem.style.margin = '0'; // Move element out of screen horizontally

      this.fakeElem.style.position = 'absolute';

      this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px'; // Move element to the same position vertically

      var yPosition = window.pageYOffset || document.documentElement.scrollTop;

      this.fakeElem.style.top = "".concat(yPosition, "px");

      this.fakeElem.setAttribute('readonly', '');

      this.fakeElem.value = this.text;

      return this.fakeElem;

    }

    /**

     * Get's the value of fakeElem,

     * and makes a selection on it.

     */

  }, {

    key: "selectFake",

    value: function selectFake() {

      var _this = this;

      var fakeElem = this.createFakeElement();

      this.fakeHandlerCallback = function () {

        return _this.removeFake();

      };

      this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;

      this.container.appendChild(fakeElem);

      this.selectedText = select_default()(fakeElem);

      this.copyText();

      this.removeFake();

    }

    /**

     * Only removes the fake element after another click event, that way

     * a user can hit `Ctrl+C` to copy because selection still exists.

     */

  }, {

    key: "removeFake",

    value: function removeFake() {

      if (this.fakeHandler) {

        this.container.removeEventListener('click', this.fakeHandlerCallback);

        this.fakeHandler = null;

        this.fakeHandlerCallback = null;

      }

      if (this.fakeElem) {

        this.container.removeChild(this.fakeElem);

        this.fakeElem = null;

      }

    }

    /**

     * Selects the content from element passed on `target` property.

     */

  }, {

    key: "selectTarget",

    value: function selectTarget() {

      this.selectedText = select_default()(this.target);

      this.copyText();

    }

    /**

     * Executes the copy operation based on the current selection.

     */

  }, {

    key: "copyText",

    value: function copyText() {

      var succeeded;

      try {

        succeeded = document.execCommand(this.action);

      } catch (err) {

        succeeded = false;

      }

      this.handleResult(succeeded);

    }

    /**

     * Fires an event based on the copy operation result.

     * @param {Boolean} succeeded

     */

  }, {

    key: "handleResult",

    value: function handleResult(succeeded) {

      this.emitter.emit(succeeded ? 'success' : 'error', {

        action: this.action,

        text: this.selectedText,

        trigger: this.trigger,

        clearSelection: this.clearSelection.bind(this)

      });

    }

    /**

     * Moves focus away from `target` and back to the trigger, removes current selection.

     */

  }, {

    key: "clearSelection",

    value: function clearSelection() {

      if (this.trigger) {

        this.trigger.focus();

      }

      document.activeElement.blur();

      window.getSelection().removeAllRanges();

    }

    /**

     * Sets the `action` to be performed which can be either 'copy' or 'cut'.

     * @param {String} action

     */

  }, {

    key: "destroy",

    /**

     * Destroy lifecycle.

     */

    value: function destroy() {

      this.removeFake();

    }

  }, {

    key: "action",

    set: function set() {

      var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';

      this._action = action;

      if (this._action !== 'copy' && this._action !== 'cut') {

        throw new Error('Invalid "action" value, use either "copy" or "cut"');

      }

    }

    /**

     * Gets the `action` property.

     * @return {String}

     */

    ,

    get: function get() {

      return this._action;

    }

    /**

     * Sets the `target` property using an element

     * that will be have its content copied.

     * @param {Element} target

     */

  }, {

    key: "target",

    set: function set(target) {

      if (target !== undefined) {

        if (target && _typeof(target) === 'object' && target.nodeType === 1) {

          if (this.action === 'copy' && target.hasAttribute('disabled')) {

            throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');

          }

          if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {

            throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');

          }

          this._target = target;

        } else {

          throw new Error('Invalid "target" value, use a valid Element');

        }

      }

    }

    /**

     * Gets the `target` property.

     * @return {String|HTMLElement}

     */

    ,

    get: function get() {

      return this._target;

  }]);

  return ClipboardAction;

}();

/* harmony default export */ var clipboard_action = (ClipboardAction);

;// CONCATENATED MODULE: ./src/clipboard.js

function 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); }

function clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function clipboard_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); } }

function clipboard_createClass(Constructor, protoProps, staticProps) { if (protoProps) clipboard_defineProperties(Constructor.prototype, protoProps); if (staticProps) clipboard_defineProperties(Constructor, staticProps); return Constructor; }

function _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); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _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); }; }

function _possibleConstructorReturn(self, call) { if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _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; } }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

/**

 * Helper function to retrieve attribute value.

 * @param {String} suffix

 * @param {Element} element