2018-12-13 23:41:57 -05:00
this [ "wp" ] = this [ "wp" ] || { } ; this [ "wp" ] [ "compose" ] =
/******/ ( 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 ) ) {
/******/ Object . defineProperty ( exports , name , { enumerable : true , get : getter } ) ;
/******/ }
/******/ } ;
/******/
/******/ // define __esModule on exports
/******/ _ _webpack _require _ _ . r = function ( exports ) {
/******/ if ( typeof Symbol !== 'undefined' && Symbol . toStringTag ) {
/******/ Object . defineProperty ( exports , Symbol . toStringTag , { value : 'Module' } ) ;
/******/ }
/******/ Object . defineProperty ( exports , '__esModule' , { value : true } ) ;
/******/ } ;
/******/
/******/ // 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 ;
/******/ } ;
/******/
/******/ // 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 = "" ;
/******/
/******/
/******/ // Load entry module and return exports
2020-10-20 09:36:16 -04:00
/******/ return _ _webpack _require _ _ ( _ _webpack _require _ _ . s = 463 ) ;
2018-12-13 23:41:57 -05:00
/******/ } )
/************************************************************************/
/******/ ( {
2018-12-17 22:14:52 -05:00
/***/ 0 :
/***/ ( function ( module , exports ) {
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
( function ( ) { module . exports = this [ "wp" ] [ "element" ] ; } ( ) ) ;
2018-12-13 23:41:57 -05:00
/***/ } ) ,
2020-07-07 10:43:35 -04:00
/***/ 12 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2020-06-29 07:50:29 -04:00
// EXPORTS
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return /* binding */ _slicedToArray ; } ) ;
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
var arrayWithHoles = _ _webpack _require _ _ ( 38 ) ;
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
function _iterableToArrayLimit ( arr , i ) {
if ( typeof Symbol === "undefined" || ! ( Symbol . iterator in Object ( arr ) ) ) return ;
var _arr = [ ] ;
var _n = true ;
var _d = false ;
var _e = undefined ;
try {
for ( var _i = arr [ Symbol . iterator ] ( ) , _s ; ! ( _n = ( _s = _i . next ( ) ) . done ) ; _n = true ) {
_arr . push ( _s . value ) ;
if ( i && _arr . length === i ) break ;
}
} catch ( err ) {
_d = true ;
_e = err ;
} finally {
try {
if ( ! _n && _i [ "return" ] != null ) _i [ "return" ] ( ) ;
} finally {
if ( _d ) throw _e ;
}
}
return _arr ;
}
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
2020-10-13 09:10:30 -04:00
var unsupportedIterableToArray = _ _webpack _require _ _ ( 30 ) ;
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
var nonIterableRest = _ _webpack _require _ _ ( 39 ) ;
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
function _slicedToArray ( arr , i ) {
return Object ( arrayWithHoles [ "a" /* default */ ] ) ( arr ) || _iterableToArrayLimit ( arr , i ) || Object ( unsupportedIterableToArray [ "a" /* default */ ] ) ( arr , i ) || Object ( nonIterableRest [ "a" /* default */ ] ) ( ) ;
}
/***/ } ) ,
2020-10-13 09:10:30 -04:00
/***/ 13 :
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "React" ] ; } ( ) ) ;
/***/ } ) ,
/***/ 152 :
2020-07-07 10:43:35 -04:00
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
2020-07-21 08:14:37 -04:00
var e = _ _webpack _require _ _ ( 13 ) , n = { display : "block" , opacity : 0 , position : "absolute" , top : 0 , left : 0 , height : "100%" , width : "100%" , overflow : "hidden" , pointerEvents : "none" , zIndex : - 1 } , t = function ( t ) { var r = t . onResize , u = e . useRef ( ) ; return function ( n , t ) { var r = function ( ) { return n . current && n . current . contentDocument && n . current . contentDocument . defaultView } ; function u ( ) { t ( ) ; var e = r ( ) ; e && e . addEventListener ( "resize" , t ) } e . useEffect ( ( function ( ) { return r ( ) ? u ( ) : n . current && n . current . addEventListener && n . current . addEventListener ( "load" , u ) , function ( ) { var e = r ( ) ; e && "function" == typeof e . removeEventListener && e . removeEventListener ( "resize" , t ) } } ) , [ ] ) } ( u , ( function ( ) { return r ( u ) } ) ) , e . createElement ( "iframe" , { style : n , src : "about:blank" , ref : u , "aria-hidden" : ! 0 , tabIndex : - 1 , frameBorder : 0 } ) } , r = function ( e ) { return { width : null != e ? e . offsetWidth : null , height : null != e ? e . offsetHeight : null } } ; module . exports = function ( n ) { void 0 === n && ( n = r ) ; var u = e . useState ( n ( null ) ) , o = u [ 0 ] , i = u [ 1 ] , c = e . useCallback ( ( function ( e ) { return i ( n ( e . current ) ) } ) , [ n ] ) ; return [ e . useMemo ( ( function ( ) { return e . createElement ( t , { onResize : c } ) } ) , [ c ] ) , o ] } ;
2020-07-07 10:43:35 -04:00
/***/ } ) ,
2020-10-13 09:10:30 -04:00
/***/ 153 :
2020-07-07 10:43:35 -04:00
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "wp" ] [ "priorityQueue" ] ; } ( ) ) ;
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 154 :
2020-07-07 10:43:35 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2020-10-20 09:36:16 -04:00
/* unused harmony export useCallback */
/* unused harmony export useCallbackOne */
/* unused harmony export useMemo */
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return useMemoOne ; } ) ;
/* harmony import */ var react _ _WEBPACK _IMPORTED _MODULE _0 _ _ = _ _webpack _require _ _ ( 13 ) ;
/* harmony import */ var react _ _WEBPACK _IMPORTED _MODULE _0 _ _ _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( react _ _WEBPACK _IMPORTED _MODULE _0 _ _ ) ;
function areInputsEqual ( newInputs , lastInputs ) {
if ( newInputs . length !== lastInputs . length ) {
return false ;
}
for ( var i = 0 ; i < newInputs . length ; i ++ ) {
if ( newInputs [ i ] !== lastInputs [ i ] ) {
return false ;
}
}
return true ;
}
function useMemoOne ( getResult , inputs ) {
var initial = Object ( react _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ "useState" ] ) ( function ( ) {
return {
inputs : inputs ,
result : getResult ( )
} ;
} ) [ 0 ] ;
var committed = Object ( react _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ "useRef" ] ) ( initial ) ;
var isInputMatch = Boolean ( inputs && committed . current . inputs && areInputsEqual ( inputs , committed . current . inputs ) ) ;
var cache = isInputMatch ? committed . current : {
inputs : inputs ,
result : getResult ( )
2020-07-07 10:43:35 -04:00
} ;
2020-10-20 09:36:16 -04:00
Object ( react _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ "useEffect" ] ) ( function ( ) {
committed . current = cache ;
} , [ cache ] ) ;
return cache . result ;
2020-07-07 10:43:35 -04:00
}
2020-10-20 09:36:16 -04:00
function useCallbackOne ( callback , inputs ) {
return useMemoOne ( function ( ) {
return callback ;
} , inputs ) ;
}
var useMemo = useMemoOne ;
var useCallback = useCallbackOne ;
2020-07-07 10:43:35 -04:00
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 16 :
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _assertThisInitialized ; } ) ;
function _assertThisInitialized ( self ) {
if ( self === void 0 ) {
throw new ReferenceError ( "this hasn't been initialised - super() hasn't been called" ) ;
}
return self ;
}
/***/ } ) ,
/***/ 17 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2020-06-29 07:50:29 -04:00
// EXPORTS
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return /* binding */ _toConsumableArray ; } ) ;
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
2020-10-13 09:10:30 -04:00
var arrayLikeToArray = _ _webpack _require _ _ ( 27 ) ;
2020-06-26 09:33:47 -04:00
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
function _arrayWithoutHoles ( arr ) {
if ( Array . isArray ( arr ) ) return Object ( arrayLikeToArray [ "a" /* default */ ] ) ( arr ) ;
}
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
2020-10-13 09:10:30 -04:00
var iterableToArray = _ _webpack _require _ _ ( 37 ) ;
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
2020-10-13 09:10:30 -04:00
var unsupportedIterableToArray = _ _webpack _require _ _ ( 30 ) ;
2020-06-26 09:33:47 -04:00
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
function _nonIterableSpread ( ) {
throw new TypeError ( "Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method." ) ;
}
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
function _toConsumableArray ( arr ) {
return _arrayWithoutHoles ( arr ) || Object ( iterableToArray [ "a" /* default */ ] ) ( arr ) || Object ( unsupportedIterableToArray [ "a" /* default */ ] ) ( arr ) || _nonIterableSpread ( ) ;
}
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 19 :
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _getPrototypeOf ; } ) ;
function _getPrototypeOf ( o ) {
_getPrototypeOf = Object . setPrototypeOf ? Object . getPrototypeOf : function _getPrototypeOf ( o ) {
return o . _ _proto _ _ || Object . getPrototypeOf ( o ) ;
} ;
return _getPrototypeOf ( o ) ;
}
/***/ } ) ,
2020-10-13 09:10:30 -04:00
/***/ 2 :
/***/ ( function ( module , exports ) {
( function ( ) { module . exports = this [ "lodash" ] ; } ( ) ) ;
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 21 :
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _classCallCheck ; } ) ;
function _classCallCheck ( instance , Constructor ) {
if ( ! ( instance instanceof Constructor ) ) {
throw new TypeError ( "Cannot call a class as a function" ) ;
}
}
/***/ } ) ,
/***/ 22 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _createClass ; } ) ;
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 ;
}
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 23 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2020-06-29 07:50:29 -04:00
// EXPORTS
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return /* binding */ _inherits ; } ) ;
2020-06-26 09:33:47 -04:00
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
function _setPrototypeOf ( o , p ) {
_setPrototypeOf = Object . setPrototypeOf || function _setPrototypeOf ( o , p ) {
o . _ _proto _ _ = p ;
return o ;
} ;
return _setPrototypeOf ( o , p ) ;
}
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
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 ) ;
}
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 24 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _possibleConstructorReturn ; } ) ;
/* harmony import */ var _helpers _esm _typeof _ _WEBPACK _IMPORTED _MODULE _0 _ _ = _ _webpack _require _ _ ( 40 ) ;
2020-10-20 09:36:16 -04:00
/* harmony import */ var _assertThisInitialized _ _WEBPACK _IMPORTED _MODULE _1 _ _ = _ _webpack _require _ _ ( 16 ) ;
2020-06-26 09:33:47 -04:00
function _possibleConstructorReturn ( self , call ) {
if ( call && ( Object ( _helpers _esm _typeof _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ /* default */ "a" ] ) ( call ) === "object" || typeof call === "function" ) ) {
return call ;
}
return Object ( _assertThisInitialized _ _WEBPACK _IMPORTED _MODULE _1 _ _ [ /* default */ "a" ] ) ( self ) ;
}
/***/ } ) ,
2020-10-13 09:10:30 -04:00
/***/ 27 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _arrayLikeToArray ; } ) ;
function _arrayLikeToArray ( arr , len ) {
if ( len == null || len > arr . length ) len = arr . length ;
for ( var i = 0 , arr2 = new Array ( len ) ; i < len ; i ++ ) {
arr2 [ i ] = arr [ i ] ;
}
return arr2 ;
}
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 287 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
/ * !
* clipboard . js v2 . 0.6
* https : //clipboardjs.com/
*
* Licensed MIT © Zeno Rocha
* /
( function webpackUniversalModuleDefinition ( root , factory ) {
if ( true )
module . exports = factory ( ) ;
else { }
} ) ( this , function ( ) {
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 ) ) {
/******/ Object . defineProperty ( exports , name , { enumerable : true , get : getter } ) ;
/******/ }
/******/ } ;
/******/
/******/ // define __esModule on exports
/******/ _ _webpack _require _ _ . r = function ( exports ) {
/******/ if ( typeof Symbol !== 'undefined' && Symbol . toStringTag ) {
/******/ Object . defineProperty ( exports , Symbol . toStringTag , { value : 'Module' } ) ;
/******/ }
/******/ Object . defineProperty ( exports , '__esModule' , { value : true } ) ;
/******/ } ;
/******/
/******/ // 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 ;
/******/ } ;
/******/
/******/ // 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 = "" ;
/******/
/******/
/******/ // Load entry module and return exports
/******/ return _ _webpack _require _ _ ( _ _webpack _require _ _ . s = 6 ) ;
/******/ } )
/************************************************************************/
/******/ ( [
/* 0 */
/***/ ( function ( 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 ;
}
module . exports = select ;
/***/ } ) ,
/* 1 */
/***/ ( function ( module , exports ) {
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 ;
}
} ;
module . exports = E ;
module . exports . TinyEmitter = E ;
/***/ } ) ,
/* 2 */
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
var is = _ _webpack _require _ _ ( 3 ) ;
var delegate = _ _webpack _require _ _ ( 4 ) ;
/ * *
* 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' ) ;
}
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 ( document . body , selector , type , callback ) ;
}
module . exports = listen ;
/***/ } ) ,
/* 3 */
/***/ ( 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]' ;
} ;
/***/ } ) ,
/* 4 */
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
var closest = _ _webpack _require _ _ ( 5 ) ;
/ * *
* Delegates event to a selector .
*
* @ param { Element } element
* @ param { String } selector
* @ param { String } type
* @ param { Function } callback
* @ param { Boolean } useCapture
* @ return { Object }
* /
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 ( e . target , selector ) ;
if ( e . delegateTarget ) {
callback . call ( element , e ) ;
}
}
}
module . exports = delegate ;
/***/ } ) ,
/* 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 _ _ ) {
"use strict" ;
_ _webpack _require _ _ . r ( _ _webpack _exports _ _ ) ;
// EXTERNAL MODULE: ./node_modules/select/src/select.js
var src _select = _ _webpack _require _ _ ( 0 ) ;
var select _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( src _select ) ;
// CONCATENATED MODULE: ./src/clipboard-action.js
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 ; } ;
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 _classCallCheck ( instance , Constructor ) { if ( ! ( instance instanceof Constructor ) ) { throw new TypeError ( "Cannot call a class as a function" ) ; } }
/ * *
* Inner class which performs selection from either ` text ` or ` target `
* properties and then executes copy or cut operations .
* /
var clipboard _action _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 = '' ;
}
/ * *
* Decides which selection strategy is going to be applied based
* on the existence of ` text ` and ` target ` properties .
* /
} , {
key : 'initSelection' ,
value : function initSelection ( ) {
if ( this . text ) {
this . selectFake ( ) ;
} else if ( this . target ) {
this . selectTarget ( ) ;
}
}
/ * *
* Creates a fake textarea element , sets its value from ` text ` property ,
* and makes a selection on it .
* /
} , {
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 = 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 .
* /
} , {
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 ;
}
}
/ * *
* Selects the content from element passed on ` target ` property .
* /
} , {
key : 'selectTarget' ,
value : function selectTarget ( ) {
this . selectedText = select _default ( ) ( this . target ) ;
this . copyText ( ) ;
}
/ * *
* Executes the copy operation based on the current selection .
* /
} , {
key : 'copyText' ,
value : function copyText ( ) {
var succeeded = void 0 ;
try {
succeeded = document . execCommand ( this . action ) ;
} catch ( err ) {
succeeded = false ;
}
this . handleResult ( succeeded ) ;
}
/ * *
* Fires an event based on the copy operation result .
* @ param { Boolean } 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 )
} ) ;
}
/ * *
* Moves focus away from ` target ` and back to the trigger , removes current selection .
* /
} , {
key : 'clearSelection' ,
value : function clearSelection ( ) {
if ( this . trigger ) {
this . trigger . focus ( ) ;
}
document . activeElement . blur ( ) ;
window . getSelection ( ) . removeAllRanges ( ) ;
}
/ * *
* Sets the ` action ` to be performed which can be either 'copy' or 'cut' .
* @ param { String } action
* /
2020-02-06 16:03:31 -05:00
2020-06-26 09:33:47 -04:00
} , {
key : 'destroy' ,
2020-01-03 08:17:24 -05:00
2020-01-22 17:06:21 -05:00
2020-06-26 09:33:47 -04:00
/ * *
* Destroy lifecycle .
* /
value : function destroy ( ) {
this . removeFake ( ) ;
2020-01-22 17:06:21 -05:00
}
2020-06-26 09:33:47 -04:00
} , {
key : 'action' ,
set : function set ( ) {
var action = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : 'copy' ;
2020-01-22 17:06:21 -05:00
2020-06-26 09:33:47 -04:00
this . _action = action ;
2020-01-22 17:06:21 -05:00
2020-06-26 09:33:47 -04:00
if ( this . _action !== 'copy' && this . _action !== 'cut' ) {
throw new Error ( 'Invalid "action" value, use either "copy" or "cut"' ) ;
}
}
2020-01-22 17:06:21 -05:00
2020-06-26 09:33:47 -04:00
/ * *
* Gets the ` action ` property .
* @ return { String }
* /
,
get : function get ( ) {
return this . _action ;
}
2020-01-22 17:06:21 -05:00
2020-06-26 09:33:47 -04:00
/ * *
* Sets the ` target ` property using an element
* that will be have its content copied .
* @ param { Element } target
* /
2020-01-22 17:06:21 -05:00
2020-06-26 09:33:47 -04:00
} , {
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' ) ;
}
2020-01-03 08:17:24 -05:00
2020-06-26 09:33:47 -04:00
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' ) ;
}
2020-01-03 08:17:24 -05:00
2020-06-26 09:33:47 -04:00
this . _target = target ;
} else {
throw new Error ( 'Invalid "target" value, use a valid Element' ) ;
}
}
}
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Gets the ` target ` property .
* @ return { String | HTMLElement }
* /
,
get : function get ( ) {
return this . _target ;
}
} ] ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return ClipboardAction ;
} ( ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04: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-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
var listen = _ _webpack _require _ _ ( 2 ) ;
var listen _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( listen ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
// CONCATENATED MODULE: ./src/clipboard.js
var clipboard _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 ; } ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var clipboard _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 ; } ; } ( ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
function clipboard _classCallCheck ( instance , Constructor ) { if ( ! ( instance instanceof Constructor ) ) { throw new TypeError ( "Cannot call a class as a function" ) ; } }
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
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 ; }
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
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 ; }
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
/ * *
* Base class which takes one or more elements , adds event listeners to them ,
* and instantiates a new ` ClipboardAction ` on each click .
* /
2018-12-17 22:14:52 -05:00
2020-06-26 09:33:47 -04:00
var clipboard _Clipboard = function ( _Emitter ) {
_inherits ( Clipboard , _Emitter ) ;
2018-12-17 22:14:52 -05:00
2020-06-26 09:33:47 -04:00
/ * *
* @ param { String | HTMLElement | HTMLCollection | NodeList } trigger
* @ param { Object } options
* /
function Clipboard ( trigger , options ) {
clipboard _classCallCheck ( this , Clipboard ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var _this = _possibleConstructorReturn ( this , ( Clipboard . _ _proto _ _ || Object . getPrototypeOf ( Clipboard ) ) . call ( this ) ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
_this . resolveOptions ( options ) ;
_this . listenClick ( trigger ) ;
return _this ;
2018-12-13 23:41:57 -05:00
}
2020-06-26 09:33:47 -04:00
/ * *
* Defines if attributes would be resolved using internal setter functions
* or custom functions that were passed in the constructor .
* @ param { Object } options
* /
2018-12-13 23:41:57 -05:00
2019-10-15 12:17:12 -04:00
2020-06-26 09:33:47 -04:00
clipboard _createClass ( Clipboard , [ {
key : 'resolveOptions' ,
value : function resolveOptions ( ) {
var options = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
2019-10-15 12:17:12 -04:00
2020-06-26 09:33:47 -04:00
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 ;
}
2019-10-15 12:17:12 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Adds a click event listener to the passed trigger .
* @ param { String | HTMLElement | HTMLCollection | NodeList } trigger
* /
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
} , {
key : 'listenClick' ,
value : function listenClick ( trigger ) {
var _this2 = this ;
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
this . listener = listen _default ( ) ( trigger , 'click' , function ( e ) {
return _this2 . onClick ( e ) ;
} ) ;
}
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Defines a new ` ClipboardAction ` on each click event .
* @ param { Event } e
* /
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
} , {
key : 'onClick' ,
value : function onClick ( e ) {
var trigger = e . delegateTarget || e . currentTarget ;
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
if ( this . clipboardAction ) {
this . clipboardAction = null ;
}
2019-03-21 08:48:00 -04:00
2020-06-26 09:33:47 -04: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
} ) ;
}
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Default ` action ` lookup function .
* @ param { Element } trigger
* /
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
} , {
key : 'defaultAction' ,
value : function defaultAction ( trigger ) {
return getAttributeValue ( 'action' , trigger ) ;
}
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Default ` target ` lookup function .
* @ param { Element } trigger
* /
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
} , {
key : 'defaultTarget' ,
value : function defaultTarget ( trigger ) {
var selector = getAttributeValue ( 'target' , trigger ) ;
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
if ( selector ) {
return document . querySelector ( selector ) ;
}
}
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Returns the support of the given action , or all actions if no action is
* given .
* @ param { String } [ action ]
* /
2020-02-06 16:03:31 -05:00
2020-06-26 09:33:47 -04:00
} , {
key : 'defaultText' ,
2020-02-06 16:03:31 -05:00
2020-06-26 09:33:47 -04:00
/ * *
* Default ` text ` lookup function .
* @ param { Element } trigger
* /
value : function defaultText ( trigger ) {
return getAttributeValue ( 'text' , trigger ) ;
}
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
/ * *
* Destroy lifecycle .
* /
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
} , {
key : 'destroy' ,
value : function destroy ( ) {
this . listener . destroy ( ) ;
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04: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' ] ;
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
var actions = typeof action === 'string' ? [ action ] : action ;
var support = ! ! document . queryCommandSupported ;
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
actions . forEach ( function ( action ) {
support = support && ! ! document . queryCommandSupported ( action ) ;
} ) ;
2020-02-06 16:03:31 -05:00
2020-06-26 09:33:47 -04:00
return support ;
}
} ] ) ;
return Clipboard ;
} ( tiny _emitter _default . a ) ;
2020-02-06 16:03:31 -05:00
/ * *
2020-06-26 09:33:47 -04:00
* Helper function to retrieve attribute value .
* @ param { String } suffix
* @ param { Element } element
2020-02-06 16:03:31 -05:00
* /
2020-06-26 09:33:47 -04:00
function getAttributeValue ( suffix , element ) {
var attribute = 'data-clipboard-' + suffix ;
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
if ( ! element . hasAttribute ( attribute ) ) {
return ;
}
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
return element . getAttribute ( attribute ) ;
}
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
/* harmony default export */ var clipboard = _ _webpack _exports _ _ [ "default" ] = ( clipboard _Clipboard ) ;
2020-03-23 19:40:19 -04:00
2020-06-26 09:33:47 -04:00
/***/ } )
/******/ ] ) [ "default" ] ;
} ) ;
2019-03-21 08:48:00 -04:00
2019-10-15 11:37:08 -04:00
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 288 :
2020-01-22 17:06:21 -05:00
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
var _ _WEBPACK _AMD _DEFINE _RESULT _ _ ; /*global define:false */
/ * *
* Copyright 2012 - 2017 Craig Campbell
*
* Licensed under the Apache License , Version 2.0 ( the "License" ) ;
* you may not use this file except in compliance with the License .
* You may obtain a copy of the License at
*
* http : //www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing , software
* distributed under the License is distributed on an "AS IS" BASIS ,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND , either express or implied .
* See the License for the specific language governing permissions and
* limitations under the License .
*
* Mousetrap is a simple keyboard shortcut library for Javascript with
* no external dependencies
*
2020-02-06 16:03:31 -05:00
* @ version 1.6 . 5
2020-01-22 17:06:21 -05:00
* @ url craig . is / killing / mice
* /
( function ( window , document , undefined ) {
// Check if mousetrap is used inside browser, if not, return
if ( ! window ) {
return ;
}
/ * *
* mapping of special keycodes to their corresponding keys
*
* everything in this dictionary cannot use keypress events
* so it has to be here to map to the correct keycodes for
* keyup / keydown events
*
* @ type { Object }
* /
var _MAP = {
8 : 'backspace' ,
9 : 'tab' ,
13 : 'enter' ,
16 : 'shift' ,
17 : 'ctrl' ,
18 : 'alt' ,
20 : 'capslock' ,
27 : 'esc' ,
32 : 'space' ,
33 : 'pageup' ,
34 : 'pagedown' ,
35 : 'end' ,
36 : 'home' ,
37 : 'left' ,
38 : 'up' ,
39 : 'right' ,
40 : 'down' ,
45 : 'ins' ,
46 : 'del' ,
91 : 'meta' ,
93 : 'meta' ,
224 : 'meta'
} ;
/ * *
* mapping for special characters so they can support
*
* this dictionary is only used incase you want to bind a
* keyup or keydown event to one of these keys
*
* @ type { Object }
* /
var _KEYCODE _MAP = {
106 : '*' ,
107 : '+' ,
109 : '-' ,
110 : '.' ,
111 : '/' ,
186 : ';' ,
187 : '=' ,
188 : ',' ,
189 : '-' ,
190 : '.' ,
191 : '/' ,
192 : '`' ,
219 : '[' ,
220 : '\\' ,
221 : ']' ,
222 : '\''
} ;
/ * *
* this is a mapping of keys that require shift on a US keypad
* back to the non shift equivelents
*
* this is so you can use keyup events with these keys
*
* note that this will only work reliably on US keyboards
*
* @ type { Object }
* /
var _SHIFT _MAP = {
'~' : '`' ,
'!' : '1' ,
'@' : '2' ,
'#' : '3' ,
'$' : '4' ,
'%' : '5' ,
'^' : '6' ,
'&' : '7' ,
'*' : '8' ,
'(' : '9' ,
')' : '0' ,
'_' : '-' ,
'+' : '=' ,
':' : ';' ,
'\"' : '\'' ,
'<' : ',' ,
'>' : '.' ,
'?' : '/' ,
'|' : '\\'
} ;
/ * *
* this is a list of special strings you can use to map
* to modifier keys when you specify your keyboard shortcuts
*
* @ type { Object }
* /
var _SPECIAL _ALIASES = {
'option' : 'alt' ,
'command' : 'meta' ,
'return' : 'enter' ,
'escape' : 'esc' ,
'plus' : '+' ,
'mod' : /Mac|iPod|iPhone|iPad/ . test ( navigator . platform ) ? 'meta' : 'ctrl'
} ;
/ * *
* variable to store the flipped version of _MAP from above
* needed to check if we should use keypress or not when no action
* is specified
*
* @ type { Object | undefined }
* /
var _REVERSE _MAP ;
/ * *
* loop through the f keys , f1 to f19 and add them to the map
* programatically
* /
for ( var i = 1 ; i < 20 ; ++ i ) {
_MAP [ 111 + i ] = 'f' + i ;
}
/ * *
* loop through to map numbers on the numeric keypad
* /
for ( i = 0 ; i <= 9 ; ++ i ) {
// This needs to use a string cause otherwise since 0 is falsey
// mousetrap will never fire for numpad 0 pressed as part of a keydown
// event.
//
// @see https://github.com/ccampbell/mousetrap/pull/258
_MAP [ i + 96 ] = i . toString ( ) ;
}
/ * *
* cross browser add event method
*
* @ param { Element | HTMLDocument } object
* @ param { string } type
* @ param { Function } callback
* @ returns void
* /
function _addEvent ( object , type , callback ) {
if ( object . addEventListener ) {
object . addEventListener ( type , callback , false ) ;
return ;
}
object . attachEvent ( 'on' + type , callback ) ;
}
/ * *
* takes the event and returns the key character
*
* @ param { Event } e
* @ return { string }
* /
function _characterFromEvent ( e ) {
// for keypress events we should return the character as is
if ( e . type == 'keypress' ) {
var character = String . fromCharCode ( e . which ) ;
// if the shift key is not pressed then it is safe to assume
// that we want the character to be lowercase. this means if
// you accidentally have caps lock on then your key bindings
// will continue to work
//
// the only side effect that might not be desired is if you
// bind something like 'A' cause you want to trigger an
// event when capital A is pressed caps lock will no longer
// trigger the event. shift+a will though.
if ( ! e . shiftKey ) {
character = character . toLowerCase ( ) ;
}
return character ;
}
// for non keypress events the special maps are needed
if ( _MAP [ e . which ] ) {
return _MAP [ e . which ] ;
}
if ( _KEYCODE _MAP [ e . which ] ) {
return _KEYCODE _MAP [ e . which ] ;
}
// if it is not in the special map
// with keydown and keyup events the character seems to always
// come in as an uppercase character whether you are pressing shift
// or not. we should make sure it is always lowercase for comparisons
return String . fromCharCode ( e . which ) . toLowerCase ( ) ;
}
/ * *
* checks if two arrays are equal
*
* @ param { Array } modifiers1
* @ param { Array } modifiers2
* @ returns { boolean }
* /
function _modifiersMatch ( modifiers1 , modifiers2 ) {
return modifiers1 . sort ( ) . join ( ',' ) === modifiers2 . sort ( ) . join ( ',' ) ;
}
/ * *
* takes a key event and figures out what the modifiers are
*
* @ param { Event } e
* @ returns { Array }
* /
function _eventModifiers ( e ) {
var modifiers = [ ] ;
if ( e . shiftKey ) {
modifiers . push ( 'shift' ) ;
}
if ( e . altKey ) {
modifiers . push ( 'alt' ) ;
}
if ( e . ctrlKey ) {
modifiers . push ( 'ctrl' ) ;
}
if ( e . metaKey ) {
modifiers . push ( 'meta' ) ;
}
return modifiers ;
}
/ * *
* prevents default for this event
*
* @ param { Event } e
* @ returns void
* /
function _preventDefault ( e ) {
if ( e . preventDefault ) {
e . preventDefault ( ) ;
return ;
}
e . returnValue = false ;
}
/ * *
* stops propogation for this event
*
* @ param { Event } e
* @ returns void
* /
function _stopPropagation ( e ) {
if ( e . stopPropagation ) {
e . stopPropagation ( ) ;
return ;
}
e . cancelBubble = true ;
}
/ * *
* determines if the keycode specified is a modifier key or not
*
* @ param { string } key
* @ returns { boolean }
* /
function _isModifier ( key ) {
return key == 'shift' || key == 'ctrl' || key == 'alt' || key == 'meta' ;
}
/ * *
* reverses the map lookup so that we can look for specific keys
* to see what can and can ' t use keypress
*
* @ return { Object }
* /
function _getReverseMap ( ) {
if ( ! _REVERSE _MAP ) {
_REVERSE _MAP = { } ;
for ( var key in _MAP ) {
// pull out the numeric keypad from here cause keypress should
// be able to detect the keys from the character
if ( key > 95 && key < 112 ) {
continue ;
}
if ( _MAP . hasOwnProperty ( key ) ) {
_REVERSE _MAP [ _MAP [ key ] ] = key ;
}
}
}
return _REVERSE _MAP ;
}
/ * *
* picks the best action based on the key combination
*
* @ param { string } key - character for key
* @ param { Array } modifiers
* @ param { string = } action passed in
* /
function _pickBestAction ( key , modifiers , action ) {
// if no action was picked in we should try to pick the one
// that we think would work best for this key
if ( ! action ) {
action = _getReverseMap ( ) [ key ] ? 'keydown' : 'keypress' ;
}
// modifier keys don't work as expected with keypress,
// switch to keydown
if ( action == 'keypress' && modifiers . length ) {
action = 'keydown' ;
}
return action ;
}
/ * *
* Converts from a string key combination to an array
*
* @ param { string } combination like "command+shift+l"
* @ return { Array }
* /
function _keysFromString ( combination ) {
if ( combination === '+' ) {
return [ '+' ] ;
}
combination = combination . replace ( /\+{2}/g , '+plus' ) ;
return combination . split ( '+' ) ;
}
/ * *
* Gets info for a specific key combination
*
* @ param { string } combination key combination ( "command+s" or "a" or "*" )
* @ param { string = } action
* @ returns { Object }
* /
function _getKeyInfo ( combination , action ) {
var keys ;
var key ;
var i ;
var modifiers = [ ] ;
// take the keys from this pattern and figure out what the actual
// pattern is all about
keys = _keysFromString ( combination ) ;
for ( i = 0 ; i < keys . length ; ++ i ) {
key = keys [ i ] ;
// normalize key names
if ( _SPECIAL _ALIASES [ key ] ) {
key = _SPECIAL _ALIASES [ key ] ;
}
// if this is not a keypress event then we should
// be smart about using shift keys
// this will only work for US keyboards however
if ( action && action != 'keypress' && _SHIFT _MAP [ key ] ) {
key = _SHIFT _MAP [ key ] ;
modifiers . push ( 'shift' ) ;
}
// if this key is a modifier then add it to the list of modifiers
if ( _isModifier ( key ) ) {
modifiers . push ( key ) ;
}
}
// depending on what the key combination is
// we will try to pick the best event for it
action = _pickBestAction ( key , modifiers , action ) ;
return {
key : key ,
modifiers : modifiers ,
action : action
} ;
}
function _belongsTo ( element , ancestor ) {
if ( element === null || element === document ) {
return false ;
}
if ( element === ancestor ) {
return true ;
}
return _belongsTo ( element . parentNode , ancestor ) ;
}
function Mousetrap ( targetElement ) {
var self = this ;
targetElement = targetElement || document ;
if ( ! ( self instanceof Mousetrap ) ) {
return new Mousetrap ( targetElement ) ;
}
/ * *
* element to attach key events to
*
* @ type { Element }
* /
self . target = targetElement ;
/ * *
* a list of all the callbacks setup via Mousetrap . bind ( )
*
* @ type { Object }
* /
self . _callbacks = { } ;
/ * *
* direct map of string combinations to callbacks used for trigger ( )
*
* @ type { Object }
* /
self . _directMap = { } ;
/ * *
* keeps track of what level each sequence is at since multiple
* sequences can start out with the same sequence
*
* @ type { Object }
* /
var _sequenceLevels = { } ;
/ * *
* variable to store the setTimeout call
*
* @ type { null | number }
* /
var _resetTimer ;
/ * *
* temporary state where we will ignore the next keyup
*
* @ type { boolean | string }
* /
var _ignoreNextKeyup = false ;
/ * *
* temporary state where we will ignore the next keypress
*
* @ type { boolean }
* /
var _ignoreNextKeypress = false ;
/ * *
* are we currently inside of a sequence ?
* type of action ( "keyup" or "keydown" or "keypress" ) or false
*
* @ type { boolean | string }
* /
var _nextExpectedAction = false ;
/ * *
* resets all sequence counters except for the ones passed in
*
* @ param { Object } doNotReset
* @ returns void
* /
function _resetSequences ( doNotReset ) {
doNotReset = doNotReset || { } ;
var activeSequences = false ,
key ;
for ( key in _sequenceLevels ) {
if ( doNotReset [ key ] ) {
activeSequences = true ;
continue ;
}
_sequenceLevels [ key ] = 0 ;
}
if ( ! activeSequences ) {
_nextExpectedAction = false ;
}
}
/ * *
* finds all callbacks that match based on the keycode , modifiers ,
* and action
*
* @ param { string } character
* @ param { Array } modifiers
* @ param { Event | Object } e
* @ param { string = } sequenceName - name of the sequence we are looking for
* @ param { string = } combination
* @ param { number = } level
* @ returns { Array }
* /
function _getMatches ( character , modifiers , e , sequenceName , combination , level ) {
var i ;
var callback ;
var matches = [ ] ;
var action = e . type ;
// if there are no events related to this keycode
if ( ! self . _callbacks [ character ] ) {
return [ ] ;
}
// if a modifier key is coming up on its own we should allow it
if ( action == 'keyup' && _isModifier ( character ) ) {
modifiers = [ character ] ;
}
// loop through all callbacks for the key that was pressed
// and see if any of them match
for ( i = 0 ; i < self . _callbacks [ character ] . length ; ++ i ) {
callback = self . _callbacks [ character ] [ i ] ;
// if a sequence name is not specified, but this is a sequence at
// the wrong level then move onto the next match
if ( ! sequenceName && callback . seq && _sequenceLevels [ callback . seq ] != callback . level ) {
continue ;
}
// if the action we are looking for doesn't match the action we got
// then we should keep going
if ( action != callback . action ) {
continue ;
}
// if this is a keypress event and the meta key and control key
// are not pressed that means that we need to only look at the
// character, otherwise check the modifiers as well
//
// chrome will not fire a keypress if meta or control is down
// safari will fire a keypress if meta or meta+shift is down
// firefox will fire a keypress if meta or control is down
if ( ( action == 'keypress' && ! e . metaKey && ! e . ctrlKey ) || _modifiersMatch ( modifiers , callback . modifiers ) ) {
// when you bind a combination or sequence a second time it
// should overwrite the first one. if a sequenceName or
// combination is specified in this call it does just that
//
// @todo make deleting its own method?
var deleteCombo = ! sequenceName && callback . combo == combination ;
var deleteSequence = sequenceName && callback . seq == sequenceName && callback . level == level ;
if ( deleteCombo || deleteSequence ) {
self . _callbacks [ character ] . splice ( i , 1 ) ;
}
matches . push ( callback ) ;
}
}
return matches ;
}
/ * *
* actually calls the callback function
*
* if your callback function returns false this will use the jquery
* convention - prevent default and stop propogation on the event
*
* @ param { Function } callback
* @ param { Event } e
* @ returns void
* /
function _fireCallback ( callback , e , combo , sequence ) {
// if this event should not happen stop here
if ( self . stopCallback ( e , e . target || e . srcElement , combo , sequence ) ) {
return ;
}
if ( callback ( e , combo ) === false ) {
_preventDefault ( e ) ;
_stopPropagation ( e ) ;
}
}
/ * *
* handles a character key event
*
* @ param { string } character
* @ param { Array } modifiers
* @ param { Event } e
* @ returns void
* /
self . _handleKey = function ( character , modifiers , e ) {
var callbacks = _getMatches ( character , modifiers , e ) ;
var i ;
var doNotReset = { } ;
var maxLevel = 0 ;
var processedSequenceCallback = false ;
// Calculate the maxLevel for sequences so we can only execute the longest callback sequence
for ( i = 0 ; i < callbacks . length ; ++ i ) {
if ( callbacks [ i ] . seq ) {
maxLevel = Math . max ( maxLevel , callbacks [ i ] . level ) ;
}
}
// loop through matching callbacks for this key event
for ( i = 0 ; i < callbacks . length ; ++ i ) {
// fire for all sequence callbacks
// this is because if for example you have multiple sequences
// bound such as "g i" and "g t" they both need to fire the
// callback for matching g cause otherwise you can only ever
// match the first one
if ( callbacks [ i ] . seq ) {
// only fire callbacks for the maxLevel to prevent
// subsequences from also firing
//
// for example 'a option b' should not cause 'option b' to fire
// even though 'option b' is part of the other sequence
//
// any sequences that do not match here will be discarded
// below by the _resetSequences call
if ( callbacks [ i ] . level != maxLevel ) {
continue ;
}
processedSequenceCallback = true ;
// keep a list of which sequences were matches for later
doNotReset [ callbacks [ i ] . seq ] = 1 ;
_fireCallback ( callbacks [ i ] . callback , e , callbacks [ i ] . combo , callbacks [ i ] . seq ) ;
continue ;
}
// if there were no sequence matches but we are still here
// that means this is a regular match so we should fire that
if ( ! processedSequenceCallback ) {
_fireCallback ( callbacks [ i ] . callback , e , callbacks [ i ] . combo ) ;
}
}
// if the key you pressed matches the type of sequence without
// being a modifier (ie "keyup" or "keypress") then we should
// reset all sequences that were not matched by this event
//
// this is so, for example, if you have the sequence "h a t" and you
// type "h e a r t" it does not match. in this case the "e" will
// cause the sequence to reset
//
// modifier keys are ignored because you can have a sequence
// that contains modifiers such as "enter ctrl+space" and in most
// cases the modifier key will be pressed before the next key
//
// also if you have a sequence such as "ctrl+b a" then pressing the
// "b" key will trigger a "keypress" and a "keydown"
//
// the "keydown" is expected when there is a modifier, but the
// "keypress" ends up matching the _nextExpectedAction since it occurs
// after and that causes the sequence to reset
//
// we ignore keypresses in a sequence that directly follow a keydown
// for the same character
var ignoreThisKeypress = e . type == 'keypress' && _ignoreNextKeypress ;
if ( e . type == _nextExpectedAction && ! _isModifier ( character ) && ! ignoreThisKeypress ) {
_resetSequences ( doNotReset ) ;
}
_ignoreNextKeypress = processedSequenceCallback && e . type == 'keydown' ;
} ;
/ * *
* handles a keydown event
*
* @ param { Event } e
* @ returns void
* /
function _handleKeyEvent ( e ) {
// normalize e.which for key events
// @see http://stackoverflow.com/questions/4285627/javascript-keycode-vs-charcode-utter-confusion
if ( typeof e . which !== 'number' ) {
e . which = e . keyCode ;
}
var character = _characterFromEvent ( e ) ;
// no character found then stop
if ( ! character ) {
return ;
}
// need to use === for the character check because the character can be 0
if ( e . type == 'keyup' && _ignoreNextKeyup === character ) {
_ignoreNextKeyup = false ;
return ;
}
self . handleKey ( character , _eventModifiers ( e ) , e ) ;
}
/ * *
* called to set a 1 second timeout on the specified sequence
*
* this is so after each key press in the sequence you have 1 second
* to press the next key before you have to start over
*
* @ returns void
* /
function _resetSequenceTimer ( ) {
clearTimeout ( _resetTimer ) ;
_resetTimer = setTimeout ( _resetSequences , 1000 ) ;
}
/ * *
* binds a key sequence to an event
*
* @ param { string } combo - combo specified in bind call
* @ param { Array } keys
* @ param { Function } callback
* @ param { string = } action
* @ returns void
* /
function _bindSequence ( combo , keys , callback , action ) {
// start off by adding a sequence level record for this combination
// and setting the level to 0
_sequenceLevels [ combo ] = 0 ;
/ * *
* callback to increase the sequence level for this sequence and reset
* all other sequences that were active
*
* @ param { string } nextAction
* @ returns { Function }
* /
function _increaseSequence ( nextAction ) {
return function ( ) {
_nextExpectedAction = nextAction ;
++ _sequenceLevels [ combo ] ;
_resetSequenceTimer ( ) ;
} ;
}
/ * *
* wraps the specified callback inside of another function in order
* to reset all sequence counters as soon as this sequence is done
*
* @ param { Event } e
* @ returns void
* /
function _callbackAndReset ( e ) {
_fireCallback ( callback , e , combo ) ;
// we should ignore the next key up if the action is key down
// or keypress. this is so if you finish a sequence and
// release the key the final key will not trigger a keyup
if ( action !== 'keyup' ) {
_ignoreNextKeyup = _characterFromEvent ( e ) ;
}
// weird race condition if a sequence ends with the key
// another sequence begins with
setTimeout ( _resetSequences , 10 ) ;
}
// loop through keys one at a time and bind the appropriate callback
// function. for any key leading up to the final one it should
// increase the sequence. after the final, it should reset all sequences
//
// if an action is specified in the original bind call then that will
// be used throughout. otherwise we will pass the action that the
// next key in the sequence should match. this allows a sequence
// to mix and match keypress and keydown events depending on which
// ones are better suited to the key provided
for ( var i = 0 ; i < keys . length ; ++ i ) {
var isFinal = i + 1 === keys . length ;
var wrappedCallback = isFinal ? _callbackAndReset : _increaseSequence ( action || _getKeyInfo ( keys [ i + 1 ] ) . action ) ;
_bindSingle ( keys [ i ] , wrappedCallback , action , combo , i ) ;
}
}
/ * *
* binds a single keyboard combination
*
* @ param { string } combination
* @ param { Function } callback
* @ param { string = } action
* @ param { string = } sequenceName - name of sequence if part of sequence
* @ param { number = } level - what part of the sequence the command is
* @ returns void
* /
function _bindSingle ( combination , callback , action , sequenceName , level ) {
// store a direct mapped reference for use with Mousetrap.trigger
self . _directMap [ combination + ':' + action ] = callback ;
// make sure multiple spaces in a row become a single space
combination = combination . replace ( /\s+/g , ' ' ) ;
var sequence = combination . split ( ' ' ) ;
var info ;
// if this pattern is a sequence of keys then run through this method
// to reprocess each pattern one key at a time
if ( sequence . length > 1 ) {
_bindSequence ( combination , sequence , callback , action ) ;
return ;
}
info = _getKeyInfo ( combination , action ) ;
// make sure to initialize array if this is the first time
// a callback is added for this key
self . _callbacks [ info . key ] = self . _callbacks [ info . key ] || [ ] ;
// remove an existing match if there is one
_getMatches ( info . key , info . modifiers , { type : info . action } , sequenceName , combination , level ) ;
// add this call back to the array
// if it is a sequence put it at the beginning
// if not put it at the end
//
// this is important because the way these are processed expects
// the sequence ones to come first
self . _callbacks [ info . key ] [ sequenceName ? 'unshift' : 'push' ] ( {
callback : callback ,
modifiers : info . modifiers ,
action : info . action ,
seq : sequenceName ,
level : level ,
combo : combination
} ) ;
}
/ * *
* binds multiple combinations to the same callback
*
* @ param { Array } combinations
* @ param { Function } callback
* @ param { string | undefined } action
* @ returns void
* /
self . _bindMultiple = function ( combinations , callback , action ) {
for ( var i = 0 ; i < combinations . length ; ++ i ) {
_bindSingle ( combinations [ i ] , callback , action ) ;
}
} ;
// start!
_addEvent ( targetElement , 'keypress' , _handleKeyEvent ) ;
_addEvent ( targetElement , 'keydown' , _handleKeyEvent ) ;
_addEvent ( targetElement , 'keyup' , _handleKeyEvent ) ;
}
/ * *
* binds an event to mousetrap
*
* can be a single key , a combination of keys separated with + ,
* an array of keys , or a sequence of keys separated by spaces
*
* be sure to list the modifier keys first to make sure that the
* correct key ends up getting bound ( the last key in the pattern )
*
* @ param { string | Array } keys
* @ param { Function } callback
* @ param { string = } action - 'keypress' , 'keydown' , or 'keyup'
* @ returns void
* /
Mousetrap . prototype . bind = function ( keys , callback , action ) {
var self = this ;
keys = keys instanceof Array ? keys : [ keys ] ;
self . _bindMultiple . call ( self , keys , callback , action ) ;
return self ;
} ;
/ * *
* unbinds an event to mousetrap
*
* the unbinding sets the callback function of the specified key combo
* to an empty function and deletes the corresponding key in the
* _directMap dict .
*
* TODO : actually remove this from the _callbacks dictionary instead
* of binding an empty function
*
* the keycombo + action has to be exactly the same as
* it was defined in the bind method
*
* @ param { string | Array } keys
* @ param { string } action
* @ returns void
* /
Mousetrap . prototype . unbind = function ( keys , action ) {
var self = this ;
return self . bind . call ( self , keys , function ( ) { } , action ) ;
} ;
/ * *
* triggers an event that has already been bound
*
* @ param { string } keys
* @ param { string = } action
* @ returns void
* /
Mousetrap . prototype . trigger = function ( keys , action ) {
var self = this ;
if ( self . _directMap [ keys + ':' + action ] ) {
self . _directMap [ keys + ':' + action ] ( { } , keys ) ;
}
return self ;
} ;
/ * *
* resets the library back to its initial state . this is useful
* if you want to clear out the current keyboard shortcuts and bind
* new ones - for example if you switch to another page
*
* @ returns void
* /
Mousetrap . prototype . reset = function ( ) {
var self = this ;
self . _callbacks = { } ;
self . _directMap = { } ;
return self ;
} ;
/ * *
* should we stop this event before firing off callbacks
*
* @ param { Event } e
* @ param { Element } element
* @ return { boolean }
* /
Mousetrap . prototype . stopCallback = function ( e , element ) {
var self = this ;
// if the element has the class "mousetrap" then no need to stop
if ( ( ' ' + element . className + ' ' ) . indexOf ( ' mousetrap ' ) > - 1 ) {
return false ;
}
if ( _belongsTo ( element , self . target ) ) {
return false ;
}
// Events originating from a shadow DOM are re-targetted and `e.target` is the shadow host,
// not the initial event target in the shadow tree. Note that not all events cross the
// shadow boundary.
// For shadow trees with `mode: 'open'`, the initial event target is the first element in
// the event’
// target cannot be obtained.
if ( 'composedPath' in e && typeof e . composedPath === 'function' ) {
// For open shadow trees, update `element` so that the following check works.
var initialEventTarget = e . composedPath ( ) [ 0 ] ;
if ( initialEventTarget !== e . target ) {
element = initialEventTarget ;
2020-02-06 16:03:31 -05:00
}
}
2019-10-15 11:37:08 -04:00
2020-02-06 16:03:31 -05:00
// stop for input, select, and textarea
return element . tagName == 'INPUT' || element . tagName == 'SELECT' || element . tagName == 'TEXTAREA' || element . isContentEditable ;
} ;
2019-10-15 11:37:08 -04:00
2020-02-06 16:03:31 -05:00
/ * *
* exposes _handleKey publicly so it can be overwritten by extensions
* /
Mousetrap . prototype . handleKey = function ( ) {
var self = this ;
return self . _handleKey . apply ( self , arguments ) ;
} ;
/ * *
* allow custom key mappings
* /
Mousetrap . addKeycodes = function ( object ) {
for ( var key in object ) {
if ( object . hasOwnProperty ( key ) ) {
_MAP [ key ] = object [ key ] ;
2019-10-15 11:37:08 -04:00
}
}
2020-02-06 16:03:31 -05:00
_REVERSE _MAP = null ;
} ;
2019-10-15 11:37:08 -04:00
2020-02-06 16:03:31 -05:00
/ * *
* Init the global mousetrap functions
*
* This method is needed to allow the global mousetrap functions to work
* now that mousetrap is a constructor function .
* /
Mousetrap . init = function ( ) {
var documentMousetrap = Mousetrap ( document ) ;
for ( var method in documentMousetrap ) {
if ( method . charAt ( 0 ) !== '_' ) {
Mousetrap [ method ] = ( function ( method ) {
return function ( ) {
return documentMousetrap [ method ] . apply ( documentMousetrap , arguments ) ;
} ;
} ( method ) ) ;
}
2019-10-15 11:37:08 -04:00
}
2020-02-06 16:03:31 -05:00
} ;
Mousetrap . init ( ) ;
// expose mousetrap to the global object
window . Mousetrap = Mousetrap ;
// expose as a common js module
if ( true && module . exports ) {
module . exports = Mousetrap ;
2019-10-15 11:37:08 -04:00
}
2020-02-06 16:03:31 -05:00
// expose mousetrap as an AMD module
if ( true ) {
! ( _ _WEBPACK _AMD _DEFINE _RESULT _ _ = ( function ( ) {
return Mousetrap ;
} ) . call ( exports , _ _webpack _require _ _ , exports , module ) ,
_ _WEBPACK _AMD _DEFINE _RESULT _ _ !== undefined && ( module . exports = _ _WEBPACK _AMD _DEFINE _RESULT _ _ ) ) ;
}
} ) ( typeof window !== 'undefined' ? window : null , typeof window !== 'undefined' ? document : null ) ;
2019-10-15 11:37:08 -04:00
2020-02-06 16:03:31 -05:00
/***/ } ) ,
2019-10-15 11:37:08 -04:00
2020-10-13 09:10:30 -04:00
/***/ 30 :
2020-06-26 09:33:47 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _unsupportedIterableToArray ; } ) ;
2020-10-13 09:10:30 -04:00
/* harmony import */ var _arrayLikeToArray _ _WEBPACK _IMPORTED _MODULE _0 _ _ = _ _webpack _require _ _ ( 27 ) ;
2020-06-26 09:33:47 -04:00
function _unsupportedIterableToArray ( o , minLen ) {
if ( ! o ) return ;
if ( typeof o === "string" ) return Object ( _arrayLikeToArray _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ /* default */ "a" ] ) ( o , minLen ) ;
var n = Object . prototype . toString . call ( o ) . slice ( 8 , - 1 ) ;
if ( n === "Object" && o . constructor ) n = o . constructor . name ;
if ( n === "Map" || n === "Set" ) return Array . from ( o ) ;
if ( n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/ . test ( n ) ) return Object ( _arrayLikeToArray _ _WEBPACK _IMPORTED _MODULE _0 _ _ [ /* default */ "a" ] ) ( o , minLen ) ;
}
/***/ } ) ,
2020-10-13 09:10:30 -04:00
/***/ 37 :
2020-02-06 16:03:31 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
2019-10-15 11:37:08 -04:00
2020-02-06 16:03:31 -05:00
"use strict" ;
2020-06-26 09:33:47 -04:00
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _iterableToArray ; } ) ;
function _iterableToArray ( iter ) {
if ( typeof Symbol !== "undefined" && Symbol . iterator in Object ( iter ) ) return Array . from ( iter ) ;
2020-02-06 16:03:31 -05:00
}
2019-10-15 11:37:08 -04:00
2019-03-21 08:48:00 -04:00
/***/ } ) ,
2020-03-23 19:40:19 -04:00
/***/ 38 :
2020-01-22 17:06:21 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _arrayWithHoles ; } ) ;
function _arrayWithHoles ( arr ) {
if ( Array . isArray ( arr ) ) return arr ;
}
/***/ } ) ,
2020-03-23 19:40:19 -04:00
/***/ 39 :
2020-01-08 06:57:23 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _nonIterableRest ; } ) ;
function _nonIterableRest ( ) {
2020-03-23 19:40:19 -04:00
throw new TypeError ( "Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method." ) ;
2020-01-08 06:57:23 -05:00
}
/***/ } ) ,
2020-06-26 09:33:47 -04:00
/***/ 40 :
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _typeof ; } ) ;
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 ) ;
}
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 429 :
2020-02-06 16:03:31 -05:00
/***/ ( function ( module , exports ) {
/ * *
* adds a bindGlobal method to Mousetrap that allows you to
* bind specific keyboard shortcuts that will still work
* inside a text input field
*
* usage :
* Mousetrap . bindGlobal ( 'ctrl+s' , _saveChanges ) ;
* /
/* global Mousetrap:true */
( function ( Mousetrap ) {
if ( ! Mousetrap ) {
return ;
}
var _globalCallbacks = { } ;
var _originalStopCallback = Mousetrap . prototype . stopCallback ;
Mousetrap . prototype . stopCallback = function ( e , element , combo , sequence ) {
var self = this ;
if ( self . paused ) {
return true ;
}
if ( _globalCallbacks [ combo ] || _globalCallbacks [ sequence ] ) {
return false ;
}
return _originalStopCallback . call ( self , e , element , combo ) ;
} ;
Mousetrap . prototype . bindGlobal = function ( keys , callback , action ) {
var self = this ;
self . bind ( keys , callback , action ) ;
if ( keys instanceof Array ) {
for ( var i = 0 ; i < keys . length ; i ++ ) {
_globalCallbacks [ keys [ i ] ] = true ;
}
return ;
}
_globalCallbacks [ keys ] = true ;
} ;
Mousetrap . init ( ) ;
} ) ( typeof Mousetrap !== "undefined" ? Mousetrap : undefined ) ;
/***/ } ) ,
2020-10-20 09:36:16 -04:00
/***/ 463 :
2018-12-13 23:41:57 -05:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2020-06-29 07:50:29 -04:00
// ESM COMPAT FLAG
2018-12-13 23:41:57 -05:00
_ _webpack _require _ _ . r ( _ _webpack _exports _ _ ) ;
2018-12-17 22:14:52 -05:00
2020-06-29 07:50:29 -04:00
// EXPORTS
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "createHigherOrderComponent" , function ( ) { return /* reexport */ create _higher _order _component ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "compose" , function ( ) { return /* reexport */ compose ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "ifCondition" , function ( ) { return /* reexport */ if _condition ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "pure" , function ( ) { return /* reexport */ higher _order _pure ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "withGlobalEvents" , function ( ) { return /* reexport */ with _global _events ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "withInstanceId" , function ( ) { return /* reexport */ with _instance _id ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "withSafeTimeout" , function ( ) { return /* reexport */ with _safe _timeout ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "withState" , function ( ) { return /* reexport */ withState ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useCopyOnClick" , function ( ) { return /* reexport */ useCopyOnClick ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "__experimentalUseDragging" , function ( ) { return /* reexport */ useDragging ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useInstanceId" , function ( ) { return /* reexport */ useInstanceId ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useKeyboardShortcut" , function ( ) { return /* reexport */ use _keyboard _shortcut ; } ) ;
2020-07-07 12:08:28 -04:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useMediaQuery" , function ( ) { return /* reexport */ useMediaQuery ; } ) ;
2020-06-29 07:50:29 -04:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "usePrevious" , function ( ) { return /* reexport */ usePrevious ; } ) ;
2020-07-07 12:08:28 -04:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useReducedMotion" , function ( ) { return /* reexport */ use _reduced _motion ; } ) ;
2020-06-29 07:50:29 -04:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useViewportMatch" , function ( ) { return /* reexport */ use _viewport _match ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useResizeObserver" , function ( ) { return /* reexport */ use _resize _observer ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useAsyncList" , function ( ) { return /* reexport */ use _async _list ; } ) ;
2020-07-14 07:39:09 -04:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useWarnOnChange" , function ( ) { return /* reexport */ use _warn _on _change ; } ) ;
2020-10-20 09:36:16 -04:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "useDebounce" , function ( ) { return /* reexport */ useDebounce ; } ) ;
2020-06-29 07:50:29 -04:00
2020-01-03 08:17:24 -05:00
// EXTERNAL MODULE: external {"this":"lodash"}
var external _this _lodash _ = _ _webpack _require _ _ ( 2 ) ;
2018-12-17 22:14:52 -05:00
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js
2018-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* Given a function mapping a component to an enhanced component and modifier
* name , returns the enhanced component augmented with a generated displayName .
*
* @ param { Function } mapComponentToEnhancedComponent Function mapping component
* to enhanced component .
* @ param { string } modifierName Seed name from which to
* generated display name .
*
* @ return { WPComponent } Component class with generated display name assigned .
* /
function createHigherOrderComponent ( mapComponentToEnhancedComponent , modifierName ) {
return function ( OriginalComponent ) {
var EnhancedComponent = mapComponentToEnhancedComponent ( OriginalComponent ) ;
var _OriginalComponent$di = OriginalComponent . displayName ,
displayName = _OriginalComponent$di === void 0 ? OriginalComponent . name || 'Component' : _OriginalComponent$di ;
2020-01-03 08:17:24 -05:00
EnhancedComponent . displayName = "" . concat ( Object ( external _this _lodash _ [ "upperFirst" ] ) ( Object ( external _this _lodash _ [ "camelCase" ] ) ( modifierName ) ) , "(" ) . concat ( displayName , ")" ) ;
2018-12-13 23:41:57 -05:00
return EnhancedComponent ;
} ;
}
2018-12-17 22:14:52 -05:00
/* harmony default export */ var create _higher _order _component = ( createHigherOrderComponent ) ;
2018-12-13 23:41:57 -05:00
2020-01-08 06:57:23 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js
/ * *
* External dependencies
* /
/ * *
* Composes multiple higher - order components into a single higher - order component . Performs right - to - left function
* composition , where each successive invocation is supplied the return value of the previous .
*
* @ param { ... Function } hocs The HOC functions to invoke .
*
* @ return { Function } Returns the new composite function .
* /
/* harmony default export */ var compose = ( external _this _lodash _ [ "flowRight" ] ) ;
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: external {"this":["wp","element"]}
var external _this _wp _element _ = _ _webpack _require _ _ ( 0 ) ;
2018-12-13 23:41:57 -05:00
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js
2018-12-13 23:41:57 -05:00
/ * *
* Internal dependencies
* /
/ * *
* Higher - order component creator , creating a new component which renders if
* the given condition is satisfied or with the given optional prop name .
*
* @ param { Function } predicate Function to test condition .
*
* @ return { Function } Higher - order component .
* /
2018-12-17 22:14:52 -05:00
var if _condition _ifCondition = function ifCondition ( predicate ) {
return create _higher _order _component ( function ( WrappedComponent ) {
2018-12-13 23:41:57 -05:00
return function ( props ) {
if ( ! predicate ( props ) ) {
return null ;
}
2018-12-17 22:14:52 -05:00
return Object ( external _this _wp _element _ [ "createElement" ] ) ( WrappedComponent , props ) ;
2018-12-13 23:41:57 -05:00
} ;
} , 'ifCondition' ) ;
} ;
2018-12-17 22:14:52 -05:00
/* harmony default export */ var if _condition = ( if _condition _ifCondition ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
2020-10-13 09:10:30 -04:00
var classCallCheck = _ _webpack _require _ _ ( 21 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
2020-10-20 09:36:16 -04:00
var createClass = _ _webpack _require _ _ ( 22 ) ;
2020-10-13 09:10:30 -04:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules
2020-10-20 09:36:16 -04:00
var inherits = _ _webpack _require _ _ ( 23 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
2020-10-20 09:36:16 -04:00
var possibleConstructorReturn = _ _webpack _require _ _ ( 24 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
2020-10-20 09:36:16 -04:00
var getPrototypeOf = _ _webpack _require _ _ ( 19 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]}
2020-07-21 08:14:37 -04:00
var external _this _wp _isShallowEqual _ = _ _webpack _require _ _ ( 64 ) ;
2018-12-17 22:14:52 -05:00
var external _this _wp _isShallowEqual _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( external _this _wp _isShallowEqual _ ) ;
2018-12-13 23:41:57 -05:00
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js
2018-12-13 23:41:57 -05:00
2020-10-13 09:10:30 -04:00
function _createSuper ( Derived ) { var hasNativeReflectConstruct = _isNativeReflectConstruct ( ) ; return function _createSuperInternal ( ) { var Super = Object ( getPrototypeOf [ "a" /* default */ ] ) ( Derived ) , result ; if ( hasNativeReflectConstruct ) { var NewTarget = Object ( getPrototypeOf [ "a" /* default */ ] ) ( this ) . constructor ; result = Reflect . construct ( Super , arguments , NewTarget ) ; } else { result = Super . apply ( this , arguments ) ; } return Object ( possibleConstructorReturn [ "a" /* default */ ] ) ( this , result ) ; } ; }
2020-06-26 09:33:47 -04: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-12-13 23:41:57 -05:00
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* Given a component returns the enhanced component augmented with a component
* only rerendering when its props / state change
*
* @ param { Function } mapComponentToEnhancedComponent Function mapping component
* to enhanced component .
* @ param { string } modifierName Seed name from which to
* generated display name .
*
* @ return { WPComponent } Component class with generated display name assigned .
* /
2018-12-17 22:14:52 -05:00
var pure = create _higher _order _component ( function ( Wrapped ) {
if ( Wrapped . prototype instanceof external _this _wp _element _ [ "Component" ] ) {
2020-06-26 09:33:47 -04:00
return /*#__PURE__*/ function ( _Wrapped ) {
Object ( inherits [ "a" /* default */ ] ) ( _class , _Wrapped ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var _super = _createSuper ( _class ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
function _class ( ) {
Object ( classCallCheck [ "a" /* default */ ] ) ( this , _class ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return _super . apply ( this , arguments ) ;
}
Object ( createClass [ "a" /* default */ ] ) ( _class , [ {
key : "shouldComponentUpdate" ,
value : function shouldComponentUpdate ( nextProps , nextState ) {
return ! external _this _wp _isShallowEqual _default ( ) ( nextProps , this . props ) || ! external _this _wp _isShallowEqual _default ( ) ( nextState , this . state ) ;
}
} ] ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return _class ;
} ( Wrapped ) ;
2018-12-13 23:41:57 -05:00
}
2020-06-26 09:33:47 -04:00
return /*#__PURE__*/ function ( _Component ) {
Object ( inherits [ "a" /* default */ ] ) ( _class2 , _Component ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var _super2 = _createSuper ( _class2 ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
function _class2 ( ) {
Object ( classCallCheck [ "a" /* default */ ] ) ( this , _class2 ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return _super2 . apply ( this , arguments ) ;
}
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
Object ( createClass [ "a" /* default */ ] ) ( _class2 , [ {
key : "shouldComponentUpdate" ,
value : function shouldComponentUpdate ( nextProps ) {
return ! external _this _wp _isShallowEqual _default ( ) ( nextProps , this . props ) ;
}
} , {
key : "render" ,
value : function render ( ) {
return Object ( external _this _wp _element _ [ "createElement" ] ) ( Wrapped , this . props ) ;
}
} ] ) ;
return _class2 ;
} ( external _this _wp _element _ [ "Component" ] ) ;
2018-12-13 23:41:57 -05:00
} , 'pure' ) ;
2019-09-19 11:19:18 -04:00
/* harmony default export */ var higher _order _pure = ( pure ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
2020-06-26 09:33:47 -04:00
var esm _extends = _ _webpack _require _ _ ( 8 ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
2020-10-20 09:36:16 -04:00
var assertThisInitialized = _ _webpack _require _ _ ( 16 ) ;
2018-12-13 23:41:57 -05:00
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
/ * *
* External dependencies
* /
/ * *
* Class responsible for orchestrating event handling on the global window ,
* binding a single event to be shared across all handling instances , and
* removing the handler when no instances are listening for the event .
* /
2020-06-26 09:33:47 -04:00
var listener _Listener = /*#__PURE__*/ function ( ) {
2018-12-17 22:14:52 -05:00
function Listener ( ) {
Object ( classCallCheck [ "a" /* default */ ] ) ( this , Listener ) ;
this . listeners = { } ;
this . handleEvent = this . handleEvent . bind ( this ) ;
}
Object ( createClass [ "a" /* default */ ] ) ( Listener , [ {
key : "add" ,
value : function add ( eventType , instance ) {
if ( ! this . listeners [ eventType ] ) {
// Adding first listener for this type, so bind event.
window . addEventListener ( eventType , this . handleEvent ) ;
this . listeners [ eventType ] = [ ] ;
}
this . listeners [ eventType ] . push ( instance ) ;
}
} , {
key : "remove" ,
value : function remove ( eventType , instance ) {
2020-01-03 08:17:24 -05:00
this . listeners [ eventType ] = Object ( external _this _lodash _ [ "without" ] ) ( this . listeners [ eventType ] , instance ) ;
2018-12-17 22:14:52 -05:00
if ( ! this . listeners [ eventType ] . length ) {
// Removing last listener for this type, so unbind event.
window . removeEventListener ( eventType , this . handleEvent ) ;
delete this . listeners [ eventType ] ;
}
}
} , {
key : "handleEvent" ,
value : function handleEvent ( event ) {
2020-01-03 08:17:24 -05:00
Object ( external _this _lodash _ [ "forEach" ] ) ( this . listeners [ event . type ] , function ( instance ) {
2018-12-17 22:14:52 -05:00
instance . handleEvent ( event ) ;
} ) ;
}
} ] ) ;
return Listener ;
} ( ) ;
/* harmony default export */ var listener = ( listener _Listener ) ;
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js
2018-12-13 23:41:57 -05:00
2020-10-13 09:10:30 -04:00
function with _global _events _createSuper ( Derived ) { var hasNativeReflectConstruct = with _global _events _isNativeReflectConstruct ( ) ; return function _createSuperInternal ( ) { var Super = Object ( getPrototypeOf [ "a" /* default */ ] ) ( Derived ) , result ; if ( hasNativeReflectConstruct ) { var NewTarget = Object ( getPrototypeOf [ "a" /* default */ ] ) ( this ) . constructor ; result = Reflect . construct ( Super , arguments , NewTarget ) ; } else { result = Super . apply ( this , arguments ) ; } return Object ( possibleConstructorReturn [ "a" /* default */ ] ) ( this , result ) ; } ; }
2020-06-26 09:33:47 -04:00
function with _global _events _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-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* Listener instance responsible for managing document event handling .
*
* @ type { Listener }
* /
2018-12-17 22:14:52 -05:00
var with _global _events _listener = new listener ( ) ;
2019-09-19 11:19:18 -04:00
/ * *
* Higher - order component creator which , given an object of DOM event types and
* values corresponding to a callback function name on the component , will
* create or update a window event handler to invoke the callback when an event
* occurs . On behalf of the consuming developer , the higher - order component
* manages unbinding when the component unmounts , and binding at most a single
* event handler for the entire application .
*
* @ param { Object < string , string > } eventTypesToHandlers Object with keys of DOM
* event type , the value a
* name of the function on
* the original component ' s
* instance which handles
* the event .
*
* @ return { Function } Higher - order component .
* /
2018-12-13 23:41:57 -05:00
function withGlobalEvents ( eventTypesToHandlers ) {
2018-12-17 22:14:52 -05:00
return create _higher _order _component ( function ( WrappedComponent ) {
2020-06-26 09:33:47 -04:00
var Wrapper = /*#__PURE__*/ function ( _Component ) {
2018-12-17 22:14:52 -05:00
Object ( inherits [ "a" /* default */ ] ) ( Wrapper , _Component ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var _super = with _global _events _createSuper ( Wrapper ) ;
2018-12-13 23:41:57 -05:00
function Wrapper ( ) {
var _this ;
2018-12-17 22:14:52 -05:00
Object ( classCallCheck [ "a" /* default */ ] ) ( this , Wrapper ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
_this = _super . apply ( this , arguments ) ;
2019-09-19 11:19:18 -04:00
_this . handleEvent = _this . handleEvent . bind ( Object ( assertThisInitialized [ "a" /* default */ ] ) ( _this ) ) ;
_this . handleRef = _this . handleRef . bind ( Object ( assertThisInitialized [ "a" /* default */ ] ) ( _this ) ) ;
2018-12-13 23:41:57 -05:00
return _this ;
}
2018-12-17 22:14:52 -05:00
Object ( createClass [ "a" /* default */ ] ) ( Wrapper , [ {
2018-12-13 23:41:57 -05:00
key : "componentDidMount" ,
value : function componentDidMount ( ) {
var _this2 = this ;
2020-01-03 08:17:24 -05:00
Object ( external _this _lodash _ [ "forEach" ] ) ( eventTypesToHandlers , function ( handler , eventType ) {
2018-12-17 22:14:52 -05:00
with _global _events _listener . add ( eventType , _this2 ) ;
2018-12-13 23:41:57 -05:00
} ) ;
}
} , {
key : "componentWillUnmount" ,
value : function componentWillUnmount ( ) {
var _this3 = this ;
2020-01-03 08:17:24 -05:00
Object ( external _this _lodash _ [ "forEach" ] ) ( eventTypesToHandlers , function ( handler , eventType ) {
2018-12-17 22:14:52 -05:00
with _global _events _listener . remove ( eventType , _this3 ) ;
2018-12-13 23:41:57 -05:00
} ) ;
}
} , {
key : "handleEvent" ,
value : function handleEvent ( event ) {
var handler = eventTypesToHandlers [ event . type ] ;
if ( typeof this . wrappedRef [ handler ] === 'function' ) {
this . wrappedRef [ handler ] ( event ) ;
}
}
} , {
key : "handleRef" ,
value : function handleRef ( el ) {
this . wrappedRef = el ; // Any component using `withGlobalEvents` that is not setting a `ref`
// will cause `this.props.forwardedRef` to be `null`, so we need this
// check.
if ( this . props . forwardedRef ) {
this . props . forwardedRef ( el ) ;
}
}
} , {
key : "render" ,
value : function render ( ) {
2018-12-17 22:14:52 -05:00
return Object ( external _this _wp _element _ [ "createElement" ] ) ( WrappedComponent , Object ( esm _extends [ "a" /* default */ ] ) ( { } , this . props . ownProps , {
2018-12-13 23:41:57 -05:00
ref : this . handleRef
} ) ) ;
}
} ] ) ;
return Wrapper ;
2018-12-17 22:14:52 -05:00
} ( external _this _wp _element _ [ "Component" ] ) ;
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
return Object ( external _this _wp _element _ [ "forwardRef" ] ) ( function ( props , ref ) {
return Object ( external _this _wp _element _ [ "createElement" ] ) ( Wrapper , {
2018-12-13 23:41:57 -05:00
ownProps : props ,
forwardedRef : ref
} ) ;
} ) ;
} , 'withGlobalEvents' ) ;
}
2018-12-17 22:14:52 -05:00
/* harmony default export */ var with _global _events = ( withGlobalEvents ) ;
2018-12-13 23:41:57 -05:00
2020-01-22 17:06:21 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js
/ * *
* WordPress dependencies
* /
2018-12-13 23:41:57 -05:00
2020-01-22 17:06:21 -05:00
var instanceMap = new WeakMap ( ) ;
/ * *
* Creates a new id for a given object .
*
* @ param { Object } object Object reference to create an id for .
* /
2018-12-13 23:41:57 -05:00
2020-01-22 17:06:21 -05:00
function createId ( object ) {
var instances = instanceMap . get ( object ) || 0 ;
instanceMap . set ( object , instances + 1 ) ;
return instances ;
}
/ * *
* Provides a unique instance ID .
*
* @ param { Object } object Object reference to create an id for .
2020-06-26 09:33:47 -04:00
* @ param { string } prefix Prefix for the unique id .
2020-01-22 17:06:21 -05:00
* /
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
function useInstanceId ( object , prefix ) {
2020-01-22 17:06:21 -05:00
return Object ( external _this _wp _element _ [ "useMemo" ] ) ( function ( ) {
2020-06-26 09:33:47 -04:00
var id = createId ( object ) ;
return prefix ? "" . concat ( prefix , "-" ) . concat ( id ) : id ;
2020-01-22 17:06:21 -05:00
} , [ object ] ) ;
}
2018-12-13 23:41:57 -05:00
2020-01-22 17:06:21 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js
2018-12-13 23:41:57 -05:00
/ * *
* Internal dependencies
* /
/ * *
* A Higher Order Component used to be provide a unique instance ID by
* component .
*
2020-01-08 06:57:23 -05:00
* @ param { WPComponent } WrappedComponent The wrapped component .
2018-12-13 23:41:57 -05:00
*
2020-01-08 06:57:23 -05:00
* @ return { WPComponent } Component with an instanceId prop .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
/* harmony default export */ var with _instance _id = ( create _higher _order _component ( function ( WrappedComponent ) {
2020-01-22 17:06:21 -05:00
return function ( props ) {
var instanceId = useInstanceId ( WrappedComponent ) ;
return Object ( external _this _wp _element _ [ "createElement" ] ) ( WrappedComponent , Object ( esm _extends [ "a" /* default */ ] ) ( { } , props , {
instanceId : instanceId
} ) ) ;
} ;
2018-12-13 23:41:57 -05:00
} , 'withInstanceId' ) ) ;
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-safe-timeout/index.js
2018-12-13 23:41:57 -05:00
2020-10-13 09:10:30 -04:00
function with _safe _timeout _createSuper ( Derived ) { var hasNativeReflectConstruct = with _safe _timeout _isNativeReflectConstruct ( ) ; return function _createSuperInternal ( ) { var Super = Object ( getPrototypeOf [ "a" /* default */ ] ) ( Derived ) , result ; if ( hasNativeReflectConstruct ) { var NewTarget = Object ( getPrototypeOf [ "a" /* default */ ] ) ( this ) . constructor ; result = Reflect . construct ( Super , arguments , NewTarget ) ; } else { result = Super . apply ( this , arguments ) ; } return Object ( possibleConstructorReturn [ "a" /* default */ ] ) ( this , result ) ; } ; }
2020-06-26 09:33:47 -04:00
function with _safe _timeout _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-12-13 23:41:57 -05:00
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* A higher - order component used to provide and manage delayed function calls
* that ought to be bound to a component ' s lifecycle .
*
2020-01-08 06:57:23 -05:00
* @ param { WPComponent } OriginalComponent Component requiring setTimeout
2018-12-13 23:41:57 -05:00
*
2020-01-08 06:57:23 -05:00
* @ return { WPComponent } Wrapped component .
2018-12-13 23:41:57 -05:00
* /
2018-12-17 22:14:52 -05:00
var withSafeTimeout = create _higher _order _component ( function ( OriginalComponent ) {
2020-06-26 09:33:47 -04:00
return /*#__PURE__*/ function ( _Component ) {
Object ( inherits [ "a" /* default */ ] ) ( WrappedComponent , _Component ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var _super = with _safe _timeout _createSuper ( WrappedComponent ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
function WrappedComponent ( ) {
var _this ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
Object ( classCallCheck [ "a" /* default */ ] ) ( this , WrappedComponent ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
_this = _super . apply ( this , arguments ) ;
_this . timeouts = [ ] ;
_this . setTimeout = _this . setTimeout . bind ( Object ( assertThisInitialized [ "a" /* default */ ] ) ( _this ) ) ;
_this . clearTimeout = _this . clearTimeout . bind ( Object ( assertThisInitialized [ "a" /* default */ ] ) ( _this ) ) ;
return _this ;
}
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
Object ( createClass [ "a" /* default */ ] ) ( WrappedComponent , [ {
key : "componentWillUnmount" ,
value : function componentWillUnmount ( ) {
this . timeouts . forEach ( clearTimeout ) ;
}
} , {
key : "setTimeout" ,
value : function ( _setTimeout ) {
function setTimeout ( _x , _x2 ) {
return _setTimeout . apply ( this , arguments ) ;
}
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
setTimeout . toString = function ( ) {
return _setTimeout . toString ( ) ;
} ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return setTimeout ;
} ( function ( fn , delay ) {
var _this2 = this ;
var id = setTimeout ( function ( ) {
fn ( ) ;
_this2 . clearTimeout ( id ) ;
} , delay ) ;
this . timeouts . push ( id ) ;
return id ;
} )
} , {
key : "clearTimeout" ,
value : function ( _clearTimeout ) {
function clearTimeout ( _x3 ) {
return _clearTimeout . apply ( this , arguments ) ;
}
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
clearTimeout . toString = function ( ) {
return _clearTimeout . toString ( ) ;
} ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return clearTimeout ;
} ( function ( id ) {
clearTimeout ( id ) ;
this . timeouts = Object ( external _this _lodash _ [ "without" ] ) ( this . timeouts , id ) ;
} )
} , {
key : "render" ,
value : function render ( ) {
return Object ( external _this _wp _element _ [ "createElement" ] ) ( OriginalComponent , Object ( esm _extends [ "a" /* default */ ] ) ( { } , this . props , {
setTimeout : this . setTimeout ,
clearTimeout : this . clearTimeout
} ) ) ;
}
} ] ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return WrappedComponent ;
} ( external _this _wp _element _ [ "Component" ] ) ;
2018-12-13 23:41:57 -05:00
} , 'withSafeTimeout' ) ;
2018-12-17 22:14:52 -05:00
/* harmony default export */ var with _safe _timeout = ( withSafeTimeout ) ;
2018-12-13 23:41:57 -05:00
2019-09-19 11:19:18 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-state/index.js
2018-12-13 23:41:57 -05:00
2020-10-13 09:10:30 -04:00
function with _state _createSuper ( Derived ) { var hasNativeReflectConstruct = with _state _isNativeReflectConstruct ( ) ; return function _createSuperInternal ( ) { var Super = Object ( getPrototypeOf [ "a" /* default */ ] ) ( Derived ) , result ; if ( hasNativeReflectConstruct ) { var NewTarget = Object ( getPrototypeOf [ "a" /* default */ ] ) ( this ) . constructor ; result = Reflect . construct ( Super , arguments , NewTarget ) ; } else { result = Super . apply ( this , arguments ) ; } return Object ( possibleConstructorReturn [ "a" /* default */ ] ) ( this , result ) ; } ; }
2020-06-26 09:33:47 -04:00
function with _state _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-12-13 23:41:57 -05:00
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
/ * *
* A Higher Order Component used to provide and manage internal component state
* via props .
*
* @ param { ? Object } initialState Optional initial state of the component .
*
2020-01-08 06:57:23 -05:00
* @ return { WPComponent } Wrapped component .
2018-12-13 23:41:57 -05:00
* /
function withState ( ) {
var initialState = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : { } ;
2018-12-17 22:14:52 -05:00
return create _higher _order _component ( function ( OriginalComponent ) {
2020-06-26 09:33:47 -04:00
return /*#__PURE__*/ function ( _Component ) {
Object ( inherits [ "a" /* default */ ] ) ( WrappedComponent , _Component ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
var _super = with _state _createSuper ( WrappedComponent ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
function WrappedComponent ( ) {
var _this ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
Object ( classCallCheck [ "a" /* default */ ] ) ( this , WrappedComponent ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
_this = _super . apply ( this , arguments ) ;
_this . setState = _this . setState . bind ( Object ( assertThisInitialized [ "a" /* default */ ] ) ( _this ) ) ;
_this . state = initialState ;
return _this ;
}
Object ( createClass [ "a" /* default */ ] ) ( WrappedComponent , [ {
key : "render" ,
value : function render ( ) {
return Object ( external _this _wp _element _ [ "createElement" ] ) ( OriginalComponent , Object ( esm _extends [ "a" /* default */ ] ) ( { } , this . props , this . state , {
setState : this . setState
} ) ) ;
}
} ] ) ;
2018-12-13 23:41:57 -05:00
2020-06-26 09:33:47 -04:00
return WrappedComponent ;
} ( external _this _wp _element _ [ "Component" ] ) ;
2018-12-13 23:41:57 -05:00
} , 'withState' ) ;
}
2020-02-06 16:03:31 -05:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
2020-10-13 09:10:30 -04:00
var slicedToArray = _ _webpack _require _ _ ( 12 ) ;
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/clipboard/dist/clipboard.js
2020-10-20 09:36:16 -04:00
var dist _clipboard = _ _webpack _require _ _ ( 287 ) ;
2020-06-26 09:33:47 -04:00
var clipboard _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( dist _clipboard ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-copy-on-click/index.js
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* Copies the text to the clipboard when the element is clicked .
*
* @ param { Object } ref Reference with the element .
* @ param { string | Function } text The text to copy .
* @ param { number } timeout Optional timeout to reset the returned
* state . 4 seconds by default .
*
* @ return { boolean } Whether or not the text has been copied . Resets after the
* timeout .
* /
function useCopyOnClick ( ref , _text ) {
var timeout = arguments . length > 2 && arguments [ 2 ] !== undefined ? arguments [ 2 ] : 4000 ;
var clipboard = Object ( external _this _wp _element _ [ "useRef" ] ) ( ) ;
var _useState = Object ( external _this _wp _element _ [ "useState" ] ) ( false ) ,
_useState2 = Object ( slicedToArray [ "a" /* default */ ] ) ( _useState , 2 ) ,
hasCopied = _useState2 [ 0 ] ,
setHasCopied = _useState2 [ 1 ] ;
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
var timeoutId ; // Clipboard listens to click events.
clipboard . current = new clipboard _default . a ( ref . current , {
text : function text ( ) {
return typeof _text === 'function' ? _text ( ) : _text ;
2020-07-27 16:10:36 -04:00
}
2020-06-26 09:33:47 -04:00
} ) ;
clipboard . current . on ( 'success' , function ( _ref ) {
2020-07-21 08:14:37 -04:00
var clearSelection = _ref . clearSelection ,
trigger = _ref . trigger ;
2020-06-26 09:33:47 -04:00
// Clearing selection will move focus back to the triggering button,
// ensuring that it is not reset to the body, and further that it is
// kept within the rendered node.
2020-07-21 08:14:37 -04:00
clearSelection ( ) ; // Handle ClipboardJS focus bug, see https://github.com/zenorocha/clipboard.js/issues/680
if ( trigger ) {
trigger . focus ( ) ;
}
2020-06-26 09:33:47 -04:00
if ( timeout ) {
setHasCopied ( true ) ;
clearTimeout ( timeoutId ) ;
timeoutId = setTimeout ( function ( ) {
return setHasCopied ( false ) ;
} , timeout ) ;
}
} ) ;
return function ( ) {
clipboard . current . destroy ( ) ;
clearTimeout ( timeoutId ) ;
} ;
} , [ _text , timeout , setHasCopied ] ) ;
return hasCopied ;
}
2020-02-06 16:03:31 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-dragging/index.js
/ * *
* WordPress dependencies
* /
var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? external _this _wp _element _ [ "useLayoutEffect" ] : external _this _wp _element _ [ "useEffect" ] ;
function useDragging ( _ref ) {
var onDragStart = _ref . onDragStart ,
onDragMove = _ref . onDragMove ,
onDragEnd = _ref . onDragEnd ;
var _useState = Object ( external _this _wp _element _ [ "useState" ] ) ( false ) ,
_useState2 = Object ( slicedToArray [ "a" /* default */ ] ) ( _useState , 2 ) ,
isDragging = _useState2 [ 0 ] ,
setIsDragging = _useState2 [ 1 ] ;
var eventsRef = Object ( external _this _wp _element _ [ "useRef" ] ) ( {
onDragStart : onDragStart ,
onDragMove : onDragMove ,
onDragEnd : onDragEnd
} ) ;
useIsomorphicLayoutEffect ( function ( ) {
eventsRef . current . onDragStart = onDragStart ;
eventsRef . current . onDragMove = onDragMove ;
eventsRef . current . onDragEnd = onDragEnd ;
} , [ onDragStart , onDragMove , onDragEnd ] ) ;
var onMouseMove = Object ( external _this _wp _element _ [ "useCallback" ] ) ( function ( ) {
var _eventsRef$current ;
return eventsRef . current . onDragMove && ( _eventsRef$current = eventsRef . current ) . onDragMove . apply ( _eventsRef$current , arguments ) ;
} , [ ] ) ;
var endDrag = Object ( external _this _wp _element _ [ "useCallback" ] ) ( function ( ) {
if ( eventsRef . current . onDragEnd ) {
var _eventsRef$current2 ;
( _eventsRef$current2 = eventsRef . current ) . onDragEnd . apply ( _eventsRef$current2 , arguments ) ;
}
document . removeEventListener ( 'mousemove' , onMouseMove ) ;
document . removeEventListener ( 'mouseup' , endDrag ) ;
setIsDragging ( false ) ;
} , [ ] ) ;
var startDrag = Object ( external _this _wp _element _ [ "useCallback" ] ) ( function ( ) {
if ( eventsRef . current . onDragStart ) {
var _eventsRef$current3 ;
( _eventsRef$current3 = eventsRef . current ) . onDragStart . apply ( _eventsRef$current3 , arguments ) ;
}
document . addEventListener ( 'mousemove' , onMouseMove ) ;
document . addEventListener ( 'mouseup' , endDrag ) ;
setIsDragging ( true ) ;
} , [ ] ) ; // Remove the global events when unmounting if needed.
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
return function ( ) {
if ( isDragging ) {
document . removeEventListener ( 'mousemove' , onMouseMove ) ;
document . removeEventListener ( 'mouseup' , endDrag ) ;
}
} ;
} , [ isDragging ] ) ;
return {
startDrag : startDrag ,
endDrag : endDrag ,
isDragging : isDragging
} ;
}
2020-01-22 17:06:21 -05:00
// EXTERNAL MODULE: ./node_modules/mousetrap/mousetrap.js
2020-10-20 09:36:16 -04:00
var mousetrap _mousetrap = _ _webpack _require _ _ ( 288 ) ;
2020-01-22 17:06:21 -05:00
var mousetrap _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( mousetrap _mousetrap ) ;
// EXTERNAL MODULE: ./node_modules/mousetrap/plugins/global-bind/mousetrap-global-bind.js
2020-10-20 09:36:16 -04:00
var mousetrap _global _bind = _ _webpack _require _ _ ( 429 ) ;
2020-01-22 17:06:21 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-keyboard-shortcut/index.js
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* A block selection object .
*
* @ typedef { Object } WPKeyboardShortcutConfig
*
* @ property { boolean } [ bindGlobal ] Handle keyboard events anywhere including inside textarea / input fields .
* @ property { string } [ eventName ] Event name used to trigger the handler , defaults to keydown .
* @ property { boolean } [ isDisabled ] Disables the keyboard handler if the value is true .
* @ property { Object } [ target ] React reference to the DOM element used to catch the keyboard event .
* /
/ * *
* Return true if platform is MacOS .
*
* @ param { Object } _window window object by default ; used for DI testing .
*
* @ return { boolean } True if MacOS ; false otherwise .
* /
function isAppleOS ( ) {
var _window = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : window ;
var platform = _window . navigator . platform ;
return platform . indexOf ( 'Mac' ) !== - 1 || Object ( external _this _lodash _ [ "includes" ] ) ( [ 'iPad' , 'iPhone' ] , platform ) ;
}
/ * *
* Attach a keyboard shortcut handler .
*
* @ param { string [ ] | string } shortcuts Keyboard Shortcuts .
* @ param { Function } callback Shortcut callback .
* @ param { WPKeyboardShortcutConfig } options Shortcut options .
* /
function useKeyboardShortcut ( shortcuts , callback ) {
var _ref = arguments . length > 2 && arguments [ 2 ] !== undefined ? arguments [ 2 ] : { } ,
_ref$bindGlobal = _ref . bindGlobal ,
bindGlobal = _ref$bindGlobal === void 0 ? false : _ref$bindGlobal ,
_ref$eventName = _ref . eventName ,
eventName = _ref$eventName === void 0 ? 'keydown' : _ref$eventName ,
_ref$isDisabled = _ref . isDisabled ,
isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled ,
target = _ref . target ;
2020-07-07 10:43:35 -04:00
var currentCallback = Object ( external _this _wp _element _ [ "useRef" ] ) ( callback ) ;
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
currentCallback . current = callback ;
} , [ callback ] ) ;
2020-01-22 17:06:21 -05:00
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
if ( isDisabled ) {
return ;
}
var mousetrap = new mousetrap _default . a ( target ? target . current : document ) ;
Object ( external _this _lodash _ [ "castArray" ] ) ( shortcuts ) . forEach ( function ( shortcut ) {
var keys = shortcut . split ( '+' ) ; // Determines whether a key is a modifier by the length of the string.
// E.g. if I add a pass a shortcut Shift+Cmd+M, it'll determine that
// the modifiers are Shift and Cmd because they're not a single character.
var modifiers = new Set ( keys . filter ( function ( value ) {
return value . length > 1 ;
} ) ) ;
var hasAlt = modifiers . has ( 'alt' ) ;
var hasShift = modifiers . has ( 'shift' ) ; // This should be better moved to the shortcut registration instead.
if ( isAppleOS ( ) && ( modifiers . size === 1 && hasAlt || modifiers . size === 2 && hasAlt && hasShift ) ) {
throw new Error ( "Cannot bind " . concat ( shortcut , ". Alt and Shift+Alt modifiers are reserved for character input." ) ) ;
}
var bindFn = bindGlobal ? 'bindGlobal' : 'bind' ;
2020-07-07 10:43:35 -04:00
mousetrap [ bindFn ] ( shortcut , function ( ) {
return currentCallback . current . apply ( currentCallback , arguments ) ;
} , eventName ) ;
2020-01-22 17:06:21 -05:00
} ) ;
return function ( ) {
mousetrap . reset ( ) ;
} ;
2020-07-07 10:43:35 -04:00
} , [ shortcuts , bindGlobal , eventName , target , isDisabled ] ) ;
2020-01-22 17:06:21 -05:00
}
/* harmony default export */ var use _keyboard _shortcut = ( useKeyboardShortcut ) ;
2020-07-07 12:08:28 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-media-query/index.js
/ * *
* WordPress dependencies
* /
/ * *
* Runs a media query and returns its value when it changes .
*
* @ param { string } [ query ] Media Query .
* @ return { boolean } return value of the media query .
* /
function useMediaQuery ( query ) {
var _useState = Object ( external _this _wp _element _ [ "useState" ] ) ( query && window . matchMedia ( query ) . matches ) ,
_useState2 = Object ( slicedToArray [ "a" /* default */ ] ) ( _useState , 2 ) ,
match = _useState2 [ 0 ] ,
setMatch = _useState2 [ 1 ] ;
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
if ( ! query ) {
return ;
}
var updateMatch = function updateMatch ( ) {
return setMatch ( window . matchMedia ( query ) . matches ) ;
} ;
updateMatch ( ) ;
var list = window . matchMedia ( query ) ;
list . addListener ( updateMatch ) ;
return function ( ) {
list . removeListener ( updateMatch ) ;
} ;
} , [ query ] ) ;
return query && match ;
}
2020-06-26 09:33:47 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-previous/index.js
/ * *
* WordPress dependencies
* /
/ * *
* Use something ' s value from the previous render .
* Based on https : //usehooks.com/usePrevious/.
*
* @ template T
*
* @ param { T } value The value to track .
*
* @ return { T | undefined } The value from the previous render .
* /
function usePrevious ( value ) {
// Disable reason: without an explicit type detail, the type of ref will be
// inferred based on the initial useRef argument, which is undefined.
// https://github.com/WordPress/gutenberg/pull/22597#issuecomment-633588366
/* eslint-disable jsdoc/no-undefined-types */
var ref = Object ( external _this _wp _element _ [ "useRef" ] ) (
/** @type {T|undefined} */
undefined ) ;
/* eslint-enable jsdoc/no-undefined-types */
// Store current value in ref.
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
ref . current = value ;
} , [ value ] ) ; // Re-run when value changes.
// Return previous value (happens before update in useEffect above).
return ref . current ;
}
2019-09-19 11:19:18 -04:00
2020-07-07 12:08:28 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-reduced-motion/index.js
/ * *
* Internal dependencies
* /
/ * *
* Whether or not the user agent is Internet Explorer .
*
* @ type { boolean }
* /
var IS _IE = typeof window !== 'undefined' && window . navigator . userAgent . indexOf ( 'Trident' ) >= 0 ;
/ * *
* Hook returning whether the user has a preference for reduced motion .
*
* @ return { boolean } Reduced motion preference value .
* /
var useReducedMotion = undefined || IS _IE ? function ( ) {
return true ;
} : function ( ) {
return useMediaQuery ( '(prefers-reduced-motion: reduce)' ) ;
} ;
/* harmony default export */ var use _reduced _motion = ( useReducedMotion ) ;
2019-09-19 11:19:18 -04:00
2020-01-08 06:57:23 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-viewport-match/index.js
2020-01-22 17:06:21 -05:00
/ * *
* WordPress dependencies
* /
2018-12-17 22:14:52 -05:00
/ * *
2020-01-08 06:57:23 -05:00
* Internal dependencies
2018-12-17 22:14:52 -05:00
* /
2020-01-22 17:06:21 -05:00
2020-01-08 06:57:23 -05:00
/ * *
* @ typedef { "huge" | "wide" | "large" | "medium" | "small" | "mobile" } WPBreakpoint
* /
2018-12-17 22:14:52 -05:00
/ * *
2020-01-08 06:57:23 -05:00
* Hash of breakpoint names with pixel width at which it becomes effective .
2018-12-17 22:14:52 -05:00
*
2020-01-08 06:57:23 -05:00
* @ see _breakpoints . scss
2018-12-17 22:14:52 -05:00
*
2020-01-08 06:57:23 -05:00
* @ type { Object < WPBreakpoint , number > }
2018-12-17 22:14:52 -05:00
* /
2018-12-13 23:41:57 -05:00
2020-01-08 06:57:23 -05:00
var BREAKPOINTS = {
huge : 1440 ,
wide : 1280 ,
large : 960 ,
medium : 782 ,
small : 600 ,
mobile : 480
} ;
/ * *
* @ typedef { ">=" | "<" } WPViewportOperator
* /
2019-09-19 11:19:18 -04:00
2020-01-08 06:57:23 -05:00
/ * *
* Object mapping media query operators to the condition to be used .
*
* @ type { Object < WPViewportOperator , string > }
* /
2019-09-19 11:19:18 -04:00
2020-01-08 06:57:23 -05:00
var CONDITIONS = {
'>=' : 'min-width' ,
'<' : 'max-width'
} ;
2020-01-22 17:06:21 -05:00
/ * *
* Object mapping media query operators to a function that given a breakpointValue and a width evaluates if the operator matches the values .
*
* @ type { Object < WPViewportOperator , Function > }
* /
var OPERATOR _EVALUATORS = {
'>=' : function _ ( breakpointValue , width ) {
return width >= breakpointValue ;
} ,
'<' : function _ ( breakpointValue , width ) {
return width < breakpointValue ;
}
} ;
var ViewportMatchWidthContext = Object ( external _this _wp _element _ [ "createContext" ] ) ( null ) ;
2020-01-08 06:57:23 -05:00
/ * *
* Returns true if the viewport matches the given query , or false otherwise .
*
* @ param { WPBreakpoint } breakpoint Breakpoint size name .
* @ param { WPViewportOperator } [ operator = ">=" ] Viewport operator .
*
* @ example
*
* ` ` ` js
2020-06-26 09:33:47 -04:00
* useViewportMatch ( 'huge' , '<' ) ;
2020-01-08 06:57:23 -05:00
* useViewportMatch ( 'medium' ) ;
* ` ` `
*
* @ return { boolean } Whether viewport matches query .
* /
2019-09-19 11:19:18 -04:00
2020-01-08 06:57:23 -05:00
var use _viewport _match _useViewportMatch = function useViewportMatch ( breakpoint ) {
var operator = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : '>=' ;
2020-01-22 17:06:21 -05:00
var simulatedWidth = Object ( external _this _wp _element _ [ "useContext" ] ) ( ViewportMatchWidthContext ) ;
var mediaQuery = ! simulatedWidth && "(" . concat ( CONDITIONS [ operator ] , ": " ) . concat ( BREAKPOINTS [ breakpoint ] , "px)" ) ;
2020-07-07 12:08:28 -04:00
var mediaQueryResult = useMediaQuery ( mediaQuery ) ;
2020-01-22 17:06:21 -05:00
if ( simulatedWidth ) {
return OPERATOR _EVALUATORS [ operator ] ( BREAKPOINTS [ breakpoint ] , simulatedWidth ) ;
}
return mediaQueryResult ;
2020-01-08 06:57:23 -05:00
} ;
2019-09-19 11:19:18 -04:00
2020-01-22 17:06:21 -05:00
use _viewport _match _useViewportMatch . _ _experimentalWidthProvider = ViewportMatchWidthContext . Provider ;
2020-01-08 06:57:23 -05:00
/* harmony default export */ var use _viewport _match = ( use _viewport _match _useViewportMatch ) ;
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: ./node_modules/react-resize-aware/dist/index.js
2020-10-13 09:10:30 -04:00
var dist = _ _webpack _require _ _ ( 152 ) ;
2020-06-26 09:33:47 -04:00
var dist _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( dist ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-resize-observer/index.js
/ * *
* External dependencies
* /
/ * *
* Hook which allows to listen the resize event of any target element when it changes sizes .
* _Note : ` useResizeObserver ` will report ` null ` until after first render _
*
* @ return { Array } An array of { Element } ` resizeListener ` and { ? Object } ` sizes ` with properties ` width ` and ` height `
*
* @ example
*
* ` ` ` js
* const App = ( ) => {
* const [ resizeListener , sizes ] = useResizeObserver ( ) ;
*
* return (
* < div >
* { resizeListener }
* Your content here
* < / d i v >
* ) ;
* } ;
* ` ` `
*
* /
/* harmony default export */ var use _resize _observer = ( dist _default . a ) ;
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
2020-10-20 09:36:16 -04:00
var toConsumableArray = _ _webpack _require _ _ ( 17 ) ;
2020-06-26 09:33:47 -04:00
// EXTERNAL MODULE: external {"this":["wp","priorityQueue"]}
2020-10-13 09:10:30 -04:00
var external _this _wp _priorityQueue _ = _ _webpack _require _ _ ( 153 ) ;
2020-06-26 09:33:47 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-async-list/index.js
/ * *
* WordPress dependencies
* /
/ * *
* Returns the first items from list that are present on state .
*
* @ param { Array } list New array .
* @ param { Array } state Current state .
* @ return { Array } First items present iin state .
* /
function getFirstItemsPresentInState ( list , state ) {
var firstItems = [ ] ;
for ( var i = 0 ; i < list . length ; i ++ ) {
var item = list [ i ] ;
if ( ! state . includes ( item ) ) {
break ;
}
firstItems . push ( item ) ;
}
return firstItems ;
}
/ * *
* Reducer keeping track of a list of appended items .
*
* @ param { Array } state Current state
* @ param { Object } action Action
*
* @ return { Array } update state .
* /
function listReducer ( state , action ) {
if ( action . type === 'reset' ) {
return action . list ;
}
if ( action . type === 'append' ) {
return [ ] . concat ( Object ( toConsumableArray [ "a" /* default */ ] ) ( state ) , [ action . item ] ) ;
}
return state ;
}
/ * *
* React hook returns an array which items get asynchronously appended from a source array .
* This behavior is useful if we want to render a list of items asynchronously for performance reasons .
*
* @ param { Array } list Source array .
* @ return { Array } Async array .
* /
function useAsyncList ( list ) {
var _useReducer = Object ( external _this _wp _element _ [ "useReducer" ] ) ( listReducer , [ ] ) ,
_useReducer2 = Object ( slicedToArray [ "a" /* default */ ] ) ( _useReducer , 2 ) ,
current = _useReducer2 [ 0 ] ,
dispatch = _useReducer2 [ 1 ] ;
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
// On reset, we keep the first items that were previously rendered.
var firstItems = getFirstItemsPresentInState ( list , current ) ;
dispatch ( {
type : 'reset' ,
list : firstItems
} ) ;
var asyncQueue = Object ( external _this _wp _priorityQueue _ [ "createQueue" ] ) ( ) ;
var append = function append ( index ) {
return function ( ) {
if ( list . length <= index ) {
return ;
}
dispatch ( {
type : 'append' ,
item : list [ index ]
} ) ;
asyncQueue . add ( { } , append ( index + 1 ) ) ;
} ;
} ;
asyncQueue . add ( { } , append ( firstItems . length ) ) ;
return function ( ) {
return asyncQueue . reset ( ) ;
} ;
} , [ list ] ) ;
return current ;
}
/* harmony default export */ var use _async _list = ( useAsyncList ) ;
2020-07-14 07:39:09 -04:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-warn-on-change/index.js
/ * *
* Internal dependencies
* /
/ * *
* Hook that performs a shallow comparison between the preview value of an object
* and the new one , if there ' s a difference , it prints it to the console .
* this is useful in performance related work , to check why a component re - renders .
*
* @ example
*
* ` ` ` jsx
* function MyComponent ( props ) {
* useWarnOnChange ( props ) ;
*
* return "Something" ;
* }
* ` ` `
*
* @ param { Object } object Object which changes to compare .
* @ param { string } prefix Just a prefix to show when console logging .
* /
function useWarnOnChange ( object ) {
var prefix = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : 'Change detection' ;
var previousValues = usePrevious ( object ) ;
Object . entries ( previousValues !== null && previousValues !== void 0 ? previousValues : [ ] ) . forEach ( function ( _ref ) {
var _ref2 = Object ( slicedToArray [ "a" /* default */ ] ) ( _ref , 2 ) ,
key = _ref2 [ 0 ] ,
value = _ref2 [ 1 ] ;
if ( value !== object [ key ] ) {
// eslint-disable-next-line no-console
console . warn ( "" . concat ( prefix , ": " ) . concat ( key , " key changed:" ) , value , object [ key ] ) ;
}
} ) ;
}
/* harmony default export */ var use _warn _on _change = ( useWarnOnChange ) ;
2020-10-20 09:36:16 -04:00
// EXTERNAL MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js
var use _memo _one _esm = _ _webpack _require _ _ ( 154 ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-debounce/index.js
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* Debounces a function with Lodash ' s ` debounce ` . A new debounced function will
* be returned and any scheduled calls cancelled if any of the arguments change ,
* including the function to debounce , so please wrap functions created on
* render in components in ` useCallback ` .
*
* @ param { ... any } args Arguments passed to Lodash ' s ` debounce ` .
* /
function useDebounce ( ) {
for ( var _len = arguments . length , args = new Array ( _len ) , _key = 0 ; _key < _len ; _key ++ ) {
args [ _key ] = arguments [ _key ] ;
}
var debounced = Object ( use _memo _one _esm [ "a" /* useMemoOne */ ] ) ( function ( ) {
return external _this _lodash _ [ "debounce" ] . apply ( void 0 , args ) ;
} , args ) ;
Object ( external _this _wp _element _ [ "useEffect" ] ) ( function ( ) {
return function ( ) {
return debounced . cancel ( ) ;
} ;
} , [ debounced ] ) ;
return debounced ;
}
2020-01-08 06:57:23 -05:00
// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js
// Utils
// Compose helper (aliased flowRight from Lodash)
2019-09-19 11:19:18 -04:00
2020-01-08 06:57:23 -05:00
// Higher-order components
2019-09-19 11:19:18 -04:00
2018-12-13 23:41:57 -05:00
2020-01-08 06:57:23 -05:00
// Hooks
2018-12-13 23:41:57 -05:00
2018-12-17 22:14:52 -05:00
2020-01-22 17:06:21 -05:00
2020-02-06 16:03:31 -05:00
2020-06-26 09:33:47 -04:00
2020-07-14 07:39:09 -04:00
2020-10-20 09:36:16 -04:00
2019-09-19 11:19:18 -04:00
/***/ } ) ,
2020-07-21 08:14:37 -04:00
/***/ 64 :
2019-09-19 11:19:18 -04:00
/***/ ( function ( module , exports ) {
2019-10-15 11:37:08 -04:00
( function ( ) { module . exports = this [ "wp" ] [ "isShallowEqual" ] ; } ( ) ) ;
2019-09-19 11:19:18 -04:00
2019-10-15 11:37:08 -04:00
/***/ } ) ,
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
/***/ 8 :
2019-10-15 11:37:08 -04:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
2019-09-19 11:19:18 -04:00
2019-10-15 11:37:08 -04:00
"use strict" ;
2020-06-26 09:33:47 -04:00
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _extends ; } ) ;
function _extends ( ) {
_extends = Object . assign || function ( target ) {
for ( var i = 1 ; i < arguments . length ; i ++ ) {
var source = arguments [ i ] ;
2019-09-19 11:19:18 -04:00
2020-06-26 09:33:47 -04:00
for ( var key in source ) {
if ( Object . prototype . hasOwnProperty . call ( source , key ) ) {
target [ key ] = source [ key ] ;
}
}
}
return target ;
} ;
return _extends . apply ( this , arguments ) ;
2019-09-19 11:19:18 -04:00
}
2018-12-13 23:41:57 -05:00
/***/ } )
2018-12-17 22:14:52 -05:00
/******/ } ) ;
