☰

clipboard.js

Hosting of clipboard.js for inclusion in greasyfork scripts

ეს სკრიპტი არ უნდა იყოს პირდაპირ დაინსტალირებული. ეს ბიბლიოთეკაა, სხვა სკრიპტებისთვის უნდა ჩართეთ მეტა-დირექტივაში // @require https://update.greatest.deepsurf.us/scripts/27254/174357/clipboardjs.js. 

  1. // ==UserScript==
  2. // @name                Clipboard.js
  3. // @namespace           https://greatest.deepsurf.us/users/30701-justins83-waze
  4. // @description         Hosting of clipboard.js for inclusion in greasyfork scripts
  5. // @version             0.1
  6. // @grant               none
  7.  
  8. /*!
  9.  * clipboard.js v1.6.0
  10.  * https://zenorocha.github.io/clipboard.js
  11.  *
  12.  * Licensed MIT © Zeno Rocha
  13.  */
  14. (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Clipboard = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
  15. var DOCUMENT_NODE_TYPE = 9;
  16.  
  17. /**
  18.  * A polyfill for Element.matches()
  19.  */
  20. if (Element && !Element.prototype.matches) {
  21.     var proto = Element.prototype;
  22.  
  23.     proto.matches = proto.matchesSelector ||
  24.                     proto.mozMatchesSelector ||
  25.                     proto.msMatchesSelector ||
  26.                     proto.oMatchesSelector ||
  27.                     proto.webkitMatchesSelector;
  28. }
  29.  
  30. /**
  31.  * Finds the closest parent that matches a selector.
  32.  *
  33.  * @param {Element} element
  34.  * @param {String} selector
  35.  * @return {Function}
  36.  */
  37. function closest (element, selector) {
  38.     while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
  39.         if (element.matches(selector)) return element;
  40.         element = element.parentNode;
  41.     }
  42. }
  43.  
  44. module.exports = closest;
  45.  
  46. },{}],2:[function(require,module,exports){
  47. var closest = require('./closest');
  48.  
  49. /**
  50.  * Delegates event to a selector.
  51.  *
  52.  * @param {Element} element
  53.  * @param {String} selector
  54.  * @param {String} type
  55.  * @param {Function} callback
  56.  * @param {Boolean} useCapture
  57.  * @return {Object}
  58.  */
  59. function delegate(element, selector, type, callback, useCapture) {
  60.     var listenerFn = listener.apply(this, arguments);
  61.  
  62.     element.addEventListener(type, listenerFn, useCapture);
  63.  
  64.     return {
  65.         destroy: function() {
  66.             element.removeEventListener(type, listenerFn, useCapture);
  67.         }
  68.     }
  69. }
  70.  
  71. /**
  72.  * Finds closest match and invokes callback.
  73.  *
  74.  * @param {Element} element
  75.  * @param {String} selector
  76.  * @param {String} type
  77.  * @param {Function} callback
  78.  * @return {Function}
  79.  */
  80. function listener(element, selector, type, callback) {
  81.     return function(e) {
  82.         e.delegateTarget = closest(e.target, selector);
  83.  
  84.         if (e.delegateTarget) {
  85.             callback.call(element, e);
  86.         }
  87.     }
  88. }
  89.  
  90. module.exports = delegate;
  91.  
  92. },{"./closest":1}],3:[function(require,module,exports){
  93. /**
  94.  * Check if argument is a HTML element.
  95.  *
  96.  * @param {Object} value
  97.  * @return {Boolean}
  98.  */
  99. exports.node = function(value) {
  100.     return value !== undefined
  101.         && value instanceof HTMLElement
  102.         && value.nodeType === 1;
  103. };
  104.  
  105. /**
  106.  * Check if argument is a list of HTML elements.
  107.  *
  108.  * @param {Object} value
  109.  * @return {Boolean}
  110.  */
  111. exports.nodeList = function(value) {
  112.     var type = Object.prototype.toString.call(value);
  113.  
  114.     return value !== undefined
  115.         && (type === '[object NodeList]' || type === '[object HTMLCollection]')
  116.         && ('length' in value)
  117.         && (value.length === 0 || exports.node(value[0]));
  118. };
  119.  
  120. /**
  121.  * Check if argument is a string.
  122.  *
  123.  * @param {Object} value
  124.  * @return {Boolean}
  125.  */
  126. exports.string = function(value) {
  127.     return typeof value === 'string'
  128.         || value instanceof String;
  129. };
  130.  
  131. /**
  132.  * Check if argument is a function.
  133.  *
  134.  * @param {Object} value
  135.  * @return {Boolean}
  136.  */
  137. exports.fn = function(value) {
  138.     var type = Object.prototype.toString.call(value);
  139.  
  140.     return type === '[object Function]';
  141. };
  142.  
  143. },{}],4:[function(require,module,exports){
  144. var is = require('./is');
  145. var delegate = require('delegate');
  146.  
  147. /**
  148.  * Validates all params and calls the right
  149.  * listener function based on its target type.
  150.  *
  151.  * @param {String|HTMLElement|HTMLCollection|NodeList} target
  152.  * @param {String} type
  153.  * @param {Function} callback
  154.  * @return {Object}
  155.  */
  156. function listen(target, type, callback) {
  157.     if (!target && !type && !callback) {
  158.         throw new Error('Missing required arguments');
  159.     }
  160.  
  161.     if (!is.string(type)) {
  162.         throw new TypeError('Second argument must be a String');
  163.     }
  164.  
  165.     if (!is.fn(callback)) {
  166.         throw new TypeError('Third argument must be a Function');
  167.     }
  168.  
  169.     if (is.node(target)) {
  170.         return listenNode(target, type, callback);
  171.     }
  172.     else if (is.nodeList(target)) {
  173.         return listenNodeList(target, type, callback);
  174.     }
  175.     else if (is.string(target)) {
  176.         return listenSelector(target, type, callback);
  177.     }
  178.     else {
  179.         throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
  180.     }
  181. }
  182.  
  183. /**
  184.  * Adds an event listener to a HTML element
  185.  * and returns a remove listener function.
  186.  *
  187.  * @param {HTMLElement} node
  188.  * @param {String} type
  189.  * @param {Function} callback
  190.  * @return {Object}
  191.  */
  192. function listenNode(node, type, callback) {
  193.     node.addEventListener(type, callback);
  194.  
  195.     return {
  196.         destroy: function() {
  197.             node.removeEventListener(type, callback);
  198.         }
  199.     }
  200. }
  201.  
  202. /**
  203.  * Add an event listener to a list of HTML elements
  204.  * and returns a remove listener function.
  205.  *
  206.  * @param {NodeList|HTMLCollection} nodeList
  207.  * @param {String} type
  208.  * @param {Function} callback
  209.  * @return {Object}
  210.  */
  211. function listenNodeList(nodeList, type, callback) {
  212.     Array.prototype.forEach.call(nodeList, function(node) {
  213.         node.addEventListener(type, callback);
  214.     });
  215.  
  216.     return {
  217.         destroy: function() {
  218.             Array.prototype.forEach.call(nodeList, function(node) {
  219.                 node.removeEventListener(type, callback);
  220.             });
  221.         }
  222.     }
  223. }
  224.  
  225. /**
  226.  * Add an event listener to a selector
  227.  * and returns a remove listener function.
  228.  *
  229.  * @param {String} selector
  230.  * @param {String} type
  231.  * @param {Function} callback
  232.  * @return {Object}
  233.  */
  234. function listenSelector(selector, type, callback) {
  235.     return delegate(document.body, selector, type, callback);
  236. }
  237.  
  238. module.exports = listen;
  239.  
  240. },{"./is":3,"delegate":2}],5:[function(require,module,exports){
  241. function select(element) {
  242.     var selectedText;
  243.  
  244.     if (element.nodeName === 'SELECT') {
  245.         element.focus();
  246.  
  247.         selectedText = element.value;
  248.     }
  249.     else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
  250.         var isReadOnly = element.hasAttribute('readonly');
  251.  
  252.         if (!isReadOnly) {
  253.             element.setAttribute('readonly', '');
  254.         }
  255.  
  256.         element.select();
  257.         element.setSelectionRange(0, element.value.length);
  258.  
  259.         if (!isReadOnly) {
  260.             element.removeAttribute('readonly');
  261.         }
  262.  
  263.         selectedText = element.value;
  264.     }
  265.     else {
  266.         if (element.hasAttribute('contenteditable')) {
  267.             element.focus();
  268.         }
  269.  
  270.         var selection = window.getSelection();
  271.         var range = document.createRange();
  272.  
  273.         range.selectNodeContents(element);
  274.         selection.removeAllRanges();
  275.         selection.addRange(range);
  276.  
  277.         selectedText = selection.toString();
  278.     }
  279.  
  280.     return selectedText;
  281. }
  282.  
  283. module.exports = select;
  284.  
  285. },{}],6:[function(require,module,exports){
  286. function E () {
  287.   // Keep this empty so it's easier to inherit from
  288.   // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
  289. }
  290.  
  291. E.prototype = {
  292.   on: function (name, callback, ctx) {
  293.     var e = this.e || (this.e = {});
  294.  
  295.     (e[name] || (e[name] = [])).push({
  296.       fn: callback,
  297.       ctx: ctx
  298.     });
  299.  
  300.     return this;
  301.   },
  302.  
  303.   once: function (name, callback, ctx) {
  304.     var self = this;
  305.     function listener () {
  306.       self.off(name, listener);
  307.       callback.apply(ctx, arguments);
  308.     };
  309.  
  310.     listener._ = callback
  311.     return this.on(name, listener, ctx);
  312.   },
  313.  
  314.   emit: function (name) {
  315.     var data = [].slice.call(arguments, 1);
  316.     var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
  317.     var i = 0;
  318.     var len = evtArr.length;
  319.  
  320.     for (i; i < len; i++) {
  321.       evtArr[i].fn.apply(evtArr[i].ctx, data);
  322.     }
  323.  
  324.     return this;
  325.   },
  326.  
  327.   off: function (name, callback) {
  328.     var e = this.e || (this.e = {});
  329.     var evts = e[name];
  330.     var liveEvents = [];
  331.  
  332.     if (evts && callback) {
  333.       for (var i = 0, len = evts.length; i < len; i++) {
  334.         if (evts[i].fn !== callback && evts[i].fn._ !== callback)
  335.           liveEvents.push(evts[i]);
  336.       }
  337.     }
  338.  
  339.     // Remove event from queue to prevent memory leak
  340.     // Suggested by https://github.com/lazd
  341.     // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
  342.  
  343.     (liveEvents.length)
  344.       ? e[name] = liveEvents
  345.       : delete e[name];
  346.  
  347.     return this;
  348.   }
  349. };
  350.  
  351. module.exports = E;
  352.  
  353. },{}],7:[function(require,module,exports){
  354. (function (global, factory) {
  355.     if (typeof define === "function" && define.amd) {
  356.         define(['module', 'select'], factory);
  357.     } else if (typeof exports !== "undefined") {
  358.         factory(module, require('select'));
  359.     } else {
  360.         var mod = {
  361.             exports: {}
  362.         };
  363.         factory(mod, global.select);
  364.         global.clipboardAction = mod.exports;
  365.     }
  366. })(this, function (module, _select) {
  367.     'use strict';
  368.  
  369.     var _select2 = _interopRequireDefault(_select);
  370.  
  371.     function _interopRequireDefault(obj) {
  372.         return obj && obj.__esModule ? obj : {
  373.             default: obj
  374.         };
  375.     }
  376.  
  377.     var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
  378.         return typeof obj;
  379.     } : function (obj) {
  380.         return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  381.     };
  382.  
  383.     function _classCallCheck(instance, Constructor) {
  384.         if (!(instance instanceof Constructor)) {
  385.             throw new TypeError("Cannot call a class as a function");
  386.         }
  387.     }
  388.  
  389.     var _createClass = function () {
  390.         function defineProperties(target, props) {
  391.             for (var i = 0; i < props.length; i++) {
  392.                 var descriptor = props[i];
  393.                 descriptor.enumerable = descriptor.enumerable || false;
  394.                 descriptor.configurable = true;
  395.                 if ("value" in descriptor) descriptor.writable = true;
  396.                 Object.defineProperty(target, descriptor.key, descriptor);
  397.             }
  398.         }
  399.  
  400.         return function (Constructor, protoProps, staticProps) {
  401.             if (protoProps) defineProperties(Constructor.prototype, protoProps);
  402.             if (staticProps) defineProperties(Constructor, staticProps);
  403.             return Constructor;
  404.         };
  405.     }();
  406.  
  407.     var ClipboardAction = function () {
  408.         /**
  409.          * @param {Object} options
  410.          */
  411.         function ClipboardAction(options) {
  412.             _classCallCheck(this, ClipboardAction);
  413.  
  414.             this.resolveOptions(options);
  415.             this.initSelection();
  416.         }
  417.  
  418.         /**
  419.          * Defines base properties passed from constructor.
  420.          * @param {Object} options
  421.          */
  422.  
  423.  
  424.         _createClass(ClipboardAction, [{
  425.             key: 'resolveOptions',
  426.             value: function resolveOptions() {
  427.                 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  428.  
  429.                 this.action = options.action;
  430.                 this.emitter = options.emitter;
  431.                 this.target = options.target;
  432.                 this.text = options.text;
  433.                 this.trigger = options.trigger;
  434.  
  435.                 this.selectedText = '';
  436.             }
  437.         }, {
  438.             key: 'initSelection',
  439.             value: function initSelection() {
  440.                 if (this.text) {
  441.                     this.selectFake();
  442.                 } else if (this.target) {
  443.                     this.selectTarget();
  444.                 }
  445.             }
  446.         }, {
  447.             key: 'selectFake',
  448.             value: function selectFake() {
  449.                 var _this = this;
  450.  
  451.                 var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
  452.  
  453.                 this.removeFake();
  454.  
  455.                 this.fakeHandlerCallback = function () {
  456.                     return _this.removeFake();
  457.                 };
  458.                 this.fakeHandler = document.body.addEventListener('click', this.fakeHandlerCallback) || true;
  459.  
  460.                 this.fakeElem = document.createElement('textarea');
  461.                 // Prevent zooming on iOS
  462.                 this.fakeElem.style.fontSize = '12pt';
  463.                 // Reset box model
  464.                 this.fakeElem.style.border = '0';
  465.                 this.fakeElem.style.padding = '0';
  466.                 this.fakeElem.style.margin = '0';
  467.                 // Move element out of screen horizontally
  468.                 this.fakeElem.style.position = 'absolute';
  469.                 this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
  470.                 // Move element to the same position vertically
  471.                 var yPosition = window.pageYOffset || document.documentElement.scrollTop;
  472.                 this.fakeElem.style.top = yPosition + 'px';
  473.  
  474.                 this.fakeElem.setAttribute('readonly', '');
  475.                 this.fakeElem.value = this.text;
  476.  
  477.                 document.body.appendChild(this.fakeElem);
  478.  
  479.                 this.selectedText = (0, _select2.default)(this.fakeElem);
  480.                 this.copyText();
  481.             }
  482.         }, {
  483.             key: 'removeFake',
  484.             value: function removeFake() {
  485.                 if (this.fakeHandler) {
  486.                     document.body.removeEventListener('click', this.fakeHandlerCallback);
  487.                     this.fakeHandler = null;
  488.                     this.fakeHandlerCallback = null;
  489.                 }
  490.  
  491.                 if (this.fakeElem) {
  492.                     document.body.removeChild(this.fakeElem);
  493.                     this.fakeElem = null;
  494.                 }
  495.             }
  496.         }, {
  497.             key: 'selectTarget',
  498.             value: function selectTarget() {
  499.                 this.selectedText = (0, _select2.default)(this.target);
  500.                 this.copyText();
  501.             }
  502.         }, {
  503.             key: 'copyText',
  504.             value: function copyText() {
  505.                 var succeeded = void 0;
  506.  
  507.                 try {
  508.                     succeeded = document.execCommand(this.action);
  509.                 } catch (err) {
  510.                     succeeded = false;
  511.                 }
  512.  
  513.                 this.handleResult(succeeded);
  514.             }
  515.         }, {
  516.             key: 'handleResult',
  517.             value: function handleResult(succeeded) {
  518.                 this.emitter.emit(succeeded ? 'success' : 'error', {
  519.                     action: this.action,
  520.                     text: this.selectedText,
  521.                     trigger: this.trigger,
  522.                     clearSelection: this.clearSelection.bind(this)
  523.                 });
  524.             }
  525.         }, {
  526.             key: 'clearSelection',
  527.             value: function clearSelection() {
  528.                 if (this.target) {
  529.                     this.target.blur();
  530.                 }
  531.  
  532.                 window.getSelection().removeAllRanges();
  533.             }
  534.         }, {
  535.             key: 'destroy',
  536.             value: function destroy() {
  537.                 this.removeFake();
  538.             }
  539.         }, {
  540.             key: 'action',
  541.             set: function set() {
  542.                 var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
  543.  
  544.                 this._action = action;
  545.  
  546.                 if (this._action !== 'copy' && this._action !== 'cut') {
  547.                     throw new Error('Invalid "action" value, use either "copy" or "cut"');
  548.                 }
  549.             },
  550.             get: function get() {
  551.                 return this._action;
  552.             }
  553.         }, {
  554.             key: 'target',
  555.             set: function set(target) {
  556.                 if (target !== undefined) {
  557.                     if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
  558.                         if (this.action === 'copy' && target.hasAttribute('disabled')) {
  559.                             throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
  560.                         }
  561.  
  562.                         if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
  563.                             throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
  564.                         }
  565.  
  566.                         this._target = target;
  567.                     } else {
  568.                         throw new Error('Invalid "target" value, use a valid Element');
  569.                     }
  570.                 }
  571.             },
  572.             get: function get() {
  573.                 return this._target;
  574.             }
  575.         }]);
  576.  
  577.         return ClipboardAction;
  578.     }();
  579.  
  580.     module.exports = ClipboardAction;
  581. });
  582.  
  583. },{"select":5}],8:[function(require,module,exports){
  584. (function (global, factory) {
  585.     if (typeof define === "function" && define.amd) {
  586.         define(['module', './clipboard-action', 'tiny-emitter', 'good-listener'], factory);
  587.     } else if (typeof exports !== "undefined") {
  588.         factory(module, require('./clipboard-action'), require('tiny-emitter'), require('good-listener'));
  589.     } else {
  590.         var mod = {
  591.             exports: {}
  592.         };
  593.         factory(mod, global.clipboardAction, global.tinyEmitter, global.goodListener);
  594.         global.clipboard = mod.exports;
  595.     }
  596. })(this, function (module, _clipboardAction, _tinyEmitter, _goodListener) {
  597.     'use strict';
  598.  
  599.     var _clipboardAction2 = _interopRequireDefault(_clipboardAction);
  600.  
  601.     var _tinyEmitter2 = _interopRequireDefault(_tinyEmitter);
  602.  
  603.     var _goodListener2 = _interopRequireDefault(_goodListener);
  604.  
  605.     function _interopRequireDefault(obj) {
  606.         return obj && obj.__esModule ? obj : {
  607.             default: obj
  608.         };
  609.     }
  610.  
  611.     function _classCallCheck(instance, Constructor) {
  612.         if (!(instance instanceof Constructor)) {
  613.             throw new TypeError("Cannot call a class as a function");
  614.         }
  615.     }
  616.  
  617.     var _createClass = function () {
  618.         function defineProperties(target, props) {
  619.             for (var i = 0; i < props.length; i++) {
  620.                 var descriptor = props[i];
  621.                 descriptor.enumerable = descriptor.enumerable || false;
  622.                 descriptor.configurable = true;
  623.                 if ("value" in descriptor) descriptor.writable = true;
  624.                 Object.defineProperty(target, descriptor.key, descriptor);
  625.             }
  626.         }
  627.  
  628.         return function (Constructor, protoProps, staticProps) {
  629.             if (protoProps) defineProperties(Constructor.prototype, protoProps);
  630.             if (staticProps) defineProperties(Constructor, staticProps);
  631.             return Constructor;
  632.         };
  633.     }();
  634.  
  635.     function _possibleConstructorReturn(self, call) {
  636.         if (!self) {
  637.             throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  638.         }
  639.  
  640.         return call && (typeof call === "object" || typeof call === "function") ? call : self;
  641.     }
  642.  
  643.     function _inherits(subClass, superClass) {
  644.         if (typeof superClass !== "function" && superClass !== null) {
  645.             throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  646.         }
  647.  
  648.         subClass.prototype = Object.create(superClass && superClass.prototype, {
  649.             constructor: {
  650.                 value: subClass,
  651.                 enumerable: false,
  652.                 writable: true,
  653.                 configurable: true
  654.             }
  655.         });
  656.         if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  657.     }
  658.  
  659.     var Clipboard = function (_Emitter) {
  660.         _inherits(Clipboard, _Emitter);
  661.  
  662.         /**
  663.          * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
  664.          * @param {Object} options
  665.          */
  666.         function Clipboard(trigger, options) {
  667.             _classCallCheck(this, Clipboard);
  668.  
  669.             var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));
  670.  
  671.             _this.resolveOptions(options);
  672.             _this.listenClick(trigger);
  673.             return _this;
  674.         }
  675.  
  676.         /**
  677.          * Defines if attributes would be resolved using internal setter functions
  678.          * or custom functions that were passed in the constructor.
  679.          * @param {Object} options
  680.          */
  681.  
  682.  
  683.         _createClass(Clipboard, [{
  684.             key: 'resolveOptions',
  685.             value: function resolveOptions() {
  686.                 var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  687.  
  688.                 this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
  689.                 this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
  690.                 this.text = typeof options.text === 'function' ? options.text : this.defaultText;
  691.             }
  692.         }, {
  693.             key: 'listenClick',
  694.             value: function listenClick(trigger) {
  695.                 var _this2 = this;
  696.  
  697.                 this.listener = (0, _goodListener2.default)(trigger, 'click', function (e) {
  698.                     return _this2.onClick(e);
  699.                 });
  700.             }
  701.         }, {
  702.             key: 'onClick',
  703.             value: function onClick(e) {
  704.                 var trigger = e.delegateTarget || e.currentTarget;
  705.  
  706.                 if (this.clipboardAction) {
  707.                     this.clipboardAction = null;
  708.                 }
  709.  
  710.                 this.clipboardAction = new _clipboardAction2.default({
  711.                     action: this.action(trigger),
  712.                     target: this.target(trigger),
  713.                     text: this.text(trigger),
  714.                     trigger: trigger,
  715.                     emitter: this
  716.                 });
  717.             }
  718.         }, {
  719.             key: 'defaultAction',
  720.             value: function defaultAction(trigger) {
  721.                 return getAttributeValue('action', trigger);
  722.             }
  723.         }, {
  724.             key: 'defaultTarget',
  725.             value: function defaultTarget(trigger) {
  726.                 var selector = getAttributeValue('target', trigger);
  727.  
  728.                 if (selector) {
  729.                     return document.querySelector(selector);
  730.                 }
  731.             }
  732.         }, {
  733.             key: 'defaultText',
  734.             value: function defaultText(trigger) {
  735.                 return getAttributeValue('text', trigger);
  736.             }
  737.         }, {
  738.             key: 'destroy',
  739.             value: function destroy() {
  740.                 this.listener.destroy();
  741.  
  742.                 if (this.clipboardAction) {
  743.                     this.clipboardAction.destroy();
  744.                     this.clipboardAction = null;
  745.                 }
  746.             }
  747.         }], [{
  748.             key: 'isSupported',
  749.             value: function isSupported() {
  750.                 var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
  751.  
  752.                 var actions = typeof action === 'string' ? [action] : action;
  753.                 var support = !!document.queryCommandSupported;
  754.  
  755.                 actions.forEach(function (action) {
  756.                     support = support && !!document.queryCommandSupported(action);
  757.                 });
  758.  
  759.                 return support;
  760.             }
  761.         }]);
  762.  
  763.         return Clipboard;
  764.     }(_tinyEmitter2.default);
  765.  
  766.     /**
  767.      * Helper function to retrieve attribute value.
  768.      * @param {String} suffix
  769.      * @param {Element} element
  770.      */
  771.     function getAttributeValue(suffix, element) {
  772.         var attribute = 'data-clipboard-' + suffix;
  773.  
  774.         if (!element.hasAttribute(attribute)) {
  775.             return;
  776.         }
  777.  
  778.         return element.getAttribute(attribute);
  779.     }
  780.  
  781.     module.exports = Clipboard;
  782. });
  783.  
  784. },{"./clipboard-action":7,"good-listener":4,"tiny-emitter":6}]},{},[8])(8)
  785. });