1(window["webpackJsonp"] = window["webpackJsonp"] || []).push([["vendors~app"],{ 2
vendor: 710 bytes, lines 3-32
3/***/ "./node_modules/dashify/index.js": 4/*!***************************************!*\ 5 !*** ./node_modules/dashify/index.js ***! 6 \***************************************/ 7/*! no static exports found */ 8/***/ (function(module, exports, __webpack_require__) { 9 10"use strict"; 11/*! 12 * dashify <https://github.com/jonschlinkert/dashify> 13 * 14 * Copyright (c) 2015 Jon Schlinkert. 15 * Licensed under the MIT license. 16 */ 17 18 19 20module.exports = function dashify(str) { 21 if (typeof str !== 'string') { 22 throw new TypeError('expected a string'); 23 } 24 str = str.replace(/([a-z])([A-Z])/g, '$1-$2'); 25 str = str.replace(/[ \t\W]/g, '-'); 26 str = str.replace(/^-+|-+$/g, ''); 27 return str.toLowerCase(); 28}; 29 30 31/***/ }), 32
vendor: 1,898 bytes, lines 33-94
33/***/ "./node_modules/desandro-matches-selector/matches-selector.js": 34/*!********************************************************************!*\ 35 !*** ./node_modules/desandro-matches-selector/matches-selector.js ***! 36 \********************************************************************/ 37/*! no static exports found */ 38/***/ (function(module, exports, __webpack_require__) { 39 40var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/** 41 * matchesSelector v2.0.2 42 * matchesSelector( element, '.selector' ) 43 * MIT license 44 */ 45 46/*jshint browser: true, strict: true, undef: true, unused: true */ 47 48( function( window, factory ) { 49 /*global define: false, module: false */ 50 'use strict'; 51 // universal module definition 52 if ( true ) { 53 // AMD 54 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 55 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 56 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 57 __WEBPACK_AMD_DEFINE_FACTORY__), 58 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 59 } else {} 60 61}( window, function factory() { 62 'use strict'; 63 64 var matchesMethod = ( function() { 65 var ElemProto = window.Element.prototype; 66 // check for the standard method name first 67 if ( ElemProto.matches ) { 68 return 'matches'; 69 } 70 // check un-prefixed 71 if ( ElemProto.matchesSelector ) { 72 return 'matchesSelector'; 73 } 74 // check vendor prefixes 75 var prefixes = [ 'webkit', 'moz', 'ms', 'o' ]; 76 77 for ( var i=0; i < prefixes.length; i++ ) { 78 var prefix = prefixes[i]; 79 var method = prefix + 'MatchesSelector'; 80 if ( ElemProto[ method ] ) { 81 return method; 82 } 83 } 84 })(); 85 86 return function matchesSelector( elem, selector ) { 87 return elem[ matchesMethod ]( selector ); 88 }; 89 90})); 91 92 93/***/ }), 94
vendor: 3,198 bytes, lines 95-215
95/***/ "./node_modules/ev-emitter/ev-emitter.js": 96/*!***********************************************!*\ 97 !*** ./node_modules/ev-emitter/ev-emitter.js ***! 98 \***********************************************/ 99/*! no static exports found */ 100/***/ (function(module, exports, __webpack_require__) { 101 102var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/** 103 * EvEmitter v1.1.0 104 * Lil' event emitter 105 * MIT License 106 */ 107 108/* jshint unused: true, undef: true, strict: true */ 109 110( function( global, factory ) { 111 // universal module definition 112 /* jshint strict: false */ /* globals define, module, window */ 113 if ( true ) { 114 // AMD - RequireJS 115 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 116 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 117 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 118 __WEBPACK_AMD_DEFINE_FACTORY__), 119 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 120 } else {} 121 122}( typeof window != 'undefined' ? window : this, function() { 123 124"use strict"; 125 126function EvEmitter() {} 127 128var proto = EvEmitter.prototype; 129 130proto.on = function( eventName, listener ) { 131 if ( !eventName || !listener ) { 132 return; 133 } 134 // set events hash 135 var events = this._events = this._events || {}; 136 // set listeners array 137 var listeners = events[ eventName ] = events[ eventName ] || []; 138 // only add once 139 if ( listeners.indexOf( listener ) == -1 ) { 140 listeners.push( listener ); 141 } 142 143 return this; 144}; 145 146proto.once = function( eventName, listener ) { 147 if ( !eventName || !listener ) { 148 return; 149 } 150 // add event 151 this.on( eventName, listener ); 152 // set once flag 153 // set onceEvents hash 154 var onceEvents = this._onceEvents = this._onceEvents || {}; 155 // set onceListeners object 156 var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {}; 157 // set flag 158 onceListeners[ listener ] = true; 159 160 return this; 161}; 162 163proto.off = function( eventName, listener ) { 164 var listeners = this._events && this._events[ eventName ]; 165 if ( !listeners || !listeners.length ) { 166 return; 167 } 168 var index = listeners.indexOf( listener ); 169 if ( index != -1 ) { 170 listeners.splice( index, 1 ); 171 } 172 173 return this; 174}; 175 176proto.emitEvent = function( eventName, args ) { 177 var listeners = this._events && this._events[ eventName ]; 178 if ( !listeners || !listeners.length ) { 179 return; 180 } 181 // copy over to avoid interference if .off() in listener 182 listeners = listeners.slice(0); 183 args = args || []; 184 // once stuff 185 var onceListeners = this._onceEvents && this._onceEvents[ eventName ]; 186 187 for ( var i=0; i < listeners.length; i++ ) { 188 var listener = listeners[i] 189 var isOnce = onceListeners && onceListeners[ listener ]; 190 if ( isOnce ) { 191 // remove listener 192 // remove before trigger to prevent recursion 193 this.off( eventName, listener ); 194 // unset once flag 195 delete onceListeners[ listener ]; 196 } 197 // trigger listener 198 listener.apply( this, args ); 199 } 200 201 return this; 202}; 203 204proto.allOff = function() { 205 delete this._events; 206 delete this._onceEvents; 207}; 208 209return EvEmitter; 210 211})); 212 213 214/***/ }), 215
vendor: 6,351 bytes, lines 216-456
216/***/ "./node_modules/fizzy-ui-utils/utils.js": 217/*!**********************************************!*\ 218 !*** ./node_modules/fizzy-ui-utils/utils.js ***! 219 \**********************************************/ 220/*! no static exports found */ 221/***/ (function(module, exports, __webpack_require__) { 222 223var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/** 224 * Fizzy UI utils v2.0.7 225 * MIT license 226 */ 227 228/*jshint browser: true, undef: true, unused: true, strict: true */ 229 230( function( window, factory ) { 231 // universal module definition 232 /*jshint strict: false */ /*globals define, module, require */ 233 234 if ( true ) { 235 // AMD 236 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 237 __webpack_require__(/*! desandro-matches-selector/matches-selector */ "./node_modules/desandro-matches-selector/matches-selector.js") 238 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( matchesSelector ) { 239 return factory( window, matchesSelector ); 240 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 241 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 242 } else {} 243 244}( window, function factory( window, matchesSelector ) { 245 246'use strict'; 247 248var utils = {}; 249 250// ----- extend ----- // 251 252// extends objects 253utils.extend = function( a, b ) { 254 for ( var prop in b ) { 255 a[ prop ] = b[ prop ]; 256 } 257 return a; 258}; 259 260// ----- modulo ----- // 261 262utils.modulo = function( num, div ) { 263 return ( ( num % div ) + div ) % div; 264}; 265 266// ----- makeArray ----- // 267 268var arraySlice = Array.prototype.slice; 269 270// turn element or nodeList into an array 271utils.makeArray = function( obj ) { 272 if ( Array.isArray( obj ) ) { 273 // use object if already an array 274 return obj; 275 } 276 // return empty array if undefined or null. #6 277 if ( obj === null || obj === undefined ) { 278 return []; 279 } 280 281 var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number'; 282 if ( isArrayLike ) { 283 // convert nodeList to array 284 return arraySlice.call( obj ); 285 } 286 287 // array of single index 288 return [ obj ]; 289}; 290 291// ----- removeFrom ----- // 292 293utils.removeFrom = function( ary, obj ) { 294 var index = ary.indexOf( obj ); 295 if ( index != -1 ) { 296 ary.splice( index, 1 ); 297 } 298}; 299 300// ----- getParent ----- // 301 302utils.getParent = function( elem, selector ) { 303 while ( elem.parentNode && elem != document.body ) { 304 elem = elem.parentNode; 305 if ( matchesSelector( elem, selector ) ) { 306 return elem; 307 } 308 } 309}; 310 311// ----- getQueryElement ----- // 312 313// use element as selector string 314utils.getQueryElement = function( elem ) { 315 if ( typeof elem == 'string' ) { 316 return document.querySelector( elem ); 317 } 318 return elem; 319}; 320 321// ----- handleEvent ----- // 322 323// enable .ontype to trigger from .addEventListener( elem, 'type' ) 324utils.handleEvent = function( event ) { 325 var method = 'on' + event.type; 326 if ( this[ method ] ) { 327 this[ method ]( event ); 328 } 329}; 330 331// ----- filterFindElements ----- // 332 333utils.filterFindElements = function( elems, selector ) { 334 // make array of elems 335 elems = utils.makeArray( elems ); 336 var ffElems = []; 337 338 elems.forEach( function( elem ) { 339 // check that elem is an actual element 340 if ( !( elem instanceof HTMLElement ) ) { 341 return; 342 } 343 // add elem if no selector 344 if ( !selector ) { 345 ffElems.push( elem ); 346 return; 347 } 348 // filter & find items if we have a selector 349 // filter 350 if ( matchesSelector( elem, selector ) ) { 351 ffElems.push( elem ); 352 } 353 // find children 354 var childElems = elem.querySelectorAll( selector ); 355 // concat childElems to filterFound array 356 for ( var i=0; i < childElems.length; i++ ) { 357 ffElems.push( childElems[i] ); 358 } 359 }); 360 361 return ffElems; 362}; 363 364// ----- debounceMethod ----- // 365 366utils.debounceMethod = function( _class, methodName, threshold ) { 367 threshold = threshold || 100; 368 // original method 369 var method = _class.prototype[ methodName ]; 370 var timeoutName = methodName + 'Timeout'; 371 372 _class.prototype[ methodName ] = function() { 373 var timeout = this[ timeoutName ]; 374 clearTimeout( timeout ); 375 376 var args = arguments; 377 var _this = this; 378 this[ timeoutName ] = setTimeout( function() { 379 method.apply( _this, args ); 380 delete _this[ timeoutName ]; 381 }, threshold ); 382 }; 383}; 384 385// ----- docReady ----- // 386 387utils.docReady = function( callback ) { 388 var readyState = document.readyState; 389 if ( readyState == 'complete' || readyState == 'interactive' ) { 390 // do async to allow for other scripts to run. metafizzy/flickity#441 391 setTimeout( callback ); 392 } else { 393 document.addEventListener( 'DOMContentLoaded', callback ); 394 } 395}; 396 397// ----- htmlInit ----- // 398 399// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/ 400utils.toDashed = function( str ) { 401 return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) { 402 return $1 + '-' + $2; 403 }).toLowerCase(); 404}; 405 406var console = window.console; 407/** 408 * allow user to initialize classes via [data-namespace] or .js-namespace class 409 * htmlInit( Widget, 'widgetName' ) 410 * options are parsed from data-namespace-options 411 */ 412utils.htmlInit = function( WidgetClass, namespace ) { 413 utils.docReady( function() { 414 var dashedNamespace = utils.toDashed( namespace ); 415 var dataAttr = 'data-' + dashedNamespace; 416 var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' ); 417 var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace ); 418 var elems = utils.makeArray( dataAttrElems ) 419 .concat( utils.makeArray( jsDashElems ) ); 420 var dataOptionsAttr = dataAttr + '-options'; 421 var jQuery = window.jQuery; 422 423 elems.forEach( function( elem ) { 424 var attr = elem.getAttribute( dataAttr ) || 425 elem.getAttribute( dataOptionsAttr ); 426 var options; 427 try { 428 options = attr && JSON.parse( attr ); 429 } catch ( error ) { 430 // log error, do not initialize 431 if ( console ) { 432 console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className + 433 ': ' + error ); 434 } 435 return; 436 } 437 // initialize 438 var instance = new WidgetClass( elem, options ); 439 // make available via $().data('namespace') 440 if ( jQuery ) { 441 jQuery.data( elem, namespace, instance ); 442 } 443 }); 444 445 }); 446}; 447 448// ----- ----- // 449 450return utils; 451 452})); 453 454 455/***/ }), 456
vendor: 2,011 bytes, lines 457-517
457/***/ "./node_modules/flickity-imagesloaded/flickity-imagesloaded.js": 458/*!*********************************************************************!*\ 459 !*** ./node_modules/flickity-imagesloaded/flickity-imagesloaded.js ***! 460 \*********************************************************************/ 461/*! no static exports found */ 462/***/ (function(module, exports, __webpack_require__) { 463 464var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 465 * Flickity imagesLoaded v2.0.0 466 * enables imagesLoaded option for Flickity 467 */ 468 469/*jshint browser: true, strict: true, undef: true, unused: true */ 470 471( function( window, factory ) { 472 // universal module definition 473 /*jshint strict: false */ /*globals define, module, require */ 474 if ( true ) { 475 // AMD 476 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 477 __webpack_require__(/*! flickity/js/index */ "./node_modules/flickity/js/index.js"), 478 __webpack_require__(/*! imagesloaded/imagesloaded */ "./node_modules/imagesloaded/imagesloaded.js") 479 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Flickity, imagesLoaded ) { 480 return factory( window, Flickity, imagesLoaded ); 481 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 482 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 483 } else {} 484 485}( window, function factory( window, Flickity, imagesLoaded ) { 486'use strict'; 487 488Flickity.createMethods.push('_createImagesLoaded'); 489 490var proto = Flickity.prototype; 491 492proto._createImagesLoaded = function() { 493 this.on( 'activate', this.imagesLoaded ); 494}; 495 496proto.imagesLoaded = function() { 497 if ( !this.options.imagesLoaded ) { 498 return; 499 } 500 var _this = this; 501 function onImagesLoadedProgress( instance, image ) { 502 var cell = _this.getParentCell( image.img ); 503 _this.cellSizeChange( cell && cell.element ); 504 if ( !_this.options.freeScroll ) { 505 _this.positionSliderAtSelected(); 506 } 507 } 508 imagesLoaded( this.slider ).on( 'progress', onImagesLoadedProgress ); 509}; 510 511return Flickity; 512 513})); 514 515 516/***/ }), 517
vendor: 4,515 bytes, lines 518-676
518/***/ "./node_modules/flickity/js/add-remove-cell.js": 519/*!*****************************************************!*\ 520 !*** ./node_modules/flickity/js/add-remove-cell.js ***! 521 \*****************************************************/ 522/*! no static exports found */ 523/***/ (function(module, exports, __webpack_require__) { 524 525var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// add, remove cell 526( function( window, factory ) { 527 // universal module definition 528 /* jshint strict: false */ 529 if ( true ) { 530 // AMD 531 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 532 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js"), 533 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js") 534 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Flickity, utils ) { 535 return factory( window, Flickity, utils ); 536 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 537 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 538 } else {} 539 540}( window, function factory( window, Flickity, utils ) { 541 542'use strict'; 543 544// append cells to a document fragment 545function getCellsFragment( cells ) { 546 var fragment = document.createDocumentFragment(); 547 cells.forEach( function( cell ) { 548 fragment.appendChild( cell.element ); 549 }); 550 return fragment; 551} 552 553// -------------------------- add/remove cell prototype -------------------------- // 554 555var proto = Flickity.prototype; 556 557/** 558 * Insert, prepend, or append cells 559 * @param {Element, Array, NodeList} elems 560 * @param {Integer} index 561 */ 562proto.insert = function( elems, index ) { 563 var cells = this._makeCells( elems ); 564 if ( !cells || !cells.length ) { 565 return; 566 } 567 var len = this.cells.length; 568 // default to append 569 index = index === undefined ? len : index; 570 // add cells with document fragment 571 var fragment = getCellsFragment( cells ); 572 // append to slider 573 var isAppend = index == len; 574 if ( isAppend ) { 575 this.slider.appendChild( fragment ); 576 } else { 577 var insertCellElement = this.cells[ index ].element; 578 this.slider.insertBefore( fragment, insertCellElement ); 579 } 580 // add to this.cells 581 if ( index === 0 ) { 582 // prepend, add to start 583 this.cells = cells.concat( this.cells ); 584 } else if ( isAppend ) { 585 // append, add to end 586 this.cells = this.cells.concat( cells ); 587 } else { 588 // insert in this.cells 589 var endCells = this.cells.splice( index, len - index ); 590 this.cells = this.cells.concat( cells ).concat( endCells ); 591 } 592 593 this._sizeCells( cells ); 594 this.cellChange( index, true ); 595}; 596 597proto.append = function( elems ) { 598 this.insert( elems, this.cells.length ); 599}; 600 601proto.prepend = function( elems ) { 602 this.insert( elems, 0 ); 603}; 604 605/** 606 * Remove cells 607 * @param {Element, Array, NodeList} elems 608 */ 609proto.remove = function( elems ) { 610 var cells = this.getCells( elems ); 611 if ( !cells || !cells.length ) { 612 return; 613 } 614 615 var minCellIndex = this.cells.length - 1; 616 // remove cells from collection & DOM 617 cells.forEach( function( cell ) { 618 cell.remove(); 619 var index = this.cells.indexOf( cell ); 620 minCellIndex = Math.min( index, minCellIndex ); 621 utils.removeFrom( this.cells, cell ); 622 }, this ); 623 624 this.cellChange( minCellIndex, true ); 625}; 626 627/** 628 * logic to be run after a cell's size changes 629 * @param {Element} elem - cell's element 630 */ 631proto.cellSizeChange = function( elem ) { 632 var cell = this.getCell( elem ); 633 if ( !cell ) { 634 return; 635 } 636 cell.getSize(); 637 638 var index = this.cells.indexOf( cell ); 639 this.cellChange( index ); 640}; 641 642/** 643 * logic any time a cell is changed: added, removed, or size changed 644 * @param {Integer} changedCellIndex - index of the changed cell, optional 645 */ 646proto.cellChange = function( changedCellIndex, isPositioningSlider ) { 647 var prevSelectedElem = this.selectedElement; 648 this._positionCells( changedCellIndex ); 649 this._getWrapShiftCells(); 650 this.setGallerySize(); 651 // update selectedIndex 652 // try to maintain position & select previous selected element 653 var cell = this.getCell( prevSelectedElem ); 654 if ( cell ) { 655 this.selectedIndex = this.getCellSlideIndex( cell ); 656 } 657 this.selectedIndex = Math.min( this.slides.length - 1, this.selectedIndex ); 658 659 this.emitEvent( 'cellChange', [ changedCellIndex ] ); 660 // position slider 661 this.select( this.selectedIndex ); 662 // do not position slider after lazy load 663 if ( isPositioningSlider ) { 664 this.positionSliderAtSelected(); 665 } 666}; 667 668// ----- ----- // 669 670return Flickity; 671 672})); 673 674 675/***/ }), 676
vendor: 5,646 bytes, lines 677-876
677/***/ "./node_modules/flickity/js/animate.js": 678/*!*********************************************!*\ 679 !*** ./node_modules/flickity/js/animate.js ***! 680 \*********************************************/ 681/*! no static exports found */ 682/***/ (function(module, exports, __webpack_require__) { 683 684var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// animate 685( function( window, factory ) { 686 // universal module definition 687 /* jshint strict: false */ 688 if ( true ) { 689 // AMD 690 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 691 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js") 692 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( utils ) { 693 return factory( window, utils ); 694 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 695 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 696 } else {} 697 698}( window, function factory( window, utils ) { 699 700'use strict'; 701 702// -------------------------- animate -------------------------- // 703 704var proto = {}; 705 706proto.startAnimation = function() { 707 if ( this.isAnimating ) { 708 return; 709 } 710 711 this.isAnimating = true; 712 this.restingFrames = 0; 713 this.animate(); 714}; 715 716proto.animate = function() { 717 this.applyDragForce(); 718 this.applySelectedAttraction(); 719 720 var previousX = this.x; 721 722 this.integratePhysics(); 723 this.positionSlider(); 724 this.settle( previousX ); 725 // animate next frame 726 if ( this.isAnimating ) { 727 var _this = this; 728 requestAnimationFrame( function animateFrame() { 729 _this.animate(); 730 }); 731 } 732}; 733 734proto.positionSlider = function() { 735 var x = this.x; 736 // wrap position around 737 if ( this.options.wrapAround && this.cells.length > 1 ) { 738 x = utils.modulo( x, this.slideableWidth ); 739 x = x - this.slideableWidth; 740 this.shiftWrapCells( x ); 741 } 742 743 this.setTranslateX( x, this.isAnimating ); 744 this.dispatchScrollEvent(); 745}; 746 747proto.setTranslateX = function( x, is3d ) { 748 x += this.cursorPosition; 749 // reverse if right-to-left and using transform 750 x = this.options.rightToLeft ? -x : x; 751 var translateX = this.getPositionValue( x ); 752 // use 3D tranforms for hardware acceleration on iOS 753 // but use 2D when settled, for better font-rendering 754 this.slider.style.transform = is3d ? 755 'translate3d(' + translateX + ',0,0)' : 'translateX(' + translateX + ')'; 756}; 757 758proto.dispatchScrollEvent = function() { 759 var firstSlide = this.slides[0]; 760 if ( !firstSlide ) { 761 return; 762 } 763 var positionX = -this.x - firstSlide.target; 764 var progress = positionX / this.slidesWidth; 765 this.dispatchEvent( 'scroll', null, [ progress, positionX ] ); 766}; 767 768proto.positionSliderAtSelected = function() { 769 if ( !this.cells.length ) { 770 return; 771 } 772 this.x = -this.selectedSlide.target; 773 this.velocity = 0; // stop wobble 774 this.positionSlider(); 775}; 776 777proto.getPositionValue = function( position ) { 778 if ( this.options.percentPosition ) { 779 // percent position, round to 2 digits, like 12.34% 780 return ( Math.round( ( position / this.size.innerWidth ) * 10000 ) * 0.01 )+ '%'; 781 } else { 782 // pixel positioning 783 return Math.round( position ) + 'px'; 784 } 785}; 786 787proto.settle = function( previousX ) { 788 // keep track of frames where x hasn't moved 789 if ( !this.isPointerDown && Math.round( this.x * 100 ) == Math.round( previousX * 100 ) ) { 790 this.restingFrames++; 791 } 792 // stop animating if resting for 3 or more frames 793 if ( this.restingFrames > 2 ) { 794 this.isAnimating = false; 795 delete this.isFreeScrolling; 796 // render position with translateX when settled 797 this.positionSlider(); 798 this.dispatchEvent( 'settle', null, [ this.selectedIndex ] ); 799 } 800}; 801 802proto.shiftWrapCells = function( x ) { 803 // shift before cells 804 var beforeGap = this.cursorPosition + x; 805 this._shiftCells( this.beforeShiftCells, beforeGap, -1 ); 806 // shift after cells 807 var afterGap = this.size.innerWidth - ( x + this.slideableWidth + this.cursorPosition ); 808 this._shiftCells( this.afterShiftCells, afterGap, 1 ); 809}; 810 811proto._shiftCells = function( cells, gap, shift ) { 812 for ( var i=0; i < cells.length; i++ ) { 813 var cell = cells[i]; 814 var cellShift = gap > 0 ? shift : 0; 815 cell.wrapShift( cellShift ); 816 gap -= cell.size.outerWidth; 817 } 818}; 819 820proto._unshiftCells = function( cells ) { 821 if ( !cells || !cells.length ) { 822 return; 823 } 824 for ( var i=0; i < cells.length; i++ ) { 825 cells[i].wrapShift( 0 ); 826 } 827}; 828 829// -------------------------- physics -------------------------- // 830 831proto.integratePhysics = function() { 832 this.x += this.velocity; 833 this.velocity *= this.getFrictionFactor(); 834}; 835 836proto.applyForce = function( force ) { 837 this.velocity += force; 838}; 839 840proto.getFrictionFactor = function() { 841 return 1 - this.options[ this.isFreeScrolling ? 'freeScrollFriction' : 'friction' ]; 842}; 843 844proto.getRestingPosition = function() { 845 // my thanks to Steven Wittens, who simplified this math greatly 846 return this.x + this.velocity / ( 1 - this.getFrictionFactor() ); 847}; 848 849proto.applyDragForce = function() { 850 if ( !this.isDraggable || !this.isPointerDown ) { 851 return; 852 } 853 // change the position to drag position by applying force 854 var dragVelocity = this.dragX - this.x; 855 var dragForce = dragVelocity - this.velocity; 856 this.applyForce( dragForce ); 857}; 858 859proto.applySelectedAttraction = function() { 860 // do not attract if pointer down or no slides 861 var dragDown = this.isDraggable && this.isPointerDown; 862 if ( dragDown || this.isFreeScrolling || !this.slides.length ) { 863 return; 864 } 865 var distance = this.selectedSlide.target * -1 - this.x; 866 var force = distance * this.options.selectedAttraction; 867 this.applyForce( force ); 868}; 869 870return proto; 871 872})); 873 874 875/***/ }), 876
vendor: 2,659 bytes, lines 877-977
877/***/ "./node_modules/flickity/js/cell.js": 878/*!******************************************!*\ 879 !*** ./node_modules/flickity/js/cell.js ***! 880 \******************************************/ 881/*! no static exports found */ 882/***/ (function(module, exports, __webpack_require__) { 883 884var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// Flickity.Cell 885( function( window, factory ) { 886 // universal module definition 887 /* jshint strict: false */ 888 if ( true ) { 889 // AMD 890 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 891 __webpack_require__(/*! get-size/get-size */ "./node_modules/get-size/get-size.js") 892 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( getSize ) { 893 return factory( window, getSize ); 894 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 895 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 896 } else {} 897 898}( window, function factory( window, getSize ) { 899 900'use strict'; 901 902function Cell( elem, parent ) { 903 this.element = elem; 904 this.parent = parent; 905 906 this.create(); 907} 908 909var proto = Cell.prototype; 910 911proto.create = function() { 912 this.element.style.position = 'absolute'; 913 this.element.setAttribute( 'aria-hidden', 'true' ); 914 this.x = 0; 915 this.shift = 0; 916}; 917 918proto.destroy = function() { 919 // reset style 920 this.unselect(); 921 this.element.style.position = ''; 922 var side = this.parent.originSide; 923 this.element.style[ side ] = ''; 924}; 925 926proto.getSize = function() { 927 this.size = getSize( this.element ); 928}; 929 930proto.setPosition = function( x ) { 931 this.x = x; 932 this.updateTarget(); 933 this.renderPosition( x ); 934}; 935 936// setDefaultTarget v1 method, backwards compatibility, remove in v3 937proto.updateTarget = proto.setDefaultTarget = function() { 938 var marginProperty = this.parent.originSide == 'left' ? 'marginLeft' : 'marginRight'; 939 this.target = this.x + this.size[ marginProperty ] + 940 this.size.width * this.parent.cellAlign; 941}; 942 943proto.renderPosition = function( x ) { 944 // render position of cell with in slider 945 var side = this.parent.originSide; 946 this.element.style[ side ] = this.parent.getPositionValue( x ); 947}; 948 949proto.select = function() { 950 this.element.classList.add('is-selected'); 951 this.element.removeAttribute('aria-hidden'); 952}; 953 954proto.unselect = function() { 955 this.element.classList.remove('is-selected'); 956 this.element.setAttribute( 'aria-hidden', 'true' ); 957}; 958 959/** 960 * @param {Integer} factor - 0, 1, or -1 961**/ 962proto.wrapShift = function( shift ) { 963 this.shift = shift; 964 this.renderPosition( this.x + this.parent.slideableWidth * shift ); 965}; 966 967proto.remove = function() { 968 this.element.parentNode.removeChild( this.element ); 969}; 970 971return Cell; 972 973})); 974 975 976/***/ }), 977
vendor: 11,948 bytes, lines 978-1366
978/***/ "./node_modules/flickity/js/drag.js": 979/*!******************************************!*\ 980 !*** ./node_modules/flickity/js/drag.js ***! 981 \******************************************/ 982/*! no static exports found */ 983/***/ (function(module, exports, __webpack_require__) { 984 985var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// drag 986( function( window, factory ) { 987 // universal module definition 988 /* jshint strict: false */ 989 if ( true ) { 990 // AMD 991 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 992 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js"), 993 __webpack_require__(/*! unidragger/unidragger */ "./node_modules/unidragger/unidragger.js"), 994 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js") 995 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Flickity, Unidragger, utils ) { 996 return factory( window, Flickity, Unidragger, utils ); 997 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 998 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 999 } else {} 1000 1001}( window, function factory( window, Flickity, Unidragger, utils ) { 1002 1003'use strict'; 1004 1005// ----- defaults ----- // 1006 1007utils.extend( Flickity.defaults, { 1008 draggable: '>1', 1009 dragThreshold: 3, 1010}); 1011 1012// ----- create ----- // 1013 1014Flickity.createMethods.push('_createDrag'); 1015 1016// -------------------------- drag prototype -------------------------- // 1017 1018var proto = Flickity.prototype; 1019utils.extend( proto, Unidragger.prototype ); 1020proto._touchActionValue = 'pan-y'; 1021 1022// -------------------------- -------------------------- // 1023 1024var isTouch = 'createTouch' in document; 1025var isTouchmoveScrollCanceled = false; 1026 1027proto._createDrag = function() { 1028 this.on( 'activate', this.onActivateDrag ); 1029 this.on( 'uiChange', this._uiChangeDrag ); 1030 this.on( 'deactivate', this.onDeactivateDrag ); 1031 this.on( 'cellChange', this.updateDraggable ); 1032 // TODO updateDraggable on resize? if groupCells & slides change 1033 // HACK - add seemingly innocuous handler to fix iOS 10 scroll behavior 1034 // #457, RubaXa/Sortable#973 1035 if ( isTouch && !isTouchmoveScrollCanceled ) { 1036 window.addEventListener( 'touchmove', function() {}); 1037 isTouchmoveScrollCanceled = true; 1038 } 1039}; 1040 1041proto.onActivateDrag = function() { 1042 this.handles = [ this.viewport ]; 1043 this.bindHandles(); 1044 this.updateDraggable(); 1045}; 1046 1047proto.onDeactivateDrag = function() { 1048 this.unbindHandles(); 1049 this.element.classList.remove('is-draggable'); 1050}; 1051 1052proto.updateDraggable = function() { 1053 // disable dragging if less than 2 slides. #278 1054 if ( this.options.draggable == '>1' ) { 1055 this.isDraggable = this.slides.length > 1; 1056 } else { 1057 this.isDraggable = this.options.draggable; 1058 } 1059 if ( this.isDraggable ) { 1060 this.element.classList.add('is-draggable'); 1061 } else { 1062 this.element.classList.remove('is-draggable'); 1063 } 1064}; 1065 1066// backwards compatibility 1067proto.bindDrag = function() { 1068 this.options.draggable = true; 1069 this.updateDraggable(); 1070}; 1071 1072proto.unbindDrag = function() { 1073 this.options.draggable = false; 1074 this.updateDraggable(); 1075}; 1076 1077proto._uiChangeDrag = function() { 1078 delete this.isFreeScrolling; 1079}; 1080 1081// -------------------------- pointer events -------------------------- // 1082 1083proto.pointerDown = function( event, pointer ) { 1084 if ( !this.isDraggable ) { 1085 this._pointerDownDefault( event, pointer ); 1086 return; 1087 } 1088 var isOkay = this.okayPointerDown( event ); 1089 if ( !isOkay ) { 1090 return; 1091 } 1092 1093 this._pointerDownPreventDefault( event ); 1094 this.pointerDownFocus( event ); 1095 // blur 1096 if ( document.activeElement != this.element ) { 1097 // do not blur if already focused 1098 this.pointerDownBlur(); 1099 } 1100 1101 // stop if it was moving 1102 this.dragX = this.x; 1103 this.viewport.classList.add('is-pointer-down'); 1104 // track scrolling 1105 this.pointerDownScroll = getScrollPosition(); 1106 window.addEventListener( 'scroll', this ); 1107 1108 this._pointerDownDefault( event, pointer ); 1109}; 1110 1111// default pointerDown logic, used for staticClick 1112proto._pointerDownDefault = function( event, pointer ) { 1113 // track start event position 1114 // Safari 9 overrides pageX and pageY. These values needs to be copied. #779 1115 this.pointerDownPointer = { 1116 pageX: pointer.pageX, 1117 pageY: pointer.pageY, 1118 }; 1119 // bind move and end events 1120 this._bindPostStartEvents( event ); 1121 this.dispatchEvent( 'pointerDown', event, [ pointer ] ); 1122}; 1123 1124var focusNodes = { 1125 INPUT: true, 1126 TEXTAREA: true, 1127 SELECT: true, 1128}; 1129 1130proto.pointerDownFocus = function( event ) { 1131 var isFocusNode = focusNodes[ event.target.nodeName ]; 1132 if ( !isFocusNode ) { 1133 this.focus(); 1134 } 1135}; 1136 1137proto._pointerDownPreventDefault = function( event ) { 1138 var isTouchStart = event.type == 'touchstart'; 1139 var isTouchPointer = event.pointerType == 'touch'; 1140 var isFocusNode = focusNodes[ event.target.nodeName ]; 1141 if ( !isTouchStart && !isTouchPointer && !isFocusNode ) { 1142 event.preventDefault(); 1143 } 1144}; 1145 1146// ----- move ----- // 1147 1148proto.hasDragStarted = function( moveVector ) { 1149 return Math.abs( moveVector.x ) > this.options.dragThreshold; 1150}; 1151 1152// ----- up ----- // 1153 1154proto.pointerUp = function( event, pointer ) { 1155 delete this.isTouchScrolling; 1156 this.viewport.classList.remove('is-pointer-down'); 1157 this.dispatchEvent( 'pointerUp', event, [ pointer ] ); 1158 this._dragPointerUp( event, pointer ); 1159}; 1160 1161proto.pointerDone = function() { 1162 window.removeEventListener( 'scroll', this ); 1163 delete this.pointerDownScroll; 1164}; 1165 1166// -------------------------- dragging -------------------------- // 1167 1168proto.dragStart = function( event, pointer ) { 1169 if ( !this.isDraggable ) { 1170 return; 1171 } 1172 this.dragStartPosition = this.x; 1173 this.startAnimation(); 1174 window.removeEventListener( 'scroll', this ); 1175 this.dispatchEvent( 'dragStart', event, [ pointer ] ); 1176}; 1177 1178proto.pointerMove = function( event, pointer ) { 1179 var moveVector = this._dragPointerMove( event, pointer ); 1180 this.dispatchEvent( 'pointerMove', event, [ pointer, moveVector ] ); 1181 this._dragMove( event, pointer, moveVector ); 1182}; 1183 1184proto.dragMove = function( event, pointer, moveVector ) { 1185 if ( !this.isDraggable ) { 1186 return; 1187 } 1188 event.preventDefault(); 1189 1190 this.previousDragX = this.dragX; 1191 // reverse if right-to-left 1192 var direction = this.options.rightToLeft ? -1 : 1; 1193 if ( this.options.wrapAround ) { 1194 // wrap around move. #589 1195 moveVector.x = moveVector.x % this.slideableWidth; 1196 } 1197 var dragX = this.dragStartPosition + moveVector.x * direction; 1198 1199 if ( !this.options.wrapAround && this.slides.length ) { 1200 // slow drag 1201 var originBound = Math.max( -this.slides[0].target, this.dragStartPosition ); 1202 dragX = dragX > originBound ? ( dragX + originBound ) * 0.5 : dragX; 1203 var endBound = Math.min( -this.getLastSlide().target, this.dragStartPosition ); 1204 dragX = dragX < endBound ? ( dragX + endBound ) * 0.5 : dragX; 1205 } 1206 1207 this.dragX = dragX; 1208 1209 this.dragMoveTime = new Date(); 1210 this.dispatchEvent( 'dragMove', event, [ pointer, moveVector ] ); 1211}; 1212 1213proto.dragEnd = function( event, pointer ) { 1214 if ( !this.isDraggable ) { 1215 return; 1216 } 1217 if ( this.options.freeScroll ) { 1218 this.isFreeScrolling = true; 1219 } 1220 // set selectedIndex based on where flick will end up 1221 var index = this.dragEndRestingSelect(); 1222 1223 if ( this.options.freeScroll && !this.options.wrapAround ) { 1224 // if free-scroll & not wrap around 1225 // do not free-scroll if going outside of bounding slides 1226 // so bounding slides can attract slider, and keep it in bounds 1227 var restingX = this.getRestingPosition(); 1228 this.isFreeScrolling = -restingX > this.slides[0].target && 1229 -restingX < this.getLastSlide().target; 1230 } else if ( !this.options.freeScroll && index == this.selectedIndex ) { 1231 // boost selection if selected index has not changed 1232 index += this.dragEndBoostSelect(); 1233 } 1234 delete this.previousDragX; 1235 // apply selection 1236 // TODO refactor this, selecting here feels weird 1237 // HACK, set flag so dragging stays in correct direction 1238 this.isDragSelect = this.options.wrapAround; 1239 this.select( index ); 1240 delete this.isDragSelect; 1241 this.dispatchEvent( 'dragEnd', event, [ pointer ] ); 1242}; 1243 1244proto.dragEndRestingSelect = function() { 1245 var restingX = this.getRestingPosition(); 1246 // how far away from selected slide 1247 var distance = Math.abs( this.getSlideDistance( -restingX, this.selectedIndex ) ); 1248 // get closet resting going up and going down 1249 var positiveResting = this._getClosestResting( restingX, distance, 1 ); 1250 var negativeResting = this._getClosestResting( restingX, distance, -1 ); 1251 // use closer resting for wrap-around 1252 var index = positiveResting.distance < negativeResting.distance ? 1253 positiveResting.index : negativeResting.index; 1254 return index; 1255}; 1256 1257/** 1258 * given resting X and distance to selected cell 1259 * get the distance and index of the closest cell 1260 * @param {Number} restingX - estimated post-flick resting position 1261 * @param {Number} distance - distance to selected cell 1262 * @param {Integer} increment - +1 or -1, going up or down 1263 * @returns {Object} - { distance: {Number}, index: {Integer} } 1264 */ 1265proto._getClosestResting = function( restingX, distance, increment ) { 1266 var index = this.selectedIndex; 1267 var minDistance = Infinity; 1268 var condition = this.options.contain && !this.options.wrapAround ? 1269 // if contain, keep going if distance is equal to minDistance 1270 function( d, md ) { return d <= md; } : function( d, md ) { return d < md; }; 1271 while ( condition( distance, minDistance ) ) { 1272 // measure distance to next cell 1273 index += increment; 1274 minDistance = distance; 1275 distance = this.getSlideDistance( -restingX, index ); 1276 if ( distance === null ) { 1277 break; 1278 } 1279 distance = Math.abs( distance ); 1280 } 1281 return { 1282 distance: minDistance, 1283 // selected was previous index 1284 index: index - increment 1285 }; 1286}; 1287 1288/** 1289 * measure distance between x and a slide target 1290 * @param {Number} x 1291 * @param {Integer} index - slide index 1292 */ 1293proto.getSlideDistance = function( x, index ) { 1294 var len = this.slides.length; 1295 // wrap around if at least 2 slides 1296 var isWrapAround = this.options.wrapAround && len > 1; 1297 var slideIndex = isWrapAround ? utils.modulo( index, len ) : index; 1298 var slide = this.slides[ slideIndex ]; 1299 if ( !slide ) { 1300 return null; 1301 } 1302 // add distance for wrap-around slides 1303 var wrap = isWrapAround ? this.slideableWidth * Math.floor( index / len ) : 0; 1304 return x - ( slide.target + wrap ); 1305}; 1306 1307proto.dragEndBoostSelect = function() { 1308 // do not boost if no previousDragX or dragMoveTime 1309 if ( this.previousDragX === undefined || !this.dragMoveTime || 1310 // or if drag was held for 100 ms 1311 new Date() - this.dragMoveTime > 100 ) { 1312 return 0; 1313 } 1314 1315 var distance = this.getSlideDistance( -this.dragX, this.selectedIndex ); 1316 var delta = this.previousDragX - this.dragX; 1317 if ( distance > 0 && delta > 0 ) { 1318 // boost to next if moving towards the right, and positive velocity 1319 return 1; 1320 } else if ( distance < 0 && delta < 0 ) { 1321 // boost to previous if moving towards the left, and negative velocity 1322 return -1; 1323 } 1324 return 0; 1325}; 1326 1327// ----- staticClick ----- // 1328 1329proto.staticClick = function( event, pointer ) { 1330 // get clickedCell, if cell was clicked 1331 var clickedCell = this.getParentCell( event.target ); 1332 var cellElem = clickedCell && clickedCell.element; 1333 var cellIndex = clickedCell && this.cells.indexOf( clickedCell ); 1334 this.dispatchEvent( 'staticClick', event, [ pointer, cellElem, cellIndex ] ); 1335}; 1336 1337// ----- scroll ----- // 1338 1339proto.onscroll = function() { 1340 var scroll = getScrollPosition(); 1341 var scrollMoveX = this.pointerDownScroll.x - scroll.x; 1342 var scrollMoveY = this.pointerDownScroll.y - scroll.y; 1343 // cancel click/tap if scroll is too much 1344 if ( Math.abs( scrollMoveX ) > 3 || Math.abs( scrollMoveY ) > 3 ) { 1345 this._pointerDone(); 1346 } 1347}; 1348 1349// ----- utils ----- // 1350 1351function getScrollPosition() { 1352 return { 1353 x: window.pageXOffset, 1354 y: window.pageYOffset 1355 }; 1356} 1357 1358// ----- ----- // 1359 1360return Flickity; 1361 1362})); 1363 1364 1365/***/ }), 1366
vendor: 25,088 bytes, lines 1367-2283
1367/***/ "./node_modules/flickity/js/flickity.js": 1368/*!**********************************************!*\ 1369 !*** ./node_modules/flickity/js/flickity.js ***! 1370 \**********************************************/ 1371/*! no static exports found */ 1372/***/ (function(module, exports, __webpack_require__) { 1373 1374var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// Flickity main 1375( function( window, factory ) { 1376 // universal module definition 1377 /* jshint strict: false */ 1378 if ( true ) { 1379 // AMD 1380 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 1381 __webpack_require__(/*! ev-emitter/ev-emitter */ "./node_modules/ev-emitter/ev-emitter.js"), 1382 __webpack_require__(/*! get-size/get-size */ "./node_modules/get-size/get-size.js"), 1383 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js"), 1384 __webpack_require__(/*! ./cell */ "./node_modules/flickity/js/cell.js"), 1385 __webpack_require__(/*! ./slide */ "./node_modules/flickity/js/slide.js"), 1386 __webpack_require__(/*! ./animate */ "./node_modules/flickity/js/animate.js") 1387 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( EvEmitter, getSize, utils, Cell, Slide, animatePrototype ) { 1388 return factory( window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype ); 1389 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 1390 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 1391 } else { var _Flickity; } 1392 1393}( window, function factory( window, EvEmitter, getSize, 1394 utils, Cell, Slide, animatePrototype ) { 1395 1396'use strict'; 1397 1398// vars 1399var jQuery = window.jQuery; 1400var getComputedStyle = window.getComputedStyle; 1401var console = window.console; 1402 1403function moveElements( elems, toElem ) { 1404 elems = utils.makeArray( elems ); 1405 while ( elems.length ) { 1406 toElem.appendChild( elems.shift() ); 1407 } 1408} 1409 1410// -------------------------- Flickity -------------------------- // 1411 1412// globally unique identifiers 1413var GUID = 0; 1414// internal store of all Flickity intances 1415var instances = {}; 1416 1417function Flickity( element, options ) { 1418 var queryElement = utils.getQueryElement( element ); 1419 if ( !queryElement ) { 1420 if ( console ) { 1421 console.error( 'Bad element for Flickity: ' + ( queryElement || element ) ); 1422 } 1423 return; 1424 } 1425 this.element = queryElement; 1426 // do not initialize twice on same element 1427 if ( this.element.flickityGUID ) { 1428 var instance = instances[ this.element.flickityGUID ]; 1429 instance.option( options ); 1430 return instance; 1431 } 1432 1433 // add jQuery 1434 if ( jQuery ) { 1435 this.$element = jQuery( this.element ); 1436 } 1437 // options 1438 this.options = utils.extend( {}, this.constructor.defaults ); 1439 this.option( options ); 1440 1441 // kick things off 1442 this._create(); 1443} 1444 1445Flickity.defaults = { 1446 accessibility: true, 1447 // adaptiveHeight: false, 1448 cellAlign: 'center', 1449 // cellSelector: undefined, 1450 // contain: false, 1451 freeScrollFriction: 0.075, // friction when free-scrolling 1452 friction: 0.28, // friction when selecting 1453 namespaceJQueryEvents: true, 1454 // initialIndex: 0, 1455 percentPosition: true, 1456 resize: true, 1457 selectedAttraction: 0.025, 1458 setGallerySize: true 1459 // watchCSS: false, 1460 // wrapAround: false 1461}; 1462 1463// hash of methods triggered on _create() 1464Flickity.createMethods = []; 1465 1466var proto = Flickity.prototype; 1467// inherit EventEmitter 1468utils.extend( proto, EvEmitter.prototype ); 1469 1470proto._create = function() { 1471 // add id for Flickity.data 1472 var id = this.guid = ++GUID; 1473 this.element.flickityGUID = id; // expando 1474 instances[ id ] = this; // associate via id 1475 // initial properties 1476 this.selectedIndex = 0; 1477 // how many frames slider has been in same position 1478 this.restingFrames = 0; 1479 // initial physics properties 1480 this.x = 0; 1481 this.velocity = 0; 1482 this.originSide = this.options.rightToLeft ? 'right' : 'left'; 1483 // create viewport & slider 1484 this.viewport = document.createElement('div'); 1485 this.viewport.className = 'flickity-viewport'; 1486 this._createSlider(); 1487 1488 if ( this.options.resize || this.options.watchCSS ) { 1489 window.addEventListener( 'resize', this ); 1490 } 1491 1492 // add listeners from on option 1493 for ( var eventName in this.options.on ) { 1494 var listener = this.options.on[ eventName ]; 1495 this.on( eventName, listener ); 1496 } 1497 1498 Flickity.createMethods.forEach( function( method ) { 1499 this[ method ](); 1500 }, this ); 1501 1502 if ( this.options.watchCSS ) { 1503 this.watchCSS(); 1504 } else { 1505 this.activate(); 1506 } 1507 1508}; 1509 1510/** 1511 * set options 1512 * @param {Object} opts 1513 */ 1514proto.option = function( opts ) { 1515 utils.extend( this.options, opts ); 1516}; 1517 1518proto.activate = function() { 1519 if ( this.isActive ) { 1520 return; 1521 } 1522 this.isActive = true; 1523 this.element.classList.add('flickity-enabled'); 1524 if ( this.options.rightToLeft ) { 1525 this.element.classList.add('flickity-rtl'); 1526 } 1527 1528 this.getSize(); 1529 // move initial cell elements so they can be loaded as cells 1530 var cellElems = this._filterFindCellElements( this.element.children ); 1531 moveElements( cellElems, this.slider ); 1532 this.viewport.appendChild( this.slider ); 1533 this.element.appendChild( this.viewport ); 1534 // get cells from children 1535 this.reloadCells(); 1536 1537 if ( this.options.accessibility ) { 1538 // allow element to focusable 1539 this.element.tabIndex = 0; 1540 // listen for key presses 1541 this.element.addEventListener( 'keydown', this ); 1542 } 1543 1544 this.emitEvent('activate'); 1545 this.selectInitialIndex(); 1546 // flag for initial activation, for using initialIndex 1547 this.isInitActivated = true; 1548 // ready event. #493 1549 this.dispatchEvent('ready'); 1550}; 1551 1552// slider positions the cells 1553proto._createSlider = function() { 1554 // slider element does all the positioning 1555 var slider = document.createElement('div'); 1556 slider.className = 'flickity-slider'; 1557 slider.style[ this.originSide ] = 0; 1558 this.slider = slider; 1559}; 1560 1561proto._filterFindCellElements = function( elems ) { 1562 return utils.filterFindElements( elems, this.options.cellSelector ); 1563}; 1564 1565// goes through all children 1566proto.reloadCells = function() { 1567 // collection of item elements 1568 this.cells = this._makeCells( this.slider.children ); 1569 this.positionCells(); 1570 this._getWrapShiftCells(); 1571 this.setGallerySize(); 1572}; 1573 1574/** 1575 * turn elements into Flickity.Cells 1576 * @param {Array or NodeList or HTMLElement} elems 1577 * @returns {Array} items - collection of new Flickity Cells 1578 */ 1579proto._makeCells = function( elems ) { 1580 var cellElems = this._filterFindCellElements( elems ); 1581 1582 // create new Flickity for collection 1583 var cells = cellElems.map( function( cellElem ) { 1584 return new Cell( cellElem, this ); 1585 }, this ); 1586 1587 return cells; 1588}; 1589 1590proto.getLastCell = function() { 1591 return this.cells[ this.cells.length - 1 ]; 1592}; 1593 1594proto.getLastSlide = function() { 1595 return this.slides[ this.slides.length - 1 ]; 1596}; 1597 1598// positions all cells 1599proto.positionCells = function() { 1600 // size all cells 1601 this._sizeCells( this.cells ); 1602 // position all cells 1603 this._positionCells( 0 ); 1604}; 1605 1606/** 1607 * position certain cells 1608 * @param {Integer} index - which cell to start with 1609 */ 1610proto._positionCells = function( index ) { 1611 index = index || 0; 1612 // also measure maxCellHeight 1613 // start 0 if positioning all cells 1614 this.maxCellHeight = index ? this.maxCellHeight || 0 : 0; 1615 var cellX = 0; 1616 // get cellX 1617 if ( index > 0 ) { 1618 var startCell = this.cells[ index - 1 ]; 1619 cellX = startCell.x + startCell.size.outerWidth; 1620 } 1621 var len = this.cells.length; 1622 for ( var i=index; i < len; i++ ) { 1623 var cell = this.cells[i]; 1624 cell.setPosition( cellX ); 1625 cellX += cell.size.outerWidth; 1626 this.maxCellHeight = Math.max( cell.size.outerHeight, this.maxCellHeight ); 1627 } 1628 // keep track of cellX for wrap-around 1629 this.slideableWidth = cellX; 1630 // slides 1631 this.updateSlides(); 1632 // contain slides target 1633 this._containSlides(); 1634 // update slidesWidth 1635 this.slidesWidth = len ? this.getLastSlide().target - this.slides[0].target : 0; 1636}; 1637 1638/** 1639 * cell.getSize() on multiple cells 1640 * @param {Array} cells 1641 */ 1642proto._sizeCells = function( cells ) { 1643 cells.forEach( function( cell ) { 1644 cell.getSize(); 1645 }); 1646}; 1647 1648// -------------------------- -------------------------- // 1649 1650proto.updateSlides = function() { 1651 this.slides = []; 1652 if ( !this.cells.length ) { 1653 return; 1654 } 1655 1656 var slide = new Slide( this ); 1657 this.slides.push( slide ); 1658 var isOriginLeft = this.originSide == 'left'; 1659 var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft'; 1660 1661 var canCellFit = this._getCanCellFit(); 1662 1663 this.cells.forEach( function( cell, i ) { 1664 // just add cell if first cell in slide 1665 if ( !slide.cells.length ) { 1666 slide.addCell( cell ); 1667 return; 1668 } 1669 1670 var slideWidth = ( slide.outerWidth - slide.firstMargin ) + 1671 ( cell.size.outerWidth - cell.size[ nextMargin ] ); 1672 1673 if ( canCellFit.call( this, i, slideWidth ) ) { 1674 slide.addCell( cell ); 1675 } else { 1676 // doesn't fit, new slide 1677 slide.updateTarget(); 1678 1679 slide = new Slide( this ); 1680 this.slides.push( slide ); 1681 slide.addCell( cell ); 1682 } 1683 }, this ); 1684 // last slide 1685 slide.updateTarget(); 1686 // update .selectedSlide 1687 this.updateSelectedSlide(); 1688}; 1689 1690proto._getCanCellFit = function() { 1691 var groupCells = this.options.groupCells; 1692 if ( !groupCells ) { 1693 return function() { 1694 return false; 1695 }; 1696 } else if ( typeof groupCells == 'number' ) { 1697 // group by number. 3 -> [0,1,2], [3,4,5], ... 1698 var number = parseInt( groupCells, 10 ); 1699 return function( i ) { 1700 return ( i % number ) !== 0; 1701 }; 1702 } 1703 // default, group by width of slide 1704 // parse '75% 1705 var percentMatch = typeof groupCells == 'string' && 1706 groupCells.match(/^(\d+)%$/); 1707 var percent = percentMatch ? parseInt( percentMatch[1], 10 ) / 100 : 1; 1708 return function( i, slideWidth ) { 1709 return slideWidth <= ( this.size.innerWidth + 1 ) * percent; 1710 }; 1711}; 1712 1713// alias _init for jQuery plugin .flickity() 1714proto._init = 1715proto.reposition = function() { 1716 this.positionCells(); 1717 this.positionSliderAtSelected(); 1718}; 1719 1720proto.getSize = function() { 1721 this.size = getSize( this.element ); 1722 this.setCellAlign(); 1723 this.cursorPosition = this.size.innerWidth * this.cellAlign; 1724}; 1725 1726var cellAlignShorthands = { 1727 // cell align, then based on origin side 1728 center: { 1729 left: 0.5, 1730 right: 0.5 1731 }, 1732 left: { 1733 left: 0, 1734 right: 1 1735 }, 1736 right: { 1737 right: 0, 1738 left: 1 1739 } 1740}; 1741 1742proto.setCellAlign = function() { 1743 var shorthand = cellAlignShorthands[ this.options.cellAlign ]; 1744 this.cellAlign = shorthand ? shorthand[ this.originSide ] : this.options.cellAlign; 1745}; 1746 1747proto.setGallerySize = function() { 1748 if ( this.options.setGallerySize ) { 1749 var height = this.options.adaptiveHeight && this.selectedSlide ? 1750 this.selectedSlide.height : this.maxCellHeight; 1751 this.viewport.style.height = height + 'px'; 1752 } 1753}; 1754 1755proto._getWrapShiftCells = function() { 1756 // only for wrap-around 1757 if ( !this.options.wrapAround ) { 1758 return; 1759 } 1760 // unshift previous cells 1761 this._unshiftCells( this.beforeShiftCells ); 1762 this._unshiftCells( this.afterShiftCells ); 1763 // get before cells 1764 // initial gap 1765 var gapX = this.cursorPosition; 1766 var cellIndex = this.cells.length - 1; 1767 this.beforeShiftCells = this._getGapCells( gapX, cellIndex, -1 ); 1768 // get after cells 1769 // ending gap between last cell and end of gallery viewport 1770 gapX = this.size.innerWidth - this.cursorPosition; 1771 // start cloning at first cell, working forwards 1772 this.afterShiftCells = this._getGapCells( gapX, 0, 1 ); 1773}; 1774 1775proto._getGapCells = function( gapX, cellIndex, increment ) { 1776 // keep adding cells until the cover the initial gap 1777 var cells = []; 1778 while ( gapX > 0 ) { 1779 var cell = this.cells[ cellIndex ]; 1780 if ( !cell ) { 1781 break; 1782 } 1783 cells.push( cell ); 1784 cellIndex += increment; 1785 gapX -= cell.size.outerWidth; 1786 } 1787 return cells; 1788}; 1789 1790// ----- contain ----- // 1791 1792// contain cell targets so no excess sliding 1793proto._containSlides = function() { 1794 if ( !this.options.contain || this.options.wrapAround || !this.cells.length ) { 1795 return; 1796 } 1797 var isRightToLeft = this.options.rightToLeft; 1798 var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft'; 1799 var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight'; 1800 var contentWidth = this.slideableWidth - this.getLastCell().size[ endMargin ]; 1801 // content is less than gallery size 1802 var isContentSmaller = contentWidth < this.size.innerWidth; 1803 // bounds 1804 var beginBound = this.cursorPosition + this.cells[0].size[ beginMargin ]; 1805 var endBound = contentWidth - this.size.innerWidth * ( 1 - this.cellAlign ); 1806 // contain each cell target 1807 this.slides.forEach( function( slide ) { 1808 if ( isContentSmaller ) { 1809 // all cells fit inside gallery 1810 slide.target = contentWidth * this.cellAlign; 1811 } else { 1812 // contain to bounds 1813 slide.target = Math.max( slide.target, beginBound ); 1814 slide.target = Math.min( slide.target, endBound ); 1815 } 1816 }, this ); 1817}; 1818 1819// ----- ----- // 1820 1821/** 1822 * emits events via eventEmitter and jQuery events 1823 * @param {String} type - name of event 1824 * @param {Event} event - original event 1825 * @param {Array} args - extra arguments 1826 */ 1827proto.dispatchEvent = function( type, event, args ) { 1828 var emitArgs = event ? [ event ].concat( args ) : args; 1829 this.emitEvent( type, emitArgs ); 1830 1831 if ( jQuery && this.$element ) { 1832 // default trigger with type if no event 1833 type += this.options.namespaceJQueryEvents ? '.flickity' : ''; 1834 var $event = type; 1835 if ( event ) { 1836 // create jQuery event 1837 var jQEvent = jQuery.Event( event ); 1838 jQEvent.type = type; 1839 $event = jQEvent; 1840 } 1841 this.$element.trigger( $event, args ); 1842 } 1843}; 1844 1845// -------------------------- select -------------------------- // 1846 1847/** 1848 * @param {Integer} index - index of the slide 1849 * @param {Boolean} isWrap - will wrap-around to last/first if at the end 1850 * @param {Boolean} isInstant - will immediately set position at selected cell 1851 */ 1852proto.select = function( index, isWrap, isInstant ) { 1853 if ( !this.isActive ) { 1854 return; 1855 } 1856 index = parseInt( index, 10 ); 1857 this._wrapSelect( index ); 1858 1859 if ( this.options.wrapAround || isWrap ) { 1860 index = utils.modulo( index, this.slides.length ); 1861 } 1862 // bail if invalid index 1863 if ( !this.slides[ index ] ) { 1864 return; 1865 } 1866 var prevIndex = this.selectedIndex; 1867 this.selectedIndex = index; 1868 this.updateSelectedSlide(); 1869 if ( isInstant ) { 1870 this.positionSliderAtSelected(); 1871 } else { 1872 this.startAnimation(); 1873 } 1874 if ( this.options.adaptiveHeight ) { 1875 this.setGallerySize(); 1876 } 1877 // events 1878 this.dispatchEvent( 'select', null, [ index ] ); 1879 // change event if new index 1880 if ( index != prevIndex ) { 1881 this.dispatchEvent( 'change', null, [ index ] ); 1882 } 1883 // old v1 event name, remove in v3 1884 this.dispatchEvent('cellSelect'); 1885}; 1886 1887// wraps position for wrapAround, to move to closest slide. #113 1888proto._wrapSelect = function( index ) { 1889 var len = this.slides.length; 1890 var isWrapping = this.options.wrapAround && len > 1; 1891 if ( !isWrapping ) { 1892 return index; 1893 } 1894 var wrapIndex = utils.modulo( index, len ); 1895 // go to shortest 1896 var delta = Math.abs( wrapIndex - this.selectedIndex ); 1897 var backWrapDelta = Math.abs( ( wrapIndex + len ) - this.selectedIndex ); 1898 var forewardWrapDelta = Math.abs( ( wrapIndex - len ) - this.selectedIndex ); 1899 if ( !this.isDragSelect && backWrapDelta < delta ) { 1900 index += len; 1901 } else if ( !this.isDragSelect && forewardWrapDelta < delta ) { 1902 index -= len; 1903 } 1904 // wrap position so slider is within normal area 1905 if ( index < 0 ) { 1906 this.x -= this.slideableWidth; 1907 } else if ( index >= len ) { 1908 this.x += this.slideableWidth; 1909 } 1910}; 1911 1912proto.previous = function( isWrap, isInstant ) { 1913 this.select( this.selectedIndex - 1, isWrap, isInstant ); 1914}; 1915 1916proto.next = function( isWrap, isInstant ) { 1917 this.select( this.selectedIndex + 1, isWrap, isInstant ); 1918}; 1919 1920proto.updateSelectedSlide = function() { 1921 var slide = this.slides[ this.selectedIndex ]; 1922 // selectedIndex could be outside of slides, if triggered before resize() 1923 if ( !slide ) { 1924 return; 1925 } 1926 // unselect previous selected slide 1927 this.unselectSelectedSlide(); 1928 // update new selected slide 1929 this.selectedSlide = slide; 1930 slide.select(); 1931 this.selectedCells = slide.cells; 1932 this.selectedElements = slide.getCellElements(); 1933 // HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility 1934 // Remove in v3? 1935 this.selectedCell = slide.cells[0]; 1936 this.selectedElement = this.selectedElements[0]; 1937}; 1938 1939proto.unselectSelectedSlide = function() { 1940 if ( this.selectedSlide ) { 1941 this.selectedSlide.unselect(); 1942 } 1943}; 1944 1945proto.selectInitialIndex = function() { 1946 var initialIndex = this.options.initialIndex; 1947 // already activated, select previous selectedIndex 1948 if ( this.isInitActivated ) { 1949 this.select( this.selectedIndex, false, true ); 1950 return; 1951 } 1952 // select with selector string 1953 if ( initialIndex && typeof initialIndex == 'string' ) { 1954 var cell = this.queryCell( initialIndex ); 1955 if ( cell ) { 1956 this.selectCell( initialIndex, false, true ); 1957 return; 1958 } 1959 } 1960 1961 var index = 0; 1962 // select with number 1963 if ( initialIndex && this.slides[ initialIndex ] ) { 1964 index = initialIndex; 1965 } 1966 // select instantly 1967 this.select( index, false, true ); 1968}; 1969 1970/** 1971 * select slide from number or cell element 1972 * @param {Element or Number} elem 1973 */ 1974proto.selectCell = function( value, isWrap, isInstant ) { 1975 // get cell 1976 var cell = this.queryCell( value ); 1977 if ( !cell ) { 1978 return; 1979 } 1980 1981 var index = this.getCellSlideIndex( cell ); 1982 this.select( index, isWrap, isInstant ); 1983}; 1984 1985proto.getCellSlideIndex = function( cell ) { 1986 // get index of slides that has cell 1987 for ( var i=0; i < this.slides.length; i++ ) { 1988 var slide = this.slides[i]; 1989 var index = slide.cells.indexOf( cell ); 1990 if ( index != -1 ) { 1991 return i; 1992 } 1993 } 1994}; 1995 1996// -------------------------- get cells -------------------------- // 1997 1998/** 1999 * get Flickity.Cell, given an Element 2000 * @param {Element} elem 2001 * @returns {Flickity.Cell} item 2002 */ 2003proto.getCell = function( elem ) { 2004 // loop through cells to get the one that matches 2005 for ( var i=0; i < this.cells.length; i++ ) { 2006 var cell = this.cells[i]; 2007 if ( cell.element == elem ) { 2008 return cell; 2009 } 2010 } 2011}; 2012 2013/** 2014 * get collection of Flickity.Cells, given Elements 2015 * @param {Element, Array, NodeList} elems 2016 * @returns {Array} cells - Flickity.Cells 2017 */ 2018proto.getCells = function( elems ) { 2019 elems = utils.makeArray( elems ); 2020 var cells = []; 2021 elems.forEach( function( elem ) { 2022 var cell = this.getCell( elem ); 2023 if ( cell ) { 2024 cells.push( cell ); 2025 } 2026 }, this ); 2027 return cells; 2028}; 2029 2030/** 2031 * get cell elements 2032 * @returns {Array} cellElems 2033 */ 2034proto.getCellElements = function() { 2035 return this.cells.map( function( cell ) { 2036 return cell.element; 2037 }); 2038}; 2039 2040/** 2041 * get parent cell from an element 2042 * @param {Element} elem 2043 * @returns {Flickit.Cell} cell 2044 */ 2045proto.getParentCell = function( elem ) { 2046 // first check if elem is cell 2047 var cell = this.getCell( elem ); 2048 if ( cell ) { 2049 return cell; 2050 } 2051 // try to get parent cell elem 2052 elem = utils.getParent( elem, '.flickity-slider > *' ); 2053 return this.getCell( elem ); 2054}; 2055 2056/** 2057 * get cells adjacent to a slide 2058 * @param {Integer} adjCount - number of adjacent slides 2059 * @param {Integer} index - index of slide to start 2060 * @returns {Array} cells - array of Flickity.Cells 2061 */ 2062proto.getAdjacentCellElements = function( adjCount, index ) { 2063 if ( !adjCount ) { 2064 return this.selectedSlide.getCellElements(); 2065 } 2066 index = index === undefined ? this.selectedIndex : index; 2067 2068 var len = this.slides.length; 2069 if ( 1 + ( adjCount * 2 ) >= len ) { 2070 return this.getCellElements(); 2071 } 2072 2073 var cellElems = []; 2074 for ( var i = index - adjCount; i <= index + adjCount ; i++ ) { 2075 var slideIndex = this.options.wrapAround ? utils.modulo( i, len ) : i; 2076 var slide = this.slides[ slideIndex ]; 2077 if ( slide ) { 2078 cellElems = cellElems.concat( slide.getCellElements() ); 2079 } 2080 } 2081 return cellElems; 2082}; 2083 2084/** 2085 * select slide from number or cell element 2086 * @param {Element, Selector String, or Number} selector 2087 */ 2088proto.queryCell = function( selector ) { 2089 if ( typeof selector == 'number' ) { 2090 // use number as index 2091 return this.cells[ selector ]; 2092 } 2093 if ( typeof selector == 'string' ) { 2094 // do not select invalid selectors from hash: #123, #/. #791 2095 if ( selector.match(/^[#\.]?[\d\/]/) ) { 2096 return; 2097 } 2098 // use string as selector, get element 2099 selector = this.element.querySelector( selector ); 2100 } 2101 // get cell from element 2102 return this.getCell( selector ); 2103}; 2104 2105// -------------------------- events -------------------------- // 2106 2107proto.uiChange = function() { 2108 this.emitEvent('uiChange'); 2109}; 2110 2111// keep focus on element when child UI elements are clicked 2112proto.childUIPointerDown = function( event ) { 2113 // HACK iOS does not allow touch events to bubble up?! 2114 if ( event.type != 'touchstart' ) { 2115 event.preventDefault(); 2116 } 2117 this.focus(); 2118}; 2119 2120// ----- resize ----- // 2121 2122proto.onresize = function() { 2123 this.watchCSS(); 2124 this.resize(); 2125}; 2126 2127utils.debounceMethod( Flickity, 'onresize', 150 ); 2128 2129proto.resize = function() { 2130 if ( !this.isActive ) { 2131 return; 2132 } 2133 this.getSize(); 2134 // wrap values 2135 if ( this.options.wrapAround ) { 2136 this.x = utils.modulo( this.x, this.slideableWidth ); 2137 } 2138 this.positionCells(); 2139 this._getWrapShiftCells(); 2140 this.setGallerySize(); 2141 this.emitEvent('resize'); 2142 // update selected index for group slides, instant 2143 // TODO: position can be lost between groups of various numbers 2144 var selectedElement = this.selectedElements && this.selectedElements[0]; 2145 this.selectCell( selectedElement, false, true ); 2146}; 2147 2148// watches the :after property, activates/deactivates 2149proto.watchCSS = function() { 2150 var watchOption = this.options.watchCSS; 2151 if ( !watchOption ) { 2152 return; 2153 } 2154 2155 var afterContent = getComputedStyle( this.element, ':after' ).content; 2156 // activate if :after { content: 'flickity' } 2157 if ( afterContent.indexOf('flickity') != -1 ) { 2158 this.activate(); 2159 } else { 2160 this.deactivate(); 2161 } 2162}; 2163 2164// ----- keydown ----- // 2165 2166// go previous/next if left/right keys pressed 2167proto.onkeydown = function( event ) { 2168 // only work if element is in focus 2169 var isNotFocused = document.activeElement && document.activeElement != this.element; 2170 if ( !this.options.accessibility ||isNotFocused ) { 2171 return; 2172 } 2173 2174 var handler = Flickity.keyboardHandlers[ event.keyCode ]; 2175 if ( handler ) { 2176 handler.call( this ); 2177 } 2178}; 2179 2180Flickity.keyboardHandlers = { 2181 // left arrow 2182 37: function() { 2183 var leftMethod = this.options.rightToLeft ? 'next' : 'previous'; 2184 this.uiChange(); 2185 this[ leftMethod ](); 2186 }, 2187 // right arrow 2188 39: function() { 2189 var rightMethod = this.options.rightToLeft ? 'previous' : 'next'; 2190 this.uiChange(); 2191 this[ rightMethod ](); 2192 }, 2193}; 2194 2195// ----- focus ----- // 2196 2197proto.focus = function() { 2198 // TODO remove scrollTo once focus options gets more support 2199 // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#Browser_compatibility 2200 var prevScrollY = window.pageYOffset; 2201 this.element.focus({ preventScroll: true }); 2202 // hack to fix scroll jump after focus, #76 2203 if ( window.pageYOffset != prevScrollY ) { 2204 window.scrollTo( window.pageXOffset, prevScrollY ); 2205 } 2206}; 2207 2208// -------------------------- destroy -------------------------- // 2209 2210// deactivate all Flickity functionality, but keep stuff available 2211proto.deactivate = function() { 2212 if ( !this.isActive ) { 2213 return; 2214 } 2215 this.element.classList.remove('flickity-enabled'); 2216 this.element.classList.remove('flickity-rtl'); 2217 this.unselectSelectedSlide(); 2218 // destroy cells 2219 this.cells.forEach( function( cell ) { 2220 cell.destroy(); 2221 }); 2222 this.element.removeChild( this.viewport ); 2223 // move child elements back into element 2224 moveElements( this.slider.children, this.element ); 2225 if ( this.options.accessibility ) { 2226 this.element.removeAttribute('tabIndex'); 2227 this.element.removeEventListener( 'keydown', this ); 2228 } 2229 // set flags 2230 this.isActive = false; 2231 this.emitEvent('deactivate'); 2232}; 2233 2234proto.destroy = function() { 2235 this.deactivate(); 2236 window.removeEventListener( 'resize', this ); 2237 this.allOff(); 2238 this.emitEvent('destroy'); 2239 if ( jQuery && this.$element ) { 2240 jQuery.removeData( this.element, 'flickity' ); 2241 } 2242 delete this.element.flickityGUID; 2243 delete instances[ this.guid ]; 2244}; 2245 2246// -------------------------- prototype -------------------------- // 2247 2248utils.extend( proto, animatePrototype ); 2249 2250// -------------------------- extras -------------------------- // 2251 2252/** 2253 * get Flickity instance from element 2254 * @param {Element} elem 2255 * @returns {Flickity} 2256 */ 2257Flickity.data = function( elem ) { 2258 elem = utils.getQueryElement( elem ); 2259 var id = elem && elem.flickityGUID; 2260 return id && instances[ id ]; 2261}; 2262 2263utils.htmlInit( Flickity, 'flickity' ); 2264 2265if ( jQuery && jQuery.bridget ) { 2266 jQuery.bridget( 'flickity', Flickity ); 2267} 2268 2269// set internal jQuery, for Webpack + jQuery v3, #478 2270Flickity.setJQuery = function( jq ) { 2271 jQuery = jq; 2272}; 2273 2274Flickity.Cell = Cell; 2275Flickity.Slide = Slide; 2276 2277return Flickity; 2278 2279})); 2280 2281 2282/***/ }), 2283
vendor: 1,877 bytes, lines 2284-2328
2284/***/ "./node_modules/flickity/js/index.js": 2285/*!*******************************************!*\ 2286 !*** ./node_modules/flickity/js/index.js ***! 2287 \*******************************************/ 2288/*! no static exports found */ 2289/***/ (function(module, exports, __webpack_require__) { 2290 2291var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 2292 * Flickity v2.2.0 2293 * Touch, responsive, flickable carousels 2294 * 2295 * Licensed GPLv3 for open source use 2296 * or Flickity Commercial License for commercial use 2297 * 2298 * https://flickity.metafizzy.co 2299 * Copyright 2015-2018 Metafizzy 2300 */ 2301 2302( function( window, factory ) { 2303 // universal module definition 2304 /* jshint strict: false */ 2305 if ( true ) { 2306 // AMD 2307 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 2308 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js"), 2309 __webpack_require__(/*! ./drag */ "./node_modules/flickity/js/drag.js"), 2310 __webpack_require__(/*! ./prev-next-button */ "./node_modules/flickity/js/prev-next-button.js"), 2311 __webpack_require__(/*! ./page-dots */ "./node_modules/flickity/js/page-dots.js"), 2312 __webpack_require__(/*! ./player */ "./node_modules/flickity/js/player.js"), 2313 __webpack_require__(/*! ./add-remove-cell */ "./node_modules/flickity/js/add-remove-cell.js"), 2314 __webpack_require__(/*! ./lazyload */ "./node_modules/flickity/js/lazyload.js") 2315 ], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 2316 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 2317 (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), 2318 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2319 } else {} 2320 2321})( window, function factory( Flickity ) { 2322 /*jshint strict: false*/ 2323 return Flickity; 2324}); 2325 2326 2327/***/ }), 2328
vendor: 4,179 bytes, lines 2329-2460
2329/***/ "./node_modules/flickity/js/lazyload.js": 2330/*!**********************************************!*\ 2331 !*** ./node_modules/flickity/js/lazyload.js ***! 2332 \**********************************************/ 2333/*! no static exports found */ 2334/***/ (function(module, exports, __webpack_require__) { 2335 2336var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// lazyload 2337( function( window, factory ) { 2338 // universal module definition 2339 /* jshint strict: false */ 2340 if ( true ) { 2341 // AMD 2342 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 2343 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js"), 2344 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js") 2345 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Flickity, utils ) { 2346 return factory( window, Flickity, utils ); 2347 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 2348 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2349 } else {} 2350 2351}( window, function factory( window, Flickity, utils ) { 2352'use strict'; 2353 2354Flickity.createMethods.push('_createLazyload'); 2355var proto = Flickity.prototype; 2356 2357proto._createLazyload = function() { 2358 this.on( 'select', this.lazyLoad ); 2359}; 2360 2361proto.lazyLoad = function() { 2362 var lazyLoad = this.options.lazyLoad; 2363 if ( !lazyLoad ) { 2364 return; 2365 } 2366 // get adjacent cells, use lazyLoad option for adjacent count 2367 var adjCount = typeof lazyLoad == 'number' ? lazyLoad : 0; 2368 var cellElems = this.getAdjacentCellElements( adjCount ); 2369 // get lazy images in those cells 2370 var lazyImages = []; 2371 cellElems.forEach( function( cellElem ) { 2372 var lazyCellImages = getCellLazyImages( cellElem ); 2373 lazyImages = lazyImages.concat( lazyCellImages ); 2374 }); 2375 // load lazy images 2376 lazyImages.forEach( function( img ) { 2377 new LazyLoader( img, this ); 2378 }, this ); 2379}; 2380 2381function getCellLazyImages( cellElem ) { 2382 // check if cell element is lazy image 2383 if ( cellElem.nodeName == 'IMG' ) { 2384 var lazyloadAttr = cellElem.getAttribute('data-flickity-lazyload'); 2385 var srcAttr = cellElem.getAttribute('data-flickity-lazyload-src'); 2386 var srcsetAttr = cellElem.getAttribute('data-flickity-lazyload-srcset'); 2387 if ( lazyloadAttr || srcAttr || srcsetAttr ) { 2388 return [ cellElem ]; 2389 } 2390 } 2391 // select lazy images in cell 2392 var lazySelector = 'img[data-flickity-lazyload], ' + 2393 'img[data-flickity-lazyload-src], img[data-flickity-lazyload-srcset]'; 2394 var imgs = cellElem.querySelectorAll( lazySelector ); 2395 return utils.makeArray( imgs ); 2396} 2397 2398// -------------------------- LazyLoader -------------------------- // 2399 2400/** 2401 * class to handle loading images 2402 */ 2403function LazyLoader( img, flickity ) { 2404 this.img = img; 2405 this.flickity = flickity; 2406 this.load(); 2407} 2408 2409LazyLoader.prototype.handleEvent = utils.handleEvent; 2410 2411LazyLoader.prototype.load = function() { 2412 this.img.addEventListener( 'load', this ); 2413 this.img.addEventListener( 'error', this ); 2414 // get src & srcset 2415 var src = this.img.getAttribute('data-flickity-lazyload') || 2416 this.img.getAttribute('data-flickity-lazyload-src'); 2417 var srcset = this.img.getAttribute('data-flickity-lazyload-srcset'); 2418 // set src & serset 2419 this.img.src = src; 2420 if ( srcset ) { 2421 this.img.setAttribute( 'srcset', srcset ); 2422 } 2423 // remove attr 2424 this.img.removeAttribute('data-flickity-lazyload'); 2425 this.img.removeAttribute('data-flickity-lazyload-src'); 2426 this.img.removeAttribute('data-flickity-lazyload-srcset'); 2427}; 2428 2429LazyLoader.prototype.onload = function( event ) { 2430 this.complete( event, 'flickity-lazyloaded' ); 2431}; 2432 2433LazyLoader.prototype.onerror = function( event ) { 2434 this.complete( event, 'flickity-lazyerror' ); 2435}; 2436 2437LazyLoader.prototype.complete = function( event, className ) { 2438 // unbind events 2439 this.img.removeEventListener( 'load', this ); 2440 this.img.removeEventListener( 'error', this ); 2441 2442 var cell = this.flickity.getParentCell( this.img ); 2443 var cellElem = cell && cell.element; 2444 this.flickity.cellSizeChange( cellElem ); 2445 2446 this.img.classList.add( className ); 2447 this.flickity.dispatchEvent( 'lazyLoad', event, cellElem ); 2448}; 2449 2450// ----- ----- // 2451 2452Flickity.LazyLoader = LazyLoader; 2453 2454return Flickity; 2455 2456})); 2457 2458 2459/***/ }), 2460
vendor: 5,183 bytes, lines 2461-2644
2461/***/ "./node_modules/flickity/js/page-dots.js": 2462/*!***********************************************!*\ 2463 !*** ./node_modules/flickity/js/page-dots.js ***! 2464 \***********************************************/ 2465/*! no static exports found */ 2466/***/ (function(module, exports, __webpack_require__) { 2467 2468var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// page dots 2469( function( window, factory ) { 2470 // universal module definition 2471 /* jshint strict: false */ 2472 if ( true ) { 2473 // AMD 2474 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 2475 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js"), 2476 __webpack_require__(/*! unipointer/unipointer */ "./node_modules/unipointer/unipointer.js"), 2477 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js") 2478 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Flickity, Unipointer, utils ) { 2479 return factory( window, Flickity, Unipointer, utils ); 2480 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 2481 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2482 } else {} 2483 2484}( window, function factory( window, Flickity, Unipointer, utils ) { 2485 2486// -------------------------- PageDots -------------------------- // 2487 2488'use strict'; 2489 2490function PageDots( parent ) { 2491 this.parent = parent; 2492 this._create(); 2493} 2494 2495PageDots.prototype = Object.create( Unipointer.prototype ); 2496 2497PageDots.prototype._create = function() { 2498 // create holder element 2499 this.holder = document.createElement('ol'); 2500 this.holder.className = 'flickity-page-dots'; 2501 // create dots, array of elements 2502 this.dots = []; 2503 // events 2504 this.handleClick = this.onClick.bind( this ); 2505 this.on( 'pointerDown', this.parent.childUIPointerDown.bind( this.parent ) ); 2506}; 2507 2508PageDots.prototype.activate = function() { 2509 this.setDots(); 2510 this.holder.addEventListener( 'click', this.handleClick ); 2511 this.bindStartEvent( this.holder ); 2512 // add to DOM 2513 this.parent.element.appendChild( this.holder ); 2514}; 2515 2516PageDots.prototype.deactivate = function() { 2517 this.holder.removeEventListener( 'click', this.handleClick ); 2518 this.unbindStartEvent( this.holder ); 2519 // remove from DOM 2520 this.parent.element.removeChild( this.holder ); 2521}; 2522 2523PageDots.prototype.setDots = function() { 2524 // get difference between number of slides and number of dots 2525 var delta = this.parent.slides.length - this.dots.length; 2526 if ( delta > 0 ) { 2527 this.addDots( delta ); 2528 } else if ( delta < 0 ) { 2529 this.removeDots( -delta ); 2530 } 2531}; 2532 2533PageDots.prototype.addDots = function( count ) { 2534 var fragment = document.createDocumentFragment(); 2535 var newDots = []; 2536 var length = this.dots.length; 2537 var max = length + count; 2538 2539 for ( var i = length; i < max; i++ ) { 2540 var dot = document.createElement('li'); 2541 dot.className = 'dot'; 2542 dot.setAttribute( 'aria-label', 'Page dot ' + ( i + 1 ) ); 2543 fragment.appendChild( dot ); 2544 newDots.push( dot ); 2545 } 2546 2547 this.holder.appendChild( fragment ); 2548 this.dots = this.dots.concat( newDots ); 2549}; 2550 2551PageDots.prototype.removeDots = function( count ) { 2552 // remove from this.dots collection 2553 var removeDots = this.dots.splice( this.dots.length - count, count ); 2554 // remove from DOM 2555 removeDots.forEach( function( dot ) { 2556 this.holder.removeChild( dot ); 2557 }, this ); 2558}; 2559 2560PageDots.prototype.updateSelected = function() { 2561 // remove selected class on previous 2562 if ( this.selectedDot ) { 2563 this.selectedDot.className = 'dot'; 2564 this.selectedDot.removeAttribute('aria-current'); 2565 } 2566 // don't proceed if no dots 2567 if ( !this.dots.length ) { 2568 return; 2569 } 2570 this.selectedDot = this.dots[ this.parent.selectedIndex ]; 2571 this.selectedDot.className = 'dot is-selected'; 2572 this.selectedDot.setAttribute( 'aria-current', 'step' ); 2573}; 2574 2575PageDots.prototype.onTap = // old method name, backwards-compatible 2576PageDots.prototype.onClick = function( event ) { 2577 var target = event.target; 2578 // only care about dot clicks 2579 if ( target.nodeName != 'LI' ) { 2580 return; 2581 } 2582 2583 this.parent.uiChange(); 2584 var index = this.dots.indexOf( target ); 2585 this.parent.select( index ); 2586}; 2587 2588PageDots.prototype.destroy = function() { 2589 this.deactivate(); 2590 this.allOff(); 2591}; 2592 2593Flickity.PageDots = PageDots; 2594 2595// -------------------------- Flickity -------------------------- // 2596 2597utils.extend( Flickity.defaults, { 2598 pageDots: true 2599}); 2600 2601Flickity.createMethods.push('_createPageDots'); 2602 2603var proto = Flickity.prototype; 2604 2605proto._createPageDots = function() { 2606 if ( !this.options.pageDots ) { 2607 return; 2608 } 2609 this.pageDots = new PageDots( this ); 2610 // events 2611 this.on( 'activate', this.activatePageDots ); 2612 this.on( 'select', this.updateSelectedPageDots ); 2613 this.on( 'cellChange', this.updatePageDots ); 2614 this.on( 'resize', this.updatePageDots ); 2615 this.on( 'deactivate', this.deactivatePageDots ); 2616}; 2617 2618proto.activatePageDots = function() { 2619 this.pageDots.activate(); 2620}; 2621 2622proto.updateSelectedPageDots = function() { 2623 this.pageDots.updateSelected(); 2624}; 2625 2626proto.updatePageDots = function() { 2627 this.pageDots.setDots(); 2628}; 2629 2630proto.deactivatePageDots = function() { 2631 this.pageDots.deactivate(); 2632}; 2633 2634// ----- ----- // 2635 2636Flickity.PageDots = PageDots; 2637 2638return Flickity; 2639 2640})); 2641 2642 2643/***/ }), 2644
vendor: 4,918 bytes, lines 2645-2833
2645/***/ "./node_modules/flickity/js/player.js": 2646/*!********************************************!*\ 2647 !*** ./node_modules/flickity/js/player.js ***! 2648 \********************************************/ 2649/*! no static exports found */ 2650/***/ (function(module, exports, __webpack_require__) { 2651 2652var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// player & autoPlay 2653( function( window, factory ) { 2654 // universal module definition 2655 /* jshint strict: false */ 2656 if ( true ) { 2657 // AMD 2658 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 2659 __webpack_require__(/*! ev-emitter/ev-emitter */ "./node_modules/ev-emitter/ev-emitter.js"), 2660 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js"), 2661 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js") 2662 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( EvEmitter, utils, Flickity ) { 2663 return factory( EvEmitter, utils, Flickity ); 2664 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 2665 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2666 } else {} 2667 2668}( window, function factory( EvEmitter, utils, Flickity ) { 2669 2670'use strict'; 2671 2672// -------------------------- Player -------------------------- // 2673 2674function Player( parent ) { 2675 this.parent = parent; 2676 this.state = 'stopped'; 2677 // visibility change event handler 2678 this.onVisibilityChange = this.visibilityChange.bind( this ); 2679 this.onVisibilityPlay = this.visibilityPlay.bind( this ); 2680} 2681 2682Player.prototype = Object.create( EvEmitter.prototype ); 2683 2684// start play 2685Player.prototype.play = function() { 2686 if ( this.state == 'playing' ) { 2687 return; 2688 } 2689 // do not play if page is hidden, start playing when page is visible 2690 var isPageHidden = document.hidden; 2691 if ( isPageHidden ) { 2692 document.addEventListener( 'visibilitychange', this.onVisibilityPlay ); 2693 return; 2694 } 2695 2696 this.state = 'playing'; 2697 // listen to visibility change 2698 document.addEventListener( 'visibilitychange', this.onVisibilityChange ); 2699 // start ticking 2700 this.tick(); 2701}; 2702 2703Player.prototype.tick = function() { 2704 // do not tick if not playing 2705 if ( this.state != 'playing' ) { 2706 return; 2707 } 2708 2709 var time = this.parent.options.autoPlay; 2710 // default to 3 seconds 2711 time = typeof time == 'number' ? time : 3000; 2712 var _this = this; 2713 // HACK: reset ticks if stopped and started within interval 2714 this.clear(); 2715 this.timeout = setTimeout( function() { 2716 _this.parent.next( true ); 2717 _this.tick(); 2718 }, time ); 2719}; 2720 2721Player.prototype.stop = function() { 2722 this.state = 'stopped'; 2723 this.clear(); 2724 // remove visibility change event 2725 document.removeEventListener( 'visibilitychange', this.onVisibilityChange ); 2726}; 2727 2728Player.prototype.clear = function() { 2729 clearTimeout( this.timeout ); 2730}; 2731 2732Player.prototype.pause = function() { 2733 if ( this.state == 'playing' ) { 2734 this.state = 'paused'; 2735 this.clear(); 2736 } 2737}; 2738 2739Player.prototype.unpause = function() { 2740 // re-start play if paused 2741 if ( this.state == 'paused' ) { 2742 this.play(); 2743 } 2744}; 2745 2746// pause if page visibility is hidden, unpause if visible 2747Player.prototype.visibilityChange = function() { 2748 var isPageHidden = document.hidden; 2749 this[ isPageHidden ? 'pause' : 'unpause' ](); 2750}; 2751 2752Player.prototype.visibilityPlay = function() { 2753 this.play(); 2754 document.removeEventListener( 'visibilitychange', this.onVisibilityPlay ); 2755}; 2756 2757// -------------------------- Flickity -------------------------- // 2758 2759utils.extend( Flickity.defaults, { 2760 pauseAutoPlayOnHover: true 2761}); 2762 2763Flickity.createMethods.push('_createPlayer'); 2764var proto = Flickity.prototype; 2765 2766proto._createPlayer = function() { 2767 this.player = new Player( this ); 2768 2769 this.on( 'activate', this.activatePlayer ); 2770 this.on( 'uiChange', this.stopPlayer ); 2771 this.on( 'pointerDown', this.stopPlayer ); 2772 this.on( 'deactivate', this.deactivatePlayer ); 2773}; 2774 2775proto.activatePlayer = function() { 2776 if ( !this.options.autoPlay ) { 2777 return; 2778 } 2779 this.player.play(); 2780 this.element.addEventListener( 'mouseenter', this ); 2781}; 2782 2783// Player API, don't hate the ... thanks I know where the door is 2784 2785proto.playPlayer = function() { 2786 this.player.play(); 2787}; 2788 2789proto.stopPlayer = function() { 2790 this.player.stop(); 2791}; 2792 2793proto.pausePlayer = function() { 2794 this.player.pause(); 2795}; 2796 2797proto.unpausePlayer = function() { 2798 this.player.unpause(); 2799}; 2800 2801proto.deactivatePlayer = function() { 2802 this.player.stop(); 2803 this.element.removeEventListener( 'mouseenter', this ); 2804}; 2805 2806// ----- mouseenter/leave ----- // 2807 2808// pause auto-play on hover 2809proto.onmouseenter = function() { 2810 if ( !this.options.pauseAutoPlayOnHover ) { 2811 return; 2812 } 2813 this.player.pause(); 2814 this.element.addEventListener( 'mouseleave', this ); 2815}; 2816 2817// resume auto-play on hover off 2818proto.onmouseleave = function() { 2819 this.player.unpause(); 2820 this.element.removeEventListener( 'mouseleave', this ); 2821}; 2822 2823// ----- ----- // 2824 2825Flickity.Player = Player; 2826 2827return Flickity; 2828 2829})); 2830 2831 2832/***/ }), 2833
vendor: 6,207 bytes, lines 2834-3040
2834/***/ "./node_modules/flickity/js/prev-next-button.js": 2835/*!******************************************************!*\ 2836 !*** ./node_modules/flickity/js/prev-next-button.js ***! 2837 \******************************************************/ 2838/*! no static exports found */ 2839/***/ (function(module, exports, __webpack_require__) { 2840 2841var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// prev/next buttons 2842( function( window, factory ) { 2843 // universal module definition 2844 /* jshint strict: false */ 2845 if ( true ) { 2846 // AMD 2847 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 2848 __webpack_require__(/*! ./flickity */ "./node_modules/flickity/js/flickity.js"), 2849 __webpack_require__(/*! unipointer/unipointer */ "./node_modules/unipointer/unipointer.js"), 2850 __webpack_require__(/*! fizzy-ui-utils/utils */ "./node_modules/fizzy-ui-utils/utils.js") 2851 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Flickity, Unipointer, utils ) { 2852 return factory( window, Flickity, Unipointer, utils ); 2853 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 2854 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 2855 } else {} 2856 2857}( window, function factory( window, Flickity, Unipointer, utils ) { 2858'use strict'; 2859 2860var svgURI = 'http://www.w3.org/2000/svg'; 2861 2862// -------------------------- PrevNextButton -------------------------- // 2863 2864function PrevNextButton( direction, parent ) { 2865 this.direction = direction; 2866 this.parent = parent; 2867 this._create(); 2868} 2869 2870PrevNextButton.prototype = Object.create( Unipointer.prototype ); 2871 2872PrevNextButton.prototype._create = function() { 2873 // properties 2874 this.isEnabled = true; 2875 this.isPrevious = this.direction == -1; 2876 var leftDirection = this.parent.options.rightToLeft ? 1 : -1; 2877 this.isLeft = this.direction == leftDirection; 2878 2879 var element = this.element = document.createElement('button'); 2880 element.className = 'flickity-button flickity-prev-next-button'; 2881 element.className += this.isPrevious ? ' previous' : ' next'; 2882 // prevent button from submitting form http://stackoverflow.com/a/10836076/182183 2883 element.setAttribute( 'type', 'button' ); 2884 // init as disabled 2885 this.disable(); 2886 2887 element.setAttribute( 'aria-label', this.isPrevious ? 'Previous' : 'Next' ); 2888 2889 // create arrow 2890 var svg = this.createSVG(); 2891 element.appendChild( svg ); 2892 // events 2893 this.parent.on( 'select', this.update.bind( this ) ); 2894 this.on( 'pointerDown', this.parent.childUIPointerDown.bind( this.parent ) ); 2895}; 2896 2897PrevNextButton.prototype.activate = function() { 2898 this.bindStartEvent( this.element ); 2899 this.element.addEventListener( 'click', this ); 2900 // add to DOM 2901 this.parent.element.appendChild( this.element ); 2902}; 2903 2904PrevNextButton.prototype.deactivate = function() { 2905 // remove from DOM 2906 this.parent.element.removeChild( this.element ); 2907 // click events 2908 this.unbindStartEvent( this.element ); 2909 this.element.removeEventListener( 'click', this ); 2910}; 2911 2912PrevNextButton.prototype.createSVG = function() { 2913 var svg = document.createElementNS( svgURI, 'svg'); 2914 svg.setAttribute( 'class', 'flickity-button-icon' ); 2915 svg.setAttribute( 'viewBox', '0 0 100 100' ); 2916 var path = document.createElementNS( svgURI, 'path'); 2917 var pathMovements = getArrowMovements( this.parent.options.arrowShape ); 2918 path.setAttribute( 'd', pathMovements ); 2919 path.setAttribute( 'class', 'arrow' ); 2920 // rotate arrow 2921 if ( !this.isLeft ) { 2922 path.setAttribute( 'transform', 'translate(100, 100) rotate(180) ' ); 2923 } 2924 svg.appendChild( path ); 2925 return svg; 2926}; 2927 2928// get SVG path movmement 2929function getArrowMovements( shape ) { 2930 // use shape as movement if string 2931 if ( typeof shape == 'string' ) { 2932 return shape; 2933 } 2934 // create movement string 2935 return 'M ' + shape.x0 + ',50' + 2936 ' L ' + shape.x1 + ',' + ( shape.y1 + 50 ) + 2937 ' L ' + shape.x2 + ',' + ( shape.y2 + 50 ) + 2938 ' L ' + shape.x3 + ',50 ' + 2939 ' L ' + shape.x2 + ',' + ( 50 - shape.y2 ) + 2940 ' L ' + shape.x1 + ',' + ( 50 - shape.y1 ) + 2941 ' Z'; 2942} 2943 2944PrevNextButton.prototype.handleEvent = utils.handleEvent; 2945 2946PrevNextButton.prototype.onclick = function() { 2947 if ( !this.isEnabled ) { 2948 return; 2949 } 2950 this.parent.uiChange(); 2951 var method = this.isPrevious ? 'previous' : 'next'; 2952 this.parent[ method ](); 2953}; 2954 2955// ----- ----- // 2956 2957PrevNextButton.prototype.enable = function() { 2958 if ( this.isEnabled ) { 2959 return; 2960 } 2961 this.element.disabled = false; 2962 this.isEnabled = true; 2963}; 2964 2965PrevNextButton.prototype.disable = function() { 2966 if ( !this.isEnabled ) { 2967 return; 2968 } 2969 this.element.disabled = true; 2970 this.isEnabled = false; 2971}; 2972 2973PrevNextButton.prototype.update = function() { 2974 // index of first or last slide, if previous or next 2975 var slides = this.parent.slides; 2976 // enable is wrapAround and at least 2 slides 2977 if ( this.parent.options.wrapAround && slides.length > 1 ) { 2978 this.enable(); 2979 return; 2980 } 2981 var lastIndex = slides.length ? slides.length - 1 : 0; 2982 var boundIndex = this.isPrevious ? 0 : lastIndex; 2983 var method = this.parent.selectedIndex == boundIndex ? 'disable' : 'enable'; 2984 this[ method ](); 2985}; 2986 2987PrevNextButton.prototype.destroy = function() { 2988 this.deactivate(); 2989 this.allOff(); 2990}; 2991 2992// -------------------------- Flickity prototype -------------------------- // 2993 2994utils.extend( Flickity.defaults, { 2995 prevNextButtons: true, 2996 arrowShape: { 2997 x0: 10, 2998 x1: 60, y1: 50, 2999 x2: 70, y2: 40, 3000 x3: 30 3001 } 3002}); 3003 3004Flickity.createMethods.push('_createPrevNextButtons'); 3005var proto = Flickity.prototype; 3006 3007proto._createPrevNextButtons = function() { 3008 if ( !this.options.prevNextButtons ) { 3009 return; 3010 } 3011 3012 this.prevButton = new PrevNextButton( -1, this ); 3013 this.nextButton = new PrevNextButton( 1, this ); 3014 3015 this.on( 'activate', this.activatePrevNextButtons ); 3016}; 3017 3018proto.activatePrevNextButtons = function() { 3019 this.prevButton.activate(); 3020 this.nextButton.activate(); 3021 this.on( 'deactivate', this.deactivatePrevNextButtons ); 3022}; 3023 3024proto.deactivatePrevNextButtons = function() { 3025 this.prevButton.deactivate(); 3026 this.nextButton.deactivate(); 3027 this.off( 'deactivate', this.deactivatePrevNextButtons ); 3028}; 3029 3030// -------------------------- -------------------------- // 3031 3032Flickity.PrevNextButton = PrevNextButton; 3033 3034return Flickity; 3035 3036})); 3037 3038 3039/***/ }), 3040
vendor: 2,294 bytes, lines 3041-3122
3041/***/ "./node_modules/flickity/js/slide.js": 3042/*!*******************************************!*\ 3043 !*** ./node_modules/flickity/js/slide.js ***! 3044 \*******************************************/ 3045/*! no static exports found */ 3046/***/ (function(module, exports, __webpack_require__) { 3047 3048var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;// slide 3049( function( window, factory ) { 3050 // universal module definition 3051 /* jshint strict: false */ 3052 if ( true ) { 3053 // AMD 3054 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 3055 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 3056 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 3057 __WEBPACK_AMD_DEFINE_FACTORY__), 3058 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 3059 } else {} 3060 3061}( window, function factory() { 3062'use strict'; 3063 3064function Slide( parent ) { 3065 this.parent = parent; 3066 this.isOriginLeft = parent.originSide == 'left'; 3067 this.cells = []; 3068 this.outerWidth = 0; 3069 this.height = 0; 3070} 3071 3072var proto = Slide.prototype; 3073 3074proto.addCell = function( cell ) { 3075 this.cells.push( cell ); 3076 this.outerWidth += cell.size.outerWidth; 3077 this.height = Math.max( cell.size.outerHeight, this.height ); 3078 // first cell stuff 3079 if ( this.cells.length == 1 ) { 3080 this.x = cell.x; // x comes from first cell 3081 var beginMargin = this.isOriginLeft ? 'marginLeft' : 'marginRight'; 3082 this.firstMargin = cell.size[ beginMargin ]; 3083 } 3084}; 3085 3086proto.updateTarget = function() { 3087 var endMargin = this.isOriginLeft ? 'marginRight' : 'marginLeft'; 3088 var lastCell = this.getLastCell(); 3089 var lastMargin = lastCell ? lastCell.size[ endMargin ] : 0; 3090 var slideWidth = this.outerWidth - ( this.firstMargin + lastMargin ); 3091 this.target = this.x + this.firstMargin + slideWidth * this.parent.cellAlign; 3092}; 3093 3094proto.getLastCell = function() { 3095 return this.cells[ this.cells.length - 1 ]; 3096}; 3097 3098proto.select = function() { 3099 this.cells.forEach( function( cell ) { 3100 cell.select(); 3101 }); 3102}; 3103 3104proto.unselect = function() { 3105 this.cells.forEach( function( cell ) { 3106 cell.unselect(); 3107 }); 3108}; 3109 3110proto.getCellElements = function() { 3111 return this.cells.map( function( cell ) { 3112 return cell.element; 3113 }); 3114}; 3115 3116return Slide; 3117 3118})); 3119 3120 3121/***/ }), 3122
vendor: 5,877 bytes, lines 3123-3338
3123/***/ "./node_modules/get-size/get-size.js": 3124/*!*******************************************!*\ 3125 !*** ./node_modules/get-size/get-size.js ***! 3126 \*******************************************/ 3127/*! no static exports found */ 3128/***/ (function(module, exports, __webpack_require__) { 3129 3130var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 3131 * getSize v2.0.3 3132 * measure size of elements 3133 * MIT license 3134 */ 3135 3136/* jshint browser: true, strict: true, undef: true, unused: true */ 3137/* globals console: false */ 3138 3139( function( window, factory ) { 3140 /* jshint strict: false */ /* globals define, module */ 3141 if ( true ) { 3142 // AMD 3143 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 3144 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 3145 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 3146 __WEBPACK_AMD_DEFINE_FACTORY__), 3147 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 3148 } else {} 3149 3150})( window, function factory() { 3151'use strict'; 3152 3153// -------------------------- helpers -------------------------- // 3154 3155// get a number from a string, not a percentage 3156function getStyleSize( value ) { 3157 var num = parseFloat( value ); 3158 // not a percent like '100%', and a number 3159 var isValid = value.indexOf('%') == -1 && !isNaN( num ); 3160 return isValid && num; 3161} 3162 3163function noop() {} 3164 3165var logError = typeof console == 'undefined' ? noop : 3166 function( message ) { 3167 console.error( message ); 3168 }; 3169 3170// -------------------------- measurements -------------------------- // 3171 3172var measurements = [ 3173 'paddingLeft', 3174 'paddingRight', 3175 'paddingTop', 3176 'paddingBottom', 3177 'marginLeft', 3178 'marginRight', 3179 'marginTop', 3180 'marginBottom', 3181 'borderLeftWidth', 3182 'borderRightWidth', 3183 'borderTopWidth', 3184 'borderBottomWidth' 3185]; 3186 3187var measurementsLength = measurements.length; 3188 3189function getZeroSize() { 3190 var size = { 3191 width: 0, 3192 height: 0, 3193 innerWidth: 0, 3194 innerHeight: 0, 3195 outerWidth: 0, 3196 outerHeight: 0 3197 }; 3198 for ( var i=0; i < measurementsLength; i++ ) { 3199 var measurement = measurements[i]; 3200 size[ measurement ] = 0; 3201 } 3202 return size; 3203} 3204 3205// -------------------------- getStyle -------------------------- // 3206 3207/** 3208 * getStyle, get style of element, check for Firefox bug 3209 * https://bugzilla.mozilla.org/show_bug.cgi?id=548397 3210 */ 3211function getStyle( elem ) { 3212 var style = getComputedStyle( elem ); 3213 if ( !style ) { 3214 logError( 'Style returned ' + style + 3215 '. Are you running this code in a hidden iframe on Firefox? ' + 3216 'See https://bit.ly/getsizebug1' ); 3217 } 3218 return style; 3219} 3220 3221// -------------------------- setup -------------------------- // 3222 3223var isSetup = false; 3224 3225var isBoxSizeOuter; 3226 3227/** 3228 * setup 3229 * check isBoxSizerOuter 3230 * do on first getSize() rather than on page load for Firefox bug 3231 */ 3232function setup() { 3233 // setup once 3234 if ( isSetup ) { 3235 return; 3236 } 3237 isSetup = true; 3238 3239 // -------------------------- box sizing -------------------------- // 3240 3241 /** 3242 * Chrome & Safari measure the outer-width on style.width on border-box elems 3243 * IE11 & Firefox<29 measures the inner-width 3244 */ 3245 var div = document.createElement('div'); 3246 div.style.width = '200px'; 3247 div.style.padding = '1px 2px 3px 4px'; 3248 div.style.borderStyle = 'solid'; 3249 div.style.borderWidth = '1px 2px 3px 4px'; 3250 div.style.boxSizing = 'border-box'; 3251 3252 var body = document.body || document.documentElement; 3253 body.appendChild( div ); 3254 var style = getStyle( div ); 3255 // round value for browser zoom. desandro/masonry#928 3256 isBoxSizeOuter = Math.round( getStyleSize( style.width ) ) == 200; 3257 getSize.isBoxSizeOuter = isBoxSizeOuter; 3258 3259 body.removeChild( div ); 3260} 3261 3262// -------------------------- getSize -------------------------- // 3263 3264function getSize( elem ) { 3265 setup(); 3266 3267 // use querySeletor if elem is string 3268 if ( typeof elem == 'string' ) { 3269 elem = document.querySelector( elem ); 3270 } 3271 3272 // do not proceed on non-objects 3273 if ( !elem || typeof elem != 'object' || !elem.nodeType ) { 3274 return; 3275 } 3276 3277 var style = getStyle( elem ); 3278 3279 // if hidden, everything is 0 3280 if ( style.display == 'none' ) { 3281 return getZeroSize(); 3282 } 3283 3284 var size = {}; 3285 size.width = elem.offsetWidth; 3286 size.height = elem.offsetHeight; 3287 3288 var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box'; 3289 3290 // get all measurements 3291 for ( var i=0; i < measurementsLength; i++ ) { 3292 var measurement = measurements[i]; 3293 var value = style[ measurement ]; 3294 var num = parseFloat( value ); 3295 // any 'auto', 'medium' value will be 0 3296 size[ measurement ] = !isNaN( num ) ? num : 0; 3297 } 3298 3299 var paddingWidth = size.paddingLeft + size.paddingRight; 3300 var paddingHeight = size.paddingTop + size.paddingBottom; 3301 var marginWidth = size.marginLeft + size.marginRight; 3302 var marginHeight = size.marginTop + size.marginBottom; 3303 var borderWidth = size.borderLeftWidth + size.borderRightWidth; 3304 var borderHeight = size.borderTopWidth + size.borderBottomWidth; 3305 3306 var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter; 3307 3308 // overwrite width and height if we can get it from style 3309 var styleWidth = getStyleSize( style.width ); 3310 if ( styleWidth !== false ) { 3311 size.width = styleWidth + 3312 // add padding and border unless it's already including it 3313 ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth ); 3314 } 3315 3316 var styleHeight = getStyleSize( style.height ); 3317 if ( styleHeight !== false ) { 3318 size.height = styleHeight + 3319 // add padding and border unless it's already including it 3320 ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight ); 3321 } 3322 3323 size.innerWidth = size.width - ( paddingWidth + borderWidth ); 3324 size.innerHeight = size.height - ( paddingHeight + borderHeight ); 3325 3326 size.outerWidth = size.width + marginWidth; 3327 size.outerHeight = size.height + marginHeight; 3328 3329 return size; 3330} 3331 3332return getSize; 3333 3334}); 3335 3336 3337/***/ }), 3338
vendor: 1,850 bytes, lines 3339-3397
3339/***/ "./node_modules/gsap/AttrPlugin.js": 3340/*!*****************************************!*\ 3341 !*** ./node_modules/gsap/AttrPlugin.js ***! 3342 \*****************************************/ 3343/*! exports provided: AttrPlugin, default */ 3344/***/ (function(module, __webpack_exports__, __webpack_require__) { 3345 3346"use strict"; 3347__webpack_require__.r(__webpack_exports__); 3348/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AttrPlugin", function() { return AttrPlugin; }); 3349/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AttrPlugin; }); 3350/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 3351/*! 3352 * VERSION: 0.6.1 3353 * DATE: 2018-08-27 3354 * UPDATES AND DOCS AT: http://greensock.com 3355 * 3356 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 3357 * This work is subject to the terms at http://greensock.com/standard-license or for 3358 * Club GreenSock members, the software agreement that was issued with your membership. 3359 * 3360 * @author: Jack Doyle, [email protected] 3361 */ 3362/* eslint-disable */ 3363 3364 3365 3366var AttrPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 3367 propName: "attr", 3368 API: 2, 3369 version: "0.6.1", 3370 3371 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 3372 init: function(target, value, tween, index) { 3373 var p, end; 3374 if (typeof(target.setAttribute) !== "function") { 3375 return false; 3376 } 3377 for (p in value) { 3378 end = value[p]; 3379 if (typeof(end) === "function") { 3380 end = end(index, target); 3381 } 3382 this._addTween(target, "setAttribute", target.getAttribute(p) + "", end + "", p, false, p); 3383 this._overwriteProps.push(p); 3384 } 3385 return true; 3386 } 3387 3388}); 3389 3390 3391 3392 3393 3394 3395 3396/***/ }), 3397
vendor: 20,405 bytes, lines 3398-4016
3398/***/ "./node_modules/gsap/BezierPlugin.js": 3399/*!*******************************************!*\ 3400 !*** ./node_modules/gsap/BezierPlugin.js ***! 3401 \*******************************************/ 3402/*! exports provided: BezierPlugin, default */ 3403/***/ (function(module, __webpack_exports__, __webpack_require__) { 3404 3405"use strict"; 3406__webpack_require__.r(__webpack_exports__); 3407/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BezierPlugin", function() { return BezierPlugin; }); 3408/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BezierPlugin; }); 3409/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 3410/*! 3411 * VERSION: 1.3.8 3412 * DATE: 2018-05-30 3413 * UPDATES AND DOCS AT: http://greensock.com 3414 * 3415 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 3416 * This work is subject to the terms at http://greensock.com/standard-license or for 3417 * Club GreenSock members, the software agreement that was issued with your membership. 3418 * 3419 * @author: Jack Doyle, [email protected] 3420 **/ 3421/* eslint-disable */ 3422 3423 3424 var _RAD2DEG = 180 / Math.PI, 3425 _r1 = [], 3426 _r2 = [], 3427 _r3 = [], 3428 _corProps = {}, 3429 _globals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.globals, 3430 Segment = function(a, b, c, d) { 3431 if (c === d) { //if c and d match, the final autoRotate value could lock at -90 degrees, so differentiate them slightly. 3432 c = d - (d - b) / 1000000; 3433 } 3434 if (a === b) { //if a and b match, the starting autoRotate value could lock at -90 degrees, so differentiate them slightly. 3435 b = a + (c - a) / 1000000; 3436 } 3437 this.a = a; 3438 this.b = b; 3439 this.c = c; 3440 this.d = d; 3441 this.da = d - a; 3442 this.ca = c - a; 3443 this.ba = b - a; 3444 }, 3445 _correlate = ",x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,", 3446 cubicToQuadratic = function(a, b, c, d) { 3447 var q1 = {a:a}, 3448 q2 = {}, 3449 q3 = {}, 3450 q4 = {c:d}, 3451 mab = (a + b) / 2, 3452 mbc = (b + c) / 2, 3453 mcd = (c + d) / 2, 3454 mabc = (mab + mbc) / 2, 3455 mbcd = (mbc + mcd) / 2, 3456 m8 = (mbcd - mabc) / 8; 3457 q1.b = mab + (a - mab) / 4; 3458 q2.b = mabc + m8; 3459 q1.c = q2.a = (q1.b + q2.b) / 2; 3460 q2.c = q3.a = (mabc + mbcd) / 2; 3461 q3.b = mbcd - m8; 3462 q4.b = mcd + (d - mcd) / 4; 3463 q3.c = q4.a = (q3.b + q4.b) / 2; 3464 return [q1, q2, q3, q4]; 3465 }, 3466 _calculateControlPoints = function(a, curviness, quad, basic, correlate) { 3467 var l = a.length - 1, 3468 ii = 0, 3469 cp1 = a[0].a, 3470 i, p1, p2, p3, seg, m1, m2, mm, cp2, qb, r1, r2, tl; 3471 for (i = 0; i < l; i++) { 3472 seg = a[ii]; 3473 p1 = seg.a; 3474 p2 = seg.d; 3475 p3 = a[ii+1].d; 3476 3477 if (correlate) { 3478 r1 = _r1[i]; 3479 r2 = _r2[i]; 3480 tl = ((r2 + r1) * curviness * 0.25) / (basic ? 0.5 : _r3[i] || 0.5); 3481 m1 = p2 - (p2 - p1) * (basic ? curviness * 0.5 : (r1 !== 0 ? tl / r1 : 0)); 3482 m2 = p2 + (p3 - p2) * (basic ? curviness * 0.5 : (r2 !== 0 ? tl / r2 : 0)); 3483 mm = p2 - (m1 + (((m2 - m1) * ((r1 * 3 / (r1 + r2)) + 0.5) / 4) || 0)); 3484 } else { 3485 m1 = p2 - (p2 - p1) * curviness * 0.5; 3486 m2 = p2 + (p3 - p2) * curviness * 0.5; 3487 mm = p2 - (m1 + m2) / 2; 3488 } 3489 m1 += mm; 3490 m2 += mm; 3491 3492 seg.c = cp2 = m1; 3493 if (i !== 0) { 3494 seg.b = cp1; 3495 } else { 3496 seg.b = cp1 = seg.a + (seg.c - seg.a) * 0.6; //instead of placing b on a exactly, we move it inline with c so that if the user specifies an ease like Back.easeIn or Elastic.easeIn which goes BEYOND the beginning, it will do so smoothly. 3497 } 3498 3499 seg.da = p2 - p1; 3500 seg.ca = cp2 - p1; 3501 seg.ba = cp1 - p1; 3502 3503 if (quad) { 3504 qb = cubicToQuadratic(p1, cp1, cp2, p2); 3505 a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]); 3506 ii += 4; 3507 } else { 3508 ii++; 3509 } 3510 3511 cp1 = m2; 3512 } 3513 seg = a[ii]; 3514 seg.b = cp1; 3515 seg.c = cp1 + (seg.d - cp1) * 0.4; //instead of placing c on d exactly, we move it inline with b so that if the user specifies an ease like Back.easeOut or Elastic.easeOut which goes BEYOND the end, it will do so smoothly. 3516 seg.da = seg.d - seg.a; 3517 seg.ca = seg.c - seg.a; 3518 seg.ba = cp1 - seg.a; 3519 if (quad) { 3520 qb = cubicToQuadratic(seg.a, cp1, seg.c, seg.d); 3521 a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]); 3522 } 3523 }, 3524 _parseAnchors = function(values, p, correlate, prepend) { 3525 var a = [], 3526 l, i, p1, p2, p3, tmp; 3527 if (prepend) { 3528 values = [prepend].concat(values); 3529 i = values.length; 3530 while (--i > -1) { 3531 if (typeof( (tmp = values[i][p]) ) === "string") if (tmp.charAt(1) === "=") { 3532 values[i][p] = prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)); //accommodate relative values. Do it inline instead of breaking it out into a function for speed reasons 3533 } 3534 } 3535 } 3536 l = values.length - 2; 3537 if (l < 0) { 3538 a[0] = new Segment(values[0][p], 0, 0, values[0][p]); 3539 return a; 3540 } 3541 for (i = 0; i < l; i++) { 3542 p1 = values[i][p]; 3543 p2 = values[i+1][p]; 3544 a[i] = new Segment(p1, 0, 0, p2); 3545 if (correlate) { 3546 p3 = values[i+2][p]; 3547 _r1[i] = (_r1[i] || 0) + (p2 - p1) * (p2 - p1); 3548 _r2[i] = (_r2[i] || 0) + (p3 - p2) * (p3 - p2); 3549 } 3550 } 3551 a[i] = new Segment(values[i][p], 0, 0, values[i+1][p]); 3552 return a; 3553 }, 3554 bezierThrough = function(values, curviness, quadratic, basic, correlate, prepend) { 3555 var obj = {}, 3556 props = [], 3557 first = prepend || values[0], 3558 i, p, a, j, r, l, seamless, last; 3559 correlate = (typeof(correlate) === "string") ? ","+correlate+"," : _correlate; 3560 if (curviness == null) { 3561 curviness = 1; 3562 } 3563 for (p in values[0]) { 3564 props.push(p); 3565 } 3566 //check to see if the last and first values are identical (well, within 0.05). If so, make seamless by appending the second element to the very end of the values array and the 2nd-to-last element to the very beginning (we'll remove those segments later) 3567 if (values.length > 1) { 3568 last = values[values.length - 1]; 3569 seamless = true; 3570 i = props.length; 3571 while (--i > -1) { 3572 p = props[i]; 3573 if (Math.abs(first[p] - last[p]) > 0.05) { //build in a tolerance of +/-0.05 to accommodate rounding errors. 3574 seamless = false; 3575 break; 3576 } 3577 } 3578 if (seamless) { 3579 values = values.concat(); //duplicate the array to avoid contaminating the original which the user may be reusing for other tweens 3580 if (prepend) { 3581 values.unshift(prepend); 3582 } 3583 values.push(values[1]); 3584 prepend = values[values.length - 3]; 3585 } 3586 } 3587 _r1.length = _r2.length = _r3.length = 0; 3588 i = props.length; 3589 while (--i > -1) { 3590 p = props[i]; 3591 _corProps[p] = (correlate.indexOf(","+p+",") !== -1); 3592 obj[p] = _parseAnchors(values, p, _corProps[p], prepend); 3593 } 3594 i = _r1.length; 3595 while (--i > -1) { 3596 _r1[i] = Math.sqrt(_r1[i]); 3597 _r2[i] = Math.sqrt(_r2[i]); 3598 } 3599 if (!basic) { 3600 i = props.length; 3601 while (--i > -1) { 3602 if (_corProps[p]) { 3603 a = obj[props[i]]; 3604 l = a.length - 1; 3605 for (j = 0; j < l; j++) { 3606 r = (a[j+1].da / _r2[j] + a[j].da / _r1[j]) || 0; 3607 _r3[j] = (_r3[j] || 0) + r * r; 3608 } 3609 } 3610 } 3611 i = _r3.length; 3612 while (--i > -1) { 3613 _r3[i] = Math.sqrt(_r3[i]); 3614 } 3615 } 3616 i = props.length; 3617 j = quadratic ? 4 : 1; 3618 while (--i > -1) { 3619 p = props[i]; 3620 a = obj[p]; 3621 _calculateControlPoints(a, curviness, quadratic, basic, _corProps[p]); //this method requires that _parseAnchors() and _setSegmentRatios() ran first so that _r1, _r2, and _r3 values are populated for all properties 3622 if (seamless) { 3623 a.splice(0, j); 3624 a.splice(a.length - j, j); 3625 } 3626 } 3627 return obj; 3628 }, 3629 _parseBezierData = function(values, type, prepend) { 3630 type = type || "soft"; 3631 var obj = {}, 3632 inc = (type === "cubic") ? 3 : 2, 3633 soft = (type === "soft"), 3634 props = [], 3635 a, b, c, d, cur, i, j, l, p, cnt, tmp; 3636 if (soft && prepend) { 3637 values = [prepend].concat(values); 3638 } 3639 if (values == null || values.length < inc + 1) { throw "invalid Bezier data"; } 3640 for (p in values[0]) { 3641 props.push(p); 3642 } 3643 i = props.length; 3644 while (--i > -1) { 3645 p = props[i]; 3646 obj[p] = cur = []; 3647 cnt = 0; 3648 l = values.length; 3649 for (j = 0; j < l; j++) { 3650 a = (prepend == null) ? values[j][p] : (typeof( (tmp = values[j][p]) ) === "string" && tmp.charAt(1) === "=") ? prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)) : Number(tmp); 3651 if (soft) if (j > 1) if (j < l - 1) { 3652 cur[cnt++] = (a + cur[cnt-2]) / 2; 3653 } 3654 cur[cnt++] = a; 3655 } 3656 l = cnt - inc + 1; 3657 cnt = 0; 3658 for (j = 0; j < l; j += inc) { 3659 a = cur[j]; 3660 b = cur[j+1]; 3661 c = cur[j+2]; 3662 d = (inc === 2) ? 0 : cur[j+3]; 3663 cur[cnt++] = tmp = (inc === 3) ? new Segment(a, b, c, d) : new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c); 3664 } 3665 cur.length = cnt; 3666 } 3667 return obj; 3668 }, 3669 _addCubicLengths = function(a, steps, resolution) { 3670 var inc = 1 / resolution, 3671 j = a.length, 3672 d, d1, s, da, ca, ba, p, i, inv, bez, index; 3673 while (--j > -1) { 3674 bez = a[j]; 3675 s = bez.a; 3676 da = bez.d - s; 3677 ca = bez.c - s; 3678 ba = bez.b - s; 3679 d = d1 = 0; 3680 for (i = 1; i <= resolution; i++) { 3681 p = inc * i; 3682 inv = 1 - p; 3683 d = d1 - (d1 = (p * p * da + 3 * inv * (p * ca + inv * ba)) * p); 3684 index = j * resolution + i - 1; 3685 steps[index] = (steps[index] || 0) + d * d; 3686 } 3687 } 3688 }, 3689 _parseLengthData = function(obj, resolution) { 3690 resolution = resolution >> 0 || 6; 3691 var a = [], 3692 lengths = [], 3693 d = 0, 3694 total = 0, 3695 threshold = resolution - 1, 3696 segments = [], 3697 curLS = [], //current length segments array 3698 p, i, l, index; 3699 for (p in obj) { 3700 _addCubicLengths(obj[p], a, resolution); 3701 } 3702 l = a.length; 3703 for (i = 0; i < l; i++) { 3704 d += Math.sqrt(a[i]); 3705 index = i % resolution; 3706 curLS[index] = d; 3707 if (index === threshold) { 3708 total += d; 3709 index = (i / resolution) >> 0; 3710 segments[index] = curLS; 3711 lengths[index] = total; 3712 d = 0; 3713 curLS = []; 3714 } 3715 } 3716 return {length:total, lengths:lengths, segments:segments}; 3717 }, 3718 3719 3720 3721 BezierPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 3722 propName: "bezier", 3723 priority: -1, 3724 version: "1.3.8", 3725 API: 2, 3726 global:true, 3727 3728 //gets called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 3729 init: function(target, vars, tween) { 3730 this._target = target; 3731 if (vars instanceof Array) { 3732 vars = {values:vars}; 3733 } 3734 this._func = {}; 3735 this._mod = {}; 3736 this._props = []; 3737 this._timeRes = (vars.timeResolution == null) ? 6 : parseInt(vars.timeResolution, 10); 3738 var values = vars.values || [], 3739 first = {}, 3740 second = values[0], 3741 autoRotate = vars.autoRotate || tween.vars.orientToBezier, 3742 p, isFunc, i, j, prepend; 3743 3744 this._autoRotate = autoRotate ? (autoRotate instanceof Array) ? autoRotate : [["x","y","rotation",((autoRotate === true) ? 0 : Number(autoRotate) || 0)]] : null; 3745 for (p in second) { 3746 this._props.push(p); 3747 } 3748 3749 i = this._props.length; 3750 while (--i > -1) { 3751 p = this._props[i]; 3752 3753 this._overwriteProps.push(p); 3754 isFunc = this._func[p] = (typeof(target[p]) === "function"); 3755 first[p] = (!isFunc) ? parseFloat(target[p]) : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ](); 3756 if (!prepend) if (first[p] !== values[0][p]) { 3757 prepend = first; 3758 } 3759 } 3760 this._beziers = (vars.type !== "cubic" && vars.type !== "quadratic" && vars.type !== "soft") ? bezierThrough(values, isNaN(vars.curviness) ? 1 : vars.curviness, false, (vars.type === "thruBasic"), vars.correlate, prepend) : _parseBezierData(values, vars.type, first); 3761 this._segCount = this._beziers[p].length; 3762 3763 if (this._timeRes) { 3764 var ld = _parseLengthData(this._beziers, this._timeRes); 3765 this._length = ld.length; 3766 this._lengths = ld.lengths; 3767 this._segments = ld.segments; 3768 this._l1 = this._li = this._s1 = this._si = 0; 3769 this._l2 = this._lengths[0]; 3770 this._curSeg = this._segments[0]; 3771 this._s2 = this._curSeg[0]; 3772 this._prec = 1 / this._curSeg.length; 3773 } 3774 3775 if ((autoRotate = this._autoRotate)) { 3776 this._initialRotations = []; 3777 if (!(autoRotate[0] instanceof Array)) { 3778 this._autoRotate = autoRotate = [autoRotate]; 3779 } 3780 i = autoRotate.length; 3781 while (--i > -1) { 3782 for (j = 0; j < 3; j++) { 3783 p = autoRotate[i][j]; 3784 this._func[p] = (typeof(target[p]) === "function") ? target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ] : false; 3785 } 3786 p = autoRotate[i][2]; 3787 this._initialRotations[i] = (this._func[p] ? this._func[p].call(this._target) : this._target[p]) || 0; 3788 this._overwriteProps.push(p); 3789 } 3790 } 3791 this._startRatio = tween.vars.runBackwards ? 1 : 0; //we determine the starting ratio when the tween inits which is always 0 unless the tween has runBackwards:true (indicating it's a from() tween) in which case it's 1. 3792 return true; 3793 }, 3794 3795 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 3796 set: function(v) { 3797 var segments = this._segCount, 3798 func = this._func, 3799 target = this._target, 3800 notStart = (v !== this._startRatio), 3801 curIndex, inv, i, p, b, t, val, l, lengths, curSeg; 3802 if (!this._timeRes) { 3803 curIndex = (v < 0) ? 0 : (v >= 1) ? segments - 1 : (segments * v) >> 0; 3804 t = (v - (curIndex * (1 / segments))) * segments; 3805 } else { 3806 lengths = this._lengths; 3807 curSeg = this._curSeg; 3808 v *= this._length; 3809 i = this._li; 3810 //find the appropriate segment (if the currently cached one isn't correct) 3811 if (v > this._l2 && i < segments - 1) { 3812 l = segments - 1; 3813 while (i < l && (this._l2 = lengths[++i]) <= v) { } 3814 this._l1 = lengths[i-1]; 3815 this._li = i; 3816 this._curSeg = curSeg = this._segments[i]; 3817 this._s2 = curSeg[(this._s1 = this._si = 0)]; 3818 } else if (v < this._l1 && i > 0) { 3819 while (i > 0 && (this._l1 = lengths[--i]) >= v) { } 3820 if (i === 0 && v < this._l1) { 3821 this._l1 = 0; 3822 } else { 3823 i++; 3824 } 3825 this._l2 = lengths[i]; 3826 this._li = i; 3827 this._curSeg = curSeg = this._segments[i]; 3828 this._s1 = curSeg[(this._si = curSeg.length - 1) - 1] || 0; 3829 this._s2 = curSeg[this._si]; 3830 } 3831 curIndex = i; 3832 //now find the appropriate sub-segment (we split it into the number of pieces that was defined by "precision" and measured each one) 3833 v -= this._l1; 3834 i = this._si; 3835 if (v > this._s2 && i < curSeg.length - 1) { 3836 l = curSeg.length - 1; 3837 while (i < l && (this._s2 = curSeg[++i]) <= v) { } 3838 this._s1 = curSeg[i-1]; 3839 this._si = i; 3840 } else if (v < this._s1 && i > 0) { 3841 while (i > 0 && (this._s1 = curSeg[--i]) >= v) { } 3842 if (i === 0 && v < this._s1) { 3843 this._s1 = 0; 3844 } else { 3845 i++; 3846 } 3847 this._s2 = curSeg[i]; 3848 this._si = i; 3849 } 3850 t = ((i + (v - this._s1) / (this._s2 - this._s1)) * this._prec) || 0; 3851 } 3852 inv = 1 - t; 3853 3854 i = this._props.length; 3855 while (--i > -1) { 3856 p = this._props[i]; 3857 b = this._beziers[p][curIndex]; 3858 val = (t * t * b.da + 3 * inv * (t * b.ca + inv * b.ba)) * t + b.a; 3859 if (this._mod[p]) { 3860 val = this._mod[p](val, target); 3861 } 3862 if (func[p]) { 3863 target[p](val); 3864 } else { 3865 target[p] = val; 3866 } 3867 } 3868 3869 if (this._autoRotate) { 3870 var ar = this._autoRotate, 3871 b2, x1, y1, x2, y2, add, conv; 3872 i = ar.length; 3873 while (--i > -1) { 3874 p = ar[i][2]; 3875 add = ar[i][3] || 0; 3876 conv = (ar[i][4] === true) ? 1 : _RAD2DEG; 3877 b = this._beziers[ar[i][0]]; 3878 b2 = this._beziers[ar[i][1]]; 3879 3880 if (b && b2) { //in case one of the properties got overwritten. 3881 b = b[curIndex]; 3882 b2 = b2[curIndex]; 3883 3884 x1 = b.a + (b.b - b.a) * t; 3885 x2 = b.b + (b.c - b.b) * t; 3886 x1 += (x2 - x1) * t; 3887 x2 += ((b.c + (b.d - b.c) * t) - x2) * t; 3888 3889 y1 = b2.a + (b2.b - b2.a) * t; 3890 y2 = b2.b + (b2.c - b2.b) * t; 3891 y1 += (y2 - y1) * t; 3892 y2 += ((b2.c + (b2.d - b2.c) * t) - y2) * t; 3893 3894 val = notStart ? Math.atan2(y2 - y1, x2 - x1) * conv + add : this._initialRotations[i]; 3895 3896 if (this._mod[p]) { 3897 val = this._mod[p](val, target); //for modProps 3898 } 3899 3900 if (func[p]) { 3901 target[p](val); 3902 } else { 3903 target[p] = val; 3904 } 3905 } 3906 } 3907 } 3908 } 3909 }), 3910 p = BezierPlugin.prototype; 3911 3912 3913 BezierPlugin.bezierThrough = bezierThrough; 3914 BezierPlugin.cubicToQuadratic = cubicToQuadratic; 3915 BezierPlugin._autoCSS = true; //indicates that this plugin can be inserted into the "css" object using the autoCSS feature of TweenLite 3916 BezierPlugin.quadraticToCubic = function(a, b, c) { 3917 return new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c); 3918 }; 3919 3920 BezierPlugin._cssRegister = function() { 3921 var CSSPlugin = _globals.CSSPlugin; 3922 if (!CSSPlugin) { 3923 return; 3924 } 3925 var _internals = CSSPlugin._internals, 3926 _parseToProxy = _internals._parseToProxy, 3927 _setPluginRatio = _internals._setPluginRatio, 3928 CSSPropTween = _internals.CSSPropTween; 3929 _internals._registerComplexSpecialProp("bezier", {parser:function(t, e, prop, cssp, pt, plugin) { 3930 if (e instanceof Array) { 3931 e = {values:e}; 3932 } 3933 plugin = new BezierPlugin(); 3934 var values = e.values, 3935 l = values.length - 1, 3936 pluginValues = [], 3937 v = {}, 3938 i, p, data; 3939 if (l < 0) { 3940 return pt; 3941 } 3942 for (i = 0; i <= l; i++) { 3943 data = _parseToProxy(t, values[i], cssp, pt, plugin, (l !== i)); 3944 pluginValues[i] = data.end; 3945 } 3946 for (p in e) { 3947 v[p] = e[p]; //duplicate the vars object because we need to alter some things which would cause problems if the user plans to reuse the same vars object for another tween. 3948 } 3949 v.values = pluginValues; 3950 pt = new CSSPropTween(t, "bezier", 0, 0, data.pt, 2); 3951 pt.data = data; 3952 pt.plugin = plugin; 3953 pt.setRatio = _setPluginRatio; 3954 if (v.autoRotate === 0) { 3955 v.autoRotate = true; 3956 } 3957 if (v.autoRotate && !(v.autoRotate instanceof Array)) { 3958 i = (v.autoRotate === true) ? 0 : Number(v.autoRotate); 3959 v.autoRotate = (data.end.left != null) ? [["left","top","rotation",i,false]] : (data.end.x != null) ? [["x","y","rotation",i,false]] : false; 3960 } 3961 if (v.autoRotate) { 3962 if (!cssp._transform) { 3963 cssp._enableTransforms(false); 3964 } 3965 data.autoRotate = cssp._target._gsTransform; 3966 data.proxy.rotation = data.autoRotate.rotation || 0; 3967 cssp._overwriteProps.push("rotation"); 3968 } 3969 plugin._onInitTween(data.proxy, v, cssp._tween); 3970 return pt; 3971 }}); 3972 }; 3973 3974 p._mod = function(lookup) { 3975 var op = this._overwriteProps, 3976 i = op.length, 3977 val; 3978 while (--i > -1) { 3979 val = lookup[op[i]]; 3980 if (val && typeof(val) === "function") { 3981 this._mod[op[i]] = val; 3982 } 3983 } 3984 }; 3985 3986 p._kill = function(lookup) { 3987 var a = this._props, 3988 p, i; 3989 for (p in this._beziers) { 3990 if (p in lookup) { 3991 delete this._beziers[p]; 3992 delete this._func[p]; 3993 i = a.length; 3994 while (--i > -1) { 3995 if (a[i] === p) { 3996 a.splice(i, 1); 3997 } 3998 } 3999 } 4000 } 4001 a = this._autoRotate; 4002 if (a) { 4003 i = a.length; 4004 while (--i > -1) { 4005 if (lookup[a[i][2]]) { 4006 a.splice(i, 1); 4007 } 4008 } 4009 } 4010 return this._super._kill.call(this, lookup); 4011 }; 4012 4013 4014 4015/***/ }), 4016
vendor: 163,546 bytes, lines 4017-6948
4017/***/ "./node_modules/gsap/CSSPlugin.js": 4018/*!****************************************!*\ 4019 !*** ./node_modules/gsap/CSSPlugin.js ***! 4020 \****************************************/ 4021/*! exports provided: CSSPlugin, default */ 4022/***/ (function(module, __webpack_exports__, __webpack_require__) { 4023 4024"use strict"; 4025__webpack_require__.r(__webpack_exports__); 4026/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CSSPlugin", function() { return CSSPlugin; }); 4027/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return CSSPlugin; }); 4028/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 4029/*! 4030 * VERSION: 2.1.0 4031 * DATE: 2019-02-15 4032 * UPDATES AND DOCS AT: http://greensock.com 4033 * 4034 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 4035 * This work is subject to the terms at http://greensock.com/standard-license or for 4036 * Club GreenSock members, the software agreement that was issued with your membership. 4037 * 4038 * @author: Jack Doyle, [email protected] 4039 */ 4040/* eslint-disable */ 4041 4042 4043 4044 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("plugins.CSSPlugin", ["plugins.TweenPlugin","TweenLite"], function() { 4045 4046 /** @constructor **/ 4047 var CSSPlugin = function() { 4048 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"].call(this, "css"); 4049 this._overwriteProps.length = 0; 4050 this.setRatio = CSSPlugin.prototype.setRatio; //speed optimization (avoid prototype lookup on this "hot" method) 4051 }, 4052 _globals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.globals, 4053 _hasPriority, //turns true whenever a CSSPropTween instance is created that has a priority other than 0. This helps us discern whether or not we should spend the time organizing the linked list or not after a CSSPlugin's _onInitTween() method is called. 4054 _suffixMap, //we set this in _onInitTween() each time as a way to have a persistent variable we can use in other methods like _parse() without having to pass it around as a parameter and we keep _parse() decoupled from a particular CSSPlugin instance 4055 _cs, //computed style (we store this in a shared variable to conserve memory and make minification tighter 4056 _overwriteProps, //alias to the currently instantiating CSSPlugin's _overwriteProps array. We use this closure in order to avoid having to pass a reference around from method to method and aid in minification. 4057 _specialProps = {}, 4058 p = CSSPlugin.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"]("css"); 4059 4060 p.constructor = CSSPlugin; 4061 CSSPlugin.version = "2.1.0"; 4062 CSSPlugin.API = 2; 4063 CSSPlugin.defaultTransformPerspective = 0; 4064 CSSPlugin.defaultSkewType = "compensated"; 4065 CSSPlugin.defaultSmoothOrigin = true; 4066 p = "px"; //we'll reuse the "p" variable to keep file size down 4067 CSSPlugin.suffixMap = {top:p, right:p, bottom:p, left:p, width:p, height:p, fontSize:p, padding:p, margin:p, perspective:p, lineHeight:""}; 4068 4069 4070 var _numExp = /(?:\-|\.|\b)(\d|\.|e\-)+/g, 4071 _relNumExp = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g, 4072 _valuesExp = /(?:\+=|\-=|\-|\b)[\d\-\.]+[a-zA-Z0-9]*(?:%|\b)/gi, //finds all the values that begin with numbers or += or -= and then a number. Includes suffixes. We use this to split complex values apart like "1px 5px 20px rgb(255,102,51)" 4073 _NaNExp = /(?![+-]?\d*\.?\d+|[+-]|e[+-]\d+)[^0-9]/g, //also allows scientific notation and doesn't kill the leading -/+ in -= and += 4074 _suffixExp = /(?:\d|\-|\+|=|#|\.)*/g, 4075 _opacityExp = /opacity *= *([^)]*)/i, 4076 _opacityValExp = /opacity:([^;]*)/i, 4077 _alphaFilterExp = /alpha\(opacity *=.+?\)/i, 4078 _rgbhslExp = /^(rgb|hsl)/, 4079 _capsExp = /([A-Z])/g, 4080 _camelExp = /-([a-z])/gi, 4081 _urlExp = /(^(?:url\(\"|url\())|(?:(\"\))$|\)$)/gi, //for pulling out urls from url(...) or url("...") strings (some browsers wrap urls in quotes, some don't when reporting things like backgroundImage) 4082 _camelFunc = function(s, g) { return g.toUpperCase(); }, 4083 _horizExp = /(?:Left|Right|Width)/i, 4084 _ieGetMatrixExp = /(M11|M12|M21|M22)=[\d\-\.e]+/gi, 4085 _ieSetMatrixExp = /progid\:DXImageTransform\.Microsoft\.Matrix\(.+?\)/i, 4086 _commasOutsideParenExp = /,(?=[^\)]*(?:\(|$))/gi, //finds any commas that are not within parenthesis 4087 _complexExp = /[\s,\(]/i, //for testing a string to find if it has a space, comma, or open parenthesis (clues that it's a complex value) 4088 _DEG2RAD = Math.PI / 180, 4089 _RAD2DEG = 180 / Math.PI, 4090 _forcePT = {}, 4091 _dummyElement = {style:{}}, 4092 _doc = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].document || {createElement: function() {return _dummyElement;}}, 4093 _createElement = function(type, ns) { 4094 return (ns && _doc.createElementNS) ? _doc.createElementNS(ns, type) : _doc.createElement(type); 4095 }, 4096 _tempDiv = _createElement("div"), 4097 _tempImg = _createElement("img"), 4098 _internals = CSSPlugin._internals = {_specialProps:_specialProps}, //provides a hook to a few internal methods that we need to access from inside other plugins 4099 _agent = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].navigator || {}).userAgent || "", 4100 _autoRound, 4101 _reqSafariFix, //we won't apply the Safari transform fix until we actually come across a tween that affects a transform property (to maintain best performance). 4102 4103 _isSafari, 4104 _isFirefox, //Firefox has a bug that causes 3D transformed elements to randomly disappear unless a repaint is forced after each update on each element. 4105 _isSafariLT6, //Safari (and Android 4 which uses a flavor of Safari) has a bug that prevents changes to "top" and "left" properties from rendering properly if changed on the same frame as a transform UNLESS we set the element's WebkitBackfaceVisibility to hidden (weird, I know). Doing this for Android 3 and earlier seems to actually cause other problems, though (fun!) 4106 _ieVers, 4107 _supportsOpacity = (function() { //we set _isSafari, _ieVers, _isFirefox, and _supportsOpacity all in one function here to reduce file size slightly, especially in the minified version. 4108 var i = _agent.indexOf("Android"), 4109 a = _createElement("a"); 4110 _isSafari = (_agent.indexOf("Safari") !== -1 && _agent.indexOf("Chrome") === -1 && (i === -1 || parseFloat(_agent.substr(i+8, 2)) > 3)); 4111 _isSafariLT6 = (_isSafari && (parseFloat(_agent.substr(_agent.indexOf("Version/")+8, 2)) < 6)); 4112 _isFirefox = (_agent.indexOf("Firefox") !== -1); 4113 if ((/MSIE ([0-9]{1,}[\.0-9]{0,})/).exec(_agent) || (/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/).exec(_agent)) { 4114 _ieVers = parseFloat( RegExp.$1 ); 4115 } 4116 if (!a) { 4117 return false; 4118 } 4119 a.style.cssText = "top:1px;opacity:.55;"; 4120 return /^0.55/.test(a.style.opacity); 4121 }()), 4122 _getIEOpacity = function(v) { 4123 return (_opacityExp.test( ((typeof(v) === "string") ? v : (v.currentStyle ? v.currentStyle.filter : v.style.filter) || "") ) ? ( parseFloat( RegExp.$1 ) / 100 ) : 1); 4124 }, 4125 _log = function(s) {//for logging messages, but in a way that won't throw errors in old versions of IE. 4126 if (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].console) { 4127 console.log(s); 4128 } 4129 }, 4130 _target, //when initting a CSSPlugin, we set this variable so that we can access it from within many other functions without having to pass it around as params 4131 _index, //when initting a CSSPlugin, we set this variable so that we can access it from within many other functions without having to pass it around as params 4132 4133 _prefixCSS = "", //the non-camelCase vendor prefix like "-o-", "-moz-", "-ms-", or "-webkit-" 4134 _prefix = "", //camelCase vendor prefix like "O", "ms", "Webkit", or "Moz". 4135 4136 // @private feed in a camelCase property name like "transform" and it will check to see if it is valid as-is or if it needs a vendor prefix. It returns the corrected camelCase property name (i.e. "WebkitTransform" or "MozTransform" or "transform" or null if no such property is found, like if the browser is IE8 or before, "transform" won't be found at all) 4137 _checkPropPrefix = function(p, e) { 4138 e = e || _tempDiv; 4139 var s = e.style, 4140 a, i; 4141 if (s[p] !== undefined) { 4142 return p; 4143 } 4144 p = p.charAt(0).toUpperCase() + p.substr(1); 4145 a = ["O","Moz","ms","Ms","Webkit"]; 4146 i = 5; 4147 while (--i > -1 && s[a[i]+p] === undefined) { } 4148 if (i >= 0) { 4149 _prefix = (i === 3) ? "ms" : a[i]; 4150 _prefixCSS = "-" + _prefix.toLowerCase() + "-"; 4151 return _prefix + p; 4152 } 4153 return null; 4154 }, 4155 4156 _computedStyleScope = (typeof(window) !== "undefined" ? window : _doc.defaultView || {getComputedStyle:function() {}}), 4157 _getComputedStyle = function(e) { 4158 return _computedStyleScope.getComputedStyle(e); //to avoid errors in Microsoft Edge, we need to call getComputedStyle() from a specific scope, typically window. 4159 }, 4160 4161 /** 4162 * @private Returns the css style for a particular property of an element. For example, to get whatever the current "left" css value for an element with an ID of "myElement", you could do: 4163 * var currentLeft = CSSPlugin.getStyle( document.getElementById("myElement"), "left"); 4164 * 4165 * @param {!Object} t Target element whose style property you want to query 4166 * @param {!string} p Property name (like "left" or "top" or "marginTop", etc.) 4167 * @param {Object=} cs Computed style object. This just provides a way to speed processing if you're going to get several properties on the same element in quick succession - you can reuse the result of the getComputedStyle() call. 4168 * @param {boolean=} calc If true, the value will not be read directly from the element's "style" property (if it exists there), but instead the getComputedStyle() result will be used. This can be useful when you want to ensure that the browser itself is interpreting the value. 4169 * @param {string=} dflt Default value that should be returned in the place of null, "none", "auto" or "auto auto". 4170 * @return {?string} The current property value 4171 */ 4172 _getStyle = CSSPlugin.getStyle = function(t, p, cs, calc, dflt) { 4173 var rv; 4174 if (!_supportsOpacity) if (p === "opacity") { //several versions of IE don't use the standard "opacity" property - they use things like filter:alpha(opacity=50), so we parse that here. 4175 return _getIEOpacity(t); 4176 } 4177 if (!calc && t.style[p]) { 4178 rv = t.style[p]; 4179 } else if ((cs = cs || _getComputedStyle(t))) { 4180 rv = cs[p] || cs.getPropertyValue(p) || cs.getPropertyValue(p.replace(_capsExp, "-$1").toLowerCase()); 4181 } else if (t.currentStyle) { 4182 rv = t.currentStyle[p]; 4183 } 4184 return (dflt != null && (!rv || rv === "none" || rv === "auto" || rv === "auto auto")) ? dflt : rv; 4185 }, 4186 4187 /** 4188 * @private Pass the target element, the property name, the numeric value, and the suffix (like "%", "em", "px", etc.) and it will spit back the equivalent pixel number. 4189 * @param {!Object} t Target element 4190 * @param {!string} p Property name (like "left", "top", "marginLeft", etc.) 4191 * @param {!number} v Value 4192 * @param {string=} sfx Suffix (like "px" or "%" or "em") 4193 * @param {boolean=} recurse If true, the call is a recursive one. In some browsers (like IE7/8), occasionally the value isn't accurately reported initially, but if we run the function again it will take effect. 4194 * @return {number} value in pixels 4195 */ 4196 _convertToPixels = _internals.convertToPixels = function(t, p, v, sfx, recurse) { 4197 if (sfx === "px" || (!sfx && p !== "lineHeight")) { return v; } 4198 if (sfx === "auto" || !v) { return 0; } 4199 var horiz = _horizExp.test(p), 4200 node = t, 4201 style = _tempDiv.style, 4202 neg = (v < 0), 4203 precise = (v === 1), 4204 pix, cache, time; 4205 if (neg) { 4206 v = -v; 4207 } 4208 if (precise) { 4209 v *= 100; 4210 } 4211 if (p === "lineHeight" && !sfx) { //special case of when a simple lineHeight (without a unit) is used. Set it to the value, read back the computed value, and then revert. 4212 cache = _getComputedStyle(t).lineHeight; 4213 t.style.lineHeight = v; 4214 pix = parseFloat(_getComputedStyle(t).lineHeight); 4215 t.style.lineHeight = cache; 4216 } else if (sfx === "%" && p.indexOf("border") !== -1) { 4217 pix = (v / 100) * (horiz ? t.clientWidth : t.clientHeight); 4218 } else { 4219 style.cssText = "border:0 solid red;position:" + _getStyle(t, "position") + ";line-height:0;"; 4220 if (sfx === "%" || !node.appendChild || sfx.charAt(0) === "v" || sfx === "rem") { 4221 node = t.parentNode || _doc.body; 4222 if (_getStyle(node, "display").indexOf("flex") !== -1) { //Edge and IE11 have a bug that causes offsetWidth to report as 0 if the container has display:flex and the child is position:relative. Switching to position: absolute solves it. 4223 style.position = "absolute"; 4224 } 4225 cache = node._gsCache; 4226 time = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.frame; 4227 if (cache && horiz && cache.time === time) { //performance optimization: we record the width of elements along with the ticker frame so that we can quickly get it again on the same tick (seems relatively safe to assume it wouldn't change on the same tick) 4228 return cache.width * v / 100; 4229 } 4230 style[(horiz ? "width" : "height")] = v + sfx; 4231 } else { 4232 style[(horiz ? "borderLeftWidth" : "borderTopWidth")] = v + sfx; 4233 } 4234 node.appendChild(_tempDiv); 4235 pix = parseFloat(_tempDiv[(horiz ? "offsetWidth" : "offsetHeight")]); 4236 node.removeChild(_tempDiv); 4237 if (horiz && sfx === "%" && CSSPlugin.cacheWidths !== false) { 4238 cache = node._gsCache = node._gsCache || {}; 4239 cache.time = time; 4240 cache.width = pix / v * 100; 4241 } 4242 if (pix === 0 && !recurse) { 4243 pix = _convertToPixels(t, p, v, sfx, true); 4244 } 4245 } 4246 if (precise) { 4247 pix /= 100; 4248 } 4249 return neg ? -pix : pix; 4250 }, 4251 _calculateOffset = _internals.calculateOffset = function(t, p, cs) { //for figuring out "top" or "left" in px when it's "auto". We need to factor in margin with the offsetLeft/offsetTop 4252 if (_getStyle(t, "position", cs) !== "absolute") { return 0; } 4253 var dim = ((p === "left") ? "Left" : "Top"), 4254 v = _getStyle(t, "margin" + dim, cs); 4255 return t["offset" + dim] - (_convertToPixels(t, p, parseFloat(v), v.replace(_suffixExp, "")) || 0); 4256 }, 4257 4258 // @private returns at object containing ALL of the style properties in camelCase and their associated values. 4259 _getAllStyles = function(t, cs) { 4260 var s = {}, 4261 i, tr, p; 4262 if ((cs = cs || _getComputedStyle(t, null))) { 4263 if ((i = cs.length)) { 4264 while (--i > -1) { 4265 p = cs[i]; 4266 if (p.indexOf("-transform") === -1 || _transformPropCSS === p) { //Some webkit browsers duplicate transform values, one non-prefixed and one prefixed ("transform" and "WebkitTransform"), so we must weed out the extra one here. 4267 s[p.replace(_camelExp, _camelFunc)] = cs.getPropertyValue(p); 4268 } 4269 } 4270 } else { //some browsers behave differently - cs.length is always 0, so we must do a for...in loop. 4271 for (i in cs) { 4272 if (i.indexOf("Transform") === -1 || _transformProp === i) { //Some webkit browsers duplicate transform values, one non-prefixed and one prefixed ("transform" and "WebkitTransform"), so we must weed out the extra one here. 4273 s[i] = cs[i]; 4274 } 4275 } 4276 } 4277 } else if ((cs = t.currentStyle || t.style)) { 4278 for (i in cs) { 4279 if (typeof(i) === "string" && s[i] === undefined) { 4280 s[i.replace(_camelExp, _camelFunc)] = cs[i]; 4281 } 4282 } 4283 } 4284 if (!_supportsOpacity) { 4285 s.opacity = _getIEOpacity(t); 4286 } 4287 tr = _getTransform(t, cs, false); 4288 s.rotation = tr.rotation; 4289 s.skewX = tr.skewX; 4290 s.scaleX = tr.scaleX; 4291 s.scaleY = tr.scaleY; 4292 s.x = tr.x; 4293 s.y = tr.y; 4294 if (_supports3D) { 4295 s.z = tr.z; 4296 s.rotationX = tr.rotationX; 4297 s.rotationY = tr.rotationY; 4298 s.scaleZ = tr.scaleZ; 4299 } 4300 if (s.filters) { 4301 delete s.filters; 4302 } 4303 return s; 4304 }, 4305 4306 // @private analyzes two style objects (as returned by _getAllStyles()) and only looks for differences between them that contain tweenable values (like a number or color). It returns an object with a "difs" property which refers to an object containing only those isolated properties and values for tweening, and a "firstMPT" property which refers to the first MiniPropTween instance in a linked list that recorded all the starting values of the different properties so that we can revert to them at the end or beginning of the tween - we don't want the cascading to get messed up. The forceLookup parameter is an optional generic object with properties that should be forced into the results - this is necessary for className tweens that are overwriting others because imagine a scenario where a rollover/rollout adds/removes a class and the user swipes the mouse over the target SUPER fast, thus nothing actually changed yet and the subsequent comparison of the properties would indicate they match (especially when px rounding is taken into consideration), thus no tweening is necessary even though it SHOULD tween and remove those properties after the tween (otherwise the inline styles will contaminate things). See the className SpecialProp code for details. 4307 _cssDif = function(t, s1, s2, vars, forceLookup) { 4308 var difs = {}, 4309 style = t.style, 4310 val, p, mpt; 4311 for (p in s2) { 4312 if (p !== "cssText") if (p !== "length") if (isNaN(p)) if (s1[p] !== (val = s2[p]) || (forceLookup && forceLookup[p])) if (p.indexOf("Origin") === -1) if (typeof(val) === "number" || typeof(val) === "string") { 4313 difs[p] = (val === "auto" && (p === "left" || p === "top")) ? _calculateOffset(t, p) : ((val === "" || val === "auto" || val === "none") && typeof(s1[p]) === "string" && s1[p].replace(_NaNExp, "") !== "") ? 0 : val; //if the ending value is defaulting ("" or "auto"), we check the starting value and if it can be parsed into a number (a string which could have a suffix too, like 700px), then we swap in 0 for "" or "auto" so that things actually tween. 4314 if (style[p] !== undefined) { //for className tweens, we must remember which properties already existed inline - the ones that didn't should be removed when the tween isn't in progress because they were only introduced to facilitate the transition between classes. 4315 mpt = new MiniPropTween(style, p, style[p], mpt); 4316 } 4317 } 4318 } 4319 if (vars) { 4320 for (p in vars) { //copy properties (except className) 4321 if (p !== "className") { 4322 difs[p] = vars[p]; 4323 } 4324 } 4325 } 4326 return {difs:difs, firstMPT:mpt}; 4327 }, 4328 _dimensions = {width:["Left","Right"], height:["Top","Bottom"]}, 4329 _margins = ["marginLeft","marginRight","marginTop","marginBottom"], 4330 4331 /** 4332 * @private Gets the width or height of an element 4333 * @param {!Object} t Target element 4334 * @param {!string} p Property name ("width" or "height") 4335 * @param {Object=} cs Computed style object (if one exists). Just a speed optimization. 4336 * @return {number} Dimension (in pixels) 4337 */ 4338 _getDimension = function(t, p, cs) { 4339 if ((t.nodeName + "").toLowerCase() === "svg") { //Chrome no longer supports offsetWidth/offsetHeight on SVG elements. 4340 return (cs || _getComputedStyle(t))[p] || 0; 4341 } else if (t.getCTM && _isSVG(t)) { 4342 return t.getBBox()[p] || 0; 4343 } 4344 var v = parseFloat((p === "width") ? t.offsetWidth : t.offsetHeight), 4345 a = _dimensions[p], 4346 i = a.length; 4347 cs = cs || _getComputedStyle(t, null); 4348 while (--i > -1) { 4349 v -= parseFloat( _getStyle(t, "padding" + a[i], cs, true) ) || 0; 4350 v -= parseFloat( _getStyle(t, "border" + a[i] + "Width", cs, true) ) || 0; 4351 } 4352 return v; 4353 }, 4354 4355 // @private Parses position-related complex strings like "top left" or "50px 10px" or "70% 20%", etc. which are used for things like transformOrigin or backgroundPosition. Optionally decorates a supplied object (recObj) with the following properties: "ox" (offsetX), "oy" (offsetY), "oxp" (if true, "ox" is a percentage not a pixel value), and "oxy" (if true, "oy" is a percentage not a pixel value) 4356 _parsePosition = function(v, recObj) { 4357 if (v === "contain" || v === "auto" || v === "auto auto") { //note: Firefox uses "auto auto" as default whereas Chrome uses "auto". 4358 return v + " "; 4359 } 4360 if (v == null || v === "") { 4361 v = "0 0"; 4362 } 4363 var a = v.split(" "), 4364 x = (v.indexOf("left") !== -1) ? "0%" : (v.indexOf("right") !== -1) ? "100%" : a[0], 4365 y = (v.indexOf("top") !== -1) ? "0%" : (v.indexOf("bottom") !== -1) ? "100%" : a[1], 4366 i; 4367 if (a.length > 3 && !recObj) { //multiple positions 4368 a = v.split(", ").join(",").split(","); 4369 v = []; 4370 for (i = 0; i < a.length; i++) { 4371 v.push(_parsePosition(a[i])); 4372 } 4373 return v.join(","); 4374 } 4375 if (y == null) { 4376 y = (x === "center") ? "50%" : "0"; 4377 } else if (y === "center") { 4378 y = "50%"; 4379 } 4380 if (x === "center" || (isNaN(parseFloat(x)) && (x + "").indexOf("=") === -1)) { //remember, the user could flip-flop the values and say "bottom center" or "center bottom", etc. "center" is ambiguous because it could be used to describe horizontal or vertical, hence the isNaN(). If there's an "=" sign in the value, it's relative. 4381 x = "50%"; 4382 } 4383 v = x + " " + y + ((a.length > 2) ? " " + a[2] : ""); 4384 if (recObj) { 4385 recObj.oxp = (x.indexOf("%") !== -1); 4386 recObj.oyp = (y.indexOf("%") !== -1); 4387 recObj.oxr = (x.charAt(1) === "="); 4388 recObj.oyr = (y.charAt(1) === "="); 4389 recObj.ox = parseFloat(x.replace(_NaNExp, "")); 4390 recObj.oy = parseFloat(y.replace(_NaNExp, "")); 4391 recObj.v = v; 4392 } 4393 return recObj || v; 4394 }, 4395 4396 /** 4397 * @private Takes an ending value (typically a string, but can be a number) and a starting value and returns the change between the two, looking for relative value indicators like += and -= and it also ignores suffixes (but make sure the ending value starts with a number or +=/-= and that the starting value is a NUMBER!) 4398 * @param {(number|string)} e End value which is typically a string, but could be a number 4399 * @param {(number|string)} b Beginning value which is typically a string but could be a number 4400 * @return {number} Amount of change between the beginning and ending values (relative values that have a "+=" or "-=" are recognized) 4401 */ 4402 _parseChange = function(e, b) { 4403 if (typeof(e) === "function") { 4404 e = e(_index, _target); 4405 } 4406 return (typeof(e) === "string" && e.charAt(1) === "=") ? parseInt(e.charAt(0) + "1", 10) * parseFloat(e.substr(2)) : (parseFloat(e) - parseFloat(b)) || 0; 4407 }, 4408 4409 /** 4410 * @private Takes a value and a default number, checks if the value is relative, null, or numeric and spits back a normalized number accordingly. Primarily used in the _parseTransform() function. 4411 * @param {Object} v Value to be parsed 4412 * @param {!number} d Default value (which is also used for relative calculations if "+=" or "-=" is found in the first parameter) 4413 * @return {number} Parsed value 4414 */ 4415 _parseVal = function(v, d) { 4416 if (typeof(v) === "function") { 4417 v = v(_index, _target); 4418 } 4419 var isRelative = (typeof(v) === "string" && v.charAt(1) === "="); 4420 if (typeof(v) === "string" && v.charAt(v.length - 2) === "v") { //convert vw and vh into px-equivalents. 4421 v = (isRelative ? v.substr(0, 2) : 0) + (window["inner" + ((v.substr(-2) === "vh") ? "Height" : "Width")] * (parseFloat(isRelative ? v.substr(2) : v) / 100)); 4422 } 4423 return (v == null) ? d : isRelative ? parseInt(v.charAt(0) + "1", 10) * parseFloat(v.substr(2)) + d : parseFloat(v) || 0; 4424 }, 4425 4426 /** 4427 * @private Translates strings like "40deg" or "40" or 40rad" or "+=40deg" or "270_short" or "-90_cw" or "+=45_ccw" to a numeric radian angle. Of course a starting/default value must be fed in too so that relative values can be calculated properly. 4428 * @param {Object} v Value to be parsed 4429 * @param {!number} d Default value (which is also used for relative calculations if "+=" or "-=" is found in the first parameter) 4430 * @param {string=} p property name for directionalEnd (optional - only used when the parsed value is directional ("_short", "_cw", or "_ccw" suffix). We need a way to store the uncompensated value so that at the end of the tween, we set it to exactly what was requested with no directional compensation). Property name would be "rotation", "rotationX", or "rotationY" 4431 * @param {Object=} directionalEnd An object that will store the raw end values for directional angles ("_short", "_cw", or "_ccw" suffix). We need a way to store the uncompensated value so that at the end of the tween, we set it to exactly what was requested with no directional compensation. 4432 * @return {number} parsed angle in radians 4433 */ 4434 _parseAngle = function(v, d, p, directionalEnd) { 4435 var min = 0.000001, 4436 cap, split, dif, result, isRelative; 4437 if (typeof(v) === "function") { 4438 v = v(_index, _target); 4439 } 4440 if (v == null) { 4441 result = d; 4442 } else if (typeof(v) === "number") { 4443 result = v; 4444 } else { 4445 cap = 360; 4446 split = v.split("_"); 4447 isRelative = (v.charAt(1) === "="); 4448 dif = (isRelative ? parseInt(v.charAt(0) + "1", 10) * parseFloat(split[0].substr(2)) : parseFloat(split[0])) * ((v.indexOf("rad") === -1) ? 1 : _RAD2DEG) - (isRelative ? 0 : d); 4449 if (split.length) { 4450 if (directionalEnd) { 4451 directionalEnd[p] = d + dif; 4452 } 4453 if (v.indexOf("short") !== -1) { 4454 dif = dif % cap; 4455 if (dif !== dif % (cap / 2)) { 4456 dif = (dif < 0) ? dif + cap : dif - cap; 4457 } 4458 } 4459 if (v.indexOf("_cw") !== -1 && dif < 0) { 4460 dif = ((dif + cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 4461 } else if (v.indexOf("ccw") !== -1 && dif > 0) { 4462 dif = ((dif - cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 4463 } 4464 } 4465 result = d + dif; 4466 } 4467 if (result < min && result > -min) { 4468 result = 0; 4469 } 4470 return result; 4471 }, 4472 4473 _colorLookup = {aqua:[0,255,255], 4474 lime:[0,255,0], 4475 silver:[192,192,192], 4476 black:[0,0,0], 4477 maroon:[128,0,0], 4478 teal:[0,128,128], 4479 blue:[0,0,255], 4480 navy:[0,0,128], 4481 white:[255,255,255], 4482 fuchsia:[255,0,255], 4483 olive:[128,128,0], 4484 yellow:[255,255,0], 4485 orange:[255,165,0], 4486 gray:[128,128,128], 4487 purple:[128,0,128], 4488 green:[0,128,0], 4489 red:[255,0,0], 4490 pink:[255,192,203], 4491 cyan:[0,255,255], 4492 transparent:[255,255,255,0]}, 4493 4494 _hue = function(h, m1, m2) { 4495 h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; 4496 return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; 4497 }, 4498 4499 /** 4500 * @private Parses a color (like #9F0, #FF9900, rgb(255,51,153) or hsl(108, 50%, 10%)) into an array with 3 elements for red, green, and blue or if toHSL parameter is true, it will populate the array with hue, saturation, and lightness values. If a relative value is found in an hsl() or hsla() string, it will preserve those relative prefixes and all the values in the array will be strings instead of numbers (in all other cases it will be populated with numbers). 4501 * @param {(string|number)} v The value the should be parsed which could be a string like #9F0 or rgb(255,102,51) or rgba(255,0,0,0.5) or it could be a number like 0xFF00CC or even a named color like red, blue, purple, etc. 4502 * @param {(boolean)} toHSL If true, an hsl() or hsla() value will be returned instead of rgb() or rgba() 4503 * @return {Array.<number>} An array containing red, green, and blue (and optionally alpha) in that order, or if the toHSL parameter was true, the array will contain hue, saturation and lightness (and optionally alpha) in that order. Always numbers unless there's a relative prefix found in an hsl() or hsla() string and toHSL is true. 4504 */ 4505 _parseColor = CSSPlugin.parseColor = function(v, toHSL) { 4506 var a, r, g, b, h, s, l, max, min, d, wasHSL; 4507 if (!v) { 4508 a = _colorLookup.black; 4509 } else if (typeof(v) === "number") { 4510 a = [v >> 16, (v >> 8) & 255, v & 255]; 4511 } else { 4512 if (v.charAt(v.length - 1) === ",") { //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value. 4513 v = v.substr(0, v.length - 1); 4514 } 4515 if (_colorLookup[v]) { 4516 a = _colorLookup[v]; 4517 } else if (v.charAt(0) === "#") { 4518 if (v.length === 4) { //for shorthand like #9F0 4519 r = v.charAt(1); 4520 g = v.charAt(2); 4521 b = v.charAt(3); 4522 v = "#" + r + r + g + g + b + b; 4523 } 4524 v = parseInt(v.substr(1), 16); 4525 a = [v >> 16, (v >> 8) & 255, v & 255]; 4526 } else if (v.substr(0, 3) === "hsl") { 4527 a = wasHSL = v.match(_numExp); 4528 if (!toHSL) { 4529 h = (Number(a[0]) % 360) / 360; 4530 s = Number(a[1]) / 100; 4531 l = Number(a[2]) / 100; 4532 g = (l <= 0.5) ? l * (s + 1) : l + s - l * s; 4533 r = l * 2 - g; 4534 if (a.length > 3) { 4535 a[3] = Number(a[3]); 4536 } 4537 a[0] = _hue(h + 1 / 3, r, g); 4538 a[1] = _hue(h, r, g); 4539 a[2] = _hue(h - 1 / 3, r, g); 4540 } else if (v.indexOf("=") !== -1) { //if relative values are found, just return the raw strings with the relative prefixes in place. 4541 return v.match(_relNumExp); 4542 } 4543 } else { 4544 a = v.match(_numExp) || _colorLookup.transparent; 4545 } 4546 a[0] = Number(a[0]); 4547 a[1] = Number(a[1]); 4548 a[2] = Number(a[2]); 4549 if (a.length > 3) { 4550 a[3] = Number(a[3]); 4551 } 4552 } 4553 if (toHSL && !wasHSL) { 4554 r = a[0] / 255; 4555 g = a[1] / 255; 4556 b = a[2] / 255; 4557 max = Math.max(r, g, b); 4558 min = Math.min(r, g, b); 4559 l = (max + min) / 2; 4560 if (max === min) { 4561 h = s = 0; 4562 } else { 4563 d = max - min; 4564 s = l > 0.5 ? d / (2 - max - min) : d / (max + min); 4565 h = (max === r) ? (g - b) / d + (g < b ? 6 : 0) : (max === g) ? (b - r) / d + 2 : (r - g) / d + 4; 4566 h *= 60; 4567 } 4568 a[0] = (h + 0.5) | 0; 4569 a[1] = (s * 100 + 0.5) | 0; 4570 a[2] = (l * 100 + 0.5) | 0; 4571 } 4572 return a; 4573 }, 4574 _formatColors = function(s, toHSL) { 4575 var colors = s.match(_colorExp) || [], 4576 charIndex = 0, 4577 parsed = "", 4578 i, color, temp; 4579 if (!colors.length) { 4580 return s; 4581 } 4582 for (i = 0; i < colors.length; i++) { 4583 color = colors[i]; 4584 temp = s.substr(charIndex, s.indexOf(color, charIndex)-charIndex); 4585 charIndex += temp.length + color.length; 4586 color = _parseColor(color, toHSL); 4587 if (color.length === 3) { 4588 color.push(1); 4589 } 4590 parsed += temp + (toHSL ? "hsla(" + color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : "rgba(" + color.join(",")) + ")"; 4591 } 4592 return parsed + s.substr(charIndex); 4593 }, 4594 _colorExp = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b"; //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc. 4595 4596 for (p in _colorLookup) { 4597 _colorExp += "|" + p + "\\b"; 4598 } 4599 _colorExp = new RegExp(_colorExp+")", "gi"); 4600 4601 CSSPlugin.colorStringFilter = function(a) { 4602 var combined = a[0] + " " + a[1], 4603 toHSL; 4604 if (_colorExp.test(combined)) { 4605 toHSL = (combined.indexOf("hsl(") !== -1 || combined.indexOf("hsla(") !== -1); 4606 a[0] = _formatColors(a[0], toHSL); 4607 a[1] = _formatColors(a[1], toHSL); 4608 } 4609 _colorExp.lastIndex = 0; 4610 }; 4611 4612 if (!_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].defaultStringFilter) { 4613 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].defaultStringFilter = CSSPlugin.colorStringFilter; 4614 } 4615 4616 /** 4617 * @private Returns a formatter function that handles taking a string (or number in some cases) and returning a consistently formatted one in terms of delimiters, quantity of values, etc. For example, we may get boxShadow values defined as "0px red" or "0px 0px 10px rgb(255,0,0)" or "0px 0px 20px 20px #F00" and we need to ensure that what we get back is described with 4 numbers and a color. This allows us to feed it into the _parseComplex() method and split the values up appropriately. The neat thing about this _getFormatter() function is that the dflt defines a pattern as well as a default, so for example, _getFormatter("0px 0px 0px 0px #777", true) not only sets the default as 0px for all distances and #777 for the color, but also sets the pattern such that 4 numbers and a color will always get returned. 4618 * @param {!string} dflt The default value and pattern to follow. So "0px 0px 0px 0px #777" will ensure that 4 numbers and a color will always get returned. 4619 * @param {boolean=} clr If true, the values should be searched for color-related data. For example, boxShadow values typically contain a color whereas borderRadius don't. 4620 * @param {boolean=} collapsible If true, the value is a top/left/right/bottom style one that acts like margin or padding, where if only one value is received, it's used for all 4; if 2 are received, the first is duplicated for 3rd (bottom) and the 2nd is duplicated for the 4th spot (left), etc. 4621 * @return {Function} formatter function 4622 */ 4623 var _getFormatter = function(dflt, clr, collapsible, multi) { 4624 if (dflt == null) { 4625 return function(v) {return v;}; 4626 } 4627 var dColor = clr ? (dflt.match(_colorExp) || [""])[0] : "", 4628 dVals = dflt.split(dColor).join("").match(_valuesExp) || [], 4629 pfx = dflt.substr(0, dflt.indexOf(dVals[0])), 4630 sfx = (dflt.charAt(dflt.length - 1) === ")") ? ")" : "", 4631 delim = (dflt.indexOf(" ") !== -1) ? " " : ",", 4632 numVals = dVals.length, 4633 dSfx = (numVals > 0) ? dVals[0].replace(_numExp, "") : "", 4634 formatter; 4635 if (!numVals) { 4636 return function(v) {return v;}; 4637 } 4638 if (clr) { 4639 formatter = function(v) { 4640 var color, vals, i, a; 4641 if (typeof(v) === "number") { 4642 v += dSfx; 4643 } else if (multi && _commasOutsideParenExp.test(v)) { 4644 a = v.replace(_commasOutsideParenExp, "|").split("|"); 4645 for (i = 0; i < a.length; i++) { 4646 a[i] = formatter(a[i]); 4647 } 4648 return a.join(","); 4649 } 4650 color = (v.match(_colorExp) || [dColor])[0]; 4651 vals = v.split(color).join("").match(_valuesExp) || []; 4652 i = vals.length; 4653 if (numVals > i--) { 4654 while (++i < numVals) { 4655 vals[i] = collapsible ? vals[(((i - 1) / 2) | 0)] : dVals[i]; 4656 } 4657 } 4658 return pfx + vals.join(delim) + delim + color + sfx + (v.indexOf("inset") !== -1 ? " inset" : ""); 4659 }; 4660 return formatter; 4661 4662 } 4663 formatter = function(v) { 4664 var vals, a, i; 4665 if (typeof(v) === "number") { 4666 v += dSfx; 4667 } else if (multi && _commasOutsideParenExp.test(v)) { 4668 a = v.replace(_commasOutsideParenExp, "|").split("|"); 4669 for (i = 0; i < a.length; i++) { 4670 a[i] = formatter(a[i]); 4671 } 4672 return a.join(","); 4673 } 4674 vals = v.match(_valuesExp) || []; 4675 i = vals.length; 4676 if (numVals > i--) { 4677 while (++i < numVals) { 4678 vals[i] = collapsible ? vals[(((i - 1) / 2) | 0)] : dVals[i]; 4679 } 4680 } 4681 return pfx + vals.join(delim) + sfx; 4682 }; 4683 return formatter; 4684 }, 4685 4686 /** 4687 * @private returns a formatter function that's used for edge-related values like marginTop, marginLeft, paddingBottom, paddingRight, etc. Just pass a comma-delimited list of property names related to the edges. 4688 * @param {!string} props a comma-delimited list of property names in order from top to left, like "marginTop,marginRight,marginBottom,marginLeft" 4689 * @return {Function} a formatter function 4690 */ 4691 _getEdgeParser = function(props) { 4692 props = props.split(","); 4693 return function(t, e, p, cssp, pt, plugin, vars) { 4694 var a = (e + "").split(" "), 4695 i; 4696 vars = {}; 4697 for (i = 0; i < 4; i++) { 4698 vars[props[i]] = a[i] = a[i] || a[(((i - 1) / 2) >> 0)]; 4699 } 4700 return cssp.parse(t, vars, pt, plugin); 4701 }; 4702 }, 4703 4704 // @private used when other plugins must tween values first, like BezierPlugin or ThrowPropsPlugin, etc. That plugin's setRatio() gets called first so that the values are updated, and then we loop through the MiniPropTweens which handle copying the values into their appropriate slots so that they can then be applied correctly in the main CSSPlugin setRatio() method. Remember, we typically create a proxy object that has a bunch of uniquely-named properties that we feed to the sub-plugin and it does its magic normally, and then we must interpret those values and apply them to the css because often numbers must get combined/concatenated, suffixes added, etc. to work with css, like boxShadow could have 4 values plus a color. 4705 _setPluginRatio = _internals._setPluginRatio = function(v) { 4706 this.plugin.setRatio(v); 4707 var d = this.data, 4708 proxy = d.proxy, 4709 mpt = d.firstMPT, 4710 min = 0.000001, 4711 val, pt, i, str, p; 4712 while (mpt) { 4713 val = proxy[mpt.v]; 4714 if (mpt.r) { 4715 val = mpt.r(val); 4716 } else if (val < min && val > -min) { 4717 val = 0; 4718 } 4719 mpt.t[mpt.p] = val; 4720 mpt = mpt._next; 4721 } 4722 if (d.autoRotate) { 4723 d.autoRotate.rotation = d.mod ? d.mod.call(this._tween, proxy.rotation, this.t, this._tween) : proxy.rotation; //special case for ModifyPlugin to hook into an auto-rotating bezier 4724 } 4725 //at the end, we must set the CSSPropTween's "e" (end) value dynamically here because that's what is used in the final setRatio() method. Same for "b" at the beginning. 4726 if (v === 1 || v === 0) { 4727 mpt = d.firstMPT; 4728 p = (v === 1) ? "e" : "b"; 4729 while (mpt) { 4730 pt = mpt.t; 4731 if (!pt.type) { 4732 pt[p] = pt.s + pt.xs0; 4733 } else if (pt.type === 1) { 4734 str = pt.xs0 + pt.s + pt.xs1; 4735 for (i = 1; i < pt.l; i++) { 4736 str += pt["xn"+i] + pt["xs"+(i+1)]; 4737 } 4738 pt[p] = str; 4739 } 4740 mpt = mpt._next; 4741 } 4742 } 4743 }, 4744 4745 /** 4746 * @private @constructor Used by a few SpecialProps to hold important values for proxies. For example, _parseToProxy() creates a MiniPropTween instance for each property that must get tweened on the proxy, and we record the original property name as well as the unique one we create for the proxy, plus whether or not the value needs to be rounded plus the original value. 4747 * @param {!Object} t target object whose property we're tweening (often a CSSPropTween) 4748 * @param {!string} p property name 4749 * @param {(number|string|object)} v value 4750 * @param {MiniPropTween=} next next MiniPropTween in the linked list 4751 * @param {boolean=} r if true, the tweened value should be rounded to the nearest integer 4752 */ 4753 MiniPropTween = function(t, p, v, next, r) { 4754 this.t = t; 4755 this.p = p; 4756 this.v = v; 4757 this.r = r; 4758 if (next) { 4759 next._prev = this; 4760 this._next = next; 4761 } 4762 }, 4763 4764 /** 4765 * @private Most other plugins (like BezierPlugin and ThrowPropsPlugin and others) can only tween numeric values, but CSSPlugin must accommodate special values that have a bunch of extra data (like a suffix or strings between numeric values, etc.). For example, boxShadow has values like "10px 10px 20px 30px rgb(255,0,0)" which would utterly confuse other plugins. This method allows us to split that data apart and grab only the numeric data and attach it to uniquely-named properties of a generic proxy object ({}) so that we can feed that to virtually any plugin to have the numbers tweened. However, we must also keep track of which properties from the proxy go with which CSSPropTween values and instances. So we create a linked list of MiniPropTweens. Each one records a target (the original CSSPropTween), property (like "s" or "xn1" or "xn2") that we're tweening and the unique property name that was used for the proxy (like "boxShadow_xn1" and "boxShadow_xn2") and whether or not they need to be rounded. That way, in the _setPluginRatio() method we can simply copy the values over from the proxy to the CSSPropTween instance(s). Then, when the main CSSPlugin setRatio() method runs and applies the CSSPropTween values accordingly, they're updated nicely. So the external plugin tweens the numbers, _setPluginRatio() copies them over, and setRatio() acts normally, applying css-specific values to the element. 4766 * This method returns an object that has the following properties: 4767 * - proxy: a generic object containing the starting values for all the properties that will be tweened by the external plugin. This is what we feed to the external _onInitTween() as the target 4768 * - end: a generic object containing the ending values for all the properties that will be tweened by the external plugin. This is what we feed to the external plugin's _onInitTween() as the destination values 4769 * - firstMPT: the first MiniPropTween in the linked list 4770 * - pt: the first CSSPropTween in the linked list that was created when parsing. If shallow is true, this linked list will NOT attach to the one passed into the _parseToProxy() as the "pt" (4th) parameter. 4771 * @param {!Object} t target object to be tweened 4772 * @param {!(Object|string)} vars the object containing the information about the tweening values (typically the end/destination values) that should be parsed 4773 * @param {!CSSPlugin} cssp The CSSPlugin instance 4774 * @param {CSSPropTween=} pt the next CSSPropTween in the linked list 4775 * @param {TweenPlugin=} plugin the external TweenPlugin instance that will be handling tweening the numeric values 4776 * @param {boolean=} shallow if true, the resulting linked list from the parse will NOT be attached to the CSSPropTween that was passed in as the "pt" (4th) parameter. 4777 * @return An object containing the following properties: proxy, end, firstMPT, and pt (see above for descriptions) 4778 */ 4779 _parseToProxy = _internals._parseToProxy = function(t, vars, cssp, pt, plugin, shallow) { 4780 var bpt = pt, 4781 start = {}, 4782 end = {}, 4783 transform = cssp._transform, 4784 oldForce = _forcePT, 4785 i, p, xp, mpt, firstPT; 4786 cssp._transform = null; 4787 _forcePT = vars; 4788 pt = firstPT = cssp.parse(t, vars, pt, plugin); 4789 _forcePT = oldForce; 4790 //break off from the linked list so the new ones are isolated. 4791 if (shallow) { 4792 cssp._transform = transform; 4793 if (bpt) { 4794 bpt._prev = null; 4795 if (bpt._prev) { 4796 bpt._prev._next = null; 4797 } 4798 } 4799 } 4800 while (pt && pt !== bpt) { 4801 if (pt.type <= 1) { 4802 p = pt.p; 4803 end[p] = pt.s + pt.c; 4804 start[p] = pt.s; 4805 if (!shallow) { 4806 mpt = new MiniPropTween(pt, "s", p, mpt, pt.r); 4807 pt.c = 0; 4808 } 4809 if (pt.type === 1) { 4810 i = pt.l; 4811 while (--i > 0) { 4812 xp = "xn" + i; 4813 p = pt.p + "_" + xp; 4814 end[p] = pt.data[xp]; 4815 start[p] = pt[xp]; 4816 if (!shallow) { 4817 mpt = new MiniPropTween(pt, xp, p, mpt, pt.rxp[xp]); 4818 } 4819 } 4820 } 4821 } 4822 pt = pt._next; 4823 } 4824 return {proxy:start, end:end, firstMPT:mpt, pt:firstPT}; 4825 }, 4826 4827 4828 4829 /** 4830 * @constructor Each property that is tweened has at least one CSSPropTween associated with it. These instances store important information like the target, property, starting value, amount of change, etc. They can also optionally have a number of "extra" strings and numeric values named xs1, xn1, xs2, xn2, xs3, xn3, etc. where "s" indicates string and "n" indicates number. These can be pieced together in a complex-value tween (type:1) that has alternating types of data like a string, number, string, number, etc. For example, boxShadow could be "5px 5px 8px rgb(102, 102, 51)". In that value, there are 6 numbers that may need to tween and then pieced back together into a string again with spaces, suffixes, etc. xs0 is special in that it stores the suffix for standard (type:0) tweens, -OR- the first string (prefix) in a complex-value (type:1) CSSPropTween -OR- it can be the non-tweening value in a type:-1 CSSPropTween. We do this to conserve memory. 4831 * CSSPropTweens have the following optional properties as well (not defined through the constructor): 4832 * - l: Length in terms of the number of extra properties that the CSSPropTween has (default: 0). For example, for a boxShadow we may need to tween 5 numbers in which case l would be 5; Keep in mind that the start/end values for the first number that's tweened are always stored in the s and c properties to conserve memory. All additional values thereafter are stored in xn1, xn2, etc. 4833 * - xfirst: The first instance of any sub-CSSPropTweens that are tweening properties of this instance. For example, we may split up a boxShadow tween so that there's a main CSSPropTween of type:1 that has various xs* and xn* values associated with the h-shadow, v-shadow, blur, color, etc. Then we spawn a CSSPropTween for each of those that has a higher priority and runs BEFORE the main CSSPropTween so that the values are all set by the time it needs to re-assemble them. The xfirst gives us an easy way to identify the first one in that chain which typically ends at the main one (because they're all prepende to the linked list) 4834 * - plugin: The TweenPlugin instance that will handle the tweening of any complex values. For example, sometimes we don't want to use normal subtweens (like xfirst refers to) to tween the values - we might want ThrowPropsPlugin or BezierPlugin some other plugin to do the actual tweening, so we create a plugin instance and store a reference here. We need this reference so that if we get a request to round values or disable a tween, we can pass along that request. 4835 * - data: Arbitrary data that needs to be stored with the CSSPropTween. Typically if we're going to have a plugin handle the tweening of a complex-value tween, we create a generic object that stores the END values that we're tweening to and the CSSPropTween's xs1, xs2, etc. have the starting values. We store that object as data. That way, we can simply pass that object to the plugin and use the CSSPropTween as the target. 4836 * - setRatio: Only used for type:2 tweens that require custom functionality. In this case, we call the CSSPropTween's setRatio() method and pass the ratio each time the tween updates. This isn't quite as efficient as doing things directly in the CSSPlugin's setRatio() method, but it's very convenient and flexible. 4837 * @param {!Object} t Target object whose property will be tweened. Often a DOM element, but not always. It could be anything. 4838 * @param {string} p Property to tween (name). For example, to tween element.width, p would be "width". 4839 * @param {number} s Starting numeric value 4840 * @param {number} c Change in numeric value over the course of the entire tween. For example, if element.width starts at 5 and should end at 100, c would be 95. 4841 * @param {CSSPropTween=} next The next CSSPropTween in the linked list. If one is defined, we will define its _prev as the new instance, and the new instance's _next will be pointed at it. 4842 * @param {number=} type The type of CSSPropTween where -1 = a non-tweening value, 0 = a standard simple tween, 1 = a complex value (like one that has multiple numbers in a comma- or space-delimited string like border:"1px solid red"), and 2 = one that uses a custom setRatio function that does all of the work of applying the values on each update. 4843 * @param {string=} n Name of the property that should be used for overwriting purposes which is typically the same as p but not always. For example, we may need to create a subtween for the 2nd part of a "clip:rect(...)" tween in which case "p" might be xs1 but "n" is still "clip" 4844 * @param {boolean=} r If true, the value(s) should be rounded 4845 * @param {number=} pr Priority in the linked list order. Higher priority CSSPropTweens will be updated before lower priority ones. The default priority is 0. 4846 * @param {string=} b Beginning value. We store this to ensure that it is EXACTLY what it was when the tween began without any risk of interpretation issues. 4847 * @param {string=} e Ending value. We store this to ensure that it is EXACTLY what the user defined at the end of the tween without any risk of interpretation issues. 4848 */ 4849 CSSPropTween = _internals.CSSPropTween = function(t, p, s, c, next, type, n, r, pr, b, e) { 4850 this.t = t; //target 4851 this.p = p; //property 4852 this.s = s; //starting value 4853 this.c = c; //change value 4854 this.n = n || p; //name that this CSSPropTween should be associated to (usually the same as p, but not always - n is what overwriting looks at) 4855 if (!(t instanceof CSSPropTween)) { 4856 _overwriteProps.push(this.n); 4857 } 4858 this.r = !r ? r : (typeof(r) === "function") ? r : Math.round; //round (boolean) 4859 this.type = type || 0; //0 = normal tween, -1 = non-tweening (in which case xs0 will be applied to the target's property, like tp.t[tp.p] = tp.xs0), 1 = complex-value SpecialProp, 2 = custom setRatio() that does all the work 4860 if (pr) { 4861 this.pr = pr; 4862 _hasPriority = true; 4863 } 4864 this.b = (b === undefined) ? s : b; 4865 this.e = (e === undefined) ? s + c : e; 4866 if (next) { 4867 this._next = next; 4868 next._prev = this; 4869 } 4870 }, 4871 4872 _addNonTweeningNumericPT = function(target, prop, start, end, next, overwriteProp) { //cleans up some code redundancies and helps minification. Just a fast way to add a NUMERIC non-tweening CSSPropTween 4873 var pt = new CSSPropTween(target, prop, start, end - start, next, -1, overwriteProp); 4874 pt.b = start; 4875 pt.e = pt.xs0 = end; 4876 return pt; 4877 }, 4878 4879 /** 4880 * Takes a target, the beginning value and ending value (as strings) and parses them into a CSSPropTween (possibly with child CSSPropTweens) that accommodates multiple numbers, colors, comma-delimited values, etc. For example: 4881 * sp.parseComplex(element, "boxShadow", "5px 10px 20px rgb(255,102,51)", "0px 0px 0px red", true, "0px 0px 0px rgb(0,0,0,0)", pt); 4882 * It will walk through the beginning and ending values (which should be in the same format with the same number and type of values) and figure out which parts are numbers, what strings separate the numeric/tweenable values, and then create the CSSPropTweens accordingly. If a plugin is defined, no child CSSPropTweens will be created. Instead, the ending values will be stored in the "data" property of the returned CSSPropTween like: {s:-5, xn1:-10, xn2:-20, xn3:255, xn4:0, xn5:0} so that it can be fed to any other plugin and it'll be plain numeric tweens but the recomposition of the complex value will be handled inside CSSPlugin's setRatio(). 4883 * If a setRatio is defined, the type of the CSSPropTween will be set to 2 and recomposition of the values will be the responsibility of that method. 4884 * 4885 * @param {!Object} t Target whose property will be tweened 4886 * @param {!string} p Property that will be tweened (its name, like "left" or "backgroundColor" or "boxShadow") 4887 * @param {string} b Beginning value 4888 * @param {string} e Ending value 4889 * @param {boolean} clrs If true, the value could contain a color value like "rgb(255,0,0)" or "#F00" or "red". The default is false, so no colors will be recognized (a performance optimization) 4890 * @param {(string|number|Object)} dflt The default beginning value that should be used if no valid beginning value is defined or if the number of values inside the complex beginning and ending values don't match 4891 * @param {?CSSPropTween} pt CSSPropTween instance that is the current head of the linked list (we'll prepend to this). 4892 * @param {number=} pr Priority in the linked list order. Higher priority properties will be updated before lower priority ones. The default priority is 0. 4893 * @param {TweenPlugin=} plugin If a plugin should handle the tweening of extra properties, pass the plugin instance here. If one is defined, then NO subtweens will be created for any extra properties (the properties will be created - just not additional CSSPropTween instances to tween them) because the plugin is expected to do so. However, the end values WILL be populated in the "data" property, like {s:100, xn1:50, xn2:300} 4894 * @param {function(number)=} setRatio If values should be set in a custom function instead of being pieced together in a type:1 (complex-value) CSSPropTween, define that custom function here. 4895 * @return {CSSPropTween} The first CSSPropTween in the linked list which includes the new one(s) added by the parseComplex() call. 4896 */ 4897 _parseComplex = CSSPlugin.parseComplex = function(t, p, b, e, clrs, dflt, pt, pr, plugin, setRatio) { 4898 //DEBUG: _log("parseComplex: "+p+", b: "+b+", e: "+e); 4899 b = b || dflt || ""; 4900 if (typeof(e) === "function") { 4901 e = e(_index, _target); 4902 } 4903 pt = new CSSPropTween(t, p, 0, 0, pt, (setRatio ? 2 : 1), null, false, pr, b, e); 4904 e += ""; //ensures it's a string 4905 if (clrs && _colorExp.test(e + b)) { //if colors are found, normalize the formatting to rgba() or hsla(). 4906 e = [b, e]; 4907 CSSPlugin.colorStringFilter(e); 4908 b = e[0]; 4909 e = e[1]; 4910 } 4911 var ba = b.split(", ").join(",").split(" "), //beginning array 4912 ea = e.split(", ").join(",").split(" "), //ending array 4913 l = ba.length, 4914 autoRound = (_autoRound !== false), 4915 i, xi, ni, bv, ev, bnums, enums, bn, hasAlpha, temp, cv, str, useHSL; 4916 if (e.indexOf(",") !== -1 || b.indexOf(",") !== -1) { 4917 if ((e + b).indexOf("rgb") !== -1 || (e + b).indexOf("hsl") !== -1) { //keep rgb(), rgba(), hsl(), and hsla() values together! (remember, we're splitting on spaces) 4918 ba = ba.join(" ").replace(_commasOutsideParenExp, ", ").split(" "); 4919 ea = ea.join(" ").replace(_commasOutsideParenExp, ", ").split(" "); 4920 } else { 4921 ba = ba.join(" ").split(",").join(", ").split(" "); 4922 ea = ea.join(" ").split(",").join(", ").split(" "); 4923 } 4924 l = ba.length; 4925 } 4926 if (l !== ea.length) { 4927 //DEBUG: _log("mismatched formatting detected on " + p + " (" + b + " vs " + e + ")"); 4928 ba = (dflt || "").split(" "); 4929 l = ba.length; 4930 } 4931 pt.plugin = plugin; 4932 pt.setRatio = setRatio; 4933 _colorExp.lastIndex = 0; 4934 for (i = 0; i < l; i++) { 4935 bv = ba[i]; 4936 ev = ea[i] + ""; 4937 bn = parseFloat(bv); 4938 //if the value begins with a number (most common). It's fine if it has a suffix like px 4939 if (bn || bn === 0) { 4940 pt.appendXtra("", bn, _parseChange(ev, bn), ev.replace(_relNumExp, ""), (autoRound && ev.indexOf("px") !== -1) ? Math.round : false, true); 4941 4942 //if the value is a color 4943 } else if (clrs && _colorExp.test(bv)) { 4944 str = ev.indexOf(")") + 1; 4945 str = ")" + (str ? ev.substr(str) : ""); //if there's a comma or ) at the end, retain it. 4946 useHSL = (ev.indexOf("hsl") !== -1 && _supportsOpacity); 4947 temp = ev; //original string value so we can look for any prefix later. 4948 bv = _parseColor(bv, useHSL); 4949 ev = _parseColor(ev, useHSL); 4950 hasAlpha = (bv.length + ev.length > 6); 4951 if (hasAlpha && !_supportsOpacity && ev[3] === 0) { //older versions of IE don't support rgba(), so if the destination alpha is 0, just use "transparent" for the end color 4952 pt["xs" + pt.l] += pt.l ? " transparent" : "transparent"; 4953 pt.e = pt.e.split(ea[i]).join("transparent"); 4954 } else { 4955 if (!_supportsOpacity) { //old versions of IE don't support rgba(). 4956 hasAlpha = false; 4957 } 4958 if (useHSL) { 4959 pt.appendXtra(temp.substr(0, temp.indexOf("hsl")) + (hasAlpha ? "hsla(" : "hsl("), bv[0], _parseChange(ev[0], bv[0]), ",", false, true) 4960 .appendXtra("", bv[1], _parseChange(ev[1], bv[1]), "%,", false) 4961 .appendXtra("", bv[2], _parseChange(ev[2], bv[2]), (hasAlpha ? "%," : "%" + str), false); 4962 } else { 4963 pt.appendXtra(temp.substr(0, temp.indexOf("rgb")) + (hasAlpha ? "rgba(" : "rgb("), bv[0], ev[0] - bv[0], ",", Math.round, true) 4964 .appendXtra("", bv[1], ev[1] - bv[1], ",", Math.round) 4965 .appendXtra("", bv[2], ev[2] - bv[2], (hasAlpha ? "," : str), Math.round); 4966 } 4967 4968 if (hasAlpha) { 4969 bv = (bv.length < 4) ? 1 : bv[3]; 4970 pt.appendXtra("", bv, ((ev.length < 4) ? 1 : ev[3]) - bv, str, false); 4971 } 4972 } 4973 _colorExp.lastIndex = 0; //otherwise the test() on the RegExp could move the lastIndex and taint future results. 4974 4975 } else { 4976 bnums = bv.match(_numExp); //gets each group of numbers in the beginning value string and drops them into an array 4977 4978 //if no number is found, treat it as a non-tweening value and just append the string to the current xs. 4979 if (!bnums) { 4980 pt["xs" + pt.l] += (pt.l || pt["xs" + pt.l]) ? " " + ev : ev; 4981 4982 //loop through all the numbers that are found and construct the extra values on the pt. 4983 } else { 4984 enums = ev.match(_relNumExp); //get each group of numbers in the end value string and drop them into an array. We allow relative values too, like +=50 or -=.5 4985 if (!enums || enums.length !== bnums.length) { 4986 //DEBUG: _log("mismatched formatting detected on " + p + " (" + b + " vs " + e + ")"); 4987 return pt; 4988 } 4989 ni = 0; 4990 for (xi = 0; xi < bnums.length; xi++) { 4991 cv = bnums[xi]; 4992 temp = bv.indexOf(cv, ni); 4993 pt.appendXtra(bv.substr(ni, temp - ni), Number(cv), _parseChange(enums[xi], cv), "", (autoRound && bv.substr(temp + cv.length, 2) === "px") ? Math.round : false, (xi === 0)); 4994 ni = temp + cv.length; 4995 } 4996 pt["xs" + pt.l] += bv.substr(ni); 4997 } 4998 } 4999 } 5000 //if there are relative values ("+=" or "-=" prefix), we need to adjust the ending value to eliminate the prefixes and combine the values properly. 5001 if (e.indexOf("=") !== -1) if (pt.data) { 5002 str = pt.xs0 + pt.data.s; 5003 for (i = 1; i < pt.l; i++) { 5004 str += pt["xs" + i] + pt.data["xn" + i]; 5005 } 5006 pt.e = str + pt["xs" + i]; 5007 } 5008 if (!pt.l) { 5009 pt.type = -1; 5010 pt.xs0 = pt.e; 5011 } 5012 return pt.xfirst || pt; 5013 }, 5014 i = 9; 5015 5016 5017 p = CSSPropTween.prototype; 5018 p.l = p.pr = 0; //length (number of extra properties like xn1, xn2, xn3, etc. 5019 while (--i > 0) { 5020 p["xn" + i] = 0; 5021 p["xs" + i] = ""; 5022 } 5023 p.xs0 = ""; 5024 p._next = p._prev = p.xfirst = p.data = p.plugin = p.setRatio = p.rxp = null; 5025 5026 5027 /** 5028 * Appends and extra tweening value to a CSSPropTween and automatically manages any prefix and suffix strings. The first extra value is stored in the s and c of the main CSSPropTween instance, but thereafter any extras are stored in the xn1, xn2, xn3, etc. The prefixes and suffixes are stored in the xs0, xs1, xs2, etc. properties. For example, if I walk through a clip value like "rect(10px, 5px, 0px, 20px)", the values would be stored like this: 5029 * xs0:"rect(", s:10, xs1:"px, ", xn1:5, xs2:"px, ", xn2:0, xs3:"px, ", xn3:20, xn4:"px)" 5030 * And they'd all get joined together when the CSSPlugin renders (in the setRatio() method). 5031 * @param {string=} pfx Prefix (if any) 5032 * @param {!number} s Starting value 5033 * @param {!number} c Change in numeric value over the course of the entire tween. For example, if the start is 5 and the end is 100, the change would be 95. 5034 * @param {string=} sfx Suffix (if any) 5035 * @param {boolean=} r Round (if true). 5036 * @param {boolean=} pad If true, this extra value should be separated by the previous one by a space. If there is no previous extra and pad is true, it will automatically drop the space. 5037 * @return {CSSPropTween} returns itself so that multiple methods can be chained together. 5038 */ 5039 p.appendXtra = function(pfx, s, c, sfx, r, pad) { 5040 var pt = this, 5041 l = pt.l; 5042 pt["xs" + l] += (pad && (l || pt["xs" + l])) ? " " + pfx : pfx || ""; 5043 if (!c) if (l !== 0 && !pt.plugin) { //typically we'll combine non-changing values right into the xs to optimize performance, but we don't combine them when there's a plugin that will be tweening the values because it may depend on the values being split apart, like for a bezier, if a value doesn't change between the first and second iteration but then it does on the 3rd, we'll run into trouble because there's no xn slot for that value! 5044 pt["xs" + l] += s + (sfx || ""); 5045 return pt; 5046 } 5047 pt.l++; 5048 pt.type = pt.setRatio ? 2 : 1; 5049 pt["xs" + pt.l] = sfx || ""; 5050 if (l > 0) { 5051 pt.data["xn" + l] = s + c; 5052 pt.rxp["xn" + l] = r; //round extra property (we need to tap into this in the _parseToProxy() method) 5053 pt["xn" + l] = s; 5054 if (!pt.plugin) { 5055 pt.xfirst = new CSSPropTween(pt, "xn" + l, s, c, pt.xfirst || pt, 0, pt.n, r, pt.pr); 5056 pt.xfirst.xs0 = 0; //just to ensure that the property stays numeric which helps modern browsers speed up processing. Remember, in the setRatio() method, we do pt.t[pt.p] = val + pt.xs0 so if pt.xs0 is "" (the default), it'll cast the end value as a string. When a property is a number sometimes and a string sometimes, it prevents the compiler from locking in the data type, slowing things down slightly. 5057 } 5058 return pt; 5059 } 5060 pt.data = {s:s + c}; 5061 pt.rxp = {}; 5062 pt.s = s; 5063 pt.c = c; 5064 pt.r = r; 5065 return pt; 5066 }; 5067 5068 /** 5069 * @constructor A SpecialProp is basically a css property that needs to be treated in a non-standard way, like if it may contain a complex value like boxShadow:"5px 10px 15px rgb(255, 102, 51)" or if it is associated with another plugin like ThrowPropsPlugin or BezierPlugin. Every SpecialProp is associated with a particular property name like "boxShadow" or "throwProps" or "bezier" and it will intercept those values in the vars object that's passed to the CSSPlugin and handle them accordingly. 5070 * @param {!string} p Property name (like "boxShadow" or "throwProps") 5071 * @param {Object=} options An object containing any of the following configuration options: 5072 * - defaultValue: the default value 5073 * - parser: A function that should be called when the associated property name is found in the vars. This function should return a CSSPropTween instance and it should ensure that it is properly inserted into the linked list. It will receive 4 paramters: 1) The target, 2) The value defined in the vars, 3) The CSSPlugin instance (whose _firstPT should be used for the linked list), and 4) A computed style object if one was calculated (this is a speed optimization that allows retrieval of starting values quicker) 5074 * - formatter: a function that formats any value received for this special property (for example, boxShadow could take "5px 5px red" and format it to "5px 5px 0px 0px red" so that both the beginning and ending values have a common order and quantity of values.) 5075 * - prefix: if true, we'll determine whether or not this property requires a vendor prefix (like Webkit or Moz or ms or O) 5076 * - color: set this to true if the value for this SpecialProp may contain color-related values like rgb(), rgba(), etc. 5077 * - priority: priority in the linked list order. Higher priority SpecialProps will be updated before lower priority ones. The default priority is 0. 5078 * - multi: if true, the formatter should accommodate a comma-delimited list of values, like boxShadow could have multiple boxShadows listed out. 5079 * - collapsible: if true, the formatter should treat the value like it's a top/right/bottom/left value that could be collapsed, like "5px" would apply to all, "5px, 10px" would use 5px for top/bottom and 10px for right/left, etc. 5080 * - keyword: a special keyword that can [optionally] be found inside the value (like "inset" for boxShadow). This allows us to validate beginning/ending values to make sure they match (if the keyword is found in one, it'll be added to the other for consistency by default). 5081 */ 5082 var SpecialProp = function(p, options) { 5083 options = options || {}; 5084 this.p = options.prefix ? _checkPropPrefix(p) || p : p; 5085 _specialProps[p] = _specialProps[this.p] = this; 5086 this.format = options.formatter || _getFormatter(options.defaultValue, options.color, options.collapsible, options.multi); 5087 if (options.parser) { 5088 this.parse = options.parser; 5089 } 5090 this.clrs = options.color; 5091 this.multi = options.multi; 5092 this.keyword = options.keyword; 5093 this.dflt = options.defaultValue; 5094 this.allowFunc = options.allowFunc; 5095 this.pr = options.priority || 0; 5096 }, 5097 5098 //shortcut for creating a new SpecialProp that can accept multiple properties as a comma-delimited list (helps minification). dflt can be an array for multiple values (we don't do a comma-delimited list because the default value may contain commas, like rect(0px,0px,0px,0px)). We attach this method to the SpecialProp class/object instead of using a private _createSpecialProp() method so that we can tap into it externally if necessary, like from another plugin. 5099 _registerComplexSpecialProp = _internals._registerComplexSpecialProp = function(p, options, defaults) { 5100 if (typeof(options) !== "object") { 5101 options = {parser:defaults}; //to make backwards compatible with older versions of BezierPlugin and ThrowPropsPlugin 5102 } 5103 var a = p.split(","), 5104 d = options.defaultValue, 5105 i, temp; 5106 defaults = defaults || [d]; 5107 for (i = 0; i < a.length; i++) { 5108 options.prefix = (i === 0 && options.prefix); 5109 options.defaultValue = defaults[i] || d; 5110 temp = new SpecialProp(a[i], options); 5111 } 5112 }, 5113 5114 //creates a placeholder special prop for a plugin so that the property gets caught the first time a tween of it is attempted, and at that time it makes the plugin register itself, thus taking over for all future tweens of that property. This allows us to not mandate that things load in a particular order and it also allows us to log() an error that informs the user when they attempt to tween an external plugin-related property without loading its .js file. 5115 _registerPluginProp = _internals._registerPluginProp = function(p) { 5116 if (!_specialProps[p]) { 5117 var pluginName = p.charAt(0).toUpperCase() + p.substr(1) + "Plugin"; 5118 _registerComplexSpecialProp(p, {parser:function(t, e, p, cssp, pt, plugin, vars) { 5119 var pluginClass = _globals.com.greensock.plugins[pluginName]; 5120 if (!pluginClass) { 5121 _log("Error: " + pluginName + " js file not loaded."); 5122 return pt; 5123 } 5124 pluginClass._cssRegister(); 5125 return _specialProps[p].parse(t, e, p, cssp, pt, plugin, vars); 5126 }}); 5127 } 5128 }; 5129 5130 5131 p = SpecialProp.prototype; 5132 5133 /** 5134 * Alias for _parseComplex() that automatically plugs in certain values for this SpecialProp, like its property name, whether or not colors should be sensed, the default value, and priority. It also looks for any keyword that the SpecialProp defines (like "inset" for boxShadow) and ensures that the beginning and ending values have the same number of values for SpecialProps where multi is true (like boxShadow and textShadow can have a comma-delimited list) 5135 * @param {!Object} t target element 5136 * @param {(string|number|object)} b beginning value 5137 * @param {(string|number|object)} e ending (destination) value 5138 * @param {CSSPropTween=} pt next CSSPropTween in the linked list 5139 * @param {TweenPlugin=} plugin If another plugin will be tweening the complex value, that TweenPlugin instance goes here. 5140 * @param {function=} setRatio If a custom setRatio() method should be used to handle this complex value, that goes here. 5141 * @return {CSSPropTween=} First CSSPropTween in the linked list 5142 */ 5143 p.parseComplex = function(t, b, e, pt, plugin, setRatio) { 5144 var kwd = this.keyword, 5145 i, ba, ea, l, bi, ei; 5146 //if this SpecialProp's value can contain a comma-delimited list of values (like boxShadow or textShadow), we must parse them in a special way, and look for a keyword (like "inset" for boxShadow) and ensure that the beginning and ending BOTH have it if the end defines it as such. We also must ensure that there are an equal number of values specified (we can't tween 1 boxShadow to 3 for example) 5147 if (this.multi) if (_commasOutsideParenExp.test(e) || _commasOutsideParenExp.test(b)) { 5148 ba = b.replace(_commasOutsideParenExp, "|").split("|"); 5149 ea = e.replace(_commasOutsideParenExp, "|").split("|"); 5150 } else if (kwd) { 5151 ba = [b]; 5152 ea = [e]; 5153 } 5154 if (ea) { 5155 l = (ea.length > ba.length) ? ea.length : ba.length; 5156 for (i = 0; i < l; i++) { 5157 b = ba[i] = ba[i] || this.dflt; 5158 e = ea[i] = ea[i] || this.dflt; 5159 if (kwd) { 5160 bi = b.indexOf(kwd); 5161 ei = e.indexOf(kwd); 5162 if (bi !== ei) { 5163 if (ei === -1) { //if the keyword isn't in the end value, remove it from the beginning one. 5164 ba[i] = ba[i].split(kwd).join(""); 5165 } else if (bi === -1) { //if the keyword isn't in the beginning, add it. 5166 ba[i] += " " + kwd; 5167 } 5168 } 5169 } 5170 } 5171 b = ba.join(", "); 5172 e = ea.join(", "); 5173 } 5174 return _parseComplex(t, this.p, b, e, this.clrs, this.dflt, pt, this.pr, plugin, setRatio); 5175 }; 5176 5177 /** 5178 * Accepts a target and end value and spits back a CSSPropTween that has been inserted into the CSSPlugin's linked list and conforms with all the conventions we use internally, like type:-1, 0, 1, or 2, setting up any extra property tweens, priority, etc. For example, if we have a boxShadow SpecialProp and call: 5179 * this._firstPT = sp.parse(element, "5px 10px 20px rgb(2550,102,51)", "boxShadow", this); 5180 * It should figure out the starting value of the element's boxShadow, compare it to the provided end value and create all the necessary CSSPropTweens of the appropriate types to tween the boxShadow. The CSSPropTween that gets spit back should already be inserted into the linked list (the 4th parameter is the current head, so prepend to that). 5181 * @param {!Object} t Target object whose property is being tweened 5182 * @param {Object} e End value as provided in the vars object (typically a string, but not always - like a throwProps would be an object). 5183 * @param {!string} p Property name 5184 * @param {!CSSPlugin} cssp The CSSPlugin instance that should be associated with this tween. 5185 * @param {?CSSPropTween} pt The CSSPropTween that is the current head of the linked list (we'll prepend to it) 5186 * @param {TweenPlugin=} plugin If a plugin will be used to tween the parsed value, this is the plugin instance. 5187 * @param {Object=} vars Original vars object that contains the data for parsing. 5188 * @return {CSSPropTween} The first CSSPropTween in the linked list which includes the new one(s) added by the parse() call. 5189 */ 5190 p.parse = function(t, e, p, cssp, pt, plugin, vars) { 5191 return this.parseComplex(t.style, this.format(_getStyle(t, this.p, _cs, false, this.dflt)), this.format(e), pt, plugin); 5192 }; 5193 5194 /** 5195 * Registers a special property that should be intercepted from any "css" objects defined in tweens. This allows you to handle them however you want without CSSPlugin doing it for you. The 2nd parameter should be a function that accepts 3 parameters: 5196 * 1) Target object whose property should be tweened (typically a DOM element) 5197 * 2) The end/destination value (could be a string, number, object, or whatever you want) 5198 * 3) The tween instance (you probably don't need to worry about this, but it can be useful for looking up information like the duration) 5199 * 5200 * Then, your function should return a function which will be called each time the tween gets rendered, passing a numeric "ratio" parameter to your function that indicates the change factor (usually between 0 and 1). For example: 5201 * 5202 * CSSPlugin.registerSpecialProp("myCustomProp", function(target, value, tween) { 5203 * var start = target.style.width; 5204 * return function(ratio) { 5205 * target.style.width = (start + value * ratio) + "px"; 5206 * console.log("set width to " + target.style.width); 5207 * } 5208 * }, 0); 5209 * 5210 * Then, when I do this tween, it will trigger my special property: 5211 * 5212 * TweenLite.to(element, 1, {css:{myCustomProp:100}}); 5213 * 5214 * In the example, of course, we're just changing the width, but you can do anything you want. 5215 * 5216 * @param {!string} name Property name (or comma-delimited list of property names) that should be intercepted and handled by your function. For example, if I define "myCustomProp", then it would handle that portion of the following tween: TweenLite.to(element, 1, {css:{myCustomProp:100}}) 5217 * @param {!function(Object, Object, Object, string):function(number)} onInitTween The function that will be called when a tween of this special property is performed. The function will receive 4 parameters: 1) Target object that should be tweened, 2) Value that was passed to the tween, 3) The tween instance itself (rarely used), and 4) The property name that's being tweened. Your function should return a function that should be called on every update of the tween. That function will receive a single parameter that is a "change factor" value (typically between 0 and 1) indicating the amount of change as a ratio. You can use this to determine how to set the values appropriately in your function. 5218 * @param {number=} priority Priority that helps the engine determine the order in which to set the properties (default: 0). Higher priority properties will be updated before lower priority ones. 5219 */ 5220 CSSPlugin.registerSpecialProp = function(name, onInitTween, priority) { 5221 _registerComplexSpecialProp(name, {parser:function(t, e, p, cssp, pt, plugin, vars) { 5222 var rv = new CSSPropTween(t, p, 0, 0, pt, 2, p, false, priority); 5223 rv.plugin = plugin; 5224 rv.setRatio = onInitTween(t, e, cssp._tween, p); 5225 return rv; 5226 }, priority:priority}); 5227 }; 5228 5229 5230 5231 5232 5233 5234 //transform-related methods and properties 5235 CSSPlugin.useSVGTransformAttr = true; //Safari and Firefox both have some rendering bugs when applying CSS transforms to SVG elements, so default to using the "transform" attribute instead (users can override this). 5236 var _transformProps = ("scaleX,scaleY,scaleZ,x,y,z,skewX,skewY,rotation,rotationX,rotationY,perspective,xPercent,yPercent").split(","), 5237 _transformProp = _checkPropPrefix("transform"), //the Javascript (camelCase) transform property, like msTransform, WebkitTransform, MozTransform, or OTransform. 5238 _transformPropCSS = _prefixCSS + "transform", 5239 _transformOriginProp = _checkPropPrefix("transformOrigin"), 5240 _supports3D = (_checkPropPrefix("perspective") !== null), 5241 Transform = _internals.Transform = function() { 5242 this.perspective = parseFloat(CSSPlugin.defaultTransformPerspective) || 0; 5243 this.force3D = (CSSPlugin.defaultForce3D === false || !_supports3D) ? false : CSSPlugin.defaultForce3D || "auto"; 5244 }, 5245 _SVGElement = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].SVGElement, 5246 _useSVGTransformAttr, 5247 //Some browsers (like Firefox and IE) don't honor transform-origin properly in SVG elements, so we need to manually adjust the matrix accordingly. We feature detect here rather than always doing the conversion for certain browsers because they may fix the problem at some point in the future. 5248 5249 _createSVG = function(type, container, attributes) { 5250 var element = _doc.createElementNS("http://www.w3.org/2000/svg", type), 5251 reg = /([a-z])([A-Z])/g, 5252 p; 5253 for (p in attributes) { 5254 element.setAttributeNS(null, p.replace(reg, "$1-$2").toLowerCase(), attributes[p]); 5255 } 5256 container.appendChild(element); 5257 return element; 5258 }, 5259 _docElement = _doc.documentElement || {}, 5260 _forceSVGTransformAttr = (function() { 5261 //IE and Android stock don't support CSS transforms on SVG elements, so we must write them to the "transform" attribute. We populate this variable in the _parseTransform() method, and only if/when we come across an SVG element 5262 var force = _ieVers || (/Android/i.test(_agent) && !_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].chrome), 5263 svg, rect, width; 5264 if (_doc.createElementNS && !force) { //IE8 and earlier doesn't support SVG anyway 5265 svg = _createSVG("svg", _docElement); 5266 rect = _createSVG("rect", svg, {width:100, height:50, x:100}); 5267 width = rect.getBoundingClientRect().width; 5268 rect.style[_transformOriginProp] = "50% 50%"; 5269 rect.style[_transformProp] = "scaleX(0.5)"; 5270 force = (width === rect.getBoundingClientRect().width && !(_isFirefox && _supports3D)); //note: Firefox fails the test even though it does support CSS transforms in 3D. Since we can't push 3D stuff into the transform attribute, we force Firefox to pass the test here (as long as it does truly support 3D). 5271 _docElement.removeChild(svg); 5272 } 5273 return force; 5274 })(), 5275 _parseSVGOrigin = function(e, local, decoratee, absolute, smoothOrigin, skipRecord) { 5276 var tm = e._gsTransform, 5277 m = _getMatrix(e, true), 5278 v, x, y, xOrigin, yOrigin, a, b, c, d, tx, ty, determinant, xOriginOld, yOriginOld; 5279 if (tm) { 5280 xOriginOld = tm.xOrigin; //record the original values before we alter them. 5281 yOriginOld = tm.yOrigin; 5282 } 5283 if (!absolute || (v = absolute.split(" ")).length < 2) { 5284 b = e.getBBox(); 5285 if (b.x === 0 && b.y === 0 && b.width + b.height === 0) { //some browsers (like Firefox) misreport the bounds if the element has zero width and height (it just assumes it's at x:0, y:0), thus we need to manually grab the position in that case. 5286 b = {x: parseFloat(e.hasAttribute("x") ? e.getAttribute("x") : e.hasAttribute("cx") ? e.getAttribute("cx") : 0) || 0, y: parseFloat(e.hasAttribute("y") ? e.getAttribute("y") : e.hasAttribute("cy") ? e.getAttribute("cy") : 0) || 0, width:0, height:0}; 5287 } 5288 local = _parsePosition(local).split(" "); 5289 v = [(local[0].indexOf("%") !== -1 ? parseFloat(local[0]) / 100 * b.width : parseFloat(local[0])) + b.x, 5290 (local[1].indexOf("%") !== -1 ? parseFloat(local[1]) / 100 * b.height : parseFloat(local[1])) + b.y]; 5291 } 5292 decoratee.xOrigin = xOrigin = parseFloat(v[0]); 5293 decoratee.yOrigin = yOrigin = parseFloat(v[1]); 5294 if (absolute && m !== _identity2DMatrix) { //if svgOrigin is being set, we must invert the matrix and determine where the absolute point is, factoring in the current transforms. Otherwise, the svgOrigin would be based on the element's non-transformed position on the canvas. 5295 a = m[0]; 5296 b = m[1]; 5297 c = m[2]; 5298 d = m[3]; 5299 tx = m[4]; 5300 ty = m[5]; 5301 determinant = (a * d - b * c); 5302 if (determinant) { //if it's zero (like if scaleX and scaleY are zero), skip it to avoid errors with dividing by zero. 5303 x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + ((c * ty - d * tx) / determinant); 5304 y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - ((a * ty - b * tx) / determinant); 5305 xOrigin = decoratee.xOrigin = v[0] = x; 5306 yOrigin = decoratee.yOrigin = v[1] = y; 5307 } 5308 } 5309 if (tm) { //avoid jump when transformOrigin is changed - adjust the x/y values accordingly 5310 if (skipRecord) { 5311 decoratee.xOffset = tm.xOffset; 5312 decoratee.yOffset = tm.yOffset; 5313 tm = decoratee; 5314 } 5315 if (smoothOrigin || (smoothOrigin !== false && CSSPlugin.defaultSmoothOrigin !== false)) { 5316 x = xOrigin - xOriginOld; 5317 y = yOrigin - yOriginOld; 5318 //originally, we simply adjusted the x and y values, but that would cause problems if, for example, you created a rotational tween part-way through an x/y tween. Managing the offset in a separate variable gives us ultimate flexibility. 5319 //tm.x -= x - (x * m[0] + y * m[2]); 5320 //tm.y -= y - (x * m[1] + y * m[3]); 5321 tm.xOffset += (x * m[0] + y * m[2]) - x; 5322 tm.yOffset += (x * m[1] + y * m[3]) - y; 5323 } else { 5324 tm.xOffset = tm.yOffset = 0; 5325 } 5326 } 5327 if (!skipRecord) { 5328 e.setAttribute("data-svg-origin", v.join(" ")); 5329 } 5330 }, 5331 _getBBoxHack = function(swapIfPossible) { //works around issues in some browsers (like Firefox) that don't correctly report getBBox() on SVG elements inside a <defs> element and/or <mask>. We try creating an SVG, adding it to the documentElement and toss the element in there so that it's definitely part of the rendering tree, then grab the bbox and if it works, we actually swap out the original getBBox() method for our own that does these extra steps whenever getBBox is needed. This helps ensure that performance is optimal (only do all these extra steps when absolutely necessary...most elements don't need it). 5332 var svg = _createElement("svg", (this.ownerSVGElement && this.ownerSVGElement.getAttribute("xmlns")) || "http://www.w3.org/2000/svg"), 5333 oldParent = this.parentNode, 5334 oldSibling = this.nextSibling, 5335 oldCSS = this.style.cssText, 5336 bbox; 5337 _docElement.appendChild(svg); 5338 svg.appendChild(this); 5339 this.style.display = "block"; 5340 if (swapIfPossible) { 5341 try { 5342 bbox = this.getBBox(); 5343 this._originalGetBBox = this.getBBox; 5344 this.getBBox = _getBBoxHack; 5345 } catch (e) { } 5346 } else if (this._originalGetBBox) { 5347 bbox = this._originalGetBBox(); 5348 } 5349 if (oldSibling) { 5350 oldParent.insertBefore(this, oldSibling); 5351 } else { 5352 oldParent.appendChild(this); 5353 } 5354 _docElement.removeChild(svg); 5355 this.style.cssText = oldCSS; 5356 return bbox; 5357 }, 5358 _getBBox = function(e) { 5359 try { 5360 return e.getBBox(); //Firefox throws errors if you try calling getBBox() on an SVG element that's not rendered (like in a <symbol> or <defs>). https://bugzilla.mozilla.org/show_bug.cgi?id=612118 5361 } catch (error) { 5362 return _getBBoxHack.call(e, true); 5363 } 5364 }, 5365 _isSVG = function(e) { //reports if the element is an SVG on which getBBox() actually works 5366 return !!(_SVGElement && e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e)); 5367 }, 5368 _identity2DMatrix = [1,0,0,1,0,0], 5369 _getMatrix = function(e, force2D) { 5370 var tm = e._gsTransform || new Transform(), 5371 rnd = 100000, 5372 style = e.style, 5373 isDefault, s, m, n, dec, nextSibling, parent; 5374 if (_transformProp) { 5375 s = _getStyle(e, _transformPropCSS, null, true); 5376 } else if (e.currentStyle) { 5377 //for older versions of IE, we need to interpret the filter portion that is in the format: progid:DXImageTransform.Microsoft.Matrix(M11=6.123233995736766e-17, M12=-1, M21=1, M22=6.123233995736766e-17, sizingMethod='auto expand') Notice that we need to swap b and c compared to a normal matrix. 5378 s = e.currentStyle.filter.match(_ieGetMatrixExp); 5379 s = (s && s.length === 4) ? [s[0].substr(4), Number(s[2].substr(4)), Number(s[1].substr(4)), s[3].substr(4), (tm.x || 0), (tm.y || 0)].join(",") : ""; 5380 } 5381 isDefault = (!s || s === "none" || s === "matrix(1, 0, 0, 1, 0, 0)"); 5382 if (_transformProp && isDefault && !e.offsetParent) { //note: if offsetParent is null, that means the element isn't in the normal document flow, like if it has display:none or one of its ancestors has display:none). Firefox returns null for getComputedStyle() if the element is in an iframe that has display:none. https://bugzilla.mozilla.org/show_bug.cgi?id=548397 5383 //browsers don't report transforms accurately unless the element is in the DOM and has a display value that's not "none". Firefox and Microsoft browsers have a partial bug where they'll report transforms even if display:none BUT not any percentage-based values like translate(-50%, 8px) will be reported as if it's translate(0, 8px). 5384 n = style.display; 5385 style.display = "block"; 5386 parent = e.parentNode; 5387 if (!parent || !e.offsetParent) { 5388 dec = 1; //flag 5389 nextSibling = e.nextSibling; 5390 _docElement.appendChild(e); //we must add it to the DOM in order to get values properly 5391 } 5392 s = _getStyle(e, _transformPropCSS, null, true); 5393 isDefault = (!s || s === "none" || s === "matrix(1, 0, 0, 1, 0, 0)"); 5394 if (n) { 5395 style.display = n; 5396 } else { 5397 _removeProp(style, "display"); 5398 } 5399 if (dec) { 5400 if (nextSibling) { 5401 parent.insertBefore(e, nextSibling); 5402 } else if (parent) { 5403 parent.appendChild(e); 5404 } else { 5405 _docElement.removeChild(e); 5406 } 5407 } 5408 } 5409 if (tm.svg || (e.getCTM && _isSVG(e))) { 5410 if (isDefault && (style[_transformProp] + "").indexOf("matrix") !== -1) { //some browsers (like Chrome 40) don't correctly report transforms that are applied inline on an SVG element (they don't get included in the computed style), so we double-check here and accept matrix values 5411 s = style[_transformProp]; 5412 isDefault = 0; 5413 } 5414 m = e.getAttribute("transform"); 5415 if (isDefault && m) { 5416 m = e.transform.baseVal.consolidate().matrix; //ensures that even complex values like "translate(50,60) rotate(135,0,0)" are parsed because it mashes it into a matrix. 5417 s = "matrix(" + m.a + "," + m.b + "," + m.c + "," + m.d + "," + m.e + "," + m.f + ")"; 5418 isDefault = 0; 5419 } 5420 } 5421 if (isDefault) { 5422 return _identity2DMatrix; 5423 } 5424 //split the matrix values out into an array (m for matrix) 5425 m = (s || "").match(_numExp) || []; 5426 i = m.length; 5427 while (--i > -1) { 5428 n = Number(m[i]); 5429 m[i] = (dec = n - (n |= 0)) ? ((dec * rnd + (dec < 0 ? -0.5 : 0.5)) | 0) / rnd + n : n; //convert strings to Numbers and round to 5 decimal places to avoid issues with tiny numbers. Roughly 20x faster than Number.toFixed(). We also must make sure to round before dividing so that values like 0.9999999999 become 1 to avoid glitches in browser rendering and interpretation of flipped/rotated 3D matrices. And don't just multiply the number by rnd, floor it, and then divide by rnd because the bitwise operations max out at a 32-bit signed integer, thus it could get clipped at a relatively low value (like 22,000.00000 for example). 5430 } 5431 return (force2D && m.length > 6) ? [m[0], m[1], m[4], m[5], m[12], m[13]] : m; 5432 }, 5433 5434 /** 5435 * Parses the transform values for an element, returning an object with x, y, z, scaleX, scaleY, scaleZ, rotation, rotationX, rotationY, skewX, and skewY properties. Note: by default (for performance reasons), all skewing is combined into skewX and rotation but skewY still has a place in the transform object so that we can record how much of the skew is attributed to skewX vs skewY. Remember, a skewY of 10 looks the same as a rotation of 10 and skewX of -10. 5436 * @param {!Object} t target element 5437 * @param {Object=} cs computed style object (optional) 5438 * @param {boolean=} rec if true, the transform values will be recorded to the target element's _gsTransform object, like target._gsTransform = {x:0, y:0, z:0, scaleX:1...} 5439 * @param {boolean=} parse if true, we'll ignore any _gsTransform values that already exist on the element, and force a reparsing of the css (calculated style) 5440 * @return {object} object containing all of the transform properties/values like {x:0, y:0, z:0, scaleX:1...} 5441 */ 5442 _getTransform = _internals.getTransform = function(t, cs, rec, parse) { 5443 if (t._gsTransform && rec && !parse) { 5444 return t._gsTransform; //if the element already has a _gsTransform, use that. Note: some browsers don't accurately return the calculated style for the transform (particularly for SVG), so it's almost always safest to just use the values we've already applied rather than re-parsing things. 5445 } 5446 var tm = rec ? t._gsTransform || new Transform() : new Transform(), 5447 invX = (tm.scaleX < 0), //in order to interpret things properly, we need to know if the user applied a negative scaleX previously so that we can adjust the rotation and skewX accordingly. Otherwise, if we always interpret a flipped matrix as affecting scaleY and the user only wants to tween the scaleX on multiple sequential tweens, it would keep the negative scaleY without that being the user's intent. 5448 min = 0.00002, 5449 rnd = 100000, 5450 zOrigin = _supports3D ? parseFloat(_getStyle(t, _transformOriginProp, cs, false, "0 0 0").split(" ")[2]) || tm.zOrigin || 0 : 0, 5451 defaultTransformPerspective = parseFloat(CSSPlugin.defaultTransformPerspective) || 0, 5452 m, i, scaleX, scaleY, rotation, skewX; 5453 5454 tm.svg = !!(t.getCTM && _isSVG(t)); 5455 if (tm.svg) { 5456 _parseSVGOrigin(t, _getStyle(t, _transformOriginProp, cs, false, "50% 50%") + "", tm, t.getAttribute("data-svg-origin")); 5457 _useSVGTransformAttr = CSSPlugin.useSVGTransformAttr || _forceSVGTransformAttr; 5458 } 5459 m = _getMatrix(t); 5460 if (m !== _identity2DMatrix) { 5461 5462 if (m.length === 16) { 5463 //we'll only look at these position-related 6 variables first because if x/y/z all match, it's relatively safe to assume we don't need to re-parse everything which risks losing important rotational information (like rotationX:180 plus rotationY:180 would look the same as rotation:180 - there's no way to know for sure which direction was taken based solely on the matrix3d() values) 5464 var a11 = m[0], a21 = m[1], a31 = m[2], a41 = m[3], 5465 a12 = m[4], a22 = m[5], a32 = m[6], a42 = m[7], 5466 a13 = m[8], a23 = m[9], a33 = m[10], 5467 a14 = m[12], a24 = m[13], a34 = m[14], 5468 a43 = m[11], 5469 angle = Math.atan2(a32, a33), 5470 t1, t2, t3, t4, cos, sin; 5471 //we manually compensate for non-zero z component of transformOrigin to work around bugs in Safari 5472 if (tm.zOrigin) { 5473 a34 = -tm.zOrigin; 5474 a14 = a13*a34-m[12]; 5475 a24 = a23*a34-m[13]; 5476 a34 = a33*a34+tm.zOrigin-m[14]; 5477 } 5478 //note for possible future consolidation: rotationX: Math.atan2(a32, a33), rotationY: Math.atan2(-a31, Math.sqrt(a33 * a33 + a32 * a32)), rotation: Math.atan2(a21, a11), skew: Math.atan2(a12, a22). However, it doesn't seem to be quite as reliable as the full-on backwards rotation procedure. 5479 tm.rotationX = angle * _RAD2DEG; 5480 //rotationX 5481 if (angle) { 5482 cos = Math.cos(-angle); 5483 sin = Math.sin(-angle); 5484 t1 = a12*cos+a13*sin; 5485 t2 = a22*cos+a23*sin; 5486 t3 = a32*cos+a33*sin; 5487 a13 = a12*-sin+a13*cos; 5488 a23 = a22*-sin+a23*cos; 5489 a33 = a32*-sin+a33*cos; 5490 a43 = a42*-sin+a43*cos; 5491 a12 = t1; 5492 a22 = t2; 5493 a32 = t3; 5494 } 5495 //rotationY 5496 angle = Math.atan2(-a31, a33); 5497 tm.rotationY = angle * _RAD2DEG; 5498 if (angle) { 5499 cos = Math.cos(-angle); 5500 sin = Math.sin(-angle); 5501 t1 = a11*cos-a13*sin; 5502 t2 = a21*cos-a23*sin; 5503 t3 = a31*cos-a33*sin; 5504 a23 = a21*sin+a23*cos; 5505 a33 = a31*sin+a33*cos; 5506 a43 = a41*sin+a43*cos; 5507 a11 = t1; 5508 a21 = t2; 5509 a31 = t3; 5510 } 5511 //rotationZ 5512 angle = Math.atan2(a21, a11); 5513 tm.rotation = angle * _RAD2DEG; 5514 if (angle) { 5515 cos = Math.cos(angle); 5516 sin = Math.sin(angle); 5517 t1 = a11*cos+a21*sin; 5518 t2 = a12*cos+a22*sin; 5519 t3 = a13*cos+a23*sin; 5520 a21 = a21*cos-a11*sin; 5521 a22 = a22*cos-a12*sin; 5522 a23 = a23*cos-a13*sin; 5523 a11 = t1; 5524 a12 = t2; 5525 a13 = t3; 5526 } 5527 5528 if (tm.rotationX && Math.abs(tm.rotationX) + Math.abs(tm.rotation) > 359.9) { //when rotationY is set, it will often be parsed as 180 degrees different than it should be, and rotationX and rotation both being 180 (it looks the same), so we adjust for that here. 5529 tm.rotationX = tm.rotation = 0; 5530 tm.rotationY = 180 - tm.rotationY; 5531 } 5532 5533 //skewX 5534 angle = Math.atan2(a12, a22); 5535 5536 //scales 5537 tm.scaleX = ((Math.sqrt(a11 * a11 + a21 * a21 + a31 * a31) * rnd + 0.5) | 0) / rnd; 5538 tm.scaleY = ((Math.sqrt(a22 * a22 + a32 * a32) * rnd + 0.5) | 0) / rnd; 5539 tm.scaleZ = ((Math.sqrt(a13 * a13 + a23 * a23 + a33 * a33) * rnd + 0.5) | 0) / rnd; 5540 a11 /= tm.scaleX; 5541 a12 /= tm.scaleY; 5542 a21 /= tm.scaleX; 5543 a22 /= tm.scaleY; 5544 if (Math.abs(angle) > min) { 5545 tm.skewX = angle * _RAD2DEG; 5546 a12 = 0; //unskews 5547 if (tm.skewType !== "simple") { 5548 tm.scaleY *= 1 / Math.cos(angle); //by default, we compensate the scale based on the skew so that the element maintains a similar proportion when skewed, so we have to alter the scaleY here accordingly to match the default (non-adjusted) skewing that CSS does (stretching more and more as it skews). 5549 } 5550 5551 } else { 5552 tm.skewX = 0; 5553 } 5554 5555 /* //for testing purposes 5556 var transform = "matrix3d(", 5557 comma = ",", 5558 zero = "0"; 5559 a13 /= tm.scaleZ; 5560 a23 /= tm.scaleZ; 5561 a31 /= tm.scaleX; 5562 a32 /= tm.scaleY; 5563 a33 /= tm.scaleZ; 5564 transform += ((a11 < min && a11 > -min) ? zero : a11) + comma + ((a21 < min && a21 > -min) ? zero : a21) + comma + ((a31 < min && a31 > -min) ? zero : a31); 5565 transform += comma + ((a41 < min && a41 > -min) ? zero : a41) + comma + ((a12 < min && a12 > -min) ? zero : a12) + comma + ((a22 < min && a22 > -min) ? zero : a22); 5566 transform += comma + ((a32 < min && a32 > -min) ? zero : a32) + comma + ((a42 < min && a42 > -min) ? zero : a42) + comma + ((a13 < min && a13 > -min) ? zero : a13); 5567 transform += comma + ((a23 < min && a23 > -min) ? zero : a23) + comma + ((a33 < min && a33 > -min) ? zero : a33) + comma + ((a43 < min && a43 > -min) ? zero : a43) + comma; 5568 transform += a14 + comma + a24 + comma + a34 + comma + (tm.perspective ? (1 + (-a34 / tm.perspective)) : 1) + ")"; 5569 console.log(transform); 5570 document.querySelector(".test").style[_transformProp] = transform; 5571 */ 5572 5573 tm.perspective = a43 ? 1 / ((a43 < 0) ? -a43 : a43) : 0; 5574 tm.x = a14; 5575 tm.y = a24; 5576 tm.z = a34; 5577 if (tm.svg) { 5578 tm.x -= tm.xOrigin - (tm.xOrigin * a11 - tm.yOrigin * a12); 5579 tm.y -= tm.yOrigin - (tm.yOrigin * a21 - tm.xOrigin * a22); 5580 } 5581 5582 } else if ((!_supports3D || parse || !m.length || tm.x !== m[4] || tm.y !== m[5] || (!tm.rotationX && !tm.rotationY))) { //sometimes a 6-element matrix is returned even when we performed 3D transforms, like if rotationX and rotationY are 180. In cases like this, we still need to honor the 3D transforms. If we just rely on the 2D info, it could affect how the data is interpreted, like scaleY might get set to -1 or rotation could get offset by 180 degrees. For example, do a TweenLite.to(element, 1, {css:{rotationX:180, rotationY:180}}) and then later, TweenLite.to(element, 1, {css:{rotationX:0}}) and without this conditional logic in place, it'd jump to a state of being unrotated when the 2nd tween starts. Then again, we need to honor the fact that the user COULD alter the transforms outside of CSSPlugin, like by manually applying new css, so we try to sense that by looking at x and y because if those changed, we know the changes were made outside CSSPlugin and we force a reinterpretation of the matrix values. Also, in Webkit browsers, if the element's "display" is "none", its calculated style value will always return empty, so if we've already recorded the values in the _gsTransform object, we'll just rely on those. 5583 var k = (m.length >= 6), 5584 a = k ? m[0] : 1, 5585 b = m[1] || 0, 5586 c = m[2] || 0, 5587 d = k ? m[3] : 1; 5588 tm.x = m[4] || 0; 5589 tm.y = m[5] || 0; 5590 scaleX = Math.sqrt(a * a + b * b); 5591 scaleY = Math.sqrt(d * d + c * c); 5592 rotation = (a || b) ? Math.atan2(b, a) * _RAD2DEG : tm.rotation || 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist). 5593 skewX = (c || d) ? Math.atan2(c, d) * _RAD2DEG + rotation : tm.skewX || 0; 5594 tm.scaleX = scaleX; 5595 tm.scaleY = scaleY; 5596 tm.rotation = rotation; 5597 tm.skewX = skewX; 5598 if (_supports3D) { 5599 tm.rotationX = tm.rotationY = tm.z = 0; 5600 tm.perspective = defaultTransformPerspective; 5601 tm.scaleZ = 1; 5602 } 5603 if (tm.svg) { 5604 tm.x -= tm.xOrigin - (tm.xOrigin * a + tm.yOrigin * c); 5605 tm.y -= tm.yOrigin - (tm.xOrigin * b + tm.yOrigin * d); 5606 } 5607 } 5608 if (Math.abs(tm.skewX) > 90 && Math.abs(tm.skewX) < 270) { 5609 if (invX) { 5610 tm.scaleX *= -1; 5611 tm.skewX += (tm.rotation <= 0) ? 180 : -180; 5612 tm.rotation += (tm.rotation <= 0) ? 180 : -180; 5613 } else { 5614 tm.scaleY *= -1; 5615 tm.skewX += (tm.skewX <= 0) ? 180 : -180; 5616 } 5617 } 5618 tm.zOrigin = zOrigin; 5619 //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 0 in these cases. The conditional logic here is faster than calling Math.abs(). Also, browsers tend to render a SLIGHTLY rotated object in a fuzzy way, so we need to snap to exactly 0 when appropriate. 5620 for (i in tm) { 5621 if (tm[i] < min) if (tm[i] > -min) { 5622 tm[i] = 0; 5623 } 5624 } 5625 } 5626 //DEBUG: _log("parsed rotation of " + t.getAttribute("id")+": "+(tm.rotationX)+", "+(tm.rotationY)+", "+(tm.rotation)+", scale: "+tm.scaleX+", "+tm.scaleY+", "+tm.scaleZ+", position: "+tm.x+", "+tm.y+", "+tm.z+", perspective: "+tm.perspective+ ", origin: "+ tm.xOrigin+ ","+ tm.yOrigin); 5627 if (rec) { 5628 t._gsTransform = tm; //record to the object's _gsTransform which we use so that tweens can control individual properties independently (we need all the properties to accurately recompose the matrix in the setRatio() method) 5629 if (tm.svg) { //if we're supposed to apply transforms to the SVG element's "transform" attribute, make sure there aren't any CSS transforms applied or they'll override the attribute ones. Also clear the transform attribute if we're using CSS, just to be clean. 5630 if (_useSVGTransformAttr && t.style[_transformProp]) { 5631 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0.001, function(){ //if we apply this right away (before anything has rendered), we risk there being no transforms for a brief moment and it also interferes with adjusting the transformOrigin in a tween with immediateRender:true (it'd try reading the matrix and it wouldn't have the appropriate data in place because we just removed it). 5632 _removeProp(t.style, _transformProp); 5633 }); 5634 } else if (!_useSVGTransformAttr && t.getAttribute("transform")) { 5635 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0.001, function(){ 5636 t.removeAttribute("transform"); 5637 }); 5638 } 5639 } 5640 } 5641 return tm; 5642 }, 5643 5644 //for setting 2D transforms in IE6, IE7, and IE8 (must use a "filter" to emulate the behavior of modern day browser transforms) 5645 _setIETransformRatio = function(v) { 5646 var t = this.data, //refers to the element's _gsTransform object 5647 ang = -t.rotation * _DEG2RAD, 5648 skew = ang + t.skewX * _DEG2RAD, 5649 rnd = 100000, 5650 a = ((Math.cos(ang) * t.scaleX * rnd) | 0) / rnd, 5651 b = ((Math.sin(ang) * t.scaleX * rnd) | 0) / rnd, 5652 c = ((Math.sin(skew) * -t.scaleY * rnd) | 0) / rnd, 5653 d = ((Math.cos(skew) * t.scaleY * rnd) | 0) / rnd, 5654 style = this.t.style, 5655 cs = this.t.currentStyle, 5656 filters, val; 5657 if (!cs) { 5658 return; 5659 } 5660 val = b; //just for swapping the variables an inverting them (reused "val" to avoid creating another variable in memory). IE's filter matrix uses a non-standard matrix configuration (angle goes the opposite way, and b and c are reversed and inverted) 5661 b = -c; 5662 c = -val; 5663 filters = cs.filter; 5664 style.filter = ""; //remove filters so that we can accurately measure offsetWidth/offsetHeight 5665 var w = this.t.offsetWidth, 5666 h = this.t.offsetHeight, 5667 clip = (cs.position !== "absolute"), 5668 m = "progid:DXImageTransform.Microsoft.Matrix(M11=" + a + ", M12=" + b + ", M21=" + c + ", M22=" + d, 5669 ox = t.x + (w * t.xPercent / 100), 5670 oy = t.y + (h * t.yPercent / 100), 5671 dx, dy; 5672 5673 //if transformOrigin is being used, adjust the offset x and y 5674 if (t.ox != null) { 5675 dx = ((t.oxp) ? w * t.ox * 0.01 : t.ox) - w / 2; 5676 dy = ((t.oyp) ? h * t.oy * 0.01 : t.oy) - h / 2; 5677 ox += dx - (dx * a + dy * b); 5678 oy += dy - (dx * c + dy * d); 5679 } 5680 5681 if (!clip) { 5682 m += ", sizingMethod='auto expand')"; 5683 } else { 5684 dx = (w / 2); 5685 dy = (h / 2); 5686 //translate to ensure that transformations occur around the correct origin (default is center). 5687 m += ", Dx=" + (dx - (dx * a + dy * b) + ox) + ", Dy=" + (dy - (dx * c + dy * d) + oy) + ")"; 5688 } 5689 if (filters.indexOf("DXImageTransform.Microsoft.Matrix(") !== -1) { 5690 style.filter = filters.replace(_ieSetMatrixExp, m); 5691 } else { 5692 style.filter = m + " " + filters; //we must always put the transform/matrix FIRST (before alpha(opacity=xx)) to avoid an IE bug that slices part of the object when rotation is applied with alpha. 5693 } 5694 5695 //at the end or beginning of the tween, if the matrix is normal (1, 0, 0, 1) and opacity is 100 (or doesn't exist), remove the filter to improve browser performance. 5696 if (v === 0 || v === 1) if (a === 1) if (b === 0) if (c === 0) if (d === 1) if (!clip || m.indexOf("Dx=0, Dy=0") !== -1) if (!_opacityExp.test(filters) || parseFloat(RegExp.$1) === 100) if (filters.indexOf( true && filters.indexOf("Alpha")) === -1) { 5697 style.removeAttribute("filter"); 5698 } 5699 5700 //we must set the margins AFTER applying the filter in order to avoid some bugs in IE8 that could (in rare scenarios) cause them to be ignored intermittently (vibration). 5701 if (!clip) { 5702 var mult = (_ieVers < 8) ? 1 : -1, //in Internet Explorer 7 and before, the box model is broken, causing the browser to treat the width/height of the actual rotated filtered image as the width/height of the box itself, but Microsoft corrected that in IE8. We must use a negative offset in IE8 on the right/bottom 5703 marg, prop, dif; 5704 dx = t.ieOffsetX || 0; 5705 dy = t.ieOffsetY || 0; 5706 t.ieOffsetX = Math.round((w - ((a < 0 ? -a : a) * w + (b < 0 ? -b : b) * h)) / 2 + ox); 5707 t.ieOffsetY = Math.round((h - ((d < 0 ? -d : d) * h + (c < 0 ? -c : c) * w)) / 2 + oy); 5708 for (i = 0; i < 4; i++) { 5709 prop = _margins[i]; 5710 marg = cs[prop]; 5711 //we need to get the current margin in case it is being tweened separately (we want to respect that tween's changes) 5712 val = (marg.indexOf("px") !== -1) ? parseFloat(marg) : _convertToPixels(this.t, prop, parseFloat(marg), marg.replace(_suffixExp, "")) || 0; 5713 if (val !== t[prop]) { 5714 dif = (i < 2) ? -t.ieOffsetX : -t.ieOffsetY; //if another tween is controlling a margin, we cannot only apply the difference in the ieOffsets, so we essentially zero-out the dx and dy here in that case. We record the margin(s) later so that we can keep comparing them, making this code very flexible. 5715 } else { 5716 dif = (i < 2) ? dx - t.ieOffsetX : dy - t.ieOffsetY; 5717 } 5718 style[prop] = (t[prop] = Math.round( val - dif * ((i === 0 || i === 2) ? 1 : mult) )) + "px"; 5719 } 5720 } 5721 }, 5722 5723 /* translates a super small decimal to a string WITHOUT scientific notation 5724 _safeDecimal = function(n) { 5725 var s = (n < 0 ? -n : n) + "", 5726 a = s.split("e-"); 5727 return (n < 0 ? "-0." : "0.") + new Array(parseInt(a[1], 10) || 0).join("0") + a[0].split(".").join(""); 5728 }, 5729 */ 5730 5731 _setTransformRatio = _internals.set3DTransformRatio = _internals.setTransformRatio = function(v) { 5732 var t = this.data, //refers to the element's _gsTransform object 5733 style = this.t.style, 5734 angle = t.rotation, 5735 rotationX = t.rotationX, 5736 rotationY = t.rotationY, 5737 sx = t.scaleX, 5738 sy = t.scaleY, 5739 sz = t.scaleZ, 5740 x = t.x, 5741 y = t.y, 5742 z = t.z, 5743 isSVG = t.svg, 5744 perspective = t.perspective, 5745 force3D = t.force3D, 5746 skewY = t.skewY, 5747 skewX = t.skewX, 5748 t1, a11, a12, a13, a21, a22, a23, a31, a32, a33, a41, a42, a43, 5749 zOrigin, min, cos, sin, t2, transform, comma, zero, skew, rnd; 5750 if (skewY) { //for performance reasons, we combine all skewing into the skewX and rotation values. Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of 10 degrees. 5751 skewX += skewY; 5752 angle += skewY; 5753 } 5754 5755 //check to see if we should render as 2D (and SVGs must use 2D when _useSVGTransformAttr is true) 5756 if (((((v === 1 || v === 0) && force3D === "auto" && (this.tween._totalTime === this.tween._totalDuration || !this.tween._totalTime)) || !force3D) && !z && !perspective && !rotationY && !rotationX && sz === 1) || (_useSVGTransformAttr && isSVG) || !_supports3D) { //on the final render (which could be 0 for a from tween), if there are no 3D aspects, render in 2D to free up memory and improve performance especially on mobile devices. Check the tween's totalTime/totalDuration too in order to make sure it doesn't happen between repeats if it's a repeating tween. 5757 5758 //2D 5759 if (angle || skewX || isSVG) { 5760 angle *= _DEG2RAD; 5761 skew = skewX * _DEG2RAD; 5762 rnd = 100000; 5763 a11 = Math.cos(angle) * sx; 5764 a21 = Math.sin(angle) * sx; 5765 a12 = Math.sin(angle - skew) * -sy; 5766 a22 = Math.cos(angle - skew) * sy; 5767 if (skew && t.skewType === "simple") { //by default, we compensate skewing on the other axis to make it look more natural, but you can set the skewType to "simple" to use the uncompensated skewing that CSS does 5768 t1 = Math.tan(skew - skewY * _DEG2RAD); 5769 t1 = Math.sqrt(1 + t1 * t1); 5770 a12 *= t1; 5771 a22 *= t1; 5772 if (skewY) { 5773 t1 = Math.tan(skewY * _DEG2RAD); 5774 t1 = Math.sqrt(1 + t1 * t1); 5775 a11 *= t1; 5776 a21 *= t1; 5777 } 5778 } 5779 if (isSVG) { 5780 x += t.xOrigin - (t.xOrigin * a11 + t.yOrigin * a12) + t.xOffset; 5781 y += t.yOrigin - (t.xOrigin * a21 + t.yOrigin * a22) + t.yOffset; 5782 if (_useSVGTransformAttr && (t.xPercent || t.yPercent)) { //The SVG spec doesn't support percentage-based translation in the "transform" attribute, so we merge it into the matrix to simulate it. 5783 min = this.t.getBBox(); 5784 x += t.xPercent * 0.01 * min.width; 5785 y += t.yPercent * 0.01 * min.height; 5786 } 5787 min = 0.000001; 5788 if (x < min) if (x > -min) { 5789 x = 0; 5790 } 5791 if (y < min) if (y > -min) { 5792 y = 0; 5793 } 5794 } 5795 transform = (((a11 * rnd) | 0) / rnd) + "," + (((a21 * rnd) | 0) / rnd) + "," + (((a12 * rnd) | 0) / rnd) + "," + (((a22 * rnd) | 0) / rnd) + "," + x + "," + y + ")"; 5796 if (isSVG && _useSVGTransformAttr) { 5797 this.t.setAttribute("transform", "matrix(" + transform); 5798 } else { 5799 //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 5 decimal places. 5800 style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix(" : "matrix(") + transform; 5801 } 5802 } else { 5803 style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix(" : "matrix(") + sx + ",0,0," + sy + "," + x + "," + y + ")"; 5804 } 5805 return; 5806 5807 } 5808 if (_isFirefox) { //Firefox has a bug (at least in v25) that causes it to render the transparent part of 32-bit PNG images as black when displayed inside an iframe and the 3D scale is very small and doesn't change sufficiently enough between renders (like if you use a Power4.easeInOut to scale from 0 to 1 where the beginning values only change a tiny amount to begin the tween before accelerating). In this case, we force the scale to be 0.00002 instead which is visually the same but works around the Firefox issue. 5809 min = 0.0001; 5810 if (sx < min && sx > -min) { 5811 sx = sz = 0.00002; 5812 } 5813 if (sy < min && sy > -min) { 5814 sy = sz = 0.00002; 5815 } 5816 if (perspective && !t.z && !t.rotationX && !t.rotationY) { //Firefox has a bug that causes elements to have an odd super-thin, broken/dotted black border on elements that have a perspective set but aren't utilizing 3D space (no rotationX, rotationY, or z). 5817 perspective = 0; 5818 } 5819 } 5820 if (angle || skewX) { 5821 angle *= _DEG2RAD; 5822 cos = a11 = Math.cos(angle); 5823 sin = a21 = Math.sin(angle); 5824 if (skewX) { 5825 angle -= skewX * _DEG2RAD; 5826 cos = Math.cos(angle); 5827 sin = Math.sin(angle); 5828 if (t.skewType === "simple") { //by default, we compensate skewing on the other axis to make it look more natural, but you can set the skewType to "simple" to use the uncompensated skewing that CSS does 5829 t1 = Math.tan((skewX - skewY) * _DEG2RAD); 5830 t1 = Math.sqrt(1 + t1 * t1); 5831 cos *= t1; 5832 sin *= t1; 5833 if (t.skewY) { 5834 t1 = Math.tan(skewY * _DEG2RAD); 5835 t1 = Math.sqrt(1 + t1 * t1); 5836 a11 *= t1; 5837 a21 *= t1; 5838 } 5839 } 5840 } 5841 a12 = -sin; 5842 a22 = cos; 5843 5844 } else if (!rotationY && !rotationX && sz === 1 && !perspective && !isSVG) { //if we're only translating and/or 2D scaling, this is faster... 5845 style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) translate3d(" : "translate3d(") + x + "px," + y + "px," + z +"px)" + ((sx !== 1 || sy !== 1) ? " scale(" + sx + "," + sy + ")" : ""); 5846 return; 5847 } else { 5848 a11 = a22 = 1; 5849 a12 = a21 = 0; 5850 } 5851 // KEY INDEX AFFECTS a[row][column] 5852 // a11 0 rotation, rotationY, scaleX 5853 // a21 1 rotation, rotationY, scaleX 5854 // a31 2 rotationY, scaleX 5855 // a41 3 rotationY, scaleX 5856 // a12 4 rotation, skewX, rotationX, scaleY 5857 // a22 5 rotation, skewX, rotationX, scaleY 5858 // a32 6 rotationX, scaleY 5859 // a42 7 rotationX, scaleY 5860 // a13 8 rotationY, rotationX, scaleZ 5861 // a23 9 rotationY, rotationX, scaleZ 5862 // a33 10 rotationY, rotationX, scaleZ 5863 // a43 11 rotationY, rotationX, perspective, scaleZ 5864 // a14 12 x, zOrigin, svgOrigin 5865 // a24 13 y, zOrigin, svgOrigin 5866 // a34 14 z, zOrigin 5867 // a44 15 5868 // rotation: Math.atan2(a21, a11) 5869 // rotationY: Math.atan2(a13, a33) (or Math.atan2(a13, a11)) 5870 // rotationX: Math.atan2(a32, a33) 5871 a33 = 1; 5872 a13 = a23 = a31 = a32 = a41 = a42 = 0; 5873 a43 = (perspective) ? -1 / perspective : 0; 5874 zOrigin = t.zOrigin; 5875 min = 0.000001; //threshold below which browsers use scientific notation which won't work. 5876 comma = ","; 5877 zero = "0"; 5878 angle = rotationY * _DEG2RAD; 5879 if (angle) { 5880 cos = Math.cos(angle); 5881 sin = Math.sin(angle); 5882 a31 = -sin; 5883 a41 = a43*-sin; 5884 a13 = a11*sin; 5885 a23 = a21*sin; 5886 a33 = cos; 5887 a43 *= cos; 5888 a11 *= cos; 5889 a21 *= cos; 5890 } 5891 angle = rotationX * _DEG2RAD; 5892 if (angle) { 5893 cos = Math.cos(angle); 5894 sin = Math.sin(angle); 5895 t1 = a12*cos+a13*sin; 5896 t2 = a22*cos+a23*sin; 5897 a32 = a33*sin; 5898 a42 = a43*sin; 5899 a13 = a12*-sin+a13*cos; 5900 a23 = a22*-sin+a23*cos; 5901 a33 = a33*cos; 5902 a43 = a43*cos; 5903 a12 = t1; 5904 a22 = t2; 5905 } 5906 if (sz !== 1) { 5907 a13*=sz; 5908 a23*=sz; 5909 a33*=sz; 5910 a43*=sz; 5911 } 5912 if (sy !== 1) { 5913 a12*=sy; 5914 a22*=sy; 5915 a32*=sy; 5916 a42*=sy; 5917 } 5918 if (sx !== 1) { 5919 a11*=sx; 5920 a21*=sx; 5921 a31*=sx; 5922 a41*=sx; 5923 } 5924 5925 if (zOrigin || isSVG) { 5926 if (zOrigin) { 5927 x += a13*-zOrigin; 5928 y += a23*-zOrigin; 5929 z += a33*-zOrigin+zOrigin; 5930 } 5931 if (isSVG) { //due to bugs in some browsers, we need to manage the transform-origin of SVG manually 5932 x += t.xOrigin - (t.xOrigin * a11 + t.yOrigin * a12) + t.xOffset; 5933 y += t.yOrigin - (t.xOrigin * a21 + t.yOrigin * a22) + t.yOffset; 5934 } 5935 if (x < min && x > -min) { 5936 x = zero; 5937 } 5938 if (y < min && y > -min) { 5939 y = zero; 5940 } 5941 if (z < min && z > -min) { 5942 z = 0; //don't use string because we calculate perspective later and need the number. 5943 } 5944 } 5945 5946 //optimized way of concatenating all the values into a string. If we do it all in one shot, it's slower because of the way browsers have to create temp strings and the way it affects memory. If we do it piece-by-piece with +=, it's a bit slower too. We found that doing it in these sized chunks works best overall: 5947 transform = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix3d(" : "matrix3d("); 5948 transform += ((a11 < min && a11 > -min) ? zero : a11) + comma + ((a21 < min && a21 > -min) ? zero : a21) + comma + ((a31 < min && a31 > -min) ? zero : a31); 5949 transform += comma + ((a41 < min && a41 > -min) ? zero : a41) + comma + ((a12 < min && a12 > -min) ? zero : a12) + comma + ((a22 < min && a22 > -min) ? zero : a22); 5950 if (rotationX || rotationY || sz !== 1) { //performance optimization (often there's no rotationX or rotationY, so we can skip these calculations) 5951 transform += comma + ((a32 < min && a32 > -min) ? zero : a32) + comma + ((a42 < min && a42 > -min) ? zero : a42) + comma + ((a13 < min && a13 > -min) ? zero : a13); 5952 transform += comma + ((a23 < min && a23 > -min) ? zero : a23) + comma + ((a33 < min && a33 > -min) ? zero : a33) + comma + ((a43 < min && a43 > -min) ? zero : a43) + comma; 5953 } else { 5954 transform += ",0,0,0,0,1,0,"; 5955 } 5956 transform += x + comma + y + comma + z + comma + (perspective ? (1 + (-z / perspective)) : 1) + ")"; 5957 5958 style[_transformProp] = transform; 5959 }; 5960 5961 p = Transform.prototype; 5962 p.x = p.y = p.z = p.skewX = p.skewY = p.rotation = p.rotationX = p.rotationY = p.zOrigin = p.xPercent = p.yPercent = p.xOffset = p.yOffset = 0; 5963 p.scaleX = p.scaleY = p.scaleZ = 1; 5964 5965 _registerComplexSpecialProp("transform,scale,scaleX,scaleY,scaleZ,x,y,z,rotation,rotationX,rotationY,rotationZ,skewX,skewY,shortRotation,shortRotationX,shortRotationY,shortRotationZ,transformOrigin,svgOrigin,transformPerspective,directionalRotation,parseTransform,force3D,skewType,xPercent,yPercent,smoothOrigin", {parser:function(t, e, parsingProp, cssp, pt, plugin, vars) { 5966 if (cssp._lastParsedTransform === vars) { return pt; } //only need to parse the transform once, and only if the browser supports it. 5967 cssp._lastParsedTransform = vars; 5968 var scaleFunc = (vars.scale && typeof(vars.scale) === "function") ? vars.scale : 0; //if there's a function-based "scale" value, swap in the resulting numeric value temporarily. Otherwise, if it's called for both scaleX and scaleY independently, they may not match (like if the function uses Math.random()). 5969 if (scaleFunc) { 5970 vars.scale = scaleFunc(_index, t); 5971 } 5972 var originalGSTransform = t._gsTransform, 5973 style = t.style, 5974 min = 0.000001, 5975 i = _transformProps.length, 5976 v = vars, 5977 endRotations = {}, 5978 transformOriginString = "transformOrigin", 5979 m1 = _getTransform(t, _cs, true, v.parseTransform), 5980 orig = v.transform && ((typeof(v.transform) === "function") ? v.transform(_index, _target) : v.transform), 5981 m2, copy, has3D, hasChange, dr, x, y, matrix, p; 5982 m1.skewType = v.skewType || m1.skewType || CSSPlugin.defaultSkewType; 5983 cssp._transform = m1; 5984 if ("rotationZ" in v) { 5985 v.rotation = v.rotationZ; 5986 } 5987 if (orig && typeof(orig) === "string" && _transformProp) { //for values like transform:"rotate(60deg) scale(0.5, 0.8)" 5988 copy = _tempDiv.style; //don't use the original target because it might be SVG in which case some browsers don't report computed style correctly. 5989 copy[_transformProp] = orig; 5990 copy.display = "block"; //if display is "none", the browser often refuses to report the transform properties correctly. 5991 copy.position = "absolute"; 5992 if (orig.indexOf("%") !== -1) { //%-based translations will fail unless we set the width/height to match the original target... 5993 copy.width = _getStyle(t, "width"); 5994 copy.height = _getStyle(t, "height"); 5995 } 5996 _doc.body.appendChild(_tempDiv); 5997 m2 = _getTransform(_tempDiv, null, false); 5998 if (m1.skewType === "simple") { //the default _getTransform() reports the skewX/scaleY as if skewType is "compensated", thus we need to adjust that here if skewType is "simple". 5999 m2.scaleY *= Math.cos(m2.skewX * _DEG2RAD); 6000 } 6001 if (m1.svg) { //if it's an SVG element, x/y part of the matrix will be affected by whatever we use as the origin and the offsets, so compensate here... 6002 x = m1.xOrigin; 6003 y = m1.yOrigin; 6004 m2.x -= m1.xOffset; 6005 m2.y -= m1.yOffset; 6006 if (v.transformOrigin || v.svgOrigin) { //if this tween is altering the origin, we must factor that in here. The actual work of recording the transformOrigin values and setting up the PropTween is done later (still inside this function) so we cannot leave the changes intact here - we only want to update the x/y accordingly. 6007 orig = {}; 6008 _parseSVGOrigin(t, _parsePosition(v.transformOrigin), orig, v.svgOrigin, v.smoothOrigin, true); 6009 x = orig.xOrigin; 6010 y = orig.yOrigin; 6011 m2.x -= orig.xOffset - m1.xOffset; 6012 m2.y -= orig.yOffset - m1.yOffset; 6013 } 6014 if (x || y) { 6015 matrix = _getMatrix(_tempDiv, true); 6016 m2.x -= x - (x * matrix[0] + y * matrix[2]); 6017 m2.y -= y - (x * matrix[1] + y * matrix[3]); 6018 } 6019 } 6020 _doc.body.removeChild(_tempDiv); 6021 if (!m2.perspective) { 6022 m2.perspective = m1.perspective; //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case. 6023 } 6024 if (v.xPercent != null) { 6025 m2.xPercent = _parseVal(v.xPercent, m1.xPercent); 6026 } 6027 if (v.yPercent != null) { 6028 m2.yPercent = _parseVal(v.yPercent, m1.yPercent); 6029 } 6030 } else if (typeof(v) === "object") { //for values like scaleX, scaleY, rotation, x, y, skewX, and skewY or transform:{...} (object) 6031 m2 = {scaleX:_parseVal((v.scaleX != null) ? v.scaleX : v.scale, m1.scaleX), 6032 scaleY:_parseVal((v.scaleY != null) ? v.scaleY : v.scale, m1.scaleY), 6033 scaleZ:_parseVal(v.scaleZ, m1.scaleZ), 6034 x:_parseVal(v.x, m1.x), 6035 y:_parseVal(v.y, m1.y), 6036 z:_parseVal(v.z, m1.z), 6037 xPercent:_parseVal(v.xPercent, m1.xPercent), 6038 yPercent:_parseVal(v.yPercent, m1.yPercent), 6039 perspective:_parseVal(v.transformPerspective, m1.perspective)}; 6040 dr = v.directionalRotation; 6041 if (dr != null) { 6042 if (typeof(dr) === "object") { 6043 for (copy in dr) { 6044 v[copy] = dr[copy]; 6045 } 6046 } else { 6047 v.rotation = dr; 6048 } 6049 } 6050 if (typeof(v.x) === "string" && v.x.indexOf("%") !== -1) { 6051 m2.x = 0; 6052 m2.xPercent = _parseVal(v.x, m1.xPercent); 6053 } 6054 if (typeof(v.y) === "string" && v.y.indexOf("%") !== -1) { 6055 m2.y = 0; 6056 m2.yPercent = _parseVal(v.y, m1.yPercent); 6057 } 6058 6059 m2.rotation = _parseAngle(("rotation" in v) ? v.rotation : ("shortRotation" in v) ? v.shortRotation + "_short" : m1.rotation, m1.rotation, "rotation", endRotations); 6060 if (_supports3D) { 6061 m2.rotationX = _parseAngle(("rotationX" in v) ? v.rotationX : ("shortRotationX" in v) ? v.shortRotationX + "_short" : m1.rotationX || 0, m1.rotationX, "rotationX", endRotations); 6062 m2.rotationY = _parseAngle(("rotationY" in v) ? v.rotationY : ("shortRotationY" in v) ? v.shortRotationY + "_short" : m1.rotationY || 0, m1.rotationY, "rotationY", endRotations); 6063 } 6064 m2.skewX = _parseAngle(v.skewX, m1.skewX); 6065 m2.skewY = _parseAngle(v.skewY, m1.skewY); 6066 } 6067 if (_supports3D && v.force3D != null) { 6068 m1.force3D = v.force3D; 6069 hasChange = true; 6070 } 6071 6072 has3D = (m1.force3D || m1.z || m1.rotationX || m1.rotationY || m2.z || m2.rotationX || m2.rotationY || m2.perspective); 6073 if (!has3D && v.scale != null) { 6074 m2.scaleZ = 1; //no need to tween scaleZ. 6075 } 6076 6077 while (--i > -1) { 6078 p = _transformProps[i]; 6079 orig = m2[p] - m1[p]; 6080 if (orig > min || orig < -min || v[p] != null || _forcePT[p] != null) { 6081 hasChange = true; 6082 pt = new CSSPropTween(m1, p, m1[p], orig, pt); 6083 if (p in endRotations) { 6084 pt.e = endRotations[p]; //directional rotations typically have compensated values during the tween, but we need to make sure they end at exactly what the user requested 6085 } 6086 pt.xs0 = 0; //ensures the value stays numeric in setRatio() 6087 pt.plugin = plugin; 6088 cssp._overwriteProps.push(pt.n); 6089 } 6090 } 6091 6092 orig = (typeof(v.transformOrigin) === "function") ? v.transformOrigin(_index, _target) : v.transformOrigin; 6093 if (m1.svg && (orig || v.svgOrigin)) { 6094 x = m1.xOffset; //when we change the origin, in order to prevent things from jumping we adjust the x/y so we must record those here so that we can create PropTweens for them and flip them at the same time as the origin 6095 y = m1.yOffset; 6096 _parseSVGOrigin(t, _parsePosition(orig), m2, v.svgOrigin, v.smoothOrigin); 6097 pt = _addNonTweeningNumericPT(m1, "xOrigin", (originalGSTransform ? m1 : m2).xOrigin, m2.xOrigin, pt, transformOriginString); //note: if there wasn't a transformOrigin defined yet, just start with the destination one; it's wasteful otherwise, and it causes problems with fromTo() tweens. For example, TweenLite.to("#wheel", 3, {rotation:180, transformOrigin:"50% 50%", delay:1}); TweenLite.fromTo("#wheel", 3, {scale:0.5, transformOrigin:"50% 50%"}, {scale:1, delay:2}); would cause a jump when the from values revert at the beginning of the 2nd tween. 6098 pt = _addNonTweeningNumericPT(m1, "yOrigin", (originalGSTransform ? m1 : m2).yOrigin, m2.yOrigin, pt, transformOriginString); 6099 if (x !== m1.xOffset || y !== m1.yOffset) { 6100 pt = _addNonTweeningNumericPT(m1, "xOffset", (originalGSTransform ? x : m1.xOffset), m1.xOffset, pt, transformOriginString); 6101 pt = _addNonTweeningNumericPT(m1, "yOffset", (originalGSTransform ? y : m1.yOffset), m1.yOffset, pt, transformOriginString); 6102 } 6103 orig = "0px 0px"; //certain browsers (like firefox) completely botch transform-origin, so we must remove it to prevent it from contaminating transforms. We manage it ourselves with xOrigin and yOrigin 6104 } 6105 if (orig || (_supports3D && has3D && m1.zOrigin)) { //if anything 3D is happening and there's a transformOrigin with a z component that's non-zero, we must ensure that the transformOrigin's z-component is set to 0 so that we can manually do those calculations to get around Safari bugs. Even if the user didn't specifically define a "transformOrigin" in this particular tween (maybe they did it via css directly). 6106 if (_transformProp) { 6107 hasChange = true; 6108 p = _transformOriginProp; 6109 if (!orig) { 6110 orig = (_getStyle(t, p, _cs, false, "50% 50%") + "").split(" "); 6111 orig = orig[0] + " " + orig[1] + " " + m1.zOrigin + "px"; 6112 } 6113 orig += ""; 6114 pt = new CSSPropTween(style, p, 0, 0, pt, -1, transformOriginString); 6115 pt.b = style[p]; 6116 pt.plugin = plugin; 6117 if (_supports3D) { 6118 copy = m1.zOrigin; 6119 orig = orig.split(" "); 6120 m1.zOrigin = ((orig.length > 2) ? parseFloat(orig[2]) : copy) || 0; //Safari doesn't handle the z part of transformOrigin correctly, so we'll manually handle it in the _set3DTransformRatio() method. 6121 pt.xs0 = pt.e = orig[0] + " " + (orig[1] || "50%") + " 0px"; //we must define a z value of 0px specifically otherwise iOS 5 Safari will stick with the old one (if one was defined)! 6122 pt = new CSSPropTween(m1, "zOrigin", 0, 0, pt, -1, pt.n); //we must create a CSSPropTween for the _gsTransform.zOrigin so that it gets reset properly at the beginning if the tween runs backward (as opposed to just setting m1.zOrigin here) 6123 pt.b = copy; 6124 pt.xs0 = pt.e = m1.zOrigin; 6125 } else { 6126 pt.xs0 = pt.e = orig; 6127 } 6128 6129 //for older versions of IE (6-8), we need to manually calculate things inside the setRatio() function. We record origin x and y (ox and oy) and whether or not the values are percentages (oxp and oyp). 6130 } else { 6131 _parsePosition(orig + "", m1); 6132 } 6133 } 6134 if (hasChange) { 6135 cssp._transformType = (!(m1.svg && _useSVGTransformAttr) && (has3D || this._transformType === 3)) ? 3 : 2; //quicker than calling cssp._enableTransforms(); 6136 } 6137 if (scaleFunc) { 6138 vars.scale = scaleFunc; 6139 } 6140 return pt; 6141 }, allowFunc:true, prefix:true}); 6142 6143 _registerComplexSpecialProp("boxShadow", {defaultValue:"0px 0px 0px 0px #999", prefix:true, color:true, multi:true, keyword:"inset"}); 6144 _registerComplexSpecialProp("clipPath", {defaultValue:"inset(0px)", prefix:true, multi:true, formatter:_getFormatter("inset(0px 0px 0px 0px)", false, true)}); 6145 6146 _registerComplexSpecialProp("borderRadius", {defaultValue:"0px", parser:function(t, e, p, cssp, pt, plugin) { 6147 e = this.format(e); 6148 var props = ["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"], 6149 style = t.style, 6150 ea1, i, es2, bs2, bs, es, bn, en, w, h, esfx, bsfx, rel, hn, vn, em; 6151 w = parseFloat(t.offsetWidth); 6152 h = parseFloat(t.offsetHeight); 6153 ea1 = e.split(" "); 6154 for (i = 0; i < props.length; i++) { //if we're dealing with percentages, we must convert things separately for the horizontal and vertical axis! 6155 if (this.p.indexOf("border")) { //older browsers used a prefix 6156 props[i] = _checkPropPrefix(props[i]); 6157 } 6158 bs = bs2 = _getStyle(t, props[i], _cs, false, "0px"); 6159 if (bs.indexOf(" ") !== -1) { 6160 bs2 = bs.split(" "); 6161 bs = bs2[0]; 6162 bs2 = bs2[1]; 6163 } 6164 es = es2 = ea1[i]; 6165 bn = parseFloat(bs); 6166 bsfx = bs.substr((bn + "").length); 6167 rel = (es.charAt(1) === "="); 6168 if (rel) { 6169 en = parseInt(es.charAt(0)+"1", 10); 6170 es = es.substr(2); 6171 en *= parseFloat(es); 6172 esfx = es.substr((en + "").length - (en < 0 ? 1 : 0)) || ""; 6173 } else { 6174 en = parseFloat(es); 6175 esfx = es.substr((en + "").length); 6176 } 6177 if (esfx === "") { 6178 esfx = _suffixMap[p] || bsfx; 6179 } 6180 if (esfx !== bsfx) { 6181 hn = _convertToPixels(t, "borderLeft", bn, bsfx); //horizontal number (we use a bogus "borderLeft" property just because the _convertToPixels() method searches for the keywords "Left", "Right", "Top", and "Bottom" to determine of it's a horizontal or vertical property, and we need "border" in the name so that it knows it should measure relative to the element itself, not its parent. 6182 vn = _convertToPixels(t, "borderTop", bn, bsfx); //vertical number 6183 if (esfx === "%") { 6184 bs = (hn / w * 100) + "%"; 6185 bs2 = (vn / h * 100) + "%"; 6186 } else if (esfx === "em") { 6187 em = _convertToPixels(t, "borderLeft", 1, "em"); 6188 bs = (hn / em) + "em"; 6189 bs2 = (vn / em) + "em"; 6190 } else { 6191 bs = hn + "px"; 6192 bs2 = vn + "px"; 6193 } 6194 if (rel) { 6195 es = (parseFloat(bs) + en) + esfx; 6196 es2 = (parseFloat(bs2) + en) + esfx; 6197 } 6198 } 6199 pt = _parseComplex(style, props[i], bs + " " + bs2, es + " " + es2, false, "0px", pt); 6200 } 6201 return pt; 6202 }, prefix:true, formatter:_getFormatter("0px 0px 0px 0px", false, true)}); 6203 _registerComplexSpecialProp("borderBottomLeftRadius,borderBottomRightRadius,borderTopLeftRadius,borderTopRightRadius", {defaultValue:"0px", parser:function(t, e, p, cssp, pt, plugin) { 6204 return _parseComplex(t.style, p, this.format(_getStyle(t, p, _cs, false, "0px 0px")), this.format(e), false, "0px", pt); 6205 }, prefix:true, formatter:_getFormatter("0px 0px", false, true)}); 6206 _registerComplexSpecialProp("backgroundPosition", {defaultValue:"0 0", parser:function(t, e, p, cssp, pt, plugin) { 6207 var bp = "background-position", 6208 cs = (_cs || _getComputedStyle(t, null)), 6209 bs = this.format( ((cs) ? _ieVers ? cs.getPropertyValue(bp + "-x") + " " + cs.getPropertyValue(bp + "-y") : cs.getPropertyValue(bp) : t.currentStyle.backgroundPositionX + " " + t.currentStyle.backgroundPositionY) || "0 0"), //Internet Explorer doesn't report background-position correctly - we must query background-position-x and background-position-y and combine them (even in IE10). Before IE9, we must do the same with the currentStyle object and use camelCase 6210 es = this.format(e), 6211 ba, ea, i, pct, overlap, src; 6212 if ((bs.indexOf("%") !== -1) !== (es.indexOf("%") !== -1) && es.split(",").length < 2) { 6213 src = _getStyle(t, "backgroundImage").replace(_urlExp, ""); 6214 if (src && src !== "none") { 6215 ba = bs.split(" "); 6216 ea = es.split(" "); 6217 _tempImg.setAttribute("src", src); //set the temp IMG's src to the background-image so that we can measure its width/height 6218 i = 2; 6219 while (--i > -1) { 6220 bs = ba[i]; 6221 pct = (bs.indexOf("%") !== -1); 6222 if (pct !== (ea[i].indexOf("%") !== -1)) { 6223 overlap = (i === 0) ? t.offsetWidth - _tempImg.width : t.offsetHeight - _tempImg.height; 6224 ba[i] = pct ? (parseFloat(bs) / 100 * overlap) + "px" : (parseFloat(bs) / overlap * 100) + "%"; 6225 } 6226 } 6227 bs = ba.join(" "); 6228 } 6229 } 6230 return this.parseComplex(t.style, bs, es, pt, plugin); 6231 }, formatter:_parsePosition}); 6232 _registerComplexSpecialProp("backgroundSize", {defaultValue:"0 0", formatter:function(v) { 6233 v += ""; //ensure it's a string 6234 return (v.substr(0,2) === "co") ? v : _parsePosition(v.indexOf(" ") === -1 ? v + " " + v : v); //if set to something like "100% 100%", Safari typically reports the computed style as just "100%" (no 2nd value), but we should ensure that there are two values, so copy the first one. Otherwise, it'd be interpreted as "100% 0" (wrong). Also remember that it could be "cover" or "contain" which we can't tween but should be able to set. 6235 }}); 6236 _registerComplexSpecialProp("perspective", {defaultValue:"0px", prefix:true}); 6237 _registerComplexSpecialProp("perspectiveOrigin", {defaultValue:"50% 50%", prefix:true}); 6238 _registerComplexSpecialProp("transformStyle", {prefix:true}); 6239 _registerComplexSpecialProp("backfaceVisibility", {prefix:true}); 6240 _registerComplexSpecialProp("userSelect", {prefix:true}); 6241 _registerComplexSpecialProp("margin", {parser:_getEdgeParser("marginTop,marginRight,marginBottom,marginLeft")}); 6242 _registerComplexSpecialProp("padding", {parser:_getEdgeParser("paddingTop,paddingRight,paddingBottom,paddingLeft")}); 6243 _registerComplexSpecialProp("clip", {defaultValue:"rect(0px,0px,0px,0px)", parser:function(t, e, p, cssp, pt, plugin){ 6244 var b, cs, delim; 6245 if (_ieVers < 9) { //IE8 and earlier don't report a "clip" value in the currentStyle - instead, the values are split apart into clipTop, clipRight, clipBottom, and clipLeft. Also, in IE7 and earlier, the values inside rect() are space-delimited, not comma-delimited. 6246 cs = t.currentStyle; 6247 delim = _ieVers < 8 ? " " : ","; 6248 b = "rect(" + cs.clipTop + delim + cs.clipRight + delim + cs.clipBottom + delim + cs.clipLeft + ")"; 6249 e = this.format(e).split(",").join(delim); 6250 } else { 6251 b = this.format(_getStyle(t, this.p, _cs, false, this.dflt)); 6252 e = this.format(e); 6253 } 6254 return this.parseComplex(t.style, b, e, pt, plugin); 6255 }}); 6256 _registerComplexSpecialProp("textShadow", {defaultValue:"0px 0px 0px #999", color:true, multi:true}); 6257 _registerComplexSpecialProp("autoRound,strictUnits", {parser:function(t, e, p, cssp, pt) {return pt;}}); //just so that we can ignore these properties (not tween them) 6258 _registerComplexSpecialProp("border", {defaultValue:"0px solid #000", parser:function(t, e, p, cssp, pt, plugin) { 6259 var bw = _getStyle(t, "borderTopWidth", _cs, false, "0px"), 6260 end = this.format(e).split(" "), 6261 esfx = end[0].replace(_suffixExp, ""); 6262 if (esfx !== "px") { //if we're animating to a non-px value, we need to convert the beginning width to that unit. 6263 bw = (parseFloat(bw) / _convertToPixels(t, "borderTopWidth", 1, esfx)) + esfx; 6264 } 6265 return this.parseComplex(t.style, this.format(bw + " " + _getStyle(t, "borderTopStyle", _cs, false, "solid") + " " + _getStyle(t, "borderTopColor", _cs, false, "#000")), end.join(" "), pt, plugin); 6266 }, color:true, formatter:function(v) { 6267 var a = v.split(" "); 6268 return a[0] + " " + (a[1] || "solid") + " " + (v.match(_colorExp) || ["#000"])[0]; 6269 }}); 6270 _registerComplexSpecialProp("borderWidth", {parser:_getEdgeParser("borderTopWidth,borderRightWidth,borderBottomWidth,borderLeftWidth")}); //Firefox doesn't pick up on borderWidth set in style sheets (only inline). 6271 _registerComplexSpecialProp("float,cssFloat,styleFloat", {parser:function(t, e, p, cssp, pt, plugin) { 6272 var s = t.style, 6273 prop = ("cssFloat" in s) ? "cssFloat" : "styleFloat"; 6274 return new CSSPropTween(s, prop, 0, 0, pt, -1, p, false, 0, s[prop], e); 6275 }}); 6276 6277 //opacity-related 6278 var _setIEOpacityRatio = function(v) { 6279 var t = this.t, //refers to the element's style property 6280 filters = t.filter || _getStyle(this.data, "filter") || "", 6281 val = (this.s + this.c * v) | 0, 6282 skip; 6283 if (val === 100) { //for older versions of IE that need to use a filter to apply opacity, we should remove the filter if opacity hits 1 in order to improve performance, but make sure there isn't a transform (matrix) or gradient in the filters. 6284 if (filters.indexOf("atrix(") === -1 && filters.indexOf("radient(") === -1 && filters.indexOf("oader(") === -1) { 6285 t.removeAttribute("filter"); 6286 skip = (!_getStyle(this.data, "filter")); //if a class is applied that has an alpha filter, it will take effect (we don't want that), so re-apply our alpha filter in that case. We must first remove it and then check. 6287 } else { 6288 t.filter = filters.replace(_alphaFilterExp, ""); 6289 skip = true; 6290 } 6291 } 6292 if (!skip) { 6293 if (this.xn1) { 6294 t.filter = filters = filters || ("alpha(opacity=" + val + ")"); //works around bug in IE7/8 that prevents changes to "visibility" from being applied properly if the filter is changed to a different alpha on the same frame. 6295 } 6296 if (filters.indexOf("pacity") === -1) { //only used if browser doesn't support the standard opacity style property (IE 7 and 8). We omit the "O" to avoid case-sensitivity issues 6297 if (val !== 0 || !this.xn1) { //bugs in IE7/8 won't render the filter properly if opacity is ADDED on the same frame/render as "visibility" changes (this.xn1 is 1 if this tween is an "autoAlpha" tween) 6298 t.filter = filters + " alpha(opacity=" + val + ")"; //we round the value because otherwise, bugs in IE7/8 can prevent "visibility" changes from being applied properly. 6299 } 6300 } else { 6301 t.filter = filters.replace(_opacityExp, "opacity=" + val); 6302 } 6303 } 6304 }; 6305 _registerComplexSpecialProp("opacity,alpha,autoAlpha", {defaultValue:"1", parser:function(t, e, p, cssp, pt, plugin) { 6306 var b = parseFloat(_getStyle(t, "opacity", _cs, false, "1")), 6307 style = t.style, 6308 isAutoAlpha = (p === "autoAlpha"); 6309 if (typeof(e) === "string" && e.charAt(1) === "=") { 6310 e = ((e.charAt(0) === "-") ? -1 : 1) * parseFloat(e.substr(2)) + b; 6311 } 6312 if (isAutoAlpha && b === 1 && _getStyle(t, "visibility", _cs) === "hidden" && e !== 0) { //if visibility is initially set to "hidden", we should interpret that as intent to make opacity 0 (a convenience) 6313 b = 0; 6314 } 6315 if (_supportsOpacity) { 6316 pt = new CSSPropTween(style, "opacity", b, e - b, pt); 6317 } else { 6318 pt = new CSSPropTween(style, "opacity", b * 100, (e - b) * 100, pt); 6319 pt.xn1 = isAutoAlpha ? 1 : 0; //we need to record whether or not this is an autoAlpha so that in the setRatio(), we know to duplicate the setting of the alpha in order to work around a bug in IE7 and IE8 that prevents changes to "visibility" from taking effect if the filter is changed to a different alpha(opacity) at the same time. Setting it to the SAME value first, then the new value works around the IE7/8 bug. 6320 style.zoom = 1; //helps correct an IE issue. 6321 pt.type = 2; 6322 pt.b = "alpha(opacity=" + pt.s + ")"; 6323 pt.e = "alpha(opacity=" + (pt.s + pt.c) + ")"; 6324 pt.data = t; 6325 pt.plugin = plugin; 6326 pt.setRatio = _setIEOpacityRatio; 6327 } 6328 if (isAutoAlpha) { //we have to create the "visibility" PropTween after the opacity one in the linked list so that they run in the order that works properly in IE8 and earlier 6329 pt = new CSSPropTween(style, "visibility", 0, 0, pt, -1, null, false, 0, ((b !== 0) ? "inherit" : "hidden"), ((e === 0) ? "hidden" : "inherit")); 6330 pt.xs0 = "inherit"; 6331 cssp._overwriteProps.push(pt.n); 6332 cssp._overwriteProps.push(p); 6333 } 6334 return pt; 6335 }}); 6336 6337 6338 var _removeProp = function(s, p) { 6339 if (p) { 6340 if (s.removeProperty) { 6341 if (p.substr(0,2) === "ms" || p.substr(0,6) === "webkit") { //Microsoft and some Webkit browsers don't conform to the standard of capitalizing the first prefix character, so we adjust so that when we prefix the caps with a dash, it's correct (otherwise it'd be "ms-transform" instead of "-ms-transform" for IE9, for example) 6342 p = "-" + p; 6343 } 6344 s.removeProperty(p.replace(_capsExp, "-$1").toLowerCase()); 6345 } else { //note: old versions of IE use "removeAttribute()" instead of "removeProperty()" 6346 s.removeAttribute(p); 6347 } 6348 } 6349 }, 6350 _setClassNameRatio = function(v) { 6351 this.t._gsClassPT = this; 6352 if (v === 1 || v === 0) { 6353 this.t.setAttribute("class", (v === 0) ? this.b : this.e); 6354 var mpt = this.data, //first MiniPropTween 6355 s = this.t.style; 6356 while (mpt) { 6357 if (!mpt.v) { 6358 _removeProp(s, mpt.p); 6359 } else { 6360 s[mpt.p] = mpt.v; 6361 } 6362 mpt = mpt._next; 6363 } 6364 if (v === 1 && this.t._gsClassPT === this) { 6365 this.t._gsClassPT = null; 6366 } 6367 } else if (this.t.getAttribute("class") !== this.e) { 6368 this.t.setAttribute("class", this.e); 6369 } 6370 }; 6371 _registerComplexSpecialProp("className", {parser:function(t, e, p, cssp, pt, plugin, vars) { 6372 var b = t.getAttribute("class") || "", //don't use t.className because it doesn't work consistently on SVG elements; getAttribute("class") and setAttribute("class", value") is more reliable. 6373 cssText = t.style.cssText, 6374 difData, bs, cnpt, cnptLookup, mpt; 6375 pt = cssp._classNamePT = new CSSPropTween(t, p, 0, 0, pt, 2); 6376 pt.setRatio = _setClassNameRatio; 6377 pt.pr = -11; 6378 _hasPriority = true; 6379 pt.b = b; 6380 bs = _getAllStyles(t, _cs); 6381 //if there's a className tween already operating on the target, force it to its end so that the necessary inline styles are removed and the class name is applied before we determine the end state (we don't want inline styles interfering that were there just for class-specific values) 6382 cnpt = t._gsClassPT; 6383 if (cnpt) { 6384 cnptLookup = {}; 6385 mpt = cnpt.data; //first MiniPropTween which stores the inline styles - we need to force these so that the inline styles don't contaminate things. Otherwise, there's a small chance that a tween could start and the inline values match the destination values and they never get cleaned. 6386 while (mpt) { 6387 cnptLookup[mpt.p] = 1; 6388 mpt = mpt._next; 6389 } 6390 cnpt.setRatio(1); 6391 } 6392 t._gsClassPT = pt; 6393 pt.e = (e.charAt(1) !== "=") ? e : b.replace(new RegExp("(?:\\s|^)" + e.substr(2) + "(?![\\w-])"), "") + ((e.charAt(0) === "+") ? " " + e.substr(2) : ""); 6394 t.setAttribute("class", pt.e); 6395 difData = _cssDif(t, bs, _getAllStyles(t), vars, cnptLookup); 6396 t.setAttribute("class", b); 6397 pt.data = difData.firstMPT; 6398 t.style.cssText = cssText; //we recorded cssText before we swapped classes and ran _getAllStyles() because in cases when a className tween is overwritten, we remove all the related tweening properties from that class change (otherwise class-specific stuff can't override properties we've directly set on the target's style object due to specificity). 6399 pt = pt.xfirst = cssp.parse(t, difData.difs, pt, plugin); //we record the CSSPropTween as the xfirst so that we can handle overwriting propertly (if "className" gets overwritten, we must kill all the properties associated with the className part of the tween, so we can loop through from xfirst to the pt itself) 6400 return pt; 6401 }}); 6402 6403 6404 var _setClearPropsRatio = function(v) { 6405 if (v === 1 || v === 0) if (this.data._totalTime === this.data._totalDuration && this.data.data !== "isFromStart") { //this.data refers to the tween. Only clear at the END of the tween (remember, from() tweens make the ratio go from 1 to 0, so we can't just check that and if the tween is the zero-duration one that's created internally to render the starting values in a from() tween, ignore that because otherwise, for example, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in). 6406 var s = this.t.style, 6407 transformParse = _specialProps.transform.parse, 6408 a, p, i, clearTransform, transform; 6409 if (this.e === "all") { 6410 s.cssText = ""; 6411 clearTransform = true; 6412 } else { 6413 a = this.e.split(" ").join("").split(","); 6414 i = a.length; 6415 while (--i > -1) { 6416 p = a[i]; 6417 if (_specialProps[p]) { 6418 if (_specialProps[p].parse === transformParse) { 6419 clearTransform = true; 6420 } else { 6421 p = (p === "transformOrigin") ? _transformOriginProp : _specialProps[p].p; //ensures that special properties use the proper browser-specific property name, like "scaleX" might be "-webkit-transform" or "boxShadow" might be "-moz-box-shadow" 6422 } 6423 } 6424 _removeProp(s, p); 6425 } 6426 } 6427 if (clearTransform) { 6428 _removeProp(s, _transformProp); 6429 transform = this.t._gsTransform; 6430 if (transform) { 6431 if (transform.svg) { 6432 this.t.removeAttribute("data-svg-origin"); 6433 this.t.removeAttribute("transform"); 6434 } 6435 delete this.t._gsTransform; 6436 } 6437 } 6438 6439 } 6440 }; 6441 _registerComplexSpecialProp("clearProps", {parser:function(t, e, p, cssp, pt) { 6442 pt = new CSSPropTween(t, p, 0, 0, pt, 2); 6443 pt.setRatio = _setClearPropsRatio; 6444 pt.e = e; 6445 pt.pr = -10; 6446 pt.data = cssp._tween; 6447 _hasPriority = true; 6448 return pt; 6449 }}); 6450 6451 p = "bezier,throwProps,physicsProps,physics2D".split(","); 6452 i = p.length; 6453 while (i--) { 6454 _registerPluginProp(p[i]); 6455 } 6456 6457 6458 6459 6460 6461 6462 6463 6464 p = CSSPlugin.prototype; 6465 p._firstPT = p._lastParsedTransform = p._transform = null; 6466 6467 //gets called when the tween renders for the first time. This kicks everything off, recording start/end values, etc. 6468 p._onInitTween = function(target, vars, tween, index) { 6469 if (!target.nodeType) { //css is only for dom elements 6470 return false; 6471 } 6472 this._target = _target = target; 6473 this._tween = tween; 6474 this._vars = vars; 6475 _index = index; 6476 _autoRound = vars.autoRound; 6477 _hasPriority = false; 6478 _suffixMap = vars.suffixMap || CSSPlugin.suffixMap; 6479 _cs = _getComputedStyle(target, ""); 6480 _overwriteProps = this._overwriteProps; 6481 var style = target.style, 6482 v, pt, pt2, first, last, next, zIndex, tpt, threeD; 6483 if (_reqSafariFix) if (style.zIndex === "") { 6484 v = _getStyle(target, "zIndex", _cs); 6485 if (v === "auto" || v === "") { 6486 //corrects a bug in [non-Android] Safari that prevents it from repainting elements in their new positions if they don't have a zIndex set. We also can't just apply this inside _parseTransform() because anything that's moved in any way (like using "left" or "top" instead of transforms like "x" and "y") can be affected, so it is best to ensure that anything that's tweening has a z-index. Setting "WebkitPerspective" to a non-zero value worked too except that on iOS Safari things would flicker randomly. Plus zIndex is less memory-intensive. 6487 this._addLazySet(style, "zIndex", 0); 6488 } 6489 } 6490 6491 if (typeof(vars) === "string") { 6492 first = style.cssText; 6493 v = _getAllStyles(target, _cs); 6494 style.cssText = first + ";" + vars; 6495 v = _cssDif(target, v, _getAllStyles(target)).difs; 6496 if (!_supportsOpacity && _opacityValExp.test(vars)) { 6497 v.opacity = parseFloat( RegExp.$1 ); 6498 } 6499 vars = v; 6500 style.cssText = first; 6501 } 6502 6503 if (vars.className) { //className tweens will combine any differences they find in the css with the vars that are passed in, so {className:"myClass", scale:0.5, left:20} would work. 6504 this._firstPT = pt = _specialProps.className.parse(target, vars.className, "className", this, null, null, vars); 6505 } else { 6506 this._firstPT = pt = this.parse(target, vars, null); 6507 } 6508 6509 if (this._transformType) { 6510 threeD = (this._transformType === 3); 6511 if (!_transformProp) { 6512 style.zoom = 1; //helps correct an IE issue. 6513 } else if (_isSafari) { 6514 _reqSafariFix = true; 6515 //if zIndex isn't set, iOS Safari doesn't repaint things correctly sometimes (seemingly at random). 6516 if (style.zIndex === "") { 6517 zIndex = _getStyle(target, "zIndex", _cs); 6518 if (zIndex === "auto" || zIndex === "") { 6519 this._addLazySet(style, "zIndex", 0); 6520 } 6521 } 6522 //Setting WebkitBackfaceVisibility corrects 3 bugs: 6523 // 1) [non-Android] Safari skips rendering changes to "top" and "left" that are made on the same frame/render as a transform update. 6524 // 2) iOS Safari sometimes neglects to repaint elements in their new positions. Setting "WebkitPerspective" to a non-zero value worked too except that on iOS Safari things would flicker randomly. 6525 // 3) Safari sometimes displayed odd artifacts when tweening the transform (or WebkitTransform) property, like ghosts of the edges of the element remained. Definitely a browser bug. 6526 //Note: we allow the user to override the auto-setting by defining WebkitBackfaceVisibility in the vars of the tween. 6527 if (_isSafariLT6) { 6528 this._addLazySet(style, "WebkitBackfaceVisibility", this._vars.WebkitBackfaceVisibility || (threeD ? "visible" : "hidden")); 6529 } 6530 } 6531 pt2 = pt; 6532 while (pt2 && pt2._next) { 6533 pt2 = pt2._next; 6534 } 6535 tpt = new CSSPropTween(target, "transform", 0, 0, null, 2); 6536 this._linkCSSP(tpt, null, pt2); 6537 tpt.setRatio = _transformProp ? _setTransformRatio : _setIETransformRatio; 6538 tpt.data = this._transform || _getTransform(target, _cs, true); 6539 tpt.tween = tween; 6540 tpt.pr = -1; //ensures that the transforms get applied after the components are updated. 6541 _overwriteProps.pop(); //we don't want to force the overwrite of all "transform" tweens of the target - we only care about individual transform properties like scaleX, rotation, etc. The CSSPropTween constructor automatically adds the property to _overwriteProps which is why we need to pop() here. 6542 } 6543 6544 if (_hasPriority) { 6545 //reorders the linked list in order of pr (priority) 6546 while (pt) { 6547 next = pt._next; 6548 pt2 = first; 6549 while (pt2 && pt2.pr > pt.pr) { 6550 pt2 = pt2._next; 6551 } 6552 if ((pt._prev = pt2 ? pt2._prev : last)) { 6553 pt._prev._next = pt; 6554 } else { 6555 first = pt; 6556 } 6557 if ((pt._next = pt2)) { 6558 pt2._prev = pt; 6559 } else { 6560 last = pt; 6561 } 6562 pt = next; 6563 } 6564 this._firstPT = first; 6565 } 6566 return true; 6567 }; 6568 6569 6570 p.parse = function(target, vars, pt, plugin) { 6571 var style = target.style, 6572 p, sp, bn, en, bs, es, bsfx, esfx, isStr, rel; 6573 for (p in vars) { 6574 es = vars[p]; //ending value string 6575 sp = _specialProps[p]; //SpecialProp lookup. 6576 if (typeof(es) === "function" && !(sp && sp.allowFunc)) { 6577 es = es(_index, _target); 6578 } 6579 if (sp) { 6580 pt = sp.parse(target, es, p, this, pt, plugin, vars); 6581 } else if (p.substr(0,2) === "--") { //for tweening CSS variables (which always start with "--"). To maximize performance and simplicity, we bypass CSSPlugin altogether and just add a normal property tween to the tween instance itself. 6582 this._tween._propLookup[p] = this._addTween.call(this._tween, target.style, "setProperty", _getComputedStyle(target).getPropertyValue(p) + "", es + "", p, false, p); 6583 continue; 6584 } else { 6585 bs = _getStyle(target, p, _cs) + ""; 6586 isStr = (typeof(es) === "string"); 6587 if (p === "color" || p === "fill" || p === "stroke" || p.indexOf("Color") !== -1 || (isStr && _rgbhslExp.test(es))) { //Opera uses background: to define color sometimes in addition to backgroundColor: 6588 if (!isStr) { 6589 es = _parseColor(es); 6590 es = ((es.length > 3) ? "rgba(" : "rgb(") + es.join(",") + ")"; 6591 } 6592 pt = _parseComplex(style, p, bs, es, true, "transparent", pt, 0, plugin); 6593 6594 } else if (isStr && _complexExp.test(es)) { 6595 pt = _parseComplex(style, p, bs, es, true, null, pt, 0, plugin); 6596 6597 } else { 6598 bn = parseFloat(bs); 6599 bsfx = (bn || bn === 0) ? bs.substr((bn + "").length) : ""; //remember, bs could be non-numeric like "normal" for fontWeight, so we should default to a blank suffix in that case. 6600 6601 if (bs === "" || bs === "auto") { 6602 if (p === "width" || p === "height") { 6603 bn = _getDimension(target, p, _cs); 6604 bsfx = "px"; 6605 } else if (p === "left" || p === "top") { 6606 bn = _calculateOffset(target, p, _cs); 6607 bsfx = "px"; 6608 } else { 6609 bn = (p !== "opacity") ? 0 : 1; 6610 bsfx = ""; 6611 } 6612 } 6613 6614 rel = (isStr && es.charAt(1) === "="); 6615 if (rel) { 6616 en = parseInt(es.charAt(0) + "1", 10); 6617 es = es.substr(2); 6618 en *= parseFloat(es); 6619 esfx = es.replace(_suffixExp, ""); 6620 } else { 6621 en = parseFloat(es); 6622 esfx = isStr ? es.replace(_suffixExp, "") : ""; 6623 } 6624 6625 if (esfx === "") { 6626 esfx = (p in _suffixMap) ? _suffixMap[p] : bsfx; //populate the end suffix, prioritizing the map, then if none is found, use the beginning suffix. 6627 } 6628 6629 es = (en || en === 0) ? (rel ? en + bn : en) + esfx : vars[p]; //ensures that any += or -= prefixes are taken care of. Record the end value before normalizing the suffix because we always want to end the tween on exactly what they intended even if it doesn't match the beginning value's suffix. 6630 //if the beginning/ending suffixes don't match, normalize them... 6631 if (bsfx !== esfx) if (esfx !== "" || p === "lineHeight") if (en || en === 0) if (bn) { //note: if the beginning value (bn) is 0, we don't need to convert units! 6632 bn = _convertToPixels(target, p, bn, bsfx); 6633 if (esfx === "%") { 6634 bn /= _convertToPixels(target, p, 100, "%") / 100; 6635 if (vars.strictUnits !== true) { //some browsers report only "px" values instead of allowing "%" with getComputedStyle(), so we assume that if we're tweening to a %, we should start there too unless strictUnits:true is defined. This approach is particularly useful for responsive designs that use from() tweens. 6636 bs = bn + "%"; 6637 } 6638 6639 } else if (esfx === "em" || esfx === "rem" || esfx === "vw" || esfx === "vh") { 6640 bn /= _convertToPixels(target, p, 1, esfx); 6641 6642 //otherwise convert to pixels. 6643 } else if (esfx !== "px") { 6644 en = _convertToPixels(target, p, en, esfx); 6645 esfx = "px"; //we don't use bsfx after this, so we don't need to set it to px too. 6646 } 6647 if (rel) if (en || en === 0) { 6648 es = (en + bn) + esfx; //the changes we made affect relative calculations, so adjust the end value here. 6649 } 6650 } 6651 6652 if (rel) { 6653 en += bn; 6654 } 6655 6656 if ((bn || bn === 0) && (en || en === 0)) { //faster than isNaN(). Also, previously we required en !== bn but that doesn't really gain much performance and it prevents _parseToProxy() from working properly if beginning and ending values match but need to get tweened by an external plugin anyway. For example, a bezier tween where the target starts at left:0 and has these points: [{left:50},{left:0}] wouldn't work properly because when parsing the last point, it'd match the first (current) one and a non-tweening CSSPropTween would be recorded when we actually need a normal tween (type:0) so that things get updated during the tween properly. 6657 pt = new CSSPropTween(style, p, bn, en - bn, pt, 0, p, (_autoRound !== false && (esfx === "px" || p === "zIndex")), 0, bs, es); 6658 pt.xs0 = esfx; 6659 //DEBUG: _log("tween "+p+" from "+pt.b+" ("+bn+esfx+") to "+pt.e+" with suffix: "+pt.xs0); 6660 } else if (style[p] === undefined || !es && (es + "" === "NaN" || es == null)) { 6661 _log("invalid " + p + " tween value: " + vars[p]); 6662 } else { 6663 pt = new CSSPropTween(style, p, en || bn || 0, 0, pt, -1, p, false, 0, bs, es); 6664 pt.xs0 = (es === "none" && (p === "display" || p.indexOf("Style") !== -1)) ? bs : es; //intermediate value should typically be set immediately (end value) except for "display" or things like borderTopStyle, borderBottomStyle, etc. which should use the beginning value during the tween. 6665 //DEBUG: _log("non-tweening value "+p+": "+pt.xs0); 6666 } 6667 } 6668 } 6669 if (plugin) if (pt && !pt.plugin) { 6670 pt.plugin = plugin; 6671 } 6672 } 6673 return pt; 6674 }; 6675 6676 6677 //gets called every time the tween updates, passing the new ratio (typically a value between 0 and 1, but not always (for example, if an Elastic.easeOut is used, the value can jump above 1 mid-tween). It will always start and 0 and end at 1. 6678 p.setRatio = function(v) { 6679 var pt = this._firstPT, 6680 min = 0.000001, 6681 val, str, i; 6682 //at the end of the tween, we set the values to exactly what we received in order to make sure non-tweening values (like "position" or "float" or whatever) are set and so that if the beginning/ending suffixes (units) didn't match and we normalized to px, the value that the user passed in is used here. We check to see if the tween is at its beginning in case it's a from() tween in which case the ratio will actually go from 1 to 0 over the course of the tween (backwards). 6683 if (v === 1 && (this._tween._time === this._tween._duration || this._tween._time === 0)) { 6684 while (pt) { 6685 if (pt.type !== 2) { 6686 if (pt.r && pt.type !== -1) { 6687 val = pt.r(pt.s + pt.c); 6688 if (!pt.type) { 6689 pt.t[pt.p] = val + pt.xs0; 6690 } else if (pt.type === 1) { //complex value (one that typically has multiple numbers inside a string, like "rect(5px,10px,20px,25px)" 6691 i = pt.l; 6692 str = pt.xs0 + val + pt.xs1; 6693 for (i = 1; i < pt.l; i++) { 6694 str += pt["xn"+i] + pt["xs"+(i+1)]; 6695 } 6696 pt.t[pt.p] = str; 6697 } 6698 } else { 6699 pt.t[pt.p] = pt.e; 6700 } 6701 } else { 6702 pt.setRatio(v); 6703 } 6704 pt = pt._next; 6705 } 6706 6707 } else if (v || !(this._tween._time === this._tween._duration || this._tween._time === 0) || this._tween._rawPrevTime === -0.000001) { 6708 while (pt) { 6709 val = pt.c * v + pt.s; 6710 if (pt.r) { 6711 val = pt.r(val); 6712 } else if (val < min) if (val > -min) { 6713 val = 0; 6714 } 6715 if (!pt.type) { 6716 pt.t[pt.p] = val + pt.xs0; 6717 } else if (pt.type === 1) { //complex value (one that typically has multiple numbers inside a string, like "rect(5px,10px,20px,25px)" 6718 i = pt.l; 6719 if (i === 2) { 6720 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2; 6721 } else if (i === 3) { 6722 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3; 6723 } else if (i === 4) { 6724 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3 + pt.xn3 + pt.xs4; 6725 } else if (i === 5) { 6726 pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3 + pt.xn3 + pt.xs4 + pt.xn4 + pt.xs5; 6727 } else { 6728 str = pt.xs0 + val + pt.xs1; 6729 for (i = 1; i < pt.l; i++) { 6730 str += pt["xn"+i] + pt["xs"+(i+1)]; 6731 } 6732 pt.t[pt.p] = str; 6733 } 6734 6735 } else if (pt.type === -1) { //non-tweening value 6736 pt.t[pt.p] = pt.xs0; 6737 6738 } else if (pt.setRatio) { //custom setRatio() for things like SpecialProps, external plugins, etc. 6739 pt.setRatio(v); 6740 } 6741 pt = pt._next; 6742 } 6743 6744 //if the tween is reversed all the way back to the beginning, we need to restore the original values which may have different units (like % instead of px or em or whatever). 6745 } else { 6746 while (pt) { 6747 if (pt.type !== 2) { 6748 pt.t[pt.p] = pt.b; 6749 } else { 6750 pt.setRatio(v); 6751 } 6752 pt = pt._next; 6753 } 6754 } 6755 }; 6756 6757 /** 6758 * @private 6759 * Forces rendering of the target's transforms (rotation, scale, etc.) whenever the CSSPlugin's setRatio() is called. 6760 * Basically, this tells the CSSPlugin to create a CSSPropTween (type 2) after instantiation that runs last in the linked 6761 * list and calls the appropriate (3D or 2D) rendering function. We separate this into its own method so that we can call 6762 * it from other plugins like BezierPlugin if, for example, it needs to apply an autoRotation and this CSSPlugin 6763 * doesn't have any transform-related properties of its own. You can call this method as many times as you 6764 * want and it won't create duplicate CSSPropTweens. 6765 * 6766 * @param {boolean} threeD if true, it should apply 3D tweens (otherwise, just 2D ones are fine and typically faster) 6767 */ 6768 p._enableTransforms = function(threeD) { 6769 this._transform = this._transform || _getTransform(this._target, _cs, true); //ensures that the element has a _gsTransform property with the appropriate values. 6770 this._transformType = (!(this._transform.svg && _useSVGTransformAttr) && (threeD || this._transformType === 3)) ? 3 : 2; 6771 }; 6772 6773 var lazySet = function(v) { 6774 this.t[this.p] = this.e; 6775 this.data._linkCSSP(this, this._next, null, true); //we purposefully keep this._next even though it'd make sense to null it, but this is a performance optimization, as this happens during the while (pt) {} loop in setRatio() at the bottom of which it sets pt = pt._next, so if we null it, the linked list will be broken in that loop. 6776 }; 6777 /** @private Gives us a way to set a value on the first render (and only the first render). **/ 6778 p._addLazySet = function(t, p, v) { 6779 var pt = this._firstPT = new CSSPropTween(t, p, 0, 0, this._firstPT, 2); 6780 pt.e = v; 6781 pt.setRatio = lazySet; 6782 pt.data = this; 6783 }; 6784 6785 /** @private **/ 6786 p._linkCSSP = function(pt, next, prev, remove) { 6787 if (pt) { 6788 if (next) { 6789 next._prev = pt; 6790 } 6791 if (pt._next) { 6792 pt._next._prev = pt._prev; 6793 } 6794 if (pt._prev) { 6795 pt._prev._next = pt._next; 6796 } else if (this._firstPT === pt) { 6797 this._firstPT = pt._next; 6798 remove = true; //just to prevent resetting this._firstPT 5 lines down in case pt._next is null. (optimized for speed) 6799 } 6800 if (prev) { 6801 prev._next = pt; 6802 } else if (!remove && this._firstPT === null) { 6803 this._firstPT = pt; 6804 } 6805 pt._next = next; 6806 pt._prev = prev; 6807 } 6808 return pt; 6809 }; 6810 6811 p._mod = function(lookup) { 6812 var pt = this._firstPT; 6813 while (pt) { 6814 if (typeof(lookup[pt.p]) === "function") { //only gets called by RoundPropsPlugin (ModifyPlugin manages all the rendering internally for CSSPlugin properties that need modification). Remember, we handle rounding a bit differently in this plugin for performance reasons, leveraging "r" as an indicator that the value should be rounded internally. 6815 pt.r = lookup[pt.p]; 6816 } 6817 pt = pt._next; 6818 } 6819 }; 6820 6821 //we need to make sure that if alpha or autoAlpha is killed, opacity is too. And autoAlpha affects the "visibility" property. 6822 p._kill = function(lookup) { 6823 var copy = lookup, 6824 pt, p, xfirst; 6825 if (lookup.autoAlpha || lookup.alpha) { 6826 copy = {}; 6827 for (p in lookup) { //copy the lookup so that we're not changing the original which may be passed elsewhere. 6828 copy[p] = lookup[p]; 6829 } 6830 copy.opacity = 1; 6831 if (copy.autoAlpha) { 6832 copy.visibility = 1; 6833 } 6834 } 6835 if (lookup.className && (pt = this._classNamePT)) { //for className tweens, we need to kill any associated CSSPropTweens too; a linked list starts at the className's "xfirst". 6836 xfirst = pt.xfirst; 6837 if (xfirst && xfirst._prev) { 6838 this._linkCSSP(xfirst._prev, pt._next, xfirst._prev._prev); //break off the prev 6839 } else if (xfirst === this._firstPT) { 6840 this._firstPT = pt._next; 6841 } 6842 if (pt._next) { 6843 this._linkCSSP(pt._next, pt._next._next, xfirst._prev); 6844 } 6845 this._classNamePT = null; 6846 } 6847 pt = this._firstPT; 6848 while (pt) { 6849 if (pt.plugin && pt.plugin !== p && pt.plugin._kill) { //for plugins that are registered with CSSPlugin, we should notify them of the kill. 6850 pt.plugin._kill(lookup); 6851 p = pt.plugin; 6852 } 6853 pt = pt._next; 6854 } 6855 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"].prototype._kill.call(this, copy); 6856 }; 6857 6858 6859 6860 //used by cascadeTo() for gathering all the style properties of each child element into an array for comparison. 6861 var _getChildStyles = function(e, props, targets) { 6862 var children, i, child, type; 6863 if (e.slice) { 6864 i = e.length; 6865 while (--i > -1) { 6866 _getChildStyles(e[i], props, targets); 6867 } 6868 return; 6869 } 6870 children = e.childNodes; 6871 i = children.length; 6872 while (--i > -1) { 6873 child = children[i]; 6874 type = child.type; 6875 if (child.style) { 6876 props.push(_getAllStyles(child)); 6877 if (targets) { 6878 targets.push(child); 6879 } 6880 } 6881 if ((type === 1 || type === 9 || type === 11) && child.childNodes.length) { 6882 _getChildStyles(child, props, targets); 6883 } 6884 } 6885 }; 6886 6887 /** 6888 * Typically only useful for className tweens that may affect child elements, this method creates a TweenLite 6889 * and then compares the style properties of all the target's child elements at the tween's start and end, and 6890 * if any are different, it also creates tweens for those and returns an array containing ALL of the resulting 6891 * tweens (so that you can easily add() them to a TimelineLite, for example). The reason this functionality is 6892 * wrapped into a separate static method of CSSPlugin instead of being integrated into all regular className tweens 6893 * is because it creates entirely new tweens that may have completely different targets than the original tween, 6894 * so if they were all lumped into the original tween instance, it would be inconsistent with the rest of the API 6895 * and it would create other problems. For example: 6896 * - If I create a tween of elementA, that tween instance may suddenly change its target to include 50 other elements (unintuitive if I specifically defined the target I wanted) 6897 * - We can't just create new independent tweens because otherwise, what happens if the original/parent tween is reversed or pause or dropped into a TimelineLite for tight control? You'd expect that tween's behavior to affect all the others. 6898 * - Analyzing every style property of every child before and after the tween is an expensive operation when there are many children, so this behavior shouldn't be imposed on all className tweens by default, especially since it's probably rare that this extra functionality is needed. 6899 * 6900 * @param {Object} target object to be tweened 6901 * @param {number} Duration in seconds (or frames for frames-based tweens) 6902 * @param {Object} Object containing the end values, like {className:"newClass", ease:Linear.easeNone} 6903 * @return {Array} An array of TweenLite instances 6904 */ 6905 CSSPlugin.cascadeTo = function(target, duration, vars) { 6906 var tween = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].to(target, duration, vars), 6907 results = [tween], 6908 b = [], 6909 e = [], 6910 targets = [], 6911 _reservedProps = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]._internals.reservedProps, 6912 i, difs, p, from; 6913 target = tween._targets || tween.target; 6914 _getChildStyles(target, b, targets); 6915 tween.render(duration, true, true); 6916 _getChildStyles(target, e); 6917 tween.render(0, true, true); 6918 tween._enabled(true); 6919 i = targets.length; 6920 while (--i > -1) { 6921 difs = _cssDif(targets[i], b[i], e[i]); 6922 if (difs.firstMPT) { 6923 difs = difs.difs; 6924 for (p in vars) { 6925 if (_reservedProps[p]) { 6926 difs[p] = vars[p]; 6927 } 6928 } 6929 from = {}; 6930 for (p in difs) { 6931 from[p] = b[i][p]; 6932 } 6933 results.push(_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].fromTo(targets[i], duration, from, difs)); 6934 } 6935 } 6936 return results; 6937 }; 6938 6939 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"].activate([CSSPlugin]); 6940 return CSSPlugin; 6941 6942 }, true); 6943 6944var CSSPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].CSSPlugin; 6945 6946 6947/***/ }), 6948
vendor: 5,348 bytes, lines 6949-7075
6949/***/ "./node_modules/gsap/CSSRulePlugin.js": 6950/*!********************************************!*\ 6951 !*** ./node_modules/gsap/CSSRulePlugin.js ***! 6952 \********************************************/ 6953/*! exports provided: CSSRulePlugin, default */ 6954/***/ (function(module, __webpack_exports__, __webpack_require__) { 6955 6956"use strict"; 6957__webpack_require__.r(__webpack_exports__); 6958/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CSSRulePlugin", function() { return CSSRulePlugin; }); 6959/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return CSSRulePlugin; }); 6960/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 6961/* harmony import */ var _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./CSSPlugin.js */ "./node_modules/gsap/CSSPlugin.js"); 6962/*! 6963 * VERSION: 0.6.8 6964 * DATE: 2019-02-22 6965 * UPDATES AND DOCS AT: http://greensock.com 6966 * 6967 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 6968 * This work is subject to the terms at http://greensock.com/standard-license or for 6969 * Club GreenSock members, the software agreement that was issued with your membership. 6970 * 6971 * @author: Jack Doyle, [email protected] 6972 */ 6973/* eslint-disable */ 6974 6975 6976 6977 6978_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("plugins.CSSRulePlugin", ["plugins.TweenPlugin","TweenLite","plugins.CSSPlugin"], function() { 6979 6980 /** @constructor **/ 6981 var CSSRulePlugin = function() { 6982 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"].call(this, "cssRule"); 6983 this._overwriteProps.length = 0; 6984 }, 6985 _doc = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].document, 6986 _superSetRatio = _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__["default"].prototype.setRatio, 6987 p = CSSRulePlugin.prototype = new _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__["default"](); 6988 6989 p._propName = "cssRule"; 6990 p.constructor = CSSRulePlugin; 6991 CSSRulePlugin.version = "0.6.8"; 6992 CSSRulePlugin.API = 2; 6993 6994 /** 6995 * Searches the style sheets in the document for a particular selector like ".myClass" or "a" or "a:hover" or ":after" and 6996 * returns a reference to that style sheet (or an array of them in the case of a pseudo selector like ":after"). Then you 6997 * can animate the individual properties of the style sheet. 6998 * 6999 * @param {!string} selector a string describing the selector, like ".myClass" or "a" or "a:hover" or ":after" 7000 * @return a reference to the style sheet (or an array of them in the case of a pseudo selector). If none was found, null is returned (or an empty array for a pseudo selector) 7001 */ 7002 CSSRulePlugin.getRule = function(selector) { 7003 var ruleProp = _doc.all ? "rules" : "cssRules", 7004 ss = _doc.styleSheets, 7005 i = ss.length, 7006 pseudo = (selector.charAt(0) === ":"), 7007 j, curSS, cs, a; 7008 selector = (pseudo ? "" : ",") + selector.split("::").join(":").toLowerCase() + ","; //note: old versions of IE report tag name selectors as upper case, so we just change everything to lowercase. 7009 if (pseudo) { 7010 a = []; 7011 } 7012 while (--i > -1) { 7013 //Firefox may throw insecure operation errors when css is loaded from other domains, so try/catch. 7014 try { 7015 curSS = ss[i][ruleProp]; 7016 if (!curSS) { 7017 continue; 7018 } 7019 j = curSS.length; 7020 } catch (e) { 7021 console.log(e); 7022 continue; 7023 } 7024 while (--j > -1) { 7025 cs = curSS[j]; 7026 if (cs.selectorText && ("," + cs.selectorText.split("::").join(":").toLowerCase() + ",").indexOf(selector) !== -1) { //note: IE adds an extra ":" to pseudo selectors, so .myClass:after becomes .myClass::after, so we need to strip the extra one out. 7027 if (pseudo) { 7028 a.push(cs.style); 7029 } else { 7030 return cs.style; 7031 } 7032 } 7033 } 7034 } 7035 return a; 7036 }; 7037 7038 7039 // @private gets called when the tween renders for the first time. This kicks everything off, recording start/end values, etc. 7040 p._onInitTween = function(target, value, tween) { 7041 if (target.cssText === undefined) { 7042 return false; 7043 } 7044 var div = target._gsProxy = target._gsProxy || _doc.createElement("div"); 7045 this._ss = target; 7046 this._proxy = div.style; 7047 div.style.cssText = target.cssText; 7048 _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__["default"].prototype._onInitTween.call(this, div, value, tween); //we just offload all the work to the regular CSSPlugin and then copy the cssText back over to the rule in the setRatio() method. This allows us to have all of the updates to CSSPlugin automatically flow through to CSSRulePlugin instead of having to maintain both 7049 return true; 7050 }; 7051 7052 7053 7054 // @private gets called every time the tween updates, passing the new ratio (typically a value between 0 and 1, but not always (for example, if an Elastic.easeOut is used, the value can jump above 1 mid-tween). It will always start and 0 and end at 1. 7055 p.setRatio = function(v) { 7056 _superSetRatio.call(this, v); 7057 var proxy = this._proxy, 7058 ss = this._ss, 7059 i = proxy.length; 7060 while (--i > -1) { 7061 ss[proxy[i]] = proxy[proxy[i]]; 7062 } 7063 }; 7064 7065 7066 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"].activate([CSSRulePlugin]); 7067 return CSSRulePlugin; 7068 7069 }, true); 7070 7071var CSSRulePlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].CSSRulePlugin; 7072 7073 7074/***/ }), 7075
vendor: 9,597 bytes, lines 7076-7322
7076/***/ "./node_modules/gsap/ColorPropsPlugin.js": 7077/*!***********************************************!*\ 7078 !*** ./node_modules/gsap/ColorPropsPlugin.js ***! 7079 \***********************************************/ 7080/*! exports provided: ColorPropsPlugin, default */ 7081/***/ (function(module, __webpack_exports__, __webpack_require__) { 7082 7083"use strict"; 7084__webpack_require__.r(__webpack_exports__); 7085/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorPropsPlugin", function() { return ColorPropsPlugin; }); 7086/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ColorPropsPlugin; }); 7087/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 7088/*! 7089 * VERSION: 1.5.3 7090 * DATE: 2018-05-30 7091 * UPDATES AND DOCS AT: http://greensock.com 7092 * 7093 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 7094 * This work is subject to the terms at http://greensock.com/standard-license or for 7095 * Club GreenSock members, the software agreement that was issued with your membership. 7096 * 7097 * @author: Jack Doyle, [email protected] 7098 **/ 7099/* eslint-disable */ 7100 7101 7102 7103 7104 var _numExp = /(\d|\.)+/g, 7105 _relNumExp = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g, 7106 _colorLookup = {aqua:[0,255,255], 7107 lime:[0,255,0], 7108 silver:[192,192,192], 7109 black:[0,0,0], 7110 maroon:[128,0,0], 7111 teal:[0,128,128], 7112 blue:[0,0,255], 7113 navy:[0,0,128], 7114 white:[255,255,255], 7115 fuchsia:[255,0,255], 7116 olive:[128,128,0], 7117 yellow:[255,255,0], 7118 orange:[255,165,0], 7119 gray:[128,128,128], 7120 purple:[128,0,128], 7121 green:[0,128,0], 7122 red:[255,0,0], 7123 pink:[255,192,203], 7124 cyan:[0,255,255], 7125 transparent:[255,255,255,0]}, 7126 _hue = function(h, m1, m2) { 7127 h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; 7128 return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; 7129 }, 7130 /** 7131 * @private Parses a color (like #9F0, #FF9900, rgb(255,51,153) or hsl(108, 50%, 10%)) into an array with 3 elements for red, green, and blue or if toHSL parameter is true, it will populate the array with hue, saturation, and lightness values. If a relative value is found in an hsl() or hsla() string, it will preserve those relative prefixes and all the values in the array will be strings instead of numbers (in all other cases it will be populated with numbers). 7132 * @param {(string|number)} v The value the should be parsed which could be a string like #9F0 or rgb(255,102,51) or rgba(255,0,0,0.5) or it could be a number like 0xFF00CC or even a named color like red, blue, purple, etc. 7133 * @param {(boolean)} toHSL If true, an hsl() or hsla() value will be returned instead of rgb() or rgba() 7134 * @return {Array.<number>} An array containing red, green, and blue (and optionally alpha) in that order, or if the toHSL parameter was true, the array will contain hue, saturation and lightness (and optionally alpha) in that order. Always numbers unless there's a relative prefix found in an hsl() or hsla() string and toHSL is true. 7135 */ 7136 _parseColor = function(v, toHSL) { 7137 var a, r, g, b, h, s, l, max, min, d, wasHSL; 7138 if (!v) { 7139 a = _colorLookup.black; 7140 } else if (typeof(v) === "number") { 7141 a = [v >> 16, (v >> 8) & 255, v & 255]; 7142 } else { 7143 if (v.charAt(v.length - 1) === ",") { //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value. 7144 v = v.substr(0, v.length - 1); 7145 } 7146 if (_colorLookup[v]) { 7147 a = _colorLookup[v]; 7148 } else if (v.charAt(0) === "#") { 7149 if (v.length === 4) { //for shorthand like #9F0 7150 r = v.charAt(1); 7151 g = v.charAt(2); 7152 b = v.charAt(3); 7153 v = "#" + r + r + g + g + b + b; 7154 } 7155 v = parseInt(v.substr(1), 16); 7156 a = [v >> 16, (v >> 8) & 255, v & 255]; 7157 } else if (v.substr(0, 3) === "hsl") { 7158 a = wasHSL = v.match(_numExp); 7159 if (!toHSL) { 7160 h = (Number(a[0]) % 360) / 360; 7161 s = Number(a[1]) / 100; 7162 l = Number(a[2]) / 100; 7163 g = (l <= 0.5) ? l * (s + 1) : l + s - l * s; 7164 r = l * 2 - g; 7165 if (a.length > 3) { 7166 a[3] = Number(a[3]); 7167 } 7168 a[0] = _hue(h + 1 / 3, r, g); 7169 a[1] = _hue(h, r, g); 7170 a[2] = _hue(h - 1 / 3, r, g); 7171 } else if (v.indexOf("=") !== -1) { //if relative values are found, just return the raw strings with the relative prefixes in place. 7172 return v.match(_relNumExp); 7173 } 7174 } else { 7175 a = v.match(_numExp) || _colorLookup.transparent; 7176 } 7177 a[0] = Number(a[0]); 7178 a[1] = Number(a[1]); 7179 a[2] = Number(a[2]); 7180 if (a.length > 3) { 7181 a[3] = Number(a[3]); 7182 } 7183 } 7184 if (toHSL && !wasHSL) { 7185 r = a[0] / 255; 7186 g = a[1] / 255; 7187 b = a[2] / 255; 7188 max = Math.max(r, g, b); 7189 min = Math.min(r, g, b); 7190 l = (max + min) / 2; 7191 if (max === min) { 7192 h = s = 0; 7193 } else { 7194 d = max - min; 7195 s = l > 0.5 ? d / (2 - max - min) : d / (max + min); 7196 h = (max === r) ? (g - b) / d + (g < b ? 6 : 0) : (max === g) ? (b - r) / d + 2 : (r - g) / d + 4; 7197 h *= 60; 7198 } 7199 a[0] = (h + 0.5) | 0; 7200 a[1] = (s * 100 + 0.5) | 0; 7201 a[2] = (l * 100 + 0.5) | 0; 7202 } 7203 return a; 7204 }, 7205 _formatColors = function(s, toHSL) { 7206 var colors = (s + "").match(_colorExp) || [], 7207 charIndex = 0, 7208 parsed = "", 7209 i, color, temp; 7210 if (!colors.length) { 7211 return s; 7212 } 7213 for (i = 0; i < colors.length; i++) { 7214 color = colors[i]; 7215 temp = s.substr(charIndex, s.indexOf(color, charIndex)-charIndex); 7216 charIndex += temp.length + color.length; 7217 color = _parseColor(color, toHSL); 7218 if (color.length === 3) { 7219 color.push(1); 7220 } 7221 parsed += temp + (toHSL ? "hsla(" + color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : "rgba(" + color.join(",")) + ")"; 7222 } 7223 return parsed + s.substr(charIndex); 7224 }, p, _colorStringFilter, 7225 TweenLite = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].GreenSockGlobals || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]).TweenLite, 7226 _colorExp = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b", //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc. 7227 7228 ColorPropsPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 7229 propName: "colorProps", 7230 version: "1.5.3", 7231 priority: -1, 7232 API: 2, 7233 global: true, 7234 7235 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 7236 init: function(target, value, tween, index) { 7237 var p, proxy, pt, val; 7238 this._target = target; 7239 this._proxy = proxy = ((value.format + "").toUpperCase() === "NUMBER") ? {} : 0; 7240 for (p in value) { 7241 if (p !== "format") { 7242 if (proxy) { 7243 this._firstNumPT = pt = {_next:this._firstNumPT, t:target, p:p, f:(typeof(target[p]) === "function")}; 7244 proxy[p] = "rgb(" + _parseColor(!pt.f ? target[p] : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ]()).join(",") + ")"; 7245 val = value[p]; 7246 if (typeof(val) === "function") { 7247 val = val(index, target); 7248 } 7249 this._addTween(proxy, p, "get", ((typeof(val) === "number") ? "rgb(" + _parseColor(val, false).join(",") + ")" : val), p, null, null, _colorStringFilter); 7250 } else { 7251 this._addTween(target, p, "get", value[p], p, null, null, _colorStringFilter, index); 7252 } 7253 7254 } 7255 } 7256 return true; 7257 }, 7258 7259 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 7260 set: function(v) { 7261 var pt = this._firstNumPT, 7262 val; 7263 this._super.setRatio.call(this, v); 7264 while (pt) { 7265 val = _parseColor(this._proxy[pt.p], false); 7266 val = val[0] << 16 | val[1] << 8 | val[2]; 7267 if (pt.f) { 7268 this._target[pt.p](val); 7269 } else { 7270 this._target[pt.p] = val; 7271 } 7272 pt = pt._next; 7273 } 7274 } 7275 }); 7276 7277 for (p in _colorLookup) { 7278 _colorExp += "|" + p + "\\b"; 7279 } 7280 _colorExp = new RegExp(_colorExp+")", "gi"); 7281 ColorPropsPlugin.colorStringFilter = _colorStringFilter = function(a) { 7282 var combined = a[0] + " " + a[1], 7283 toHSL; 7284 _colorExp.lastIndex = 0; 7285 if (_colorExp.test(combined)) { 7286 toHSL = (combined.indexOf("hsl(") !== -1 || combined.indexOf("hsla(") !== -1); 7287 a[0] = _formatColors(a[0], toHSL); 7288 a[1] = _formatColors(a[1], toHSL); 7289 } 7290 }; 7291 7292 if (!TweenLite.defaultStringFilter) { 7293 TweenLite.defaultStringFilter = ColorPropsPlugin.colorStringFilter; 7294 } 7295 7296 ColorPropsPlugin.parseColor = _parseColor; 7297 p = ColorPropsPlugin.prototype; 7298 p._firstNumPT = null; 7299 p._kill = function(lookup) { 7300 var pt = this._firstNumPT, 7301 prev; 7302 while (pt) { 7303 if (pt.p in lookup) { 7304 if (pt === p._firstNumPT) { 7305 this._firstNumPT = pt._next; 7306 } 7307 if (prev) { 7308 prev._next = pt._next; 7309 } 7310 } else { 7311 prev = pt; 7312 } 7313 pt = pt._next; 7314 } 7315 return this._super._kill(lookup); 7316 }; 7317 7318 7319 7320 7321/***/ }), 7322
vendor: 3,666 bytes, lines 7323-7423
7323/***/ "./node_modules/gsap/DirectionalRotationPlugin.js": 7324/*!********************************************************!*\ 7325 !*** ./node_modules/gsap/DirectionalRotationPlugin.js ***! 7326 \********************************************************/ 7327/*! exports provided: DirectionalRotationPlugin, default */ 7328/***/ (function(module, __webpack_exports__, __webpack_require__) { 7329 7330"use strict"; 7331__webpack_require__.r(__webpack_exports__); 7332/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DirectionalRotationPlugin", function() { return DirectionalRotationPlugin; }); 7333/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return DirectionalRotationPlugin; }); 7334/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 7335/*! 7336 * VERSION: 0.3.1 7337 * DATE: 2018-08-27 7338 * UPDATES AND DOCS AT: http://greensock.com 7339 * 7340 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 7341 * This work is subject to the terms at http://greensock.com/standard-license or for 7342 * Club GreenSock members, the software agreement that was issued with your membership. 7343 * 7344 * @author: Jack Doyle, [email protected] 7345 **/ 7346/* eslint-disable */ 7347 7348 7349 7350var DirectionalRotationPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 7351 propName: "directionalRotation", 7352 version: "0.3.1", 7353 API: 2, 7354 7355 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 7356 init: function(target, value, tween, index) { 7357 if (typeof(value) !== "object") { 7358 value = {rotation:value}; 7359 } 7360 this.finals = {}; 7361 var cap = (value.useRadians === true) ? Math.PI * 2 : 360, 7362 min = 0.000001, 7363 p, v, start, end, dif, split; 7364 for (p in value) { 7365 if (p !== "useRadians") { 7366 end = value[p]; 7367 if (typeof(end) === "function") { 7368 end = end(index, target); 7369 } 7370 split = (end + "").split("_"); 7371 v = split[0]; 7372 start = parseFloat( (typeof(target[p]) !== "function") ? target[p] : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ]() ); 7373 end = this.finals[p] = (typeof(v) === "string" && v.charAt(1) === "=") ? start + parseInt(v.charAt(0) + "1", 10) * Number(v.substr(2)) : Number(v) || 0; 7374 dif = end - start; 7375 if (split.length) { 7376 v = split.join("_"); 7377 if (v.indexOf("short") !== -1) { 7378 dif = dif % cap; 7379 if (dif !== dif % (cap / 2)) { 7380 dif = (dif < 0) ? dif + cap : dif - cap; 7381 } 7382 } 7383 if (v.indexOf("_cw") !== -1 && dif < 0) { 7384 dif = ((dif + cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 7385 } else if (v.indexOf("ccw") !== -1 && dif > 0) { 7386 dif = ((dif - cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; 7387 } 7388 } 7389 if (dif > min || dif < -min) { 7390 this._addTween(target, p, start, start + dif, p); 7391 this._overwriteProps.push(p); 7392 } 7393 } 7394 } 7395 return true; 7396 }, 7397 7398 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 7399 set: function(ratio) { 7400 var pt; 7401 if (ratio !== 1) { 7402 this._super.setRatio.call(this, ratio); 7403 } else { 7404 pt = this._firstPT; 7405 while (pt) { 7406 if (pt.f) { 7407 pt.t[pt.p](this.finals[pt.p]); 7408 } else { 7409 pt.t[pt.p] = this.finals[pt.p]; 7410 } 7411 pt = pt._next; 7412 } 7413 } 7414 } 7415 7416 }); 7417 7418DirectionalRotationPlugin._autoCSS = true; 7419 7420 7421 7422/***/ }), 7423
vendor: 118,823 bytes, lines 7424-9941
7424/***/ "./node_modules/gsap/Draggable.js": 7425/*!****************************************!*\ 7426 !*** ./node_modules/gsap/Draggable.js ***! 7427 \****************************************/ 7428/*! exports provided: Draggable, default */ 7429/***/ (function(module, __webpack_exports__, __webpack_require__) { 7430 7431"use strict"; 7432__webpack_require__.r(__webpack_exports__); 7433/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Draggable", function() { return Draggable; }); 7434/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Draggable; }); 7435/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 7436/* harmony import */ var _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./CSSPlugin.js */ "./node_modules/gsap/CSSPlugin.js"); 7437/*! 7438 * VERSION: 0.17.1 7439 * DATE: 2019-02-28 7440 * UPDATES AND DOCS AT: http://greensock.com 7441 * 7442 * Requires TweenLite and CSSPlugin version 1.17.0 or later (TweenMax contains both TweenLite and CSSPlugin). ThrowPropsPlugin is required for momentum-based continuation of movement after the mouse/touch is released (ThrowPropsPlugin is a membership benefit of Club GreenSock - http://greensock.com/club/). 7443 * 7444 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 7445 * This work is subject to the terms at http://greensock.com/standard-license or for 7446 * Club GreenSock members, the software agreement that was issued with your membership. 7447 * 7448 * @author: Jack Doyle, [email protected] 7449 */ 7450/* eslint-disable */ 7451 7452 7453 7454 7455 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("utils.Draggable", ["events.EventDispatcher","TweenLite","plugins.CSSPlugin"], function() { 7456 7457 var _tempVarsXY = {css:{}, data:"_draggable"}, //speed optimization - we reuse the same vars object for x/y TweenLite.set() calls to minimize garbage collection tasks and improve performance. 7458 _tempVarsX = {css:{}, data:"_draggable"}, 7459 _tempVarsY = {css:{}, data:"_draggable"}, 7460 _tempVarsRotation = {css:{}}, 7461 _globals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.globals, 7462 _tempEvent = {}, //for populating with pageX/pageY in old versions of IE 7463 _emptyFunc = function() { return false; }, 7464 _dummyElement = {style:{}, appendChild:_emptyFunc, removeChild:_emptyFunc}, 7465 _doc = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].document || {createElement: function() {return _dummyElement;}}, 7466 _docElement = _doc.documentElement || {}, 7467 _createElement = function(type) { 7468 return _doc.createElementNS ? _doc.createElementNS("http://www.w3.org/1999/xhtml", type) : _doc.createElement(type); 7469 }, 7470 _tempDiv = _createElement("div"), 7471 _emptyArray = [], 7472 _RAD2DEG = 180 / Math.PI, 7473 _max = 999999999999999, 7474 _getTime = Date.now || function() {return new Date().getTime();}, 7475 _isOldIE = !!(!_doc.addEventListener && _doc.all), 7476 _placeholderDiv = _doc.createElement("div"), 7477 _renderQueue = [], 7478 _lookup = {}, //when a Draggable is created, the target gets a unique _gsDragID property that allows gets associated with the Draggable instance for quick lookups in Draggable.get(). This avoids circular references that could cause gc problems. 7479 _lookupCount = 0, 7480 _clickableTagExp = /^(?:a|input|textarea|button|select)$/i, 7481 _dragCount = 0, //total number of elements currently being dragged 7482 _prefix, 7483 _isMultiTouching, 7484 _isAndroid = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].navigator && _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].navigator.userAgent.toLowerCase().indexOf("android") !== -1), //Android handles touch events in an odd way and it's virtually impossible to "feature test" so we resort to UA sniffing 7485 _lastDragTime = 0, 7486 _temp1 = {}, // a simple object we reuse and populate (usually x/y properties) to conserve memory and improve performance. 7487 _windowProxy = {}, //memory/performance optimization - we reuse this object during autoScroll to store window-related bounds/offsets. 7488 _supportsPassive, 7489 _slice = function(a) { //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 7490 if (typeof(a) === "string") { 7491 a = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].selector(a); 7492 } 7493 if (!a || a.nodeType) { //if it's not an array, wrap it in one. 7494 return [a]; 7495 } 7496 var b = [], 7497 l = a.length, 7498 i; 7499 for (i = 0; i !== l; b.push(a[i++])); 7500 return b; 7501 }, 7502 _copy = function(obj, factor) { 7503 var copy = {}, p; 7504 if (factor) { 7505 for (p in obj) { 7506 copy[p] = obj[p] * factor; 7507 } 7508 } else { 7509 for (p in obj) { 7510 copy[p] = obj[p]; 7511 } 7512 } 7513 return copy; 7514 }, 7515 ThrowPropsPlugin, 7516 7517 _renderQueueTick = function() { 7518 var i = _renderQueue.length; 7519 while (--i > -1) { 7520 _renderQueue[i](); 7521 } 7522 }, 7523 _addToRenderQueue = function(func) { 7524 _renderQueue.push(func); 7525 if (_renderQueue.length === 1) { 7526 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.addEventListener("tick", _renderQueueTick, this, false, 1); 7527 } 7528 }, 7529 _removeFromRenderQueue = function(func) { 7530 var i = _renderQueue.length; 7531 while (--i > -1) { 7532 if (_renderQueue[i] === func) { 7533 _renderQueue.splice(i, 1); 7534 } 7535 } 7536 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].to(_renderQueueTimeout, 0, {overwrite:"all", delay:15, onComplete:_renderQueueTimeout, data:"_draggable"}); //remove the "tick" listener only after the render queue is empty for 15 seconds (to improve performance). Adding/removing it constantly for every click/touch wouldn't deliver optimal speed, and we also don't want the ticker to keep calling the render method when things are idle for long periods of time (we want to improve battery life on mobile devices). 7537 }, 7538 _renderQueueTimeout = function() { 7539 if (!_renderQueue.length) { 7540 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.removeEventListener("tick", _renderQueueTick); 7541 } 7542 }, 7543 7544 _extend = function(obj, defaults) { 7545 var p; 7546 for (p in defaults) { 7547 if (obj[p] === undefined) { 7548 obj[p] = defaults[p]; 7549 } 7550 } 7551 return obj; 7552 }, 7553 _getDocScrollTop = function() { 7554 return (window.pageYOffset != null) ? window.pageYOffset : (_doc.scrollTop != null) ? _doc.scrollTop : _docElement.scrollTop || _doc.body.scrollTop || 0; 7555 }, 7556 _getDocScrollLeft = function() { 7557 return (window.pageXOffset != null) ? window.pageXOffset : (_doc.scrollLeft != null) ? _doc.scrollLeft : _docElement.scrollLeft || _doc.body.scrollLeft || 0; 7558 }, 7559 _addScrollListener = function(e, callback) { 7560 _addListener(e, "scroll", callback); 7561 if (!_isRoot(e.parentNode)) { 7562 _addScrollListener(e.parentNode, callback); 7563 } 7564 }, 7565 _removeScrollListener = function(e, callback) { 7566 _removeListener(e, "scroll", callback); 7567 if (!_isRoot(e.parentNode)) { 7568 _removeScrollListener(e.parentNode, callback); 7569 } 7570 }, 7571 _isRoot = function (e) { 7572 return !!(!e || e === _docElement || e === _doc || e === _doc.body || e === window || !e.nodeType || !e.parentNode); 7573 }, 7574 _getMaxScroll = function(element, axis) { 7575 var dim = (axis === "x") ? "Width" : "Height", 7576 scroll = "scroll" + dim, 7577 client = "client" + dim, 7578 body = _doc.body; 7579 return Math.max(0, _isRoot(element) ? Math.max(_docElement[scroll], body[scroll]) - (window["inner" + dim] || _docElement[client] || body[client]) : element[scroll] - element[client]); 7580 }, 7581 _recordMaxScrolls = function(e) { //records _gsMaxScrollX and _gsMaxScrollY properties for the element and all ancestors up the chain so that we can cap it, otherwise dragging beyond the edges with autoScroll on can endlessly scroll. 7582 var isRoot = _isRoot(e), 7583 x = _getMaxScroll(e, "x"), 7584 y = _getMaxScroll(e, "y"); 7585 if (isRoot) { 7586 e = _windowProxy; 7587 } else { 7588 _recordMaxScrolls(e.parentNode); 7589 } 7590 e._gsMaxScrollX = x; 7591 e._gsMaxScrollY = y; 7592 e._gsScrollX = e.scrollLeft || 0; 7593 e._gsScrollY = e.scrollTop || 0; 7594 }, 7595 7596 //just used for IE8 and earlier to normalize events and populate pageX/pageY 7597 _populateIEEvent = function(e, preventDefault) { 7598 e = e || window.event; 7599 _tempEvent.pageX = e.clientX + _doc.body.scrollLeft + _docElement.scrollLeft; 7600 _tempEvent.pageY = e.clientY + _doc.body.scrollTop + _docElement.scrollTop; 7601 if (preventDefault) { 7602 e.returnValue = false; 7603 } 7604 return _tempEvent; 7605 }, 7606 7607 //grabs the first element it finds (and we include the window as an element), so if it's selector text, it'll feed that value to TweenLite.selector, if it's a jQuery object or some other selector engine's result, it'll grab the first one, and same for an array. If the value doesn't contain a DOM element, it'll just return null. 7608 _unwrapElement = function(value) { 7609 if (!value) { 7610 return value; 7611 } 7612 if (typeof(value) === "string") { 7613 value = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].selector(value); 7614 } 7615 if (value.length && value !== window && value[0] && value[0].style && !value.nodeType) { 7616 value = value[0]; 7617 } 7618 return (value === window || (value.nodeType && value.style)) ? value : null; 7619 }, 7620 7621 _checkPrefix = function(e, p) { 7622 var s = e.style, 7623 capped, i, a; 7624 if (s[p] === undefined) { 7625 a = ["O","Moz","ms","Ms","Webkit"]; 7626 i = 5; 7627 capped = p.charAt(0).toUpperCase() + p.substr(1); 7628 while (--i > -1 && s[a[i]+capped] === undefined) { } 7629 if (i < 0) { 7630 return ""; 7631 } 7632 _prefix = (i === 3) ? "ms" : a[i]; 7633 p = _prefix + capped; 7634 } 7635 return p; 7636 }, 7637 7638 _setStyle = function(e, p, value) { 7639 var s = e.style; 7640 if (!s) { 7641 return; 7642 } 7643 if (s[p] === undefined) { 7644 p = _checkPrefix(e, p); 7645 } 7646 if (value == null) { 7647 if (s.removeProperty) { 7648 s.removeProperty(p.replace(/([A-Z])/g, "-$1").toLowerCase()); 7649 } else { //note: old versions of IE use "removeAttribute()" instead of "removeProperty()" 7650 s.removeAttribute(p); 7651 } 7652 } else if (s[p] !== undefined) { 7653 s[p] = value; 7654 } 7655 }, 7656 7657 _computedStyleScope = (typeof(window) !== "undefined" ? window : _doc.defaultView || {getComputedStyle:function() {}}), 7658 _getComputedStyle = function(e, s) { 7659 return _computedStyleScope.getComputedStyle((e instanceof Element) ? e : e.host || (e.parentNode || {}).host || e, s); //the "host" stuff helps to accommodate ShadowDom objects. 7660 }, 7661 _horizExp = /(?:Left|Right|Width)/i, 7662 _suffixExp = /(?:\d|\-|\+|=|#|\.)*/g, 7663 _convertToPixels = function(t, p, v, sfx, recurse) { 7664 if (sfx === "px" || !sfx) { return v; } 7665 if (sfx === "auto" || !v) { return 0; } 7666 var horiz = _horizExp.test(p), 7667 node = t, 7668 style = _tempDiv.style, 7669 neg = (v < 0), 7670 pix; 7671 if (neg) { 7672 v = -v; 7673 } 7674 if (sfx === "%" && p.indexOf("border") !== -1) { 7675 pix = (v / 100) * (horiz ? t.clientWidth : t.clientHeight); 7676 } else { 7677 style.cssText = "border:0 solid red;position:" + _getStyle(t, "position", true) + ";line-height:0;"; 7678 if (sfx === "%" || !node.appendChild) { 7679 node = t.parentNode || _doc.body; 7680 style[(horiz ? "width" : "height")] = v + sfx; 7681 } else { 7682 style[(horiz ? "borderLeftWidth" : "borderTopWidth")] = v + sfx; 7683 } 7684 node.appendChild(_tempDiv); 7685 pix = parseFloat(_tempDiv[(horiz ? "offsetWidth" : "offsetHeight")]); 7686 node.removeChild(_tempDiv); 7687 if (pix === 0 && !recurse) { 7688 pix = _convertToPixels(t, p, v, sfx, true); 7689 } 7690 } 7691 return neg ? -pix : pix; 7692 }, 7693 _calculateOffset = function(t, p) { //for figuring out "top" or "left" in px when it's "auto". We need to factor in margin with the offsetLeft/offsetTop 7694 if (_getStyle(t, "position", true) !== "absolute") { return 0; } 7695 var dim = ((p === "left") ? "Left" : "Top"), 7696 v = _getStyle(t, "margin" + dim, true); 7697 return t["offset" + dim] - (_convertToPixels(t, p, parseFloat(v), (v + "").replace(_suffixExp, "")) || 0); 7698 }, 7699 7700 _getStyle = function(element, prop, keepUnits) { 7701 var rv = (element._gsTransform || {})[prop], 7702 cs; 7703 if (rv || rv === 0) { 7704 return rv; 7705 } else if (element.style && element.style[prop]) { //shadow dom elements don't have "style". 7706 rv = element.style[prop]; 7707 } else if ((cs = _getComputedStyle(element))) { 7708 rv = cs.getPropertyValue(prop.replace(/([A-Z])/g, "-$1").toLowerCase()); 7709 rv = (rv || cs.length) ? rv : cs[prop]; //Opera behaves VERY strangely - length is usually 0 and cs[prop] is the only way to get accurate results EXCEPT when checking for -o-transform which only works with cs.getPropertyValue()! 7710 } else if (element.currentStyle) { 7711 rv = element.currentStyle[prop]; 7712 } 7713 if (rv === "auto" && (prop === "top" || prop === "left")) { 7714 rv = _calculateOffset(element, prop); 7715 } 7716 return keepUnits ? rv : parseFloat(rv) || 0; 7717 }, 7718 7719 _dispatchEvent = function(instance, type, callbackName) { 7720 var vars = instance.vars, 7721 callback = vars[callbackName], 7722 listeners = instance._listeners[type]; 7723 if (typeof(callback) === "function") { 7724 callback.apply(vars[callbackName + "Scope"] || vars.callbackScope || instance, vars[callbackName + "Params"] || [instance.pointerEvent]); 7725 } 7726 if (listeners) { 7727 instance.dispatchEvent(type); 7728 } 7729 }, 7730 _getBounds = function(obj, context) { //accepts any of the following: a DOM element, jQuery object, selector text, or an object defining bounds as {top, left, width, height} or {minX, maxX, minY, maxY}. Returns an object with left, top, width, and height properties. 7731 var e = _unwrapElement(obj), 7732 top, left, offset; 7733 if (!e) { 7734 if (obj.left !== undefined) { 7735 offset = _getOffsetTransformOrigin(context); //the bounds should be relative to the origin 7736 return {left: obj.left - offset.x, top: obj.top - offset.y, width: obj.width, height: obj.height}; 7737 } 7738 left = obj.min || obj.minX || obj.minRotation || 0; 7739 top = obj.min || obj.minY || 0; 7740 return {left:left, top:top, width:(obj.max || obj.maxX || obj.maxRotation || 0) - left, height:(obj.max || obj.maxY || 0) - top}; 7741 } 7742 return _getElementBounds(e, context); 7743 }, 7744 7745 _svgBorderFactor, 7746 _svgBorderScales, 7747 _svgScrollOffset, 7748 _hasBorderBug, 7749 _hasReparentBug,//some browsers, like Chrome 49, alter the offsetTop/offsetLeft/offsetParent of elements when a non-identity transform is applied. 7750 _setEnvironmentVariables = function() { //some browsers factor the border into the SVG coordinate space, some don't (like Firefox). Some apply transforms to them, some don't. We feature-detect here so we know how to handle the border(s). We can't do this immediately - we must wait for the document.body to exist. 7751 if (!_doc.createElementNS) { 7752 _svgBorderFactor = 0; 7753 _svgBorderScales = false; 7754 return; 7755 } 7756 var div = _createElement("div"), 7757 svg = _doc.createElementNS("http://www.w3.org/2000/svg", "svg"), 7758 wrapper = _createElement("div"), 7759 style = div.style, 7760 parent = _doc.body || _docElement, 7761 isFlex = (_getStyle(parent, "display", true) === "flex"), //Firefox bug causes getScreenCTM() to return null when parent is display:flex and the element isn't rendered inside the window (like if it's below the scroll position) 7762 matrix, e1, point, oldValue; 7763 if (_doc.body && _transformProp) { 7764 style.position = "absolute"; 7765 parent.appendChild(wrapper); 7766 wrapper.appendChild(div); 7767 oldValue = div.offsetParent; 7768 wrapper.style[_transformProp] = "rotate(1deg)"; 7769 _hasReparentBug = (div.offsetParent === oldValue); 7770 wrapper.style.position = "absolute"; 7771 style.height = "10px"; 7772 oldValue = div.offsetTop; 7773 wrapper.style.border = "5px solid red"; 7774 _hasBorderBug = (oldValue !== div.offsetTop); //some browsers, like Firefox 38, cause the offsetTop/Left to be affected by a parent's border. 7775 parent.removeChild(wrapper); 7776 } 7777 style = svg.style; 7778 svg.setAttributeNS(null, "width", "400px"); 7779 svg.setAttributeNS(null, "height", "400px"); 7780 svg.setAttributeNS(null, "viewBox", "0 0 400 400"); 7781 style.display = "block"; 7782 style.boxSizing = "border-box"; 7783 style.border = "0px solid red"; 7784 style.transform = "none"; 7785 // in some browsers (like certain flavors of Android), the getScreenCTM() matrix is contaminated by the scroll position. We can run some logic here to detect that condition, but we ended up not needing this because we found another workaround using getBoundingClientRect(). 7786 div.style.cssText = "width:100px;height:100px;overflow:scroll;-ms-overflow-style:none;"; 7787 parent.appendChild(div); 7788 div.appendChild(svg); 7789 point = svg.createSVGPoint().matrixTransform(svg.getScreenCTM()); 7790 e1 = point.y; 7791 div.scrollTop = 100; 7792 point.x = point.y = 0; 7793 point = point.matrixTransform(svg.getScreenCTM()); 7794 _svgScrollOffset = (e1 - point.y < 100.1) ? 0 : e1 - point.y - 150; 7795 div.removeChild(svg); 7796 parent.removeChild(div); 7797 // -- end _svgScrollOffset calculation. 7798 parent.appendChild(svg); 7799 if (isFlex) { 7800 parent.style.display = "block"; //Firefox bug causes getScreenCTM() to return null when parent is display:flex and the element isn't rendered inside the window (like if it's below the scroll position) 7801 } 7802 matrix = svg.getScreenCTM(); 7803 e1 = matrix.e; 7804 style.border = "50px solid red"; 7805 matrix = svg.getScreenCTM(); 7806 if (e1 === 0 && matrix.e === 0 && matrix.f === 0 && matrix.a === 1) { //Opera has a bunch of bugs - it doesn't adjust the x/y of the matrix, nor does it scale when box-sizing is border-box but it does so elsewhere; to get the correct behavior we set _svgBorderScales to true. 7807 _svgBorderFactor = 1; 7808 _svgBorderScales = true; 7809 } else { 7810 _svgBorderFactor = (e1 !== matrix.e) ? 1 : 0; 7811 _svgBorderScales = (matrix.a !== 1); 7812 } 7813 if (isFlex) { 7814 parent.style.display = "flex"; 7815 } 7816 parent.removeChild(svg); 7817 }, 7818 7819 _supports3D = (_checkPrefix(_tempDiv, "perspective") !== ""), 7820 7821 // start matrix and point conversion methods... 7822 _transformOriginProp = _checkPrefix(_tempDiv, "transformOrigin").replace(/^ms/g, "Ms").replace(/([A-Z])/g, "-$1").toLowerCase(), 7823 _transformProp = _checkPrefix(_tempDiv, "transform"), 7824 _transformPropCSS = _transformProp.replace(/^ms/g, "Ms").replace(/([A-Z])/g, "-$1").toLowerCase(), 7825 _point1 = {}, //we reuse _point1 and _point2 objects inside matrix and point conversion methods to conserve memory and minimize garbage collection tasks. 7826 _point2 = {}, 7827 _SVGElement = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].SVGElement, 7828 _isSVG = function(e) { 7829 return !!(_SVGElement && typeof(e.getBBox) === "function" && e.getCTM && (!e.parentNode || (e.parentNode.getBBox && e.parentNode.getCTM))); 7830 }, 7831 _isIE10orBelow = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].navigator && (((/MSIE ([0-9]{1,}[\.0-9]{0,})/).exec(_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].navigator.userAgent) || (/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/).exec(_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].navigator.userAgent)) && parseFloat( RegExp.$1 ) < 11)), //Ideally we'd avoid user agent sniffing, but there doesn't seem to be a way to feature-detect and sense a border-related bug that only affects IE10 and IE9. 7832 _tempTransforms = [], 7833 _tempElements = [], 7834 _getSVGOffsets = function(e) { //SVG elements don't always report offsetTop/offsetLeft/offsetParent at all (I'm looking at you, Firefox 29 and Android), so we have to do some work to manufacture those values. You can pass any SVG element and it'll spit back an object with offsetTop, offsetLeft, offsetParent, scaleX, and scaleY properties. We need the scaleX and scaleY to handle the way SVG can resize itself based on the container. 7835 if (!e.getBoundingClientRect || !e.parentNode || !_transformProp) { 7836 return {offsetTop:0, offsetLeft:0, scaleX:1, scaleY:1, offsetParent:_docElement}; 7837 } 7838 if (Draggable.cacheSVGData !== false && e._dCache && e._dCache.lastUpdate === _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.frame) { //performance optimization. Assume that if the offsets are requested again on the same tick, we can just feed back the values we already calculated (no need to keep recalculating until another tick elapses). 7839 return e._dCache; 7840 } 7841 var curElement = e, 7842 cache = _cache(e), 7843 eRect, parentRect, offsetParent, cs, m, i, point1, point2, borderWidth, borderHeight, width, height; 7844 cache.lastUpdate = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.frame; 7845 if (e.getBBox && !cache.isSVGRoot) { //if it's a nested/child SVG element, we must find the parent SVG canvas and measure the offset from there. 7846 curElement = e.parentNode; 7847 eRect = e.getBBox(); 7848 while (curElement && (curElement.nodeName + "").toLowerCase() !== "svg") { 7849 curElement = curElement.parentNode; 7850 } 7851 cs = _getSVGOffsets(curElement); 7852 cache.offsetTop = eRect.y * cs.scaleY; 7853 cache.offsetLeft = eRect.x * cs.scaleX; 7854 cache.scaleX = cs.scaleX; 7855 cache.scaleY = cs.scaleY; 7856 cache.offsetParent = curElement || _docElement; 7857 return cache; 7858 } 7859 //only root SVG elements continue here... 7860 offsetParent = cache.offsetParent; 7861 if (offsetParent === _doc.body) { 7862 offsetParent = _docElement; //avoids problems with margins/padding on the body 7863 } 7864 //walk up the ancestors and record any non-identity transforms (and reset them to "none") until we reach the offsetParent. We must do this so that the getBoundingClientRect() is accurate for measuring the offsetTop/offsetLeft. We'll revert the values later... 7865 _tempElements.length = _tempTransforms.length = 0; 7866 while (curElement && curElement.parentNode) { 7867 m = _getStyle(curElement, _transformProp, true); 7868 if (m !== "matrix(1, 0, 0, 1, 0, 0)" && m !== "none" && m !== "translate3d(0px, 0px, 0px)") { 7869 _tempElements.push(curElement); 7870 _tempTransforms.push(curElement.style[_transformProp]); 7871 curElement.style[_transformProp] = "none"; 7872 } 7873 curElement = curElement.parentNode; 7874 } 7875 parentRect = offsetParent.getBoundingClientRect(); 7876 m = e.getScreenCTM(); 7877 7878 point2 = e.createSVGPoint(); 7879 point1 = point2.matrixTransform(m); 7880 cache.scaleX = Math.sqrt(m.a * m.a + m.b * m.b); 7881 cache.scaleY = Math.sqrt(m.d * m.d + m.c * m.c); 7882 if (_svgBorderFactor === undefined) { 7883 _setEnvironmentVariables(); 7884 } 7885 if (cache.borderBox && !_svgBorderScales && e.getAttribute("width")) { //some browsers (like Safari) don't properly scale the matrix to accommodate the border when box-sizing is border-box, so we must calculate it here... 7886 cs = _getComputedStyle(e) || {}; 7887 borderWidth = (parseFloat(cs.borderLeftWidth) + parseFloat(cs.borderRightWidth)) || 0; 7888 borderHeight = (parseFloat(cs.borderTopWidth) + parseFloat(cs.borderBottomWidth)) || 0; 7889 width = parseFloat(cs.width) || 0; 7890 height = parseFloat(cs.height) || 0; 7891 cache.scaleX *= (width - borderWidth) / width; 7892 cache.scaleY *= (height - borderHeight) / height; 7893 } 7894 if (_svgScrollOffset) { //some browsers (like Chrome for Android) have bugs in the way getScreenCTM() is reported (it doesn't factor in scroll position), so we must revert to a more expensive technique for calculating offsetTop/Left. 7895 eRect = e.getBoundingClientRect(); 7896 cache.offsetLeft = eRect.left - parentRect.left; 7897 cache.offsetTop = eRect.top - parentRect.top; 7898 } else { 7899 cache.offsetLeft = point1.x - parentRect.left; 7900 cache.offsetTop = point1.y - parentRect.top; 7901 } 7902 cache.offsetParent = offsetParent; 7903 i = _tempElements.length; 7904 while (--i > -1) { 7905 _tempElements[i].style[_transformProp] = _tempTransforms[i]; 7906 } 7907 return cache; 7908 }, 7909 _getOffsetTransformOrigin = function(e, decoratee) { //returns the x/y position of the transformOrigin of the element, in its own local coordinate system (pixels), offset from the top left corner. 7910 decoratee = decoratee || {}; 7911 if (!e || e === _docElement || !e.parentNode || e === window) { 7912 return {x:0, y:0}; 7913 } 7914 var cs = _getComputedStyle(e), 7915 v = (_transformOriginProp && cs) ? cs.getPropertyValue(_transformOriginProp) : "50% 50%", 7916 a = v.split(" "), 7917 x = (v.indexOf("left") !== -1) ? "0%" : (v.indexOf("right") !== -1) ? "100%" : a[0], 7918 y = (v.indexOf("top") !== -1) ? "0%" : (v.indexOf("bottom") !== -1) ? "100%" : a[1]; 7919 if (y === "center" || y == null) { 7920 y = "50%"; 7921 } 7922 if (x === "center" || isNaN(parseFloat(x))) { //remember, the user could flip-flop the values and say "bottom center" or "center bottom", etc. "center" is ambiguous because it could be used to describe horizontal or vertical, hence the isNaN(). If there's an "=" sign in the value, it's relative. 7923 x = "50%"; 7924 } 7925 if (e.getBBox && _isSVG(e)) { //SVG elements must be handled in a special way because their origins are calculated from the top left. 7926 if (!e._gsTransform) { 7927 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].set(e, {x:"+=0", overwrite:false}); //forces creation of the _gsTransform where we store all the transform components including xOrigin and yOrigin for SVG elements, as of GSAP 1.15.0 which also takes care of calculating the origin from the upper left corner of the SVG canvas. 7928 if (e._gsTransform.xOrigin === undefined) { 7929 console.log("Draggable requires at least GSAP 1.17.0"); 7930 } 7931 } 7932 v = e.getBBox(); 7933 decoratee.x = (e._gsTransform.xOrigin - v.x); 7934 decoratee.y = (e._gsTransform.yOrigin - v.y); 7935 } else { 7936 if (e.getBBox && (x + y).indexOf("%") !== -1) { //Firefox doesn't report offsetWidth/height on <svg> elements. 7937 e = e.getBBox(); 7938 e = {offsetWidth: e.width, offsetHeight: e.height}; 7939 } 7940 decoratee.x = ((x.indexOf("%") !== -1) ? e.offsetWidth * parseFloat(x) / 100 : parseFloat(x)); 7941 decoratee.y = ((y.indexOf("%") !== -1) ? e.offsetHeight * parseFloat(y) / 100 : parseFloat(y)); 7942 } 7943 return decoratee; 7944 }, 7945 _cache = function(e) { //computes some important values and stores them in a _dCache object attached to the element itself so that we can optimize performance 7946 if (Draggable.cacheSVGData !== false && e._dCache && e._dCache.lastUpdate === _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.frame) { //performance optimization. Assume that if the offsets are requested again on the same tick, we can just feed back the values we already calculated (no need to keep recalculating until another tick elapses). 7947 return e._dCache; 7948 } 7949 var cache = e._dCache = e._dCache || {}, 7950 cs = _getComputedStyle(e), 7951 isSVG = (e.getBBox && _isSVG(e)), 7952 isSVGRoot = ((e.nodeName + "").toLowerCase() === "svg"), 7953 curSVG; 7954 cache.isSVG = isSVG; 7955 cache.isSVGRoot = isSVGRoot; 7956 cache.borderBox = (cs.boxSizing === "border-box"); 7957 cache.computedStyle = cs; 7958 if (isSVGRoot) { //some browsers don't report parentNode on SVG elements. 7959 curSVG = e.parentNode || _docElement; 7960 curSVG.insertBefore(_tempDiv, e); 7961 cache.offsetParent = _tempDiv.offsetParent || _docElement; //in some cases, Firefox still reports offsetParent as null. 7962 curSVG.removeChild(_tempDiv); 7963 } else if (isSVG) { 7964 curSVG = e.parentNode; 7965 while (curSVG && (curSVG.nodeName + "").toLowerCase() !== "svg") { //offsetParent is always the SVG canvas for SVG elements. 7966 curSVG = curSVG.parentNode; 7967 } 7968 cache.offsetParent = curSVG; 7969 } else { 7970 cache.offsetParent = e.offsetParent; 7971 } 7972 return cache; 7973 }, 7974 _getOffset2DMatrix = function(e, offsetOrigin, parentOffsetOrigin, zeroOrigin, isBase) { //"isBase" helps us discern context - it should only be true when the element is the base one (the one at which we're starting to walk up the chain). It only matters in cases when it's an <svg> element itself because that's a case when we don't apply scaling. 7975 if (e === window || !e || !e.style || !e.parentNode) { 7976 return [1,0,0,1,0,0]; 7977 } 7978 var cache = e._dCache || _cache(e), 7979 parent = e.parentNode, 7980 parentCache = parent._dCache || _cache(parent), 7981 cs = cache.computedStyle, 7982 parentOffsetParent = cache.isSVG ? parentCache.offsetParent : parent.offsetParent, 7983 m, isRoot, offsets, rect, t, sx, sy, offsetX, offsetY, parentRect, borderTop, borderLeft, borderTranslateX, borderTranslateY; 7984 m = (cache.isSVG && (e.style[_transformProp] + "").indexOf("matrix") !== -1) ? e.style[_transformProp] : cs ? cs.getPropertyValue(_transformPropCSS) : e.currentStyle ? e.currentStyle[_transformProp] : "1,0,0,1,0,0"; //some browsers (like Chrome 40) don't correctly report transforms that are applied inline on an SVG element (they don't get included in the computed style), so we double-check here and accept matrix values 7985 if (e.getBBox && (e.getAttribute("transform") + "").indexOf("matrix") !== -1) { //SVG can store transform data in its "transform" attribute instead of the CSS, so look for that here (only accept matrix()). 7986 m = e.getAttribute("transform"); 7987 } 7988 m = (m + "").match(/(?:\-|\.|\b)(\d|\.|e\-)+/g) || [1,0,0,1,0,0]; 7989 if (m.length > 6) { 7990 m = [m[0], m[1], m[4], m[5], m[12], m[13]]; 7991 } 7992 if (zeroOrigin) { 7993 m[4] = m[5] = 0; 7994 } else if (cache.isSVG && (t = e._gsTransform) && (t.xOrigin || t.yOrigin)) { 7995 //SVGs handle origin very differently. Factor in GSAP's handling of origin values here: 7996 m[0] = parseFloat(m[0]); 7997 m[1] = parseFloat(m[1]); 7998 m[2] = parseFloat(m[2]); 7999 m[3] = parseFloat(m[3]); 8000 m[4] = parseFloat(m[4]) - (t.xOrigin - (t.xOrigin * m[0] + t.yOrigin * m[2])); 8001 m[5] = parseFloat(m[5]) - (t.yOrigin - (t.xOrigin * m[1] + t.yOrigin * m[3])); 8002 } 8003 if (offsetOrigin) { 8004 if (_svgBorderFactor === undefined) { 8005 _setEnvironmentVariables(); 8006 } 8007 offsets = (cache.isSVG || cache.isSVGRoot) ? _getSVGOffsets(e) : e; 8008 if (cache.isSVG) { //don't just rely on "instanceof _SVGElement" because if the SVG is embedded via an object tag, it won't work (SVGElement is mapped to a different object)) 8009 rect = e.getBBox(); 8010 parentRect = (parentCache.isSVGRoot) ? {x:0, y:0} : parent.getBBox(); 8011 offsets = {offsetLeft:rect.x - parentRect.x, offsetTop:rect.y - parentRect.y, offsetParent:cache.offsetParent}; 8012 } else if (cache.isSVGRoot) { 8013 borderTop = parseInt(cs.borderTopWidth, 10) || 0; 8014 borderLeft = parseInt(cs.borderLeftWidth, 10) || 0; 8015 borderTranslateX = ((m[0] - _svgBorderFactor) * borderLeft + m[2] * borderTop); 8016 borderTranslateY = (m[1] * borderLeft + (m[3] - _svgBorderFactor) * borderTop); 8017 8018 sx = offsetOrigin.x; 8019 sy = offsetOrigin.y; 8020 offsetX = (sx - (sx * m[0] + sy * m[2])); //accommodate the SVG root's transforms when the origin isn't in the top left. 8021 offsetY = (sy - (sx * m[1] + sy * m[3])); 8022 8023 m[4] = parseFloat(m[4]) + offsetX; 8024 m[5] = parseFloat(m[5]) + offsetY; 8025 offsetOrigin.x -= offsetX; 8026 offsetOrigin.y -= offsetY; 8027 sx = offsets.scaleX; 8028 sy = offsets.scaleY; 8029 if (!isBase) { //when getting the matrix for a root <svg> element itself (NOT in the context of an SVG element that's nested inside of it like a <path>), we do NOT apply the scaling! 8030 offsetOrigin.x *= sx; 8031 offsetOrigin.y *= sy; 8032 } 8033 m[0] *= sx; 8034 m[1] *= sy; 8035 m[2] *= sx; 8036 m[3] *= sy; 8037 if (!_isIE10orBelow) { 8038 offsetOrigin.x += borderTranslateX; 8039 offsetOrigin.y += borderTranslateY; 8040 } 8041 if (parentOffsetParent === _doc.body && offsets.offsetParent === _docElement) { //to avoid issues with margin/padding on the <body>, we always set the offsetParent to _docElement in the _getSVGOffsets() function but there's a condition we check later in this function for (parentOffsetParent === offsets.offsetParent) which would fail if we don't run this logic. In other words, parentOffsetParent may be <body> and the <svg>'s offsetParent is also <body> but artificially set to _docElement to avoid margin/padding issues. 8042 parentOffsetParent = _docElement; 8043 } 8044 } else if (!_hasBorderBug && e.offsetParent) { 8045 offsetOrigin.x += parseInt(_getStyle(e.offsetParent, "borderLeftWidth"), 10) || 0; 8046 offsetOrigin.y += parseInt(_getStyle(e.offsetParent, "borderTopWidth"), 10) || 0; 8047 } 8048 isRoot = (parent === _docElement || parent === _doc.body); 8049 m[4] = Number(m[4]) + offsetOrigin.x + (offsets.offsetLeft || 0) - parentOffsetOrigin.x - (isRoot ? 0 : parent.scrollLeft || 0); 8050 m[5] = Number(m[5]) + offsetOrigin.y + (offsets.offsetTop || 0) - parentOffsetOrigin.y - (isRoot ? 0 : parent.scrollTop || 0); 8051 if (parent && _getStyle(e, "position", true) === "fixed") { //fixed position elements should factor in the scroll position of the document. 8052 m[4] += _getDocScrollLeft(); 8053 m[5] += _getDocScrollTop(); 8054 parent = parent.offsetParent; 8055 while (parent) { 8056 m[4] -= parent.offsetLeft; 8057 m[5] -= parent.offsetTop; 8058 parent = parent.offsetParent; 8059 } 8060 } else if (parent && parent !== _docElement && parentOffsetParent === offsets.offsetParent && !parentCache.isSVG && (!_hasReparentBug || _getOffset2DMatrix(parent).join("") === "100100")) { 8061 offsets = (parentCache.isSVGRoot) ? _getSVGOffsets(parent) : parent; 8062 m[4] -= offsets.offsetLeft || 0; 8063 m[5] -= offsets.offsetTop || 0; 8064 if (!_hasBorderBug && parentCache.offsetParent && !cache.isSVG && !cache.isSVGRoot) { 8065 m[4] -= parseInt(_getStyle(parentCache.offsetParent, "borderLeftWidth"), 10) || 0; 8066 m[5] -= parseInt(_getStyle(parentCache.offsetParent, "borderTopWidth"), 10) || 0; 8067 } 8068 } 8069 } 8070 return m; 8071 }, 8072 _getConcatenatedMatrix = function(e, invert) { 8073 if (!e || e === window || !e.parentNode) { 8074 return [1,0,0,1,0,0]; 8075 } 8076 //note: we keep reusing _point1 and _point2 in order to minimize memory usage and garbage collection chores. 8077 var originOffset = _getOffsetTransformOrigin(e, _point1), 8078 parentOriginOffset = _getOffsetTransformOrigin(e.parentNode, _point2), 8079 m = _getOffset2DMatrix(e, originOffset, parentOriginOffset, false, !invert), 8080 a, b, c, d, tx, ty, m2, determinant; 8081 while ((e = e.parentNode) && e.parentNode && e !== _docElement) { 8082 originOffset = parentOriginOffset; 8083 parentOriginOffset = _getOffsetTransformOrigin(e.parentNode, (originOffset === _point1) ? _point2 : _point1); 8084 m2 = _getOffset2DMatrix(e, originOffset, parentOriginOffset); 8085 a = m[0]; 8086 b = m[1]; 8087 c = m[2]; 8088 d = m[3]; 8089 tx = m[4]; 8090 ty = m[5]; 8091 m[0] = a * m2[0] + b * m2[2]; 8092 m[1] = a * m2[1] + b * m2[3]; 8093 m[2] = c * m2[0] + d * m2[2]; 8094 m[3] = c * m2[1] + d * m2[3]; 8095 m[4] = tx * m2[0] + ty * m2[2] + m2[4]; 8096 m[5] = tx * m2[1] + ty * m2[3] + m2[5]; 8097 } 8098 if (invert) { 8099 a = m[0]; 8100 b = m[1]; 8101 c = m[2]; 8102 d = m[3]; 8103 tx = m[4]; 8104 ty = m[5]; 8105 determinant = (a * d - b * c); 8106 m[0] = d / determinant; 8107 m[1] = -b / determinant; 8108 m[2] = -c / determinant; 8109 m[3] = a / determinant; 8110 m[4] = (c * ty - d * tx) / determinant; 8111 m[5] = -(a * ty - b * tx) / determinant; 8112 } 8113 return m; 8114 }, 8115 _localToGlobal = function(e, p, fromTopLeft, decoratee) { 8116 e = _unwrapElement(e); 8117 var m = _getConcatenatedMatrix(e, false), 8118 x = p.x, 8119 y = p.y; 8120 if (fromTopLeft) { 8121 _getOffsetTransformOrigin(e, p); 8122 x -= p.x; 8123 y -= p.y; 8124 } 8125 decoratee = (decoratee === true) ? p : decoratee || {}; 8126 decoratee.x = x * m[0] + y * m[2] + m[4]; 8127 decoratee.y = x * m[1] + y * m[3] + m[5]; 8128 return decoratee; 8129 }, 8130 _localizePoint = function(p, localToGlobal, globalToLocal) { 8131 var x = p.x * localToGlobal[0] + p.y * localToGlobal[2] + localToGlobal[4], 8132 y = p.x * localToGlobal[1] + p.y * localToGlobal[3] + localToGlobal[5]; 8133 p.x = x * globalToLocal[0] + y * globalToLocal[2] + globalToLocal[4]; 8134 p.y = x * globalToLocal[1] + y * globalToLocal[3] + globalToLocal[5]; 8135 return p; 8136 }, 8137 8138 _getElementBounds = function(e, context, fromTopLeft) { 8139 if (!(e = _unwrapElement(e))) { 8140 return null; 8141 } 8142 context = _unwrapElement(context); 8143 var isSVG = (e.getBBox && _isSVG(e)), 8144 origin, left, right, top, bottom, mLocalToGlobal, mGlobalToLocal, p1, p2, p3, p4, bbox, width, height, cache, borderLeft, borderTop, viewBox, viewBoxX, viewBoxY, computedDimensions, cs; 8145 if (e === window) { 8146 top = _getDocScrollTop(); 8147 left = _getDocScrollLeft(); 8148 right = left + (_docElement.clientWidth || e.innerWidth || _doc.body.clientWidth || 0); 8149 bottom = top + (((e.innerHeight || 0) - 20 < _docElement.clientHeight) ? _docElement.clientHeight : e.innerHeight || _doc.body.clientHeight || 0); //some browsers (like Firefox) ignore absolutely positioned elements, and collapse the height of the documentElement, so it could be 8px, for example, if you have just an absolutely positioned div. In that case, we use the innerHeight to resolve this. 8150 } else if (context === undefined || context === window) { 8151 return e.getBoundingClientRect(); 8152 } else { 8153 origin = _getOffsetTransformOrigin(e); 8154 left = -origin.x; 8155 top = -origin.y; 8156 if (isSVG) { 8157 bbox = e.getBBox(); 8158 width = bbox.width; 8159 height = bbox.height; 8160 } else if ((e.nodeName + "").toLowerCase() !== "svg" && e.offsetWidth) { //Chrome dropped support for "offsetWidth" on SVG elements 8161 width = e.offsetWidth; 8162 height = e.offsetHeight; 8163 } else { 8164 computedDimensions = _getComputedStyle(e); 8165 width = parseFloat(computedDimensions.width); 8166 height = parseFloat(computedDimensions.height); 8167 } 8168 right = left + width; 8169 bottom = top + height; 8170 if (e.nodeName.toLowerCase() === "svg" && !_isOldIE) { //root SVG elements are a special beast because they have 2 types of scaling - transforms on themselves as well as the stretching of the SVG canvas itself based on the outer size and the viewBox. If, for example, the SVG's viewbox is "0 0 100 100" but the CSS is set to width:200px; height:200px, that'd make it appear at 2x scale even though the element itself has no CSS transforms but the offsetWidth/offsetHeight are based on that css, not the viewBox so we need to adjust them accordingly. 8171 cache = _getSVGOffsets(e); 8172 cs = cache.computedStyle || {}; 8173 viewBox = (e.getAttribute("viewBox") || "0 0").split(" "); 8174 viewBoxX = parseFloat(viewBox[0]); 8175 viewBoxY = parseFloat(viewBox[1]); 8176 borderLeft = parseFloat(cs.borderLeftWidth) || 0; 8177 borderTop = parseFloat(cs.borderTopWidth) || 0; 8178 left /= cache.scaleX; 8179 top /= cache.scaleY; 8180 right = left + width - (width - ((width - borderLeft) / cache.scaleX) - viewBoxX); 8181 bottom = top + height - (height - ((height - borderTop) / cache.scaleY) - viewBoxY); 8182 left -= borderLeft / cache.scaleX - viewBoxX; 8183 top -= borderTop / cache.scaleY - viewBoxY; 8184 if (computedDimensions) { //when we had to use computed styles, factor in the border now. 8185 right += (parseFloat(cs.borderRightWidth) + borderLeft) / cache.scaleX; 8186 bottom += (borderTop + parseFloat(cs.borderBottomWidth)) / cache.scaleY; 8187 } 8188 } 8189 } 8190 if (e === context) { 8191 return {left:left, top:top, width: right - left, height: bottom - top}; 8192 } 8193 mLocalToGlobal = _getConcatenatedMatrix(e); 8194 mGlobalToLocal = _getConcatenatedMatrix(context, true); 8195 p1 = _localizePoint({x:left, y:top}, mLocalToGlobal, mGlobalToLocal); 8196 p2 = _localizePoint({x:right, y:top}, mLocalToGlobal, mGlobalToLocal); 8197 p3 = _localizePoint({x:right, y:bottom}, mLocalToGlobal, mGlobalToLocal); 8198 p4 = _localizePoint({x:left, y:bottom}, mLocalToGlobal, mGlobalToLocal); 8199 left = Math.min(p1.x, p2.x, p3.x, p4.x); 8200 top = Math.min(p1.y, p2.y, p3.y, p4.y); 8201 _temp1.x = _temp1.y = 0; 8202 if (fromTopLeft) { 8203 _getOffsetTransformOrigin(context, _temp1); 8204 } 8205 return {left:left + _temp1.x, top:top + _temp1.y, width:Math.max(p1.x, p2.x, p3.x, p4.x) - left, height:Math.max(p1.y, p2.y, p3.y, p4.y) - top}; 8206 }, 8207 // end matrix and point conversion methods 8208 8209 8210 8211 _isArrayLike = function(e) { 8212 return (e && e.length && e[0] && ((e[0].nodeType && e[0].style && !e.nodeType) || (e[0].length && e[0][0]))) ? true : false; //could be an array of jQuery objects too, so accommodate that. 8213 }, 8214 8215 _flattenArray = function(a) { 8216 var result = [], 8217 l = a.length, 8218 i, e, j; 8219 for (i = 0; i < l; i++) { 8220 e = a[i]; 8221 if (_isArrayLike(e)) { 8222 j = e.length; 8223 for (j = 0; j < e.length; j++) { 8224 result.push(e[j]); 8225 } 8226 } else if (e && e.length !== 0) { 8227 result.push(e); 8228 } 8229 } 8230 return result; 8231 }, 8232 8233 _isTouchDevice = (typeof(window) !== "undefined" && ("ontouchstart" in _docElement) && ("orientation" in window)), 8234 _touchEventLookup = (function(types) { //we create an object that makes it easy to translate touch event types into their "pointer" counterparts if we're in a browser that uses those instead. Like IE10 uses "MSPointerDown" instead of "touchstart", for example. 8235 var standard = types.split(","), 8236 converted = ((_tempDiv.onpointerdown !== undefined) ? "pointerdown,pointermove,pointerup,pointercancel" : (_tempDiv.onmspointerdown !== undefined) ? "MSPointerDown,MSPointerMove,MSPointerUp,MSPointerCancel" : types).split(","), 8237 obj = {}, 8238 i = 4; 8239 while (--i > -1) { 8240 obj[standard[i]] = converted[i]; 8241 obj[converted[i]] = standard[i]; 8242 } 8243 //to avoid problems in iOS 9, test to see if the browser supports the "passive" option on addEventListener(). 8244 try { 8245 _docElement.addEventListener("test", null, Object.defineProperty({}, "passive", { 8246 get: function () { 8247 _supportsPassive = 1; 8248 } 8249 })); 8250 } catch (e) {} 8251 return obj; 8252 }("touchstart,touchmove,touchend,touchcancel")), 8253 8254 _addListener = function(element, type, func, capture) { 8255 if (element.addEventListener) { 8256 var touchType = _touchEventLookup[type]; 8257 capture = capture || (_supportsPassive ? {passive:false} : null); 8258 element.addEventListener(touchType || type, func, capture); 8259 if (touchType && type !== touchType) { //some browsers actually support both, so must we. 8260 element.addEventListener(type, func, capture); 8261 } 8262 } else if (element.attachEvent) { 8263 element.attachEvent("on" + type, func); 8264 } 8265 }, 8266 8267 _removeListener = function(element, type, func) { 8268 if (element.removeEventListener) { 8269 var touchType = _touchEventLookup[type]; 8270 element.removeEventListener(touchType || type, func); 8271 if (touchType && type !== touchType) { 8272 element.removeEventListener(type, func); 8273 } 8274 } else if (element.detachEvent) { 8275 element.detachEvent("on" + type, func); 8276 } 8277 }, 8278 8279 _hasTouchID = function(list, ID) { 8280 var i = list.length; 8281 while (--i > -1) { 8282 if (list[i].identifier === ID) { 8283 return true; 8284 } 8285 } 8286 return false; 8287 }, 8288 8289 _onMultiTouchDocumentEnd = function(e) { 8290 _isMultiTouching = (e.touches && _dragCount < e.touches.length); 8291 _removeListener(e.target, "touchend", _onMultiTouchDocumentEnd); 8292 }, 8293 8294 _onMultiTouchDocument = function(e) { 8295 _isMultiTouching = (e.touches && _dragCount < e.touches.length); 8296 _addListener(e.target, "touchend", _onMultiTouchDocumentEnd); 8297 }, 8298 8299 _parseThrowProps = function(draggable, snap, max, min, factor, forceZeroVelocity) { 8300 var vars = {}, 8301 a, i, l; 8302 if (snap) { 8303 if (factor !== 1 && snap instanceof Array) { //some data must be altered to make sense, like if the user passes in an array of rotational values in degrees, we must convert it to radians. Or for scrollLeft and scrollTop, we invert the values. 8304 vars.end = a = []; 8305 l = snap.length; 8306 if (typeof(snap[0]) === "object") { //if the array is populated with objects, like points ({x:100, y:200}), make copies before multiplying by the factor, otherwise we'll mess up the originals and the user may reuse it elsewhere. 8307 for (i = 0; i < l; i++) { 8308 a[i] = _copy(snap[i], factor); 8309 } 8310 } else { 8311 for (i = 0; i < l; i++) { 8312 a[i] = snap[i] * factor; 8313 } 8314 } 8315 max += 1.1; //allow 1.1 pixels of wiggle room when snapping in order to work around some browser inconsistencies in the way bounds are reported which can make them roughly a pixel off. For example, if "snap:[-$('#menu').width(), 0]" was defined and #menu had a wrapper that was used as the bounds, some browsers would be one pixel off, making the minimum -752 for example when snap was [-753,0], thus instead of snapping to -753, it would snap to 0 since -753 was below the minimum. 8316 min -= 1.1; 8317 } else if (typeof(snap) === "function") { 8318 vars.end = function(value) { 8319 var result = snap.call(draggable, value), 8320 copy, p; 8321 if (factor !== 1) { 8322 if (typeof(result) === "object") { 8323 copy = {}; 8324 for (p in result) { 8325 copy[p] = result[p] * factor; 8326 } 8327 result = copy; 8328 } else { 8329 result *= factor; 8330 } 8331 } 8332 return result; //we need to ensure that we can scope the function call to the Draggable instance itself so that users can access important values like maxX, minX, maxY, minY, x, and y from within that function. 8333 }; 8334 } else { 8335 vars.end = snap; 8336 } 8337 } 8338 if (max || max === 0) { 8339 vars.max = max; 8340 } 8341 if (min || min === 0) { 8342 vars.min = min; 8343 } 8344 if (forceZeroVelocity) { 8345 vars.velocity = 0; 8346 } 8347 return vars; 8348 }, 8349 8350 _isClickable = function(e) { //sometimes it's convenient to mark an element as clickable by adding a data-clickable="true" attribute (in which case we won't preventDefault() the mouse/touch event). This method checks if the element is an <a>, <input>, or <button> or has an onclick or has the data-clickable or contentEditable attribute set to true (or any of its parent elements). 8351 var data; 8352 return (!e || !e.getAttribute || e.nodeName === "BODY") ? false : ((data = e.getAttribute("data-clickable")) === "true" || (data !== "false" && (e.onclick || _clickableTagExp.test(e.nodeName + "") || e.getAttribute("contentEditable") === "true"))) ? true : _isClickable(e.parentNode); 8353 }, 8354 8355 _setSelectable = function(elements, selectable) { 8356 var i = elements.length, 8357 e; 8358 while (--i > -1) { 8359 e = elements[i]; 8360 e.ondragstart = e.onselectstart = selectable ? null : _emptyFunc; 8361 _setStyle(e, "userSelect", (selectable ? "text" : "none")); 8362 } 8363 }, 8364 8365 _addPaddingBR = (function() { //this function is in charge of analyzing browser behavior related to padding. It sets the _addPaddingBR to true if the browser doesn't normally factor in the bottom or right padding on the element inside the scrolling area, and it sets _addPaddingLeft to true if it's a browser that requires the extra offset (offsetLeft) to be added to the paddingRight (like Opera). 8366 var div = _doc.createElement("div"), 8367 child = _doc.createElement("div"), 8368 childStyle = child.style, 8369 parent = _doc.body || _tempDiv, 8370 val; 8371 childStyle.display = "inline-block"; 8372 childStyle.position = "relative"; 8373 div.style.cssText = child.innerHTML = "width:90px; height:40px; padding:10px; overflow:auto; visibility: hidden"; 8374 div.appendChild(child); 8375 parent.appendChild(div); 8376 val = (child.offsetHeight + 18 > div.scrollHeight); //div.scrollHeight should be child.offsetHeight + 20 because of the 10px of padding on each side, but some browsers ignore one side. We allow a 2px margin of error. 8377 parent.removeChild(div); 8378 return val; 8379 }()), 8380 8381 8382 8383 8384 //The ScrollProxy class wraps an element's contents into another div (we call it "content") that we either add padding when necessary or apply a translate3d() transform in order to overscroll (scroll past the boundaries). This allows us to simply set the scrollTop/scrollLeft (or top/left for easier reverse-axis orientation, which is what we do in Draggable) and it'll do all the work for us. For example, if we tried setting scrollTop to -100 on a normal DOM element, it wouldn't work - it'd look the same as setting it to 0, but if we set scrollTop of a ScrollProxy to -100, it'll give the correct appearance by either setting paddingTop of the wrapper to 100 or applying a 100-pixel translateY. 8385 ScrollProxy = function(element, vars) { 8386 element = _unwrapElement(element); 8387 vars = vars || {}; 8388 var content = _doc.createElement("div"), 8389 style = content.style, 8390 node = element.firstChild, 8391 offsetTop = 0, 8392 offsetLeft = 0, 8393 prevTop = element.scrollTop, 8394 prevLeft = element.scrollLeft, 8395 scrollWidth = element.scrollWidth, 8396 scrollHeight = element.scrollHeight, 8397 extraPadRight = 0, 8398 maxLeft = 0, 8399 maxTop = 0, 8400 elementWidth, elementHeight, contentHeight, nextNode, transformStart, transformEnd; 8401 8402 if (_supports3D && vars.force3D !== false) { 8403 transformStart = "translate3d("; 8404 transformEnd = "px,0px)"; 8405 } else if (_transformProp) { 8406 transformStart = "translate("; 8407 transformEnd = "px)"; 8408 } 8409 8410 this.scrollTop = function(value, force) { 8411 if (!arguments.length) { 8412 return -this.top(); 8413 } 8414 this.top(-value, force); 8415 }; 8416 8417 this.scrollLeft = function(value, force) { 8418 if (!arguments.length) { 8419 return -this.left(); 8420 } 8421 this.left(-value, force); 8422 }; 8423 8424 this.left = function(value, force) { 8425 if (!arguments.length) { 8426 return -(element.scrollLeft + offsetLeft); 8427 } 8428 var dif = element.scrollLeft - prevLeft, 8429 oldOffset = offsetLeft; 8430 if ((dif > 2 || dif < -2) && !force) { //if the user interacts with the scrollbar (or something else scrolls it, like the mouse wheel), we should kill any tweens of the ScrollProxy. 8431 prevLeft = element.scrollLeft; 8432 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].killTweensOf(this, true, {left:1, scrollLeft:1}); 8433 this.left(-prevLeft); 8434 if (vars.onKill) { 8435 vars.onKill(); 8436 } 8437 return; 8438 } 8439 value = -value; //invert because scrolling works in the opposite direction 8440 if (value < 0) { 8441 offsetLeft = (value - 0.5) | 0; 8442 value = 0; 8443 } else if (value > maxLeft) { 8444 offsetLeft = (value - maxLeft) | 0; 8445 value = maxLeft; 8446 } else { 8447 offsetLeft = 0; 8448 } 8449 if (offsetLeft || oldOffset) { 8450 if (transformStart) { 8451 if (!this._suspendTransforms) { 8452 style[_transformProp] = transformStart + -offsetLeft + "px," + -offsetTop + transformEnd; 8453 } 8454 } else { 8455 style.left = -offsetLeft + "px"; 8456 } 8457 if (offsetLeft + extraPadRight >= 0) { 8458 style.paddingRight = offsetLeft + extraPadRight + "px"; 8459 } 8460 } 8461 element.scrollLeft = value | 0; 8462 prevLeft = element.scrollLeft; //don't merge this with the line above because some browsers adjsut the scrollLeft after it's set, so in order to be 100% accurate in tracking it, we need to ask the browser to report it. 8463 }; 8464 8465 this.top = function(value, force) { 8466 if (!arguments.length) { 8467 return -(element.scrollTop + offsetTop); 8468 } 8469 var dif = element.scrollTop - prevTop, 8470 oldOffset = offsetTop; 8471 if ((dif > 2 || dif < -2) && !force) { //if the user interacts with the scrollbar (or something else scrolls it, like the mouse wheel), we should kill any tweens of the ScrollProxy. 8472 prevTop = element.scrollTop; 8473 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].killTweensOf(this, true, {top:1, scrollTop:1}); 8474 this.top(-prevTop); 8475 if (vars.onKill) { 8476 vars.onKill(); 8477 } 8478 return; 8479 } 8480 value = -value; //invert because scrolling works in the opposite direction 8481 if (value < 0) { 8482 offsetTop = (value - 0.5) | 0; 8483 value = 0; 8484 } else if (value > maxTop) { 8485 offsetTop = (value - maxTop) | 0; 8486 value = maxTop; 8487 } else { 8488 offsetTop = 0; 8489 } 8490 if (offsetTop || oldOffset) { 8491 if (transformStart) { 8492 if (!this._suspendTransforms) { 8493 style[_transformProp] = transformStart + -offsetLeft + "px," + -offsetTop + transformEnd; 8494 } 8495 } else { 8496 style.top = -offsetTop + "px"; 8497 } 8498 } 8499 element.scrollTop = value | 0; 8500 prevTop = element.scrollTop; 8501 }; 8502 8503 this.maxScrollTop = function() { 8504 return maxTop; 8505 }; 8506 8507 this.maxScrollLeft = function() { 8508 return maxLeft; 8509 }; 8510 8511 this.disable = function() { 8512 node = content.firstChild; 8513 while (node) { 8514 nextNode = node.nextSibling; 8515 element.appendChild(node); 8516 node = nextNode; 8517 } 8518 if (element === content.parentNode) { //in case disable() is called when it's already disabled. 8519 element.removeChild(content); 8520 } 8521 }; 8522 8523 this.enable = function() { 8524 node = element.firstChild; 8525 if (node === content) { 8526 return; 8527 } 8528 while (node) { 8529 nextNode = node.nextSibling; 8530 content.appendChild(node); 8531 node = nextNode; 8532 } 8533 element.appendChild(content); 8534 this.calibrate(); 8535 }; 8536 8537 this.calibrate = function(force) { 8538 var widthMatches = (element.clientWidth === elementWidth), 8539 x, y; 8540 prevTop = element.scrollTop; 8541 prevLeft = element.scrollLeft; 8542 if (widthMatches && element.clientHeight === elementHeight && content.offsetHeight === contentHeight && scrollWidth === element.scrollWidth && scrollHeight === element.scrollHeight && !force) { 8543 return; //no need to recalculate things if the width and height haven't changed. 8544 } 8545 if (offsetTop || offsetLeft) { 8546 x = this.left(); 8547 y = this.top(); 8548 this.left(-element.scrollLeft); 8549 this.top(-element.scrollTop); 8550 } 8551 //first, we need to remove any width constraints to see how the content naturally flows so that we can see if it's wider than the containing element. If so, we've got to record the amount of overage so that we can apply that as padding in order for browsers to correctly handle things. Then we switch back to a width of 100% (without that, some browsers don't flow the content correctly) 8552 if (!widthMatches || force) { 8553 style.display = "block"; 8554 style.width = "auto"; 8555 style.paddingRight = "0px"; 8556 extraPadRight = Math.max(0, element.scrollWidth - element.clientWidth); 8557 //if the content is wider than the container, we need to add the paddingLeft and paddingRight in order for things to behave correctly. 8558 if (extraPadRight) { 8559 extraPadRight += _getStyle(element, "paddingLeft") + (_addPaddingBR ? _getStyle(element, "paddingRight") : 0); 8560 } 8561 } 8562 style.display = "inline-block"; 8563 style.position = "relative"; 8564 style.overflow = "visible"; 8565 style.verticalAlign = "top"; 8566 style.width = "100%"; 8567 style.paddingRight = extraPadRight + "px"; 8568 //some browsers neglect to factor in the bottom padding when calculating the scrollHeight, so we need to add that padding to the content when that happens. Allow a 2px margin for error 8569 if (_addPaddingBR) { 8570 style.paddingBottom = _getStyle(element, "paddingBottom", true); 8571 } 8572 if (_isOldIE) { 8573 style.zoom = "1"; 8574 } 8575 elementWidth = element.clientWidth; 8576 elementHeight = element.clientHeight; 8577 scrollWidth = element.scrollWidth; 8578 scrollHeight = element.scrollHeight; 8579 maxLeft = element.scrollWidth - elementWidth; 8580 maxTop = element.scrollHeight - elementHeight; 8581 contentHeight = content.offsetHeight; 8582 style.display = "block"; 8583 if (x || y) { 8584 this.left(x); 8585 this.top(y); 8586 } 8587 }; 8588 8589 this.content = content; 8590 this.element = element; 8591 this._suspendTransforms = false; 8592 this.enable(); 8593 }, 8594 8595 8596 8597 8598 8599 Draggable = function(target, vars) { 8600 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["EventDispatcher"].call(this, target); 8601 target = _unwrapElement(target); //in case the target is a selector object or selector text 8602 if (!ThrowPropsPlugin) { 8603 ThrowPropsPlugin = _globals.com.greensock.plugins.ThrowPropsPlugin; 8604 } 8605 this.vars = vars = _copy(vars || {}); 8606 this.target = target; 8607 this.x = this.y = this.rotation = 0; 8608 this.dragResistance = parseFloat(vars.dragResistance) || 0; 8609 this.edgeResistance = isNaN(vars.edgeResistance) ? 1 : parseFloat(vars.edgeResistance) || 0; 8610 this.lockAxis = vars.lockAxis; 8611 this.autoScroll = vars.autoScroll || 0; 8612 this.lockedAxis = null; 8613 this.allowEventDefault = !!vars.allowEventDefault; 8614 var type = (vars.type || (_isOldIE ? "top,left" : "x,y")).toLowerCase(), 8615 xyMode = (type.indexOf("x") !== -1 || type.indexOf("y") !== -1), 8616 rotationMode = (type.indexOf("rotation") !== -1), 8617 xProp = rotationMode ? "rotation" : xyMode ? "x" : "left", 8618 yProp = xyMode ? "y" : "top", 8619 allowX = (type.indexOf("x") !== -1 || type.indexOf("left") !== -1 || type === "scroll"), 8620 allowY = (type.indexOf("y") !== -1 || type.indexOf("top") !== -1 || type === "scroll"), 8621 minimumMovement = vars.minimumMovement || 2, 8622 self = this, 8623 triggers = _slice(vars.trigger || vars.handle || target), 8624 killProps = {}, 8625 dragEndTime = 0, 8626 checkAutoScrollBounds = false, 8627 autoScrollMarginTop = vars.autoScrollMarginTop || 40, 8628 autoScrollMarginRight = vars.autoScrollMarginRight || 40, 8629 autoScrollMarginBottom = vars.autoScrollMarginBottom || 40, 8630 autoScrollMarginLeft = vars.autoScrollMarginLeft || 40, 8631 isClickable = vars.clickableTest || _isClickable, 8632 clickTime = 0, 8633 enabled, scrollProxy, startPointerX, startPointerY, startElementX, startElementY, hasBounds, hasDragCallback, maxX, minX, maxY, minY, tempVars, cssVars, touch, touchID, rotationOrigin, dirty, old, snapX, snapY, snapXY, isClicking, touchEventTarget, matrix, interrupted, startScrollTop, startScrollLeft, applyObj, allowNativeTouchScrolling, touchDragAxis, isDispatching, clickDispatch, trustedClickDispatch, 8634 8635 onContextMenu = function(e) { //used to prevent long-touch from triggering a context menu. 8636 if (self.isPressed && e.which < 2) { 8637 self.endDrag(); 8638 } else { 8639 e.preventDefault(); 8640 e.stopPropagation(); 8641 return false; 8642 } 8643 }, 8644 8645 //this method gets called on every tick of TweenLite.ticker which allows us to synchronize the renders to the core engine (which is typically synchronized with the display refresh via requestAnimationFrame). This is an optimization - it's better than applying the values inside the "mousemove" or "touchmove" event handler which may get called many times inbetween refreshes. 8646 render = function(suppressEvents) { 8647 if (self.autoScroll && self.isDragging && (checkAutoScrollBounds || dirty)) { 8648 var e = target, 8649 autoScrollFactor = self.autoScroll * 15, //multiplying by 15 just gives us a better "feel" speed-wise. 8650 parent, isRoot, rect, pointerX, pointerY, changeX, changeY, gap; 8651 checkAutoScrollBounds = false; 8652 _windowProxy.scrollTop = ((window.pageYOffset != null) ? window.pageYOffset : (_docElement.scrollTop != null) ? _docElement.scrollTop : _doc.body.scrollTop); 8653 _windowProxy.scrollLeft = ((window.pageXOffset != null) ? window.pageXOffset : (_docElement.scrollLeft != null) ? _docElement.scrollLeft : _doc.body.scrollLeft); 8654 pointerX = self.pointerX - _windowProxy.scrollLeft; 8655 pointerY = self.pointerY - _windowProxy.scrollTop; 8656 while (e && !isRoot) { //walk up the chain and sense wherever the pointer is within 40px of an edge that's scrollable. 8657 isRoot = _isRoot(e.parentNode); 8658 parent = isRoot ? _windowProxy : e.parentNode; 8659 rect = isRoot ? {bottom:Math.max(_docElement.clientHeight, window.innerHeight || 0), right: Math.max(_docElement.clientWidth, window.innerWidth || 0), left:0, top:0} : parent.getBoundingClientRect(); 8660 changeX = changeY = 0; 8661 if (allowY) { 8662 gap = parent._gsMaxScrollY - parent.scrollTop; 8663 if (gap < 0) { 8664 changeY = gap; 8665 } else if (pointerY > rect.bottom - autoScrollMarginBottom && gap) { 8666 checkAutoScrollBounds = true; 8667 changeY = Math.min(gap, (autoScrollFactor * (1 - Math.max(0, (rect.bottom - pointerY)) / autoScrollMarginBottom)) | 0); 8668 } else if (pointerY < rect.top + autoScrollMarginTop && parent.scrollTop) { 8669 checkAutoScrollBounds = true; 8670 changeY = -Math.min(parent.scrollTop, (autoScrollFactor * (1 - Math.max(0, (pointerY - rect.top)) / autoScrollMarginTop)) | 0); 8671 } 8672 if (changeY) { 8673 parent.scrollTop += changeY; 8674 } 8675 } 8676 if (allowX) { 8677 gap = parent._gsMaxScrollX - parent.scrollLeft; 8678 if (gap < 0) { 8679 changeX = gap; 8680 } else if (pointerX > rect.right - autoScrollMarginRight && gap) { 8681 checkAutoScrollBounds = true; 8682 changeX = Math.min(gap, (autoScrollFactor * (1 - Math.max(0, (rect.right - pointerX)) / autoScrollMarginRight)) | 0); 8683 } else if (pointerX < rect.left + autoScrollMarginLeft && parent.scrollLeft) { 8684 checkAutoScrollBounds = true; 8685 changeX = -Math.min(parent.scrollLeft, (autoScrollFactor * (1 - Math.max(0, (pointerX - rect.left)) / autoScrollMarginLeft)) | 0); 8686 } 8687 if (changeX) { 8688 parent.scrollLeft += changeX; 8689 } 8690 } 8691 8692 if (isRoot && (changeX || changeY)) { 8693 window.scrollTo(parent.scrollLeft, parent.scrollTop); 8694 setPointerPosition(self.pointerX + changeX, self.pointerY + changeY); 8695 } 8696 e = parent; 8697 } 8698 } 8699 if (dirty) { 8700 var x = self.x, 8701 y = self.y, 8702 min = 0.000001; 8703 if (x < min && x > -min) { //browsers don't handle super small decimals well. 8704 x = 0; 8705 } 8706 if (y < min && y > -min) { 8707 y = 0; 8708 } 8709 if (rotationMode) { 8710 self.deltaX = x - applyObj.data.rotation; 8711 applyObj.data.rotation = self.rotation = x; 8712 applyObj.setRatio(1); //note: instead of doing TweenLite.set(), as a performance optimization we skip right to the method that renders the transforms inside CSSPlugin. For old versions of IE, though, we do a normal TweenLite.set() to leverage its ability to re-reroute to an IE-specific 2D renderer. 8713 } else { 8714 if (scrollProxy) { 8715 if (allowY) { 8716 self.deltaY = y - scrollProxy.top(); 8717 scrollProxy.top(y); 8718 } 8719 if (allowX) { 8720 self.deltaX = x - scrollProxy.left(); 8721 scrollProxy.left(x); 8722 } 8723 } else if (xyMode) { 8724 if (allowY) { 8725 self.deltaY = y - applyObj.data.y; 8726 applyObj.data.y = y; 8727 } 8728 if (allowX) { 8729 self.deltaX = x - applyObj.data.x; 8730 applyObj.data.x = x; 8731 } 8732 applyObj.setRatio(1); //note: instead of doing TweenLite.set(), as a performance optimization we skip right to the method that renders the transforms inside CSSPlugin. For old versions of IE, though, we do a normal TweenLite.set() to leverage its ability to re-reroute to an IE-specific 2D renderer. 8733 } else { 8734 if (allowY) { 8735 self.deltaY = y - parseFloat(target.style.top || 0); 8736 target.style.top = y + "px"; 8737 } 8738 if (allowX) { 8739 self.deltaY = x - parseFloat(target.style.left || 0); 8740 target.style.left = x + "px"; 8741 } 8742 } 8743 } 8744 if (hasDragCallback && !suppressEvents && !isDispatching) { 8745 isDispatching = true; //in case onDrag has an update() call (avoid endless loop) 8746 _dispatchEvent(self, "drag", "onDrag"); 8747 isDispatching = false; 8748 } 8749 } 8750 dirty = false; 8751 }, 8752 8753 //copies the x/y from the element (whether that be transforms, top/left, or ScrollProxy's top/left) to the Draggable's x and y (and rotation if necessary) properties so that they reflect reality and it also (optionally) applies any snapping necessary. This is used by the ThrowPropsPlugin tween in an onUpdate to ensure things are synced and snapped. 8754 syncXY = function(skipOnUpdate, skipSnap) { 8755 var x = self.x, 8756 y = self.y, 8757 snappedValue; 8758 if (!target._gsTransform && (xyMode || rotationMode)) { //just in case the _gsTransform got wiped, like if the user called clearProps on the transform or something (very rare), doing an x tween forces a re-parsing of the transforms and population of the _gsTransform. 8759 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].set(target, {x:"+=0", overwrite:false, data:"_draggable"}); 8760 } 8761 if (xyMode) { 8762 self.y = target._gsTransform.y; 8763 self.x = target._gsTransform.x; 8764 } else if (rotationMode) { 8765 self.x = self.rotation = target._gsTransform.rotation; 8766 } else if (scrollProxy) { 8767 self.y = scrollProxy.top(); 8768 self.x = scrollProxy.left(); 8769 } else { 8770 self.y = parseInt(target.style.top, 10) || 0; 8771 self.x = parseInt(target.style.left, 10) || 0; 8772 } 8773 if ((snapX || snapY || snapXY) && !skipSnap && (self.isDragging || self.isThrowing)) { 8774 if (snapXY) { 8775 _temp1.x = self.x; 8776 _temp1.y = self.y; 8777 snappedValue = snapXY(_temp1); 8778 if (snappedValue.x !== self.x) { 8779 self.x = snappedValue.x; 8780 dirty = true; 8781 } 8782 if (snappedValue.y !== self.y) { 8783 self.y = snappedValue.y; 8784 dirty = true; 8785 } 8786 } 8787 if (snapX) { 8788 snappedValue = snapX(self.x); 8789 if (snappedValue !== self.x) { 8790 self.x = snappedValue; 8791 if (rotationMode) { 8792 self.rotation = snappedValue; 8793 } 8794 dirty = true; 8795 } 8796 } 8797 if (snapY) { 8798 snappedValue = snapY(self.y); 8799 if (snappedValue !== self.y) { 8800 self.y = snappedValue; 8801 } 8802 dirty = true; 8803 } 8804 } 8805 if (dirty) { 8806 render(true); 8807 } 8808 if (!skipOnUpdate) { 8809 self.deltaX = self.x - x; 8810 self.deltaY = self.y - y; 8811 _dispatchEvent(self, "throwupdate", "onThrowUpdate"); 8812 } 8813 }, 8814 8815 calculateBounds = function() { 8816 var bounds, targetBounds, snap, snapIsRaw; 8817 hasBounds = false; 8818 if (scrollProxy) { 8819 scrollProxy.calibrate(); 8820 self.minX = minX = -scrollProxy.maxScrollLeft(); 8821 self.minY = minY = -scrollProxy.maxScrollTop(); 8822 self.maxX = maxX = self.maxY = maxY = 0; 8823 hasBounds = true; 8824 } else if (!!vars.bounds) { 8825 bounds = _getBounds(vars.bounds, target.parentNode); //could be a selector/jQuery object or a DOM element or a generic object like {top:0, left:100, width:1000, height:800} or {minX:100, maxX:1100, minY:0, maxY:800} 8826 if (rotationMode) { 8827 self.minX = minX = bounds.left; 8828 self.maxX = maxX = bounds.left + bounds.width; 8829 self.minY = minY = self.maxY = maxY = 0; 8830 } else if (vars.bounds.maxX !== undefined || vars.bounds.maxY !== undefined) { 8831 bounds = vars.bounds; 8832 self.minX = minX = bounds.minX; 8833 self.minY = minY = bounds.minY; 8834 self.maxX = maxX = bounds.maxX; 8835 self.maxY = maxY = bounds.maxY; 8836 } else { 8837 targetBounds = _getBounds(target, target.parentNode); 8838 self.minX = minX = _getStyle(target, xProp) + bounds.left - targetBounds.left; 8839 self.minY = minY = _getStyle(target, yProp) + bounds.top - targetBounds.top; 8840 self.maxX = maxX = minX + (bounds.width - targetBounds.width); 8841 self.maxY = maxY = minY + (bounds.height - targetBounds.height); 8842 } 8843 if (minX > maxX) { 8844 self.minX = maxX; 8845 self.maxX = maxX = minX; 8846 minX = self.minX; 8847 } 8848 if (minY > maxY) { 8849 self.minY = maxY; 8850 self.maxY = maxY = minY; 8851 minY = self.minY; 8852 } 8853 if (rotationMode) { 8854 self.minRotation = minX; 8855 self.maxRotation = maxX; 8856 } 8857 hasBounds = true; 8858 } 8859 if (vars.liveSnap) { 8860 snap = (vars.liveSnap === true) ? (vars.snap || {}) : vars.liveSnap; 8861 snapIsRaw = (snap instanceof Array || typeof(snap) === "function"); 8862 if (rotationMode) { 8863 snapX = buildSnapFunc((snapIsRaw ? snap : snap.rotation), minX, maxX, 1); 8864 snapY = null; 8865 } else { 8866 if (snap.points) { 8867 snapXY = buildPointSnapFunc((snapIsRaw ? snap : snap.points), minX, maxX, minY, maxY, snap.radius, scrollProxy ? -1 : 1); 8868 } else { 8869 if (allowX) { 8870 snapX = buildSnapFunc((snapIsRaw ? snap : snap.x || snap.left || snap.scrollLeft), minX, maxX, scrollProxy ? -1 : 1); 8871 } 8872 if (allowY) { 8873 snapY = buildSnapFunc((snapIsRaw ? snap : snap.y || snap.top || snap.scrollTop), minY, maxY, scrollProxy ? -1 : 1); 8874 } 8875 } 8876 } 8877 } 8878 8879 }, 8880 8881 onThrowComplete = function() { 8882 self.isThrowing = false; 8883 _dispatchEvent(self, "throwcomplete", "onThrowComplete"); 8884 }, 8885 onThrowOverwrite = function() { 8886 self.isThrowing = false; 8887 }, 8888 8889 animate = function(throwProps, forceZeroVelocity) { 8890 var snap, snapIsRaw, tween, overshootTolerance; 8891 if (throwProps && ThrowPropsPlugin) { 8892 if (throwProps === true) { 8893 snap = vars.snap || vars.liveSnap || {}; 8894 snapIsRaw = (snap instanceof Array || typeof(snap) === "function"); 8895 throwProps = {resistance:(vars.throwResistance || vars.resistance || 1000) / (rotationMode ? 10 : 1)}; 8896 if (rotationMode) { 8897 throwProps.rotation = _parseThrowProps(self, snapIsRaw ? snap : snap.rotation, maxX, minX, 1, forceZeroVelocity); 8898 } else { 8899 if (allowX) { 8900 throwProps[xProp] = _parseThrowProps(self, snapIsRaw ? snap : snap.points || snap.x || snap.left || snap.scrollLeft, maxX, minX, scrollProxy ? -1 : 1, forceZeroVelocity || (self.lockedAxis === "x")); 8901 } 8902 if (allowY) { 8903 throwProps[yProp] = _parseThrowProps(self, snapIsRaw ? snap : snap.points || snap.y || snap.top || snap.scrollTop, maxY, minY, scrollProxy ? -1 : 1, forceZeroVelocity || (self.lockedAxis === "y")); 8904 } 8905 if (snap.points || (snap instanceof Array && typeof(snap[0]) === "object")) { 8906 throwProps.linkedProps = xProp + "," + yProp; 8907 throwProps.radius = snap.radius; //note: we also disable liveSnapping while throwing if there's a "radius" defined, otherwise it looks weird to have the item thrown past a snapping point but live-snapping mid-tween. We do this by altering the onUpdateParams so that "skipSnap" parameter is true for syncXY. 8908 } 8909 } 8910 } 8911 self.isThrowing = true; 8912 overshootTolerance = (!isNaN(vars.overshootTolerance)) ? vars.overshootTolerance : (vars.edgeResistance === 1) ? 0 : (1 - self.edgeResistance) + 0.2; 8913 self.tween = tween = ThrowPropsPlugin.to(scrollProxy || target, {throwProps:throwProps, data:"_draggable", ease:(vars.ease || _globals.Power3.easeOut), onComplete:onThrowComplete, onOverwrite:onThrowOverwrite, onUpdate:(vars.fastMode ? _dispatchEvent : syncXY), onUpdateParams:(vars.fastMode ? [self, "onthrowupdate", "onThrowUpdate"] : (snap && snap.radius) ? [false, true] : _emptyArray)}, Math.max(vars.minDuration || 0, vars.maxDuration || 0) || 2, (!isNaN(vars.minDuration) ? vars.minDuration : (overshootTolerance === 0 || (typeof(throwProps) === "object" && throwProps.resistance > 1000)) ? 0 : 0.5), overshootTolerance); 8914 if (!vars.fastMode) { 8915 //to populate the end values, we just scrub the tween to the end, record the values, and then jump back to the beginning. 8916 if (scrollProxy) { 8917 scrollProxy._suspendTransforms = true; //Microsoft browsers have a bug that causes them to briefly render the position incorrectly (it flashes to the end state when we seek() the tween even though we jump right back to the current position, and this only seems to happen when we're affecting both top and left), so we set a _suspendTransforms flag to prevent it from actually applying the values in the ScrollProxy. 8918 } 8919 tween.render(tween.duration(), true, true); 8920 syncXY(true, true); 8921 self.endX = self.x; 8922 self.endY = self.y; 8923 if (rotationMode) { 8924 self.endRotation = self.x; 8925 } 8926 tween.play(0); 8927 syncXY(true, true); 8928 if (scrollProxy) { 8929 scrollProxy._suspendTransforms = false; 8930 } 8931 } 8932 } else if (hasBounds) { 8933 self.applyBounds(); 8934 } 8935 }, 8936 8937 updateMatrix = function(shiftStart) { 8938 var start = matrix || [1,0,0,1,0,0], 8939 a, b, c, d, tx, ty, determinant, pointerX, pointerY; 8940 matrix = _getConcatenatedMatrix(target.parentNode, true); 8941 if (shiftStart && self.isPressed && start.join(",") !== matrix.join(",")) { //if the matrix changes WHILE the element is pressed, we must adjust the startPointerX and startPointerY accordingly, so we invert the original matrix and figure out where the pointerX and pointerY were in the global space, then apply the new matrix to get the updated coordinates. 8942 a = start[0]; 8943 b = start[1]; 8944 c = start[2]; 8945 d = start[3]; 8946 tx = start[4]; 8947 ty = start[5]; 8948 determinant = (a * d - b * c); 8949 pointerX = startPointerX * (d / determinant) + startPointerY * (-c / determinant) + ((c * ty - d * tx) / determinant); 8950 pointerY = startPointerX * (-b / determinant) + startPointerY * (a / determinant) + (-(a * ty - b * tx) / determinant); 8951 startPointerY = pointerX * matrix[1] + pointerY * matrix[3] + matrix[5]; 8952 startPointerX = pointerX * matrix[0] + pointerY * matrix[2] + matrix[4]; 8953 } 8954 if (!matrix[1] && !matrix[2] && matrix[0] == 1 && matrix[3] == 1 && matrix[4] == 0 && matrix[5] == 0) { //if there are no transforms, we can optimize performance by not factoring in the matrix 8955 matrix = null; 8956 } 8957 8958 }, 8959 8960 recordStartPositions = function() { 8961 var edgeTolerance = 1 - self.edgeResistance; 8962 updateMatrix(false); 8963 if (matrix) { 8964 startPointerX = self.pointerX * matrix[0] + self.pointerY * matrix[2] + matrix[4]; //translate to local coordinate system 8965 startPointerY = self.pointerX * matrix[1] + self.pointerY * matrix[3] + matrix[5]; 8966 } 8967 if (dirty) { 8968 setPointerPosition(self.pointerX, self.pointerY); 8969 render(true); 8970 } 8971 if (scrollProxy) { 8972 calculateBounds(); 8973 startElementY = scrollProxy.top(); 8974 startElementX = scrollProxy.left(); 8975 } else { 8976 //if the element is in the process of tweening, don't force snapping to occur because it could make it jump. Imagine the user throwing, then before it's done, clicking on the element in its inbetween state. 8977 if (isTweening()) { 8978 syncXY(true, true); 8979 calculateBounds(); 8980 } else { 8981 self.applyBounds(); 8982 } 8983 if (rotationMode) { 8984 rotationOrigin = self.rotationOrigin = _localToGlobal(target, {x:0, y:0}); 8985 syncXY(true, true); 8986 startElementX = self.x; //starting rotation (x always refers to rotation in type:"rotation", measured in degrees) 8987 startElementY = self.y = Math.atan2(rotationOrigin.y - self.pointerY, self.pointerX - rotationOrigin.x) * _RAD2DEG; 8988 } else { 8989 startScrollTop = target.parentNode ? target.parentNode.scrollTop || 0 : 0; 8990 startScrollLeft = target.parentNode ? target.parentNode.scrollLeft || 0 : 0; 8991 startElementY = _getStyle(target, yProp); //record the starting top and left values so that we can just add the mouse's movement to them later. 8992 startElementX = _getStyle(target, xProp); 8993 } 8994 } 8995 if (hasBounds && edgeTolerance) { 8996 if (startElementX > maxX) { 8997 startElementX = maxX + (startElementX - maxX) / edgeTolerance; 8998 } else if (startElementX < minX) { 8999 startElementX = minX - (minX - startElementX) / edgeTolerance; 9000 } 9001 if (!rotationMode) { 9002 if (startElementY > maxY) { 9003 startElementY = maxY + (startElementY - maxY) / edgeTolerance; 9004 } else if (startElementY < minY) { 9005 startElementY = minY - (minY - startElementY) / edgeTolerance; 9006 } 9007 } 9008 } 9009 self.startX = startElementX; 9010 self.startY = startElementY; 9011 }, 9012 9013 isTweening = function() { 9014 return (self.tween && self.tween.isActive()); 9015 }, 9016 9017 removePlaceholder = function() { 9018 if (_placeholderDiv.parentNode && !isTweening() && !self.isDragging) { //_placeholderDiv just props open auto-scrolling containers so they don't collapse as the user drags left/up. We remove it after dragging (and throwing, if necessary) finishes. 9019 _placeholderDiv.parentNode.removeChild(_placeholderDiv); 9020 } 9021 }, 9022 9023 buildSnapFunc = function(snap, min, max, factor) { 9024 if (min == null) { 9025 min = -_max; 9026 } 9027 if (max == null) { 9028 max = _max; 9029 } 9030 if (typeof(snap) === "function") { 9031 return function(n) { 9032 var edgeTolerance = !self.isPressed ? 1 : 1 - self.edgeResistance; //if we're tweening, disable the edgeTolerance because it's already factored into the tweening values (we don't want to apply it multiple times) 9033 return snap.call(self, (n > max ? max + (n - max) * edgeTolerance : (n < min) ? min + (n - min) * edgeTolerance : n)) * factor; 9034 }; 9035 } 9036 if (snap instanceof Array) { 9037 return function(n) { 9038 var i = snap.length, 9039 closest = 0, 9040 absDif = _max, 9041 val, dif; 9042 while (--i > -1) { 9043 val = snap[i]; 9044 dif = val - n; 9045 if (dif < 0) { 9046 dif = -dif; 9047 } 9048 if (dif < absDif && val >= min && val <= max) { 9049 closest = i; 9050 absDif = dif; 9051 } 9052 } 9053 return snap[closest]; 9054 }; 9055 } 9056 return isNaN(snap) ? function(n) { return n; } : function() { return snap * factor; }; 9057 }, 9058 9059 buildPointSnapFunc = function(snap, minX, maxX, minY, maxY, radius, factor) { 9060 radius = (radius && radius < _max) ? radius * radius : _max; //so we don't have to Math.sqrt() in the functions. Performance optimization. 9061 if (typeof(snap) === "function") { 9062 return function(point) { 9063 var edgeTolerance = !self.isPressed ? 1 : 1 - self.edgeResistance, 9064 x = point.x, 9065 y = point.y, 9066 result, dx, dy; //if we're tweening, disable the edgeTolerance because it's already factored into the tweening values (we don't want to apply it multiple times) 9067 point.x = x = (x > maxX ? maxX + (x - maxX) * edgeTolerance : (x < minX) ? minX + (x - minX) * edgeTolerance : x); 9068 point.y = y = (y > maxY ? maxY + (y - maxY) * edgeTolerance : (y < minY) ? minY + (y - minY) * edgeTolerance : y); 9069 result = snap.call(self, point); 9070 if (result !== point) { 9071 point.x = result.x; 9072 point.y = result.y; 9073 } 9074 if (factor !== 1) { 9075 point.x *= factor; 9076 point.y *= factor; 9077 } 9078 if (radius < _max) { 9079 dx = point.x - x; 9080 dy = point.y - y; 9081 if (dx * dx + dy * dy > radius) { 9082 point.x = x; 9083 point.y = y; 9084 } 9085 } 9086 return point; 9087 }; 9088 } 9089 if (snap instanceof Array) { 9090 return function(p) { 9091 var i = snap.length, 9092 closest = 0, 9093 minDist = _max, 9094 x, y, point, dist; 9095 while (--i > -1) { 9096 point = snap[i]; 9097 x = point.x - p.x; 9098 y = point.y - p.y; 9099 dist = x * x + y * y; 9100 if (dist < minDist) { 9101 closest = i; 9102 minDist = dist; 9103 } 9104 } 9105 return (minDist <= radius) ? snap[closest] : p; 9106 }; 9107 } 9108 return function(n) { return n; }; 9109 }, 9110 9111 //called when the mouse is pressed (or touch starts) 9112 onPress = function(e, force) { 9113 var i; 9114 if (!enabled || self.isPressed || !e || ((e.type === "mousedown" || e.type === "pointerdown") && !force && _getTime() - clickTime < 30 && _touchEventLookup[self.pointerEvent.type])) { //when we DON'T preventDefault() in order to accommodate touch-scrolling and the user just taps, many browsers also fire a mousedown/mouseup sequence AFTER the touchstart/touchend sequence, thus it'd result in two quick "click" events being dispatched. This line senses that condition and halts it on the subsequent mousedown. 9115 return; 9116 } 9117 interrupted = isTweening(); 9118 self.pointerEvent = e; 9119 if (_touchEventLookup[e.type]) { //note: on iOS, BOTH touchmove and mousemove are dispatched, but the mousemove has pageY and pageX of 0 which would mess up the calculations and needlessly hurt performance. 9120 touchEventTarget = (e.type.indexOf("touch") !== -1) ? (e.currentTarget || e.target) : _doc; //pointer-based touches (for Microsoft browsers) don't remain locked to the original target like other browsers, so we must use the document instead. The event type would be "MSPointerDown" or "pointerdown". 9121 _addListener(touchEventTarget, "touchend", onRelease); 9122 _addListener(touchEventTarget, "touchmove", onMove); 9123 _addListener(touchEventTarget, "touchcancel", onRelease); 9124 _addListener(_doc, "touchstart", _onMultiTouchDocument); 9125 } else { 9126 touchEventTarget = null; 9127 _addListener(_doc, "mousemove", onMove); //attach these to the document instead of the box itself so that if the user's mouse moves too quickly (and off of the box), things still work. 9128 } 9129 touchDragAxis = null; 9130 _addListener(_doc, "mouseup", onRelease); 9131 if (e && e.target) { 9132 _addListener(e.target, "mouseup", onRelease); //we also have to listen directly on the element because some browsers don't bubble up the event to the _doc on elements with contentEditable="true" 9133 } 9134 isClicking = (isClickable.call(self, e.target) && vars.dragClickables === false && !force); 9135 if (isClicking) { 9136 _addListener(e.target, "change", onRelease); //in some browsers, when you mousedown on a <select> element, no mouseup gets dispatched! So we listen for a "change" event instead. 9137 _dispatchEvent(self, "pressInit", "onPressInit"); 9138 _dispatchEvent(self, "press", "onPress"); 9139 _setSelectable(triggers, true); //accommodates things like inputs and elements with contentEditable="true" (otherwise user couldn't drag to select text) 9140 return; 9141 } 9142 allowNativeTouchScrolling = (!touchEventTarget || allowX === allowY || self.vars.allowNativeTouchScrolling === false || (self.vars.allowContextMenu && e && (e.ctrlKey || e.which > 2))) ? false : allowX ? "y" : "x"; //note: in Chrome, right-clicking (for a context menu) fires onPress and it doesn't have the event.which set properly, so we must look for event.ctrlKey. If the user wants to allow context menus we should of course sense it here and not allow native touch scrolling. 9143 if (_isOldIE) { 9144 e = _populateIEEvent(e, true); 9145 } else if (!allowNativeTouchScrolling && !self.allowEventDefault) { 9146 e.preventDefault(); 9147 if (e.preventManipulation) { 9148 e.preventManipulation(); //for some Microsoft browsers 9149 } 9150 } 9151 if (e.changedTouches) { //touch events store the data slightly differently 9152 e = touch = e.changedTouches[0]; 9153 touchID = e.identifier; 9154 } else if (e.pointerId) { 9155 touchID = e.pointerId; //for some Microsoft browsers 9156 } else { 9157 touch = touchID = null; 9158 } 9159 _dragCount++; 9160 _addToRenderQueue(render); //causes the Draggable to render on each "tick" of TweenLite.ticker (performance optimization - updating values in a mousemove can cause them to happen too frequently, like multiple times between frame redraws which is wasteful, and it also prevents values from updating properly in IE8) 9161 startPointerY = self.pointerY = e.pageY; //record the starting x and y so that we can calculate the movement from the original in _onMouseMove 9162 startPointerX = self.pointerX = e.pageX; 9163 _dispatchEvent(self, "pressInit", "onPressInit"); 9164 if (allowNativeTouchScrolling || self.autoScroll) { 9165 _recordMaxScrolls(target.parentNode); 9166 } 9167 if (target.parentNode && self.autoScroll && !scrollProxy && !rotationMode && target.parentNode._gsMaxScrollX && !_placeholderDiv.parentNode && !target.getBBox) { //add a placeholder div to prevent the parent container from collapsing when the user drags the element left. 9168 _placeholderDiv.style.width = target.parentNode.scrollWidth + "px"; 9169 target.parentNode.appendChild(_placeholderDiv); 9170 } 9171 recordStartPositions(); 9172 if (self.tween) { 9173 self.tween.kill(); 9174 } 9175 self.isThrowing = false; 9176 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].killTweensOf(scrollProxy || target, true, killProps); //in case the user tries to drag it before the last tween is done. 9177 if (scrollProxy) { 9178 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].killTweensOf(target, true, {scrollTo:1}); //just in case the original target's scroll position is being tweened somewhere else. 9179 } 9180 self.tween = self.lockedAxis = null; 9181 if (vars.zIndexBoost || (!rotationMode && !scrollProxy && vars.zIndexBoost !== false)) { 9182 target.style.zIndex = Draggable.zIndex++; 9183 } 9184 self.isPressed = true; 9185 hasDragCallback = !!(vars.onDrag || self._listeners.drag); 9186 if (!rotationMode && (vars.cursor !== false || vars.activeCursor)) { 9187 i = triggers.length; 9188 while (--i > -1) { 9189 _setStyle(triggers[i], "cursor", vars.activeCursor || vars.cursor || "move"); 9190 } 9191 } 9192 _dispatchEvent(self, "press", "onPress"); 9193 }, 9194 9195 //called every time the mouse/touch moves 9196 onMove = function(e) { 9197 var originalEvent = e, 9198 touches, pointerX, pointerY, i, dx, dy; 9199 if (!enabled || _isMultiTouching || !self.isPressed || !e) { 9200 return; 9201 } 9202 self.pointerEvent = e; 9203 touches = e.changedTouches; 9204 if (touches) { //touch events store the data slightly differently 9205 e = touches[0]; 9206 if (e !== touch && e.identifier !== touchID) { //Usually changedTouches[0] will be what we're looking for, but in case it's not, look through the rest of the array...(and Android browsers don't reuse the event like iOS) 9207 i = touches.length; 9208 while (--i > -1 && (e = touches[i]).identifier !== touchID) {} 9209 if (i < 0) { 9210 return; 9211 } 9212 } 9213 } else if (e.pointerId && touchID && e.pointerId !== touchID) { //for some Microsoft browsers, we must attach the listener to the doc rather than the trigger so that when the finger moves outside the bounds of the trigger, things still work. So if the event we're receiving has a pointerId that doesn't match the touchID, ignore it (for multi-touch) 9214 return; 9215 } 9216 if (_isOldIE) { 9217 e = _populateIEEvent(e, true); 9218 } else { 9219 if (touchEventTarget && allowNativeTouchScrolling && !touchDragAxis) { //Android browsers force us to decide on the first "touchmove" event if we should allow the default (scrolling) behavior or preventDefault(). Otherwise, a "touchcancel" will be fired and then no "touchmove" or "touchend" will fire during the scrolling (no good). 9220 pointerX = e.pageX; 9221 pointerY = e.pageY; 9222 if (matrix) { 9223 i = pointerX * matrix[0] + pointerY * matrix[2] + matrix[4]; 9224 pointerY = pointerX * matrix[1] + pointerY * matrix[3] + matrix[5]; 9225 pointerX = i; 9226 } 9227 dx = Math.abs(pointerX - startPointerX); 9228 dy = Math.abs(pointerY - startPointerY); 9229 if ((dx !== dy && (dx > minimumMovement || dy > minimumMovement)) || (_isAndroid && allowNativeTouchScrolling === touchDragAxis)) { 9230 touchDragAxis = (dx > dy && allowX) ? "x" : "y"; 9231 if (self.vars.lockAxisOnTouchScroll !== false) { 9232 self.lockedAxis = (touchDragAxis === "x") ? "y" : "x"; 9233 if (typeof(self.vars.onLockAxis) === "function") { 9234 self.vars.onLockAxis.call(self, originalEvent); 9235 } 9236 } 9237 if (_isAndroid && allowNativeTouchScrolling === touchDragAxis) { 9238 onRelease(originalEvent); 9239 return; 9240 } 9241 } 9242 } 9243 if (!self.allowEventDefault && (!allowNativeTouchScrolling || (touchDragAxis && allowNativeTouchScrolling !== touchDragAxis)) && originalEvent.cancelable !== false) { 9244 originalEvent.preventDefault(); 9245 if (originalEvent.preventManipulation) { //for some Microsoft browsers 9246 originalEvent.preventManipulation(); 9247 } 9248 } 9249 } 9250 if (self.autoScroll) { 9251 checkAutoScrollBounds = true; 9252 } 9253 setPointerPosition(e.pageX, e.pageY); 9254 }, 9255 9256 setPointerPosition = function(pointerX, pointerY) { 9257 var dragTolerance = 1 - self.dragResistance, 9258 edgeTolerance = 1 - self.edgeResistance, 9259 xChange, yChange, x, y, dif, temp; 9260 9261 self.pointerX = pointerX; 9262 self.pointerY = pointerY; 9263 if (rotationMode) { 9264 y = Math.atan2(rotationOrigin.y - pointerY, pointerX - rotationOrigin.x) * _RAD2DEG; 9265 dif = self.y - y; 9266 if (dif > 180) { 9267 startElementY -= 360; 9268 self.y = y; 9269 } else if (dif < -180) { 9270 startElementY += 360; 9271 self.y = y; 9272 } 9273 if (self.x !== startElementX || Math.abs(startElementY - y) > minimumMovement) { 9274 self.y = y; 9275 x = startElementX + (startElementY - y) * dragTolerance; 9276 } else { 9277 x = startElementX; 9278 } 9279 9280 } else { 9281 if (matrix) { 9282 temp = pointerX * matrix[0] + pointerY * matrix[2] + matrix[4]; 9283 pointerY = pointerX * matrix[1] + pointerY * matrix[3] + matrix[5]; 9284 pointerX = temp; 9285 } 9286 yChange = (pointerY - startPointerY); 9287 xChange = (pointerX - startPointerX); 9288 if (yChange < minimumMovement && yChange > -minimumMovement) { 9289 yChange = 0; 9290 } 9291 if (xChange < minimumMovement && xChange > -minimumMovement) { 9292 xChange = 0; 9293 } 9294 if ((self.lockAxis || self.lockedAxis) && (xChange || yChange)) { 9295 temp = self.lockedAxis; 9296 if (!temp) { 9297 self.lockedAxis = temp = (allowX && Math.abs(xChange) > Math.abs(yChange)) ? "y" : allowY ? "x" : null; 9298 if (temp && typeof(self.vars.onLockAxis) === "function") { 9299 self.vars.onLockAxis.call(self, self.pointerEvent); 9300 } 9301 } 9302 if (temp === "y") { 9303 yChange = 0; 9304 } else if (temp === "x") { 9305 xChange = 0; 9306 } 9307 } 9308 x = startElementX + xChange * dragTolerance; 9309 y = startElementY + yChange * dragTolerance; 9310 } 9311 9312 if ((snapX || snapY || snapXY) && (self.x !== x || (self.y !== y && !rotationMode))) { 9313 if (snapXY) { 9314 _temp1.x = x; 9315 _temp1.y = y; 9316 temp = snapXY(_temp1); 9317 x = temp.x; 9318 y = temp.y; 9319 } 9320 if (snapX) { 9321 x = snapX(x); 9322 } 9323 if (snapY) { 9324 y = snapY(y); 9325 } 9326 } else if (hasBounds) { 9327 if (x > maxX) { 9328 x = maxX + (x - maxX) * edgeTolerance; 9329 } else if (x < minX) { 9330 x = minX + (x - minX) * edgeTolerance; 9331 } 9332 if (!rotationMode) { 9333 if (y > maxY) { 9334 y = maxY + (y - maxY) * edgeTolerance; 9335 } else if (y < minY) { 9336 y = minY + (y - minY) * edgeTolerance; 9337 } 9338 } 9339 } 9340 if (!rotationMode && !matrix) { 9341 x = Math.round(x); //helps work around an issue with some Win Touch devices 9342 y = Math.round(y); 9343 } 9344 if (self.x !== x || (self.y !== y && !rotationMode)) { 9345 if (rotationMode) { 9346 self.endRotation = self.x = self.endX = x; 9347 dirty = true; 9348 } else { 9349 if (allowY) { 9350 self.y = self.endY = y; 9351 dirty = true; //a flag that indicates we need to render the target next time the TweenLite.ticker dispatches a "tick" event (typically on a requestAnimationFrame) - this is a performance optimization (we shouldn't render on every move because sometimes many move events can get dispatched between screen refreshes, and that'd be wasteful to render every time) 9352 } 9353 if (allowX) { 9354 self.x = self.endX = x; 9355 dirty = true; 9356 } 9357 } 9358 if (!self.isDragging && self.isPressed) { 9359 self.isDragging = true; 9360 _dispatchEvent(self, "dragstart", "onDragStart"); 9361 } 9362 } 9363 }, 9364 9365 //called when the mouse/touch is released 9366 onRelease = function(e, force) { 9367 if (!enabled || !self.isPressed || (e && touchID != null && !force && ((e.pointerId && e.pointerId !== touchID) || (e.changedTouches && !_hasTouchID(e.changedTouches, touchID))))) { //for some Microsoft browsers, we must attach the listener to the doc rather than the trigger so that when the finger moves outside the bounds of the trigger, things still work. So if the event we're receiving has a pointerId that doesn't match the touchID, ignore it (for multi-touch) 9368 return; 9369 } 9370 self.isPressed = false; 9371 var originalEvent = e, 9372 wasDragging = self.isDragging, 9373 isContextMenuRelease = (self.vars.allowContextMenu && e && (e.ctrlKey || e.which > 2)), 9374 placeholderDelayedCall = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0.001, removePlaceholder), 9375 touches, i, syntheticEvent, eventTarget, syntheticClick; 9376 if (touchEventTarget) { 9377 _removeListener(touchEventTarget, "touchend", onRelease); 9378 _removeListener(touchEventTarget, "touchmove", onMove); 9379 _removeListener(touchEventTarget, "touchcancel", onRelease); 9380 _removeListener(_doc, "touchstart", _onMultiTouchDocument); 9381 } else { 9382 _removeListener(_doc, "mousemove", onMove); 9383 } 9384 _removeListener(_doc, "mouseup", onRelease); 9385 if (e && e.target) { 9386 _removeListener(e.target, "mouseup", onRelease); 9387 } 9388 dirty = false; 9389 if (isClicking && !isContextMenuRelease) { 9390 if (e) { 9391 _removeListener(e.target, "change", onRelease); 9392 self.pointerEvent = originalEvent; 9393 } 9394 _setSelectable(triggers, false); 9395 _dispatchEvent(self, "release", "onRelease"); 9396 _dispatchEvent(self, "click", "onClick"); 9397 isClicking = false; 9398 return; 9399 } 9400 _removeFromRenderQueue(render); 9401 if (!rotationMode) { 9402 i = triggers.length; 9403 while (--i > -1) { 9404 _setStyle(triggers[i], "cursor", vars.cursor || (vars.cursor !== false ? "move" : null)); 9405 } 9406 } 9407 if (wasDragging) { 9408 dragEndTime = _lastDragTime = _getTime(); 9409 self.isDragging = false; 9410 } 9411 _dragCount--; 9412 if (e) { 9413 if (_isOldIE) { 9414 e = _populateIEEvent(e, false); 9415 } 9416 touches = e.changedTouches; 9417 if (touches) { //touch events store the data slightly differently 9418 e = touches[0]; 9419 if (e !== touch && e.identifier !== touchID) { //Usually changedTouches[0] will be what we're looking for, but in case it's not, look through the rest of the array...(and Android browsers don't reuse the event like iOS) 9420 i = touches.length; 9421 while (--i > -1 && (e = touches[i]).identifier !== touchID) {} 9422 if (i < 0) { 9423 return; 9424 } 9425 } 9426 } 9427 self.pointerEvent = originalEvent; 9428 self.pointerX = e.pageX; 9429 self.pointerY = e.pageY; 9430 } 9431 if (isContextMenuRelease && originalEvent) { 9432 originalEvent.preventDefault(); 9433 if (originalEvent.preventManipulation) { 9434 originalEvent.preventManipulation(); //for some Microsoft browsers 9435 } 9436 _dispatchEvent(self, "release", "onRelease"); 9437 } else if (originalEvent && !wasDragging) { 9438 if (interrupted && (vars.snap || vars.bounds)) { //otherwise, if the user clicks on the object while it's animating to a snapped position, and then releases without moving 3 pixels, it will just stay there (it should animate/snap) 9439 animate(vars.throwProps); 9440 } 9441 _dispatchEvent(self, "release", "onRelease"); 9442 if ((!_isAndroid || originalEvent.type !== "touchmove") && originalEvent.type.indexOf("cancel") === -1) { //to accommodate native scrolling on Android devices, we have to immediately call onRelease() on the first touchmove event, but that shouldn't trigger a "click". 9443 _dispatchEvent(self, "click", "onClick"); 9444 if (_getTime() - clickTime < 300) { 9445 _dispatchEvent(self, "doubleclick", "onDoubleClick"); 9446 } 9447 eventTarget = originalEvent.target || originalEvent.srcElement || target; //old IE uses srcElement 9448 clickTime = _getTime(); 9449 syntheticClick = function () { // some browsers (like Firefox) won't trust script-generated clicks, so if the user tries to click on a video to play it, for example, it simply won't work. Since a regular "click" event will most likely be generated anyway (one that has its isTrusted flag set to true), we must slightly delay our script-generated click so that the "real"/trusted one is prioritized. Remember, when there are duplicate events in quick succession, we suppress all but the first one. Some browsers don't even trigger the "real" one at all, so our synthetic one is a safety valve that ensures that no matter what, a click event does get dispatched. 9450 if (clickTime !== clickDispatch && self.enabled() && !self.isPressed) { 9451 if (eventTarget.click) { //some browsers (like mobile Safari) don't properly trigger the click event 9452 eventTarget.click(); 9453 } else if (_doc.createEvent) { 9454 syntheticEvent = _doc.createEvent("MouseEvents"); 9455 syntheticEvent.initMouseEvent("click", true, true, window, 1, self.pointerEvent.screenX, self.pointerEvent.screenY, self.pointerX, self.pointerY, false, false, false, false, 0, null); 9456 eventTarget.dispatchEvent(syntheticEvent); 9457 } 9458 } 9459 }; 9460 if (!_isAndroid && !originalEvent.defaultPrevented) { //iOS Safari requires the synthetic click to happen immediately or else it simply won't work, but Android doesn't play nice. 9461 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0.00001, syntheticClick); //in addition to the iOS bug workaround, there's a Firefox issue with clicking on things like a video to play, so we must fake a click event in a slightly delayed fashion. Previously, we listened for the "click" event with "capture" false which solved the video-click-to-play issue, but it would allow the "click" event to be dispatched twice like if you were using a jQuery.click() because that was handled in the capture phase, thus we had to switch to the capture phase to avoid the double-dispatching, but do the delayed synthetic click. 9462 } 9463 } 9464 } else { 9465 animate(vars.throwProps); //will skip if throwProps isn't defined or ThrowPropsPlugin isn't loaded. 9466 if (!_isOldIE && !self.allowEventDefault && originalEvent && (vars.dragClickables !== false || !isClickable.call(self, originalEvent.target)) && wasDragging && (!allowNativeTouchScrolling || (touchDragAxis && allowNativeTouchScrolling === touchDragAxis)) && originalEvent.cancelable !== false) { 9467 originalEvent.preventDefault(); 9468 if (originalEvent.preventManipulation) { 9469 originalEvent.preventManipulation(); //for some Microsoft browsers 9470 } 9471 } 9472 _dispatchEvent(self, "release", "onRelease"); 9473 } 9474 if (isTweening()) { 9475 placeholderDelayedCall.duration( self.tween.duration() ); //sync the timing so that the placeholder DIV gets 9476 } 9477 if (wasDragging) { 9478 _dispatchEvent(self, "dragend", "onDragEnd"); 9479 } 9480 return true; 9481 }, 9482 9483 updateScroll = function(e) { 9484 if (e && self.isDragging && !scrollProxy) { 9485 var parent = e.target || e.srcElement || target.parentNode, 9486 deltaX = parent.scrollLeft - parent._gsScrollX, 9487 deltaY = parent.scrollTop - parent._gsScrollY; 9488 if (deltaX || deltaY) { 9489 if (matrix) { 9490 startPointerX -= deltaX * matrix[0] + deltaY * matrix[2]; 9491 startPointerY -= deltaY * matrix[3] + deltaX * matrix[1]; 9492 } else { 9493 startPointerX -= deltaX; 9494 startPointerY -= deltaY; 9495 } 9496 parent._gsScrollX += deltaX; 9497 parent._gsScrollY += deltaY; 9498 setPointerPosition(self.pointerX, self.pointerY); 9499 } 9500 } 9501 }, 9502 9503 onClick = function(e) { //this was a huge pain in the neck to align all the various browsers and their behaviors. Chrome, Firefox, Safari, Opera, Android, and Microsoft Edge all handle events differently! Some will only trigger native behavior (like checkbox toggling) from trusted events. Others don't even support isTrusted, but require 2 events to flow through before triggering native behavior. Edge treats everything as trusted but also mandates that 2 flow through to trigger the correct native behavior. 9504 var time = _getTime(), 9505 recentlyClicked = (time - clickTime < 40), 9506 recentlyDragged = (time - dragEndTime < 40), 9507 alreadyDispatched = (recentlyClicked && clickDispatch === clickTime), 9508 isModern = !!e.preventDefault, 9509 defaultPrevented = (self.pointerEvent && self.pointerEvent.defaultPrevented), 9510 alreadyDispatchedTrusted = (recentlyClicked && trustedClickDispatch === clickTime), 9511 trusted = e.isTrusted || (e.isTrusted == null && recentlyClicked && alreadyDispatched); //note: Safari doesn't support isTrusted, and it won't properly execute native behavior (like toggling checkboxes) on the first synthetic "click" event - we must wait for the 2nd and treat it as trusted (but stop propagation at that point). Confusing, I know. Don't you love cross-browser compatibility challenges? 9512 if (isModern && (alreadyDispatched || (recentlyDragged && self.vars.suppressClickOnDrag !== false) )) { 9513 e.stopImmediatePropagation(); 9514 } 9515 if (recentlyClicked && !(self.pointerEvent && self.pointerEvent.defaultPrevented) && (!alreadyDispatched || (trusted !== alreadyDispatchedTrusted))) { //let the first click pass through unhindered. Let the next one only if it's trusted, then no more (stop quick-succession ones) 9516 if (trusted && alreadyDispatched) { 9517 trustedClickDispatch = clickTime; 9518 } 9519 clickDispatch = clickTime; 9520 return; 9521 } 9522 if (self.isPressed || recentlyDragged || recentlyClicked) { 9523 if (!isModern) { 9524 e.returnValue = false; 9525 } else if (!trusted || !e.detail || !recentlyClicked || defaultPrevented) { 9526 e.preventDefault(); 9527 if (e.preventManipulation) { 9528 e.preventManipulation(); //for some Microsoft browsers 9529 } 9530 } 9531 } 9532 }, 9533 9534 localizePoint = function(p) { 9535 return matrix ? {x:p.x * matrix[0] + p.y * matrix[2] + matrix[4], y:p.x * matrix[1] + p.y * matrix[3] + matrix[5]} : {x:p.x, y:p.y}; 9536 }; 9537 9538 old = Draggable.get(this.target); 9539 if (old) { 9540 old.kill(); // avoids duplicates (an element can only be controlled by one Draggable) 9541 } 9542 9543 //give the user access to start/stop dragging... 9544 this.startDrag = function(e, align) { 9545 var r1, r2, p1, p2; 9546 onPress(e || self.pointerEvent, true); 9547 //if the pointer isn't on top of the element, adjust things accordingly 9548 if (align && !self.hitTest(e || self.pointerEvent)) { 9549 r1 = _parseRect(e || self.pointerEvent); 9550 r2 = _parseRect(target); 9551 p1 = localizePoint({x:r1.left + r1.width / 2, y:r1.top + r1.height / 2}); 9552 p2 = localizePoint({x:r2.left + r2.width / 2, y:r2.top + r2.height / 2}); 9553 startPointerX -= p1.x - p2.x; 9554 startPointerY -= p1.y - p2.y; 9555 } 9556 if (!self.isDragging) { 9557 self.isDragging = true; 9558 _dispatchEvent(self, "dragstart", "onDragStart"); 9559 } 9560 }; 9561 this.drag = onMove; 9562 this.endDrag = function(e) { 9563 onRelease(e || self.pointerEvent, true); 9564 }; 9565 this.timeSinceDrag = function() { 9566 return self.isDragging ? 0 : (_getTime() - dragEndTime) / 1000; 9567 }; 9568 this.timeSinceClick = function() { 9569 return (_getTime() - clickTime) / 1000; 9570 }; 9571 this.hitTest = function(target, threshold) { 9572 return Draggable.hitTest(self.target, target, threshold); 9573 }; 9574 9575 this.getDirection = function(from, diagonalThreshold) { //from can be "start" (default), "velocity", or an element 9576 var mode = (from === "velocity" && ThrowPropsPlugin) ? from : (typeof(from) === "object" && !rotationMode) ? "element" : "start", 9577 xChange, yChange, ratio, direction, r1, r2; 9578 if (mode === "element") { 9579 r1 = _parseRect(self.target); 9580 r2 = _parseRect(from); 9581 } 9582 xChange = (mode === "start") ? self.x - startElementX : (mode === "velocity") ? ThrowPropsPlugin.getVelocity(this.target, xProp) : (r1.left + r1.width / 2) - (r2.left + r2.width / 2); 9583 if (rotationMode) { 9584 return xChange < 0 ? "counter-clockwise" : "clockwise"; 9585 } else { 9586 diagonalThreshold = diagonalThreshold || 2; 9587 yChange = (mode === "start") ? self.y - startElementY : (mode === "velocity") ? ThrowPropsPlugin.getVelocity(this.target, yProp) : (r1.top + r1.height / 2) - (r2.top + r2.height / 2); 9588 ratio = Math.abs(xChange / yChange); 9589 direction = (ratio < 1 / diagonalThreshold) ? "" : (xChange < 0) ? "left" : "right"; 9590 if (ratio < diagonalThreshold) { 9591 if (direction !== "") { 9592 direction += "-"; 9593 } 9594 direction += (yChange < 0) ? "up" : "down"; 9595 } 9596 } 9597 return direction; 9598 }; 9599 9600 9601 this.applyBounds = function(newBounds) { 9602 var x, y, forceZeroVelocity, e, parent, isRoot; 9603 if (newBounds && vars.bounds !== newBounds) { 9604 vars.bounds = newBounds; 9605 return self.update(true); 9606 } 9607 syncXY(true); 9608 calculateBounds(); 9609 if (hasBounds) { 9610 x = self.x; 9611 y = self.y; 9612 if (x > maxX) { 9613 x = maxX; 9614 } else if (x < minX) { 9615 x = minX; 9616 } 9617 if (y > maxY) { 9618 y = maxY; 9619 } else if (y < minY) { 9620 y = minY; 9621 } 9622 if (self.x !== x || self.y !== y) { 9623 forceZeroVelocity = true; 9624 self.x = self.endX = x; 9625 if (rotationMode) { 9626 self.endRotation = x; 9627 } else { 9628 self.y = self.endY = y; 9629 } 9630 dirty = true; 9631 render(true); 9632 if (self.autoScroll && !self.isDragging) { 9633 _recordMaxScrolls(target.parentNode); 9634 e = target; 9635 _windowProxy.scrollTop = ((window.pageYOffset != null) ? window.pageYOffset : (_docElement.scrollTop != null) ? _docElement.scrollTop : _doc.body.scrollTop); 9636 _windowProxy.scrollLeft = ((window.pageXOffset != null) ? window.pageXOffset : (_docElement.scrollLeft != null) ? _docElement.scrollLeft : _doc.body.scrollLeft); 9637 while (e && !isRoot) { //walk up the chain and sense wherever the scrollTop/scrollLeft exceeds the maximum. 9638 isRoot = _isRoot(e.parentNode); 9639 parent = isRoot ? _windowProxy : e.parentNode; 9640 if (allowY && parent.scrollTop > parent._gsMaxScrollY) { 9641 parent.scrollTop = parent._gsMaxScrollY; 9642 } 9643 if (allowX && parent.scrollLeft > parent._gsMaxScrollX) { 9644 parent.scrollLeft = parent._gsMaxScrollX; 9645 } 9646 e = parent; 9647 } 9648 } 9649 } 9650 if (self.isThrowing && (forceZeroVelocity || self.endX > maxX || self.endX < minX || self.endY > maxY || self.endY < minY)) { 9651 animate(vars.throwProps, forceZeroVelocity); 9652 } 9653 } 9654 return self; 9655 }; 9656 9657 this.update = function(applyBounds, sticky, ignoreExternalChanges) { 9658 var x = self.x, 9659 y = self.y; 9660 updateMatrix(!sticky); 9661 if (applyBounds) { 9662 self.applyBounds(); 9663 } else { 9664 if (dirty && ignoreExternalChanges) { 9665 render(true); 9666 } 9667 syncXY(true); 9668 } 9669 if (sticky) { 9670 setPointerPosition(self.pointerX, self.pointerY); 9671 if (dirty) { 9672 render(true); 9673 } 9674 } 9675 if (self.isPressed && !sticky && ((allowX && Math.abs(x - self.x) > 0.01) || (allowY && (Math.abs(y - self.y) > 0.01 && !rotationMode)))) { 9676 recordStartPositions(); 9677 } 9678 if (self.autoScroll) { 9679 _recordMaxScrolls(target.parentNode); 9680 checkAutoScrollBounds = self.isDragging; 9681 render(true); 9682 } 9683 if (self.autoScroll) { //in case reparenting occurred. 9684 _removeScrollListener(target, updateScroll); 9685 _addScrollListener(target, updateScroll); 9686 } 9687 return self; 9688 }; 9689 9690 this.enable = function(type) { 9691 var id, i, trigger; 9692 if (type !== "soft") { 9693 i = triggers.length; 9694 while (--i > -1) { 9695 trigger = triggers[i]; 9696 _addListener(trigger, "mousedown", onPress); 9697 _addListener(trigger, "touchstart", onPress); 9698 _addListener(trigger, "click", onClick, true); //note: used to pass true for capture but it prevented click-to-play-video functionality in Firefox. 9699 if (!rotationMode && vars.cursor !== false) { 9700 _setStyle(trigger, "cursor", vars.cursor || "move"); 9701 } 9702 _setStyle(trigger, "touchCallout", "none"); 9703 _setStyle(trigger, "touchAction", (allowX === allowY) ? "none" : allowX ? "pan-y" : "pan-x"); 9704 if (_isSVG(trigger)) { // a bug in chrome doesn't respect touch-action on SVG elements - it only works if we set it on the parent SVG. 9705 _setStyle(trigger.ownerSVGElement || trigger, "touchAction", (allowX === allowY) ? "none" : allowX ? "pan-y" : "pan-x"); 9706 } 9707 if (!this.vars.allowContextMenu) { 9708 _addListener(trigger, "contextmenu", onContextMenu); 9709 } 9710 } 9711 _setSelectable(triggers, false); 9712 } 9713 _addScrollListener(target, updateScroll); 9714 enabled = true; 9715 if (ThrowPropsPlugin && type !== "soft") { 9716 ThrowPropsPlugin.track(scrollProxy || target, (xyMode ? "x,y" : rotationMode ? "rotation" : "top,left")); 9717 } 9718 if (scrollProxy) { 9719 scrollProxy.enable(); 9720 } 9721 target._gsDragID = id = "d" + (_lookupCount++); 9722 _lookup[id] = this; 9723 if (scrollProxy) { 9724 scrollProxy.element._gsDragID = id; 9725 } 9726 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].set(target, {x:"+=0", overwrite:false, data:"_draggable"}); //simply ensures that there's a _gsTransform on the element. 9727 applyObj = { 9728 t:target, 9729 data:_isOldIE ? cssVars : target._gsTransform, 9730 tween:{}, 9731 setRatio:(_isOldIE ? function() { _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].set(target, tempVars); } : _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__["default"]._internals.setTransformRatio || _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_1__["default"]._internals.set3DTransformRatio) 9732 }; 9733 recordStartPositions(); 9734 self.update(true); 9735 return self; 9736 }; 9737 9738 this.disable = function(type) { 9739 var dragging = self.isDragging, 9740 i, trigger; 9741 if (!rotationMode) { 9742 i = triggers.length; 9743 while (--i > -1) { 9744 _setStyle(triggers[i], "cursor", null); 9745 } 9746 } 9747 if (type !== "soft") { 9748 i = triggers.length; 9749 while (--i > -1) { 9750 trigger = triggers[i]; 9751 _setStyle(trigger, "touchCallout", null); 9752 _setStyle(trigger, "touchAction", null); 9753 _removeListener(trigger, "mousedown", onPress); 9754 _removeListener(trigger, "touchstart", onPress); 9755 _removeListener(trigger, "click", onClick); 9756 _removeListener(trigger, "contextmenu", onContextMenu); 9757 } 9758 _setSelectable(triggers, true); 9759 if (touchEventTarget) { 9760 _removeListener(touchEventTarget, "touchcancel", onRelease); 9761 _removeListener(touchEventTarget, "touchend", onRelease); 9762 _removeListener(touchEventTarget, "touchmove", onMove); 9763 } 9764 _removeListener(_doc, "mouseup", onRelease); 9765 _removeListener(_doc, "mousemove", onMove); 9766 } 9767 _removeScrollListener(target, updateScroll); 9768 enabled = false; 9769 if (ThrowPropsPlugin && type !== "soft") { 9770 ThrowPropsPlugin.untrack(scrollProxy || target, (xyMode ? "x,y" : rotationMode ? "rotation" : "top,left")); 9771 } 9772 if (scrollProxy) { 9773 scrollProxy.disable(); 9774 } 9775 _removeFromRenderQueue(render); 9776 self.isDragging = self.isPressed = isClicking = false; 9777 if (dragging) { 9778 _dispatchEvent(self, "dragend", "onDragEnd"); 9779 } 9780 return self; 9781 }; 9782 9783 this.enabled = function(value, type) { 9784 return arguments.length ? (value ? self.enable(type) : self.disable(type)) : enabled; 9785 }; 9786 9787 this.kill = function() { 9788 self.isThrowing = false; 9789 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].killTweensOf(scrollProxy || target, true, killProps); 9790 self.disable(); 9791 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].set(triggers, {clearProps:"userSelect"}); 9792 delete _lookup[target._gsDragID]; 9793 return self; 9794 }; 9795 9796 if (type.indexOf("scroll") !== -1) { 9797 scrollProxy = this.scrollProxy = new ScrollProxy(target, _extend({onKill:function() { //ScrollProxy's onKill() gets called if/when the ScrollProxy senses that the user interacted with the scroll position manually (like using the scrollbar). IE9 doesn't fire the "mouseup" properly when users drag the scrollbar of an element, so this works around that issue. 9798 if (self.isPressed) { 9799 onRelease(null); 9800 }}}, vars)); 9801 //a bug in many Android devices' stock browser causes scrollTop to get forced back to 0 after it is altered via JS, so we set overflow to "hidden" on mobile/touch devices (they hide the scroll bar anyway). That works around the bug. (This bug is discussed at https://code.google.com/p/android/issues/detail?id=19625) 9802 target.style.overflowY = (allowY && !_isTouchDevice) ? "auto" : "hidden"; 9803 target.style.overflowX = (allowX && !_isTouchDevice) ? "auto" : "hidden"; 9804 target = scrollProxy.content; 9805 } 9806 9807 if (vars.force3D !== false) { 9808 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].set(target, {force3D:true}); //improve performance by forcing a GPU layer when possible 9809 } 9810 if (rotationMode) { 9811 killProps.rotation = 1; 9812 } else { 9813 if (allowX) { 9814 killProps[xProp] = 1; 9815 } 9816 if (allowY) { 9817 killProps[yProp] = 1; 9818 } 9819 } 9820 if (rotationMode) { 9821 tempVars = _tempVarsRotation; 9822 cssVars = tempVars.css; 9823 tempVars.overwrite = false; 9824 } else if (xyMode) { 9825 tempVars = (allowX && allowY) ? _tempVarsXY : allowX ? _tempVarsX : _tempVarsY; 9826 cssVars = tempVars.css; 9827 tempVars.overwrite = false; 9828 } 9829 9830 this.enable(); 9831 }, 9832 p = Draggable.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["EventDispatcher"](); 9833 9834 p.constructor = Draggable; 9835 p.pointerX = p.pointerY = p.startX = p.startY = p.deltaX = p.deltaY = 0; 9836 p.isDragging = p.isPressed = false; 9837 Draggable.version = "0.17.1"; 9838 Draggable.zIndex = 1000; 9839 9840 _addListener(_doc, "touchcancel", function() { 9841 //some older Android devices intermittently stop dispatching "touchmove" events if we don't listen for "touchcancel" on the document. Very strange indeed. 9842 }); 9843 _addListener(_doc, "contextmenu", function(e) { 9844 var p; 9845 for (p in _lookup) { 9846 if (_lookup[p].isPressed) { 9847 _lookup[p].endDrag(); 9848 } 9849 } 9850 }); 9851 9852 Draggable.create = function(targets, vars) { 9853 if (typeof(targets) === "string") { 9854 targets = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].selector(targets); 9855 } 9856 var a = (!targets || targets.length === 0) ? [] : _isArrayLike(targets) ? _flattenArray(targets) : [targets], 9857 i = a.length; 9858 while (--i > -1) { 9859 a[i] = new Draggable(a[i], vars); 9860 } 9861 return a; 9862 }; 9863 9864 Draggable.get = function(target) { 9865 return _lookup[(_unwrapElement(target) || {})._gsDragID]; 9866 }; 9867 9868 Draggable.timeSinceDrag = function() { 9869 return (_getTime() - _lastDragTime) / 1000; 9870 }; 9871 9872 var _tempRect = {}, //reuse to reduce garbage collection tasks 9873 _oldIERect = function(e) { //IE8 doesn't support getBoundingClientRect(), so we use this as a backup. 9874 var top = 0, 9875 left = 0, 9876 width, height; 9877 e = _unwrapElement(e); 9878 width = e.offsetWidth; 9879 height = e.offsetHeight; 9880 while(e) { 9881 top += e.offsetTop; 9882 left += e.offsetLeft; 9883 e = e.offsetParent; 9884 } 9885 return {top: top, left: left, width: width, height: height}; 9886 }, 9887 _parseRect = function(e, undefined) { //accepts a DOM element, a mouse event, or a rectangle object and returns the corresponding rectangle with left, right, width, height, top, and bottom properties 9888 if (e === window) { 9889 _tempRect.left = _tempRect.top = 0; 9890 _tempRect.width = _tempRect.right = _docElement.clientWidth || e.innerWidth || _doc.body.clientWidth || 0; 9891 _tempRect.height = _tempRect.bottom = ((e.innerHeight || 0) - 20 < _docElement.clientHeight) ? _docElement.clientHeight : e.innerHeight || _doc.body.clientHeight || 0; 9892 return _tempRect; 9893 } 9894 var r = (e.pageX !== undefined) ? {left:e.pageX - _getDocScrollLeft(), top:e.pageY - _getDocScrollTop(), right:e.pageX - _getDocScrollLeft() + 1, bottom:e.pageY - _getDocScrollTop() + 1} : (!e.nodeType && e.left !== undefined && e.top !== undefined) ? e : _isOldIE ? _oldIERect(e) : _unwrapElement(e).getBoundingClientRect(); 9895 if (r.right === undefined && r.width !== undefined) { 9896 r.right = r.left + r.width; 9897 r.bottom = r.top + r.height; 9898 } else if (r.width === undefined) { //some browsers don't include width and height properties. We can't just set them directly on r because some browsers throw errors, so create a new generic object. 9899 r = {width: r.right - r.left, height: r.bottom - r.top, right: r.right, left: r.left, bottom: r.bottom, top: r.top}; 9900 } 9901 return r; 9902 }; 9903 9904 Draggable.hitTest = function(obj1, obj2, threshold) { 9905 if (obj1 === obj2) { 9906 return false; 9907 } 9908 var r1 = _parseRect(obj1), 9909 r2 = _parseRect(obj2), 9910 isOutside = (r2.left > r1.right || r2.right < r1.left || r2.top > r1.bottom || r2.bottom < r1.top), 9911 overlap, area, isRatio; 9912 if (isOutside || !threshold) { 9913 return !isOutside; 9914 } 9915 isRatio = ((threshold + "").indexOf("%") !== -1); 9916 threshold = parseFloat(threshold) || 0; 9917 overlap = {left:Math.max(r1.left, r2.left), top:Math.max(r1.top, r2.top)}; 9918 overlap.width = Math.min(r1.right, r2.right) - overlap.left; 9919 overlap.height = Math.min(r1.bottom, r2.bottom) - overlap.top; 9920 if (overlap.width < 0 || overlap.height < 0) { 9921 return false; 9922 } 9923 if (isRatio) { 9924 threshold *= 0.01; 9925 area = overlap.width * overlap.height; 9926 return (area >= r1.width * r1.height * threshold || area >= r2.width * r2.height * threshold); 9927 } 9928 return (overlap.width > threshold && overlap.height > threshold); 9929 }; 9930 9931 _placeholderDiv.style.cssText = "visibility:hidden;height:1px;top:-1px;pointer-events:none;position:relative;clear:both;"; 9932 9933 return Draggable; 9934 9935 }, true); 9936 9937var Draggable = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Draggable; 9938 9939 9940/***/ }), 9941
vendor: 14,777 bytes, lines 9942-10351
9942/***/ "./node_modules/gsap/EasePack.js": 9943/*!***************************************!*\ 9944 !*** ./node_modules/gsap/EasePack.js ***! 9945 \***************************************/ 9946/*! exports provided: Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase, Linear, Power0, Power1, Power2, Power3, Power4 */ 9947/***/ (function(module, __webpack_exports__, __webpack_require__) { 9948 9949"use strict"; 9950__webpack_require__.r(__webpack_exports__); 9951/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Back", function() { return Back; }); 9952/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Elastic", function() { return Elastic; }); 9953/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Bounce", function() { return Bounce; }); 9954/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RoughEase", function() { return RoughEase; }); 9955/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SlowMo", function() { return SlowMo; }); 9956/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SteppedEase", function() { return SteppedEase; }); 9957/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Circ", function() { return Circ; }); 9958/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Expo", function() { return Expo; }); 9959/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Sine", function() { return Sine; }); 9960/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ExpoScaleEase", function() { return ExpoScaleEase; }); 9961/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 9962/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Linear"]; }); 9963 9964/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power0"]; }); 9965 9966/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power1"]; }); 9967 9968/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power2"]; }); 9969 9970/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power3"]; }); 9971 9972/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power4"]; }); 9973 9974/*! 9975 * VERSION: 1.16.1 9976 * DATE: 2018-08-27 9977 * UPDATES AND DOCS AT: http://greensock.com 9978 * 9979 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 9980 * This work is subject to the terms at http://greensock.com/standard-license or for 9981 * Club GreenSock members, the software agreement that was issued with your membership. 9982 * 9983 * @author: Jack Doyle, [email protected] 9984 **/ 9985/* eslint-disable */ 9986 9987 9988 9989_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("easing.Back", ["easing.Ease"], function() { 9990 9991 var w = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].GreenSockGlobals || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]), 9992 gs = w.com.greensock, 9993 _2PI = Math.PI * 2, 9994 _HALF_PI = Math.PI / 2, 9995 _class = gs._class, 9996 _create = function(n, f) { 9997 var C = _class("easing." + n, function(){}, true), 9998 p = C.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](); 9999 p.constructor = C; 10000 p.getRatio = f; 10001 return C; 10002 }, 10003 _easeReg = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"].register || function(){}, //put an empty function in place just as a safety measure in case someone loads an OLD version of TweenLite.js where Ease.register doesn't exist. 10004 _wrap = function(name, EaseOut, EaseIn, EaseInOut, aliases) { 10005 var C = _class("easing."+name, { 10006 easeOut:new EaseOut(), 10007 easeIn:new EaseIn(), 10008 easeInOut:new EaseInOut() 10009 }, true); 10010 _easeReg(C, name); 10011 return C; 10012 }, 10013 EasePoint = function(time, value, next) { 10014 this.t = time; 10015 this.v = value; 10016 if (next) { 10017 this.next = next; 10018 next.prev = this; 10019 this.c = next.v - value; 10020 this.gap = next.t - time; 10021 } 10022 }, 10023 10024 //Back 10025 _createBack = function(n, f) { 10026 var C = _class("easing." + n, function(overshoot) { 10027 this._p1 = (overshoot || overshoot === 0) ? overshoot : 1.70158; 10028 this._p2 = this._p1 * 1.525; 10029 }, true), 10030 p = C.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](); 10031 p.constructor = C; 10032 p.getRatio = f; 10033 p.config = function(overshoot) { 10034 return new C(overshoot); 10035 }; 10036 return C; 10037 }, 10038 10039 Back = _wrap("Back", 10040 _createBack("BackOut", function(p) { 10041 return ((p = p - 1) * p * ((this._p1 + 1) * p + this._p1) + 1); 10042 }), 10043 _createBack("BackIn", function(p) { 10044 return p * p * ((this._p1 + 1) * p - this._p1); 10045 }), 10046 _createBack("BackInOut", function(p) { 10047 return ((p *= 2) < 1) ? 0.5 * p * p * ((this._p2 + 1) * p - this._p2) : 0.5 * ((p -= 2) * p * ((this._p2 + 1) * p + this._p2) + 2); 10048 }) 10049 ), 10050 10051 10052 //SlowMo 10053 SlowMo = _class("easing.SlowMo", function(linearRatio, power, yoyoMode) { 10054 power = (power || power === 0) ? power : 0.7; 10055 if (linearRatio == null) { 10056 linearRatio = 0.7; 10057 } else if (linearRatio > 1) { 10058 linearRatio = 1; 10059 } 10060 this._p = (linearRatio !== 1) ? power : 0; 10061 this._p1 = (1 - linearRatio) / 2; 10062 this._p2 = linearRatio; 10063 this._p3 = this._p1 + this._p2; 10064 this._calcEnd = (yoyoMode === true); 10065 }, true), 10066 p = SlowMo.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](), 10067 SteppedEase, ExpoScaleEase, RoughEase, _createElastic; 10068 10069 p.constructor = SlowMo; 10070 p.getRatio = function(p) { 10071 var r = p + (0.5 - p) * this._p; 10072 if (p < this._p1) { 10073 return this._calcEnd ? 1 - ((p = 1 - (p / this._p1)) * p) : r - ((p = 1 - (p / this._p1)) * p * p * p * r); 10074 } else if (p > this._p3) { 10075 return this._calcEnd ? (p === 1 ? 0 : 1 - (p = (p - this._p3) / this._p1) * p) : r + ((p - r) * (p = (p - this._p3) / this._p1) * p * p * p); //added p === 1 ? 0 to avoid floating point rounding errors from affecting the final value, like 1 - 0.7 = 0.30000000000000004 instead of 0.3 10076 } 10077 return this._calcEnd ? 1 : r; 10078 }; 10079 SlowMo.ease = new SlowMo(0.7, 0.7); 10080 10081 p.config = SlowMo.config = function(linearRatio, power, yoyoMode) { 10082 return new SlowMo(linearRatio, power, yoyoMode); 10083 }; 10084 10085 10086 //SteppedEase 10087 SteppedEase = _class("easing.SteppedEase", function(steps, immediateStart) { 10088 steps = steps || 1; 10089 this._p1 = 1 / steps; 10090 this._p2 = steps + (immediateStart ? 0 : 1); 10091 this._p3 = immediateStart ? 1 : 0; 10092 }, true); 10093 p = SteppedEase.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](); 10094 p.constructor = SteppedEase; 10095 p.getRatio = function(p) { 10096 if (p < 0) { 10097 p = 0; 10098 } else if (p >= 1) { 10099 p = 0.999999999; 10100 } 10101 return (((this._p2 * p) | 0) + this._p3) * this._p1; 10102 }; 10103 p.config = SteppedEase.config = function(steps, immediateStart) { 10104 return new SteppedEase(steps, immediateStart); 10105 }; 10106 10107 10108 //ExpoScaleEase 10109 ExpoScaleEase = _class("easing.ExpoScaleEase", function(start, end, ease) { 10110 this._p1 = Math.log(end / start); 10111 this._p2 = end - start; 10112 this._p3 = start; 10113 this._ease = ease; 10114 }, true); 10115 p = ExpoScaleEase.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](); 10116 p.constructor = ExpoScaleEase; 10117 p.getRatio = function(p) { 10118 if (this._ease) { 10119 p = this._ease.getRatio(p); 10120 } 10121 return (this._p3 * Math.exp(this._p1 * p) - this._p3) / this._p2; 10122 }; 10123 p.config = ExpoScaleEase.config = function(start, end, ease) { 10124 return new ExpoScaleEase(start, end, ease); 10125 }; 10126 10127 10128 //RoughEase 10129 RoughEase = _class("easing.RoughEase", function(vars) { 10130 vars = vars || {}; 10131 var taper = vars.taper || "none", 10132 a = [], 10133 cnt = 0, 10134 points = (vars.points || 20) | 0, 10135 i = points, 10136 randomize = (vars.randomize !== false), 10137 clamp = (vars.clamp === true), 10138 template = (vars.template instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]) ? vars.template : null, 10139 strength = (typeof(vars.strength) === "number") ? vars.strength * 0.4 : 0.4, 10140 x, y, bump, invX, obj, pnt; 10141 while (--i > -1) { 10142 x = randomize ? Math.random() : (1 / points) * i; 10143 y = template ? template.getRatio(x) : x; 10144 if (taper === "none") { 10145 bump = strength; 10146 } else if (taper === "out") { 10147 invX = 1 - x; 10148 bump = invX * invX * strength; 10149 } else if (taper === "in") { 10150 bump = x * x * strength; 10151 } else if (x < 0.5) { //"both" (start) 10152 invX = x * 2; 10153 bump = invX * invX * 0.5 * strength; 10154 } else { //"both" (end) 10155 invX = (1 - x) * 2; 10156 bump = invX * invX * 0.5 * strength; 10157 } 10158 if (randomize) { 10159 y += (Math.random() * bump) - (bump * 0.5); 10160 } else if (i % 2) { 10161 y += bump * 0.5; 10162 } else { 10163 y -= bump * 0.5; 10164 } 10165 if (clamp) { 10166 if (y > 1) { 10167 y = 1; 10168 } else if (y < 0) { 10169 y = 0; 10170 } 10171 } 10172 a[cnt++] = {x:x, y:y}; 10173 } 10174 a.sort(function(a, b) { 10175 return a.x - b.x; 10176 }); 10177 10178 pnt = new EasePoint(1, 1, null); 10179 i = points; 10180 while (--i > -1) { 10181 obj = a[i]; 10182 pnt = new EasePoint(obj.x, obj.y, pnt); 10183 } 10184 10185 this._prev = new EasePoint(0, 0, (pnt.t !== 0) ? pnt : pnt.next); 10186 }, true); 10187 p = RoughEase.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](); 10188 p.constructor = RoughEase; 10189 p.getRatio = function(p) { 10190 var pnt = this._prev; 10191 if (p > pnt.t) { 10192 while (pnt.next && p >= pnt.t) { 10193 pnt = pnt.next; 10194 } 10195 pnt = pnt.prev; 10196 } else { 10197 while (pnt.prev && p <= pnt.t) { 10198 pnt = pnt.prev; 10199 } 10200 } 10201 this._prev = pnt; 10202 return (pnt.v + ((p - pnt.t) / pnt.gap) * pnt.c); 10203 }; 10204 p.config = function(vars) { 10205 return new RoughEase(vars); 10206 }; 10207 RoughEase.ease = new RoughEase(); 10208 10209 10210 //Bounce 10211 _wrap("Bounce", 10212 _create("BounceOut", function(p) { 10213 if (p < 1 / 2.75) { 10214 return 7.5625 * p * p; 10215 } else if (p < 2 / 2.75) { 10216 return 7.5625 * (p -= 1.5 / 2.75) * p + 0.75; 10217 } else if (p < 2.5 / 2.75) { 10218 return 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375; 10219 } 10220 return 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375; 10221 }), 10222 _create("BounceIn", function(p) { 10223 if ((p = 1 - p) < 1 / 2.75) { 10224 return 1 - (7.5625 * p * p); 10225 } else if (p < 2 / 2.75) { 10226 return 1 - (7.5625 * (p -= 1.5 / 2.75) * p + 0.75); 10227 } else if (p < 2.5 / 2.75) { 10228 return 1 - (7.5625 * (p -= 2.25 / 2.75) * p + 0.9375); 10229 } 10230 return 1 - (7.5625 * (p -= 2.625 / 2.75) * p + 0.984375); 10231 }), 10232 _create("BounceInOut", function(p) { 10233 var invert = (p < 0.5); 10234 if (invert) { 10235 p = 1 - (p * 2); 10236 } else { 10237 p = (p * 2) - 1; 10238 } 10239 if (p < 1 / 2.75) { 10240 p = 7.5625 * p * p; 10241 } else if (p < 2 / 2.75) { 10242 p = 7.5625 * (p -= 1.5 / 2.75) * p + 0.75; 10243 } else if (p < 2.5 / 2.75) { 10244 p = 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375; 10245 } else { 10246 p = 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375; 10247 } 10248 return invert ? (1 - p) * 0.5 : p * 0.5 + 0.5; 10249 }) 10250 ); 10251 10252 10253 //CIRC 10254 _wrap("Circ", 10255 _create("CircOut", function(p) { 10256 return Math.sqrt(1 - (p = p - 1) * p); 10257 }), 10258 _create("CircIn", function(p) { 10259 return -(Math.sqrt(1 - (p * p)) - 1); 10260 }), 10261 _create("CircInOut", function(p) { 10262 return ((p*=2) < 1) ? -0.5 * (Math.sqrt(1 - p * p) - 1) : 0.5 * (Math.sqrt(1 - (p -= 2) * p) + 1); 10263 }) 10264 ); 10265 10266 10267 //Elastic 10268 _createElastic = function(n, f, def) { 10269 var C = _class("easing." + n, function(amplitude, period) { 10270 this._p1 = (amplitude >= 1) ? amplitude : 1; //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1. 10271 this._p2 = (period || def) / (amplitude < 1 ? amplitude : 1); 10272 this._p3 = this._p2 / _2PI * (Math.asin(1 / this._p1) || 0); 10273 this._p2 = _2PI / this._p2; //precalculate to optimize 10274 }, true), 10275 p = C.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](); 10276 p.constructor = C; 10277 p.getRatio = f; 10278 p.config = function(amplitude, period) { 10279 return new C(amplitude, period); 10280 }; 10281 return C; 10282 }; 10283 _wrap("Elastic", 10284 _createElastic("ElasticOut", function(p) { 10285 return this._p1 * Math.pow(2, -10 * p) * Math.sin( (p - this._p3) * this._p2 ) + 1; 10286 }, 0.3), 10287 _createElastic("ElasticIn", function(p) { 10288 return -(this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2 )); 10289 }, 0.3), 10290 _createElastic("ElasticInOut", function(p) { 10291 return ((p *= 2) < 1) ? -0.5 * (this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2)) : this._p1 * Math.pow(2, -10 *(p -= 1)) * Math.sin( (p - this._p3) * this._p2 ) * 0.5 + 1; 10292 }, 0.45) 10293 ); 10294 10295 10296 //Expo 10297 _wrap("Expo", 10298 _create("ExpoOut", function(p) { 10299 return 1 - Math.pow(2, -10 * p); 10300 }), 10301 _create("ExpoIn", function(p) { 10302 return Math.pow(2, 10 * (p - 1)) - 0.001; 10303 }), 10304 _create("ExpoInOut", function(p) { 10305 return ((p *= 2) < 1) ? 0.5 * Math.pow(2, 10 * (p - 1)) : 0.5 * (2 - Math.pow(2, -10 * (p - 1))); 10306 }) 10307 ); 10308 10309 10310 //Sine 10311 _wrap("Sine", 10312 _create("SineOut", function(p) { 10313 return Math.sin(p * _HALF_PI); 10314 }), 10315 _create("SineIn", function(p) { 10316 return -Math.cos(p * _HALF_PI) + 1; 10317 }), 10318 _create("SineInOut", function(p) { 10319 return -0.5 * (Math.cos(Math.PI * p) - 1); 10320 }) 10321 ); 10322 10323 _class("easing.EaseLookup", { 10324 find:function(s) { 10325 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"].map[s]; 10326 } 10327 }, true); 10328 10329 //register the non-standard eases 10330 _easeReg(w.SlowMo, "SlowMo", "ease,"); 10331 _easeReg(RoughEase, "RoughEase", "ease,"); 10332 _easeReg(SteppedEase, "SteppedEase", "ease,"); 10333 10334 return Back; 10335 10336 }, true); 10337 10338var Back = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Back; 10339var Elastic = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Elastic; 10340var Bounce = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Bounce; 10341var RoughEase = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].RoughEase; 10342var SlowMo = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].SlowMo; 10343var SteppedEase = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].SteppedEase; 10344var Circ = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Circ; 10345var Expo = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Expo; 10346var Sine = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].Sine; 10347var ExpoScaleEase = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].ExpoScaleEase; 10348 10349 10350/***/ }), 10351
vendor: 10,758 bytes, lines 10352-10678
10352/***/ "./node_modules/gsap/EaselPlugin.js": 10353/*!******************************************!*\ 10354 !*** ./node_modules/gsap/EaselPlugin.js ***! 10355 \******************************************/ 10356/*! exports provided: EaselPlugin, default */ 10357/***/ (function(module, __webpack_exports__, __webpack_require__) { 10358 10359"use strict"; 10360__webpack_require__.r(__webpack_exports__); 10361/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EaselPlugin", function() { return EaselPlugin; }); 10362/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return EaselPlugin; }); 10363/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 10364/*! 10365 * VERSION: 0.2.2 10366 * DATE: 2018-05-30 10367 * UPDATES AND DOCS AT: http://greensock.com 10368 * 10369 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 10370 * This work is subject to the terms at http://greensock.com/standard-license or for 10371 * Club GreenSock members, the software agreement that was issued with your membership. 10372 * 10373 * @author: Jack Doyle, [email protected] 10374 **/ 10375/* eslint-disable */ 10376 10377 10378 10379 10380 var _numExp = /(\d|\.)+/g, 10381 _ColorFilter, _ColorMatrixFilter, 10382 _colorProps = ["redMultiplier","greenMultiplier","blueMultiplier","alphaMultiplier","redOffset","greenOffset","blueOffset","alphaOffset"], 10383 _colorLookup = {aqua:[0,255,255], 10384 lime:[0,255,0], 10385 silver:[192,192,192], 10386 black:[0,0,0], 10387 maroon:[128,0,0], 10388 teal:[0,128,128], 10389 blue:[0,0,255], 10390 navy:[0,0,128], 10391 white:[255,255,255], 10392 fuchsia:[255,0,255], 10393 olive:[128,128,0], 10394 yellow:[255,255,0], 10395 orange:[255,165,0], 10396 gray:[128,128,128], 10397 purple:[128,0,128], 10398 green:[0,128,0], 10399 red:[255,0,0], 10400 pink:[255,192,203], 10401 cyan:[0,255,255], 10402 transparent:[255,255,255,0]}, 10403 _parseColor = function(color) { 10404 if (color === "" || color == null || color === "none") { 10405 return _colorLookup.transparent; 10406 } else if (_colorLookup[color]) { 10407 return _colorLookup[color]; 10408 } else if (typeof(color) === "number") { 10409 return [color >> 16, (color >> 8) & 255, color & 255]; 10410 } else if (color.charAt(0) === "#") { 10411 if (color.length === 4) { //for shorthand like #9F0 10412 color = "#" + color.charAt(1) + color.charAt(1) + color.charAt(2) + color.charAt(2) + color.charAt(3) + color.charAt(3); 10413 } 10414 color = parseInt(color.substr(1), 16); 10415 return [color >> 16, (color >> 8) & 255, color & 255]; 10416 } 10417 return color.match(_numExp) || _colorLookup.transparent; 10418 }, 10419 _parseColorFilter = function(t, v, pg) { 10420 if (!_ColorFilter) { 10421 _ColorFilter = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].ColorFilter || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].createjs.ColorFilter); 10422 if (!_ColorFilter) { 10423 throw("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded."); 10424 } 10425 } 10426 var filters = t.filters || [], 10427 i = filters.length, 10428 c, s, e, a, p; 10429 while (--i > -1) { 10430 if (filters[i] instanceof _ColorFilter) { 10431 s = filters[i]; 10432 break; 10433 } 10434 } 10435 if (!s) { 10436 s = new _ColorFilter(); 10437 filters.push(s); 10438 t.filters = filters; 10439 } 10440 e = s.clone(); 10441 if (v.tint != null) { 10442 c = _parseColor(v.tint); 10443 a = (v.tintAmount != null) ? Number(v.tintAmount) : 1; 10444 e.redOffset = Number(c[0]) * a; 10445 e.greenOffset = Number(c[1]) * a; 10446 e.blueOffset = Number(c[2]) * a; 10447 e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - a; 10448 } else { 10449 for (p in v) { 10450 if (p !== "exposure") if (p !== "brightness") { 10451 e[p] = Number(v[p]); 10452 } 10453 } 10454 } 10455 if (v.exposure != null) { 10456 e.redOffset = e.greenOffset = e.blueOffset = 255 * (Number(v.exposure) - 1); 10457 e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1; 10458 } else if (v.brightness != null) { 10459 a = Number(v.brightness) - 1; 10460 e.redOffset = e.greenOffset = e.blueOffset = (a > 0) ? a * 255 : 0; 10461 e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - Math.abs(a); 10462 } 10463 i = 8; 10464 while (--i > -1) { 10465 p = _colorProps[i]; 10466 if (s[p] !== e[p]) { 10467 pg._addTween(s, p, s[p], e[p], "easel_colorFilter"); 10468 } 10469 } 10470 pg._overwriteProps.push("easel_colorFilter"); 10471 if (!t.cacheID) { 10472 throw("EaselPlugin warning: for filters to display in EaselJS, you must call the object's cache() method first. " + t); 10473 } 10474 }, 10475 10476 _idMatrix = [1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0], 10477 _lumR = 0.212671, 10478 _lumG = 0.715160, 10479 _lumB = 0.072169, 10480 10481 _applyMatrix = function(m, m2) { 10482 if (!(m instanceof Array) || !(m2 instanceof Array)) { 10483 return m2; 10484 } 10485 var temp = [], 10486 i = 0, 10487 z = 0, 10488 y, x; 10489 for (y = 0; y < 4; y++) { 10490 for (x = 0; x < 5; x++) { 10491 z = (x === 4) ? m[i + 4] : 0; 10492 temp[i + x] = m[i] * m2[x] + m[i+1] * m2[x + 5] + m[i+2] * m2[x + 10] + m[i+3] * m2[x + 15] + z; 10493 } 10494 i += 5; 10495 } 10496 return temp; 10497 }, 10498 10499 _setSaturation = function(m, n) { 10500 if (isNaN(n)) { 10501 return m; 10502 } 10503 var inv = 1 - n, 10504 r = inv * _lumR, 10505 g = inv * _lumG, 10506 b = inv * _lumB; 10507 return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m); 10508 }, 10509 10510 _colorize = function(m, color, amount) { 10511 if (isNaN(amount)) { 10512 amount = 1; 10513 } 10514 var c = _parseColor(color), 10515 r = c[0] / 255, 10516 g = c[1] / 255, 10517 b = c[2] / 255, 10518 inv = 1 - amount; 10519 return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m); 10520 }, 10521 10522 _setHue = function(m, n) { 10523 if (isNaN(n)) { 10524 return m; 10525 } 10526 n *= Math.PI / 180; 10527 var c = Math.cos(n), 10528 s = Math.sin(n); 10529 return _applyMatrix([(_lumR + (c * (1 - _lumR))) + (s * (-_lumR)), (_lumG + (c * (-_lumG))) + (s * (-_lumG)), (_lumB + (c * (-_lumB))) + (s * (1 - _lumB)), 0, 0, (_lumR + (c * (-_lumR))) + (s * 0.143), (_lumG + (c * (1 - _lumG))) + (s * 0.14), (_lumB + (c * (-_lumB))) + (s * -0.283), 0, 0, (_lumR + (c * (-_lumR))) + (s * (-(1 - _lumR))), (_lumG + (c * (-_lumG))) + (s * _lumG), (_lumB + (c * (1 - _lumB))) + (s * _lumB), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m); 10530 }, 10531 10532 _setContrast = function(m, n) { 10533 if (isNaN(n)) { 10534 return m; 10535 } 10536 n += 0.01; 10537 return _applyMatrix([n,0,0,0,128 * (1 - n), 0,n,0,0,128 * (1 - n), 0,0,n,0,128 * (1 - n), 0,0,0,1,0], m); 10538 }, 10539 10540 _parseColorMatrixFilter = function(t, v, pg) { 10541 if (!_ColorMatrixFilter) { 10542 _ColorMatrixFilter = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].ColorMatrixFilter || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].createjs.ColorMatrixFilter); 10543 if (!_ColorMatrixFilter) { 10544 throw("EaselPlugin error: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded."); 10545 } 10546 } 10547 var filters = t.filters || [], 10548 i = filters.length, 10549 matrix, startMatrix, s; 10550 while (--i > -1) { 10551 if (filters[i] instanceof _ColorMatrixFilter) { 10552 s = filters[i]; 10553 break; 10554 } 10555 } 10556 if (!s) { 10557 s = new _ColorMatrixFilter(_idMatrix.slice()); 10558 filters.push(s); 10559 t.filters = filters; 10560 } 10561 startMatrix = s.matrix; 10562 matrix = _idMatrix.slice(); 10563 if (v.colorize != null) { 10564 matrix = _colorize(matrix, v.colorize, Number(v.colorizeAmount)); 10565 } 10566 if (v.contrast != null) { 10567 matrix = _setContrast(matrix, Number(v.contrast)); 10568 } 10569 if (v.hue != null) { 10570 matrix = _setHue(matrix, Number(v.hue)); 10571 } 10572 if (v.saturation != null) { 10573 matrix = _setSaturation(matrix, Number(v.saturation)); 10574 } 10575 10576 i = matrix.length; 10577 while (--i > -1) { 10578 if (matrix[i] !== startMatrix[i]) { 10579 pg._addTween(startMatrix, i, startMatrix[i], matrix[i], "easel_colorMatrixFilter"); 10580 } 10581 } 10582 10583 pg._overwriteProps.push("easel_colorMatrixFilter"); 10584 if (!t.cacheID) { 10585 throw("EaselPlugin warning: for filters to display in EaselJS, you must call the object's cache() method first. " + t); 10586 } 10587 10588 pg._matrix = startMatrix; 10589 }; 10590 10591 10592 var EaselPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 10593 propName: "easel", 10594 priority: -1, 10595 version: "0.2.2", 10596 API: 2, 10597 10598 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 10599 init: function(target, value, tween, index) { 10600 this._target = target; 10601 var p, pt, tint, colorMatrix, end, labels, i; 10602 for (p in value) { 10603 10604 end = value[p]; 10605 if (typeof(end) === "function") { 10606 end = end(index, target); 10607 } 10608 if (p === "colorFilter" || p === "tint" || p === "tintAmount" || p === "exposure" || p === "brightness") { 10609 if (!tint) { 10610 _parseColorFilter(target, value.colorFilter || value, this); 10611 tint = true; 10612 } 10613 10614 } else if (p === "saturation" || p === "contrast" || p === "hue" || p === "colorize" || p === "colorizeAmount") { 10615 if (!colorMatrix) { 10616 _parseColorMatrixFilter(target, value.colorMatrixFilter || value, this); 10617 colorMatrix = true; 10618 } 10619 10620 } else if (p === "frame") { 10621 this._firstPT = pt = {_next:this._firstPT, t:target, p:"gotoAndStop", s:target.currentFrame, f:true, n:"frame", pr:0, type:0, m:Math.round}; 10622 if (typeof(end) === "string" && end.charAt(1) !== "=" && (labels = target.labels)) { 10623 for (i = 0; i < labels.length; i++) { 10624 if (labels[i].label === end) { 10625 end = labels[i].position; 10626 } 10627 } 10628 } 10629 pt.c = (typeof(end) === "number") ? end - pt.s : parseFloat((end+"").split("=").join("")); 10630 if (pt._next) { 10631 pt._next._prev = pt; 10632 } 10633 10634 } else if (target[p] != null) { 10635 this._firstPT = pt = {_next:this._firstPT, t:target, p:p, f:(typeof(target[p]) === "function"), n:p, pr:0, type:0}; 10636 pt.s = (!pt.f) ? parseFloat(target[p]) : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ](); 10637 pt.c = (typeof(end) === "number") ? end - pt.s : (typeof(end) === "string") ? parseFloat(end.split("=").join("")) : 0; 10638 10639 if (pt._next) { 10640 pt._next._prev = pt; 10641 } 10642 } 10643 10644 } 10645 return true; 10646 }, 10647 10648 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 10649 set: function(v) { 10650 var pt = this._firstPT, 10651 min = 0.000001, 10652 val; 10653 while (pt) { 10654 val = pt.c * v + pt.s; 10655 if (pt.m) { 10656 val = pt.m(val, pt.t); 10657 } else if (val < min && val > -min) { 10658 val = 0; 10659 } 10660 if (pt.f) { 10661 pt.t[pt.p](val); 10662 } else { 10663 pt.t[pt.p] = val; 10664 } 10665 pt = pt._next; 10666 } 10667 if (this._target.cacheID) { 10668 this._target.updateCache(); 10669 } 10670 } 10671 10672 }); 10673 10674 10675 10676 10677/***/ }), 10678
vendor: 2,580 bytes, lines 10679-10763
10679/***/ "./node_modules/gsap/EndArrayPlugin.js": 10680/*!*********************************************!*\ 10681 !*** ./node_modules/gsap/EndArrayPlugin.js ***! 10682 \*********************************************/ 10683/*! exports provided: EndArrayPlugin, default */ 10684/***/ (function(module, __webpack_exports__, __webpack_require__) { 10685 10686"use strict"; 10687__webpack_require__.r(__webpack_exports__); 10688/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EndArrayPlugin", function() { return EndArrayPlugin; }); 10689/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return EndArrayPlugin; }); 10690/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 10691/*! 10692 * VERSION: 0.1.3 10693 * DATE: 2018-08-27 10694 * UPDATES AND DOCS AT: http://greensock.com 10695 * 10696 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 10697 * This work is subject to the terms at http://greensock.com/standard-license or for 10698 * Club GreenSock members, the software agreement that was issued with your membership. 10699 * 10700 * @author: Jack Doyle, [email protected] 10701 */ 10702/* eslint-disable */ 10703 10704 10705 10706var EndArrayPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 10707 propName: "endArray", 10708 API: 2, 10709 version: "0.1.3", 10710 10711 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 10712 init: function(target, value, tween) { 10713 var i = value.length, 10714 a = this.a = [], 10715 start, end; 10716 this.target = target; 10717 this._mod = 0; 10718 if (!i) { 10719 return false; 10720 } 10721 while (--i > -1) { 10722 start = target[i]; 10723 end = value[i]; 10724 if (start !== end) { 10725 a.push({i:i, s:start, c:end - start}); 10726 } 10727 } 10728 return true; 10729 }, 10730 10731 mod: function(lookup) { 10732 if (typeof(lookup.endArray) === "function") { 10733 this._mod = lookup.endArray; 10734 } 10735 }, 10736 10737 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 10738 set: function(ratio) { 10739 var target = this.target, 10740 a = this.a, 10741 i = a.length, 10742 mod = this._mod, 10743 e, val; 10744 if (mod) { 10745 while (--i > -1) { 10746 e = a[i]; 10747 target[e.i] = mod(e.s + e.c * ratio, target); 10748 } 10749 } else { 10750 while (--i > -1) { 10751 e = a[i]; 10752 val = e.s + e.c * ratio; 10753 target[e.i] = (val < 0.000001 && val > -0.000001) ? 0 : val; 10754 } 10755 } 10756 } 10757 10758 }); 10759 10760 10761 10762/***/ }), 10763
vendor: 7,329 bytes, lines 10764-10948
10764/***/ "./node_modules/gsap/ModifiersPlugin.js": 10765/*!**********************************************!*\ 10766 !*** ./node_modules/gsap/ModifiersPlugin.js ***! 10767 \**********************************************/ 10768/*! exports provided: ModifiersPlugin, default */ 10769/***/ (function(module, __webpack_exports__, __webpack_require__) { 10770 10771"use strict"; 10772__webpack_require__.r(__webpack_exports__); 10773/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ModifiersPlugin", function() { return ModifiersPlugin; }); 10774/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ModifiersPlugin; }); 10775/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 10776/*! 10777 * VERSION: 0.0.4 10778 * DATE: 2018-05-30 10779 * UPDATES AND DOCS AT: http://greensock.com 10780 * 10781 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 10782 * This work is subject to the terms at http://greensock.com/standard-license or for 10783 * Club GreenSock members, the software agreement that was issued with your membership. 10784 * 10785 * @author: Jack Doyle, [email protected] 10786 */ 10787/* eslint-disable */ 10788 10789 10790 10791 10792 var _cssRatioSetter = function(pt, cssp, mod) { //Takes an individual CSSPropTween and converts it into a type:2 that has a setRatio that does everything the regular CSSPlugin.setRatio() method does but applying the mod() too. We do this to keep the main CSSPlugin.setRatio() as fast as possible (the vast majority of times, no mod() will be necessary) 10793 var type = pt.type, 10794 oldSetRatio = pt.setRatio, 10795 tween = cssp._tween, 10796 target = cssp._target; 10797 pt.type = 2; 10798 pt.m = mod; 10799 pt.setRatio = function(v) { 10800 var min = 0.000001, 10801 val, str, i; 10802 if (v === 1 && (tween._time === tween._duration || tween._time === 0)) { 10803 10804 if (type !== 2) { 10805 if (pt.r && type !== -1) { 10806 val = Math.round(pt.s + pt.c); 10807 if (!type) { 10808 pt.t[pt.p] = mod.call(tween, val + pt.xs0, target, tween); 10809 } else if (type === 1) { 10810 str = pt.xs0 + val + pt.xs1; 10811 for (i = 1; i < pt.l; i++) { 10812 str += pt["xn"+i] + pt["xs"+(i+1)]; 10813 } 10814 pt.t[pt.p] = mod.call(tween, str, target, tween); 10815 } 10816 } else { 10817 pt.t[pt.p] = mod.call(tween, pt.e, target, tween); 10818 } 10819 } else { 10820 oldSetRatio.call(pt, v); 10821 } 10822 10823 } else if (v || !(tween._time === tween._duration || tween._time === 0) || tween._rawPrevTime === -0.000001) { 10824 val = pt.c * v + pt.s; 10825 if (pt.r) { 10826 val = Math.round(val); 10827 } else if (val < min) if (val > -min) { 10828 val = 0; 10829 } 10830 if (!type) { 10831 pt.t[pt.p] = mod.call(tween, val + pt.xs0, target, tween); 10832 } else if (type === 1) { 10833 str = pt.xs0 + val + pt.xs1; 10834 for (i = 1; i < pt.l; i++) { 10835 str += pt["xn"+i] + pt["xs"+(i+1)]; 10836 } 10837 pt.t[pt.p] = mod.call(tween, str, target, tween); 10838 10839 } else if (type === -1) { //non-tweening value 10840 pt.t[pt.p] = mod.call(tween, pt.xs0, target, tween); 10841 10842 } else if (oldSetRatio) { 10843 oldSetRatio.call(pt, v); 10844 } 10845 10846 } else { 10847 if (type !== 2) { 10848 pt.t[pt.p] = mod.call(tween, pt.b, target, tween); 10849 } else { 10850 oldSetRatio.call(pt, v); 10851 } 10852 } 10853 }; 10854 }, 10855 _modCSS = function(lookup, cssp) { 10856 var pt = cssp._firstPT, 10857 hasBezier = (lookup.rotation && cssp._overwriteProps.join("").indexOf("bezier") !== -1); //when a Bezier tween is applying autoRotation, it's a very special case we need to handle differently. 10858 if (lookup.scale) { 10859 lookup.scaleX = lookup.scaleY = lookup.scale; 10860 } else if (lookup.rotationZ) { 10861 lookup.rotation = lookup.rotationZ; 10862 } 10863 while (pt) { 10864 if (typeof(lookup[pt.p]) === "function") { 10865 _cssRatioSetter(pt, cssp, lookup[pt.p]); 10866 } else if (hasBezier && pt.n === "bezier" && pt.plugin._overwriteProps.join("").indexOf("rotation") !== -1) { 10867 pt.data.mod = lookup.rotation; 10868 } 10869 pt = pt._next; 10870 } 10871 }, 10872 10873 ModifiersPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 10874 propName: "modifiers", 10875 version: "0.0.4", 10876 API: 2, 10877 10878 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 10879 init: function(target, value, tween) { 10880 this._tween = tween; 10881 this._vars = value; 10882 return true; 10883 }, 10884 10885 initAll: function() { 10886 var tween = this._tween, 10887 lookup = this._vars, 10888 mpt = this, 10889 pt = tween._firstPT, 10890 val, next; 10891 //initAll() gets called for each and every ModifiersPlugin instance in a tween, so if there are multiple targets, there will be multiple instances. Since we're ripping through the whole tween (and all the PropTweens), we only need to run this code ONCE. So we're setting a toggle on the first PropTween that just tells us if we've done it already. We don't set it on the tween instance because if it gets invalidated, we don't want to have to track this property and reset it. PropTweens get blown away when a tween is invalidated. 10892 if (pt._modInitted) { 10893 return false; 10894 } else { 10895 pt._modInitted = 1; 10896 } 10897 while (pt) { 10898 next = pt._next; //record here, because it may get removed 10899 val = lookup[pt.n]; 10900 if (pt.pg) { 10901 if (pt.t._propName === "css") { //handle CSSPlugin uniquely (for performance, due to the fact that the values almost always are a concatenation of numbers and strings, like suffixes, and we don't want to slow down the regular CSSPlugin setRatio() performance with conditional checks for if the value needs to be modded, so we pull any modding prop out and change it to a type:2 one that simply calls a setRatio() method where we encapsulate the modding and update all together. That way, it says in the main CSSProp linked list and just has some custom logic applied to it inside its setRatio()) 10902 _modCSS(lookup, pt.t); 10903 } else if (pt.t !== mpt) { //don't run modProps on modProps :) 10904 val = lookup[pt.t._propName]; 10905 pt.t._tween = tween; 10906 pt.t._mod((typeof(val) === "object") ? val : lookup); 10907 } 10908 } else if (typeof(val) === "function") { 10909 if (pt.f === 2 && pt.t) { //a blob (text containing multiple numeric values) 10910 pt.t._applyPT.m = val; 10911 pt.t._tween = tween; 10912 } else { 10913 this._add(pt.t, pt.p, pt.s, pt.c, val); 10914 //remove from linked list 10915 if (next) { 10916 next._prev = pt._prev; 10917 } 10918 if (pt._prev) { 10919 pt._prev._next = next; 10920 } else if (tween._firstPT === pt) { 10921 tween._firstPT = next; 10922 } 10923 pt._next = pt._prev = null; 10924 tween._propLookup[pt.n] = mpt; 10925 } 10926 } 10927 pt = next; 10928 } 10929 return false; 10930 } 10931 10932 }), 10933 p = ModifiersPlugin.prototype; 10934 10935 p._add = function(target, p, s, c, mod) { 10936 this._addTween(target, p, s, s + c, p, mod); 10937 this._overwriteProps.push(p); 10938 }; 10939 10940 p = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.globals.TweenLite.version.split("."); 10941 if (Number(p[0]) <= 1 && Number(p[1]) < 19 && _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].console) { 10942 console.log("ModifiersPlugin requires GSAP 1.19.0 or later."); 10943 } 10944 10945 10946 10947/***/ }), 10948
vendor: 20,153 bytes, lines 10949-11427
10949/***/ "./node_modules/gsap/PixiPlugin.js": 10950/*!*****************************************!*\ 10951 !*** ./node_modules/gsap/PixiPlugin.js ***! 10952 \*****************************************/ 10953/*! exports provided: PixiPlugin, default */ 10954/***/ (function(module, __webpack_exports__, __webpack_require__) { 10955 10956"use strict"; 10957__webpack_require__.r(__webpack_exports__); 10958/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PixiPlugin", function() { return PixiPlugin; }); 10959/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return PixiPlugin; }); 10960/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 10961/*! 10962 * VERSION: 0.2.1 10963 * DATE: 2018-05-30 10964 * UPDATES AND DOCS AT: http://greensock.com 10965 * 10966 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 10967 * PixiPlugin is subject to the terms at http://greensock.com/standard-license or for 10968 * Club GreenSock members, the software agreement that was issued with your membership. 10969 * 10970 * @author: Jack Doyle, [email protected] 10971 */ 10972/* eslint-disable */ 10973 10974 10975 10976 10977 var _numExp = /(\d|\.)+/g, 10978 _relNumExp = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g, 10979 _colorLookup = {aqua:[0,255,255], 10980 lime:[0,255,0], 10981 silver:[192,192,192], 10982 black:[0,0,0], 10983 maroon:[128,0,0], 10984 teal:[0,128,128], 10985 blue:[0,0,255], 10986 navy:[0,0,128], 10987 white:[255,255,255], 10988 fuchsia:[255,0,255], 10989 olive:[128,128,0], 10990 yellow:[255,255,0], 10991 orange:[255,165,0], 10992 gray:[128,128,128], 10993 purple:[128,0,128], 10994 green:[0,128,0], 10995 red:[255,0,0], 10996 pink:[255,192,203], 10997 cyan:[0,255,255], 10998 transparent:[255,255,255,0]}, 10999 _hue = function(h, m1, m2) { 11000 h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; 11001 return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; 11002 }, 11003 /** 11004 * @private Parses a color (like #9F0, #FF9900, rgb(255,51,153) or hsl(108, 50%, 10%)) into an array with 3 elements for red, green, and blue or if "format" parameter is "hsl", it will populate the array with hue, saturation, and lightness values. Or if "format" is "number", it'll return a number like 0xFF0000 instead of an array. If a relative value is found in an hsl() or hsla() string, it will preserve those relative prefixes and all the values in the array will be strings instead of numbers (in all other cases it will be populated with numbers). 11005 * @param {(string|number)} v The value the should be parsed which could be a string like #9F0 or rgb(255,102,51) or rgba(255,0,0,0.5) or it could be a number like 0xFF00CC or even a named color like red, blue, purple, etc. 11006 * @param {(string)} format If "hsl", an hsl() or hsla() value will be returned instead of rgb() or rgba(). Or if "number", then a numeric value will be returned, like 0xFF0000. Default is rgb. 11007 * @return {(array|number)} An array containing red, green, and blue (and optionally alpha) in that order, or if the format parameter was "hsl", the array will contain hue, saturation and lightness (and optionally alpha) in that order. Or if "format" is defined as "number", it'll return a number like 0xFF0000. Always numbers unless there's a relative prefix found in an hsl() or hsla() string and "format" is "hsl". 11008 */ 11009 _parseColor = function(v, format) { 11010 var toHSL = (format === "hsl"), 11011 a, r, g, b, h, s, l, max, min, d, wasHSL; 11012 if (!v) { 11013 a = _colorLookup.black; 11014 } else if (typeof(v) === "number") { 11015 a = [v >> 16, (v >> 8) & 255, v & 255]; 11016 } else { 11017 if (v.charAt(v.length - 1) === ",") { //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value. 11018 v = v.substr(0, v.length - 1); 11019 } 11020 if (_colorLookup[v]) { 11021 a = _colorLookup[v]; 11022 } else if (v.charAt(0) === "#") { 11023 if (v.length === 4) { //for shorthand like #9F0 11024 r = v.charAt(1); 11025 g = v.charAt(2); 11026 b = v.charAt(3); 11027 v = "#" + r + r + g + g + b + b; 11028 } 11029 v = parseInt(v.substr(1), 16); 11030 a = [v >> 16, (v >> 8) & 255, v & 255]; 11031 } else if (v.substr(0, 3) === "hsl") { 11032 a = wasHSL = v.match(_numExp); 11033 if (!toHSL) { 11034 h = (Number(a[0]) % 360) / 360; 11035 s = Number(a[1]) / 100; 11036 l = Number(a[2]) / 100; 11037 g = (l <= 0.5) ? l * (s + 1) : l + s - l * s; 11038 r = l * 2 - g; 11039 if (a.length > 3) { 11040 a[3] = Number(v[3]); 11041 } 11042 a[0] = _hue(h + 1 / 3, r, g); 11043 a[1] = _hue(h, r, g); 11044 a[2] = _hue(h - 1 / 3, r, g); 11045 } else if (v.indexOf("=") !== -1) { //if relative values are found, just return the raw strings with the relative prefixes in place. 11046 return v.match(_relNumExp); 11047 } 11048 } else { 11049 a = v.match(_numExp) || _colorLookup.transparent; 11050 } 11051 a[0] = Number(a[0]); 11052 a[1] = Number(a[1]); 11053 a[2] = Number(a[2]); 11054 if (a.length > 3) { 11055 a[3] = Number(a[3]); 11056 } 11057 } 11058 if (toHSL && !wasHSL) { 11059 r = a[0] / 255; 11060 g = a[1] / 255; 11061 b = a[2] / 255; 11062 max = Math.max(r, g, b); 11063 min = Math.min(r, g, b); 11064 l = (max + min) / 2; 11065 if (max === min) { 11066 h = s = 0; 11067 } else { 11068 d = max - min; 11069 s = l > 0.5 ? d / (2 - max - min) : d / (max + min); 11070 h = (max === r) ? (g - b) / d + (g < b ? 6 : 0) : (max === g) ? (b - r) / d + 2 : (r - g) / d + 4; 11071 h *= 60; 11072 } 11073 a[0] = (h + 0.5) | 0; 11074 a[1] = (s * 100 + 0.5) | 0; 11075 a[2] = (l * 100 + 0.5) | 0; 11076 } 11077 return (format === "number") ? (a[0] << 16 | a[1] << 8 | a[2]) : a; 11078 }, 11079 _formatColors = function(s, toHSL) { 11080 var colors = (s + "").match(_colorExp) || [], 11081 charIndex = 0, 11082 parsed = "", 11083 i, color, temp; 11084 if (!colors.length) { 11085 return s; 11086 } 11087 for (i = 0; i < colors.length; i++) { 11088 color = colors[i]; 11089 temp = s.substr(charIndex, s.indexOf(color, charIndex)-charIndex); 11090 charIndex += temp.length + color.length; 11091 color = _parseColor(color, (toHSL ? "hsl" : "rgb")); 11092 if (color.length === 3) { 11093 color.push(1); 11094 } 11095 parsed += temp + (toHSL ? "hsla(" + color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : "rgba(" + color.join(",")) + ")"; 11096 } 11097 return parsed + s.substr(charIndex); 11098 }, _colorStringFilter, 11099 TweenLite = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].GreenSockGlobals || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]).TweenLite, 11100 _colorExp = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b", //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc. 11101 11102 _idMatrix = [1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0], 11103 _lumR = 0.212671, 11104 _lumG = 0.715160, 11105 _lumB = 0.072169, 11106 11107 _applyMatrix = function(m, m2) { 11108 var temp = [], 11109 i = 0, 11110 z = 0, 11111 y, x; 11112 for (y = 0; y < 4; y++) { 11113 for (x = 0; x < 5; x++) { 11114 z = (x === 4) ? m[i + 4] : 0; 11115 temp[i + x] = m[i] * m2[x] + m[i+1] * m2[x + 5] + m[i+2] * m2[x + 10] + m[i+3] * m2[x + 15] + z; 11116 } 11117 i += 5; 11118 } 11119 return temp; 11120 }, 11121 11122 _setSaturation = function(m, n) { 11123 var inv = 1 - n, 11124 r = inv * _lumR, 11125 g = inv * _lumG, 11126 b = inv * _lumB; 11127 return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m); 11128 }, 11129 11130 _colorize = function(m, color, amount) { 11131 var c = _parseColor(color), 11132 r = c[0] / 255, 11133 g = c[1] / 255, 11134 b = c[2] / 255, 11135 inv = 1 - amount; 11136 return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m); 11137 }, 11138 11139 _setHue = function(m, n) { 11140 n *= Math.PI / 180; 11141 var c = Math.cos(n), 11142 s = Math.sin(n); 11143 return _applyMatrix([(_lumR + (c * (1 - _lumR))) + (s * (-_lumR)), (_lumG + (c * (-_lumG))) + (s * (-_lumG)), (_lumB + (c * (-_lumB))) + (s * (1 - _lumB)), 0, 0, (_lumR + (c * (-_lumR))) + (s * 0.143), (_lumG + (c * (1 - _lumG))) + (s * 0.14), (_lumB + (c * (-_lumB))) + (s * -0.283), 0, 0, (_lumR + (c * (-_lumR))) + (s * (-(1 - _lumR))), (_lumG + (c * (-_lumG))) + (s * _lumG), (_lumB + (c * (1 - _lumB))) + (s * _lumB), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m); 11144 }, 11145 11146 _setContrast = function(m, n) { 11147 return _applyMatrix([n,0,0,0,0.5 * (1 - n), 0,n,0,0,0.5 * (1 - n), 0,0,n,0,0.5 * (1 - n), 0,0,0,1,0], m); 11148 }, 11149 11150 _getFilter = function(t, type) { 11151 var filterClass = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].PIXI.filters[type], 11152 filters = t.filters || [], 11153 i = filters.length, 11154 filter; 11155 if (!filterClass) { 11156 throw("PixiPlugin error: " + type + " isn't present."); 11157 } 11158 while (--i > -1) { 11159 if (filters[i] instanceof filterClass) { 11160 return filters[i]; 11161 } 11162 } 11163 filter = new filterClass(); 11164 if (type === "BlurFilter") { 11165 filter.blur = 0; 11166 } 11167 filters.push(filter); 11168 t.filters = filters; 11169 return filter; 11170 }, 11171 11172 _addColorMatrixFilterCacheTween = function(p, pg, cache, vars) { //we cache the ColorMatrixFilter components in a _gsColorMatrixFilter object attached to the target object so that it's easy to grab the current value at any time. 11173 pg._addTween(cache, p, cache[p], vars[p], p); 11174 pg._overwriteProps.push(p); 11175 }, 11176 11177 _applyBrightnessToMatrix = function(brightness, matrix) { 11178 var temp = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].PIXI.filters.ColorMatrixFilter(); 11179 temp.matrix = matrix; 11180 temp.brightness(brightness, true); 11181 return temp.matrix; 11182 }, 11183 11184 _CMFdefaults = {contrast:1, saturation:1, colorizeAmount:0, colorize:"rgb(255,255,255)", hue:0, brightness:1}, 11185 11186 _parseColorMatrixFilter = function(t, v, pg) { 11187 var filter = _getFilter(t, "ColorMatrixFilter"), 11188 cache = t._gsColorMatrixFilter = t._gsColorMatrixFilter || {contrast:1, saturation:1, colorizeAmount:0, colorize:"rgb(255,255,255)", hue:0, brightness:1}, 11189 combine = v.combineCMF && !("colorMatrixFilter" in v && !v.colorMatrixFilter), 11190 i, matrix, startMatrix; 11191 startMatrix = filter.matrix; 11192 if (v.resolution) { 11193 filter.resolution = v.resolution; 11194 } 11195 if (v.matrix && v.matrix.length === startMatrix.length) { 11196 matrix = v.matrix; 11197 if (cache.contrast !== 1) { 11198 _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults); 11199 } 11200 if (cache.hue) { 11201 _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults); 11202 } 11203 if (cache.brightness !== 1) { 11204 _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults); 11205 } 11206 if (cache.colorizeAmount) { 11207 _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults); 11208 _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults); 11209 } 11210 if (cache.saturation !== 1) { 11211 _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults); 11212 } 11213 11214 } else { 11215 matrix = _idMatrix.slice(); 11216 if (v.contrast != null) { 11217 matrix = _setContrast(matrix, Number(v.contrast)); 11218 _addColorMatrixFilterCacheTween("contrast", pg, cache, v); 11219 } else if (cache.contrast !== 1) { 11220 if (combine) { 11221 matrix = _setContrast(matrix, cache.contrast); 11222 } else { 11223 _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults); 11224 } 11225 } 11226 if (v.hue != null) { 11227 matrix = _setHue(matrix, Number(v.hue)); 11228 _addColorMatrixFilterCacheTween("hue", pg, cache, v); 11229 } else if (cache.hue) { 11230 if (combine) { 11231 matrix = _setHue(matrix, cache.hue); 11232 } else { 11233 _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults); 11234 } 11235 } 11236 if (v.brightness != null) { 11237 matrix = _applyBrightnessToMatrix(Number(v.brightness), matrix); 11238 _addColorMatrixFilterCacheTween("brightness", pg, cache, v); 11239 } else if (cache.brightness !== 1) { 11240 if (combine) { 11241 matrix = _applyBrightnessToMatrix(cache.brightness, matrix); 11242 } else { 11243 _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults); 11244 } 11245 } 11246 if (v.colorize != null) { 11247 v.colorizeAmount = ("colorizeAmount" in v) ? Number(v.colorizeAmount) : 1; 11248 matrix = _colorize(matrix, v.colorize, v.colorizeAmount); 11249 _addColorMatrixFilterCacheTween("colorize", pg, cache, v); 11250 _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, v); 11251 } else if (cache.colorizeAmount) { 11252 if (combine) { 11253 matrix = _colorize(matrix, cache.colorize, cache.colorizeAmount); 11254 } else { 11255 _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults); 11256 _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults); 11257 } 11258 } 11259 if (v.saturation != null) { 11260 matrix = _setSaturation(matrix, Number(v.saturation)); 11261 _addColorMatrixFilterCacheTween("saturation", pg, cache, v); 11262 } else if (cache.saturation !== 1) { 11263 if (combine) { 11264 matrix = _setSaturation(matrix, cache.saturation); 11265 } else { 11266 _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults); 11267 } 11268 } 11269 } 11270 i = matrix.length; 11271 while (--i > -1) { 11272 if (matrix[i] !== startMatrix[i]) { 11273 pg._addTween(startMatrix, i, startMatrix[i], matrix[i], "colorMatrixFilter"); 11274 } 11275 } 11276 pg._overwriteProps.push("colorMatrixFilter"); 11277 }, 11278 11279 _addColorTween = function(target, p, value, colorSetter, plugin) { 11280 var pt = colorSetter._firstPT = {_next:colorSetter._firstPT, t:target, p:p, proxy:{}, f:(typeof(target[p]) === "function")}; 11281 pt.proxy[p] = "rgb(" + _parseColor(!pt.f ? target[p] : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ]()).join(",") + ")"; 11282 plugin._addTween(pt.proxy, p, "get", ((typeof(value) === "number") ? "rgb(" + _parseColor(value, false).join(",") + ")" : value), p, null, null, _colorStringFilter); 11283 }, 11284 11285 //to improve performance, when a color is sensed, we hijack the setRatio() method of the plugin instance with a new function that this method spits back. This is a special method that handles parsing color values on-the-fly and turns them into numeric values which PixiJS requires. In other words, instead of "rgb(255, 0, 0)", PixiJS wants 0xFF0000. This also works with hsl() values. 11286 _buildColorSetter = function(tween, plugin) { 11287 var setRatio = plugin.setRatio, //save the original (super) setRatio() function 11288 func = function(v) { 11289 var pt = func._firstPT, 11290 val; 11291 setRatio.call(plugin, v); 11292 while (pt) { 11293 val = _parseColor(pt.proxy[pt.p], "number"); 11294 if (pt.f) { 11295 pt.t[pt.p](val); 11296 } else { 11297 pt.t[pt.p] = val; 11298 } 11299 pt = pt._next; 11300 } 11301 if (func.graphics) { //in order for PixiJS to actually redraw GraphicsData, we've gotta increment the "dirty" and "clearDirty" values. If we don't do this, the values will be tween properly, but not rendered. 11302 func.graphics.dirty++; 11303 func.graphics.clearDirty++; 11304 } 11305 }; 11306 plugin.setRatio = func; 11307 return func; 11308 }, 11309 11310 11311 _colorProps = {tint:1, lineColor:1, fillColor:1}, 11312 _xyContexts = "position,scale,skew,pivot,anchor,tilePosition,tileScale".split(","), 11313 _contexts = {x:"position", y:"position", tileX:"tilePosition", tileY:"tilePosition"}, 11314 _colorMatrixFilterProps = {colorMatrixFilter:1, saturation:1, contrast:1, hue:1, colorize:1, colorizeAmount:1, brightness:1, combineCMF:1}, 11315 _DEG2RAD = Math.PI / 180, 11316 _degreesToRadians = function(value) { 11317 return (typeof(value) === "string" && value.charAt(1) === "=") ? value.substr(0, 2) + (parseFloat(value.substr(2)) * _DEG2RAD) : value * _DEG2RAD; 11318 }, i, p; 11319 11320 //context setup... 11321 for (i = 0; i < _xyContexts.length; i++) { 11322 p = _xyContexts[i]; 11323 _contexts[p + "X"] = p; 11324 _contexts[p + "Y"] = p; 11325 } 11326 11327 //color parsing setup... 11328 for (p in _colorLookup) { 11329 _colorExp += "|" + p + "\\b"; 11330 } 11331 _colorExp = new RegExp(_colorExp+")", "gi"); 11332 _colorStringFilter = function(a) { 11333 var combined = a[0] + " " + a[1], 11334 toHSL; 11335 _colorExp.lastIndex = 0; 11336 if (_colorExp.test(combined)) { 11337 toHSL = (combined.indexOf("hsl(") !== -1 || combined.indexOf("hsla(") !== -1); 11338 a[0] = _formatColors(a[0], toHSL); 11339 a[1] = _formatColors(a[1], toHSL); 11340 } 11341 }; 11342 11343 if (!TweenLite.defaultStringFilter) { 11344 TweenLite.defaultStringFilter = _colorStringFilter; 11345 } 11346 11347 var PixiPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 11348 propName: "pixi", 11349 priority: 0, 11350 API: 2, 11351 global: true, 11352 version: "0.2.1", 11353 11354 init: function (target, values, tween, index) { 11355 if (!target instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].PIXI.DisplayObject) { 11356 return false; 11357 } 11358 var context, axis, value, colorMatrix, filter, p, padding, colorSetter, i, data, pt; 11359 for (p in values) { 11360 context = _contexts[p]; 11361 value = values[p]; 11362 if (typeof(value) === "function") { 11363 value = value(index || 0, target); 11364 } 11365 if (context) { 11366 axis = (p.charAt(p.length-1).toLowerCase().indexOf("x") !== -1) ? "x" : "y"; 11367 this._addTween(target[context], axis, target[context][axis], (context === "skew") ? _degreesToRadians(value) : value, p); 11368 } else if (p === "scale" || p === "anchor" || p === "pivot" || p === "tileScale") { 11369 this._addTween(target[p], "x", target[p].x, value, p + "X"); 11370 this._addTween(target[p], "y", target[p].y, value, p + "Y"); 11371 } else if (p === "rotation") { //PIXI expects rotation in radians, but as a convenience we let folks define it in degrees and we do the conversion. 11372 this._addTween(target, p, target.rotation, _degreesToRadians(value), p); 11373 11374 } else if (_colorMatrixFilterProps[p]) { 11375 if (!colorMatrix) { 11376 _parseColorMatrixFilter(target, values.colorMatrixFilter || values, this); 11377 colorMatrix = true; 11378 } 11379 } else if (p === "blur" || p === "blurX" || p === "blurY" || p === "blurPadding") { 11380 filter = _getFilter(target, "BlurFilter"); 11381 this._addTween(filter, p, filter[p], value, p); 11382 if (values.blurPadding !== 0) { 11383 padding = values.blurPadding || Math.max(filter[p], value) * 2; 11384 i = target.filters.length; 11385 while (--i > -1) { 11386 target.filters[i].padding = Math.max(target.filters[i].padding, padding); //if we don't expand the padding on all the filters, it can look clipped. 11387 } 11388 } 11389 } else if (_colorProps[p]) { 11390 if (!colorSetter) { 11391 colorSetter = _buildColorSetter(tween, this); 11392 } 11393 if ((p === "lineColor" || p === "fillColor") && target instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].PIXI.Graphics) { 11394 data = target.graphicsData; 11395 i = data.length; 11396 while (--i > -1) { 11397 _addColorTween(data[i], p, value, colorSetter, this); 11398 } 11399 colorSetter.graphics = target; 11400 } else { 11401 _addColorTween(target, p, value, colorSetter, this); 11402 } 11403 } else if (p === "autoAlpha") { 11404 this._firstPT = pt = {t: {setRatio:function() { target.visible = !!target.alpha; }}, p: "setRatio", s: 0, c: 1, f: 1, pg: 0, n: "visible", pr: 0, m: 0, _next:this._firstPT}; 11405 if (pt._next) { 11406 pt._next._prev = pt; 11407 } 11408 this._addTween(target, "alpha", target.alpha, value, "alpha"); 11409 this._overwriteProps.push("alpha", "visible"); 11410 } else { 11411 this._addTween(target, p, target[p], value, p); 11412 } 11413 this._overwriteProps.push(p); 11414 } 11415 return true; 11416 } 11417 }); 11418 11419 PixiPlugin.colorProps = _colorProps; 11420 PixiPlugin.parseColor = _parseColor; 11421 PixiPlugin.formatColors = _formatColors; 11422 PixiPlugin.colorStringFilter = _colorStringFilter; 11423 11424 11425 11426/***/ }), 11427
vendor: 4,084 bytes, lines 11428-11546
11428/***/ "./node_modules/gsap/RoundPropsPlugin.js": 11429/*!***********************************************!*\ 11430 !*** ./node_modules/gsap/RoundPropsPlugin.js ***! 11431 \***********************************************/ 11432/*! exports provided: RoundPropsPlugin, _getRoundFunc, _roundLinkedList, p, default */ 11433/***/ (function(module, __webpack_exports__, __webpack_require__) { 11434 11435"use strict"; 11436__webpack_require__.r(__webpack_exports__); 11437/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RoundPropsPlugin", function() { return RoundPropsPlugin; }); 11438/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_getRoundFunc", function() { return _getRoundFunc; }); 11439/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_roundLinkedList", function() { return _roundLinkedList; }); 11440/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return p; }); 11441/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return RoundPropsPlugin; }); 11442/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 11443/*! 11444 * VERSION: 1.6.0 11445 * DATE: 2018-08-27 11446 * UPDATES AND DOCS AT: http://greensock.com 11447 * 11448 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 11449 * This work is subject to the terms at http://greensock.com/standard-license or for 11450 * Club GreenSock members, the software agreement that was issued with your membership. 11451 * 11452 * @author: Jack Doyle, [email protected] 11453 **/ 11454/* eslint-disable */ 11455 11456 11457 11458var RoundPropsPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 11459 propName: "roundProps", 11460 version: "1.7.0", 11461 priority: -1, 11462 API: 2, 11463 11464 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 11465 init: function(target, value, tween) { 11466 this._tween = tween; 11467 return true; 11468 } 11469 11470 }), 11471 _getRoundFunc = function(v) { //pass in 0.1 get a function that'll round to the nearest tenth, or 5 to round to the closest 5, or 0.001 to the closest 1000th, etc. 11472 var p = v < 1 ? Math.pow(10, (v + "").length - 2) : 1; //to avoid floating point math errors (like 24 * 0.1 == 2.4000000000000004), we chop off at a specific number of decimal places (much faster than toFixed() 11473 return function(n) { 11474 return ((Math.round(n / v) * v * p) | 0) / p; 11475 }; 11476 }, 11477 _roundLinkedList = function(node, mod) { 11478 while (node) { 11479 if (!node.f && !node.blob) { 11480 node.m = mod || Math.round; 11481 } 11482 node = node._next; 11483 } 11484 }, 11485 p = RoundPropsPlugin.prototype; 11486 11487 p._onInitAllProps = function() { 11488 var tween = this._tween, 11489 rp = tween.vars.roundProps, 11490 lookup = {}, 11491 rpt = tween._propLookup.roundProps, 11492 pt, next, i, p; 11493 if (typeof(rp) === "object" && !rp.push) { 11494 for (p in rp) { 11495 lookup[p] = _getRoundFunc(rp[p]); 11496 } 11497 } else { 11498 if (typeof(rp) === "string") { 11499 rp = rp.split(","); 11500 } 11501 i = rp.length; 11502 while (--i > -1) { 11503 lookup[rp[i]] = Math.round; 11504 } 11505 } 11506 11507 for (p in lookup) { 11508 pt = tween._firstPT; 11509 while (pt) { 11510 next = pt._next; //record here, because it may get removed 11511 if (pt.pg) { 11512 pt.t._mod(lookup); 11513 } else if (pt.n === p) { 11514 if (pt.f === 2 && pt.t) { //a blob (text containing multiple numeric values) 11515 _roundLinkedList(pt.t._firstPT, lookup[p]); 11516 } else { 11517 this._add(pt.t, p, pt.s, pt.c, lookup[p]); 11518 //remove from linked list 11519 if (next) { 11520 next._prev = pt._prev; 11521 } 11522 if (pt._prev) { 11523 pt._prev._next = next; 11524 } else if (tween._firstPT === pt) { 11525 tween._firstPT = next; 11526 } 11527 pt._next = pt._prev = null; 11528 tween._propLookup[p] = rpt; 11529 } 11530 } 11531 pt = next; 11532 } 11533 } 11534 return false; 11535 }; 11536 11537 p._add = function(target, p, s, c, mod) { 11538 this._addTween(target, p, s, s + c, p, mod || Math.round); 11539 this._overwriteProps.push(p); 11540 }; 11541 11542 11543 11544 11545/***/ }), 11546
vendor: 8,240 bytes, lines 11547-11743
11547/***/ "./node_modules/gsap/ScrollToPlugin.js": 11548/*!*********************************************!*\ 11549 !*** ./node_modules/gsap/ScrollToPlugin.js ***! 11550 \*********************************************/ 11551/*! exports provided: ScrollToPlugin, default */ 11552/***/ (function(module, __webpack_exports__, __webpack_require__) { 11553 11554"use strict"; 11555__webpack_require__.r(__webpack_exports__); 11556/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ScrollToPlugin", function() { return ScrollToPlugin; }); 11557/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ScrollToPlugin; }); 11558/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 11559/*! 11560 * VERSION: 1.9.2 11561 * DATE: 2019-02-07 11562 * UPDATES AND DOCS AT: http://greensock.com 11563 * 11564 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 11565 * This work is subject to the terms at http://greensock.com/standard-license or for 11566 * Club GreenSock members, the software agreement that was issued with your membership. 11567 * 11568 * @author: Jack Doyle, [email protected] 11569 **/ 11570/* eslint-disable */ 11571 11572 11573 11574 11575var _doc = (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"].document || {}).documentElement, 11576 _window = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"], 11577 _max = function(element, axis) { 11578 var dim = (axis === "x") ? "Width" : "Height", 11579 scroll = "scroll" + dim, 11580 client = "client" + dim, 11581 body = document.body; 11582 return (element === _window || element === _doc || element === body) ? Math.max(_doc[scroll], body[scroll]) - (_window["inner" + dim] || _doc[client] || body[client]) : element[scroll] - element["offset" + dim]; 11583 }, 11584 _unwrapElement = function(value) { 11585 if (typeof(value) === "string") { 11586 value = TweenLite.selector(value); 11587 } 11588 if (value.length && value !== _window && value[0] && value[0].style && !value.nodeType) { 11589 value = value[0]; 11590 } 11591 return (value === _window || (value.nodeType && value.style)) ? value : null; 11592 }, 11593 _buildGetter = function(e, axis) { //pass in an element and an axis ("x" or "y") and it'll return a getter function for the scroll position of that element (like scrollTop or scrollLeft, although if the element is the window, it'll use the pageXOffset/pageYOffset or the documentElement's scrollTop/scrollLeft or document.body's. Basically this streamlines things and makes a very fast getter across browsers. 11594 var p = "scroll" + ((axis === "x") ? "Left" : "Top"); 11595 if (e === _window) { 11596 if (e.pageXOffset != null) { 11597 p = "page" + axis.toUpperCase() + "Offset"; 11598 } else if (_doc[p] != null) { 11599 e = _doc; 11600 } else { 11601 e = document.body; 11602 } 11603 } 11604 return function() { 11605 return e[p]; 11606 }; 11607 }, 11608 _getOffset = function(element, container) { 11609 var rect = _unwrapElement(element).getBoundingClientRect(), 11610 b = document.body, 11611 isRoot = (!container || container === _window || container === b), 11612 cRect = isRoot ? {top:_doc.clientTop - (window.pageYOffset || _doc.scrollTop || b.scrollTop || 0), left:_doc.clientLeft - (window.pageXOffset || _doc.scrollLeft || b.scrollLeft || 0)} : container.getBoundingClientRect(), 11613 offsets = {x: rect.left - cRect.left, y: rect.top - cRect.top}; 11614 if (!isRoot && container) { //only add the current scroll position if it's not the window/body. 11615 offsets.x += _buildGetter(container, "x")(); 11616 offsets.y += _buildGetter(container, "y")(); 11617 } 11618 return offsets; 11619 /* PREVIOUS 11620 var rect = _unwrapElement(element).getBoundingClientRect(), 11621 isRoot = (!container || container === _window || container === document.body), 11622 cRect = (isRoot ? _doc : container).getBoundingClientRect(), 11623 offsets = {x: rect.left - cRect.left, y: rect.top - cRect.top}; 11624 if (!isRoot && container) { //only add the current scroll position if it's not the window/body. 11625 offsets.x += _buildGetter(container, "x")(); 11626 offsets.y += _buildGetter(container, "y")(); 11627 } 11628 return offsets; 11629 */ 11630 }, 11631 _parseVal = function(value, target, axis, currentVal) { 11632 var type = typeof(value); 11633 return !isNaN(value) ? parseFloat(value) : (type === "string" && value.charAt(1) === "=") ? parseInt(value.charAt(0) + "1", 10) * parseFloat(value.substr(2)) + currentVal : (value === "max") ? _max(target, axis) : Math.min(_max(target, axis), _getOffset(value, target)[axis]); 11634 }, 11635 11636 ScrollToPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 11637 propName: "scrollTo", 11638 API: 2, 11639 global: true, 11640 version:"1.9.2", 11641 11642 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 11643 init: function(target, value, tween) { 11644 this._wdw = (target === _window); 11645 this._target = target; 11646 this._tween = tween; 11647 if (typeof(value) !== "object") { 11648 value = {y:value}; //if we don't receive an object as the parameter, assume the user intends "y". 11649 if (typeof(value.y) === "string" && value.y !== "max" && value.y.charAt(1) !== "=") { 11650 value.x = value.y; 11651 } 11652 } else if (value.nodeType) { 11653 value = {y:value, x:value}; 11654 } 11655 this.vars = value; 11656 this._autoKill = (value.autoKill !== false); 11657 this.getX = _buildGetter(target, "x"); 11658 this.getY = _buildGetter(target, "y"); 11659 this.x = this.xPrev = this.getX(); 11660 this.y = this.yPrev = this.getY(); 11661 if (value.x != null) { 11662 this._addTween(this, "x", this.x, _parseVal(value.x, target, "x", this.x) - (value.offsetX || 0), "scrollTo_x", true); 11663 this._overwriteProps.push("scrollTo_x"); 11664 } else { 11665 this.skipX = true; 11666 } 11667 if (value.y != null) { 11668 this._addTween(this, "y", this.y, _parseVal(value.y, target, "y", this.y) - (value.offsetY || 0), "scrollTo_y", true); 11669 this._overwriteProps.push("scrollTo_y"); 11670 } else { 11671 this.skipY = true; 11672 } 11673 return true; 11674 }, 11675 11676 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 11677 set: function(v) { 11678 this._super.setRatio.call(this, v); 11679 11680 var x = (this._wdw || !this.skipX) ? this.getX() : this.xPrev, 11681 y = (this._wdw || !this.skipY) ? this.getY() : this.yPrev, 11682 yDif = y - this.yPrev, 11683 xDif = x - this.xPrev, 11684 threshold = ScrollToPlugin.autoKillThreshold; 11685 11686 if (this.x < 0) { //can't scroll to a position less than 0! Might happen if someone uses a Back.easeOut or Elastic.easeOut when scrolling back to the top of the page (for example) 11687 this.x = 0; 11688 } 11689 if (this.y < 0) { 11690 this.y = 0; 11691 } 11692 if (this._autoKill) { 11693 //note: iOS has a bug that throws off the scroll by several pixels, so we need to check if it's within 7 pixels of the previous one that we set instead of just looking for an exact match. 11694 if (!this.skipX && (xDif > threshold || xDif < -threshold) && x < _max(this._target, "x")) { 11695 this.skipX = true; //if the user scrolls separately, we should stop tweening! 11696 } 11697 if (!this.skipY && (yDif > threshold || yDif < -threshold) && y < _max(this._target, "y")) { 11698 this.skipY = true; //if the user scrolls separately, we should stop tweening! 11699 } 11700 if (this.skipX && this.skipY) { 11701 this._tween.kill(); 11702 if (this.vars.onAutoKill) { 11703 this.vars.onAutoKill.apply(this.vars.onAutoKillScope || this._tween, this.vars.onAutoKillParams || []); 11704 } 11705 } 11706 } 11707 if (this._wdw) { 11708 _window.scrollTo((!this.skipX) ? this.x : x, (!this.skipY) ? this.y : y); 11709 } else { 11710 if (!this.skipY) { 11711 this._target.scrollTop = this.y; 11712 } 11713 if (!this.skipX) { 11714 this._target.scrollLeft = this.x; 11715 } 11716 } 11717 this.xPrev = this.x; 11718 this.yPrev = this.y; 11719 } 11720 11721 }), 11722 p = ScrollToPlugin.prototype; 11723 11724 ScrollToPlugin.max = _max; 11725 ScrollToPlugin.getOffset = _getOffset; 11726 ScrollToPlugin.buildGetter = _buildGetter; 11727 ScrollToPlugin.autoKillThreshold = 7; 11728 11729 p._kill = function(lookup) { 11730 if (lookup.scrollTo_x) { 11731 this.skipX = true; 11732 } 11733 if (lookup.scrollTo_y) { 11734 this.skipY = true; 11735 } 11736 return this._super._kill.call(this, lookup); 11737 }; 11738 11739 11740 11741 11742/***/ }), 11743
vendor: 6,733 bytes, lines 11744-11915
11744/***/ "./node_modules/gsap/TextPlugin.js": 11745/*!*****************************************!*\ 11746 !*** ./node_modules/gsap/TextPlugin.js ***! 11747 \*****************************************/ 11748/*! exports provided: TextPlugin, default */ 11749/***/ (function(module, __webpack_exports__, __webpack_require__) { 11750 11751"use strict"; 11752__webpack_require__.r(__webpack_exports__); 11753/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TextPlugin", function() { return TextPlugin; }); 11754/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TextPlugin; }); 11755/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 11756/*! 11757 * VERSION: 0.6.2 11758 * DATE: 2018-05-30 11759 * UPDATES AND DOCS AT: http://greensock.com 11760 * 11761 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 11762 * This work is subject to the terms at http://greensock.com/standard-license or for 11763 * Club GreenSock members, the software agreement that was issued with your membership. 11764 * 11765 * @author: Jack Doyle, [email protected] 11766 */ 11767/* eslint-disable */ 11768 11769 11770 11771var _getText = function(e) { 11772 var type = e.nodeType, 11773 result = ""; 11774 if (type === 1 || type === 9 || type === 11) { 11775 if (typeof(e.textContent) === "string") { 11776 return e.textContent; 11777 } else { 11778 for ( e = e.firstChild; e; e = e.nextSibling ) { 11779 result += _getText(e); 11780 } 11781 } 11782 } else if (type === 3 || type === 4) { 11783 return e.nodeValue; 11784 } 11785 return result; 11786 }, 11787 _emoji = "[\uE000-\uF8FF]|\uD83C[\uDC00-\uDFFF]|\uD83D[\uDC00-\uDFFF]|[\u2694-\u2697]|\uD83E[\uDD10-\uDD5D]|[\uD800-\uDBFF][\uDC00-\uDFFF]", 11788 _emojiExp = new RegExp(_emoji), 11789 _emojiAndCharsExp = new RegExp(_emoji + "|.", "g"), 11790 _emojiSafeSplit = function(text, delimiter) { 11791 return ((delimiter === "" || !delimiter) && _emojiExp.test(text)) ? text.match(_emojiAndCharsExp) : text.split(delimiter || ""); 11792 }, 11793 /* //previous emoji-related splitting. New method above is faster and more concise. 11794 _emojiStart = 0xD800, 11795 _emojiEnd = 0xDBFF, 11796 _emojiLowStart = 0xDC00, 11797 _emojiRegionStart = 0x1F1E6, 11798 _emojiRegionEnd = 0x1F1FF, 11799 _emojiModStart = 0x1f3fb, 11800 _emojiModEnd = 0x1f3ff, 11801 _emojiPairCode = function(s) { 11802 return ((s.charCodeAt(0) - _emojiStart) << 10) + (s.charCodeAt(1) - _emojiLowStart) + 0x10000; 11803 }, 11804 _emojiSafeSplit = function(text, delimiter) { //like calling String.split(delimiter) except that it keeps emoji characters together. 11805 if (delimiter !== "") { 11806 return text.split(delimiter); 11807 } 11808 var l = text.length, 11809 a = [], 11810 character, i, emojiPair1, emojiPair2, j; 11811 for (i = 0; i < l; i++) { 11812 character = text.charAt(i); 11813 if ((character.charCodeAt(0) >= _emojiStart && character.charCodeAt(0) <= _emojiEnd) || (text.charCodeAt(i+1) >= 0xFE00 && text.charCodeAt(i+1) <= 0xFE0F)) { //special emoji characters use 2 or 4 unicode characters that we must keep together. 11814 emojiPair1 = _emojiPairCode(text.substr(i, 2)); 11815 emojiPair2 = _emojiPairCode(text.substr(i + 2, 2)); 11816 j = ((emojiPair1 >= _emojiRegionStart && emojiPair1 <= _emojiRegionEnd && emojiPair2 >= _emojiRegionStart && emojiPair2 <= _emojiRegionEnd) || (emojiPair2 >= _emojiModStart && emojiPair2 <= _emojiModEnd)) ? 4 : 2; 11817 a.push(text.substr(i, j)); 11818 i += j - 1; 11819 } else { 11820 a.push(character); 11821 } 11822 } 11823 return a; 11824 }, 11825 */ 11826 TextPlugin = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.plugin({ 11827 propName: "text", 11828 API: 2, 11829 version:"0.6.2", 11830 11831 //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. 11832 init: function(target, value, tween, index) { 11833 var i = target.nodeName.toUpperCase(), 11834 shrt; 11835 if (typeof(value) === "function") { 11836 value = value(index, target); 11837 } 11838 this._svg = (target.getBBox && (i === "TEXT" || i === "TSPAN")); 11839 if (!("innerHTML" in target) && !this._svg) { 11840 return false; 11841 } 11842 this._target = target; 11843 if (typeof(value) !== "object") { 11844 value = {value:value}; 11845 } 11846 if (value.value === undefined) { 11847 this._text = this._original = [""]; 11848 return true; 11849 } 11850 this._delimiter = value.delimiter || ""; 11851 this._original = _emojiSafeSplit(_getText(target).replace(/\s+/g, " "), this._delimiter); 11852 this._text = _emojiSafeSplit(value.value.replace(/\s+/g, " "), this._delimiter); 11853 this._runBackwards = (tween.vars.runBackwards === true); 11854 if (this._runBackwards) { 11855 i = this._original; 11856 this._original = this._text; 11857 this._text = i; 11858 } 11859 if (typeof(value.newClass) === "string") { 11860 this._newClass = value.newClass; 11861 this._hasClass = true; 11862 } 11863 if (typeof(value.oldClass) === "string") { 11864 this._oldClass = value.oldClass; 11865 this._hasClass = true; 11866 } 11867 i = this._original.length - this._text.length; 11868 shrt = (i < 0) ? this._original : this._text; 11869 this._fillChar = value.fillChar || (value.padSpace ? " " : ""); 11870 if (i < 0) { 11871 i = -i; 11872 } 11873 while (--i > -1) { 11874 shrt.push(this._fillChar); 11875 } 11876 return true; 11877 }, 11878 11879 //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) 11880 set: function(ratio) { 11881 if (ratio > 1) { 11882 ratio = 1; 11883 } else if (ratio < 0) { 11884 ratio = 0; 11885 } 11886 if (this._runBackwards) { 11887 ratio = 1 - ratio; 11888 } 11889 var l = this._text.length, 11890 i = (ratio * l + 0.5) | 0, 11891 applyNew, applyOld, str; 11892 if (this._hasClass) { 11893 applyNew = (this._newClass && i !== 0); 11894 applyOld = (this._oldClass && i !== l); 11895 str = (applyNew ? "<span class='" + this._newClass + "'>" : "") + this._text.slice(0, i).join(this._delimiter) + (applyNew ? "</span>" : "") + (applyOld ? "<span class='" + this._oldClass + "'>" : "") + this._delimiter + this._original.slice(i).join(this._delimiter) + (applyOld ? "</span>" : ""); 11896 } else { 11897 str = this._text.slice(0, i).join(this._delimiter) + this._delimiter + this._original.slice(i).join(this._delimiter); 11898 } 11899 if (this._svg) { //SVG text elements don't have an "innerHTML" in Microsoft browsers. 11900 this._target.textContent = str; 11901 } else { 11902 this._target.innerHTML = (this._fillChar === " " && str.indexOf(" ") !== -1) ? str.split(" ").join(" ") : str; 11903 } 11904 } 11905 11906 }), 11907 p = TextPlugin.prototype; 11908 11909 p._newClass = p._oldClass = p._delimiter = ""; 11910 11911 11912 11913 11914/***/ }), 11915
vendor: 39,418 bytes, lines 11916-12776
11916/***/ "./node_modules/gsap/TimelineLite.js": 11917/*!*******************************************!*\ 11918 !*** ./node_modules/gsap/TimelineLite.js ***! 11919 \*******************************************/ 11920/*! exports provided: TimelineLite, default */ 11921/***/ (function(module, __webpack_exports__, __webpack_require__) { 11922 11923"use strict"; 11924__webpack_require__.r(__webpack_exports__); 11925/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TimelineLite", function() { return TimelineLite; }); 11926/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TimelineLite; }); 11927/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 11928/*! 11929 * VERSION: 2.1.2 11930 * DATE: 2019-03-01 11931 * UPDATES AND DOCS AT: http://greensock.com 11932 * 11933 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 11934 * This work is subject to the terms at http://greensock.com/standard-license or for 11935 * Club GreenSock members, the software agreement that was issued with your membership. 11936 * 11937 * @author: Jack Doyle, [email protected] 11938 */ 11939/* eslint-disable */ 11940 11941 11942 11943_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("TimelineLite", ["core.Animation","core.SimpleTimeline","TweenLite"], function() { 11944 11945 var TimelineLite = function(vars) { 11946 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"].call(this, vars); 11947 var self = this, 11948 v = self.vars, 11949 val, p; 11950 self._labels = {}; 11951 self.autoRemoveChildren = !!v.autoRemoveChildren; 11952 self.smoothChildTiming = !!v.smoothChildTiming; 11953 self._sortChildren = true; 11954 self._onUpdate = v.onUpdate; 11955 for (p in v) { 11956 val = v[p]; 11957 if (_isArray(val)) if (val.join("").indexOf("{self}") !== -1) { 11958 v[p] = self._swapSelfInParams(val); 11959 } 11960 } 11961 if (_isArray(v.tweens)) { 11962 self.add(v.tweens, 0, v.align, v.stagger); 11963 } 11964 }, 11965 _tinyNum = 0.00000001, 11966 TweenLiteInternals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]._internals, 11967 _internals = TimelineLite._internals = {}, 11968 _isSelector = TweenLiteInternals.isSelector, 11969 _isArray = TweenLiteInternals.isArray, 11970 _lazyTweens = TweenLiteInternals.lazyTweens, 11971 _lazyRender = TweenLiteInternals.lazyRender, 11972 _globals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.globals, 11973 _copy = function(vars) { 11974 var copy = {}, p; 11975 for (p in vars) { 11976 copy[p] = vars[p]; 11977 } 11978 return copy; 11979 }, 11980 _applyCycle = function(vars, targets, i) { 11981 var alt = vars.cycle, 11982 p, val; 11983 for (p in alt) { 11984 val = alt[p]; 11985 vars[p] = (typeof(val) === "function") ? val(i, targets[i], targets) : val[i % val.length]; 11986 } 11987 delete vars.cycle; 11988 }, 11989 _pauseCallback = _internals.pauseCallback = function() {}, 11990 _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 11991 var b = [], 11992 l = a.length, 11993 i; 11994 for (i = 0; i !== l; b.push(a[i++])); 11995 return b; 11996 }, 11997 _defaultImmediateRender = function(tl, toVars, fromVars, defaultFalse) { //default to immediateRender:true unless otherwise set in toVars, fromVars or if defaultFalse is passed in as true 11998 var ir = "immediateRender"; 11999 if (!(ir in toVars)) { 12000 toVars[ir] = !((fromVars && fromVars[ir] === false) || defaultFalse); 12001 } 12002 return toVars; 12003 }, 12004 //for distributing values across an array. Can accept a number, a function or (most commonly) a function which can contain the following properties: {base, amount, from, ease, grid, axis, length, each}. Returns a function that expects the following parameters: index, target, array. Recognizes the following 12005 _distribute = function(v) { 12006 if (typeof(v) === "function") { 12007 return v; 12008 } 12009 var vars = (typeof(v) === "object") ? v : {each:v}, //n:1 is just to indicate v was a number; we leverage that later to set v according to the length we get. If a number is passed in, we treat it like the old stagger value where 0.1, for example, would mean that things would be distributed with 0.1 between each element in the array rather than a total "amount" that's chunked out among them all. 12010 ease = vars.ease, 12011 from = vars.from || 0, 12012 base = vars.base || 0, 12013 cache = {}, 12014 isFromKeyword = isNaN(from), 12015 axis = vars.axis, 12016 ratio = {center:0.5, end:1}[from] || 0; 12017 return function(i, target, a) { 12018 var l = (a || vars).length, 12019 distances = cache[l], 12020 originX, originY, x, y, d, j, max, min, wrap; 12021 if (!distances) { 12022 wrap = (vars.grid === "auto") ? 0 : (vars.grid || [Infinity])[0]; 12023 if (!wrap) { 12024 max = -Infinity; 12025 while (max < (max = a[wrap++].getBoundingClientRect().left) && wrap < l) { } 12026 wrap--; 12027 } 12028 distances = cache[l] = []; 12029 originX = isFromKeyword ? (Math.min(wrap, l) * ratio) - 0.5 : from % wrap; 12030 originY = isFromKeyword ? l * ratio / wrap - 0.5 : (from / wrap) | 0; 12031 max = 0; 12032 min = Infinity; 12033 for (j = 0; j < l; j++) { 12034 x = (j % wrap) - originX; 12035 y = originY - ((j / wrap) | 0); 12036 distances[j] = d = !axis ? Math.sqrt(x * x + y * y) : Math.abs((axis === "y") ? y : x); 12037 if (d > max) { 12038 max = d; 12039 } 12040 if (d < min) { 12041 min = d; 12042 } 12043 } 12044 distances.max = max - min; 12045 distances.min = min; 12046 distances.v = l = vars.amount || (vars.each * (wrap > l ? l : !axis ? Math.max(wrap, l / wrap) : axis === "y" ? l / wrap : wrap)) || 0; 12047 distances.b = (l < 0) ? base - l : base; 12048 } 12049 l = (distances[i] - distances.min) / distances.max; 12050 return distances.b + (ease ? ease.getRatio(l) : l) * distances.v; 12051 }; 12052 }, 12053 p = TimelineLite.prototype = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"](); 12054 12055 TimelineLite.version = "2.1.2"; 12056 TimelineLite.distribute = _distribute; 12057 p.constructor = TimelineLite; 12058 p.kill()._gc = p._forcingPlayhead = p._hasPause = false; 12059 12060 /* might use later... 12061 //translates a local time inside an animation to the corresponding time on the root/global timeline, factoring in all nesting and timeScales. 12062 function localToGlobal(time, animation) { 12063 while (animation) { 12064 time = (time / animation._timeScale) + animation._startTime; 12065 animation = animation.timeline; 12066 } 12067 return time; 12068 } 12069 12070 //translates the supplied time on the root/global timeline into the corresponding local time inside a particular animation, factoring in all nesting and timeScales 12071 function globalToLocal(time, animation) { 12072 var scale = 1; 12073 time -= localToGlobal(0, animation); 12074 while (animation) { 12075 scale *= animation._timeScale; 12076 animation = animation.timeline; 12077 } 12078 return time * scale; 12079 } 12080 */ 12081 12082 p.to = function(target, duration, vars, position) { 12083 var Engine = (vars.repeat && _globals.TweenMax) || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]; 12084 return duration ? this.add( new Engine(target, duration, vars), position) : this.set(target, vars, position); 12085 }; 12086 12087 p.from = function(target, duration, vars, position) { 12088 return this.add( ((vars.repeat && _globals.TweenMax) || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]).from(target, duration, _defaultImmediateRender(this, vars)), position); 12089 }; 12090 12091 p.fromTo = function(target, duration, fromVars, toVars, position) { 12092 var Engine = (toVars.repeat && _globals.TweenMax) || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]; 12093 toVars = _defaultImmediateRender(this, toVars, fromVars); 12094 return duration ? this.add( Engine.fromTo(target, duration, fromVars, toVars), position) : this.set(target, toVars, position); 12095 }; 12096 12097 p.staggerTo = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 12098 var tl = new TimelineLite({onComplete:onCompleteAll, onCompleteParams:onCompleteAllParams, callbackScope:onCompleteAllScope, smoothChildTiming:this.smoothChildTiming}), 12099 staggerFunc = _distribute(vars.stagger || stagger), 12100 startAt = vars.startAt, 12101 cycle = vars.cycle, 12102 copy, i; 12103 if (typeof(targets) === "string") { 12104 targets = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].selector(targets) || targets; 12105 } 12106 targets = targets || []; 12107 if (_isSelector(targets)) { //if the targets object is a selector, translate it into an array. 12108 targets = _slice(targets); 12109 } 12110 for (i = 0; i < targets.length; i++) { 12111 copy = _copy(vars); 12112 if (startAt) { 12113 copy.startAt = _copy(startAt); 12114 if (startAt.cycle) { 12115 _applyCycle(copy.startAt, targets, i); 12116 } 12117 } 12118 if (cycle) { 12119 _applyCycle(copy, targets, i); 12120 if (copy.duration != null) { 12121 duration = copy.duration; 12122 delete copy.duration; 12123 } 12124 } 12125 tl.to(targets[i], duration, copy, staggerFunc(i, targets[i], targets)); 12126 } 12127 return this.add(tl, position); 12128 }; 12129 12130 p.staggerFrom = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 12131 vars.runBackwards = true; 12132 return this.staggerTo(targets, duration, _defaultImmediateRender(this, vars), stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 12133 }; 12134 12135 p.staggerFromTo = function(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 12136 toVars.startAt = fromVars; 12137 return this.staggerTo(targets, duration, _defaultImmediateRender(this, toVars, fromVars), stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 12138 }; 12139 12140 p.call = function(callback, params, scope, position) { 12141 return this.add( _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0, callback, params, scope), position); 12142 }; 12143 12144 p.set = function(target, vars, position) { 12145 return this.add( new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"](target, 0, _defaultImmediateRender(this, vars, null, true)), position); 12146 }; 12147 12148 TimelineLite.exportRoot = function(vars, ignoreDelayedCalls) { 12149 vars = vars || {}; 12150 if (vars.smoothChildTiming == null) { 12151 vars.smoothChildTiming = true; 12152 } 12153 var tl = new TimelineLite(vars), 12154 root = tl._timeline, 12155 hasNegativeStart, time, tween, next; 12156 if (ignoreDelayedCalls == null) { 12157 ignoreDelayedCalls = true; 12158 } 12159 root._remove(tl, true); 12160 tl._startTime = 0; 12161 tl._rawPrevTime = tl._time = tl._totalTime = root._time; 12162 tween = root._first; 12163 while (tween) { 12164 next = tween._next; 12165 if (!ignoreDelayedCalls || !(tween instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"] && tween.target === tween.vars.onComplete)) { 12166 time = tween._startTime - tween._delay; 12167 if (time < 0) { 12168 hasNegativeStart = 1; 12169 } 12170 tl.add(tween, time); 12171 } 12172 tween = next; 12173 } 12174 root.add(tl, 0); 12175 if (hasNegativeStart) { //calling totalDuration() will force the adjustment necessary to shift the children forward so none of them start before zero, and moves the timeline backwards the same amount, so the playhead is still aligned where it should be globally, but the timeline doesn't have illegal children that start before zero. 12176 tl.totalDuration(); 12177 } 12178 return tl; 12179 }; 12180 12181 p.add = function(value, position, align, stagger) { 12182 var self = this, 12183 curTime, l, i, child, tl, beforeRawTime; 12184 if (typeof(position) !== "number") { 12185 position = self._parseTimeOrLabel(position, 0, true, value); 12186 } 12187 if (!(value instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"])) { 12188 if ((value instanceof Array) || (value && value.push && _isArray(value))) { 12189 align = align || "normal"; 12190 stagger = stagger || 0; 12191 curTime = position; 12192 l = value.length; 12193 for (i = 0; i < l; i++) { 12194 if (_isArray(child = value[i])) { 12195 child = new TimelineLite({tweens:child}); 12196 } 12197 self.add(child, curTime); 12198 if (typeof(child) !== "string" && typeof(child) !== "function") { 12199 if (align === "sequence") { 12200 curTime = child._startTime + (child.totalDuration() / child._timeScale); 12201 } else if (align === "start") { 12202 child._startTime -= child.delay(); 12203 } 12204 } 12205 curTime += stagger; 12206 } 12207 return self._uncache(true); 12208 } else if (typeof(value) === "string") { 12209 return self.addLabel(value, position); 12210 } else if (typeof(value) === "function") { 12211 value = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0, value); 12212 } else { 12213 throw("Cannot add " + value + " into the timeline; it is not a tween, timeline, function, or string."); 12214 } 12215 } 12216 12217 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"].prototype.add.call(self, value, position); 12218 12219 if (value._time || (!value._duration && value._initted)) { //in case, for example, the _startTime is moved on a tween that has already rendered. Imagine it's at its end state, then the startTime is moved WAY later (after the end of this timeline), it should render at its beginning. 12220 curTime = (self.rawTime() - value._startTime) * value._timeScale; 12221 if (!value._duration || Math.abs(Math.max(0, Math.min(value.totalDuration(), curTime))) - value._totalTime > 0.00001) { 12222 value.render(curTime, false, false); 12223 } 12224 } 12225 12226 //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate. 12227 if (self._gc || self._time === self._duration) if (!self._paused) if (self._duration < self.duration()) { 12228 //in case any of the ancestors had completed but should now be enabled... 12229 tl = self; 12230 beforeRawTime = (tl.rawTime() > value._startTime); //if the tween is placed on the timeline so that it starts BEFORE the current rawTime, we should align the playhead (move the timeline). This is because sometimes users will create a timeline, let it finish, and much later append a tween and expect it to run instead of jumping to its end state. While technically one could argue that it should jump to its end state, that's not what users intuitively expect. 12231 while (tl._timeline) { 12232 if (beforeRawTime && tl._timeline.smoothChildTiming) { 12233 tl.totalTime(tl._totalTime, true); //moves the timeline (shifts its startTime) if necessary, and also enables it. 12234 } else if (tl._gc) { 12235 tl._enabled(true, false); 12236 } 12237 tl = tl._timeline; 12238 } 12239 } 12240 12241 return self; 12242 }; 12243 12244 p.remove = function(value) { 12245 if (value instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]) { 12246 this._remove(value, false); 12247 var tl = value._timeline = value.vars.useFrames ? _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootFramesTimeline : _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootTimeline; //now that it's removed, default it to the root timeline so that if it gets played again, it doesn't jump back into this timeline. 12248 value._startTime = (value._paused ? value._pauseTime : tl._time) - ((!value._reversed ? value._totalTime : value.totalDuration() - value._totalTime) / value._timeScale); //ensure that if it gets played again, the timing is correct. 12249 return this; 12250 } else if (value instanceof Array || (value && value.push && _isArray(value))) { 12251 var i = value.length; 12252 while (--i > -1) { 12253 this.remove(value[i]); 12254 } 12255 return this; 12256 } else if (typeof(value) === "string") { 12257 return this.removeLabel(value); 12258 } 12259 return this.kill(null, value); 12260 }; 12261 12262 p._remove = function(tween, skipDisable) { 12263 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"].prototype._remove.call(this, tween, skipDisable); 12264 var last = this._last; 12265 if (!last) { 12266 this._time = this._totalTime = this._duration = this._totalDuration = 0; 12267 } else if (this._time > this.duration()) { 12268 this._time = this._duration; 12269 this._totalTime = this._totalDuration; 12270 } 12271 return this; 12272 }; 12273 12274 p.append = function(value, offsetOrLabel) { 12275 return this.add(value, this._parseTimeOrLabel(null, offsetOrLabel, true, value)); 12276 }; 12277 12278 p.insert = p.insertMultiple = function(value, position, align, stagger) { 12279 return this.add(value, position || 0, align, stagger); 12280 }; 12281 12282 p.appendMultiple = function(tweens, offsetOrLabel, align, stagger) { 12283 return this.add(tweens, this._parseTimeOrLabel(null, offsetOrLabel, true, tweens), align, stagger); 12284 }; 12285 12286 p.addLabel = function(label, position) { 12287 this._labels[label] = this._parseTimeOrLabel(position); 12288 return this; 12289 }; 12290 12291 p.addPause = function(position, callback, params, scope) { 12292 var t = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0, _pauseCallback, params, scope || this); 12293 t.vars.onComplete = t.vars.onReverseComplete = callback; 12294 t.data = "isPause"; 12295 this._hasPause = true; 12296 return this.add(t, position); 12297 }; 12298 12299 p.removeLabel = function(label) { 12300 delete this._labels[label]; 12301 return this; 12302 }; 12303 12304 p.getLabelTime = function(label) { 12305 return (this._labels[label] != null) ? this._labels[label] : -1; 12306 }; 12307 12308 p._parseTimeOrLabel = function(timeOrLabel, offsetOrLabel, appendIfAbsent, ignore) { 12309 var clippedDuration, i; 12310 //if we're about to add a tween/timeline (or an array of them) that's already a child of this timeline, we should remove it first so that it doesn't contaminate the duration(). 12311 if (ignore instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"] && ignore.timeline === this) { 12312 this.remove(ignore); 12313 } else if (ignore && ((ignore instanceof Array) || (ignore.push && _isArray(ignore)))) { 12314 i = ignore.length; 12315 while (--i > -1) { 12316 if (ignore[i] instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"] && ignore[i].timeline === this) { 12317 this.remove(ignore[i]); 12318 } 12319 } 12320 } 12321 clippedDuration = (typeof(timeOrLabel) === "number" && !offsetOrLabel) ? 0 : (this.duration() > 99999999999) ? this.recent().endTime(false) : this._duration; //in case there's a child that infinitely repeats, users almost never intend for the insertion point of a new child to be based on a SUPER long value like that so we clip it and assume the most recently-added child's endTime should be used instead. 12322 if (typeof(offsetOrLabel) === "string") { 12323 return this._parseTimeOrLabel(offsetOrLabel, (appendIfAbsent && typeof(timeOrLabel) === "number" && this._labels[offsetOrLabel] == null) ? timeOrLabel - clippedDuration : 0, appendIfAbsent); 12324 } 12325 offsetOrLabel = offsetOrLabel || 0; 12326 if (typeof(timeOrLabel) === "string" && (isNaN(timeOrLabel) || this._labels[timeOrLabel] != null)) { //if the string is a number like "1", check to see if there's a label with that name, otherwise interpret it as a number (absolute value). 12327 i = timeOrLabel.indexOf("="); 12328 if (i === -1) { 12329 if (this._labels[timeOrLabel] == null) { 12330 return appendIfAbsent ? (this._labels[timeOrLabel] = clippedDuration + offsetOrLabel) : offsetOrLabel; 12331 } 12332 return this._labels[timeOrLabel] + offsetOrLabel; 12333 } 12334 offsetOrLabel = parseInt(timeOrLabel.charAt(i-1) + "1", 10) * Number(timeOrLabel.substr(i+1)); 12335 timeOrLabel = (i > 1) ? this._parseTimeOrLabel(timeOrLabel.substr(0, i-1), 0, appendIfAbsent) : clippedDuration; 12336 } else if (timeOrLabel == null) { 12337 timeOrLabel = clippedDuration; 12338 } 12339 return Number(timeOrLabel) + offsetOrLabel; 12340 }; 12341 12342 p.seek = function(position, suppressEvents) { 12343 return this.totalTime((typeof(position) === "number") ? position : this._parseTimeOrLabel(position), (suppressEvents !== false)); 12344 }; 12345 12346 p.stop = function() { 12347 return this.paused(true); 12348 }; 12349 12350 p.gotoAndPlay = function(position, suppressEvents) { 12351 return this.play(position, suppressEvents); 12352 }; 12353 12354 p.gotoAndStop = function(position, suppressEvents) { 12355 return this.pause(position, suppressEvents); 12356 }; 12357 12358 p.render = function(time, suppressEvents, force) { 12359 if (this._gc) { 12360 this._enabled(true, false); 12361 } 12362 var self = this, 12363 prevTime = self._time, 12364 totalDur = (!self._dirty) ? self._totalDuration : self.totalDuration(), 12365 prevStart = self._startTime, 12366 prevTimeScale = self._timeScale, 12367 prevPaused = self._paused, 12368 tween, isComplete, next, callback, internalForce, pauseTween, curTime, pauseTime; 12369 if (prevTime !== self._time) { //if totalDuration() finds a child with a negative startTime and smoothChildTiming is true, things get shifted around internally so we need to adjust the time accordingly. For example, if a tween starts at -30 we must shift EVERYTHING forward 30 seconds and move this timeline's startTime backward by 30 seconds so that things align with the playhead (no jump). 12370 time += self._time - prevTime; 12371 } 12372 if (time >= totalDur - _tinyNum && time >= 0) { //to work around occasional floating point math artifacts. 12373 self._totalTime = self._time = totalDur; 12374 if (!self._reversed) if (!self._hasPausedChild()) { 12375 isComplete = true; 12376 callback = "onComplete"; 12377 internalForce = !!self._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 12378 if (self._duration === 0) if ((time <= 0 && time >= -_tinyNum) || self._rawPrevTime < 0 || self._rawPrevTime === _tinyNum) if (self._rawPrevTime !== time && self._first) { 12379 internalForce = true; 12380 if (self._rawPrevTime > _tinyNum) { 12381 callback = "onReverseComplete"; 12382 } 12383 } 12384 } 12385 self._rawPrevTime = (self._duration || !suppressEvents || time || self._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 12386 time = totalDur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. 12387 12388 } else if (time < _tinyNum) { //to work around occasional floating point math artifacts, round super small values to 0. 12389 self._totalTime = self._time = 0; 12390 if (time > -_tinyNum) { 12391 time = 0; 12392 } 12393 if (prevTime !== 0 || (self._duration === 0 && self._rawPrevTime !== _tinyNum && (self._rawPrevTime > 0 || (time < 0 && self._rawPrevTime >= 0)))) { 12394 callback = "onReverseComplete"; 12395 isComplete = self._reversed; 12396 } 12397 if (time < 0) { 12398 self._active = false; 12399 if (self._timeline.autoRemoveChildren && self._reversed) { //ensures proper GC if a timeline is resumed after it's finished reversing. 12400 internalForce = isComplete = true; 12401 callback = "onReverseComplete"; 12402 } else if (self._rawPrevTime >= 0 && self._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. 12403 internalForce = true; 12404 } 12405 self._rawPrevTime = time; 12406 } else { 12407 self._rawPrevTime = (self._duration || !suppressEvents || time || self._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 12408 if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). 12409 tween = self._first; 12410 while (tween && tween._startTime === 0) { 12411 if (!tween._duration) { 12412 isComplete = false; 12413 } 12414 tween = tween._next; 12415 } 12416 } 12417 time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) 12418 if (!self._initted) { 12419 internalForce = true; 12420 } 12421 } 12422 12423 } else { 12424 12425 if (self._hasPause && !self._forcingPlayhead && !suppressEvents) { 12426 if (time >= prevTime) { 12427 tween = self._first; 12428 while (tween && tween._startTime <= time && !pauseTween) { 12429 if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && self._rawPrevTime === 0)) { 12430 pauseTween = tween; 12431 } 12432 tween = tween._next; 12433 } 12434 } else { 12435 tween = self._last; 12436 while (tween && tween._startTime >= time && !pauseTween) { 12437 if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { 12438 pauseTween = tween; 12439 } 12440 tween = tween._prev; 12441 } 12442 } 12443 if (pauseTween) { 12444 self._time = self._totalTime = time = pauseTween._startTime; 12445 pauseTime = self._startTime + (time / self._timeScale); 12446 } 12447 } 12448 12449 self._totalTime = self._time = self._rawPrevTime = time; 12450 } 12451 if ((self._time === prevTime || !self._first) && !force && !internalForce && !pauseTween) { 12452 return; 12453 } else if (!self._initted) { 12454 self._initted = true; 12455 } 12456 12457 if (!self._active) if (!self._paused && self._time !== prevTime && time > 0) { 12458 self._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. 12459 } 12460 12461 if (prevTime === 0) if (self.vars.onStart) if (self._time !== 0 || !self._duration) if (!suppressEvents) { 12462 self._callback("onStart"); 12463 } 12464 12465 curTime = self._time; 12466 if (curTime >= prevTime) { 12467 tween = self._first; 12468 while (tween) { 12469 next = tween._next; //record it here because the value could change after rendering... 12470 if (curTime !== self._time || (self._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 12471 break; 12472 } else if (tween._active || (tween._startTime <= curTime && !tween._paused && !tween._gc)) { 12473 if (pauseTween === tween) { 12474 self.pause(); 12475 self._pauseTime = pauseTime; //so that when we resume(), it's starting from exactly the right spot (the pause() method uses the rawTime for the parent, but that may be a bit too far ahead) 12476 } 12477 if (!tween._reversed) { 12478 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 12479 } else { 12480 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 12481 } 12482 } 12483 tween = next; 12484 } 12485 } else { 12486 tween = self._last; 12487 while (tween) { 12488 next = tween._prev; //record it here because the value could change after rendering... 12489 if (curTime !== self._time || (self._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 12490 break; 12491 } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { 12492 if (pauseTween === tween) { 12493 pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. 12494 while (pauseTween && pauseTween.endTime() > self._time) { 12495 pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); 12496 pauseTween = pauseTween._prev; 12497 } 12498 pauseTween = null; 12499 self.pause(); 12500 self._pauseTime = pauseTime; //so that when we resume(), it's starting from exactly the right spot (the pause() method uses the rawTime for the parent, but that may be a bit too far ahead) 12501 } 12502 if (!tween._reversed) { 12503 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 12504 } else { 12505 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 12506 } 12507 } 12508 tween = next; 12509 } 12510 } 12511 12512 if (self._onUpdate) if (!suppressEvents) { 12513 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. 12514 _lazyRender(); 12515 } 12516 self._callback("onUpdate"); 12517 } 12518 12519 if (callback) if (!self._gc) if (prevStart === self._startTime || prevTimeScale !== self._timeScale) if (self._time === 0 || totalDur >= self.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate 12520 if (isComplete) { 12521 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. 12522 _lazyRender(); 12523 } 12524 if (self._timeline.autoRemoveChildren) { 12525 self._enabled(false, false); 12526 } 12527 self._active = false; 12528 } 12529 if (!suppressEvents && self.vars[callback]) { 12530 self._callback(callback); 12531 } 12532 } 12533 }; 12534 12535 p._hasPausedChild = function() { 12536 var tween = this._first; 12537 while (tween) { 12538 if (tween._paused || ((tween instanceof TimelineLite) && tween._hasPausedChild())) { 12539 return true; 12540 } 12541 tween = tween._next; 12542 } 12543 return false; 12544 }; 12545 12546 p.getChildren = function(nested, tweens, timelines, ignoreBeforeTime) { 12547 ignoreBeforeTime = ignoreBeforeTime || -9999999999; 12548 var a = [], 12549 tween = this._first, 12550 cnt = 0; 12551 while (tween) { 12552 if (tween._startTime < ignoreBeforeTime) { 12553 //do nothing 12554 } else if (tween instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]) { 12555 if (tweens !== false) { 12556 a[cnt++] = tween; 12557 } 12558 } else { 12559 if (timelines !== false) { 12560 a[cnt++] = tween; 12561 } 12562 if (nested !== false) { 12563 a = a.concat(tween.getChildren(true, tweens, timelines)); 12564 cnt = a.length; 12565 } 12566 } 12567 tween = tween._next; 12568 } 12569 return a; 12570 }; 12571 12572 p.getTweensOf = function(target, nested) { 12573 var disabled = this._gc, 12574 a = [], 12575 cnt = 0, 12576 tweens, i; 12577 if (disabled) { 12578 this._enabled(true, true); //getTweensOf() filters out disabled tweens, and we have to mark them as _gc = true when the timeline completes in order to allow clean garbage collection, so temporarily re-enable the timeline here. 12579 } 12580 tweens = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].getTweensOf(target); 12581 i = tweens.length; 12582 while (--i > -1) { 12583 if (tweens[i].timeline === this || (nested && this._contains(tweens[i]))) { 12584 a[cnt++] = tweens[i]; 12585 } 12586 } 12587 if (disabled) { 12588 this._enabled(false, true); 12589 } 12590 return a; 12591 }; 12592 12593 p.recent = function() { 12594 return this._recent; 12595 }; 12596 12597 p._contains = function(tween) { 12598 var tl = tween.timeline; 12599 while (tl) { 12600 if (tl === this) { 12601 return true; 12602 } 12603 tl = tl.timeline; 12604 } 12605 return false; 12606 }; 12607 12608 p.shiftChildren = function(amount, adjustLabels, ignoreBeforeTime) { 12609 ignoreBeforeTime = ignoreBeforeTime || 0; 12610 var tween = this._first, 12611 labels = this._labels, 12612 p; 12613 while (tween) { 12614 if (tween._startTime >= ignoreBeforeTime) { 12615 tween._startTime += amount; 12616 } 12617 tween = tween._next; 12618 } 12619 if (adjustLabels) { 12620 for (p in labels) { 12621 if (labels[p] >= ignoreBeforeTime) { 12622 labels[p] += amount; 12623 } 12624 } 12625 } 12626 return this._uncache(true); 12627 }; 12628 12629 p._kill = function(vars, target) { 12630 if (!vars && !target) { 12631 return this._enabled(false, false); 12632 } 12633 var tweens = (!target) ? this.getChildren(true, true, false) : this.getTweensOf(target), 12634 i = tweens.length, 12635 changed = false; 12636 while (--i > -1) { 12637 if (tweens[i]._kill(vars, target)) { 12638 changed = true; 12639 } 12640 } 12641 return changed; 12642 }; 12643 12644 p.clear = function(labels) { 12645 var tweens = this.getChildren(false, true, true), 12646 i = tweens.length; 12647 this._time = this._totalTime = 0; 12648 while (--i > -1) { 12649 tweens[i]._enabled(false, false); 12650 } 12651 if (labels !== false) { 12652 this._labels = {}; 12653 } 12654 return this._uncache(true); 12655 }; 12656 12657 p.invalidate = function() { 12658 var tween = this._first; 12659 while (tween) { 12660 tween.invalidate(); 12661 tween = tween._next; 12662 } 12663 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"].prototype.invalidate.call(this);; 12664 }; 12665 12666 p._enabled = function(enabled, ignoreTimeline) { 12667 if (enabled === this._gc) { 12668 var tween = this._first; 12669 while (tween) { 12670 tween._enabled(enabled, true); 12671 tween = tween._next; 12672 } 12673 } 12674 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"].prototype._enabled.call(this, enabled, ignoreTimeline); 12675 }; 12676 12677 p.totalTime = function(time, suppressEvents, uncapped) { 12678 this._forcingPlayhead = true; 12679 var val = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"].prototype.totalTime.apply(this, arguments); 12680 this._forcingPlayhead = false; 12681 return val; 12682 }; 12683 12684 p.duration = function(value) { 12685 if (!arguments.length) { 12686 if (this._dirty) { 12687 this.totalDuration(); //just triggers recalculation 12688 } 12689 return this._duration; 12690 } 12691 if (this.duration() !== 0 && value !== 0) { 12692 this.timeScale(this._duration / value); 12693 } 12694 return this; 12695 }; 12696 12697 p.totalDuration = function(value) { 12698 if (!arguments.length) { 12699 if (this._dirty) { 12700 var max = 0, 12701 self = this, 12702 tween = self._last, 12703 prevStart = 999999999999, 12704 prev, end; 12705 while (tween) { 12706 prev = tween._prev; //record it here in case the tween changes position in the sequence... 12707 if (tween._dirty) { 12708 tween.totalDuration(); //could change the tween._startTime, so make sure the tween's cache is clean before analyzing it. 12709 } 12710 if (tween._startTime > prevStart && self._sortChildren && !tween._paused && !self._calculatingDuration) { //in case one of the tweens shifted out of order, it needs to be re-inserted into the correct position in the sequence 12711 self._calculatingDuration = 1; //prevent endless recursive calls - there are methods that get triggered that check duration/totalDuration when we add(), like _parseTimeOrLabel(). 12712 self.add(tween, tween._startTime - tween._delay); 12713 self._calculatingDuration = 0; 12714 } else { 12715 prevStart = tween._startTime; 12716 } 12717 if (tween._startTime < 0 && !tween._paused) { //children aren't allowed to have negative startTimes unless smoothChildTiming is true, so adjust here if one is found. 12718 max -= tween._startTime; 12719 if (self._timeline.smoothChildTiming) { 12720 self._startTime += tween._startTime / self._timeScale; 12721 self._time -= tween._startTime; 12722 self._totalTime -= tween._startTime; 12723 self._rawPrevTime -= tween._startTime; 12724 } 12725 self.shiftChildren(-tween._startTime, false, -9999999999); 12726 prevStart = 0; 12727 } 12728 end = tween._startTime + (tween._totalDuration / tween._timeScale); 12729 if (end > max) { 12730 max = end; 12731 } 12732 tween = prev; 12733 } 12734 self._duration = self._totalDuration = max; 12735 self._dirty = false; 12736 } 12737 return this._totalDuration; 12738 } 12739 return (value && this.totalDuration()) ? this.timeScale(this._totalDuration / value) : this; 12740 }; 12741 12742 p.paused = function(value) { 12743 if (value === false && this._paused) { //if there's a pause directly at the spot from where we're unpausing, skip it. 12744 var tween = this._first; 12745 while (tween) { 12746 if (tween._startTime === this._time && tween.data === "isPause") { 12747 tween._rawPrevTime = 0; //remember, _rawPrevTime is how zero-duration tweens/callbacks sense directionality and determine whether or not to fire. If _rawPrevTime is the same as _startTime on the next render, it won't fire. 12748 } 12749 tween = tween._next; 12750 } 12751 } 12752 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"].prototype.paused.apply(this, arguments); 12753 }; 12754 12755 p.usesFrames = function() { 12756 var tl = this._timeline; 12757 while (tl._timeline) { 12758 tl = tl._timeline; 12759 } 12760 return (tl === _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootFramesTimeline); 12761 }; 12762 12763 p.rawTime = function(wrapRepeats) { 12764 return (wrapRepeats && (this._paused || (this._repeat && this.time() > 0 && this.totalProgress() < 1))) ? this._totalTime % (this._duration + this._repeatDelay) : this._paused ? this._totalTime : (this._timeline.rawTime(wrapRepeats) - this._startTime) * this._timeScale; 12765 }; 12766 12767 return TimelineLite; 12768 12769 }, true); 12770 12771var TimelineLite = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].TimelineLite; 12772 12773 12774 12775/***/ }), 12776
vendor: 26,883 bytes, lines 12777-13317
12777/***/ "./node_modules/gsap/TimelineMax.js": 12778/*!******************************************!*\ 12779 !*** ./node_modules/gsap/TimelineMax.js ***! 12780 \******************************************/ 12781/*! exports provided: TimelineMax, TimelineLite, default */ 12782/***/ (function(module, __webpack_exports__, __webpack_require__) { 12783 12784"use strict"; 12785__webpack_require__.r(__webpack_exports__); 12786/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TimelineMax", function() { return TimelineMax; }); 12787/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TimelineMax; }); 12788/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 12789/* harmony import */ var _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TimelineLite.js */ "./node_modules/gsap/TimelineLite.js"); 12790/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineLite", function() { return _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"]; }); 12791 12792/*! 12793 * VERSION: 2.1.2 12794 * DATE: 2019-03-01 12795 * UPDATES AND DOCS AT: http://greensock.com 12796 * 12797 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 12798 * This work is subject to the terms at http://greensock.com/standard-license or for 12799 * Club GreenSock members, the software agreement that was issued with your membership. 12800 * 12801 * @author: Jack Doyle, [email protected] 12802 */ 12803/* eslint-disable */ 12804 12805 12806 12807 12808_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("TimelineMax", ["TimelineLite","TweenLite","easing.Ease"], function() { 12809 12810 var TimelineMax = function(vars) { 12811 _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"].call(this, vars); 12812 this._repeat = this.vars.repeat || 0; 12813 this._repeatDelay = this.vars.repeatDelay || 0; 12814 this._cycle = 0; 12815 this._yoyo = !!this.vars.yoyo; 12816 this._dirty = true; 12817 }, 12818 _tinyNum = 0.00000001, 12819 TweenLiteInternals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]._internals, 12820 _lazyTweens = TweenLiteInternals.lazyTweens, 12821 _lazyRender = TweenLiteInternals.lazyRender, 12822 _globals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine.globals, 12823 _easeNone = new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](null, null, 1, 0), 12824 p = TimelineMax.prototype = new _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"](); 12825 12826 p.constructor = TimelineMax; 12827 p.kill()._gc = false; 12828 TimelineMax.version = "2.1.2"; 12829 12830 p.invalidate = function() { 12831 this._yoyo = !!this.vars.yoyo; 12832 this._repeat = this.vars.repeat || 0; 12833 this._repeatDelay = this.vars.repeatDelay || 0; 12834 this._uncache(true); 12835 return _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"].prototype.invalidate.call(this); 12836 }; 12837 12838 p.addCallback = function(callback, position, params, scope) { 12839 return this.add( _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].delayedCall(0, callback, params, scope), position); 12840 }; 12841 12842 p.removeCallback = function(callback, position) { 12843 if (callback) { 12844 if (position == null) { 12845 this._kill(null, callback); 12846 } else { 12847 var a = this.getTweensOf(callback, false), 12848 i = a.length, 12849 time = this._parseTimeOrLabel(position); 12850 while (--i > -1) { 12851 if (a[i]._startTime === time) { 12852 a[i]._enabled(false, false); 12853 } 12854 } 12855 } 12856 } 12857 return this; 12858 }; 12859 12860 p.removePause = function(position) { 12861 return this.removeCallback(_TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"]._internals.pauseCallback, position); 12862 }; 12863 12864 p.tweenTo = function(position, vars) { 12865 vars = vars || {}; 12866 var copy = {ease:_easeNone, useFrames:this.usesFrames(), immediateRender:false, lazy:false}, 12867 Engine = (vars.repeat && _globals.TweenMax) || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"], 12868 duration, p, t; 12869 for (p in vars) { 12870 copy[p] = vars[p]; 12871 } 12872 copy.time = this._parseTimeOrLabel(position); 12873 duration = (Math.abs(Number(copy.time) - this._time) / this._timeScale) || 0.001; 12874 t = new Engine(this, duration, copy); 12875 copy.onStart = function() { 12876 t.target.paused(true); 12877 if (t.vars.time !== t.target.time() && duration === t.duration() && !t.isFromTo) { //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all. 12878 t.duration( Math.abs( t.vars.time - t.target.time()) / t.target._timeScale ).render(t.time(), true, true); //render() right away to ensure that things look right, especially in the case of .tweenTo(0). 12879 } 12880 if (vars.onStart) { //in case the user had an onStart in the vars - we don't want to overwrite it. 12881 vars.onStart.apply(vars.onStartScope || vars.callbackScope || t, vars.onStartParams || []); //don't use t._callback("onStart") or it'll point to the copy.onStart and we'll get a recursion error. 12882 } 12883 }; 12884 return t; 12885 }; 12886 12887 p.tweenFromTo = function(fromPosition, toPosition, vars) { 12888 vars = vars || {}; 12889 fromPosition = this._parseTimeOrLabel(fromPosition); 12890 vars.startAt = {onComplete:this.seek, onCompleteParams:[fromPosition], callbackScope:this}; 12891 vars.immediateRender = (vars.immediateRender !== false); 12892 var t = this.tweenTo(toPosition, vars); 12893 t.isFromTo = 1; //to ensure we don't mess with the duration in the onStart (we've got the start and end values here, so lock it in) 12894 return t.duration((Math.abs( t.vars.time - fromPosition) / this._timeScale) || 0.001); 12895 }; 12896 12897 p.render = function(time, suppressEvents, force) { 12898 if (this._gc) { 12899 this._enabled(true, false); 12900 } 12901 var self = this, 12902 prevTime = self._time, 12903 totalDur = (!self._dirty) ? self._totalDuration : self.totalDuration(), 12904 dur = self._duration, 12905 prevTotalTime = self._totalTime, 12906 prevStart = self._startTime, 12907 prevTimeScale = self._timeScale, 12908 prevRawPrevTime = self._rawPrevTime, 12909 prevPaused = self._paused, 12910 prevCycle = self._cycle, 12911 tween, isComplete, next, callback, internalForce, cycleDuration, pauseTween, curTime, pauseTime; 12912 if (prevTime !== self._time) { //if totalDuration() finds a child with a negative startTime and smoothChildTiming is true, things get shifted around internally so we need to adjust the time accordingly. For example, if a tween starts at -30 we must shift EVERYTHING forward 30 seconds and move this timeline's startTime backward by 30 seconds so that things align with the playhead (no jump). 12913 time += self._time - prevTime; 12914 } 12915 if (time >= totalDur - _tinyNum && time >= 0) { //to work around occasional floating point math artifacts. 12916 if (!self._locked) { 12917 self._totalTime = totalDur; 12918 self._cycle = self._repeat; 12919 } 12920 if (!self._reversed) if (!self._hasPausedChild()) { 12921 isComplete = true; 12922 callback = "onComplete"; 12923 internalForce = !!self._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 12924 if (self._duration === 0) if ((time <= 0 && time >= -_tinyNum) || prevRawPrevTime < 0 || prevRawPrevTime === _tinyNum) if (prevRawPrevTime !== time && self._first) { 12925 internalForce = true; 12926 if (prevRawPrevTime > _tinyNum) { 12927 callback = "onReverseComplete"; 12928 } 12929 } 12930 } 12931 self._rawPrevTime = (self._duration || !suppressEvents || time || self._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 12932 if (self._yoyo && (self._cycle & 1)) { 12933 self._time = time = 0; 12934 } else { 12935 self._time = dur; 12936 time = dur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. We cannot do less then 0.0001 because the same issue can occur when the duration is extremely large like 999999999999 in which case adding 0.00000001, for example, causes it to act like nothing was added. 12937 } 12938 12939 } else if (time < _tinyNum) { //to work around occasional floating point math artifacts, round super small values to 0. 12940 if (!self._locked) { 12941 self._totalTime = self._cycle = 0; 12942 } 12943 self._time = 0; 12944 if (time > -_tinyNum) { 12945 time = 0; 12946 } 12947 if (prevTime !== 0 || (dur === 0 && prevRawPrevTime !== _tinyNum && (prevRawPrevTime > 0 || (time < 0 && prevRawPrevTime >= 0)) && !self._locked)) { //edge case for checking time < 0 && prevRawPrevTime >= 0: a zero-duration fromTo() tween inside a zero-duration timeline (yeah, very rare) 12948 callback = "onReverseComplete"; 12949 isComplete = self._reversed; 12950 } 12951 if (time < 0) { 12952 self._active = false; 12953 if (self._timeline.autoRemoveChildren && self._reversed) { 12954 internalForce = isComplete = true; 12955 callback = "onReverseComplete"; 12956 } else if (prevRawPrevTime >= 0 && self._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. 12957 internalForce = true; 12958 } 12959 self._rawPrevTime = time; 12960 } else { 12961 self._rawPrevTime = (dur || !suppressEvents || time || self._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 12962 if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). 12963 tween = self._first; 12964 while (tween && tween._startTime === 0) { 12965 if (!tween._duration) { 12966 isComplete = false; 12967 } 12968 tween = tween._next; 12969 } 12970 } 12971 time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) 12972 if (!self._initted) { 12973 internalForce = true; 12974 } 12975 } 12976 12977 } else { 12978 if (dur === 0 && prevRawPrevTime < 0) { //without this, zero-duration repeating timelines (like with a simple callback nested at the very beginning and a repeatDelay) wouldn't render the first time through. 12979 internalForce = true; 12980 } 12981 self._time = self._rawPrevTime = time; 12982 if (!self._locked) { 12983 self._totalTime = time; 12984 if (self._repeat !== 0) { 12985 cycleDuration = dur + self._repeatDelay; 12986 self._cycle = (self._totalTime / cycleDuration) >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but it gets reported as 0.79999999!) 12987 if (self._cycle) if (self._cycle === self._totalTime / cycleDuration && prevTotalTime <= time) { 12988 self._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning) 12989 } 12990 self._time = self._totalTime - (self._cycle * cycleDuration); 12991 if (self._yoyo) if (self._cycle & 1) { 12992 self._time = dur - self._time; 12993 } 12994 if (self._time > dur) { 12995 self._time = dur; 12996 time = dur + 0.0001; //to avoid occasional floating point rounding error 12997 } else if (self._time < 0) { 12998 self._time = time = 0; 12999 } else { 13000 time = self._time; 13001 } 13002 } 13003 } 13004 13005 if (self._hasPause && !self._forcingPlayhead && !suppressEvents) { 13006 time = self._time; 13007 if (time >= prevTime || (self._repeat && prevCycle !== self._cycle)) { 13008 tween = self._first; 13009 while (tween && tween._startTime <= time && !pauseTween) { 13010 if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && self._rawPrevTime === 0)) { 13011 pauseTween = tween; 13012 } 13013 tween = tween._next; 13014 } 13015 } else { 13016 tween = self._last; 13017 while (tween && tween._startTime >= time && !pauseTween) { 13018 if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { 13019 pauseTween = tween; 13020 } 13021 tween = tween._prev; 13022 } 13023 } 13024 if (pauseTween) { 13025 pauseTime = self._startTime + (pauseTween._startTime / self._timeScale); 13026 if (pauseTween._startTime < dur) { 13027 self._time = self._rawPrevTime = time = pauseTween._startTime; 13028 self._totalTime = time + (self._cycle * (self._totalDuration + self._repeatDelay)); 13029 } 13030 } 13031 } 13032 13033 } 13034 13035 if (self._cycle !== prevCycle) if (!self._locked) { 13036 /* 13037 make sure children at the end/beginning of the timeline are rendered properly. If, for example, 13038 a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which 13039 would get translated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there 13040 could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So 13041 we need to push the timeline to the end (and/or beginning depending on its yoyo value). Also we must 13042 ensure that zero-duration tweens at the very beginning or end of the TimelineMax work. 13043 */ 13044 var backwards = (self._yoyo && (prevCycle & 1) !== 0), 13045 wrap = (backwards === (self._yoyo && (self._cycle & 1) !== 0)), 13046 recTotalTime = self._totalTime, 13047 recCycle = self._cycle, 13048 recRawPrevTime = self._rawPrevTime, 13049 recTime = self._time; 13050 13051 self._totalTime = prevCycle * dur; 13052 if (self._cycle < prevCycle) { 13053 backwards = !backwards; 13054 } else { 13055 self._totalTime += dur; 13056 } 13057 self._time = prevTime; //temporarily revert _time so that render() renders the children in the correct order. Without this, tweens won't rewind correctly. We could arhictect things in a "cleaner" way by splitting out the rendering queue into a separate method but for performance reasons, we kept it all inside this method. 13058 13059 self._rawPrevTime = (dur === 0) ? prevRawPrevTime - 0.0001 : prevRawPrevTime; 13060 self._cycle = prevCycle; 13061 self._locked = true; //prevents changes to totalTime and skips repeat/yoyo behavior when we recursively call render() 13062 prevTime = (backwards) ? 0 : dur; 13063 self.render(prevTime, suppressEvents, (dur === 0)); 13064 if (!suppressEvents) if (!self._gc) { 13065 if (self.vars.onRepeat) { 13066 self._cycle = recCycle; //in case the onRepeat alters the playhead or invalidates(), we shouldn't stay locked or use the previous cycle. 13067 self._locked = false; 13068 self._callback("onRepeat"); 13069 } 13070 } 13071 if (prevTime !== self._time) { //in case there's a callback like onComplete in a nested tween/timeline that changes the playhead position, like via seek(), we should just abort. 13072 return; 13073 } 13074 if (wrap) { 13075 self._cycle = prevCycle; //if there's an onRepeat, we reverted this above, so make sure it's set properly again. We also unlocked in that scenario, so reset that too. 13076 self._locked = true; 13077 prevTime = (backwards) ? dur + 0.0001 : -0.0001; 13078 self.render(prevTime, true, false); 13079 } 13080 self._locked = false; 13081 if (self._paused && !prevPaused) { //if the render() triggered callback that paused this timeline, we should abort (very rare, but possible) 13082 return; 13083 } 13084 self._time = recTime; 13085 self._totalTime = recTotalTime; 13086 self._cycle = recCycle; 13087 self._rawPrevTime = recRawPrevTime; 13088 } 13089 13090 if ((self._time === prevTime || !self._first) && !force && !internalForce && !pauseTween) { 13091 if (prevTotalTime !== self._totalTime) if (self._onUpdate) if (!suppressEvents) { //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate. 13092 self._callback("onUpdate"); 13093 } 13094 return; 13095 } else if (!self._initted) { 13096 self._initted = true; 13097 } 13098 13099 if (!self._active) if (!self._paused && self._totalTime !== prevTotalTime && time > 0) { 13100 self._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. 13101 } 13102 13103 if (prevTotalTime === 0) if (self.vars.onStart) if (self._totalTime !== 0 || !self._totalDuration) if (!suppressEvents) { 13104 self._callback("onStart"); 13105 } 13106 13107 curTime = self._time; 13108 if (curTime >= prevTime) { 13109 tween = self._first; 13110 while (tween) { 13111 next = tween._next; //record it here because the value could change after rendering... 13112 if (curTime !== self._time || (self._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 13113 break; 13114 } else if (tween._active || (tween._startTime <= self._time && !tween._paused && !tween._gc)) { 13115 if (pauseTween === tween) { 13116 self.pause(); 13117 self._pauseTime = pauseTime; //so that when we resume(), it's starting from exactly the right spot (the pause() method uses the rawTime for the parent, but that may be a bit too far ahead) 13118 } 13119 if (!tween._reversed) { 13120 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 13121 } else { 13122 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 13123 } 13124 } 13125 tween = next; 13126 } 13127 } else { 13128 tween = self._last; 13129 while (tween) { 13130 next = tween._prev; //record it here because the value could change after rendering... 13131 if (curTime !== self._time || (self._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete 13132 break; 13133 } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { 13134 if (pauseTween === tween) { 13135 pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. 13136 while (pauseTween && pauseTween.endTime() > self._time) { 13137 pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); 13138 pauseTween = pauseTween._prev; 13139 } 13140 pauseTween = null; 13141 self.pause(); 13142 self._pauseTime = pauseTime; //so that when we resume(), it's starting from exactly the right spot (the pause() method uses the rawTime for the parent, but that may be a bit too far ahead) 13143 } 13144 if (!tween._reversed) { 13145 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 13146 } else { 13147 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 13148 } 13149 } 13150 tween = next; 13151 } 13152 } 13153 13154 if (self._onUpdate) if (!suppressEvents) { 13155 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. 13156 _lazyRender(); 13157 } 13158 self._callback("onUpdate"); 13159 } 13160 if (callback) if (!self._locked) if (!self._gc) if (prevStart === self._startTime || prevTimeScale !== self._timeScale) if (self._time === 0 || totalDur >= self.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate 13161 if (isComplete) { 13162 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. 13163 _lazyRender(); 13164 } 13165 if (self._timeline.autoRemoveChildren) { 13166 self._enabled(false, false); 13167 } 13168 self._active = false; 13169 } 13170 if (!suppressEvents && self.vars[callback]) { 13171 self._callback(callback); 13172 } 13173 } 13174 }; 13175 13176 p.getActive = function(nested, tweens, timelines) { 13177 var a = [], 13178 all = this.getChildren(nested || (nested == null), tweens || (nested == null), !!timelines), 13179 cnt = 0, 13180 l = all.length, 13181 i, tween; 13182 for (i = 0; i < l; i++) { 13183 tween = all[i]; 13184 if (tween.isActive()) { 13185 a[cnt++] = tween; 13186 } 13187 } 13188 return a; 13189 }; 13190 13191 13192 p.getLabelAfter = function(time) { 13193 if (!time) if (time !== 0) { //faster than isNan() 13194 time = this._time; 13195 } 13196 var labels = this.getLabelsArray(), 13197 l = labels.length, 13198 i; 13199 for (i = 0; i < l; i++) { 13200 if (labels[i].time > time) { 13201 return labels[i].name; 13202 } 13203 } 13204 return null; 13205 }; 13206 13207 p.getLabelBefore = function(time) { 13208 if (time == null) { 13209 time = this._time; 13210 } 13211 var labels = this.getLabelsArray(), 13212 i = labels.length; 13213 while (--i > -1) { 13214 if (labels[i].time < time) { 13215 return labels[i].name; 13216 } 13217 } 13218 return null; 13219 }; 13220 13221 p.getLabelsArray = function() { 13222 var a = [], 13223 cnt = 0, 13224 p; 13225 for (p in this._labels) { 13226 a[cnt++] = {time:this._labels[p], name:p}; 13227 } 13228 a.sort(function(a,b) { 13229 return a.time - b.time; 13230 }); 13231 return a; 13232 }; 13233 13234 p.invalidate = function() { 13235 this._locked = false; //unlock and set cycle in case invalidate() is called from inside an onRepeat 13236 return _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"].prototype.invalidate.call(this); 13237 }; 13238 13239 13240//---- GETTERS / SETTERS ------------------------------------------------------------------------------------------------------- 13241 13242 p.progress = function(value, suppressEvents) { 13243 return (!arguments.length) ? (this._time / this.duration()) || 0 : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents); 13244 }; 13245 13246 p.totalProgress = function(value, suppressEvents) { 13247 return (!arguments.length) ? (this._totalTime / this.totalDuration()) || 0 : this.totalTime( this.totalDuration() * value, suppressEvents); 13248 }; 13249 13250 p.totalDuration = function(value) { 13251 if (!arguments.length) { 13252 if (this._dirty) { 13253 _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"].prototype.totalDuration.call(this); //just forces refresh 13254 //Instead of Infinity, we use 999999999999 so that we can accommodate reverses. 13255 this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat); 13256 } 13257 return this._totalDuration; 13258 } 13259 return (this._repeat === -1 || !value) ? this : this.timeScale( this.totalDuration() / value ); 13260 }; 13261 13262 p.time = function(value, suppressEvents) { 13263 if (!arguments.length) { 13264 return this._time; 13265 } 13266 if (this._dirty) { 13267 this.totalDuration(); 13268 } 13269 var duration = this._duration, 13270 cycle = this._cycle, 13271 cycleDur = cycle * (duration + this._repeatDelay); 13272 if (value > duration) { 13273 value = duration; 13274 } 13275 return this.totalTime((this._yoyo && (cycle & 1)) ? duration - value + cycleDur : this._repeat ? value + cycleDur : value, suppressEvents); 13276 }; 13277 13278 p.repeat = function(value) { 13279 if (!arguments.length) { 13280 return this._repeat; 13281 } 13282 this._repeat = value; 13283 return this._uncache(true); 13284 }; 13285 13286 p.repeatDelay = function(value) { 13287 if (!arguments.length) { 13288 return this._repeatDelay; 13289 } 13290 this._repeatDelay = value; 13291 return this._uncache(true); 13292 }; 13293 13294 p.yoyo = function(value) { 13295 if (!arguments.length) { 13296 return this._yoyo; 13297 } 13298 this._yoyo = value; 13299 return this; 13300 }; 13301 13302 p.currentLabel = function(value) { 13303 if (!arguments.length) { 13304 return this.getLabelBefore(this._time + _tinyNum); 13305 } 13306 return this.seek(value, true); 13307 }; 13308 13309 return TimelineMax; 13310 13311 }, true); 13312 13313var TimelineMax = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].TimelineMax; 13314 13315 13316/***/ }), 13317
vendor: 89,098 bytes, lines 13318-15321
13318/***/ "./node_modules/gsap/TweenLite.js": 13319/*!****************************************!*\ 13320 !*** ./node_modules/gsap/TweenLite.js ***! 13321 \****************************************/ 13322/*! exports provided: _gsScope, TweenLite, globals, default, SimpleTimeline, Animation, Ease, Linear, Power0, Power1, Power2, Power3, Power4, TweenPlugin, EventDispatcher */ 13323/***/ (function(module, __webpack_exports__, __webpack_require__) { 13324 13325"use strict"; 13326__webpack_require__.r(__webpack_exports__); 13327/* WEBPACK VAR INJECTION */(function(module, global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_gsScope", function() { return _gsScope; }); 13328/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TweenLite", function() { return TweenLite; }); 13329/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "globals", function() { return globals; }); 13330/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TweenLite; }); 13331/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SimpleTimeline", function() { return SimpleTimeline; }); 13332/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Animation", function() { return Animation; }); 13333/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Ease", function() { return Ease; }); 13334/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return Linear; }); 13335/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return Power0; }); 13336/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return Power1; }); 13337/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return Power2; }); 13338/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return Power3; }); 13339/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return Power4; }); 13340/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TweenPlugin", function() { return TweenPlugin; }); 13341/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EventDispatcher", function() { return EventDispatcher; }); 13342/*! 13343 * VERSION: 2.1.2 13344 * DATE: 2019-03-01 13345 * UPDATES AND DOCS AT: http://greensock.com 13346 * 13347 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 13348 * This work is subject to the terms at http://greensock.com/standard-license or for 13349 * Club GreenSock members, the software agreement that was issued with your membership. 13350 * 13351 * @author: Jack Doyle, [email protected] 13352 */ 13353/* eslint-disable */ 13354 13355/* ES6 changes: 13356 - declare and export _gsScope at top. 13357 - set var TweenLite = the result of the main function 13358 - export default TweenLite at the bottom 13359 - return TweenLite at the bottom of the main function 13360 - pass in _gsScope as the first parameter of the main function (which is actually at the bottom) 13361 - remove the "export to multiple environments" in Definition(). 13362 */ 13363var _gsScope = (typeof(window) !== "undefined") ? window : ( true && module.exports && typeof(global) !== "undefined") ? global : undefined || {}; 13364 13365var TweenLite = (function(window) { 13366 13367 "use strict"; 13368 var _exports = {}, 13369 _doc = window.document, 13370 _globals = window.GreenSockGlobals = window.GreenSockGlobals || window; 13371 if (_globals.TweenLite) { 13372 return _globals.TweenLite; //in case the core set of classes is already loaded, don't instantiate twice. 13373 } 13374 var _namespace = function(ns) { 13375 var a = ns.split("."), 13376 p = _globals, i; 13377 for (i = 0; i < a.length; i++) { 13378 p[a[i]] = p = p[a[i]] || {}; 13379 } 13380 return p; 13381 }, 13382 gs = _namespace("com.greensock"), 13383 _tinyNum = 0.00000001, 13384 _slice = function(a) { //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 13385 var b = [], 13386 l = a.length, 13387 i; 13388 for (i = 0; i !== l; b.push(a[i++])) {} 13389 return b; 13390 }, 13391 _emptyFunc = function() {}, 13392 _isArray = (function() { //works around issues in iframe environments where the Array global isn't shared, thus if the object originates in a different window/iframe, "(obj instanceof Array)" will evaluate false. We added some speed optimizations to avoid Object.prototype.toString.call() unless it's absolutely necessary because it's VERY slow (like 20x slower) 13393 var toString = Object.prototype.toString, 13394 array = toString.call([]); 13395 return function(obj) { 13396 return obj != null && (obj instanceof Array || (typeof(obj) === "object" && !!obj.push && toString.call(obj) === array)); 13397 }; 13398 }()), 13399 a, i, p, _ticker, _tickerActive, 13400 _defLookup = {}, 13401 13402 /** 13403 * @constructor 13404 * Defines a GreenSock class, optionally with an array of dependencies that must be instantiated first and passed into the definition. 13405 * This allows users to load GreenSock JS files in any order even if they have interdependencies (like CSSPlugin extends TweenPlugin which is 13406 * inside TweenLite.js, but if CSSPlugin is loaded first, it should wait to run its code until TweenLite.js loads and instantiates TweenPlugin 13407 * and then pass TweenPlugin to CSSPlugin's definition). This is all done automatically and internally. 13408 * 13409 * Every definition will be added to a "com.greensock" global object (typically window, but if a window.GreenSockGlobals object is found, 13410 * it will go there as of v1.7). For example, TweenLite will be found at window.com.greensock.TweenLite and since it's a global class that should be available anywhere, 13411 * it is ALSO referenced at window.TweenLite. However some classes aren't considered global, like the base com.greensock.core.Animation class, so 13412 * those will only be at the package like window.com.greensock.core.Animation. Again, if you define a GreenSockGlobals object on the window, everything 13413 * gets tucked neatly inside there instead of on the window directly. This allows you to do advanced things like load multiple versions of GreenSock 13414 * files and put them into distinct objects (imagine a banner ad uses a newer version but the main site uses an older one). In that case, you could 13415 * sandbox the banner one like: 13416 * 13417 * <script> 13418 * var gs = window.GreenSockGlobals = {}; //the newer version we're about to load could now be referenced in a "gs" object, like gs.TweenLite.to(...). Use whatever alias you want as long as it's unique, "gs" or "banner" or whatever. 13419 * </script> 13420 * <script src="js/greensock/v1.7/TweenMax.js"></script> 13421 * <script> 13422 * window.GreenSockGlobals = window._gsQueue = window._gsDefine = null; //reset it back to null (along with the special _gsQueue variable) so that the next load of TweenMax affects the window and we can reference things directly like TweenLite.to(...) 13423 * </script> 13424 * <script src="js/greensock/v1.6/TweenMax.js"></script> 13425 * <script> 13426 * gs.TweenLite.to(...); //would use v1.7 13427 * TweenLite.to(...); //would use v1.6 13428 * </script> 13429 * 13430 * @param {!string} ns The namespace of the class definition, leaving off "com.greensock." as that's assumed. For example, "TweenLite" or "plugins.CSSPlugin" or "easing.Back". 13431 * @param {!Array.<string>} dependencies An array of dependencies (described as their namespaces minus "com.greensock." prefix). For example ["TweenLite","plugins.TweenPlugin","core.Animation"] 13432 * @param {!function():Object} func The function that should be called and passed the resolved dependencies which will return the actual class for this definition. 13433 * @param {boolean=} global If true, the class will be added to the global scope (typically window unless you define a window.GreenSockGlobals object) 13434 */ 13435 Definition = function(ns, dependencies, func, global) { 13436 this.sc = (_defLookup[ns]) ? _defLookup[ns].sc : []; //subclasses 13437 _defLookup[ns] = this; 13438 this.gsClass = null; 13439 this.func = func; 13440 var _classes = []; 13441 this.check = function(init) { 13442 var i = dependencies.length, 13443 missing = i, 13444 cur, a, n, cl; 13445 while (--i > -1) { 13446 if ((cur = _defLookup[dependencies[i]] || new Definition(dependencies[i], [])).gsClass) { 13447 _classes[i] = cur.gsClass; 13448 missing--; 13449 } else if (init) { 13450 cur.sc.push(this); 13451 } 13452 } 13453 if (missing === 0 && func) { 13454 a = ("com.greensock." + ns).split("."); 13455 n = a.pop(); 13456 cl = _namespace(a.join("."))[n] = this.gsClass = func.apply(func, _classes); 13457 13458 //exports to multiple environments 13459 if (global) { 13460 _globals[n] = _exports[n] = cl; //provides a way to avoid global namespace pollution. By default, the main classes like TweenLite, Power1, Strong, etc. are added to window unless a GreenSockGlobals is defined. So if you want to have things added to a custom object instead, just do something like window.GreenSockGlobals = {} before loading any GreenSock files. You can even set up an alias like window.GreenSockGlobals = windows.gs = {} so that you can access everything like gs.TweenLite. Also remember that ALL classes are added to the window.com.greensock object (in their respective packages, like com.greensock.easing.Power1, com.greensock.TweenLite, etc.) 13461 /* 13462 if (typeof(module) !== "undefined" && module.exports) { //node 13463 if (ns === moduleName) { 13464 module.exports = _exports[moduleName] = cl; 13465 for (i in _exports) { 13466 cl[i] = _exports[i]; 13467 } 13468 } else if (_exports[moduleName]) { 13469 _exports[moduleName][n] = cl; 13470 } 13471 } else if (typeof(define) === "function" && define.amd){ //AMD 13472 define((window.GreenSockAMDPath ? window.GreenSockAMDPath + "/" : "") + ns.split(".").pop(), [], function() { return cl; }); 13473 } 13474 */ 13475 } 13476 for (i = 0; i < this.sc.length; i++) { 13477 this.sc[i].check(); 13478 } 13479 } 13480 }; 13481 this.check(true); 13482 }, 13483 13484 //used to create Definition instances (which basically registers a class that has dependencies). 13485 _gsDefine = window._gsDefine = function(ns, dependencies, func, global) { 13486 return new Definition(ns, dependencies, func, global); 13487 }, 13488 13489 //a quick way to create a class that doesn't have any dependencies. Returns the class, but first registers it in the GreenSock namespace so that other classes can grab it (other classes might be dependent on the class). 13490 _class = gs._class = function(ns, func, global) { 13491 func = func || function() {}; 13492 _gsDefine(ns, [], function(){ return func; }, global); 13493 return func; 13494 }; 13495 13496 _gsDefine.globals = _globals; 13497 13498 13499 13500/* 13501 * ---------------------------------------------------------------- 13502 * Ease 13503 * ---------------------------------------------------------------- 13504 */ 13505 var _baseParams = [0, 0, 1, 1], 13506 Ease = _class("easing.Ease", function(func, extraParams, type, power) { 13507 this._func = func; 13508 this._type = type || 0; 13509 this._power = power || 0; 13510 this._params = extraParams ? _baseParams.concat(extraParams) : _baseParams; 13511 }, true), 13512 _easeMap = Ease.map = {}, 13513 _easeReg = Ease.register = function(ease, names, types, create) { 13514 var na = names.split(","), 13515 i = na.length, 13516 ta = (types || "easeIn,easeOut,easeInOut").split(","), 13517 e, name, j, type; 13518 while (--i > -1) { 13519 name = na[i]; 13520 e = create ? _class("easing."+name, null, true) : gs.easing[name] || {}; 13521 j = ta.length; 13522 while (--j > -1) { 13523 type = ta[j]; 13524 _easeMap[name + "." + type] = _easeMap[type + name] = e[type] = ease.getRatio ? ease : ease[type] || new ease(); 13525 } 13526 } 13527 }; 13528 13529 p = Ease.prototype; 13530 p._calcEnd = false; 13531 p.getRatio = function(p) { 13532 if (this._func) { 13533 this._params[0] = p; 13534 return this._func.apply(null, this._params); 13535 } 13536 var t = this._type, 13537 pw = this._power, 13538 r = (t === 1) ? 1 - p : (t === 2) ? p : (p < 0.5) ? p * 2 : (1 - p) * 2; 13539 if (pw === 1) { 13540 r *= r; 13541 } else if (pw === 2) { 13542 r *= r * r; 13543 } else if (pw === 3) { 13544 r *= r * r * r; 13545 } else if (pw === 4) { 13546 r *= r * r * r * r; 13547 } 13548 return (t === 1) ? 1 - r : (t === 2) ? r : (p < 0.5) ? r / 2 : 1 - (r / 2); 13549 }; 13550 13551 //create all the standard eases like Linear, Quad, Cubic, Quart, Quint, Strong, Power0, Power1, Power2, Power3, and Power4 (each with easeIn, easeOut, and easeInOut) 13552 a = ["Linear","Quad","Cubic","Quart","Quint,Strong"]; 13553 i = a.length; 13554 while (--i > -1) { 13555 p = a[i]+",Power"+i; 13556 _easeReg(new Ease(null,null,1,i), p, "easeOut", true); 13557 _easeReg(new Ease(null,null,2,i), p, "easeIn" + ((i === 0) ? ",easeNone" : "")); 13558 _easeReg(new Ease(null,null,3,i), p, "easeInOut"); 13559 } 13560 _easeMap.linear = gs.easing.Linear.easeIn; 13561 _easeMap.swing = gs.easing.Quad.easeInOut; //for jQuery folks 13562 13563 13564/* 13565 * ---------------------------------------------------------------- 13566 * EventDispatcher 13567 * ---------------------------------------------------------------- 13568 */ 13569 var EventDispatcher = _class("events.EventDispatcher", function(target) { 13570 this._listeners = {}; 13571 this._eventTarget = target || this; 13572 }); 13573 p = EventDispatcher.prototype; 13574 13575 p.addEventListener = function(type, callback, scope, useParam, priority) { 13576 priority = priority || 0; 13577 var list = this._listeners[type], 13578 index = 0, 13579 listener, i; 13580 if (this === _ticker && !_tickerActive) { 13581 _ticker.wake(); 13582 } 13583 if (list == null) { 13584 this._listeners[type] = list = []; 13585 } 13586 i = list.length; 13587 while (--i > -1) { 13588 listener = list[i]; 13589 if (listener.c === callback && listener.s === scope) { 13590 list.splice(i, 1); 13591 } else if (index === 0 && listener.pr < priority) { 13592 index = i + 1; 13593 } 13594 } 13595 list.splice(index, 0, {c:callback, s:scope, up:useParam, pr:priority}); 13596 }; 13597 13598 p.removeEventListener = function(type, callback) { 13599 var list = this._listeners[type], i; 13600 if (list) { 13601 i = list.length; 13602 while (--i > -1) { 13603 if (list[i].c === callback) { 13604 list.splice(i, 1); 13605 return; 13606 } 13607 } 13608 } 13609 }; 13610 13611 p.dispatchEvent = function(type) { 13612 var list = this._listeners[type], 13613 i, t, listener; 13614 if (list) { 13615 i = list.length; 13616 if (i > 1) { 13617 list = list.slice(0); //in case addEventListener() is called from within a listener/callback (otherwise the index could change, resulting in a skip) 13618 } 13619 t = this._eventTarget; 13620 while (--i > -1) { 13621 listener = list[i]; 13622 if (listener) { 13623 if (listener.up) { 13624 listener.c.call(listener.s || t, {type:type, target:t}); 13625 } else { 13626 listener.c.call(listener.s || t); 13627 } 13628 } 13629 } 13630 } 13631 }; 13632 13633 13634/* 13635 * ---------------------------------------------------------------- 13636 * Ticker 13637 * ---------------------------------------------------------------- 13638 */ 13639 var _reqAnimFrame = window.requestAnimationFrame, 13640 _cancelAnimFrame = window.cancelAnimationFrame, 13641 _getTime = Date.now || function() {return new Date().getTime();}, 13642 _lastUpdate = _getTime(); 13643 13644 //now try to determine the requestAnimationFrame and cancelAnimationFrame functions and if none are found, we'll use a setTimeout()/clearTimeout() polyfill. 13645 a = ["ms","moz","webkit","o"]; 13646 i = a.length; 13647 while (--i > -1 && !_reqAnimFrame) { 13648 _reqAnimFrame = window[a[i] + "RequestAnimationFrame"]; 13649 _cancelAnimFrame = window[a[i] + "CancelAnimationFrame"] || window[a[i] + "CancelRequestAnimationFrame"]; 13650 } 13651 13652 _class("Ticker", function(fps, useRAF) { 13653 var _self = this, 13654 _startTime = _getTime(), 13655 _useRAF = (useRAF !== false && _reqAnimFrame) ? "auto" : false, 13656 _lagThreshold = 500, 13657 _adjustedLag = 33, 13658 _tickWord = "tick", //helps reduce gc burden 13659 _fps, _req, _id, _gap, _nextTime, 13660 _tick = function(manual) { 13661 var elapsed = _getTime() - _lastUpdate, 13662 overlap, dispatch; 13663 if (elapsed > _lagThreshold) { 13664 _startTime += elapsed - _adjustedLag; 13665 } 13666 _lastUpdate += elapsed; 13667 _self.time = (_lastUpdate - _startTime) / 1000; 13668 overlap = _self.time - _nextTime; 13669 if (!_fps || overlap > 0 || manual === true) { 13670 _self.frame++; 13671 _nextTime += overlap + (overlap >= _gap ? 0.004 : _gap - overlap); 13672 dispatch = true; 13673 } 13674 if (manual !== true) { //make sure the request is made before we dispatch the "tick" event so that timing is maintained. Otherwise, if processing the "tick" requires a bunch of time (like 15ms) and we're using a setTimeout() that's based on 16.7ms, it'd technically take 31.7ms between frames otherwise. 13675 _id = _req(_tick); 13676 } 13677 if (dispatch) { 13678 _self.dispatchEvent(_tickWord); 13679 } 13680 }; 13681 13682 EventDispatcher.call(_self); 13683 _self.time = _self.frame = 0; 13684 _self.tick = function() { 13685 _tick(true); 13686 }; 13687 13688 _self.lagSmoothing = function(threshold, adjustedLag) { 13689 if (!arguments.length) { //if lagSmoothing() is called with no arguments, treat it like a getter that returns a boolean indicating if it's enabled or not. This is purposely undocumented and is for internal use. 13690 return (_lagThreshold < 1 / _tinyNum); 13691 } 13692 _lagThreshold = threshold || (1 / _tinyNum); //zero should be interpreted as basically unlimited 13693 _adjustedLag = Math.min(adjustedLag, _lagThreshold, 0); 13694 }; 13695 13696 _self.sleep = function() { 13697 if (_id == null) { 13698 return; 13699 } 13700 if (!_useRAF || !_cancelAnimFrame) { 13701 clearTimeout(_id); 13702 } else { 13703 _cancelAnimFrame(_id); 13704 } 13705 _req = _emptyFunc; 13706 _id = null; 13707 if (_self === _ticker) { 13708 _tickerActive = false; 13709 } 13710 }; 13711 13712 _self.wake = function(seamless) { 13713 if (_id !== null) { 13714 _self.sleep(); 13715 } else if (seamless) { 13716 _startTime += -_lastUpdate + (_lastUpdate = _getTime()); 13717 } else if (_self.frame > 10) { //don't trigger lagSmoothing if we're just waking up, and make sure that at least 10 frames have elapsed because of the iOS bug that we work around below with the 1.5-second setTimout(). 13718 _lastUpdate = _getTime() - _lagThreshold + 5; 13719 } 13720 _req = (_fps === 0) ? _emptyFunc : (!_useRAF || !_reqAnimFrame) ? function(f) { return setTimeout(f, ((_nextTime - _self.time) * 1000 + 1) | 0); } : _reqAnimFrame; 13721 if (_self === _ticker) { 13722 _tickerActive = true; 13723 } 13724 _tick(2); 13725 }; 13726 13727 _self.fps = function(value) { 13728 if (!arguments.length) { 13729 return _fps; 13730 } 13731 _fps = value; 13732 _gap = 1 / (_fps || 60); 13733 _nextTime = this.time + _gap; 13734 _self.wake(); 13735 }; 13736 13737 _self.useRAF = function(value) { 13738 if (!arguments.length) { 13739 return _useRAF; 13740 } 13741 _self.sleep(); 13742 _useRAF = value; 13743 _self.fps(_fps); 13744 }; 13745 _self.fps(fps); 13746 13747 //a bug in iOS 6 Safari occasionally prevents the requestAnimationFrame from working initially, so we use a 1.5-second timeout that automatically falls back to setTimeout() if it senses this condition. 13748 setTimeout(function() { 13749 if (_useRAF === "auto" && _self.frame < 5 && (_doc || {}).visibilityState !== "hidden") { 13750 _self.useRAF(false); 13751 } 13752 }, 1500); 13753 }); 13754 13755 p = gs.Ticker.prototype = new gs.events.EventDispatcher(); 13756 p.constructor = gs.Ticker; 13757 13758 13759/* 13760 * ---------------------------------------------------------------- 13761 * Animation 13762 * ---------------------------------------------------------------- 13763 */ 13764 var Animation = _class("core.Animation", function(duration, vars) { 13765 this.vars = vars = vars || {}; 13766 this._duration = this._totalDuration = duration || 0; 13767 this._delay = Number(vars.delay) || 0; 13768 this._timeScale = 1; 13769 this._active = !!vars.immediateRender; 13770 this.data = vars.data; 13771 this._reversed = !!vars.reversed; 13772 13773 if (!_rootTimeline) { 13774 return; 13775 } 13776 if (!_tickerActive) { //some browsers (like iOS 6 Safari) shut down JavaScript execution when the tab is disabled and they [occasionally] neglect to start up requestAnimationFrame again when returning - this code ensures that the engine starts up again properly. 13777 _ticker.wake(); 13778 } 13779 13780 var tl = this.vars.useFrames ? _rootFramesTimeline : _rootTimeline; 13781 tl.add(this, tl._time); 13782 13783 if (this.vars.paused) { 13784 this.paused(true); 13785 } 13786 }); 13787 13788 _ticker = Animation.ticker = new gs.Ticker(); 13789 p = Animation.prototype; 13790 p._dirty = p._gc = p._initted = p._paused = false; 13791 p._totalTime = p._time = 0; 13792 p._rawPrevTime = -1; 13793 p._next = p._last = p._onUpdate = p._timeline = p.timeline = null; 13794 p._paused = false; 13795 13796 13797 //some browsers (like iOS) occasionally drop the requestAnimationFrame event when the user switches to a different tab and then comes back again, so we use a 2-second setTimeout() to sense if/when that condition occurs and then wake() the ticker. 13798 var _checkTimeout = function() { 13799 if (_tickerActive && _getTime() - _lastUpdate > 2000 && ((_doc || {}).visibilityState !== "hidden" || !_ticker.lagSmoothing())) { //note: if the tab is hidden, we should still wake if lagSmoothing has been disabled. 13800 _ticker.wake(); 13801 } 13802 var t = setTimeout(_checkTimeout, 2000); 13803 if (t.unref) { 13804 // allows a node process to exit even if the timeout’s callback hasn't been invoked. Without it, the node process could hang as this function is called every two seconds. 13805 t.unref(); 13806 } 13807 }; 13808 _checkTimeout(); 13809 13810 13811 p.play = function(from, suppressEvents) { 13812 if (from != null) { 13813 this.seek(from, suppressEvents); 13814 } 13815 return this.reversed(false).paused(false); 13816 }; 13817 13818 p.pause = function(atTime, suppressEvents) { 13819 if (atTime != null) { 13820 this.seek(atTime, suppressEvents); 13821 } 13822 return this.paused(true); 13823 }; 13824 13825 p.resume = function(from, suppressEvents) { 13826 if (from != null) { 13827 this.seek(from, suppressEvents); 13828 } 13829 return this.paused(false); 13830 }; 13831 13832 p.seek = function(time, suppressEvents) { 13833 return this.totalTime(Number(time), suppressEvents !== false); 13834 }; 13835 13836 p.restart = function(includeDelay, suppressEvents) { 13837 return this.reversed(false).paused(false).totalTime(includeDelay ? -this._delay : 0, (suppressEvents !== false), true); 13838 }; 13839 13840 p.reverse = function(from, suppressEvents) { 13841 if (from != null) { 13842 this.seek((from || this.totalDuration()), suppressEvents); 13843 } 13844 return this.reversed(true).paused(false); 13845 }; 13846 13847 p.render = function(time, suppressEvents, force) { 13848 //stub - we override this method in subclasses. 13849 }; 13850 13851 p.invalidate = function() { 13852 this._time = this._totalTime = 0; 13853 this._initted = this._gc = false; 13854 this._rawPrevTime = -1; 13855 if (this._gc || !this.timeline) { 13856 this._enabled(true); 13857 } 13858 return this; 13859 }; 13860 13861 p.isActive = function() { 13862 var tl = this._timeline, //the 2 root timelines won't have a _timeline; they're always active. 13863 startTime = this._startTime, 13864 rawTime; 13865 return (!tl || (!this._gc && !this._paused && tl.isActive() && (rawTime = tl.rawTime(true)) >= startTime && rawTime < startTime + this.totalDuration() / this._timeScale - _tinyNum)); 13866 }; 13867 13868 p._enabled = function (enabled, ignoreTimeline) { 13869 if (!_tickerActive) { 13870 _ticker.wake(); 13871 } 13872 this._gc = !enabled; 13873 this._active = this.isActive(); 13874 if (ignoreTimeline !== true) { 13875 if (enabled && !this.timeline) { 13876 this._timeline.add(this, this._startTime - this._delay); 13877 } else if (!enabled && this.timeline) { 13878 this._timeline._remove(this, true); 13879 } 13880 } 13881 return false; 13882 }; 13883 13884 13885 p._kill = function(vars, target) { 13886 return this._enabled(false, false); 13887 }; 13888 13889 p.kill = function(vars, target) { 13890 this._kill(vars, target); 13891 return this; 13892 }; 13893 13894 p._uncache = function(includeSelf) { 13895 var tween = includeSelf ? this : this.timeline; 13896 while (tween) { 13897 tween._dirty = true; 13898 tween = tween.timeline; 13899 } 13900 return this; 13901 }; 13902 13903 p._swapSelfInParams = function(params) { 13904 var i = params.length, 13905 copy = params.concat(); 13906 while (--i > -1) { 13907 if (params[i] === "{self}") { 13908 copy[i] = this; 13909 } 13910 } 13911 return copy; 13912 }; 13913 13914 p._callback = function(type) { 13915 var v = this.vars, 13916 callback = v[type], 13917 params = v[type + "Params"], 13918 scope = v[type + "Scope"] || v.callbackScope || this, 13919 l = params ? params.length : 0; 13920 switch (l) { //speed optimization; call() is faster than apply() so use it when there are only a few parameters (which is by far most common). Previously we simply did var v = this.vars; v[type].apply(v[type + "Scope"] || v.callbackScope || this, v[type + "Params"] || _blankArray); 13921 case 0: callback.call(scope); break; 13922 case 1: callback.call(scope, params[0]); break; 13923 case 2: callback.call(scope, params[0], params[1]); break; 13924 default: callback.apply(scope, params); 13925 } 13926 }; 13927 13928//----Animation getters/setters -------------------------------------------------------- 13929 13930 p.eventCallback = function(type, callback, params, scope) { 13931 if ((type || "").substr(0,2) === "on") { 13932 var v = this.vars; 13933 if (arguments.length === 1) { 13934 return v[type]; 13935 } 13936 if (callback == null) { 13937 delete v[type]; 13938 } else { 13939 v[type] = callback; 13940 v[type + "Params"] = (_isArray(params) && params.join("").indexOf("{self}") !== -1) ? this._swapSelfInParams(params) : params; 13941 v[type + "Scope"] = scope; 13942 } 13943 if (type === "onUpdate") { 13944 this._onUpdate = callback; 13945 } 13946 } 13947 return this; 13948 }; 13949 13950 p.delay = function(value) { 13951 if (!arguments.length) { 13952 return this._delay; 13953 } 13954 if (this._timeline.smoothChildTiming) { 13955 this.startTime( this._startTime + value - this._delay ); 13956 } 13957 this._delay = value; 13958 return this; 13959 }; 13960 13961 p.duration = function(value) { 13962 if (!arguments.length) { 13963 this._dirty = false; 13964 return this._duration; 13965 } 13966 this._duration = this._totalDuration = value; 13967 this._uncache(true); //true in case it's a TweenMax or TimelineMax that has a repeat - we'll need to refresh the totalDuration. 13968 if (this._timeline.smoothChildTiming) if (this._time > 0) if (this._time < this._duration) if (value !== 0) { 13969 this.totalTime(this._totalTime * (value / this._duration), true); 13970 } 13971 return this; 13972 }; 13973 13974 p.totalDuration = function(value) { 13975 this._dirty = false; 13976 return (!arguments.length) ? this._totalDuration : this.duration(value); 13977 }; 13978 13979 p.time = function(value, suppressEvents) { 13980 if (!arguments.length) { 13981 return this._time; 13982 } 13983 if (this._dirty) { 13984 this.totalDuration(); 13985 } 13986 return this.totalTime((value > this._duration) ? this._duration : value, suppressEvents); 13987 }; 13988 13989 p.totalTime = function(time, suppressEvents, uncapped) { 13990 if (!_tickerActive) { 13991 _ticker.wake(); 13992 } 13993 if (!arguments.length) { 13994 return this._totalTime; 13995 } 13996 if (this._timeline) { 13997 if (time < 0 && !uncapped) { 13998 time += this.totalDuration(); 13999 } 14000 if (this._timeline.smoothChildTiming) { 14001 if (this._dirty) { 14002 this.totalDuration(); 14003 } 14004 var totalDuration = this._totalDuration, 14005 tl = this._timeline; 14006 if (time > totalDuration && !uncapped) { 14007 time = totalDuration; 14008 } 14009 this._startTime = (this._paused ? this._pauseTime : tl._time) - ((!this._reversed ? time : totalDuration - time) / this._timeScale); 14010 if (!tl._dirty) { //for performance improvement. If the parent's cache is already dirty, it already took care of marking the ancestors as dirty too, so skip the function call here. 14011 this._uncache(false); 14012 } 14013 //in case any of the ancestor timelines had completed but should now be enabled, we should reset their totalTime() which will also ensure that they're lined up properly and enabled. Skip for animations that are on the root (wasteful). Example: a TimelineLite.exportRoot() is performed when there's a paused tween on the root, the export will not complete until that tween is unpaused, but imagine a child gets restarted later, after all [unpaused] tweens have completed. The startTime of that child would get pushed out, but one of the ancestors may have completed. 14014 if (tl._timeline) { 14015 while (tl._timeline) { 14016 if (tl._timeline._time !== (tl._startTime + tl._totalTime) / tl._timeScale) { 14017 tl.totalTime(tl._totalTime, true); 14018 } 14019 tl = tl._timeline; 14020 } 14021 } 14022 } 14023 if (this._gc) { 14024 this._enabled(true, false); 14025 } 14026 if (this._totalTime !== time || this._duration === 0) { 14027 if (_lazyTweens.length) { 14028 _lazyRender(); 14029 } 14030 this.render(time, suppressEvents, false); 14031 if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when someone calls seek() or time() or progress(), they expect an immediate render. 14032 _lazyRender(); 14033 } 14034 } 14035 } 14036 return this; 14037 }; 14038 14039 p.progress = p.totalProgress = function(value, suppressEvents) { 14040 var duration = this.duration(); 14041 return (!arguments.length) ? (duration ? this._time / duration : this.ratio) : this.totalTime(duration * value, suppressEvents); 14042 }; 14043 14044 p.startTime = function(value) { 14045 if (!arguments.length) { 14046 return this._startTime; 14047 } 14048 if (value !== this._startTime) { 14049 this._startTime = value; 14050 if (this.timeline) if (this.timeline._sortChildren) { 14051 this.timeline.add(this, value - this._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct. 14052 } 14053 } 14054 return this; 14055 }; 14056 14057 p.endTime = function(includeRepeats) { 14058 return this._startTime + ((includeRepeats != false) ? this.totalDuration() : this.duration()) / this._timeScale; 14059 }; 14060 14061 p.timeScale = function(value) { 14062 if (!arguments.length) { 14063 return this._timeScale; 14064 } 14065 var pauseTime, t; 14066 value = value || _tinyNum; //can't allow zero because it'll throw the math off 14067 if (this._timeline && this._timeline.smoothChildTiming) { 14068 pauseTime = this._pauseTime; 14069 t = (pauseTime || pauseTime === 0) ? pauseTime : this._timeline.totalTime(); 14070 this._startTime = t - ((t - this._startTime) * this._timeScale / value); 14071 } 14072 this._timeScale = value; 14073 t = this.timeline; 14074 while (t && t.timeline) { //must update the duration/totalDuration of all ancestor timelines immediately in case in the middle of a render loop, one tween alters another tween's timeScale which shoves its startTime before 0, forcing the parent timeline to shift around and shiftChildren() which could affect that next tween's render (startTime). Doesn't matter for the root timeline though. 14075 t._dirty = true; 14076 t.totalDuration(); 14077 t = t.timeline; 14078 } 14079 return this; 14080 }; 14081 14082 p.reversed = function(value) { 14083 if (!arguments.length) { 14084 return this._reversed; 14085 } 14086 if (value != this._reversed) { 14087 this._reversed = value; 14088 this.totalTime(((this._timeline && !this._timeline.smoothChildTiming) ? this.totalDuration() - this._totalTime : this._totalTime), true); 14089 } 14090 return this; 14091 }; 14092 14093 p.paused = function(value) { 14094 if (!arguments.length) { 14095 return this._paused; 14096 } 14097 var tl = this._timeline, 14098 raw, elapsed; 14099 if (value != this._paused) if (tl) { 14100 if (!_tickerActive && !value) { 14101 _ticker.wake(); 14102 } 14103 raw = tl.rawTime(); 14104 elapsed = raw - this._pauseTime; 14105 if (!value && tl.smoothChildTiming) { 14106 this._startTime += elapsed; 14107 this._uncache(false); 14108 } 14109 this._pauseTime = value ? raw : null; 14110 this._paused = value; 14111 this._active = this.isActive(); 14112 if (!value && elapsed !== 0 && this._initted && this.duration()) { 14113 raw = tl.smoothChildTiming ? this._totalTime : (raw - this._startTime) / this._timeScale; 14114 this.render(raw, (raw === this._totalTime), true); //in case the target's properties changed via some other tween or manual update by the user, we should force a render. 14115 } 14116 } 14117 if (this._gc && !value) { 14118 this._enabled(true, false); 14119 } 14120 return this; 14121 }; 14122 14123 14124/* 14125 * ---------------------------------------------------------------- 14126 * SimpleTimeline 14127 * ---------------------------------------------------------------- 14128 */ 14129 var SimpleTimeline = _class("core.SimpleTimeline", function(vars) { 14130 Animation.call(this, 0, vars); 14131 this.autoRemoveChildren = this.smoothChildTiming = true; 14132 }); 14133 14134 p = SimpleTimeline.prototype = new Animation(); 14135 p.constructor = SimpleTimeline; 14136 p.kill()._gc = false; 14137 p._first = p._last = p._recent = null; 14138 p._sortChildren = false; 14139 14140 p.add = p.insert = function(child, position, align, stagger) { 14141 var prevTween, st; 14142 child._startTime = Number(position || 0) + child._delay; 14143 if (child._paused) if (this !== child._timeline) { //we only adjust the _pauseTime if it wasn't in this timeline already. Remember, sometimes a tween will be inserted again into the same timeline when its startTime is changed so that the tweens in the TimelineLite/Max are re-ordered properly in the linked list (so everything renders in the proper order). 14144 child._pauseTime = this.rawTime() - (child._timeline.rawTime() - child._pauseTime); 14145 } 14146 if (child.timeline) { 14147 child.timeline._remove(child, true); //removes from existing timeline so that it can be properly added to this one. 14148 } 14149 child.timeline = child._timeline = this; 14150 if (child._gc) { 14151 child._enabled(true, true); 14152 } 14153 prevTween = this._last; 14154 if (this._sortChildren) { 14155 st = child._startTime; 14156 while (prevTween && prevTween._startTime > st) { 14157 prevTween = prevTween._prev; 14158 } 14159 } 14160 if (prevTween) { 14161 child._next = prevTween._next; 14162 prevTween._next = child; 14163 } else { 14164 child._next = this._first; 14165 this._first = child; 14166 } 14167 if (child._next) { 14168 child._next._prev = child; 14169 } else { 14170 this._last = child; 14171 } 14172 child._prev = prevTween; 14173 this._recent = child; 14174 if (this._timeline) { 14175 this._uncache(true); 14176 } 14177 return this; 14178 }; 14179 14180 p._remove = function(tween, skipDisable) { 14181 if (tween.timeline === this) { 14182 if (!skipDisable) { 14183 tween._enabled(false, true); 14184 } 14185 14186 if (tween._prev) { 14187 tween._prev._next = tween._next; 14188 } else if (this._first === tween) { 14189 this._first = tween._next; 14190 } 14191 if (tween._next) { 14192 tween._next._prev = tween._prev; 14193 } else if (this._last === tween) { 14194 this._last = tween._prev; 14195 } 14196 tween._next = tween._prev = tween.timeline = null; 14197 if (tween === this._recent) { 14198 this._recent = this._last; 14199 } 14200 14201 if (this._timeline) { 14202 this._uncache(true); 14203 } 14204 } 14205 return this; 14206 }; 14207 14208 p.render = function(time, suppressEvents, force) { 14209 var tween = this._first, 14210 next; 14211 this._totalTime = this._time = this._rawPrevTime = time; 14212 while (tween) { 14213 next = tween._next; //record it here because the value could change after rendering... 14214 if (tween._active || (time >= tween._startTime && !tween._paused && !tween._gc)) { 14215 if (!tween._reversed) { 14216 tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); 14217 } else { 14218 tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); 14219 } 14220 } 14221 tween = next; 14222 } 14223 }; 14224 14225 p.rawTime = function() { 14226 if (!_tickerActive) { 14227 _ticker.wake(); 14228 } 14229 return this._totalTime; 14230 }; 14231 14232/* 14233 * ---------------------------------------------------------------- 14234 * TweenLite 14235 * ---------------------------------------------------------------- 14236 */ 14237 var TweenLite = _class("TweenLite", function(target, duration, vars) { 14238 Animation.call(this, duration, vars); 14239 this.render = TweenLite.prototype.render; //speed optimization (avoid prototype lookup on this "hot" method) 14240 14241 if (target == null) { 14242 throw "Cannot tween a null target."; 14243 } 14244 14245 this.target = target = (typeof(target) !== "string") ? target : TweenLite.selector(target) || target; 14246 14247 var isSelector = (target.jquery || (target.length && target !== window && target[0] && (target[0] === window || (target[0].nodeType && target[0].style && !target.nodeType)))), 14248 overwrite = this.vars.overwrite, 14249 i, targ, targets; 14250 14251 this._overwrite = overwrite = (overwrite == null) ? _overwriteLookup[TweenLite.defaultOverwrite] : (typeof(overwrite) === "number") ? overwrite >> 0 : _overwriteLookup[overwrite]; 14252 14253 if ((isSelector || target instanceof Array || (target.push && _isArray(target))) && typeof(target[0]) !== "number") { 14254 this._targets = targets = _slice(target); //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 14255 this._propLookup = []; 14256 this._siblings = []; 14257 for (i = 0; i < targets.length; i++) { 14258 targ = targets[i]; 14259 if (!targ) { 14260 targets.splice(i--, 1); 14261 continue; 14262 } else if (typeof(targ) === "string") { 14263 targ = targets[i--] = TweenLite.selector(targ); //in case it's an array of strings 14264 if (typeof(targ) === "string") { 14265 targets.splice(i+1, 1); //to avoid an endless loop (can't imagine why the selector would return a string, but just in case) 14266 } 14267 continue; 14268 } else if (targ.length && targ !== window && targ[0] && (targ[0] === window || (targ[0].nodeType && targ[0].style && !targ.nodeType))) { //in case the user is passing in an array of selector objects (like jQuery objects), we need to check one more level and pull things out if necessary. Also note that <select> elements pass all the criteria regarding length and the first child having style, so we must also check to ensure the target isn't an HTML node itself. 14269 targets.splice(i--, 1); 14270 this._targets = targets = targets.concat(_slice(targ)); 14271 continue; 14272 } 14273 this._siblings[i] = _register(targ, this, false); 14274 if (overwrite === 1) if (this._siblings[i].length > 1) { 14275 _applyOverwrite(targ, this, null, 1, this._siblings[i]); 14276 } 14277 } 14278 14279 } else { 14280 this._propLookup = {}; 14281 this._siblings = _register(target, this, false); 14282 if (overwrite === 1) if (this._siblings.length > 1) { 14283 _applyOverwrite(target, this, null, 1, this._siblings); 14284 } 14285 } 14286 if (this.vars.immediateRender || (duration === 0 && this._delay === 0 && this.vars.immediateRender !== false)) { 14287 this._time = -_tinyNum; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render) 14288 this.render(Math.min(0, -this._delay)); //in case delay is negative 14289 } 14290 }, true), 14291 _isSelector = function(v) { 14292 return (v && v.length && v !== window && v[0] && (v[0] === window || (v[0].nodeType && v[0].style && !v.nodeType))); //we cannot check "nodeType" if the target is window from within an iframe, otherwise it will trigger a security error in some browsers like Firefox. 14293 }, 14294 _autoCSS = function(vars, target) { 14295 var css = {}, 14296 p; 14297 for (p in vars) { 14298 if (!_reservedProps[p] && (!(p in target) || p === "transform" || p === "x" || p === "y" || p === "width" || p === "height" || p === "className" || p === "border") && (!_plugins[p] || (_plugins[p] && _plugins[p]._autoCSS))) { //note: <img> elements contain read-only "x" and "y" properties. We should also prioritize editing css width/height rather than the element's properties. 14299 css[p] = vars[p]; 14300 delete vars[p]; 14301 } 14302 } 14303 vars.css = css; 14304 }; 14305 14306 p = TweenLite.prototype = new Animation(); 14307 p.constructor = TweenLite; 14308 p.kill()._gc = false; 14309 14310//----TweenLite defaults, overwrite management, and root updates ---------------------------------------------------- 14311 14312 p.ratio = 0; 14313 p._firstPT = p._targets = p._overwrittenProps = p._startAt = null; 14314 p._notifyPluginsOfEnabled = p._lazy = false; 14315 14316 TweenLite.version = "2.1.2"; 14317 TweenLite.defaultEase = p._ease = new Ease(null, null, 1, 1); 14318 TweenLite.defaultOverwrite = "auto"; 14319 TweenLite.ticker = _ticker; 14320 TweenLite.autoSleep = 120; 14321 TweenLite.lagSmoothing = function(threshold, adjustedLag) { 14322 _ticker.lagSmoothing(threshold, adjustedLag); 14323 }; 14324 14325 TweenLite.selector = window.$ || window.jQuery || function(e) { 14326 var selector = window.$ || window.jQuery; 14327 if (selector) { 14328 TweenLite.selector = selector; 14329 return selector(e); 14330 } 14331 if (!_doc) { //in some dev environments (like Angular 6), GSAP gets loaded before the document is defined! So re-query it here if/when necessary. 14332 _doc = window.document; 14333 } 14334 return (!_doc) ? e : (_doc.querySelectorAll ? _doc.querySelectorAll(e) : _doc.getElementById((e.charAt(0) === "#") ? e.substr(1) : e)); 14335 }; 14336 14337 var _lazyTweens = [], 14338 _lazyLookup = {}, 14339 _numbersExp = /(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 14340 _relExp = /[\+-]=-?[\.\d]/, 14341 //_nonNumbersExp = /(?:([\-+](?!(\d|=)))|[^\d\-+=e]|(e(?![\-+][\d])))+/ig, 14342 _setRatio = function(v) { 14343 var pt = this._firstPT, 14344 min = 0.000001, 14345 val; 14346 while (pt) { 14347 val = !pt.blob ? pt.c * v + pt.s : (v === 1 && this.end != null) ? this.end : v ? this.join("") : this.start; 14348 if (pt.m) { 14349 val = pt.m.call(this._tween, val, this._target || pt.t, this._tween); 14350 } else if (val < min) if (val > -min && !pt.blob) { //prevents issues with converting very small numbers to strings in the browser 14351 val = 0; 14352 } 14353 if (!pt.f) { 14354 pt.t[pt.p] = val; 14355 } else if (pt.fp) { 14356 pt.t[pt.p](pt.fp, val); 14357 } else { 14358 pt.t[pt.p](val); 14359 } 14360 pt = pt._next; 14361 } 14362 }, 14363 _blobRound = function(v) { 14364 return (((v * 1000) | 0) / 1000) + ""; 14365 }, 14366 //compares two strings (start/end), finds the numbers that are different and spits back an array representing the whole value but with the changing values isolated as elements. For example, "rgb(0,0,0)" and "rgb(100,50,0)" would become ["rgb(", 0, ",", 50, ",0)"]. Notice it merges the parts that are identical (performance optimization). The array also has a linked list of PropTweens attached starting with _firstPT that contain the tweening data (t, p, s, c, f, etc.). It also stores the starting value as a "start" property so that we can revert to it if/when necessary, like when a tween rewinds fully. If the quantity of numbers differs between the start and end, it will always prioritize the end value(s). The pt parameter is optional - it's for a PropTween that will be appended to the end of the linked list and is typically for actually setting the value after all of the elements have been updated (with array.join("")). 14367 _blobDif = function(start, end, filter, pt) { 14368 var a = [], 14369 charIndex = 0, 14370 s = "", 14371 color = 0, 14372 startNums, endNums, num, i, l, nonNumbers, currentNum; 14373 a.start = start; 14374 a.end = end; 14375 start = a[0] = start + ""; //ensure values are strings 14376 end = a[1] = end + ""; 14377 if (filter) { 14378 filter(a); //pass an array with the starting and ending values and let the filter do whatever it needs to the values. 14379 start = a[0]; 14380 end = a[1]; 14381 } 14382 a.length = 0; 14383 startNums = start.match(_numbersExp) || []; 14384 endNums = end.match(_numbersExp) || []; 14385 if (pt) { 14386 pt._next = null; 14387 pt.blob = 1; 14388 a._firstPT = a._applyPT = pt; //apply last in the linked list (which means inserting it first) 14389 } 14390 l = endNums.length; 14391 for (i = 0; i < l; i++) { 14392 currentNum = endNums[i]; 14393 nonNumbers = end.substr(charIndex, end.indexOf(currentNum, charIndex)-charIndex); 14394 s += (nonNumbers || !i) ? nonNumbers : ","; //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case. 14395 charIndex += nonNumbers.length; 14396 if (color) { //sense rgba() values and round them. 14397 color = (color + 1) % 5; 14398 } else if (nonNumbers.substr(-5) === "rgba(") { 14399 color = 1; 14400 } 14401 if (currentNum === startNums[i] || startNums.length <= i) { 14402 s += currentNum; 14403 } else { 14404 if (s) { 14405 a.push(s); 14406 s = ""; 14407 } 14408 num = parseFloat(startNums[i]); 14409 a.push(num); 14410 a._firstPT = {_next: a._firstPT, t:a, p: a.length-1, s:num, c:((currentNum.charAt(1) === "=") ? parseInt(currentNum.charAt(0) + "1", 10) * parseFloat(currentNum.substr(2)) : (parseFloat(currentNum) - num)) || 0, f:0, m:(color && color < 4) ? Math.round : _blobRound}; //limiting to 3 decimal places and casting as a string can really help performance when array.join() is called! 14411 //note: we don't set _prev because we'll never need to remove individual PropTweens from this list. 14412 } 14413 charIndex += currentNum.length; 14414 } 14415 s += end.substr(charIndex); 14416 if (s) { 14417 a.push(s); 14418 } 14419 a.setRatio = _setRatio; 14420 if (_relExp.test(end)) { //if the end string contains relative values, delete it so that on the final render (in _setRatio()), we don't actually set it to the string with += or -= characters (forces it to use the calculated value). 14421 a.end = null; 14422 } 14423 return a; 14424 }, 14425 //note: "funcParam" is only necessary for function-based getters/setters that require an extra parameter like getAttribute("width") and setAttribute("width", value). In this example, funcParam would be "width". Used by AttrPlugin for example. 14426 _addPropTween = function(target, prop, start, end, overwriteProp, mod, funcParam, stringFilter, index) { 14427 if (typeof(end) === "function") { 14428 end = end(index || 0, target); 14429 } 14430 var type = typeof(target[prop]), 14431 getterName = (type !== "function") ? "" : ((prop.indexOf("set") || typeof(target["get" + prop.substr(3)]) !== "function") ? prop : "get" + prop.substr(3)), 14432 s = (start !== "get") ? start : !getterName ? target[prop] : funcParam ? target[getterName](funcParam) : target[getterName](), 14433 isRelative = (typeof(end) === "string" && end.charAt(1) === "="), 14434 pt = {t:target, p:prop, s:s, f:(type === "function"), pg:0, n:overwriteProp || prop, m:(!mod ? 0 : (typeof(mod) === "function") ? mod : Math.round), pr:0, c:isRelative ? parseInt(end.charAt(0) + "1", 10) * parseFloat(end.substr(2)) : (parseFloat(end) - s) || 0}, 14435 blob; 14436 14437 if (typeof(s) !== "number" || (typeof(end) !== "number" && !isRelative)) { 14438 if (funcParam || isNaN(s) || (!isRelative && isNaN(end)) || typeof(s) === "boolean" || typeof(end) === "boolean") { 14439 //a blob (string that has multiple numbers in it) 14440 pt.fp = funcParam; 14441 blob = _blobDif(s, (isRelative ? (parseFloat(pt.s) + pt.c) + (pt.s + "").replace(/[0-9\-\.]/g, "") : end), stringFilter || TweenLite.defaultStringFilter, pt); 14442 pt = {t: blob, p: "setRatio", s: 0, c: 1, f: 2, pg: 0, n: overwriteProp || prop, pr: 0, m: 0}; //"2" indicates it's a Blob property tween. Needed for RoundPropsPlugin for example. 14443 } else { 14444 pt.s = parseFloat(s); 14445 if (!isRelative) { 14446 pt.c = (parseFloat(end) - pt.s) || 0; 14447 } 14448 } 14449 } 14450 if (pt.c) { //only add it to the linked list if there's a change. 14451 if ((pt._next = this._firstPT)) { 14452 pt._next._prev = pt; 14453 } 14454 this._firstPT = pt; 14455 return pt; 14456 } 14457 }, 14458 _internals = TweenLite._internals = {isArray:_isArray, isSelector:_isSelector, lazyTweens:_lazyTweens, blobDif:_blobDif}, //gives us a way to expose certain private values to other GreenSock classes without contaminating tha main TweenLite object. 14459 _plugins = TweenLite._plugins = {}, 14460 _tweenLookup = _internals.tweenLookup = {}, 14461 _tweenLookupNum = 0, 14462 _reservedProps = _internals.reservedProps = {ease:1, delay:1, overwrite:1, onComplete:1, onCompleteParams:1, onCompleteScope:1, useFrames:1, runBackwards:1, startAt:1, onUpdate:1, onUpdateParams:1, onUpdateScope:1, onStart:1, onStartParams:1, onStartScope:1, onReverseComplete:1, onReverseCompleteParams:1, onReverseCompleteScope:1, onRepeat:1, onRepeatParams:1, onRepeatScope:1, easeParams:1, yoyo:1, immediateRender:1, repeat:1, repeatDelay:1, data:1, paused:1, reversed:1, autoCSS:1, lazy:1, onOverwrite:1, callbackScope:1, stringFilter:1, id:1, yoyoEase:1, stagger:1}, 14463 _overwriteLookup = {none:0, all:1, auto:2, concurrent:3, allOnStart:4, preexisting:5, "true":1, "false":0}, 14464 _rootFramesTimeline = Animation._rootFramesTimeline = new SimpleTimeline(), 14465 _rootTimeline = Animation._rootTimeline = new SimpleTimeline(), 14466 _nextGCFrame = 30, 14467 _lazyRender = _internals.lazyRender = function() { 14468 var l = _lazyTweens.length, 14469 i, tween; 14470 _lazyLookup = {}; 14471 for (i = 0; i < l; i++) { 14472 tween = _lazyTweens[i]; 14473 if (tween && tween._lazy !== false) { 14474 tween.render(tween._lazy[0], tween._lazy[1], true); 14475 tween._lazy = false; 14476 } 14477 } 14478 _lazyTweens.length = 0; 14479 }; 14480 14481 _rootTimeline._startTime = _ticker.time; 14482 _rootFramesTimeline._startTime = _ticker.frame; 14483 _rootTimeline._active = _rootFramesTimeline._active = true; 14484 setTimeout(_lazyRender, 1); //on some mobile devices, there isn't a "tick" before code runs which means any lazy renders wouldn't run before the next official "tick". 14485 14486 Animation._updateRoot = TweenLite.render = function() { 14487 var i, a, p; 14488 if (_lazyTweens.length) { //if code is run outside of the requestAnimationFrame loop, there may be tweens queued AFTER the engine refreshed, so we need to ensure any pending renders occur before we refresh again. 14489 _lazyRender(); 14490 } 14491 _rootTimeline.render((_ticker.time - _rootTimeline._startTime) * _rootTimeline._timeScale, false, false); 14492 _rootFramesTimeline.render((_ticker.frame - _rootFramesTimeline._startTime) * _rootFramesTimeline._timeScale, false, false); 14493 if (_lazyTweens.length) { 14494 _lazyRender(); 14495 } 14496 if (_ticker.frame >= _nextGCFrame) { //dump garbage every 120 frames or whatever the user sets TweenLite.autoSleep to 14497 _nextGCFrame = _ticker.frame + (parseInt(TweenLite.autoSleep, 10) || 120); 14498 for (p in _tweenLookup) { 14499 a = _tweenLookup[p].tweens; 14500 i = a.length; 14501 while (--i > -1) { 14502 if (a[i]._gc) { 14503 a.splice(i, 1); 14504 } 14505 } 14506 if (a.length === 0) { 14507 delete _tweenLookup[p]; 14508 } 14509 } 14510 //if there are no more tweens in the root timelines, or if they're all paused, make the _timer sleep to reduce load on the CPU slightly 14511 p = _rootTimeline._first; 14512 if (!p || p._paused) if (TweenLite.autoSleep && !_rootFramesTimeline._first && _ticker._listeners.tick.length === 1) { 14513 while (p && p._paused) { 14514 p = p._next; 14515 } 14516 if (!p) { 14517 _ticker.sleep(); 14518 } 14519 } 14520 } 14521 }; 14522 14523 _ticker.addEventListener("tick", Animation._updateRoot); 14524 14525 var _register = function(target, tween, scrub) { 14526 var id = target._gsTweenID, a, i; 14527 if (!_tweenLookup[id || (target._gsTweenID = id = "t" + (_tweenLookupNum++))]) { 14528 _tweenLookup[id] = {target:target, tweens:[]}; 14529 } 14530 if (tween) { 14531 a = _tweenLookup[id].tweens; 14532 a[(i = a.length)] = tween; 14533 if (scrub) { 14534 while (--i > -1) { 14535 if (a[i] === tween) { 14536 a.splice(i, 1); 14537 } 14538 } 14539 } 14540 } 14541 return _tweenLookup[id].tweens; 14542 }, 14543 _onOverwrite = function(overwrittenTween, overwritingTween, target, killedProps) { 14544 var func = overwrittenTween.vars.onOverwrite, r1, r2; 14545 if (func) { 14546 r1 = func(overwrittenTween, overwritingTween, target, killedProps); 14547 } 14548 func = TweenLite.onOverwrite; 14549 if (func) { 14550 r2 = func(overwrittenTween, overwritingTween, target, killedProps); 14551 } 14552 return (r1 !== false && r2 !== false); 14553 }, 14554 _applyOverwrite = function(target, tween, props, mode, siblings) { 14555 var i, changed, curTween, l; 14556 if (mode === 1 || mode >= 4) { 14557 l = siblings.length; 14558 for (i = 0; i < l; i++) { 14559 if ((curTween = siblings[i]) !== tween) { 14560 if (!curTween._gc) { 14561 if (curTween._kill(null, target, tween)) { 14562 changed = true; 14563 } 14564 } 14565 } else if (mode === 5) { 14566 break; 14567 } 14568 } 14569 return changed; 14570 } 14571 //NOTE: Add tiny amount to overcome floating point errors that can cause the startTime to be VERY slightly off (when a tween's time() is set for example) 14572 var startTime = tween._startTime + _tinyNum, 14573 overlaps = [], 14574 oCount = 0, 14575 zeroDur = (tween._duration === 0), 14576 globalStart; 14577 i = siblings.length; 14578 while (--i > -1) { 14579 if ((curTween = siblings[i]) === tween || curTween._gc || curTween._paused) { 14580 //ignore 14581 } else if (curTween._timeline !== tween._timeline) { 14582 globalStart = globalStart || _checkOverlap(tween, 0, zeroDur); 14583 if (_checkOverlap(curTween, globalStart, zeroDur) === 0) { 14584 overlaps[oCount++] = curTween; 14585 } 14586 } else if (curTween._startTime <= startTime) if (curTween._startTime + curTween.totalDuration() / curTween._timeScale > startTime) if (!((zeroDur || !curTween._initted) && startTime - curTween._startTime <= _tinyNum * 2)) { 14587 overlaps[oCount++] = curTween; 14588 } 14589 } 14590 14591 i = oCount; 14592 while (--i > -1) { 14593 curTween = overlaps[i]; 14594 l = curTween._firstPT; //we need to discern if there were property tweens originally; if they all get removed in the next line's _kill() call, the tween should be killed. See https://github.com/greensock/GreenSock-JS/issues/278 14595 if (mode === 2) if (curTween._kill(props, target, tween)) { 14596 changed = true; 14597 } 14598 if (mode !== 2 || (!curTween._firstPT && curTween._initted && l)) { 14599 if (mode !== 2 && !_onOverwrite(curTween, tween)) { 14600 continue; 14601 } 14602 if (curTween._enabled(false, false)) { //if all property tweens have been overwritten, kill the tween. 14603 changed = true; 14604 } 14605 } 14606 } 14607 return changed; 14608 }, 14609 _checkOverlap = function(tween, reference, zeroDur) { 14610 var tl = tween._timeline, 14611 ts = tl._timeScale, 14612 t = tween._startTime; 14613 while (tl._timeline) { 14614 t += tl._startTime; 14615 ts *= tl._timeScale; 14616 if (tl._paused) { 14617 return -100; 14618 } 14619 tl = tl._timeline; 14620 } 14621 t /= ts; 14622 return (t > reference) ? t - reference : ((zeroDur && t === reference) || (!tween._initted && t - reference < 2 * _tinyNum)) ? _tinyNum : ((t += tween.totalDuration() / tween._timeScale / ts) > reference + _tinyNum) ? 0 : t - reference - _tinyNum; 14623 }; 14624 14625 14626//---- TweenLite instance methods ----------------------------------------------------------------------------- 14627 14628 p._init = function() { 14629 var v = this.vars, 14630 op = this._overwrittenProps, 14631 dur = this._duration, 14632 immediate = !!v.immediateRender, 14633 ease = v.ease, 14634 startAt = this._startAt, 14635 i, initPlugins, pt, p, startVars, l; 14636 if (v.startAt) { 14637 if (startAt) { 14638 startAt.render(-1, true); //if we've run a startAt previously (when the tween instantiated), we should revert it so that the values re-instantiate correctly particularly for relative tweens. Without this, a TweenLite.fromTo(obj, 1, {x:"+=100"}, {x:"-=100"}), for example, would actually jump to +=200 because the startAt would run twice, doubling the relative change. 14639 startAt.kill(); 14640 } 14641 startVars = {}; 14642 for (p in v.startAt) { //copy the properties/values into a new object to avoid collisions, like var to = {x:0}, from = {x:500}; timeline.fromTo(e, 1, from, to).fromTo(e, 1, to, from); 14643 startVars[p] = v.startAt[p]; 14644 } 14645 startVars.data = "isStart"; 14646 startVars.overwrite = false; 14647 startVars.immediateRender = true; 14648 startVars.lazy = (immediate && v.lazy !== false); 14649 startVars.startAt = startVars.delay = null; //no nesting of startAt objects allowed (otherwise it could cause an infinite loop). 14650 startVars.onUpdate = v.onUpdate; 14651 startVars.onUpdateParams = v.onUpdateParams; 14652 startVars.onUpdateScope = v.onUpdateScope || v.callbackScope || this; 14653 this._startAt = TweenLite.to(this.target || {}, 0, startVars); 14654 if (immediate) { 14655 if (this._time > 0) { 14656 this._startAt = null; //tweens that render immediately (like most from() and fromTo() tweens) shouldn't revert when their parent timeline's playhead goes backward past the startTime because the initial render could have happened anytime and it shouldn't be directly correlated to this tween's startTime. Imagine setting up a complex animation where the beginning states of various objects are rendered immediately but the tween doesn't happen for quite some time - if we revert to the starting values as soon as the playhead goes backward past the tween's startTime, it will throw things off visually. Reversion should only happen in TimelineLite/Max instances where immediateRender was false (which is the default in the convenience methods like from()). 14657 } else if (dur !== 0) { 14658 return; //we skip initialization here so that overwriting doesn't occur until the tween actually begins. Otherwise, if you create several immediateRender:true tweens of the same target/properties to drop into a TimelineLite or TimelineMax, the last one created would overwrite the first ones because they didn't get placed into the timeline yet before the first render occurs and kicks in overwriting. 14659 } 14660 } 14661 } else if (v.runBackwards && dur !== 0) { 14662 //from() tweens must be handled uniquely: their beginning values must be rendered but we don't want overwriting to occur yet (when time is still 0). Wait until the tween actually begins before doing all the routines like overwriting. At that time, we should render at the END of the tween to ensure that things initialize correctly (remember, from() tweens go backwards) 14663 if (startAt) { 14664 startAt.render(-1, true); 14665 startAt.kill(); 14666 this._startAt = null; 14667 } else { 14668 if (this._time !== 0) { //in rare cases (like if a from() tween runs and then is invalidate()-ed), immediateRender could be true but the initial forced-render gets skipped, so there's no need to force the render in this context when the _time is greater than 0 14669 immediate = false; 14670 } 14671 pt = {}; 14672 for (p in v) { //copy props into a new object and skip any reserved props, otherwise onComplete or onUpdate or onStart could fire. We should, however, permit autoCSS to go through. 14673 if (!_reservedProps[p] || p === "autoCSS") { 14674 pt[p] = v[p]; 14675 } 14676 } 14677 pt.overwrite = 0; 14678 pt.data = "isFromStart"; //we tag the tween with as "isFromStart" so that if [inside a plugin] we need to only do something at the very END of a tween, we have a way of identifying this tween as merely the one that's setting the beginning values for a "from()" tween. For example, clearProps in CSSPlugin should only get applied at the very END of a tween and without this tag, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in. 14679 pt.lazy = (immediate && v.lazy !== false); 14680 pt.immediateRender = immediate; //zero-duration tweens render immediately by default, but if we're not specifically instructed to render this tween immediately, we should skip this and merely _init() to record the starting values (rendering them immediately would push them to completion which is wasteful in that case - we'd have to render(-1) immediately after) 14681 this._startAt = TweenLite.to(this.target, 0, pt); 14682 if (!immediate) { 14683 this._startAt._init(); //ensures that the initial values are recorded 14684 this._startAt._enabled(false); //no need to have the tween render on the next cycle. Disable it because we'll always manually control the renders of the _startAt tween. 14685 if (this.vars.immediateRender) { 14686 this._startAt = null; 14687 } 14688 } else if (this._time === 0) { 14689 return; 14690 } 14691 } 14692 } 14693 this._ease = ease = (!ease) ? TweenLite.defaultEase : (ease instanceof Ease) ? ease : (typeof(ease) === "function") ? new Ease(ease, v.easeParams) : _easeMap[ease] || TweenLite.defaultEase; 14694 if (v.easeParams instanceof Array && ease.config) { 14695 this._ease = ease.config.apply(ease, v.easeParams); 14696 } 14697 this._easeType = this._ease._type; 14698 this._easePower = this._ease._power; 14699 this._firstPT = null; 14700 14701 if (this._targets) { 14702 l = this._targets.length; 14703 for (i = 0; i < l; i++) { 14704 if ( this._initProps( this._targets[i], (this._propLookup[i] = {}), this._siblings[i], (op ? op[i] : null), i) ) { 14705 initPlugins = true; 14706 } 14707 } 14708 } else { 14709 initPlugins = this._initProps(this.target, this._propLookup, this._siblings, op, 0); 14710 } 14711 14712 if (initPlugins) { 14713 TweenLite._onPluginEvent("_onInitAllProps", this); //reorders the array in order of priority. Uses a static TweenPlugin method in order to minimize file size in TweenLite 14714 } 14715 if (op) if (!this._firstPT) if (typeof(this.target) !== "function") { //if all tweening properties have been overwritten, kill the tween. If the target is a function, it's probably a delayedCall so let it live. 14716 this._enabled(false, false); 14717 } 14718 if (v.runBackwards) { 14719 pt = this._firstPT; 14720 while (pt) { 14721 pt.s += pt.c; 14722 pt.c = -pt.c; 14723 pt = pt._next; 14724 } 14725 } 14726 this._onUpdate = v.onUpdate; 14727 this._initted = true; 14728 }; 14729 14730 p._initProps = function(target, propLookup, siblings, overwrittenProps, index) { 14731 var p, i, initPlugins, plugin, pt, v; 14732 if (target == null) { 14733 return false; 14734 } 14735 if (_lazyLookup[target._gsTweenID]) { 14736 _lazyRender(); //if other tweens of the same target have recently initted but haven't rendered yet, we've got to force the render so that the starting values are correct (imagine populating a timeline with a bunch of sequential tweens and then jumping to the end) 14737 } 14738 14739 if (!this.vars.css) if (target.style) if (target !== window && target.nodeType) if (_plugins.css) if (this.vars.autoCSS !== false) { //it's so common to use TweenLite/Max to animate the css of DOM elements, we assume that if the target is a DOM element, that's what is intended (a convenience so that users don't have to wrap things in css:{}, although we still recommend it for a slight performance boost and better specificity). Note: we cannot check "nodeType" on the window inside an iframe. 14740 _autoCSS(this.vars, target); 14741 } 14742 for (p in this.vars) { 14743 v = this.vars[p]; 14744 if (_reservedProps[p]) { 14745 if (v) if ((v instanceof Array) || (v.push && _isArray(v))) if (v.join("").indexOf("{self}") !== -1) { 14746 this.vars[p] = v = this._swapSelfInParams(v, this); 14747 } 14748 14749 } else if (_plugins[p] && (plugin = new _plugins[p]())._onInitTween(target, this.vars[p], this, index)) { 14750 14751 //t - target [object] 14752 //p - property [string] 14753 //s - start [number] 14754 //c - change [number] 14755 //f - isFunction [boolean] 14756 //n - name [string] 14757 //pg - isPlugin [boolean] 14758 //pr - priority [number] 14759 //m - mod [function | 0] 14760 this._firstPT = pt = {_next:this._firstPT, t:plugin, p:"setRatio", s:0, c:1, f:1, n:p, pg:1, pr:plugin._priority, m:0}; 14761 i = plugin._overwriteProps.length; 14762 while (--i > -1) { 14763 propLookup[plugin._overwriteProps[i]] = this._firstPT; 14764 } 14765 if (plugin._priority || plugin._onInitAllProps) { 14766 initPlugins = true; 14767 } 14768 if (plugin._onDisable || plugin._onEnable) { 14769 this._notifyPluginsOfEnabled = true; 14770 } 14771 if (pt._next) { 14772 pt._next._prev = pt; 14773 } 14774 14775 } else { 14776 propLookup[p] = _addPropTween.call(this, target, p, "get", v, p, 0, null, this.vars.stringFilter, index); 14777 } 14778 } 14779 14780 if (overwrittenProps) if (this._kill(overwrittenProps, target)) { //another tween may have tried to overwrite properties of this tween before init() was called (like if two tweens start at the same time, the one created second will run first) 14781 return this._initProps(target, propLookup, siblings, overwrittenProps, index); 14782 } 14783 if (this._overwrite > 1) if (this._firstPT) if (siblings.length > 1) if (_applyOverwrite(target, this, propLookup, this._overwrite, siblings)) { 14784 this._kill(propLookup, target); 14785 return this._initProps(target, propLookup, siblings, overwrittenProps, index); 14786 } 14787 if (this._firstPT) if ((this.vars.lazy !== false && this._duration) || (this.vars.lazy && !this._duration)) { //zero duration tweens don't lazy render by default; everything else does. 14788 _lazyLookup[target._gsTweenID] = true; 14789 } 14790 return initPlugins; 14791 }; 14792 14793 p.render = function(time, suppressEvents, force) { 14794 var self = this, 14795 prevTime = self._time, 14796 duration = self._duration, 14797 prevRawPrevTime = self._rawPrevTime, 14798 isComplete, callback, pt, rawPrevTime; 14799 if (time >= duration - _tinyNum && time >= 0) { //to work around occasional floating point math artifacts. 14800 self._totalTime = self._time = duration; 14801 self.ratio = self._ease._calcEnd ? self._ease.getRatio(1) : 1; 14802 if (!self._reversed ) { 14803 isComplete = true; 14804 callback = "onComplete"; 14805 force = (force || self._timeline.autoRemoveChildren); //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 14806 } 14807 if (duration === 0) if (self._initted || !self.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 14808 if (self._startTime === self._timeline._duration) { //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent rounding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate. 14809 time = 0; 14810 } 14811 if (prevRawPrevTime < 0 || (time <= 0 && time >= -_tinyNum) || (prevRawPrevTime === _tinyNum && self.data !== "isPause")) if (prevRawPrevTime !== time) { //note: when this.data is "isPause", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause. 14812 force = true; 14813 if (prevRawPrevTime > _tinyNum) { 14814 callback = "onReverseComplete"; 14815 } 14816 } 14817 self._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 14818 } 14819 14820 } else if (time < _tinyNum) { //to work around occasional floating point math artifacts, round super small values to 0. 14821 self._totalTime = self._time = 0; 14822 self.ratio = self._ease._calcEnd ? self._ease.getRatio(0) : 0; 14823 if (prevTime !== 0 || (duration === 0 && prevRawPrevTime > 0)) { 14824 callback = "onReverseComplete"; 14825 isComplete = self._reversed; 14826 } 14827 if (time > -_tinyNum) { 14828 time = 0; 14829 } else if (time < 0) { 14830 self._active = false; 14831 if (duration === 0) if (self._initted || !self.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 14832 if (prevRawPrevTime >= 0 && !(prevRawPrevTime === _tinyNum && self.data === "isPause")) { 14833 force = true; 14834 } 14835 self._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 14836 } 14837 } 14838 if (!self._initted || (self._startAt && self._startAt.progress())) { //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately. Also, we check progress() because if startAt has already rendered at its end, we should force a render at its beginning. Otherwise, if you put the playhead directly on top of where a fromTo({immediateRender:false}) starts, and then move it backwards, the from() won't revert its values. 14839 force = true; 14840 } 14841 } else { 14842 self._totalTime = self._time = time; 14843 14844 if (self._easeType) { 14845 var r = time / duration, type = self._easeType, pow = self._easePower; 14846 if (type === 1 || (type === 3 && r >= 0.5)) { 14847 r = 1 - r; 14848 } 14849 if (type === 3) { 14850 r *= 2; 14851 } 14852 if (pow === 1) { 14853 r *= r; 14854 } else if (pow === 2) { 14855 r *= r * r; 14856 } else if (pow === 3) { 14857 r *= r * r * r; 14858 } else if (pow === 4) { 14859 r *= r * r * r * r; 14860 } 14861 self.ratio = (type === 1) ? 1 - r : (type === 2) ? r : (time / duration < 0.5) ? r / 2 : 1 - (r / 2); 14862 } else { 14863 self.ratio = self._ease.getRatio(time / duration); 14864 } 14865 } 14866 14867 if (self._time === prevTime && !force) { 14868 return; 14869 } else if (!self._initted) { 14870 self._init(); 14871 if (!self._initted || self._gc) { //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that overwriting occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example. 14872 return; 14873 } else if (!force && self._firstPT && ((self.vars.lazy !== false && self._duration) || (self.vars.lazy && !self._duration))) { 14874 self._time = self._totalTime = prevTime; 14875 self._rawPrevTime = prevRawPrevTime; 14876 _lazyTweens.push(self); 14877 self._lazy = [time, suppressEvents]; 14878 return; 14879 } 14880 //_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently. 14881 if (self._time && !isComplete) { 14882 self.ratio = self._ease.getRatio(self._time / duration); 14883 } else if (isComplete && self._ease._calcEnd) { 14884 self.ratio = self._ease.getRatio((self._time === 0) ? 0 : 1); 14885 } 14886 } 14887 if (self._lazy !== false) { //in case a lazy render is pending, we should flush it because the new render is occurring now (imagine a lazy tween instantiating and then immediately the user calls tween.seek(tween.duration()), skipping to the end - the end render would be forced, and then if we didn't flush the lazy render, it'd fire AFTER the seek(), rendering it at the wrong time. 14888 self._lazy = false; 14889 } 14890 if (!self._active) if (!self._paused && self._time !== prevTime && time >= 0) { 14891 self._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done. 14892 } 14893 if (prevTime === 0) { 14894 if (self._startAt) { 14895 if (time >= 0) { 14896 self._startAt.render(time, true, force); 14897 } else if (!callback) { 14898 callback = "_dummyGS"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area. 14899 } 14900 } 14901 if (self.vars.onStart) if (self._time !== 0 || duration === 0) if (!suppressEvents) { 14902 self._callback("onStart"); 14903 } 14904 } 14905 pt = self._firstPT; 14906 while (pt) { 14907 if (pt.f) { 14908 pt.t[pt.p](pt.c * self.ratio + pt.s); 14909 } else { 14910 pt.t[pt.p] = pt.c * self.ratio + pt.s; 14911 } 14912 pt = pt._next; 14913 } 14914 14915 if (self._onUpdate) { 14916 if (time < 0) if (self._startAt && time !== -0.0001) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. 14917 self._startAt.render(time, true, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete. 14918 } 14919 if (!suppressEvents) if (self._time !== prevTime || isComplete || force) { 14920 self._callback("onUpdate"); 14921 } 14922 } 14923 if (callback) if (!self._gc || force) { //check _gc because there's a chance that kill() could be called in an onUpdate 14924 if (time < 0 && self._startAt && !self._onUpdate && time !== -0.0001) { //-0.0001 is a special value that we use when looping back to the beginning of a repeated TimelineMax, in which case we shouldn't render the _startAt values. 14925 self._startAt.render(time, true, force); 14926 } 14927 if (isComplete) { 14928 if (self._timeline.autoRemoveChildren) { 14929 self._enabled(false, false); 14930 } 14931 self._active = false; 14932 } 14933 if (!suppressEvents && self.vars[callback]) { 14934 self._callback(callback); 14935 } 14936 if (duration === 0 && self._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) { //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the "time" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon scenario, but possible nonetheless. 14937 self._rawPrevTime = 0; 14938 } 14939 } 14940 }; 14941 14942 p._kill = function(vars, target, overwritingTween) { 14943 if (vars === "all") { 14944 vars = null; 14945 } 14946 if (vars == null) if (target == null || target === this.target) { 14947 this._lazy = false; 14948 return this._enabled(false, false); 14949 } 14950 target = (typeof(target) !== "string") ? (target || this._targets || this.target) : TweenLite.selector(target) || target; 14951 var simultaneousOverwrite = (overwritingTween && this._time && overwritingTween._startTime === this._startTime && this._timeline === overwritingTween._timeline), 14952 firstPT = this._firstPT, 14953 i, overwrittenProps, p, pt, propLookup, changed, killProps, record, killed; 14954 if ((_isArray(target) || _isSelector(target)) && typeof(target[0]) !== "number") { 14955 i = target.length; 14956 while (--i > -1) { 14957 if (this._kill(vars, target[i], overwritingTween)) { 14958 changed = true; 14959 } 14960 } 14961 } else { 14962 if (this._targets) { 14963 i = this._targets.length; 14964 while (--i > -1) { 14965 if (target === this._targets[i]) { 14966 propLookup = this._propLookup[i] || {}; 14967 this._overwrittenProps = this._overwrittenProps || []; 14968 overwrittenProps = this._overwrittenProps[i] = vars ? this._overwrittenProps[i] || {} : "all"; 14969 break; 14970 } 14971 } 14972 } else if (target !== this.target) { 14973 return false; 14974 } else { 14975 propLookup = this._propLookup; 14976 overwrittenProps = this._overwrittenProps = vars ? this._overwrittenProps || {} : "all"; 14977 } 14978 14979 if (propLookup) { 14980 killProps = vars || propLookup; 14981 record = (vars !== overwrittenProps && overwrittenProps !== "all" && vars !== propLookup && (typeof(vars) !== "object" || !vars._tempKill)); //_tempKill is a super-secret way to delete a particular tweening property but NOT have it remembered as an official overwritten property (like in BezierPlugin) 14982 if (overwritingTween && (TweenLite.onOverwrite || this.vars.onOverwrite)) { 14983 for (p in killProps) { 14984 if (propLookup[p]) { 14985 if (!killed) { 14986 killed = []; 14987 } 14988 killed.push(p); 14989 } 14990 } 14991 if ((killed || !vars) && !_onOverwrite(this, overwritingTween, target, killed)) { //if the onOverwrite returned false, that means the user wants to override the overwriting (cancel it). 14992 return false; 14993 } 14994 } 14995 14996 for (p in killProps) { 14997 if ((pt = propLookup[p])) { 14998 if (simultaneousOverwrite) { //if another tween overwrites this one and they both start at exactly the same time, yet this tween has already rendered once (for example, at 0.001) because it's first in the queue, we should revert the values to where they were at 0 so that the starting values aren't contaminated on the overwriting tween. 14999 if (pt.f) { 15000 pt.t[pt.p](pt.s); 15001 } else { 15002 pt.t[pt.p] = pt.s; 15003 } 15004 changed = true; 15005 } 15006 if (pt.pg && pt.t._kill(killProps)) { 15007 changed = true; //some plugins need to be notified so they can perform cleanup tasks first 15008 } 15009 if (!pt.pg || pt.t._overwriteProps.length === 0) { 15010 if (pt._prev) { 15011 pt._prev._next = pt._next; 15012 } else if (pt === this._firstPT) { 15013 this._firstPT = pt._next; 15014 } 15015 if (pt._next) { 15016 pt._next._prev = pt._prev; 15017 } 15018 pt._next = pt._prev = null; 15019 } 15020 delete propLookup[p]; 15021 } 15022 if (record) { 15023 overwrittenProps[p] = 1; 15024 } 15025 } 15026 if (!this._firstPT && this._initted && firstPT) { //if all tweening properties are killed, kill the tween. Without this line, if there's a tween with multiple targets and then you killTweensOf() each target individually, the tween would technically still remain active and fire its onComplete even though there aren't any more properties tweening. 15027 this._enabled(false, false); 15028 } 15029 } 15030 } 15031 return changed; 15032 }; 15033 15034 p.invalidate = function() { 15035 if (this._notifyPluginsOfEnabled) { 15036 TweenLite._onPluginEvent("_onDisable", this); 15037 } 15038 var t = this._time; 15039 this._firstPT = this._overwrittenProps = this._startAt = this._onUpdate = null; 15040 this._notifyPluginsOfEnabled = this._active = this._lazy = false; 15041 this._propLookup = (this._targets) ? {} : []; 15042 Animation.prototype.invalidate.call(this); 15043 if (this.vars.immediateRender) { 15044 this._time = -_tinyNum; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render) 15045 this.render(t, false, this.vars.lazy !== false); 15046 } 15047 return this; 15048 }; 15049 15050 p._enabled = function(enabled, ignoreTimeline) { 15051 if (!_tickerActive) { 15052 _ticker.wake(); 15053 } 15054 if (enabled && this._gc) { 15055 var targets = this._targets, 15056 i; 15057 if (targets) { 15058 i = targets.length; 15059 while (--i > -1) { 15060 this._siblings[i] = _register(targets[i], this, true); 15061 } 15062 } else { 15063 this._siblings = _register(this.target, this, true); 15064 } 15065 } 15066 Animation.prototype._enabled.call(this, enabled, ignoreTimeline); 15067 if (this._notifyPluginsOfEnabled) if (this._firstPT) { 15068 return TweenLite._onPluginEvent((enabled ? "_onEnable" : "_onDisable"), this); 15069 } 15070 return false; 15071 }; 15072 15073 15074//----TweenLite static methods ----------------------------------------------------- 15075 15076 TweenLite.to = function(target, duration, vars) { 15077 return new TweenLite(target, duration, vars); 15078 }; 15079 15080 TweenLite.from = function(target, duration, vars) { 15081 vars.runBackwards = true; 15082 vars.immediateRender = (vars.immediateRender != false); 15083 return new TweenLite(target, duration, vars); 15084 }; 15085 15086 TweenLite.fromTo = function(target, duration, fromVars, toVars) { 15087 toVars.startAt = fromVars; 15088 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 15089 return new TweenLite(target, duration, toVars); 15090 }; 15091 15092 TweenLite.delayedCall = function(delay, callback, params, scope, useFrames) { 15093 return new TweenLite(callback, 0, {delay:delay, onComplete:callback, onCompleteParams:params, callbackScope:scope, onReverseComplete:callback, onReverseCompleteParams:params, immediateRender:false, lazy:false, useFrames:useFrames, overwrite:0}); 15094 }; 15095 15096 TweenLite.set = function(target, vars) { 15097 return new TweenLite(target, 0, vars); 15098 }; 15099 15100 TweenLite.getTweensOf = function(target, onlyActive) { 15101 if (target == null) { return []; } 15102 target = (typeof(target) !== "string") ? target : TweenLite.selector(target) || target; 15103 var i, a, j, t; 15104 if ((_isArray(target) || _isSelector(target)) && typeof(target[0]) !== "number") { 15105 i = target.length; 15106 a = []; 15107 while (--i > -1) { 15108 a = a.concat(TweenLite.getTweensOf(target[i], onlyActive)); 15109 } 15110 i = a.length; 15111 //now get rid of any duplicates (tweens of arrays of objects could cause duplicates) 15112 while (--i > -1) { 15113 t = a[i]; 15114 j = i; 15115 while (--j > -1) { 15116 if (t === a[j]) { 15117 a.splice(i, 1); 15118 } 15119 } 15120 } 15121 } else if (target._gsTweenID) { 15122 a = _register(target).concat(); 15123 i = a.length; 15124 while (--i > -1) { 15125 if (a[i]._gc || (onlyActive && !a[i].isActive())) { 15126 a.splice(i, 1); 15127 } 15128 } 15129 } 15130 return a || []; 15131 }; 15132 15133 TweenLite.killTweensOf = TweenLite.killDelayedCallsTo = function(target, onlyActive, vars) { 15134 if (typeof(onlyActive) === "object") { 15135 vars = onlyActive; //for backwards compatibility (before "onlyActive" parameter was inserted) 15136 onlyActive = false; 15137 } 15138 var a = TweenLite.getTweensOf(target, onlyActive), 15139 i = a.length; 15140 while (--i > -1) { 15141 a[i]._kill(vars, target); 15142 } 15143 }; 15144 15145 15146 15147/* 15148 * ---------------------------------------------------------------- 15149 * TweenPlugin (could easily be split out as a separate file/class, but included for ease of use (so that people don't need to include another script call before loading plugins which is easy to forget) 15150 * ---------------------------------------------------------------- 15151 */ 15152 var TweenPlugin = _class("plugins.TweenPlugin", function(props, priority) { 15153 this._overwriteProps = (props || "").split(","); 15154 this._propName = this._overwriteProps[0]; 15155 this._priority = priority || 0; 15156 this._super = TweenPlugin.prototype; 15157 }, true); 15158 15159 p = TweenPlugin.prototype; 15160 TweenPlugin.version = "1.19.0"; 15161 TweenPlugin.API = 2; 15162 p._firstPT = null; 15163 p._addTween = _addPropTween; 15164 p.setRatio = _setRatio; 15165 15166 p._kill = function(lookup) { 15167 var a = this._overwriteProps, 15168 pt = this._firstPT, 15169 i; 15170 if (lookup[this._propName] != null) { 15171 this._overwriteProps = []; 15172 } else { 15173 i = a.length; 15174 while (--i > -1) { 15175 if (lookup[a[i]] != null) { 15176 a.splice(i, 1); 15177 } 15178 } 15179 } 15180 while (pt) { 15181 if (lookup[pt.n] != null) { 15182 if (pt._next) { 15183 pt._next._prev = pt._prev; 15184 } 15185 if (pt._prev) { 15186 pt._prev._next = pt._next; 15187 pt._prev = null; 15188 } else if (this._firstPT === pt) { 15189 this._firstPT = pt._next; 15190 } 15191 } 15192 pt = pt._next; 15193 } 15194 return false; 15195 }; 15196 15197 p._mod = p._roundProps = function(lookup) { 15198 var pt = this._firstPT, 15199 val; 15200 while (pt) { 15201 val = lookup[this._propName] || (pt.n != null && lookup[ pt.n.split(this._propName + "_").join("") ]); 15202 if (val && typeof(val) === "function") { //some properties that are very plugin-specific add a prefix named after the _propName plus an underscore, so we need to ignore that extra stuff here. 15203 if (pt.f === 2) { 15204 pt.t._applyPT.m = val; 15205 } else { 15206 pt.m = val; 15207 } 15208 } 15209 pt = pt._next; 15210 } 15211 }; 15212 15213 TweenLite._onPluginEvent = function(type, tween) { 15214 var pt = tween._firstPT, 15215 changed, pt2, first, last, next; 15216 if (type === "_onInitAllProps") { 15217 //sorts the PropTween linked list in order of priority because some plugins need to render earlier/later than others, like MotionBlurPlugin applies its effects after all x/y/alpha tweens have rendered on each frame. 15218 while (pt) { 15219 next = pt._next; 15220 pt2 = first; 15221 while (pt2 && pt2.pr > pt.pr) { 15222 pt2 = pt2._next; 15223 } 15224 if ((pt._prev = pt2 ? pt2._prev : last)) { 15225 pt._prev._next = pt; 15226 } else { 15227 first = pt; 15228 } 15229 if ((pt._next = pt2)) { 15230 pt2._prev = pt; 15231 } else { 15232 last = pt; 15233 } 15234 pt = next; 15235 } 15236 pt = tween._firstPT = first; 15237 } 15238 while (pt) { 15239 if (pt.pg) if (typeof(pt.t[type]) === "function") if (pt.t[type]()) { 15240 changed = true; 15241 } 15242 pt = pt._next; 15243 } 15244 return changed; 15245 }; 15246 15247 TweenPlugin.activate = function(plugins) { 15248 var i = plugins.length; 15249 while (--i > -1) { 15250 if (plugins[i].API === TweenPlugin.API) { 15251 _plugins[(new plugins[i]())._propName] = plugins[i]; 15252 } 15253 } 15254 return true; 15255 }; 15256 15257 //provides a more concise way to define plugins that have no dependencies besides TweenPlugin and TweenLite, wrapping common boilerplate stuff into one function (added in 1.9.0). You don't NEED to use this to define a plugin - the old way still works and can be useful in certain (rare) situations. 15258 _gsDefine.plugin = function(config) { 15259 if (!config || !config.propName || !config.init || !config.API) { throw "illegal plugin definition."; } 15260 var propName = config.propName, 15261 priority = config.priority || 0, 15262 overwriteProps = config.overwriteProps, 15263 map = {init:"_onInitTween", set:"setRatio", kill:"_kill", round:"_mod", mod:"_mod", initAll:"_onInitAllProps"}, 15264 Plugin = _class("plugins." + propName.charAt(0).toUpperCase() + propName.substr(1) + "Plugin", 15265 function() { 15266 TweenPlugin.call(this, propName, priority); 15267 this._overwriteProps = overwriteProps || []; 15268 }, (config.global === true)), 15269 p = Plugin.prototype = new TweenPlugin(propName), 15270 prop; 15271 p.constructor = Plugin; 15272 Plugin.API = config.API; 15273 for (prop in map) { 15274 if (typeof(config[prop]) === "function") { 15275 p[map[prop]] = config[prop]; 15276 } 15277 } 15278 Plugin.version = config.version; 15279 TweenPlugin.activate([Plugin]); 15280 return Plugin; 15281 }; 15282 15283 15284 //now run through all the dependencies discovered and if any are missing, log that to the console as a warning. This is why it's best to have TweenLite load last - it can check all the dependencies for you. 15285 a = window._gsQueue; 15286 if (a) { 15287 for (i = 0; i < a.length; i++) { 15288 a[i](); 15289 } 15290 for (p in _defLookup) { 15291 if (!_defLookup[p].func) { 15292 window.console.log("GSAP encountered missing dependency: " + p); 15293 } 15294 } 15295 } 15296 15297 _tickerActive = false; //ensures that the first official animation forces a ticker.tick() to update the time when it is instantiated 15298 15299 return TweenLite; 15300 15301})(_gsScope, "TweenLite"); 15302 15303var globals = _gsScope.GreenSockGlobals; 15304var nonGlobals = globals.com.greensock; 15305 15306var SimpleTimeline = nonGlobals.core.SimpleTimeline; 15307var Animation = nonGlobals.core.Animation; 15308var Ease = globals.Ease; 15309var Linear = globals.Linear; 15310var Power0 = Linear; 15311var Power1 = globals.Power1; 15312var Power2 = globals.Power2; 15313var Power3 = globals.Power3; 15314var Power4 = globals.Power4; 15315var TweenPlugin = globals.TweenPlugin; 15316var EventDispatcher = nonGlobals.events.EventDispatcher; 15317 15318/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/harmony-module.js */ "./node_modules/webpack/buildin/harmony-module.js")(module), __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) 15319 15320/***/ }), 15321
vendor: 8,497 bytes, lines 15322-15428
15322/***/ "./node_modules/gsap/TweenMax.js": 15323/*!***************************************!*\ 15324 !*** ./node_modules/gsap/TweenMax.js ***! 15325 \***************************************/ 15326/*! exports provided: TweenMax, default, TweenLite, TimelineLite, TimelineMax, CSSPlugin, AttrPlugin, BezierPlugin, DirectionalRotationPlugin, RoundPropsPlugin, TweenPlugin, Ease, Power0, Power1, Power2, Power3, Power4, Linear, Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase */ 15327/***/ (function(module, __webpack_exports__, __webpack_require__) { 15328 15329"use strict"; 15330__webpack_require__.r(__webpack_exports__); 15331/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TweenMax", function() { return TweenMax; }); 15332/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TweenMax; }); 15333/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 15334/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenLite", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]; }); 15335 15336/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenPlugin", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"]; }); 15337 15338/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Ease", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]; }); 15339 15340/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power0"]; }); 15341 15342/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power1"]; }); 15343 15344/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power2"]; }); 15345 15346/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power3"]; }); 15347 15348/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power4"]; }); 15349 15350/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Linear"]; }); 15351 15352/* harmony import */ var _TweenMaxBase_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TweenMaxBase.js */ "./node_modules/gsap/TweenMaxBase.js"); 15353/* harmony import */ var _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./CSSPlugin.js */ "./node_modules/gsap/CSSPlugin.js"); 15354/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CSSPlugin", function() { return _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_2__["default"]; }); 15355 15356/* harmony import */ var _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./AttrPlugin.js */ "./node_modules/gsap/AttrPlugin.js"); 15357/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "AttrPlugin", function() { return _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_3__["default"]; }); 15358 15359/* harmony import */ var _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./RoundPropsPlugin.js */ "./node_modules/gsap/RoundPropsPlugin.js"); 15360/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RoundPropsPlugin", function() { return _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_4__["default"]; }); 15361 15362/* harmony import */ var _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./DirectionalRotationPlugin.js */ "./node_modules/gsap/DirectionalRotationPlugin.js"); 15363/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DirectionalRotationPlugin", function() { return _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_5__["default"]; }); 15364 15365/* harmony import */ var _TimelineLite_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./TimelineLite.js */ "./node_modules/gsap/TimelineLite.js"); 15366/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineLite", function() { return _TimelineLite_js__WEBPACK_IMPORTED_MODULE_6__["default"]; }); 15367 15368/* harmony import */ var _TimelineMax_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./TimelineMax.js */ "./node_modules/gsap/TimelineMax.js"); 15369/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineMax", function() { return _TimelineMax_js__WEBPACK_IMPORTED_MODULE_7__["default"]; }); 15370 15371/* harmony import */ var _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./BezierPlugin.js */ "./node_modules/gsap/BezierPlugin.js"); 15372/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BezierPlugin", function() { return _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_8__["default"]; }); 15373 15374/* harmony import */ var _EasePack_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./EasePack.js */ "./node_modules/gsap/EasePack.js"); 15375/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Back", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Back"]; }); 15376 15377/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Elastic", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Elastic"]; }); 15378 15379/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Bounce", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Bounce"]; }); 15380 15381/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RoughEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["RoughEase"]; }); 15382 15383/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SlowMo", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["SlowMo"]; }); 15384 15385/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SteppedEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["SteppedEase"]; }); 15386 15387/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Circ", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Circ"]; }); 15388 15389/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Expo", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Expo"]; }); 15390 15391/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Sine", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Sine"]; }); 15392 15393/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ExpoScaleEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["ExpoScaleEase"]; }); 15394 15395/*! 15396 * VERSION: 2.1.2 15397 * DATE: 2019-03-01 15398 * UPDATES AND DOCS AT: http://greensock.com 15399 * 15400 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 15401 * This work is subject to the terms at http://greensock.com/standard-license or for 15402 * Club GreenSock members, the software agreement that was issued with your membership. 15403 * 15404 * @author: Jack Doyle, [email protected] 15405 **/ 15406/* eslint-disable */ 15407 15408 15409 15410 15411 15412 15413 15414 15415 15416 15417 15418 15419//the following two lines are designed to prevent tree shaking of the classes that were historically included with TweenMax (otherwise, folks would have to reference CSSPlugin, for example, to ensure their CSS-related animations worked) 15420var TweenMax = _TweenMaxBase_js__WEBPACK_IMPORTED_MODULE_1__["default"]; 15421TweenMax._autoActivated = [_TimelineLite_js__WEBPACK_IMPORTED_MODULE_6__["default"], _TimelineMax_js__WEBPACK_IMPORTED_MODULE_7__["default"], _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_2__["default"], _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_3__["default"], _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_8__["default"], _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_4__["default"], _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_5__["default"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Back"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Elastic"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Bounce"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["RoughEase"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["SlowMo"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["SteppedEase"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Circ"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Expo"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Sine"], _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["ExpoScaleEase"]]; 15422 15423 15424 15425 15426 15427/***/ }), 15428
vendor: 35,864 bytes, lines 15429-16133
15429/***/ "./node_modules/gsap/TweenMaxBase.js": 15430/*!*******************************************!*\ 15431 !*** ./node_modules/gsap/TweenMaxBase.js ***! 15432 \*******************************************/ 15433/*! exports provided: TweenMax, TweenMaxBase, default, TweenLite, Ease, Power0, Power1, Power2, Power3, Power4, Linear */ 15434/***/ (function(module, __webpack_exports__, __webpack_require__) { 15435 15436"use strict"; 15437__webpack_require__.r(__webpack_exports__); 15438/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TweenMax", function() { return TweenMax; }); 15439/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TweenMaxBase", function() { return TweenMaxBase; }); 15440/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TweenMax; }); 15441/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 15442/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenLite", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]; }); 15443 15444/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Ease", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]; }); 15445 15446/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power0"]; }); 15447 15448/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power1"]; }); 15449 15450/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power2"]; }); 15451 15452/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power3"]; }); 15453 15454/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power4"]; }); 15455 15456/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Linear"]; }); 15457 15458/*! 15459 * VERSION: 2.1.2 15460 * DATE: 2019-03-01 15461 * UPDATES AND DOCS AT: http://greensock.com 15462 * 15463 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 15464 * This work is subject to the terms at http://greensock.com/standard-license or for 15465 * Club GreenSock members, the software agreement that was issued with your membership. 15466 * 15467 * @author: Jack Doyle, [email protected] 15468 **/ 15469/* eslint-disable */ 15470 15471 15472 15473 15474_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]._gsDefine("TweenMax", ["core.Animation","core.SimpleTimeline","TweenLite"], function() { 15475 15476 var _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() 15477 var b = [], 15478 l = a.length, 15479 i; 15480 for (i = 0; i !== l; b.push(a[i++])); 15481 return b; 15482 }, 15483 _applyCycle = function(vars, targets, i) { 15484 var alt = vars.cycle, 15485 p, val; 15486 for (p in alt) { 15487 val = alt[p]; 15488 vars[p] = (typeof(val) === "function") ? val(i, targets[i], targets) : val[i % val.length]; 15489 } 15490 delete vars.cycle; 15491 }, 15492 //for distributing values across an array. Can accept a number, a function or (most commonly) a function which can contain the following properties: {base, amount, from, ease, grid, axis, length, each}. Returns a function that expects the following parameters: index, target, array. Recognizes the following 15493 _distribute = function(v) { 15494 if (typeof(v) === "function") { 15495 return v; 15496 } 15497 var vars = (typeof(v) === "object") ? v : {each:v}, //n:1 is just to indicate v was a number; we leverage that later to set v according to the length we get. If a number is passed in, we treat it like the old stagger value where 0.1, for example, would mean that things would be distributed with 0.1 between each element in the array rather than a total "amount" that's chunked out among them all. 15498 ease = vars.ease, 15499 from = vars.from || 0, 15500 base = vars.base || 0, 15501 cache = {}, 15502 isFromKeyword = isNaN(from), 15503 axis = vars.axis, 15504 ratio = {center:0.5, end:1}[from] || 0; 15505 return function(i, target, a) { 15506 var l = (a || vars).length, 15507 distances = cache[l], 15508 originX, originY, x, y, d, j, max, min, wrap; 15509 if (!distances) { 15510 wrap = (vars.grid === "auto") ? 0 : (vars.grid || [Infinity])[0]; 15511 if (!wrap) { 15512 max = -Infinity; 15513 while (max < (max = a[wrap++].getBoundingClientRect().left) && wrap < l) { } 15514 wrap--; 15515 } 15516 distances = cache[l] = []; 15517 originX = isFromKeyword ? (Math.min(wrap, l) * ratio) - 0.5 : from % wrap; 15518 originY = isFromKeyword ? l * ratio / wrap - 0.5 : (from / wrap) | 0; 15519 max = 0; 15520 min = Infinity; 15521 for (j = 0; j < l; j++) { 15522 x = (j % wrap) - originX; 15523 y = originY - ((j / wrap) | 0); 15524 distances[j] = d = !axis ? Math.sqrt(x * x + y * y) : Math.abs((axis === "y") ? y : x); 15525 if (d > max) { 15526 max = d; 15527 } 15528 if (d < min) { 15529 min = d; 15530 } 15531 } 15532 distances.max = max - min; 15533 distances.min = min; 15534 distances.v = l = vars.amount || (vars.each * (wrap > l ? l : !axis ? Math.max(wrap, l / wrap) : axis === "y" ? l / wrap : wrap)) || 0; 15535 distances.b = (l < 0) ? base - l : base; 15536 } 15537 l = (distances[i] - distances.min) / distances.max; 15538 return distances.b + (ease ? ease.getRatio(l) : l) * distances.v; 15539 }; 15540 }, 15541 TweenMax = function(target, duration, vars) { 15542 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].call(this, target, duration, vars); 15543 this._cycle = 0; 15544 this._yoyo = (this.vars.yoyo === true || !!this.vars.yoyoEase); 15545 this._repeat = this.vars.repeat || 0; 15546 this._repeatDelay = this.vars.repeatDelay || 0; 15547 if (this._repeat) { 15548 this._uncache(true); //ensures that if there is any repeat, the totalDuration will get recalculated to accurately report it. 15549 } 15550 this.render = TweenMax.prototype.render; //speed optimization (avoid prototype lookup on this "hot" method) 15551 }, 15552 _tinyNum = 0.00000001, 15553 TweenLiteInternals = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]._internals, 15554 _isSelector = TweenLiteInternals.isSelector, 15555 _isArray = TweenLiteInternals.isArray, 15556 p = TweenMax.prototype = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].to({}, 0.1, {}), 15557 _blankArray = []; 15558 15559 TweenMax.version = "2.1.2"; 15560 p.constructor = TweenMax; 15561 p.kill()._gc = false; 15562 TweenMax.killTweensOf = TweenMax.killDelayedCallsTo = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].killTweensOf; 15563 TweenMax.getTweensOf = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].getTweensOf; 15564 TweenMax.lagSmoothing = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].lagSmoothing; 15565 TweenMax.ticker = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker; 15566 TweenMax.render = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].render; 15567 TweenMax.distribute = _distribute; 15568 15569 p.invalidate = function() { 15570 this._yoyo = (this.vars.yoyo === true || !!this.vars.yoyoEase); 15571 this._repeat = this.vars.repeat || 0; 15572 this._repeatDelay = this.vars.repeatDelay || 0; 15573 this._yoyoEase = null; 15574 this._uncache(true); 15575 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.invalidate.call(this); 15576 }; 15577 15578 p.updateTo = function(vars, resetDuration) { 15579 var self = this, 15580 curRatio = self.ratio, 15581 immediate = self.vars.immediateRender || vars.immediateRender, 15582 p; 15583 if (resetDuration && self._startTime < self._timeline._time) { 15584 self._startTime = self._timeline._time; 15585 self._uncache(false); 15586 if (self._gc) { 15587 self._enabled(true, false); 15588 } else { 15589 self._timeline.insert(self, self._startTime - self._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct. 15590 } 15591 } 15592 for (p in vars) { 15593 self.vars[p] = vars[p]; 15594 } 15595 if (self._initted || immediate) { 15596 if (resetDuration) { 15597 self._initted = false; 15598 if (immediate) { 15599 self.render(0, true, true); 15600 } 15601 } else { 15602 if (self._gc) { 15603 self._enabled(true, false); 15604 } 15605 if (self._notifyPluginsOfEnabled && self._firstPT) { 15606 _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]._onPluginEvent("_onDisable", self); //in case a plugin like MotionBlur must perform some cleanup tasks 15607 } 15608 if (self._time / self._duration > 0.998) { //if the tween has finished (or come extremely close to finishing), we just need to rewind it to 0 and then render it again at the end which forces it to re-initialize (parsing the new vars). We allow tweens that are close to finishing (but haven't quite finished) to work this way too because otherwise, the values are so small when determining where to project the starting values that binary math issues creep in and can make the tween appear to render incorrectly when run backwards. 15609 var prevTime = self._totalTime; 15610 self.render(0, true, false); 15611 self._initted = false; 15612 self.render(prevTime, true, false); 15613 } else { 15614 self._initted = false; 15615 self._init(); 15616 if (self._time > 0 || immediate) { 15617 var inv = 1 / (1 - curRatio), 15618 pt = self._firstPT, endValue; 15619 while (pt) { 15620 endValue = pt.s + pt.c; 15621 pt.c *= inv; 15622 pt.s = endValue - pt.c; 15623 pt = pt._next; 15624 } 15625 } 15626 } 15627 } 15628 } 15629 return self; 15630 }; 15631 15632 p.render = function(time, suppressEvents, force) { 15633 if (!this._initted) if (this._duration === 0 && this.vars.repeat) { //zero duration tweens that render immediately have render() called from TweenLite's constructor, before TweenMax's constructor has finished setting _repeat, _repeatDelay, and _yoyo which are critical in determining totalDuration() so we need to call invalidate() which is a low-kb way to get those set properly. 15634 this.invalidate(); 15635 } 15636 var self = this, 15637 totalDur = (!self._dirty) ? self._totalDuration : self.totalDuration(), 15638 prevTime = self._time, 15639 prevTotalTime = self._totalTime, 15640 prevCycle = self._cycle, 15641 duration = self._duration, 15642 prevRawPrevTime = self._rawPrevTime, 15643 isComplete, callback, pt, cycleDuration, r, type, pow, rawPrevTime, yoyoEase; 15644 if (time >= totalDur - _tinyNum && time >= 0) { //to work around occasional floating point math artifacts. 15645 self._totalTime = totalDur; 15646 self._cycle = self._repeat; 15647 if (self._yoyo && (self._cycle & 1) !== 0) { 15648 self._time = 0; 15649 self.ratio = self._ease._calcEnd ? self._ease.getRatio(0) : 0; 15650 } else { 15651 self._time = duration; 15652 self.ratio = self._ease._calcEnd ? self._ease.getRatio(1) : 1; 15653 } 15654 if (!self._reversed) { 15655 isComplete = true; 15656 callback = "onComplete"; 15657 force = (force || self._timeline.autoRemoveChildren); //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. 15658 } 15659 if (duration === 0) if (self._initted || !self.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 15660 if (self._startTime === self._timeline._duration) { //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent rounding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate. 15661 time = 0; 15662 } 15663 if (prevRawPrevTime < 0 || (time <= 0 && time >= -_tinyNum) || (prevRawPrevTime === _tinyNum && self.data !== "isPause")) if (prevRawPrevTime !== time) { //note: when this.data is "isPause", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause. 15664 force = true; 15665 if (prevRawPrevTime > _tinyNum) { 15666 callback = "onReverseComplete"; 15667 } 15668 } 15669 self._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 15670 } 15671 15672 } else if (time < _tinyNum) { //to work around occasional floating point math artifacts, round super small values to 0. 15673 self._totalTime = self._time = self._cycle = 0; 15674 self.ratio = self._ease._calcEnd ? self._ease.getRatio(0) : 0; 15675 if (prevTotalTime !== 0 || (duration === 0 && prevRawPrevTime > 0)) { 15676 callback = "onReverseComplete"; 15677 isComplete = self._reversed; 15678 } 15679 if (time > -_tinyNum) { 15680 time = 0; 15681 } else if (time < 0) { 15682 self._active = false; 15683 if (duration === 0) if (self._initted || !self.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. 15684 if (prevRawPrevTime >= 0) { 15685 force = true; 15686 } 15687 self._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. 15688 } 15689 } 15690 if (!self._initted) { //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately. 15691 force = true; 15692 } 15693 } else { 15694 self._totalTime = self._time = time; 15695 if (self._repeat !== 0) { 15696 cycleDuration = duration + self._repeatDelay; 15697 self._cycle = (self._totalTime / cycleDuration) >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but some browsers report it as 0.79999999!) 15698 if (self._cycle !== 0) if (self._cycle === self._totalTime / cycleDuration && prevTotalTime <= time) { 15699 self._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning) 15700 } 15701 self._time = self._totalTime - (self._cycle * cycleDuration); 15702 if (self._yoyo) if ((self._cycle & 1) !== 0) { 15703 self._time = duration - self._time; 15704 yoyoEase = self._yoyoEase || self.vars.yoyoEase; //note: we don't set this._yoyoEase in _init() like we do other properties because it's TweenMax-specific and doing it here allows us to optimize performance (most tweens don't have a yoyoEase). Note that we also must skip the this.ratio calculation further down right after we _init() in this function, because we're doing it here. 15705 if (yoyoEase) { 15706 if (!self._yoyoEase) { 15707 if (yoyoEase === true && !self._initted) { //if it's not initted and yoyoEase is true, this._ease won't have been populated yet so we must discern it here. 15708 yoyoEase = self.vars.ease; 15709 self._yoyoEase = yoyoEase = !yoyoEase ? _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].defaultEase : (yoyoEase instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]) ? yoyoEase : (typeof(yoyoEase) === "function") ? new _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"](yoyoEase, self.vars.easeParams) : _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"].map[yoyoEase] || _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].defaultEase; 15710 } else { 15711 self._yoyoEase = yoyoEase = (yoyoEase === true) ? self._ease : (yoyoEase instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]) ? yoyoEase : _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"].map[yoyoEase]; 15712 } 15713 } 15714 self.ratio = yoyoEase ? 1 - yoyoEase.getRatio((duration - self._time) / duration) : 0; 15715 } 15716 } 15717 if (self._time > duration) { 15718 self._time = duration; 15719 } else if (self._time < 0) { 15720 self._time = 0; 15721 } 15722 } 15723 if (self._easeType && !yoyoEase) { 15724 r = self._time / duration; 15725 type = self._easeType; 15726 pow = self._easePower; 15727 if (type === 1 || (type === 3 && r >= 0.5)) { 15728 r = 1 - r; 15729 } 15730 if (type === 3) { 15731 r *= 2; 15732 } 15733 if (pow === 1) { 15734 r *= r; 15735 } else if (pow === 2) { 15736 r *= r * r; 15737 } else if (pow === 3) { 15738 r *= r * r * r; 15739 } else if (pow === 4) { 15740 r *= r * r * r * r; 15741 } 15742 self.ratio = (type === 1) ? 1 - r : (type === 2) ? r : (self._time / duration < 0.5) ? r / 2 : 1 - (r / 2); 15743 15744 } else if (!yoyoEase) { 15745 self.ratio = self._ease.getRatio(self._time / duration); 15746 } 15747 15748 } 15749 15750 if (prevTime === self._time && !force && prevCycle === self._cycle) { 15751 if (prevTotalTime !== self._totalTime) if (self._onUpdate) if (!suppressEvents) { //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate. 15752 self._callback("onUpdate"); 15753 } 15754 return; 15755 } else if (!self._initted) { 15756 self._init(); 15757 if (!self._initted || self._gc) { //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that overwriting occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example. 15758 return; 15759 } else if (!force && self._firstPT && ((self.vars.lazy !== false && self._duration) || (self.vars.lazy && !self._duration))) { //we stick it in the queue for rendering at the very end of the tick - this is a performance optimization because browsers invalidate styles and force a recalculation if you read, write, and then read style data (so it's better to read/read/read/write/write/write than read/write/read/write/read/write). The down side, of course, is that usually you WANT things to render immediately because you may have code running right after that which depends on the change. Like imagine running TweenLite.set(...) and then immediately after that, creating a nother tween that animates the same property to another value; the starting values of that 2nd tween wouldn't be accurate if lazy is true. 15760 self._time = prevTime; 15761 self._totalTime = prevTotalTime; 15762 self._rawPrevTime = prevRawPrevTime; 15763 self._cycle = prevCycle; 15764 TweenLiteInternals.lazyTweens.push(self); 15765 self._lazy = [time, suppressEvents]; 15766 return; 15767 } 15768 //_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently. 15769 if (self._time && !isComplete && !yoyoEase) { 15770 self.ratio = self._ease.getRatio(self._time / duration); 15771 } else if (isComplete && this._ease._calcEnd && !yoyoEase) { 15772 self.ratio = self._ease.getRatio((self._time === 0) ? 0 : 1); 15773 } 15774 } 15775 if (self._lazy !== false) { 15776 self._lazy = false; 15777 } 15778 15779 if (!self._active) if (!self._paused && self._time !== prevTime && time >= 0) { 15780 self._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done. 15781 } 15782 if (prevTotalTime === 0) { 15783 if (self._initted === 2 && time > 0) { 15784 self._init(); //will just apply overwriting since _initted of (2) means it was a from() tween that had immediateRender:true 15785 } 15786 if (self._startAt) { 15787 if (time >= 0) { 15788 self._startAt.render(time, true, force); 15789 } else if (!callback) { 15790 callback = "_dummyGS"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area. 15791 } 15792 } 15793 if (self.vars.onStart) if (self._totalTime !== 0 || duration === 0) if (!suppressEvents) { 15794 self._callback("onStart"); 15795 } 15796 } 15797 15798 pt = self._firstPT; 15799 while (pt) { 15800 if (pt.f) { 15801 pt.t[pt.p](pt.c * self.ratio + pt.s); 15802 } else { 15803 pt.t[pt.p] = pt.c * self.ratio + pt.s; 15804 } 15805 pt = pt._next; 15806 } 15807 15808 if (self._onUpdate) { 15809 if (time < 0) if (self._startAt && self._startTime) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. 15810 self._startAt.render(time, true, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete. 15811 } 15812 if (!suppressEvents) if (self._totalTime !== prevTotalTime || callback) { 15813 self._callback("onUpdate"); 15814 } 15815 } 15816 if (self._cycle !== prevCycle) if (!suppressEvents) if (!self._gc) if (self.vars.onRepeat) { 15817 self._callback("onRepeat"); 15818 } 15819 if (callback) if (!self._gc || force) { //check gc because there's a chance that kill() could be called in an onUpdate 15820 if (time < 0 && self._startAt && !self._onUpdate && self._startTime) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. 15821 self._startAt.render(time, true, force); 15822 } 15823 if (isComplete) { 15824 if (self._timeline.autoRemoveChildren) { 15825 self._enabled(false, false); 15826 } 15827 self._active = false; 15828 } 15829 if (!suppressEvents && self.vars[callback]) { 15830 self._callback(callback); 15831 } 15832 if (duration === 0 && self._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) { //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the "time" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon scenario, but possible nonetheless. 15833 self._rawPrevTime = 0; 15834 } 15835 } 15836 }; 15837 15838//---- STATIC FUNCTIONS ----------------------------------------------------------------------------------------------------------- 15839 15840 TweenMax.to = function(target, duration, vars) { 15841 return new TweenMax(target, duration, vars); 15842 }; 15843 15844 TweenMax.from = function(target, duration, vars) { 15845 vars.runBackwards = true; 15846 vars.immediateRender = (vars.immediateRender != false); 15847 return new TweenMax(target, duration, vars); 15848 }; 15849 15850 TweenMax.fromTo = function(target, duration, fromVars, toVars) { 15851 toVars.startAt = fromVars; 15852 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 15853 return new TweenMax(target, duration, toVars); 15854 }; 15855 15856 TweenMax.staggerTo = TweenMax.allTo = function(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 15857 var a = [], 15858 staggerFunc = _distribute(vars.stagger || stagger), 15859 cycle = vars.cycle, 15860 fromCycle = (vars.startAt || _blankArray).cycle, 15861 l, copy, i, p; 15862 if (!_isArray(targets)) { 15863 if (typeof(targets) === "string") { 15864 targets = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].selector(targets) || targets; 15865 } 15866 if (_isSelector(targets)) { 15867 targets = _slice(targets); 15868 } 15869 } 15870 targets = targets || []; 15871 l = targets.length - 1; 15872 for (i = 0; i <= l; i++) { 15873 copy = {}; 15874 for (p in vars) { 15875 copy[p] = vars[p]; 15876 } 15877 if (cycle) { 15878 _applyCycle(copy, targets, i); 15879 if (copy.duration != null) { 15880 duration = copy.duration; 15881 delete copy.duration; 15882 } 15883 } 15884 if (fromCycle) { 15885 fromCycle = copy.startAt = {}; 15886 for (p in vars.startAt) { 15887 fromCycle[p] = vars.startAt[p]; 15888 } 15889 _applyCycle(copy.startAt, targets, i); 15890 } 15891 copy.delay = staggerFunc(i, targets[i], targets) + (copy.delay || 0); 15892 if (i === l && onCompleteAll) { 15893 copy.onComplete = function() { 15894 if (vars.onComplete) { 15895 vars.onComplete.apply(vars.onCompleteScope || this, arguments); 15896 } 15897 onCompleteAll.apply(onCompleteAllScope || vars.callbackScope || this, onCompleteAllParams || _blankArray); 15898 }; 15899 } 15900 a[i] = new TweenMax(targets[i], duration, copy); 15901 } 15902 return a; 15903 }; 15904 15905 TweenMax.staggerFrom = TweenMax.allFrom = function(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 15906 vars.runBackwards = true; 15907 vars.immediateRender = (vars.immediateRender != false); 15908 return TweenMax.staggerTo(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 15909 }; 15910 15911 TweenMax.staggerFromTo = TweenMax.allFromTo = function(targets, duration, fromVars, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { 15912 toVars.startAt = fromVars; 15913 toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); 15914 return TweenMax.staggerTo(targets, duration, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope); 15915 }; 15916 15917 TweenMax.delayedCall = function(delay, callback, params, scope, useFrames) { 15918 return new TweenMax(callback, 0, {delay:delay, onComplete:callback, onCompleteParams:params, callbackScope:scope, onReverseComplete:callback, onReverseCompleteParams:params, immediateRender:false, useFrames:useFrames, overwrite:0}); 15919 }; 15920 15921 TweenMax.set = function(target, vars) { 15922 return new TweenMax(target, 0, vars); 15923 }; 15924 15925 TweenMax.isTweening = function(target) { 15926 return (_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].getTweensOf(target, true).length > 0); 15927 }; 15928 15929 var _getChildrenOf = function(timeline, includeTimelines) { 15930 var a = [], 15931 cnt = 0, 15932 tween = timeline._first; 15933 while (tween) { 15934 if (tween instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]) { 15935 a[cnt++] = tween; 15936 } else { 15937 if (includeTimelines) { 15938 a[cnt++] = tween; 15939 } 15940 a = a.concat(_getChildrenOf(tween, includeTimelines)); 15941 cnt = a.length; 15942 } 15943 tween = tween._next; 15944 } 15945 return a; 15946 }, 15947 getAllTweens = TweenMax.getAllTweens = function(includeTimelines) { 15948 return _getChildrenOf(_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootTimeline, includeTimelines).concat( _getChildrenOf(_TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootFramesTimeline, includeTimelines) ); 15949 }; 15950 15951 TweenMax.killAll = function(complete, tweens, delayedCalls, timelines) { 15952 if (tweens == null) { 15953 tweens = true; 15954 } 15955 if (delayedCalls == null) { 15956 delayedCalls = true; 15957 } 15958 var a = getAllTweens((timelines != false)), 15959 l = a.length, 15960 allTrue = (tweens && delayedCalls && timelines), 15961 isDC, tween, i; 15962 for (i = 0; i < l; i++) { 15963 tween = a[i]; 15964 if (allTrue || (tween instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"]) || ((isDC = (tween.target === tween.vars.onComplete)) && delayedCalls) || (tweens && !isDC)) { 15965 if (complete) { 15966 tween.totalTime(tween._reversed ? 0 : tween.totalDuration()); 15967 } else { 15968 tween._enabled(false, false); 15969 } 15970 } 15971 } 15972 }; 15973 15974 TweenMax.killChildTweensOf = function(parent, complete) { 15975 if (parent == null) { 15976 return; 15977 } 15978 var tl = TweenLiteInternals.tweenLookup, 15979 a, curParent, p, i, l; 15980 if (typeof(parent) === "string") { 15981 parent = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].selector(parent) || parent; 15982 } 15983 if (_isSelector(parent)) { 15984 parent = _slice(parent); 15985 } 15986 if (_isArray(parent)) { 15987 i = parent.length; 15988 while (--i > -1) { 15989 TweenMax.killChildTweensOf(parent[i], complete); 15990 } 15991 return; 15992 } 15993 a = []; 15994 for (p in tl) { 15995 curParent = tl[p].target.parentNode; 15996 while (curParent) { 15997 if (curParent === parent) { 15998 a = a.concat(tl[p].tweens); 15999 } 16000 curParent = curParent.parentNode; 16001 } 16002 } 16003 l = a.length; 16004 for (i = 0; i < l; i++) { 16005 if (complete) { 16006 a[i].totalTime(a[i].totalDuration()); 16007 } 16008 a[i]._enabled(false, false); 16009 } 16010 }; 16011 16012 var _changePause = function(pause, tweens, delayedCalls, timelines) { 16013 tweens = (tweens !== false); 16014 delayedCalls = (delayedCalls !== false); 16015 timelines = (timelines !== false); 16016 var a = getAllTweens(timelines), 16017 allTrue = (tweens && delayedCalls && timelines), 16018 i = a.length, 16019 isDC, tween; 16020 while (--i > -1) { 16021 tween = a[i]; 16022 if (allTrue || (tween instanceof _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["SimpleTimeline"]) || ((isDC = (tween.target === tween.vars.onComplete)) && delayedCalls) || (tweens && !isDC)) { 16023 tween.paused(pause); 16024 } 16025 } 16026 }; 16027 16028 TweenMax.pauseAll = function(tweens, delayedCalls, timelines) { 16029 _changePause(true, tweens, delayedCalls, timelines); 16030 }; 16031 16032 TweenMax.resumeAll = function(tweens, delayedCalls, timelines) { 16033 _changePause(false, tweens, delayedCalls, timelines); 16034 }; 16035 16036 TweenMax.globalTimeScale = function(value) { 16037 var tl = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootTimeline, 16038 t = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.time; 16039 if (!arguments.length) { 16040 return tl._timeScale; 16041 } 16042 value = value || _tinyNum; //can't allow zero because it'll throw the math off 16043 tl._startTime = t - ((t - tl._startTime) * tl._timeScale / value); 16044 tl = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootFramesTimeline; 16045 t = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"].ticker.frame; 16046 tl._startTime = t - ((t - tl._startTime) * tl._timeScale / value); 16047 tl._timeScale = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"]._rootTimeline._timeScale = value; 16048 return value; 16049 }; 16050 16051 16052//---- GETTERS / SETTERS ---------------------------------------------------------------------------------------------------------- 16053 16054 p.progress = function(value, suppressEvents) { 16055 return (!arguments.length) ? this._time / this.duration() : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents); 16056 }; 16057 16058 p.totalProgress = function(value, suppressEvents) { 16059 return (!arguments.length) ? this._totalTime / this.totalDuration() : this.totalTime( this.totalDuration() * value, suppressEvents); 16060 }; 16061 16062 p.time = function(value, suppressEvents) { 16063 if (!arguments.length) { 16064 return this._time; 16065 } 16066 if (this._dirty) { 16067 this.totalDuration(); 16068 } 16069 var duration = this._duration, 16070 cycle = this._cycle, 16071 cycleDur = cycle * (duration + this._repeatDelay); 16072 if (value > duration) { 16073 value = duration; 16074 } 16075 return this.totalTime((this._yoyo && (cycle & 1)) ? duration - value + cycleDur : this._repeat ? value + cycleDur : value, suppressEvents); 16076 }; 16077 16078 p.duration = function(value) { 16079 if (!arguments.length) { 16080 return this._duration; //don't set _dirty = false because there could be repeats that haven't been factored into the _totalDuration yet. Otherwise, if you create a repeated TweenMax and then immediately check its duration(), it would cache the value and the totalDuration would not be correct, thus repeats wouldn't take effect. 16081 } 16082 return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Animation"].prototype.duration.call(this, value); 16083 }; 16084 16085 p.totalDuration = function(value) { 16086 if (!arguments.length) { 16087 if (this._dirty) { 16088 //instead of Infinity, we use 999999999999 so that we can accommodate reverses 16089 this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat); 16090 this._dirty = false; 16091 } 16092 return this._totalDuration; 16093 } 16094 return (this._repeat === -1) ? this : this.duration( (value - (this._repeat * this._repeatDelay)) / (this._repeat + 1) ); 16095 }; 16096 16097 p.repeat = function(value) { 16098 if (!arguments.length) { 16099 return this._repeat; 16100 } 16101 this._repeat = value; 16102 return this._uncache(true); 16103 }; 16104 16105 p.repeatDelay = function(value) { 16106 if (!arguments.length) { 16107 return this._repeatDelay; 16108 } 16109 this._repeatDelay = value; 16110 return this._uncache(true); 16111 }; 16112 16113 p.yoyo = function(value) { 16114 if (!arguments.length) { 16115 return this._yoyo; 16116 } 16117 this._yoyo = value; 16118 return this; 16119 }; 16120 16121 16122 return TweenMax; 16123 16124 }, true); 16125 16126var TweenMax = _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["globals"].TweenMax; 16127var TweenMaxBase = TweenMax; 16128 16129 16130 16131 16132/***/ }), 16133
vendor: 11,011 bytes, lines 16134-16307
16134/***/ "./node_modules/gsap/all.js": 16135/*!**********************************!*\ 16136 !*** ./node_modules/gsap/all.js ***! 16137 \**********************************/ 16138/*! exports provided: TweenLite, TweenMax, TimelineLite, TimelineMax, _gsScope, AttrPlugin, BezierPlugin, ColorPropsPlugin, CSSPlugin, CSSRulePlugin, DirectionalRotationPlugin, EaselPlugin, EndArrayPlugin, ModifiersPlugin, PixiPlugin, RoundPropsPlugin, ScrollToPlugin, TextPlugin, Draggable, Ease, Power0, Power1, Power2, Power3, Power4, Linear, Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase */ 16139/***/ (function(module, __webpack_exports__, __webpack_require__) { 16140 16141"use strict"; 16142__webpack_require__.r(__webpack_exports__); 16143/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 16144/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenLite", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]; }); 16145 16146/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "_gsScope", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]; }); 16147 16148/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Ease", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]; }); 16149 16150/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power0"]; }); 16151 16152/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power1"]; }); 16153 16154/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power2"]; }); 16155 16156/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power3"]; }); 16157 16158/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power4"]; }); 16159 16160/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Linear"]; }); 16161 16162/* harmony import */ var _TweenMaxBase_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TweenMaxBase.js */ "./node_modules/gsap/TweenMaxBase.js"); 16163/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenMax", function() { return _TweenMaxBase_js__WEBPACK_IMPORTED_MODULE_1__["default"]; }); 16164 16165/* harmony import */ var _TimelineLite_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./TimelineLite.js */ "./node_modules/gsap/TimelineLite.js"); 16166/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineLite", function() { return _TimelineLite_js__WEBPACK_IMPORTED_MODULE_2__["default"]; }); 16167 16168/* harmony import */ var _TimelineMax_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./TimelineMax.js */ "./node_modules/gsap/TimelineMax.js"); 16169/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineMax", function() { return _TimelineMax_js__WEBPACK_IMPORTED_MODULE_3__["default"]; }); 16170 16171/* harmony import */ var _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./AttrPlugin.js */ "./node_modules/gsap/AttrPlugin.js"); 16172/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "AttrPlugin", function() { return _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_4__["default"]; }); 16173 16174/* harmony import */ var _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./BezierPlugin.js */ "./node_modules/gsap/BezierPlugin.js"); 16175/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BezierPlugin", function() { return _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_5__["default"]; }); 16176 16177/* harmony import */ var _ColorPropsPlugin_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ColorPropsPlugin.js */ "./node_modules/gsap/ColorPropsPlugin.js"); 16178/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ColorPropsPlugin", function() { return _ColorPropsPlugin_js__WEBPACK_IMPORTED_MODULE_6__["default"]; }); 16179 16180/* harmony import */ var _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./CSSPlugin.js */ "./node_modules/gsap/CSSPlugin.js"); 16181/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CSSPlugin", function() { return _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_7__["default"]; }); 16182 16183/* harmony import */ var _CSSRulePlugin_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./CSSRulePlugin.js */ "./node_modules/gsap/CSSRulePlugin.js"); 16184/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CSSRulePlugin", function() { return _CSSRulePlugin_js__WEBPACK_IMPORTED_MODULE_8__["default"]; }); 16185 16186/* harmony import */ var _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./DirectionalRotationPlugin.js */ "./node_modules/gsap/DirectionalRotationPlugin.js"); 16187/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DirectionalRotationPlugin", function() { return _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_9__["default"]; }); 16188 16189/* harmony import */ var _EaselPlugin_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./EaselPlugin.js */ "./node_modules/gsap/EaselPlugin.js"); 16190/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "EaselPlugin", function() { return _EaselPlugin_js__WEBPACK_IMPORTED_MODULE_10__["default"]; }); 16191 16192/* harmony import */ var _EndArrayPlugin_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./EndArrayPlugin.js */ "./node_modules/gsap/EndArrayPlugin.js"); 16193/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "EndArrayPlugin", function() { return _EndArrayPlugin_js__WEBPACK_IMPORTED_MODULE_11__["default"]; }); 16194 16195/* harmony import */ var _ModifiersPlugin_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./ModifiersPlugin.js */ "./node_modules/gsap/ModifiersPlugin.js"); 16196/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ModifiersPlugin", function() { return _ModifiersPlugin_js__WEBPACK_IMPORTED_MODULE_12__["default"]; }); 16197 16198/* harmony import */ var _PixiPlugin_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./PixiPlugin.js */ "./node_modules/gsap/PixiPlugin.js"); 16199/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "PixiPlugin", function() { return _PixiPlugin_js__WEBPACK_IMPORTED_MODULE_13__["default"]; }); 16200 16201/* harmony import */ var _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./RoundPropsPlugin.js */ "./node_modules/gsap/RoundPropsPlugin.js"); 16202/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RoundPropsPlugin", function() { return _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_14__["default"]; }); 16203 16204/* harmony import */ var _ScrollToPlugin_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./ScrollToPlugin.js */ "./node_modules/gsap/ScrollToPlugin.js"); 16205/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ScrollToPlugin", function() { return _ScrollToPlugin_js__WEBPACK_IMPORTED_MODULE_15__["default"]; }); 16206 16207/* harmony import */ var _TextPlugin_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./TextPlugin.js */ "./node_modules/gsap/TextPlugin.js"); 16208/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TextPlugin", function() { return _TextPlugin_js__WEBPACK_IMPORTED_MODULE_16__["default"]; }); 16209 16210/* harmony import */ var _Draggable_js__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./Draggable.js */ "./node_modules/gsap/Draggable.js"); 16211/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Draggable", function() { return _Draggable_js__WEBPACK_IMPORTED_MODULE_17__["default"]; }); 16212 16213/* harmony import */ var _EasePack_js__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./EasePack.js */ "./node_modules/gsap/EasePack.js"); 16214/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Back", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["Back"]; }); 16215 16216/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Elastic", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["Elastic"]; }); 16217 16218/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Bounce", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["Bounce"]; }); 16219 16220/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RoughEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["RoughEase"]; }); 16221 16222/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SlowMo", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["SlowMo"]; }); 16223 16224/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SteppedEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["SteppedEase"]; }); 16225 16226/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Circ", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["Circ"]; }); 16227 16228/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Expo", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["Expo"]; }); 16229 16230/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Sine", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["Sine"]; }); 16231 16232/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ExpoScaleEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_18__["ExpoScaleEase"]; }); 16233 16234/*! 16235 * VERSION: 2.1.2 16236 * DATE: 2019-03-01 16237 * UPDATES AND DOCS AT: http://greensock.com 16238 * 16239 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 16240 * This work is subject to the terms at http://greensock.com/standard-license or for 16241 * Club GreenSock members, the software agreement that was issued with your membership. 16242 * 16243 * @author: Jack Doyle, [email protected] 16244 **/ 16245 16246 16247 16248 16249 16250 16251// plugins 16252 16253 16254 16255 16256 16257 16258 16259 16260 16261 16262 16263 16264 16265 16266 16267// utils 16268 16269 16270// easing 16271 16272 16273// bonus tools 16274/* 16275import DrawSVGPlugin from "./DrawSVGPlugin.js"; 16276import MorphSVGPlugin from "./MorphSVGPlugin.js"; 16277import Physics2DPlugin from "./Physics2DPlugin.js"; 16278import PhysicsPropsPlugin from "./PhysicsPropsPlugin.js"; 16279import ScrambleTextPlugin from "./ScrambleTextPlugin.js"; 16280import ThrowPropsPlugin from "./ThrowPropsPlugin.js"; 16281import GSDevTools from "./GSDevTools.js"; 16282import SplitText from "./SplitText.js"; 16283import CustomBounce from "./CustomBounce.js"; 16284import CustomEase from "./CustomEase.js"; 16285import CustomWiggle from "./CustomWiggle.js"; 16286 16287export { 16288 DrawSVGPlugin, 16289 MorphSVGPlugin, 16290 Physics2DPlugin, 16291 PhysicsPropsPlugin, 16292 ScrambleTextPlugin, 16293 ThrowPropsPlugin, 16294 GSDevTools, 16295 SplitText, 16296 CustomBounce, 16297 CustomEase, 16298 CustomWiggle 16299} 16300*/ 16301 16302 16303 16304 16305 16306/***/ }), 16307
vendor: 7,421 bytes, lines 16308-16413
16308/***/ "./node_modules/gsap/index.js": 16309/*!************************************!*\ 16310 !*** ./node_modules/gsap/index.js ***! 16311 \************************************/ 16312/*! exports provided: default, TweenLite, TweenMax, TimelineLite, TimelineMax, CSSPlugin, AttrPlugin, BezierPlugin, RoundPropsPlugin, DirectionalRotationPlugin, TweenPlugin, Ease, Power0, Power1, Power2, Power3, Power4, Linear, Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase, _gsScope */ 16313/***/ (function(module, __webpack_exports__, __webpack_require__) { 16314 16315"use strict"; 16316__webpack_require__.r(__webpack_exports__); 16317/* harmony import */ var _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TweenLite.js */ "./node_modules/gsap/TweenLite.js"); 16318/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenLite", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["default"]; }); 16319 16320/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenPlugin", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["TweenPlugin"]; }); 16321 16322/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Ease", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Ease"]; }); 16323 16324/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power0", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power0"]; }); 16325 16326/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power1", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power1"]; }); 16327 16328/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power2", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power2"]; }); 16329 16330/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power3", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power3"]; }); 16331 16332/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Power4", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Power4"]; }); 16333 16334/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["Linear"]; }); 16335 16336/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "_gsScope", function() { return _TweenLite_js__WEBPACK_IMPORTED_MODULE_0__["_gsScope"]; }); 16337 16338/* harmony import */ var _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TimelineLite.js */ "./node_modules/gsap/TimelineLite.js"); 16339/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineLite", function() { return _TimelineLite_js__WEBPACK_IMPORTED_MODULE_1__["default"]; }); 16340 16341/* harmony import */ var _TimelineMax_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./TimelineMax.js */ "./node_modules/gsap/TimelineMax.js"); 16342/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimelineMax", function() { return _TimelineMax_js__WEBPACK_IMPORTED_MODULE_2__["default"]; }); 16343 16344/* harmony import */ var _TweenMax_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./TweenMax.js */ "./node_modules/gsap/TweenMax.js"); 16345/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "default", function() { return _TweenMax_js__WEBPACK_IMPORTED_MODULE_3__["default"]; }); 16346 16347/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TweenMax", function() { return _TweenMax_js__WEBPACK_IMPORTED_MODULE_3__["default"]; }); 16348 16349/* harmony import */ var _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./CSSPlugin.js */ "./node_modules/gsap/CSSPlugin.js"); 16350/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CSSPlugin", function() { return _CSSPlugin_js__WEBPACK_IMPORTED_MODULE_4__["default"]; }); 16351 16352/* harmony import */ var _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./AttrPlugin.js */ "./node_modules/gsap/AttrPlugin.js"); 16353/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "AttrPlugin", function() { return _AttrPlugin_js__WEBPACK_IMPORTED_MODULE_5__["default"]; }); 16354 16355/* harmony import */ var _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./RoundPropsPlugin.js */ "./node_modules/gsap/RoundPropsPlugin.js"); 16356/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RoundPropsPlugin", function() { return _RoundPropsPlugin_js__WEBPACK_IMPORTED_MODULE_6__["default"]; }); 16357 16358/* harmony import */ var _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./DirectionalRotationPlugin.js */ "./node_modules/gsap/DirectionalRotationPlugin.js"); 16359/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DirectionalRotationPlugin", function() { return _DirectionalRotationPlugin_js__WEBPACK_IMPORTED_MODULE_7__["default"]; }); 16360 16361/* harmony import */ var _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./BezierPlugin.js */ "./node_modules/gsap/BezierPlugin.js"); 16362/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BezierPlugin", function() { return _BezierPlugin_js__WEBPACK_IMPORTED_MODULE_8__["default"]; }); 16363 16364/* harmony import */ var _EasePack_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./EasePack.js */ "./node_modules/gsap/EasePack.js"); 16365/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Back", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Back"]; }); 16366 16367/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Elastic", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Elastic"]; }); 16368 16369/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Bounce", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Bounce"]; }); 16370 16371/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RoughEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["RoughEase"]; }); 16372 16373/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SlowMo", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["SlowMo"]; }); 16374 16375/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "SteppedEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["SteppedEase"]; }); 16376 16377/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Circ", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Circ"]; }); 16378 16379/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Expo", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Expo"]; }); 16380 16381/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Sine", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["Sine"]; }); 16382 16383/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ExpoScaleEase", function() { return _EasePack_js__WEBPACK_IMPORTED_MODULE_9__["ExpoScaleEase"]; }); 16384 16385/*! 16386 * VERSION: 2.1.2 16387 * DATE: 2019-03-01 16388 * UPDATES AND DOCS AT: http://greensock.com 16389 * 16390 * @license Copyright (c) 2008-2019, GreenSock. All rights reserved. 16391 * This work is subject to the terms at http://greensock.com/standard-license or for 16392 * Club GreenSock members, the software agreement that was issued with your membership. 16393 * 16394 * @author: Jack Doyle, [email protected] 16395 **/ 16396 16397 16398 16399 16400 16401 16402 16403 16404 16405 16406 16407 16408 16409 16410 16411 16412/***/ }), 16413
vendor: 10,328 bytes, lines 16414-16790
16414/***/ "./node_modules/imagesloaded/imagesloaded.js": 16415/*!***************************************************!*\ 16416 !*** ./node_modules/imagesloaded/imagesloaded.js ***! 16417 \***************************************************/ 16418/*! no static exports found */ 16419/***/ (function(module, exports, __webpack_require__) { 16420 16421var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 16422 * imagesLoaded v4.1.4 16423 * JavaScript is all like "You images are done yet or what?" 16424 * MIT License 16425 */ 16426 16427( function( window, factory ) { 'use strict'; 16428 // universal module definition 16429 16430 /*global define: false, module: false, require: false */ 16431 16432 if ( true ) { 16433 // AMD 16434 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 16435 __webpack_require__(/*! ev-emitter/ev-emitter */ "./node_modules/ev-emitter/ev-emitter.js") 16436 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( EvEmitter ) { 16437 return factory( window, EvEmitter ); 16438 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 16439 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 16440 } else {} 16441 16442})( typeof window !== 'undefined' ? window : this, 16443 16444// -------------------------- factory -------------------------- // 16445 16446function factory( window, EvEmitter ) { 16447 16448'use strict'; 16449 16450var $ = window.jQuery; 16451var console = window.console; 16452 16453// -------------------------- helpers -------------------------- // 16454 16455// extend objects 16456function extend( a, b ) { 16457 for ( var prop in b ) { 16458 a[ prop ] = b[ prop ]; 16459 } 16460 return a; 16461} 16462 16463var arraySlice = Array.prototype.slice; 16464 16465// turn element or nodeList into an array 16466function makeArray( obj ) { 16467 if ( Array.isArray( obj ) ) { 16468 // use object if already an array 16469 return obj; 16470 } 16471 16472 var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number'; 16473 if ( isArrayLike ) { 16474 // convert nodeList to array 16475 return arraySlice.call( obj ); 16476 } 16477 16478 // array of single index 16479 return [ obj ]; 16480} 16481 16482// -------------------------- imagesLoaded -------------------------- // 16483 16484/** 16485 * @param {Array, Element, NodeList, String} elem 16486 * @param {Object or Function} options - if function, use as callback 16487 * @param {Function} onAlways - callback function 16488 */ 16489function ImagesLoaded( elem, options, onAlways ) { 16490 // coerce ImagesLoaded() without new, to be new ImagesLoaded() 16491 if ( !( this instanceof ImagesLoaded ) ) { 16492 return new ImagesLoaded( elem, options, onAlways ); 16493 } 16494 // use elem as selector string 16495 var queryElem = elem; 16496 if ( typeof elem == 'string' ) { 16497 queryElem = document.querySelectorAll( elem ); 16498 } 16499 // bail if bad element 16500 if ( !queryElem ) { 16501 console.error( 'Bad element for imagesLoaded ' + ( queryElem || elem ) ); 16502 return; 16503 } 16504 16505 this.elements = makeArray( queryElem ); 16506 this.options = extend( {}, this.options ); 16507 // shift arguments if no options set 16508 if ( typeof options == 'function' ) { 16509 onAlways = options; 16510 } else { 16511 extend( this.options, options ); 16512 } 16513 16514 if ( onAlways ) { 16515 this.on( 'always', onAlways ); 16516 } 16517 16518 this.getImages(); 16519 16520 if ( $ ) { 16521 // add jQuery Deferred object 16522 this.jqDeferred = new $.Deferred(); 16523 } 16524 16525 // HACK check async to allow time to bind listeners 16526 setTimeout( this.check.bind( this ) ); 16527} 16528 16529ImagesLoaded.prototype = Object.create( EvEmitter.prototype ); 16530 16531ImagesLoaded.prototype.options = {}; 16532 16533ImagesLoaded.prototype.getImages = function() { 16534 this.images = []; 16535 16536 // filter & find items if we have an item selector 16537 this.elements.forEach( this.addElementImages, this ); 16538}; 16539 16540/** 16541 * @param {Node} element 16542 */ 16543ImagesLoaded.prototype.addElementImages = function( elem ) { 16544 // filter siblings 16545 if ( elem.nodeName == 'IMG' ) { 16546 this.addImage( elem ); 16547 } 16548 // get background image on element 16549 if ( this.options.background === true ) { 16550 this.addElementBackgroundImages( elem ); 16551 } 16552 16553 // find children 16554 // no non-element nodes, #143 16555 var nodeType = elem.nodeType; 16556 if ( !nodeType || !elementNodeTypes[ nodeType ] ) { 16557 return; 16558 } 16559 var childImgs = elem.querySelectorAll('img'); 16560 // concat childElems to filterFound array 16561 for ( var i=0; i < childImgs.length; i++ ) { 16562 var img = childImgs[i]; 16563 this.addImage( img ); 16564 } 16565 16566 // get child background images 16567 if ( typeof this.options.background == 'string' ) { 16568 var children = elem.querySelectorAll( this.options.background ); 16569 for ( i=0; i < children.length; i++ ) { 16570 var child = children[i]; 16571 this.addElementBackgroundImages( child ); 16572 } 16573 } 16574}; 16575 16576var elementNodeTypes = { 16577 1: true, 16578 9: true, 16579 11: true 16580}; 16581 16582ImagesLoaded.prototype.addElementBackgroundImages = function( elem ) { 16583 var style = getComputedStyle( elem ); 16584 if ( !style ) { 16585 // Firefox returns null if in a hidden iframe https://bugzil.la/548397 16586 return; 16587 } 16588 // get url inside url("...") 16589 var reURL = /url\((['"])?(.*?)\1\)/gi; 16590 var matches = reURL.exec( style.backgroundImage ); 16591 while ( matches !== null ) { 16592 var url = matches && matches[2]; 16593 if ( url ) { 16594 this.addBackground( url, elem ); 16595 } 16596 matches = reURL.exec( style.backgroundImage ); 16597 } 16598}; 16599 16600/** 16601 * @param {Image} img 16602 */ 16603ImagesLoaded.prototype.addImage = function( img ) { 16604 var loadingImage = new LoadingImage( img ); 16605 this.images.push( loadingImage ); 16606}; 16607 16608ImagesLoaded.prototype.addBackground = function( url, elem ) { 16609 var background = new Background( url, elem ); 16610 this.images.push( background ); 16611}; 16612 16613ImagesLoaded.prototype.check = function() { 16614 var _this = this; 16615 this.progressedCount = 0; 16616 this.hasAnyBroken = false; 16617 // complete if no images 16618 if ( !this.images.length ) { 16619 this.complete(); 16620 return; 16621 } 16622 16623 function onProgress( image, elem, message ) { 16624 // HACK - Chrome triggers event before object properties have changed. #83 16625 setTimeout( function() { 16626 _this.progress( image, elem, message ); 16627 }); 16628 } 16629 16630 this.images.forEach( function( loadingImage ) { 16631 loadingImage.once( 'progress', onProgress ); 16632 loadingImage.check(); 16633 }); 16634}; 16635 16636ImagesLoaded.prototype.progress = function( image, elem, message ) { 16637 this.progressedCount++; 16638 this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded; 16639 // progress event 16640 this.emitEvent( 'progress', [ this, image, elem ] ); 16641 if ( this.jqDeferred && this.jqDeferred.notify ) { 16642 this.jqDeferred.notify( this, image ); 16643 } 16644 // check if completed 16645 if ( this.progressedCount == this.images.length ) { 16646 this.complete(); 16647 } 16648 16649 if ( this.options.debug && console ) { 16650 console.log( 'progress: ' + message, image, elem ); 16651 } 16652}; 16653 16654ImagesLoaded.prototype.complete = function() { 16655 var eventName = this.hasAnyBroken ? 'fail' : 'done'; 16656 this.isComplete = true; 16657 this.emitEvent( eventName, [ this ] ); 16658 this.emitEvent( 'always', [ this ] ); 16659 if ( this.jqDeferred ) { 16660 var jqMethod = this.hasAnyBroken ? 'reject' : 'resolve'; 16661 this.jqDeferred[ jqMethod ]( this ); 16662 } 16663}; 16664 16665// -------------------------- -------------------------- // 16666 16667function LoadingImage( img ) { 16668 this.img = img; 16669} 16670 16671LoadingImage.prototype = Object.create( EvEmitter.prototype ); 16672 16673LoadingImage.prototype.check = function() { 16674 // If complete is true and browser supports natural sizes, 16675 // try to check for image status manually. 16676 var isComplete = this.getIsImageComplete(); 16677 if ( isComplete ) { 16678 // report based on naturalWidth 16679 this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' ); 16680 return; 16681 } 16682 16683 // If none of the checks above matched, simulate loading on detached element. 16684 this.proxyImage = new Image(); 16685 this.proxyImage.addEventListener( 'load', this ); 16686 this.proxyImage.addEventListener( 'error', this ); 16687 // bind to image as well for Firefox. #191 16688 this.img.addEventListener( 'load', this ); 16689 this.img.addEventListener( 'error', this ); 16690 this.proxyImage.src = this.img.src; 16691}; 16692 16693LoadingImage.prototype.getIsImageComplete = function() { 16694 // check for non-zero, non-undefined naturalWidth 16695 // fixes Safari+InfiniteScroll+Masonry bug infinite-scroll#671 16696 return this.img.complete && this.img.naturalWidth; 16697}; 16698 16699LoadingImage.prototype.confirm = function( isLoaded, message ) { 16700 this.isLoaded = isLoaded; 16701 this.emitEvent( 'progress', [ this, this.img, message ] ); 16702}; 16703 16704// ----- events ----- // 16705 16706// trigger specified handler for event type 16707LoadingImage.prototype.handleEvent = function( event ) { 16708 var method = 'on' + event.type; 16709 if ( this[ method ] ) { 16710 this[ method ]( event ); 16711 } 16712}; 16713 16714LoadingImage.prototype.onload = function() { 16715 this.confirm( true, 'onload' ); 16716 this.unbindEvents(); 16717}; 16718 16719LoadingImage.prototype.onerror = function() { 16720 this.confirm( false, 'onerror' ); 16721 this.unbindEvents(); 16722}; 16723 16724LoadingImage.prototype.unbindEvents = function() { 16725 this.proxyImage.removeEventListener( 'load', this ); 16726 this.proxyImage.removeEventListener( 'error', this ); 16727 this.img.removeEventListener( 'load', this ); 16728 this.img.removeEventListener( 'error', this ); 16729}; 16730 16731// -------------------------- Background -------------------------- // 16732 16733function Background( url, element ) { 16734 this.url = url; 16735 this.element = element; 16736 this.img = new Image(); 16737} 16738 16739// inherit LoadingImage prototype 16740Background.prototype = Object.create( LoadingImage.prototype ); 16741 16742Background.prototype.check = function() { 16743 this.img.addEventListener( 'load', this ); 16744 this.img.addEventListener( 'error', this ); 16745 this.img.src = this.url; 16746 // check if image is already complete 16747 var isComplete = this.getIsImageComplete(); 16748 if ( isComplete ) { 16749 this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' ); 16750 this.unbindEvents(); 16751 } 16752}; 16753 16754Background.prototype.unbindEvents = function() { 16755 this.img.removeEventListener( 'load', this ); 16756 this.img.removeEventListener( 'error', this ); 16757}; 16758 16759Background.prototype.confirm = function( isLoaded, message ) { 16760 this.isLoaded = isLoaded; 16761 this.emitEvent( 'progress', [ this, this.element, message ] ); 16762}; 16763 16764// -------------------------- jQuery -------------------------- // 16765 16766ImagesLoaded.makeJQueryPlugin = function( jQuery ) { 16767 jQuery = jQuery || window.jQuery; 16768 if ( !jQuery ) { 16769 return; 16770 } 16771 // set local variable 16772 $ = jQuery; 16773 // $().imagesLoaded() 16774 $.fn.imagesLoaded = function( options, callback ) { 16775 var instance = new ImagesLoaded( this, options, callback ); 16776 return instance.jqDeferred.promise( $(this) ); 16777 }; 16778}; 16779// try making plugin 16780ImagesLoaded.makeJQueryPlugin(); 16781 16782// -------------------------- -------------------------- // 16783 16784return ImagesLoaded; 16785 16786}); 16787 16788 16789/***/ }), 16790
vendor: 11,282 bytes, lines 16791-17179
16791/***/ "./node_modules/lodash.debounce/index.js": 16792/*!***********************************************!*\ 16793 !*** ./node_modules/lodash.debounce/index.js ***! 16794 \***********************************************/ 16795/*! no static exports found */ 16796/***/ (function(module, exports, __webpack_require__) { 16797 16798/* WEBPACK VAR INJECTION */(function(global) {/** 16799 * lodash (Custom Build) <https://lodash.com/> 16800 * Build: `lodash modularize exports="npm" -o ./` 16801 * Copyright jQuery Foundation and other contributors <https://jquery.org/> 16802 * Released under MIT license <https://lodash.com/license> 16803 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> 16804 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors 16805 */ 16806 16807/** Used as the `TypeError` message for "Functions" methods. */ 16808var FUNC_ERROR_TEXT = 'Expected a function'; 16809 16810/** Used as references for various `Number` constants. */ 16811var NAN = 0 / 0; 16812 16813/** `Object#toString` result references. */ 16814var symbolTag = '[object Symbol]'; 16815 16816/** Used to match leading and trailing whitespace. */ 16817var reTrim = /^\s+|\s+$/g; 16818 16819/** Used to detect bad signed hexadecimal string values. */ 16820var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; 16821 16822/** Used to detect binary string values. */ 16823var reIsBinary = /^0b[01]+$/i; 16824 16825/** Used to detect octal string values. */ 16826var reIsOctal = /^0o[0-7]+$/i; 16827 16828/** Built-in method references without a dependency on `root`. */ 16829var freeParseInt = parseInt; 16830 16831/** Detect free variable `global` from Node.js. */ 16832var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; 16833 16834/** Detect free variable `self`. */ 16835var freeSelf = typeof self == 'object' && self && self.Object === Object && self; 16836 16837/** Used as a reference to the global object. */ 16838var root = freeGlobal || freeSelf || Function('return this')(); 16839 16840/** Used for built-in method references. */ 16841var objectProto = Object.prototype; 16842 16843/** 16844 * Used to resolve the 16845 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) 16846 * of values. 16847 */ 16848var objectToString = objectProto.toString; 16849 16850/* Built-in method references for those with the same name as other `lodash` methods. */ 16851var nativeMax = Math.max, 16852 nativeMin = Math.min; 16853 16854/** 16855 * Gets the timestamp of the number of milliseconds that have elapsed since 16856 * the Unix epoch (1 January 1970 00:00:00 UTC). 16857 * 16858 * @static 16859 * @memberOf _ 16860 * @since 2.4.0 16861 * @category Date 16862 * @returns {number} Returns the timestamp. 16863 * @example 16864 * 16865 * _.defer(function(stamp) { 16866 * console.log(_.now() - stamp); 16867 * }, _.now()); 16868 * // => Logs the number of milliseconds it took for the deferred invocation. 16869 */ 16870var now = function() { 16871 return root.Date.now(); 16872}; 16873 16874/** 16875 * Creates a debounced function that delays invoking `func` until after `wait` 16876 * milliseconds have elapsed since the last time the debounced function was 16877 * invoked. The debounced function comes with a `cancel` method to cancel 16878 * delayed `func` invocations and a `flush` method to immediately invoke them. 16879 * Provide `options` to indicate whether `func` should be invoked on the 16880 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked 16881 * with the last arguments provided to the debounced function. Subsequent 16882 * calls to the debounced function return the result of the last `func` 16883 * invocation. 16884 * 16885 * **Note:** If `leading` and `trailing` options are `true`, `func` is 16886 * invoked on the trailing edge of the timeout only if the debounced function 16887 * is invoked more than once during the `wait` timeout. 16888 * 16889 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred 16890 * until to the next tick, similar to `setTimeout` with a timeout of `0`. 16891 * 16892 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) 16893 * for details over the differences between `_.debounce` and `_.throttle`. 16894 * 16895 * @static 16896 * @memberOf _ 16897 * @since 0.1.0 16898 * @category Function 16899 * @param {Function} func The function to debounce. 16900 * @param {number} [wait=0] The number of milliseconds to delay. 16901 * @param {Object} [options={}] The options object. 16902 * @param {boolean} [options.leading=false] 16903 * Specify invoking on the leading edge of the timeout. 16904 * @param {number} [options.maxWait] 16905 * The maximum time `func` is allowed to be delayed before it's invoked. 16906 * @param {boolean} [options.trailing=true] 16907 * Specify invoking on the trailing edge of the timeout. 16908 * @returns {Function} Returns the new debounced function. 16909 * @example 16910 * 16911 * // Avoid costly calculations while the window size is in flux. 16912 * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); 16913 * 16914 * // Invoke `sendMail` when clicked, debouncing subsequent calls. 16915 * jQuery(element).on('click', _.debounce(sendMail, 300, { 16916 * 'leading': true, 16917 * 'trailing': false 16918 * })); 16919 * 16920 * // Ensure `batchLog` is invoked once after 1 second of debounced calls. 16921 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); 16922 * var source = new EventSource('/stream'); 16923 * jQuery(source).on('message', debounced); 16924 * 16925 * // Cancel the trailing debounced invocation. 16926 * jQuery(window).on('popstate', debounced.cancel); 16927 */ 16928function debounce(func, wait, options) { 16929 var lastArgs, 16930 lastThis, 16931 maxWait, 16932 result, 16933 timerId, 16934 lastCallTime, 16935 lastInvokeTime = 0, 16936 leading = false, 16937 maxing = false, 16938 trailing = true; 16939 16940 if (typeof func != 'function') { 16941 throw new TypeError(FUNC_ERROR_TEXT); 16942 } 16943 wait = toNumber(wait) || 0; 16944 if (isObject(options)) { 16945 leading = !!options.leading; 16946 maxing = 'maxWait' in options; 16947 maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; 16948 trailing = 'trailing' in options ? !!options.trailing : trailing; 16949 } 16950 16951 function invokeFunc(time) { 16952 var args = lastArgs, 16953 thisArg = lastThis; 16954 16955 lastArgs = lastThis = undefined; 16956 lastInvokeTime = time; 16957 result = func.apply(thisArg, args); 16958 return result; 16959 } 16960 16961 function leadingEdge(time) { 16962 // Reset any `maxWait` timer. 16963 lastInvokeTime = time; 16964 // Start the timer for the trailing edge. 16965 timerId = setTimeout(timerExpired, wait); 16966 // Invoke the leading edge. 16967 return leading ? invokeFunc(time) : result; 16968 } 16969 16970 function remainingWait(time) { 16971 var timeSinceLastCall = time - lastCallTime, 16972 timeSinceLastInvoke = time - lastInvokeTime, 16973 result = wait - timeSinceLastCall; 16974 16975 return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; 16976 } 16977 16978 function shouldInvoke(time) { 16979 var timeSinceLastCall = time - lastCallTime, 16980 timeSinceLastInvoke = time - lastInvokeTime; 16981 16982 // Either this is the first call, activity has stopped and we're at the 16983 // trailing edge, the system time has gone backwards and we're treating 16984 // it as the trailing edge, or we've hit the `maxWait` limit. 16985 return (lastCallTime === undefined || (timeSinceLastCall >= wait) || 16986 (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); 16987 } 16988 16989 function timerExpired() { 16990 var time = now(); 16991 if (shouldInvoke(time)) { 16992 return trailingEdge(time); 16993 } 16994 // Restart the timer. 16995 timerId = setTimeout(timerExpired, remainingWait(time)); 16996 } 16997 16998 function trailingEdge(time) { 16999 timerId = undefined; 17000 17001 // Only invoke if we have `lastArgs` which means `func` has been 17002 // debounced at least once. 17003 if (trailing && lastArgs) { 17004 return invokeFunc(time); 17005 } 17006 lastArgs = lastThis = undefined; 17007 return result; 17008 } 17009 17010 function cancel() { 17011 if (timerId !== undefined) { 17012 clearTimeout(timerId); 17013 } 17014 lastInvokeTime = 0; 17015 lastArgs = lastCallTime = lastThis = timerId = undefined; 17016 } 17017 17018 function flush() { 17019 return timerId === undefined ? result : trailingEdge(now()); 17020 } 17021 17022 function debounced() { 17023 var time = now(), 17024 isInvoking = shouldInvoke(time); 17025 17026 lastArgs = arguments; 17027 lastThis = this; 17028 lastCallTime = time; 17029 17030 if (isInvoking) { 17031 if (timerId === undefined) { 17032 return leadingEdge(lastCallTime); 17033 } 17034 if (maxing) { 17035 // Handle invocations in a tight loop. 17036 timerId = setTimeout(timerExpired, wait); 17037 return invokeFunc(lastCallTime); 17038 } 17039 } 17040 if (timerId === undefined) { 17041 timerId = setTimeout(timerExpired, wait); 17042 } 17043 return result; 17044 } 17045 debounced.cancel = cancel; 17046 debounced.flush = flush; 17047 return debounced; 17048} 17049 17050/** 17051 * Checks if `value` is the 17052 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) 17053 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) 17054 * 17055 * @static 17056 * @memberOf _ 17057 * @since 0.1.0 17058 * @category Lang 17059 * @param {*} value The value to check. 17060 * @returns {boolean} Returns `true` if `value` is an object, else `false`. 17061 * @example 17062 * 17063 * _.isObject({}); 17064 * // => true 17065 * 17066 * _.isObject([1, 2, 3]); 17067 * // => true 17068 * 17069 * _.isObject(_.noop); 17070 * // => true 17071 * 17072 * _.isObject(null); 17073 * // => false 17074 */ 17075function isObject(value) { 17076 var type = typeof value; 17077 return !!value && (type == 'object' || type == 'function'); 17078} 17079 17080/** 17081 * Checks if `value` is object-like. A value is object-like if it's not `null` 17082 * and has a `typeof` result of "object". 17083 * 17084 * @static 17085 * @memberOf _ 17086 * @since 4.0.0 17087 * @category Lang 17088 * @param {*} value The value to check. 17089 * @returns {boolean} Returns `true` if `value` is object-like, else `false`. 17090 * @example 17091 * 17092 * _.isObjectLike({}); 17093 * // => true 17094 * 17095 * _.isObjectLike([1, 2, 3]); 17096 * // => true 17097 * 17098 * _.isObjectLike(_.noop); 17099 * // => false 17100 * 17101 * _.isObjectLike(null); 17102 * // => false 17103 */ 17104function isObjectLike(value) { 17105 return !!value && typeof value == 'object'; 17106} 17107 17108/** 17109 * Checks if `value` is classified as a `Symbol` primitive or object. 17110 * 17111 * @static 17112 * @memberOf _ 17113 * @since 4.0.0 17114 * @category Lang 17115 * @param {*} value The value to check. 17116 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. 17117 * @example 17118 * 17119 * _.isSymbol(Symbol.iterator); 17120 * // => true 17121 * 17122 * _.isSymbol('abc'); 17123 * // => false 17124 */ 17125function isSymbol(value) { 17126 return typeof value == 'symbol' || 17127 (isObjectLike(value) && objectToString.call(value) == symbolTag); 17128} 17129 17130/** 17131 * Converts `value` to a number. 17132 * 17133 * @static 17134 * @memberOf _ 17135 * @since 4.0.0 17136 * @category Lang 17137 * @param {*} value The value to process. 17138 * @returns {number} Returns the number. 17139 * @example 17140 * 17141 * _.toNumber(3.2); 17142 * // => 3.2 17143 * 17144 * _.toNumber(Number.MIN_VALUE); 17145 * // => 5e-324 17146 * 17147 * _.toNumber(Infinity); 17148 * // => Infinity 17149 * 17150 * _.toNumber('3.2'); 17151 * // => 3.2 17152 */ 17153function toNumber(value) { 17154 if (typeof value == 'number') { 17155 return value; 17156 } 17157 if (isSymbol(value)) { 17158 return NAN; 17159 } 17160 if (isObject(value)) { 17161 var other = typeof value.valueOf == 'function' ? value.valueOf() : value; 17162 value = isObject(other) ? (other + '') : other; 17163 } 17164 if (typeof value != 'string') { 17165 return value === 0 ? value : +value; 17166 } 17167 value = value.replace(reTrim, ''); 17168 var isBinary = reIsBinary.test(value); 17169 return (isBinary || reIsOctal.test(value)) 17170 ? freeParseInt(value.slice(2), isBinary ? 2 : 8) 17171 : (reIsBadHex.test(value) ? NAN : +value); 17172} 17173 17174module.exports = debounce; 17175 17176/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) 17177 17178/***/ }), 17179
vendor: 2,920 bytes, lines 17180-17273
17180/***/ "./node_modules/sniffer/index.js": 17181/*!***************************************!*\ 17182 !*** ./node_modules/sniffer/index.js ***! 17183 \***************************************/ 17184/*! no static exports found */ 17185/***/ (function(module, exports, __webpack_require__) { 17186 17187"use strict"; 17188 17189 17190var dashify = __webpack_require__(/*! dashify */ "./node_modules/dashify/index.js"); 17191 17192module.exports = new Sniffer(); 17193 17194function Sniffer() { 17195 var ua = navigator.userAgent.toLowerCase(); 17196 var av = navigator.appVersion.toLowerCase(); 17197 17198 var isWindowsPhone = /windows phone|iemobile|wpdesktop/.test(ua); 17199 17200 var isDroidPhone = !isWindowsPhone && /android.*mobile/.test(ua); 17201 var isDroidTablet = !isWindowsPhone && !isDroidPhone && (/android/i).test(ua); 17202 var isDroid = isDroidPhone || isDroidTablet; 17203 17204 var isIos = !isWindowsPhone && (/ip(hone|od|ad)/i).test(ua) && !window.MSStream; 17205 var isIpad = !isWindowsPhone && (/ipad/i).test(ua) && isIos; 17206 17207 var isTablet = isDroidTablet || isIpad; 17208 var isPhone = isDroidPhone || (isIos && !isIpad) || isWindowsPhone; 17209 var isDevice = isPhone || isTablet; 17210 17211 var isFirefox = ua.indexOf('firefox') > -1; 17212 var isSafari = !!ua.match(/version\/[\d\.]+.*safari/); 17213 var isOpera = ua.indexOf('opr') > -1; 17214 var isIE11 = !(window.ActiveXObject) && "ActiveXObject" in window; 17215 var isIE = av.indexOf('msie') > -1 || isIE11 || av.indexOf('edge') > -1; 17216 var isEdge = ua.indexOf('edge') > -1; 17217 var isChrome = window.chrome !== null && window.chrome !== undefined && navigator.vendor.toLowerCase() == 'google inc.' && !isOpera && !isEdge; 17218 17219 this.infos = { 17220 isDroid: isDroid, 17221 isDroidPhone: isDroidPhone, 17222 isDroidTablet: isDroidTablet, 17223 isWindowsPhone: isWindowsPhone, 17224 isIos: isIos, 17225 isIpad: isIpad, 17226 isDevice: isDevice, 17227 isEdge: isEdge, 17228 isIE: isIE, 17229 isIE11: isIE11, 17230 isPhone: isPhone, 17231 isTablet: isTablet, 17232 isFirefox: isFirefox, 17233 isSafari: isSafari, 17234 isOpera: isOpera, 17235 isChrome: isChrome, 17236 isDesktop: !isPhone && !isTablet 17237 }; 17238 17239 Object.keys(this.infos).forEach(function(info) { 17240 Object.defineProperty(this, info, { 17241 get: function () { 17242 return this.infos[info]; 17243 } 17244 }); 17245 }, this); 17246 17247 Object.freeze(this); 17248 17249 // TODO: add getVersion() to get IE/Safari/... version 17250} 17251 17252Sniffer.prototype.addClasses = function(el) { 17253 Object.keys(this.infos).forEach(function(info) { 17254 if (this.infos[info]) addClass(el, dashify(info)); 17255 }, this); 17256}; 17257 17258Sniffer.prototype.getInfos = function() { 17259 return clone(this.infos); 17260}; 17261 17262function addClass(el, className) { 17263 if (el.addClass) el.addClass(className); 17264 else if (el.classList) el.classList.add(className); 17265 else el.className += ' ' + className; 17266} 17267 17268function clone(source) { 17269 return JSON.parse(JSON.stringify(source)); 17270} 17271 17272/***/ }), 17273
vendor: 1,872 bytes, lines 17274-17351
17274/***/ "./node_modules/tiny-emitter/index.js": 17275/*!********************************************!*\ 17276 !*** ./node_modules/tiny-emitter/index.js ***! 17277 \********************************************/ 17278/*! no static exports found */ 17279/***/ (function(module, exports) { 17280 17281function E () { 17282 // Keep this empty so it's easier to inherit from 17283 // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3) 17284} 17285 17286E.prototype = { 17287 on: function (name, callback, ctx) { 17288 var e = this.e || (this.e = {}); 17289 17290 (e[name] || (e[name] = [])).push({ 17291 fn: callback, 17292 ctx: ctx 17293 }); 17294 17295 return this; 17296 }, 17297 17298 once: function (name, callback, ctx) { 17299 var self = this; 17300 function listener () { 17301 self.off(name, listener); 17302 callback.apply(ctx, arguments); 17303 }; 17304 17305 listener._ = callback 17306 return this.on(name, listener, ctx); 17307 }, 17308 17309 emit: function (name) { 17310 var data = [].slice.call(arguments, 1); 17311 var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); 17312 var i = 0; 17313 var len = evtArr.length; 17314 17315 for (i; i < len; i++) { 17316 evtArr[i].fn.apply(evtArr[i].ctx, data); 17317 } 17318 17319 return this; 17320 }, 17321 17322 off: function (name, callback) { 17323 var e = this.e || (this.e = {}); 17324 var evts = e[name]; 17325 var liveEvents = []; 17326 17327 if (evts && callback) { 17328 for (var i = 0, len = evts.length; i < len; i++) { 17329 if (evts[i].fn !== callback && evts[i].fn._ !== callback) 17330 liveEvents.push(evts[i]); 17331 } 17332 } 17333 17334 // Remove event from queue to prevent memory leak 17335 // Suggested by https://github.com/lazd 17336 // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910 17337 17338 (liveEvents.length) 17339 ? e[name] = liveEvents 17340 : delete e[name]; 17341 17342 return this; 17343 } 17344}; 17345 17346module.exports = E; 17347module.exports.TinyEmitter = E; 17348 17349 17350/***/ }), 17351
vendor: 7,134 bytes, lines 17352-17630
17352/***/ "./node_modules/unidragger/unidragger.js": 17353/*!***********************************************!*\ 17354 !*** ./node_modules/unidragger/unidragger.js ***! 17355 \***********************************************/ 17356/*! no static exports found */ 17357/***/ (function(module, exports, __webpack_require__) { 17358 17359var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 17360 * Unidragger v2.3.0 17361 * Draggable base class 17362 * MIT license 17363 */ 17364 17365/*jshint browser: true, unused: true, undef: true, strict: true */ 17366 17367( function( window, factory ) { 17368 // universal module definition 17369 /*jshint strict: false */ /*globals define, module, require */ 17370 17371 if ( true ) { 17372 // AMD 17373 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 17374 __webpack_require__(/*! unipointer/unipointer */ "./node_modules/unipointer/unipointer.js") 17375 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Unipointer ) { 17376 return factory( window, Unipointer ); 17377 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 17378 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 17379 } else {} 17380 17381}( window, function factory( window, Unipointer ) { 17382 17383'use strict'; 17384 17385// -------------------------- Unidragger -------------------------- // 17386 17387function Unidragger() {} 17388 17389// inherit Unipointer & EvEmitter 17390var proto = Unidragger.prototype = Object.create( Unipointer.prototype ); 17391 17392// ----- bind start ----- // 17393 17394proto.bindHandles = function() { 17395 this._bindHandles( true ); 17396}; 17397 17398proto.unbindHandles = function() { 17399 this._bindHandles( false ); 17400}; 17401 17402/** 17403 * Add or remove start event 17404 * @param {Boolean} isAdd 17405 */ 17406proto._bindHandles = function( isAdd ) { 17407 // munge isAdd, default to true 17408 isAdd = isAdd === undefined ? true : isAdd; 17409 // bind each handle 17410 var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener'; 17411 var touchAction = isAdd ? this._touchActionValue : ''; 17412 for ( var i=0; i < this.handles.length; i++ ) { 17413 var handle = this.handles[i]; 17414 this._bindStartEvent( handle, isAdd ); 17415 handle[ bindMethod ]( 'click', this ); 17416 // touch-action: none to override browser touch gestures. metafizzy/flickity#540 17417 if ( window.PointerEvent ) { 17418 handle.style.touchAction = touchAction; 17419 } 17420 } 17421}; 17422 17423// prototype so it can be overwriteable by Flickity 17424proto._touchActionValue = 'none'; 17425 17426// ----- start event ----- // 17427 17428/** 17429 * pointer start 17430 * @param {Event} event 17431 * @param {Event or Touch} pointer 17432 */ 17433proto.pointerDown = function( event, pointer ) { 17434 var isOkay = this.okayPointerDown( event ); 17435 if ( !isOkay ) { 17436 return; 17437 } 17438 // track start event position 17439 this.pointerDownPointer = pointer; 17440 17441 event.preventDefault(); 17442 this.pointerDownBlur(); 17443 // bind move and end events 17444 this._bindPostStartEvents( event ); 17445 this.emitEvent( 'pointerDown', [ event, pointer ] ); 17446}; 17447 17448// nodes that have text fields 17449var cursorNodes = { 17450 TEXTAREA: true, 17451 INPUT: true, 17452 SELECT: true, 17453 OPTION: true, 17454}; 17455 17456// input types that do not have text fields 17457var clickTypes = { 17458 radio: true, 17459 checkbox: true, 17460 button: true, 17461 submit: true, 17462 image: true, 17463 file: true, 17464}; 17465 17466// dismiss inputs with text fields. flickity#403, flickity#404 17467proto.okayPointerDown = function( event ) { 17468 var isCursorNode = cursorNodes[ event.target.nodeName ]; 17469 var isClickType = clickTypes[ event.target.type ]; 17470 var isOkay = !isCursorNode || isClickType; 17471 if ( !isOkay ) { 17472 this._pointerReset(); 17473 } 17474 return isOkay; 17475}; 17476 17477// kludge to blur previously focused input 17478proto.pointerDownBlur = function() { 17479 var focused = document.activeElement; 17480 // do not blur body for IE10, metafizzy/flickity#117 17481 var canBlur = focused && focused.blur && focused != document.body; 17482 if ( canBlur ) { 17483 focused.blur(); 17484 } 17485}; 17486 17487// ----- move event ----- // 17488 17489/** 17490 * drag move 17491 * @param {Event} event 17492 * @param {Event or Touch} pointer 17493 */ 17494proto.pointerMove = function( event, pointer ) { 17495 var moveVector = this._dragPointerMove( event, pointer ); 17496 this.emitEvent( 'pointerMove', [ event, pointer, moveVector ] ); 17497 this._dragMove( event, pointer, moveVector ); 17498}; 17499 17500// base pointer move logic 17501proto._dragPointerMove = function( event, pointer ) { 17502 var moveVector = { 17503 x: pointer.pageX - this.pointerDownPointer.pageX, 17504 y: pointer.pageY - this.pointerDownPointer.pageY 17505 }; 17506 // start drag if pointer has moved far enough to start drag 17507 if ( !this.isDragging && this.hasDragStarted( moveVector ) ) { 17508 this._dragStart( event, pointer ); 17509 } 17510 return moveVector; 17511}; 17512 17513// condition if pointer has moved far enough to start drag 17514proto.hasDragStarted = function( moveVector ) { 17515 return Math.abs( moveVector.x ) > 3 || Math.abs( moveVector.y ) > 3; 17516}; 17517 17518// ----- end event ----- // 17519 17520/** 17521 * pointer up 17522 * @param {Event} event 17523 * @param {Event or Touch} pointer 17524 */ 17525proto.pointerUp = function( event, pointer ) { 17526 this.emitEvent( 'pointerUp', [ event, pointer ] ); 17527 this._dragPointerUp( event, pointer ); 17528}; 17529 17530proto._dragPointerUp = function( event, pointer ) { 17531 if ( this.isDragging ) { 17532 this._dragEnd( event, pointer ); 17533 } else { 17534 // pointer didn't move enough for drag to start 17535 this._staticClick( event, pointer ); 17536 } 17537}; 17538 17539// -------------------------- drag -------------------------- // 17540 17541// dragStart 17542proto._dragStart = function( event, pointer ) { 17543 this.isDragging = true; 17544 // prevent clicks 17545 this.isPreventingClicks = true; 17546 this.dragStart( event, pointer ); 17547}; 17548 17549proto.dragStart = function( event, pointer ) { 17550 this.emitEvent( 'dragStart', [ event, pointer ] ); 17551}; 17552 17553// dragMove 17554proto._dragMove = function( event, pointer, moveVector ) { 17555 // do not drag if not dragging yet 17556 if ( !this.isDragging ) { 17557 return; 17558 } 17559 17560 this.dragMove( event, pointer, moveVector ); 17561}; 17562 17563proto.dragMove = function( event, pointer, moveVector ) { 17564 event.preventDefault(); 17565 this.emitEvent( 'dragMove', [ event, pointer, moveVector ] ); 17566}; 17567 17568// dragEnd 17569proto._dragEnd = function( event, pointer ) { 17570 // set flags 17571 this.isDragging = false; 17572 // re-enable clicking async 17573 setTimeout( function() { 17574 delete this.isPreventingClicks; 17575 }.bind( this ) ); 17576 17577 this.dragEnd( event, pointer ); 17578}; 17579 17580proto.dragEnd = function( event, pointer ) { 17581 this.emitEvent( 'dragEnd', [ event, pointer ] ); 17582}; 17583 17584// ----- onclick ----- // 17585 17586// handle all clicks and prevent clicks when dragging 17587proto.onclick = function( event ) { 17588 if ( this.isPreventingClicks ) { 17589 event.preventDefault(); 17590 } 17591}; 17592 17593// ----- staticClick ----- // 17594 17595// triggered after pointer down & up with no/tiny movement 17596proto._staticClick = function( event, pointer ) { 17597 // ignore emulated mouse up clicks 17598 if ( this.isIgnoringMouseUp && event.type == 'mouseup' ) { 17599 return; 17600 } 17601 17602 this.staticClick( event, pointer ); 17603 17604 // set flag for emulated clicks 300ms after touchend 17605 if ( event.type != 'mouseup' ) { 17606 this.isIgnoringMouseUp = true; 17607 // reset flag after 300ms 17608 setTimeout( function() { 17609 delete this.isIgnoringMouseUp; 17610 }.bind( this ), 400 ); 17611 } 17612}; 17613 17614proto.staticClick = function( event, pointer ) { 17615 this.emitEvent( 'staticClick', [ event, pointer ] ); 17616}; 17617 17618// ----- utils ----- // 17619 17620Unidragger.getPointerPoint = Unipointer.getPointerPoint; 17621 17622// ----- ----- // 17623 17624return Unidragger; 17625 17626})); 17627 17628 17629/***/ }), 17630
vendor: 7,295 bytes, lines 17631-17931
17631/***/ "./node_modules/unipointer/unipointer.js": 17632/*!***********************************************!*\ 17633 !*** ./node_modules/unipointer/unipointer.js ***! 17634 \***********************************************/ 17635/*! no static exports found */ 17636/***/ (function(module, exports, __webpack_require__) { 17637 17638var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 17639 * Unipointer v2.3.0 17640 * base class for doing one thing with pointer event 17641 * MIT license 17642 */ 17643 17644/*jshint browser: true, undef: true, unused: true, strict: true */ 17645 17646( function( window, factory ) { 17647 // universal module definition 17648 /* jshint strict: false */ /*global define, module, require */ 17649 if ( true ) { 17650 // AMD 17651 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ 17652 __webpack_require__(/*! ev-emitter/ev-emitter */ "./node_modules/ev-emitter/ev-emitter.js") 17653 ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( EvEmitter ) { 17654 return factory( window, EvEmitter ); 17655 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 17656 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 17657 } else {} 17658 17659}( window, function factory( window, EvEmitter ) { 17660 17661'use strict'; 17662 17663function noop() {} 17664 17665function Unipointer() {} 17666 17667// inherit EvEmitter 17668var proto = Unipointer.prototype = Object.create( EvEmitter.prototype ); 17669 17670proto.bindStartEvent = function( elem ) { 17671 this._bindStartEvent( elem, true ); 17672}; 17673 17674proto.unbindStartEvent = function( elem ) { 17675 this._bindStartEvent( elem, false ); 17676}; 17677 17678/** 17679 * Add or remove start event 17680 * @param {Boolean} isAdd - remove if falsey 17681 */ 17682proto._bindStartEvent = function( elem, isAdd ) { 17683 // munge isAdd, default to true 17684 isAdd = isAdd === undefined ? true : isAdd; 17685 var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener'; 17686 17687 // default to mouse events 17688 var startEvent = 'mousedown'; 17689 if ( window.PointerEvent ) { 17690 // Pointer Events 17691 startEvent = 'pointerdown'; 17692 } else if ( 'ontouchstart' in window ) { 17693 // Touch Events. iOS Safari 17694 startEvent = 'touchstart'; 17695 } 17696 elem[ bindMethod ]( startEvent, this ); 17697}; 17698 17699// trigger handler methods for events 17700proto.handleEvent = function( event ) { 17701 var method = 'on' + event.type; 17702 if ( this[ method ] ) { 17703 this[ method ]( event ); 17704 } 17705}; 17706 17707// returns the touch that we're keeping track of 17708proto.getTouch = function( touches ) { 17709 for ( var i=0; i < touches.length; i++ ) { 17710 var touch = touches[i]; 17711 if ( touch.identifier == this.pointerIdentifier ) { 17712 return touch; 17713 } 17714 } 17715}; 17716 17717// ----- start event ----- // 17718 17719proto.onmousedown = function( event ) { 17720 // dismiss clicks from right or middle buttons 17721 var button = event.button; 17722 if ( button && ( button !== 0 && button !== 1 ) ) { 17723 return; 17724 } 17725 this._pointerDown( event, event ); 17726}; 17727 17728proto.ontouchstart = function( event ) { 17729 this._pointerDown( event, event.changedTouches[0] ); 17730}; 17731 17732proto.onpointerdown = function( event ) { 17733 this._pointerDown( event, event ); 17734}; 17735 17736/** 17737 * pointer start 17738 * @param {Event} event 17739 * @param {Event or Touch} pointer 17740 */ 17741proto._pointerDown = function( event, pointer ) { 17742 // dismiss right click and other pointers 17743 // button = 0 is okay, 1-4 not 17744 if ( event.button || this.isPointerDown ) { 17745 return; 17746 } 17747 17748 this.isPointerDown = true; 17749 // save pointer identifier to match up touch events 17750 this.pointerIdentifier = pointer.pointerId !== undefined ? 17751 // pointerId for pointer events, touch.indentifier for touch events 17752 pointer.pointerId : pointer.identifier; 17753 17754 this.pointerDown( event, pointer ); 17755}; 17756 17757proto.pointerDown = function( event, pointer ) { 17758 this._bindPostStartEvents( event ); 17759 this.emitEvent( 'pointerDown', [ event, pointer ] ); 17760}; 17761 17762// hash of events to be bound after start event 17763var postStartEvents = { 17764 mousedown: [ 'mousemove', 'mouseup' ], 17765 touchstart: [ 'touchmove', 'touchend', 'touchcancel' ], 17766 pointerdown: [ 'pointermove', 'pointerup', 'pointercancel' ], 17767}; 17768 17769proto._bindPostStartEvents = function( event ) { 17770 if ( !event ) { 17771 return; 17772 } 17773 // get proper events to match start event 17774 var events = postStartEvents[ event.type ]; 17775 // bind events to node 17776 events.forEach( function( eventName ) { 17777 window.addEventListener( eventName, this ); 17778 }, this ); 17779 // save these arguments 17780 this._boundPointerEvents = events; 17781}; 17782 17783proto._unbindPostStartEvents = function() { 17784 // check for _boundEvents, in case dragEnd triggered twice (old IE8 bug) 17785 if ( !this._boundPointerEvents ) { 17786 return; 17787 } 17788 this._boundPointerEvents.forEach( function( eventName ) { 17789 window.removeEventListener( eventName, this ); 17790 }, this ); 17791 17792 delete this._boundPointerEvents; 17793}; 17794 17795// ----- move event ----- // 17796 17797proto.onmousemove = function( event ) { 17798 this._pointerMove( event, event ); 17799}; 17800 17801proto.onpointermove = function( event ) { 17802 if ( event.pointerId == this.pointerIdentifier ) { 17803 this._pointerMove( event, event ); 17804 } 17805}; 17806 17807proto.ontouchmove = function( event ) { 17808 var touch = this.getTouch( event.changedTouches ); 17809 if ( touch ) { 17810 this._pointerMove( event, touch ); 17811 } 17812}; 17813 17814/** 17815 * pointer move 17816 * @param {Event} event 17817 * @param {Event or Touch} pointer 17818 * @private 17819 */ 17820proto._pointerMove = function( event, pointer ) { 17821 this.pointerMove( event, pointer ); 17822}; 17823 17824// public 17825proto.pointerMove = function( event, pointer ) { 17826 this.emitEvent( 'pointerMove', [ event, pointer ] ); 17827}; 17828 17829// ----- end event ----- // 17830 17831 17832proto.onmouseup = function( event ) { 17833 this._pointerUp( event, event ); 17834}; 17835 17836proto.onpointerup = function( event ) { 17837 if ( event.pointerId == this.pointerIdentifier ) { 17838 this._pointerUp( event, event ); 17839 } 17840}; 17841 17842proto.ontouchend = function( event ) { 17843 var touch = this.getTouch( event.changedTouches ); 17844 if ( touch ) { 17845 this._pointerUp( event, touch ); 17846 } 17847}; 17848 17849/** 17850 * pointer up 17851 * @param {Event} event 17852 * @param {Event or Touch} pointer 17853 * @private 17854 */ 17855proto._pointerUp = function( event, pointer ) { 17856 this._pointerDone(); 17857 this.pointerUp( event, pointer ); 17858}; 17859 17860// public 17861proto.pointerUp = function( event, pointer ) { 17862 this.emitEvent( 'pointerUp', [ event, pointer ] ); 17863}; 17864 17865// ----- pointer done ----- // 17866 17867// triggered on pointer up & pointer cancel 17868proto._pointerDone = function() { 17869 this._pointerReset(); 17870 this._unbindPostStartEvents(); 17871 this.pointerDone(); 17872}; 17873 17874proto._pointerReset = function() { 17875 // reset properties 17876 this.isPointerDown = false; 17877 delete this.pointerIdentifier; 17878}; 17879 17880proto.pointerDone = noop; 17881 17882// ----- pointer cancel ----- // 17883 17884proto.onpointercancel = function( event ) { 17885 if ( event.pointerId == this.pointerIdentifier ) { 17886 this._pointerCancel( event, event ); 17887 } 17888}; 17889 17890proto.ontouchcancel = function( event ) { 17891 var touch = this.getTouch( event.changedTouches ); 17892 if ( touch ) { 17893 this._pointerCancel( event, touch ); 17894 } 17895}; 17896 17897/** 17898 * pointer cancel 17899 * @param {Event} event 17900 * @param {Event or Touch} pointer 17901 * @private 17902 */ 17903proto._pointerCancel = function( event, pointer ) { 17904 this._pointerDone(); 17905 this.pointerCancel( event, pointer ); 17906}; 17907 17908// public 17909proto.pointerCancel = function( event, pointer ) { 17910 this.emitEvent( 'pointerCancel', [ event, pointer ] ); 17911}; 17912 17913// ----- ----- // 17914 17915// utility function for getting x/y coords from event 17916Unipointer.getPointerPoint = function( pointer ) { 17917 return { 17918 x: pointer.pageX, 17919 y: pointer.pageY 17920 }; 17921}; 17922 17923// ----- ----- // 17924 17925return Unipointer; 17926 17927})); 17928 17929 17930/***/ }), 17931
vendor: 724 bytes, lines 17932-17962
17932/***/ "./node_modules/webpack/buildin/global.js": 17933/*!***********************************!*\ 17934 !*** (webpack)/buildin/global.js ***! 17935 \***********************************/ 17936/*! no static exports found */ 17937/***/ (function(module, exports) { 17938 17939var g; 17940 17941// This works in non-strict mode 17942g = (function() { 17943 return this; 17944})(); 17945 17946try { 17947 // This works if eval is allowed (see CSP) 17948 g = g || new Function("return this")(); 17949} catch (e) { 17950 // This works if the window reference is available 17951 if (typeof window === "object") g = window; 17952} 17953 17954// g can still be undefined, but nothing to do about it... 17955// We return undefined, instead of nothing here, so it's 17956// easier to handle this case. if(!global) { ...} 17957 17958module.exports = g; 17959 17960 17961/***/ }), 17962
vendor: 854 bytes, lines 17963-17996
17963/***/ "./node_modules/webpack/buildin/harmony-module.js": 17964/*!*******************************************!*\ 17965 !*** (webpack)/buildin/harmony-module.js ***! 17966 \*******************************************/ 17967/*! no static exports found */ 17968/***/ (function(module, exports) { 17969 17970module.exports = function(originalModule) { 17971 if (!originalModule.webpackPolyfill) { 17972 var module = Object.create(originalModule); 17973 // module.parent = undefined by default 17974 if (!module.children) module.children = []; 17975 Object.defineProperty(module, "loaded", { 17976 enumerable: true, 17977 get: function() { 17978 return module.l; 17979 } 17980 }); 17981 Object.defineProperty(module, "id", { 17982 enumerable: true, 17983 get: function() { 17984 return module.i; 17985 } 17986 }); 17987 Object.defineProperty(module, "exports", { 17988 enumerable: true 17989 }); 17990 module.webpackPolyfill = 1; 17991 } 17992 return module; 17993}; 17994 17995 17996/***/ })
17996 17997 17998}]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.