2015-10-15 22:49:08 +03:00
/ * !
2020-03-05 09:26:34 +03:00
* clipboard . js v2 . 0.6
2020-02-29 20:55:14 +03:00
* https : //clipboardjs.com/
2018-03-01 08:56:32 +03:00
*
2015-10-15 22:49:08 +03:00
* Licensed MIT © Zeno Rocha
* /
2018-03-01 08:56:32 +03:00
( 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 ( ) ;
2018-11-13 07:42:07 +03:00
} ) ( this , function ( ) {
2018-03-01 08:56:32 +03:00
return /******/ ( function ( modules ) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = { } ;
/******/
/******/ // The require function
/******/ function _ _webpack _require _ _ ( moduleId ) {
/******/
/******/ // Check if module is in cache
/******/ if ( installedModules [ moduleId ] ) {
/******/ return installedModules [ moduleId ] . exports ;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules [ moduleId ] = {
/******/ i : moduleId ,
/******/ l : false ,
/******/ exports : { }
/******/ } ;
/******/
/******/ // Execute the module function
/******/ modules [ moduleId ] . call ( module . exports , module , module . exports , _ _webpack _require _ _ ) ;
/******/
/******/ // Flag the module as loaded
/******/ module . l = true ;
/******/
/******/ // Return the exports of the module
/******/ return module . exports ;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ _ _webpack _require _ _ . m = modules ;
/******/
/******/ // expose the module cache
/******/ _ _webpack _require _ _ . c = installedModules ;
/******/
/******/ // define getter function for harmony exports
/******/ _ _webpack _require _ _ . d = function ( exports , name , getter ) {
/******/ if ( ! _ _webpack _require _ _ . o ( exports , name ) ) {
2018-11-11 20:14:19 +03:00
/******/ Object . defineProperty ( exports , name , { enumerable : true , get : getter } ) ;
2018-03-01 08:56:32 +03:00
/******/ }
/******/ } ;
/******/
2018-11-11 19:17:25 +03:00
/******/ // define __esModule on exports
/******/ _ _webpack _require _ _ . r = function ( exports ) {
2018-11-11 20:14:19 +03:00
/******/ if ( typeof Symbol !== 'undefined' && Symbol . toStringTag ) {
/******/ Object . defineProperty ( exports , Symbol . toStringTag , { value : 'Module' } ) ;
/******/ }
2018-11-11 19:17:25 +03:00
/******/ Object . defineProperty ( exports , '__esModule' , { value : true } ) ;
/******/ } ;
/******/
2018-11-11 20:14:19 +03:00
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ _ _webpack _require _ _ . t = function ( value , mode ) {
/******/ if ( mode & 1 ) value = _ _webpack _require _ _ ( value ) ;
/******/ if ( mode & 8 ) return value ;
/******/ if ( ( mode & 4 ) && typeof value === 'object' && value && value . _ _esModule ) return value ;
/******/ var ns = Object . create ( null ) ;
/******/ _ _webpack _require _ _ . r ( ns ) ;
/******/ Object . defineProperty ( ns , 'default' , { enumerable : true , value : value } ) ;
/******/ if ( mode & 2 && typeof value != 'string' ) for ( var key in value ) _ _webpack _require _ _ . d ( ns , key , function ( key ) { return value [ key ] ; } . bind ( null , key ) ) ;
/******/ return ns ;
/******/ } ;
/******/
2018-03-01 08:56:32 +03:00
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ _ _webpack _require _ _ . n = function ( module ) {
/******/ var getter = module && module . _ _esModule ?
/******/ function getDefault ( ) { return module [ 'default' ] ; } :
/******/ function getModuleExports ( ) { return module ; } ;
/******/ _ _webpack _require _ _ . d ( getter , 'a' , getter ) ;
/******/ return getter ;
/******/ } ;
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ _ _webpack _require _ _ . o = function ( object , property ) { return Object . prototype . hasOwnProperty . call ( object , property ) ; } ;
/******/
/******/ // __webpack_public_path__
/******/ _ _webpack _require _ _ . p = "" ;
/******/
2018-11-11 19:17:25 +03:00
/******/
2018-03-01 08:56:32 +03:00
/******/ // Load entry module and return exports
2020-03-04 05:20:40 +03:00
/******/ return _ _webpack _require _ _ ( _ _webpack _require _ _ . s = 6 ) ;
2018-03-01 08:56:32 +03:00
/******/ } )
/************************************************************************/
2018-11-12 05:53:43 +03:00
/******/ ( [
/* 0 */
2020-03-04 05:20:40 +03:00
/***/ ( function ( module , exports ) {
2016-10-23 05:37:49 +03:00
2020-03-04 05:20:40 +03:00
function select ( element ) {
var selectedText ;
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
if ( element . nodeName === 'SELECT' ) {
element . focus ( ) ;
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
selectedText = element . value ;
}
else if ( element . nodeName === 'INPUT' || element . nodeName === 'TEXTAREA' ) {
var isReadOnly = element . hasAttribute ( 'readonly' ) ;
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
if ( ! isReadOnly ) {
element . setAttribute ( 'readonly' , '' ) ;
}
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
element . select ( ) ;
element . setSelectionRange ( 0 , element . value . length ) ;
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
if ( ! isReadOnly ) {
element . removeAttribute ( 'readonly' ) ;
}
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
selectedText = element . value ;
}
else {
if ( element . hasAttribute ( 'contenteditable' ) ) {
element . focus ( ) ;
}
2015-09-29 09:45:29 +03:00
2020-03-04 05:20:40 +03:00
var selection = window . getSelection ( ) ;
var range = document . createRange ( ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
range . selectNodeContents ( element ) ;
selection . removeAllRanges ( ) ;
selection . addRange ( range ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
selectedText = selection . toString ( ) ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
return selectedText ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
module . exports = select ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/***/ } ) ,
/* 1 */
/***/ ( function ( module , exports ) {
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
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)
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
E . prototype = {
on : function ( name , callback , ctx ) {
var e = this . e || ( this . e = { } ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
( e [ name ] || ( e [ name ] = [ ] ) ) . push ( {
fn : callback ,
ctx : ctx
} ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
return this ;
} ,
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
once : function ( name , callback , ctx ) {
var self = this ;
function listener ( ) {
self . off ( name , listener ) ;
callback . apply ( ctx , arguments ) ;
} ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
listener . _ = callback
return this . on ( name , listener , ctx ) ;
} ,
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
emit : function ( name ) {
var data = [ ] . slice . call ( arguments , 1 ) ;
var evtArr = ( ( this . e || ( this . e = { } ) ) [ name ] || [ ] ) . slice ( ) ;
var i = 0 ;
var len = evtArr . length ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
for ( i ; i < len ; i ++ ) {
evtArr [ i ] . fn . apply ( evtArr [ i ] . ctx , data ) ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
return this ;
} ,
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
off : function ( name , callback ) {
var e = this . e || ( this . e = { } ) ;
var evts = e [ name ] ;
var liveEvents = [ ] ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
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 ] ) ;
}
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
// 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
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
( liveEvents . length )
? e [ name ] = liveEvents
: delete e [ name ] ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
return this ;
}
} ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
module . exports = E ;
module . exports . TinyEmitter = E ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/***/ } ) ,
/* 2 */
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
var is = _ _webpack _require _ _ ( 3 ) ;
var delegate = _ _webpack _require _ _ ( 4 ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/ * *
* Validates all params and calls the right
* listener function based on its target type .
*
* @ param { String | HTMLElement | HTMLCollection | NodeList } target
* @ param { String } type
* @ param { Function } callback
* @ return { Object }
* /
function listen ( target , type , callback ) {
if ( ! target && ! type && ! callback ) {
throw new Error ( 'Missing required arguments' ) ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
if ( ! is . string ( type ) ) {
throw new TypeError ( 'Second argument must be a String' ) ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
if ( ! is . fn ( callback ) ) {
throw new TypeError ( 'Third argument must be a Function' ) ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
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' ) ;
}
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/ * *
* 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 ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
return {
destroy : function ( ) {
node . removeEventListener ( type , callback ) ;
2018-11-12 05:53:43 +03:00
}
2020-03-04 05:20:40 +03:00
}
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/ * *
* 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 ) ;
} ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
return {
destroy : function ( ) {
Array . prototype . forEach . call ( nodeList , function ( node ) {
node . removeEventListener ( type , callback ) ;
} ) ;
2018-11-12 05:53:43 +03:00
}
2020-03-04 05:20:40 +03:00
}
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/ * *
* 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 ( document . body , selector , type , callback ) ;
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
module . exports = listen ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/***/ } ) ,
/* 3 */
/***/ ( function ( module , exports ) {
2018-11-12 05:53:43 +03:00
/ * *
2020-03-04 05:20:40 +03:00
* 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]' ;
} ;
/***/ } ) ,
/* 4 */
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
var closest = _ _webpack _require _ _ ( 5 ) ;
/ * *
* Delegates event to a selector .
*
2018-11-12 05:53:43 +03:00
* @ param { Element } element
2020-03-04 05:20:40 +03:00
* @ param { String } selector
* @ param { String } type
* @ param { Function } callback
* @ param { Boolean } useCapture
* @ return { Object }
2018-11-12 05:53:43 +03:00
* /
2020-03-04 05:20:40 +03:00
function _delegate ( element , selector , type , callback , useCapture ) {
var listenerFn = listener . apply ( this , arguments ) ;
2015-09-29 09:45:29 +03:00
2020-03-04 05:20:40 +03:00
element . addEventListener ( type , listenerFn , useCapture ) ;
2015-09-29 09:45:29 +03:00
2020-03-04 05:20:40 +03:00
return {
destroy : function ( ) {
element . removeEventListener ( type , listenerFn , useCapture ) ;
}
}
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/ * *
* 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 ) ;
2018-11-12 05:53:43 +03:00
}
2020-03-04 05:20:40 +03:00
// 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 ( e . target , selector ) ;
if ( e . delegateTarget ) {
callback . call ( element , e ) ;
}
}
2018-11-12 05:53:43 +03:00
}
2020-03-04 05:20:40 +03:00
module . exports = delegate ;
2018-11-12 05:53:43 +03:00
/***/ } ) ,
2020-03-04 05:20:40 +03:00
/* 5 */
/***/ ( function ( module , exports ) {
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 ;
}
}
module . exports = closest ;
/***/ } ) ,
/* 6 */
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
2016-02-20 09:41:40 +03:00
2018-11-12 05:53:43 +03:00
"use strict" ;
2020-03-04 05:20:40 +03:00
_ _webpack _require _ _ . r ( _ _webpack _exports _ _ ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
// EXTERNAL MODULE: ./node_modules/select/src/select.js
var src _select = _ _webpack _require _ _ ( 0 ) ;
var select _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( src _select ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
// CONCATENATED MODULE: ./src/clipboard-action.js
2018-11-12 01:09:49 +03:00
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 ) ; }
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
function _classCallCheck ( instance , Constructor ) { if ( ! ( instance instanceof Constructor ) ) { throw new TypeError ( "Cannot call a class as a function" ) ; } }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
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 ; }
2018-11-12 05:53:43 +03:00
/ * *
* Inner class which performs selection from either ` text ` or ` target `
* properties and then executes copy or cut operations .
* /
2020-03-04 05:20:40 +03:00
2018-11-12 01:09:49 +03:00
var clipboard _action _ClipboardAction = /*#__PURE__*/ function ( ) {
/ * *
* @ param { Object } options
* /
function ClipboardAction ( options ) {
_classCallCheck ( this , ClipboardAction ) ;
this . resolveOptions ( options ) ;
this . initSelection ( ) ;
}
/ * *
* Defines base properties passed from constructor .
* @ param { Object } options
* /
_createClass ( ClipboardAction , [ {
key : "resolveOptions" ,
value : function resolveOptions ( ) {
var options = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
this . action = options . action ;
this . container = options . container ;
this . emitter = options . emitter ;
this . target = options . target ;
this . text = options . text ;
this . trigger = options . trigger ;
this . selectedText = '' ;
}
2018-11-12 05:53:43 +03:00
/ * *
2018-11-12 01:09:49 +03:00
* Decides which selection strategy is going to be applied based
* on the existence of ` text ` and ` target ` properties .
2018-11-12 05:53:43 +03:00
* /
2018-11-12 01:09:49 +03:00
} , {
key : "initSelection" ,
value : function initSelection ( ) {
if ( this . text ) {
this . selectFake ( ) ;
} else if ( this . target ) {
this . selectTarget ( ) ;
}
2018-11-12 05:53:43 +03:00
}
/ * *
2018-11-12 01:09:49 +03:00
* Creates a fake textarea element , sets its value from ` text ` property ,
* and makes a selection on it .
2018-11-12 05:53:43 +03:00
* /
2018-11-12 01:09:49 +03:00
} , {
key : "selectFake" ,
value : function selectFake ( ) {
var _this = this ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
var isRTL = document . documentElement . getAttribute ( 'dir' ) == 'rtl' ;
this . removeFake ( ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . fakeHandlerCallback = function ( ) {
return _this . removeFake ( ) ;
} ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . fakeHandler = this . container . addEventListener ( 'click' , this . fakeHandlerCallback ) || true ;
this . fakeElem = document . createElement ( 'textarea' ) ; // Prevent zooming on iOS
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . fakeElem . style . fontSize = '12pt' ; // Reset box model
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . fakeElem . style . border = '0' ;
this . fakeElem . style . padding = '0' ;
this . fakeElem . style . margin = '0' ; // Move element out of screen horizontally
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . fakeElem . style . position = 'absolute' ;
this . fakeElem . style [ isRTL ? 'right' : 'left' ] = '-9999px' ; // Move element to the same position vertically
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
var yPosition = window . pageYOffset || document . documentElement . scrollTop ;
this . fakeElem . style . top = "" . concat ( yPosition , "px" ) ;
this . fakeElem . setAttribute ( 'readonly' , '' ) ;
this . fakeElem . value = this . text ;
this . container . appendChild ( this . fakeElem ) ;
this . selectedText = select _default ( ) ( this . fakeElem ) ;
this . copyText ( ) ;
}
/ * *
* Only removes the fake element after another click event , that way
* a user can hit ` Ctrl+C ` to copy because selection still exists .
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "removeFake" ,
value : function removeFake ( ) {
if ( this . fakeHandler ) {
this . container . removeEventListener ( 'click' , this . fakeHandlerCallback ) ;
this . fakeHandler = null ;
this . fakeHandlerCallback = null ;
}
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
if ( this . fakeElem ) {
this . container . removeChild ( this . fakeElem ) ;
this . fakeElem = null ;
}
}
/ * *
* Selects the content from element passed on ` target ` property .
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "selectTarget" ,
value : function selectTarget ( ) {
this . selectedText = select _default ( ) ( this . target ) ;
this . copyText ( ) ;
}
/ * *
* Executes the copy operation based on the current selection .
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "copyText" ,
value : function copyText ( ) {
var succeeded ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
try {
succeeded = document . execCommand ( this . action ) ;
} catch ( err ) {
succeeded = false ;
}
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . handleResult ( succeeded ) ;
}
/ * *
* Fires an event based on the copy operation result .
* @ param { Boolean } succeeded
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "handleResult" ,
value : function handleResult ( succeeded ) {
this . emitter . emit ( succeeded ? 'success' : 'error' , {
action : this . action ,
text : this . selectedText ,
trigger : this . trigger ,
clearSelection : this . clearSelection . bind ( this )
} ) ;
}
/ * *
* Moves focus away from ` target ` and back to the trigger , removes current selection .
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "clearSelection" ,
value : function clearSelection ( ) {
if ( this . trigger ) {
this . trigger . focus ( ) ;
}
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
document . activeElement . blur ( ) ;
window . getSelection ( ) . removeAllRanges ( ) ;
}
/ * *
* Sets the ` action ` to be performed which can be either 'copy' or 'cut' .
* @ param { String } action
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "destroy" ,
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
/ * *
* Destroy lifecycle .
* /
value : function destroy ( ) {
this . removeFake ( ) ;
}
} , {
key : "action" ,
set : function set ( ) {
var action = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : 'copy' ;
this . _action = action ;
if ( this . _action !== 'copy' && this . _action !== 'cut' ) {
throw new Error ( 'Invalid "action" value, use either "copy" or "cut"' ) ;
}
}
/ * *
* Gets the ` action ` property .
* @ return { String }
* /
,
get : function get ( ) {
return this . _action ;
}
/ * *
* Sets the ` target ` property using an element
* that will be have its content copied .
* @ param { Element } target
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "target" ,
set : function set ( target ) {
if ( target !== undefined ) {
if ( target && _typeof ( target ) === 'object' && target . nodeType === 1 ) {
if ( this . action === 'copy' && target . hasAttribute ( 'disabled' ) ) {
throw new Error ( 'Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute' ) ;
}
if ( this . action === 'cut' && ( target . hasAttribute ( 'readonly' ) || target . hasAttribute ( 'disabled' ) ) ) {
throw new Error ( 'Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes' ) ;
}
this . _target = target ;
} else {
throw new Error ( 'Invalid "target" value, use a valid Element' ) ;
2018-11-12 05:53:43 +03:00
}
2018-11-12 01:09:49 +03:00
}
}
/ * *
* Gets the ` target ` property .
* @ return { String | HTMLElement }
* /
,
get : function get ( ) {
return this . _target ;
}
} ] ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
return ClipboardAction ;
2018-11-12 05:53:43 +03:00
} ( ) ;
2020-03-04 05:20:40 +03:00
/* harmony default export */ var clipboard _action = ( clipboard _action _ClipboardAction ) ;
// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js
var tiny _emitter = _ _webpack _require _ _ ( 1 ) ;
var tiny _emitter _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( tiny _emitter ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
var listen = _ _webpack _require _ _ ( 2 ) ;
var listen _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( listen ) ;
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
// CONCATENATED MODULE: ./src/clipboard.js
2018-11-12 01:09:49 +03:00
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 ) ; }
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
function clipboard _classCallCheck ( instance , Constructor ) { if ( ! ( instance instanceof Constructor ) ) { throw new TypeError ( "Cannot call a class as a function" ) ; } }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
function clipboard _defineProperties ( target , props ) { for ( var i = 0 ; i < props . length ; i ++ ) { var descriptor = props [ i ] ; descriptor . enumerable = descriptor . enumerable || false ; descriptor . configurable = true ; if ( "value" in descriptor ) descriptor . writable = true ; Object . defineProperty ( target , descriptor . key , descriptor ) ; } }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
function clipboard _createClass ( Constructor , protoProps , staticProps ) { if ( protoProps ) clipboard _defineProperties ( Constructor . prototype , protoProps ) ; if ( staticProps ) clipboard _defineProperties ( Constructor , staticProps ) ; return Constructor ; }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
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 ) ; }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
function _setPrototypeOf ( o , p ) { _setPrototypeOf = Object . setPrototypeOf || function _setPrototypeOf ( o , p ) { o . _ _proto _ _ = p ; return o ; } ; return _setPrototypeOf ( o , p ) ; }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
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 ) ; } ; }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
function _possibleConstructorReturn ( self , call ) { if ( call && ( clipboard _typeof ( call ) === "object" || typeof call === "function" ) ) { return call ; } return _assertThisInitialized ( self ) ; }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
function _assertThisInitialized ( self ) { if ( self === void 0 ) { throw new ReferenceError ( "this hasn't been initialised - super() hasn't been called" ) ; } return self ; }
2018-03-01 08:56:32 +03:00
2018-11-12 01:09:49 +03:00
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 ; } }
2018-03-01 08:56:32 +03:00
2018-11-12 01:09:49 +03:00
function _getPrototypeOf ( o ) { _getPrototypeOf = Object . setPrototypeOf ? Object . getPrototypeOf : function _getPrototypeOf ( o ) { return o . _ _proto _ _ || Object . getPrototypeOf ( o ) ; } ; return _getPrototypeOf ( o ) ; }
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
/ * *
* Base class which takes one or more elements , adds event listeners to them ,
* and instantiates a new ` ClipboardAction ` on each click .
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
var clipboard _Clipboard = /*#__PURE__*/ function ( _Emitter ) {
_inherits ( Clipboard , _Emitter ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
var _super = _createSuper ( Clipboard ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
/ * *
* @ param { String | HTMLElement | HTMLCollection | NodeList } trigger
* @ param { Object } options
* /
function Clipboard ( trigger , options ) {
var _this ;
2020-03-04 05:20:40 +03:00
2018-11-12 01:09:49 +03:00
clipboard _classCallCheck ( this , Clipboard ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
_this = _super . call ( this ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
_this . resolveOptions ( options ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
_this . listenClick ( trigger ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
return _this ;
}
/ * *
* Defines if attributes would be resolved using internal setter functions
* or custom functions that were passed in the constructor .
* @ param { Object } options
* /
clipboard _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
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "listenClick" ,
value : function listenClick ( trigger ) {
var _this2 = this ;
2018-03-01 08:56:32 +03:00
2018-11-12 01:09:49 +03:00
this . listener = listen _default ( ) ( trigger , 'click' , function ( e ) {
return _this2 . onClick ( e ) ;
} ) ;
}
/ * *
* Defines a new ` ClipboardAction ` on each click event .
* @ param { Event } e
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "onClick" ,
value : function onClick ( e ) {
var trigger = e . delegateTarget || e . currentTarget ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
if ( this . clipboardAction ) {
this . clipboardAction = null ;
}
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
this . clipboardAction = new clipboard _action ( {
action : this . action ( trigger ) ,
target : this . target ( trigger ) ,
text : this . text ( trigger ) ,
container : this . container ,
trigger : trigger ,
emitter : this
} ) ;
}
/ * *
* Default ` action ` lookup function .
* @ param { Element } trigger
* /
2018-03-01 08:56:32 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "defaultAction" ,
value : function defaultAction ( trigger ) {
return getAttributeValue ( 'action' , trigger ) ;
}
/ * *
* Default ` target ` lookup function .
* @ param { Element } trigger
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "defaultTarget" ,
value : function defaultTarget ( trigger ) {
var selector = getAttributeValue ( 'target' , trigger ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
if ( selector ) {
return document . querySelector ( selector ) ;
}
}
/ * *
* Returns the support of the given action , or all actions if no action is
* given .
* @ param { String } [ action ]
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "defaultText" ,
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
/ * *
* Default ` text ` lookup function .
* @ param { Element } trigger
* /
value : function defaultText ( trigger ) {
return getAttributeValue ( 'text' , trigger ) ;
}
/ * *
* Destroy lifecycle .
* /
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
} , {
key : "destroy" ,
value : function destroy ( ) {
this . listener . destroy ( ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
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 ;
}
} ] ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
return Clipboard ;
2020-03-04 05:20:40 +03:00
} ( tiny _emitter _default . a ) ;
2018-11-12 05:53:43 +03:00
/ * *
2020-03-04 05:20:40 +03:00
* Helper function to retrieve attribute value .
* @ param { String } suffix
2018-11-12 05:53:43 +03:00
* @ param { Element } element
* /
2018-03-01 08:56:32 +03:00
2020-03-04 05:20:40 +03:00
function getAttributeValue ( suffix , element ) {
2018-11-12 01:09:49 +03:00
var attribute = "data-clipboard-" . concat ( suffix ) ;
2018-11-12 05:53:43 +03:00
2018-11-12 01:09:49 +03:00
if ( ! element . hasAttribute ( attribute ) ) {
return ;
}
2018-11-11 19:17:25 +03:00
2018-11-12 01:09:49 +03:00
return element . getAttribute ( attribute ) ;
2020-03-04 05:20:40 +03:00
}
2018-11-12 05:53:43 +03:00
2020-03-04 05:20:40 +03:00
/* harmony default export */ var clipboard = _ _webpack _exports _ _ [ "default" ] = ( clipboard _Clipboard ) ;
2018-11-12 05:53:43 +03:00
/***/ } )
2020-03-04 05:20:40 +03:00
/******/ ] ) [ "default" ] ;
2015-10-04 05:17:42 +03:00
} ) ;