/*!

 * https://clipboardjs.com/

 *

 * Licensed MIT © Zeno Rocha

 */

(function webpackUniversalModuleDefinition(root, factory) {

	if(typeof exports === 'object' && typeof module === 'object')

		module.exports = factory();

	else if(typeof define === 'function' && define.amd)

		define([], factory);

	else if(typeof exports === 'object')

		exports["ClipboardJS"] = factory();

	else

		root["ClipboardJS"] = factory();

})(this, function() {

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

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

/***/ 686:

/***/ (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/common/command.js

/**

 * Executes a given operation type.

 * @param {String} type

 * @return {Boolean}

 */

function command(type) {

  try {

    return document.execCommand(type);

  } catch (err) {

    return false;

  }

}

;// CONCATENATED MODULE: ./src/actions/cut.js

/**

 * Cut action wrapper.

 * @param {String|HTMLElement} target

 * @return {String}

 */

var ClipboardActionCut = function ClipboardActionCut(target) {

  var selectedText = select_default()(target);

  command('cut');

  return selectedText;

};

/* harmony default export */ var actions_cut = (ClipboardActionCut);

;// CONCATENATED MODULE: ./src/common/create-fake-element.js

/**

 * Creates a fake textarea element with a value.

 * @param {String} value

 * @return {HTMLElement}

 */

function createFakeElement(value) {

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

  var fakeElement = document.createElement('textarea'); // Prevent zooming on iOS

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

  fakeElement.style.border = '0';

  fakeElement.style.padding = '0';

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

  fakeElement.style.position = 'absolute';

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

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

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

  fakeElement.setAttribute('readonly', '');

  fakeElement.value = value;

  return fakeElement;

}

;// CONCATENATED MODULE: ./src/actions/copy.js

/**

 * Copy action wrapper.

 * @param {String|HTMLElement} target

 * @param {Object} options

 * @return {String}

 */

var ClipboardActionCopy = function ClipboardActionCopy(target) {

  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {

    container: document.body

  };

  var selectedText = '';

  if (typeof target === 'string') {

  } else {

    selectedText = select_default()(target);

    command('copy');

  }

  return selectedText;

};

/* harmony default export */ var actions_copy = (ClipboardActionCopy);

;// CONCATENATED MODULE: ./src/actions/default.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); }

/**

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

 * properties and then executes copy or cut operations.

 * @param {Object} options

 */

var ClipboardActionDefault = function ClipboardActionDefault() {

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

  // Defines base properties passed from constructor.

  var _options$action = options.action,

      action = _options$action === void 0 ? 'copy' : _options$action,

      container = options.container,

      target = options.target,

      text = options.text; // Sets the `action` to be performed which can be either 'copy' or 'cut'.

  if (action !== 'copy' && action !== 'cut') {

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

  } // Sets the `target` property using an element that will be have its content copied.

  if (target !== undefined) {

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

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

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

      }

      if (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');

      }

    } else {

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

    }

  } // Define selection strategy based on `text` property.

  if (text) {

    return actions_copy(text, {

      container: container

    });

  } // Defines which selection strategy based on `target` property.

  if (target) {

    return action === 'cut' ? actions_cut(target) : actions_copy(target, {

      container: container

    });

  }

};

/* harmony default export */ var actions_default = (ClipboardActionDefault);

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

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

 */

function getAttributeValue(suffix, element) {

  var attribute = "data-clipboard-".concat(suffix);

  if (!element.hasAttribute(attribute)) {

    return;

  }

  return element.getAttribute(attribute);

}

/**

 * Base class which takes one or more elements, adds event listeners to them,

 * and instantiates a new `ClipboardAction` on each click.

 */

var Clipboard = /*#__PURE__*/function (_Emitter) {

  _inherits(Clipboard, _Emitter);

  var _super = _createSuper(Clipboard);

  /**

   * @param {String|HTMLElement|HTMLCollection|NodeList} trigger

   * @param {Object} options

   */

  function Clipboard(trigger, options) {

    var _this;

    _classCallCheck(this, Clipboard);

    _this = _super.call(this);

    _this.resolveOptions(options);

    _this.listenClick(trigger);

    return _this;

  }

  /**

   * Defines if attributes would be resolved using internal setter functions

   * or custom functions that were passed in the constructor.

   * @param {Object} options

   */

  _createClass(Clipboard, [{

    key: "resolveOptions",

    value: function resolveOptions() {

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

      this.action = typeof options.action === 'function' ? options.action : this.defaultAction;

      this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;

      this.text = typeof options.text === 'function' ? options.text : this.defaultText;

      this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;

    }

    /**

     * Adds a click event listener to the passed trigger.

     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger

     */

  }, {

    key: "listenClick",

    value: function listenClick(trigger) {

      var _this2 = this;

      this.listener = listen_default()(trigger, 'click', function (e) {

        return _this2.onClick(e);

      });

    }

    /**

     * Defines a new `ClipboardAction` on each click event.

     * @param {Event} e

     */

  }, {

    key: "onClick",

    value: function onClick(e) {

      var trigger = e.delegateTarget || e.currentTarget;

      var action = this.action(trigger) || 'copy';

      var text = actions_default({

        action: action,

        container: this.container,

        target: this.target(trigger),

        text: this.text(trigger)

      }); // Fires an event based on the copy operation result.

      this.emit(text ? 'success' : 'error', {

        action: action,

        text: text,

        trigger: trigger,

        clearSelection: function clearSelection() {

          if (trigger) {

            trigger.focus();