text: function _typeof(obj) {
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      _typeof = function (obj) {
        return typeof obj;
      };
    } else {
      _typeof = function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
    }
  
    return _typeof(obj);
  }
  
  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
  
  
  function unwrapExports (x) {
  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
  }
  
  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }
  
  function select(element) {
      var selectedText;
  
      if (element.nodeName === 'SELECT') {
          element.focus();
  
          selectedText = element.value;
      }
      else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
          var isReadOnly = element.hasAttribute('readonly');
  
          if (!isReadOnly) {
              element.setAttribute('readonly', '');
          }
  
          element.select();
          element.setSelectionRange(0, element.value.length);
  
          if (!isReadOnly) {
              element.removeAttribute('readonly');
          }
  
          selectedText = element.value;
      }
      else {
          if (element.hasAttribute('contenteditable')) {
              element.focus();
          }
  
          var selection = window.getSelection();
          var range = document.createRange();
  
          range.selectNodeContents(element);
          selection.removeAllRanges();
          selection.addRange(range);
  
          selectedText = selection.toString();
      }
  
      return selectedText;
  }
  
  var select_1 = select;
  
  var clipboardAction = createCommonjsModule(function (module, exports) {
  (function (global, factory) {
      if (typeof undefined === "function" && undefined.amd) {
          undefined(['module', 'select'], factory);
      } else {
          factory(module, select_1);
      }
  })(commonjsGlobal, function (module, _select) {
      var _select2 = _interopRequireDefault(_select);
  
      function _interopRequireDefault(obj) {
          return obj && obj.__esModule ? obj : {
              default: obj
          };
      }
  
      var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
          return typeof obj;
      } : function (obj) {
          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
  
      function _classCallCheck(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
          }
      }
  
      var _createClass = 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);
              }
          }
  
          return function (Constructor, protoProps, staticProps) {
              if (protoProps) defineProperties(Constructor.prototype, protoProps);
              if (staticProps) defineProperties(Constructor, staticProps);
              return Constructor;
          };
      }();
  
      var ClipboardAction = 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 = '';
              }
          }, {
              key: 'initSelection',
              value: function initSelection() {
                  if (this.text) {
                      this.selectFake();
                  } else if (this.target) {
                      this.selectTarget();
                  }
              }
          }, {
              key: 'selectFake',
              value: function selectFake() {
                  var _this = this;
  
                  var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
  
                  this.removeFake();
  
                  this.fakeHandlerCallback = function () {
                      return _this.removeFake();
                  };
                  this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;
  
                  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 = yPosition + 'px';
  
                  this.fakeElem.setAttribute('readonly', '');
                  this.fakeElem.value = this.text;
  
                  this.container.appendChild(this.fakeElem);
  
                  this.selectedText = (0, _select2.default)(this.fakeElem);
                  this.copyText();
              }
          }, {
              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;
                  }
              }
          }, {
              key: 'selectTarget',
              value: function selectTarget() {
                  this.selectedText = (0, _select2.default)(this.target);
                  this.copyText();
              }
          }, {
              key: 'copyText',
              value: function copyText() {
                  var succeeded = void 0;
  
                  try {
                      succeeded = document.execCommand(this.action);
                  } catch (err) {
                      succeeded = false;
                  }
  
                  this.handleResult(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)
                  });
              }
          }, {
              key: 'clearSelection',
              value: function clearSelection() {
                  if (this.trigger) {
                      this.trigger.focus();
                  }
  
                  window.getSelection().removeAllRanges();
              }
          }, {
              key: 'destroy',
              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"');
                  }
              },
              get: function get() {
                  return this._action;
              }
          }, {
              key: 'target',
              set: function set(target) {
                  if (target !== undefined) {
                      if (target && (typeof target === 'undefined' ? 'undefined' : _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');
                      }
                  }
              },
              get: function get() {
                  return this._target;
              }
          }]);
  
          return ClipboardAction;
      }();
  
      module.exports = ClipboardAction;
  });
  });
  
  unwrapExports(clipboardAction);
  
  function E () {
    // Keep this empty so it's easier to inherit from
    // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
  }
  
  E.prototype = {
    on: function (name, callback, ctx) {
      var e = this.e || (this.e = {});
  
      (e[name] || (e[name] = [])).push({
        fn: callback,
        ctx: ctx
      });
  
      return this;
    },
  
    once: function (name, callback, ctx) {
      var self = this;
      function listener () {
        self.off(name, listener);
        callback.apply(ctx, arguments);
      }
  
      listener._ = callback;
      return this.on(name, listener, ctx);
    },
  
    emit: function (name) {
      var data = [].slice.call(arguments, 1);
      var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
      var i = 0;
      var len = evtArr.length;
  
      for (i; i < len; i++) {
        evtArr[i].fn.apply(evtArr[i].ctx, data);
      }
  
      return this;
    },
  
    off: function (name, callback) {
      var e = this.e || (this.e = {});
      var evts = e[name];
      var liveEvents = [];
  
      if (evts && callback) {
        for (var i = 0, len = evts.length; i < len; i++) {
          if (evts[i].fn !== callback && evts[i].fn._ !== callback)
            liveEvents.push(evts[i]);
        }
      }
  
      // Remove event from queue to prevent memory leak
      // Suggested by https://github.com/lazd
      // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
  
      (liveEvents.length)
        ? e[name] = liveEvents
        : delete e[name];
  
      return this;
    }
  };
  
  var tinyEmitter = E;
  
  var is = createCommonjsModule(function (module, exports) {
  /**
   * Check if argument is a HTML element.
   *
   * @param {Object} value
   * @return {Boolean}
   */
  exports.node = function(value) {
      return value !== undefined
          && value instanceof HTMLElement
          && value.nodeType === 1;
  };
  
  /**
   * Check if argument is a list of HTML elements.
   *
   * @param {Object} value
   * @return {Boolean}
   */
  exports.nodeList = function(value) {
      var type = Object.prototype.toString.call(value);
  
      return value !== undefined
          && (type === '[object NodeList]' || type === '[object HTMLCollection]')
          && ('length' in value)
          && (value.length === 0 || exports.node(value[0]));
  };
  
  /**
   * Check if argument is a string.
   *
   * @param {Object} value
   * @return {Boolean}
   */
  exports.string = function(value) {
      return typeof value === 'string'
          || value instanceof String;
  };
  
  /**
   * Check if argument is a function.
   *
   * @param {Object} value
   * @return {Boolean}
   */
  exports.fn = function(value) {
      var type = Object.prototype.toString.call(value);
  
      return type === '[object Function]';
  };
  });
  
  var is_1 = is.node;
  var is_2 = is.nodeList;
  var is_3 = is.string;
  var is_4 = is.fn;
  
  var DOCUMENT_NODE_TYPE = 9;
  
  /**
   * A polyfill for Element.matches()
   */
  if (typeof Element !== 'undefined' && !Element.prototype.matches) {
      var proto = Element.prototype;
  
      proto.matches = proto.matchesSelector ||
                      proto.mozMatchesSelector ||
                      proto.msMatchesSelector ||
                      proto.oMatchesSelector ||
                      proto.webkitMatchesSelector;
  }
  
  /**
   * Finds the closest parent that matches a selector.
   *
   * @param {Element} element
   * @param {String} selector
   * @return {Function}
   */
  function closest (element, selector) {
      while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
          if (typeof element.matches === 'function' &&
              element.matches(selector)) {
            return element;
          }
          element = element.parentNode;
      }
  }
  
  var closest_1 = closest;
  
  function _delegate(element, selector, type, callback, useCapture) {
      var listenerFn = listener.apply(this, arguments);
  
      element.addEventListener(type, listenerFn, useCapture);
  
      return {
          destroy: function() {
              element.removeEventListener(type, listenerFn, useCapture);
          }
      }
  }
  
  /**
   * Delegates event to a selector.
   *
   * @param {Element|String|Array} [elements]
   * @param {String} selector
   * @param {String} type
   * @param {Function} callback
   * @param {Boolean} useCapture
   * @return {Object}
   */
  function delegate(elements, selector, type, callback, useCapture) {
      // Handle the regular Element usage
      if (typeof elements.addEventListener === 'function') {
          return _delegate.apply(null, arguments);
      }
  
      // Handle Element-less usage, it defaults to global delegation
      if (typeof type === 'function') {
          // Use `document` as the first parameter, then apply arguments
          // This is a short way to .unshift `arguments` without running into deoptimizations
          return _delegate.bind(null, document).apply(null, arguments);
      }
  
      // Handle Selector-based usage
      if (typeof elements === 'string') {
          elements = document.querySelectorAll(elements);
      }
  
      // Handle Array-like based usage
      return Array.prototype.map.call(elements, function (element) {
          return _delegate(element, selector, type, callback, useCapture);
      });
  }
  
  /**
   * Finds closest match and invokes callback.
   *
   * @param {Element} element
   * @param {String} selector
   * @param {String} type
   * @param {Function} callback
   * @return {Function}
   */
  function listener(element, selector, type, callback) {
      return function(e) {
          e.delegateTarget = closest_1(e.target, selector);
  
          if (e.delegateTarget) {
              callback.call(element, e);
          }
      }
  }
  
  var delegate_1 = delegate;
  
  function listen(target, type, callback) {
      if (!target && !type && !callback) {
          throw new Error('Missing required arguments');
      }
  
      if (!is.string(type)) {
          throw new TypeError('Second argument must be a String');
      }
  
      if (!is.fn(callback)) {
          throw new TypeError('Third argument must be a Function');
      }
  
      if (is.node(target)) {
          return listenNode(target, type, callback);
      }
      else if (is.nodeList(target)) {
          return listenNodeList(target, type, callback);
      }
      else if (is.string(target)) {
          return listenSelector(target, type, callback);
      }
      else {
          throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
      }
  }
  
  /**
   * Adds an event listener to a HTML element
   * and returns a remove listener function.
   *
   * @param {HTMLElement} node
   * @param {String} type
   * @param {Function} callback
   * @return {Object}
   */
  function listenNode(node, type, callback) {
      node.addEventListener(type, callback);
  
      return {
          destroy: function() {
              node.removeEventListener(type, callback);
          }
      }
  }
  
  /**
   * Add an event listener to a list of HTML elements
   * and returns a remove listener function.
   *
   * @param {NodeList|HTMLCollection} nodeList
   * @param {String} type
   * @param {Function} callback
   * @return {Object}
   */
  function listenNodeList(nodeList, type, callback) {
      Array.prototype.forEach.call(nodeList, function(node) {
          node.addEventListener(type, callback);
      });
  
      return {
          destroy: function() {
              Array.prototype.forEach.call(nodeList, function(node) {
                  node.removeEventListener(type, callback);
              });
          }
      }
  }
  
  /**
   * Add an event listener to a selector
   * and returns a remove listener function.
   *
   * @param {String} selector
   * @param {String} type
   * @param {Function} callback
   * @return {Object}
   */
  function listenSelector(selector, type, callback) {
      return delegate_1(document.body, selector, type, callback);
  }
  
  var listen_1 = listen;
  
  var clipboard = createCommonjsModule(function (module, exports) {
  (function (global, factory) {
      if (typeof undefined === "function" && undefined.amd) {
          undefined(['module', './clipboard-action', 'tiny-emitter', 'good-listener'], factory);
      } else {
          factory(module, clipboardAction, tinyEmitter, listen_1);
      }
  })(commonjsGlobal, function (module, _clipboardAction, _tinyEmitter, _goodListener) {
      var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
  
      var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
  
      var _goodListener2 = _interopRequireDefault(_goodListener);
  
      function _interopRequireDefault(obj) {
          return obj && obj.__esModule ? obj : {
              default: obj
          };
      }
  
      var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
          return typeof obj;
      } : function (obj) {
          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };
  
      function _classCallCheck(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
          }
      }
  
      var _createClass = 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);
              }
          }
  
          return function (Constructor, protoProps, staticProps) {
              if (protoProps) defineProperties(Constructor.prototype, protoProps);
              if (staticProps) defineProperties(Constructor, staticProps);
              return Constructor;
          };
      }();
  
      function _possibleConstructorReturn(self, call) {
          if (!self) {
              throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          }
  
          return call && (typeof call === "object" || typeof call === "function") ? call : self;
      }
  
      function _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
              throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
          }
  
          subClass.prototype = Object.create(superClass && superClass.prototype, {
              constructor: {
                  value: subClass,
                  enumerable: false,
                  writable: true,
                  configurable: true
              }
          });
          if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
      }
  
      var Clipboard = function (_Emitter) {
          _inherits(Clipboard, _Emitter);
  
          /**
           * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
           * @param {Object} options
           */
          function Clipboard(trigger, options) {
              _classCallCheck(this, Clipboard);
  
              var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).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 = _typeof(options.container) === 'object' ? options.container : document.body;
              }
          }, {
              key: 'listenClick',
              value: function listenClick(trigger) {
                  var _this2 = this;
  
                  this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) {
                      return _this2.onClick(e);
                  });
              }
          }, {
              key: 'onClick',
              value: function onClick(e) {
                  var trigger = e.delegateTarget || e.currentTarget;
  
                  if (this.clipboardAction) {
                      this.clipboardAction = null;
                  }
  
                  this.clipboardAction = new _clipboardAction2.default({
                      action: this.action(trigger),
                      target: this.target(trigger),
                      text: this.text(trigger),
                      container: this.container,
                      trigger: trigger,
                      emitter: this
                  });
              }
          }, {
              key: 'defaultAction',
              value: function defaultAction(trigger) {
                  return getAttributeValue('action', trigger);
              }
          }, {
              key: 'defaultTarget',
              value: function defaultTarget(trigger) {
                  var selector = getAttributeValue('target', trigger);
  
                  if (selector) {
                      return document.querySelector(selector);
                  }
              }
          }, {
              key: 'defaultText',
              value: function defaultText(trigger) {
                  return getAttributeValue('text', trigger);
              }
          }, {
              key: 'destroy',
              value: function destroy() {
                  this.listener.destroy();
  
                  if (this.clipboardAction) {
                      this.clipboardAction.destroy();
                      this.clipboardAction = null;
                  }
              }
          }], [{
              key: 'isSupported',
              value: function isSupported() {
                  var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
  
                  var actions = typeof action === 'string' ? [action] : action;
                  var support = !!document.queryCommandSupported;
  
                  actions.forEach(function (action) {
                      support = support && !!document.queryCommandSupported(action);
                  });
  
                  return support;
              }
          }]);
  
          return Clipboard;
      }(_tinyEmitter2.default);
  
      /**
       * Helper function to retrieve attribute value.
       * @param {String} suffix
       * @param {Element} element
       */
      function getAttributeValue(suffix, element) {
          var attribute = 'data-clipboard-' + suffix;
  
          if (!element.hasAttribute(attribute)) {
              return;
          }
  
          return element.getAttribute(attribute);
      }
  
      module.exports = Clipboard;
  });
  });
  
  var Clipboard = unwrapExports(clipboard);
  
  /**
   * @author: 卓文理
   * @email : 531840344@qq.com
   * @desc  : VueClipboard
   */
  if (!Clipboard) {
    throw new Error('[vue-clipboards] cannot locate Clipboard.');
  }
  
  function isDom(obj) {
    return _typeof(window.HTMLElement) === 'object' ? obj instanceof window.HTMLElement : obj && _typeof(obj) === 'object' && obj.nodeType === 1 && typeof obj.nodeName === 'string';
  }
  
  function vueClipboards (Vue) {
    Vue.directive('clipboard', {
      bind: function bind(el, _ref, vnode) {
        return new Promise(function ($return, $error) {
          var text, option, $parent, componentOptions, data, listeners, on, events;
          text = _ref.value;
          option = {};
          $parent = null;
  
          if (text && typeof text === 'function') {
            return Promise.resolve(text()).then(function ($await_2) {
              try {
                text = $await_2;
                return $If_1.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
  
          function $If_1() {
            if (/(string|number)/.test(_typeof(text))) {
              option.text = function () {
                return "".concat(text);
              };
            } else {
              return $error(new Error('[vue-clipboards] Invalid value. Please use a valid value.'));
            }
  
            if (vnode.data.attrs && vnode.data.attrs.model) {
              $parent = isDom(vnode.data.attrs.model) ? vnode.data.attrs.model : document.querySelector(vnode.data.attrs.model);
            } // 修复按钮脱离文档流时，clipboard监听失败问题
  
  
            if (vnode.elm.offsetParent) {
              option.container = vnode.elm.offsetParent;
            } else if (isDom($parent)) {
              option.container = $parent;
            } else {
              // if root element should use document.body
              option.container = el.parentElement || document.body;
            }
  
            vnode.elm.$clipboards = new Clipboard(el, option);
            componentOptions = vnode.componentOptions, data = vnode.data;
            listeners = componentOptions ? componentOptions.listeners : null;
            on = data ? data.on : null;
            events = listeners && listeners || on && on;
  
            if (events && _typeof(events) === 'object' && Object.keys(events).length) {
              // fixed with Vue 2.2.x, event object `fn` rename to `fns`
              Object.keys(events).map(function (cb) {
                return vnode.elm.$clipboards.on(cb, events[cb].fn || events[cb].fns);
              });
            }
  
            return $return(vnode.elm.$clipboards);
          }
  
          return $If_1.call(this);
        }.bind(this));
      },
      unbind: function unbind(vnode) {
        if (vnode.elm && vnode.elm.$clipboards && vnode.elm.$clipboards.destroy) {
          vnode.elm.$clipboards.destroy();
          delete vnode.elm.$clipboards;
        }
      },
      update: function update(el, binding, vnode) {
        binding.def.unbind(vnode);
        binding.def.bind(el, binding, vnode);
      }
    });
  }
  
  export default vueClipboards;
  