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