vendor: 9,287 bytes, lines 1-330
1/*! jQuery UI - v1.13.0 - 2021-11-15 2* http://jqueryui.com 3* Includes: widget.js, effect.js 4* Copyright jQuery Foundation and other contributors; Licensed MIT */ 5 6( function( factory ) { 7 "use strict"; 8 9 if ( typeof define === "function" && define.amd ) { 10 11 // AMD. Register as an anonymous module. 12 define( [ "jquery" ], factory ); 13 } else { 14 15 // Browser globals 16 factory( jQuery ); 17 } 18} )( function( $ ) { 19"use strict"; 20 21$.ui = $.ui || {}; 22 23var version = $.ui.version = "1.13.0"; 24 25 26/*! 27 * jQuery UI Widget 1.13.0 28 * http://jqueryui.com 29 * 30 * Copyright jQuery Foundation and other contributors 31 * Released under the MIT license. 32 * http://jquery.org/license 33 */ 34 35//>>label: Widget 36//>>group: Core 37//>>description: Provides a factory for creating stateful widgets with a common API. 38//>>docs: http://api.jqueryui.com/jQuery.widget/ 39//>>demos: http://jqueryui.com/widget/ 40 41 42var widgetUuid = 0; 43var widgetHasOwnProperty = Array.prototype.hasOwnProperty; 44var widgetSlice = Array.prototype.slice; 45 46$.cleanData = ( function( orig ) { 47 return function( elems ) { 48 var events, elem, i; 49 for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) { 50 51 // Only trigger remove when necessary to save time 52 events = $._data( elem, "events" ); 53 if ( events && events.remove ) { 54 $( elem ).triggerHandler( "remove" ); 55 } 56 } 57 orig( elems ); 58 }; 59} )( $.cleanData ); 60 61$.widget = function( name, base, prototype ) { 62 var existingConstructor, constructor, basePrototype; 63 64 // ProxiedPrototype allows the provided prototype to remain unmodified 65 // so that it can be used as a mixin for multiple widgets (#8876) 66 var proxiedPrototype = {}; 67 68 var namespace = name.split( "." )[ 0 ]; 69 name = name.split( "." )[ 1 ]; 70 var fullName = namespace + "-" + name; 71 72 if ( !prototype ) { 73 prototype = base; 74 base = $.Widget; 75 } 76 77 if ( Array.isArray( prototype ) ) { 78 prototype = $.extend.apply( null, [ {} ].concat( prototype ) ); 79 } 80 81 // Create selector for plugin 82 $.expr.pseudos[ fullName.toLowerCase() ] = function( elem ) { 83 return !!$.data( elem, fullName ); 84 }; 85 86 $[ namespace ] = $[ namespace ] || {}; 87 existingConstructor = $[ namespace ][ name ]; 88 constructor = $[ namespace ][ name ] = function( options, element ) { 89 90 // Allow instantiation without "new" keyword 91 if ( !this._createWidget ) { 92 return new constructor( options, element ); 93 } 94 95 // Allow instantiation without initializing for simple inheritance 96 // must use "new" keyword (the code above always passes args) 97 if ( arguments.length ) { 98 this._createWidget( options, element ); 99 } 100 }; 101 102 // Extend with the existing constructor to carry over any static properties 103 $.extend( constructor, existingConstructor, { 104 version: prototype.version, 105 106 // Copy the object used to create the prototype in case we need to 107 // redefine the widget later 108 _proto: $.extend( {}, prototype ), 109 110 // Track widgets that inherit from this widget in case this widget is 111 // redefined after a widget inherits from it 112 _childConstructors: [] 113 } ); 114 115 basePrototype = new base(); 116 117 // We need to make the options hash a property directly on the new instance 118 // otherwise we'll modify the options hash on the prototype that we're 119 // inheriting from 120 basePrototype.options = $.widget.extend( {}, basePrototype.options ); 121 $.each( prototype, function( prop, value ) { 122 if ( typeof value !== "function" ) { 123 proxiedPrototype[ prop ] = value; 124 return; 125 } 126 proxiedPrototype[ prop ] = ( function() { 127 function _super() { 128 return base.prototype[ prop ].apply( this, arguments ); 129 } 130 131 function _superApply( args ) { 132 return base.prototype[ prop ].apply( this, args ); 133 } 134 135 return function() { 136 var __super = this._super; 137 var __superApply = this._superApply; 138 var returnValue; 139 140 this._super = _super; 141 this._superApply = _superApply; 142 143 returnValue = value.apply( this, arguments ); 144 145 this._super = __super; 146 this._superApply = __superApply; 147 148 return returnValue; 149 }; 150 } )(); 151 } ); 152 constructor.prototype = $.widget.extend( basePrototype, { 153 154 // TODO: remove support for widgetEventPrefix 155 // always use the name + a colon as the prefix, e.g., draggable:start 156 // don't prefix for widgets that aren't DOM-based 157 widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name 158 }, proxiedPrototype, { 159 constructor: constructor, 160 namespace: namespace, 161 widgetName: name, 162 widgetFullName: fullName 163 } ); 164 165 // If this widget is being redefined then we need to find all widgets that 166 // are inheriting from it and redefine all of them so that they inherit from 167 // the new version of this widget. We're essentially trying to replace one 168 // level in the prototype chain. 169 if ( existingConstructor ) { 170 $.each( existingConstructor._childConstructors, function( i, child ) { 171 var childPrototype = child.prototype; 172 173 // Redefine the child widget using the same prototype that was 174 // originally used, but inherit from the new version of the base 175 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, 176 child._proto ); 177 } ); 178 179 // Remove the list of existing child constructors from the old constructor 180 // so the old child constructors can be garbage collected 181 delete existingConstructor._childConstructors; 182 } else { 183 base._childConstructors.push( constructor ); 184 } 185 186 $.widget.bridge( name, constructor ); 187 188 return constructor; 189}; 190 191$.widget.extend = function( target ) { 192 var input = widgetSlice.call( arguments, 1 ); 193 var inputIndex = 0; 194 var inputLength = input.length; 195 var key; 196 var value; 197 198 for ( ; inputIndex < inputLength; inputIndex++ ) { 199 for ( key in input[ inputIndex ] ) { 200 value = input[ inputIndex ][ key ]; 201 if ( widgetHasOwnProperty.call( input[ inputIndex ], key ) && value !== undefined ) { 202 203 // Clone objects 204 if ( $.isPlainObject( value ) ) { 205 target[ key ] = $.isPlainObject( target[ key ] ) ? 206 $.widget.extend( {}, target[ key ], value ) : 207 208 // Don't extend strings, arrays, etc. with objects 209 $.widget.extend( {}, value ); 210 211 // Copy everything else by reference 212 } else { 213 target[ key ] = value; 214 } 215 } 216 } 217 } 218 return target; 219}; 220 221$.widget.bridge = function( name, object ) { 222 var fullName = object.prototype.widgetFullName || name; 223 $.fn[ name ] = function( options ) { 224 var isMethodCall = typeof options === "string"; 225 var args = widgetSlice.call( arguments, 1 ); 226 var returnValue = this; 227 228 if ( isMethodCall ) { 229 230 // If this is an empty collection, we need to have the instance method 231 // return undefined instead of the jQuery instance 232 if ( !this.length && options === "instance" ) { 233 returnValue = undefined; 234 } else { 235 this.each( function() { 236 var methodValue; 237 var instance = $.data( this, fullName ); 238 239 if ( options === "instance" ) { 240 returnValue = instance; 241 return false; 242 } 243 244 if ( !instance ) { 245 return $.error( "cannot call methods on " + name + 246 " prior to initialization; " + 247 "attempted to call method '" + options + "'" ); 248 } 249 250 if ( typeof instance[ options ] !== "function" || 251 options.charAt( 0 ) === "_" ) { 252 return $.error( "no such method '" + options + "' for " + name + 253 " widget instance" ); 254 } 255 256 methodValue = instance[ options ].apply( instance, args ); 257 258 if ( methodValue !== instance && methodValue !== undefined ) { 259 returnValue = methodValue && methodValue.jquery ? 260 returnValue.pushStack( methodValue.get() ) : 261 methodValue; 262 return false; 263 } 264 } ); 265 } 266 } else { 267 268 // Allow multiple hashes to be passed on init 269 if ( args.length ) { 270 options = $.widget.extend.apply( null, [ options ].concat( args ) ); 271 } 272 273 this.each( function() { 274 var instance = $.data( this, fullName ); 275 if ( instance ) { 276 instance.option( options || {} ); 277 if ( instance._init ) { 278 instance._init(); 279 } 280 } else { 281 $.data( this, fullName, new object( options, this ) ); 282 } 283 } ); 284 } 285 286 return returnValue; 287 }; 288}; 289 290$.Widget = function( /* options, element */ ) {}; 291$.Widget._childConstructors = []; 292 293$.Widget.prototype = { 294 widgetName: "widget", 295 widgetEventPrefix: "", 296 defaultElement: "<div>", 297 298 options: { 299 classes: {}, 300 disabled: false, 301 302 // Callbacks 303 create: null 304 }, 305 306 _createWidget: function( options, element ) { 307 element = $( element || this.defaultElement || this )[ 0 ]; 308 this.element = $( element ); 309 this.uuid = widgetUuid++; 310 this.eventNamespace = "." + this.widgetName + this.uuid; 311 312 this.bindings = $(); 313 this.hoverable = $(); 314 this.focusable = $(); 315 this.classesElementLookup = {}; 316 317 if ( element !== this ) { 318 $.data( element, this.widgetFullName, this ); 319 this._on( true, this.element, { 320 remove: function( event ) { 321 if ( event.target === element ) { 322 this.destroy(); 323 } 324 } 325 } ); 326 this.document = $( element.style ? 327 328 // Element within the document 329 element.ownerDocument : 330
vendor: 11,620 bytes, lines 331-747
331 // Element is window or document 332 element.document || element ); 333 this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow ); 334 } 335 336 this.options = $.widget.extend( {}, 337 this.options, 338 this._getCreateOptions(), 339 options ); 340 341 this._create(); 342 343 if ( this.options.disabled ) { 344 this._setOptionDisabled( this.options.disabled ); 345 } 346 347 this._trigger( "create", null, this._getCreateEventData() ); 348 this._init(); 349 }, 350 351 _getCreateOptions: function() { 352 return {}; 353 }, 354 355 _getCreateEventData: $.noop, 356 357 _create: $.noop, 358 359 _init: $.noop, 360 361 destroy: function() { 362 var that = this; 363 364 this._destroy(); 365 $.each( this.classesElementLookup, function( key, value ) { 366 that._removeClass( value, key ); 367 } ); 368 369 // We can probably remove the unbind calls in 2.0 370 // all event bindings should go through this._on() 371 this.element 372 .off( this.eventNamespace ) 373 .removeData( this.widgetFullName ); 374 this.widget() 375 .off( this.eventNamespace ) 376 .removeAttr( "aria-disabled" ); 377 378 // Clean up events and states 379 this.bindings.off( this.eventNamespace ); 380 }, 381 382 _destroy: $.noop, 383 384 widget: function() { 385 return this.element; 386 }, 387 388 option: function( key, value ) { 389 var options = key; 390 var parts; 391 var curOption; 392 var i; 393 394 if ( arguments.length === 0 ) { 395 396 // Don't return a reference to the internal hash 397 return $.widget.extend( {}, this.options ); 398 } 399 400 if ( typeof key === "string" ) { 401 402 // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } } 403 options = {}; 404 parts = key.split( "." ); 405 key = parts.shift(); 406 if ( parts.length ) { 407 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] ); 408 for ( i = 0; i < parts.length - 1; i++ ) { 409 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {}; 410 curOption = curOption[ parts[ i ] ]; 411 } 412 key = parts.pop(); 413 if ( arguments.length === 1 ) { 414 return curOption[ key ] === undefined ? null : curOption[ key ]; 415 } 416 curOption[ key ] = value; 417 } else { 418 if ( arguments.length === 1 ) { 419 return this.options[ key ] === undefined ? null : this.options[ key ]; 420 } 421 options[ key ] = value; 422 } 423 } 424 425 this._setOptions( options ); 426 427 return this; 428 }, 429 430 _setOptions: function( options ) { 431 var key; 432 433 for ( key in options ) { 434 this._setOption( key, options[ key ] ); 435 } 436 437 return this; 438 }, 439 440 _setOption: function( key, value ) { 441 if ( key === "classes" ) { 442 this._setOptionClasses( value ); 443 } 444 445 this.options[ key ] = value; 446 447 if ( key === "disabled" ) { 448 this._setOptionDisabled( value ); 449 } 450 451 return this; 452 }, 453 454 _setOptionClasses: function( value ) { 455 var classKey, elements, currentElements; 456 457 for ( classKey in value ) { 458 currentElements = this.classesElementLookup[ classKey ]; 459 if ( value[ classKey ] === this.options.classes[ classKey ] || 460 !currentElements || 461 !currentElements.length ) { 462 continue; 463 } 464 465 // We are doing this to create a new jQuery object because the _removeClass() call 466 // on the next line is going to destroy the reference to the current elements being 467 // tracked. We need to save a copy of this collection so that we can add the new classes 468 // below. 469 elements = $( currentElements.get() ); 470 this._removeClass( currentElements, classKey ); 471 472 // We don't use _addClass() here, because that uses this.options.classes 473 // for generating the string of classes. We want to use the value passed in from 474 // _setOption(), this is the new value of the classes option which was passed to 475 // _setOption(). We pass this value directly to _classes(). 476 elements.addClass( this._classes( { 477 element: elements, 478 keys: classKey, 479 classes: value, 480 add: true 481 } ) ); 482 } 483 }, 484 485 _setOptionDisabled: function( value ) { 486 this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value ); 487 488 // If the widget is becoming disabled, then nothing is interactive 489 if ( value ) { 490 this._removeClass( this.hoverable, null, "ui-state-hover" ); 491 this._removeClass( this.focusable, null, "ui-state-focus" ); 492 } 493 }, 494 495 enable: function() { 496 return this._setOptions( { disabled: false } ); 497 }, 498 499 disable: function() { 500 return this._setOptions( { disabled: true } ); 501 }, 502 503 _classes: function( options ) { 504 var full = []; 505 var that = this; 506 507 options = $.extend( { 508 element: this.element, 509 classes: this.options.classes || {} 510 }, options ); 511 512 function bindRemoveEvent() { 513 options.element.each( function( _, element ) { 514 var isTracked = $.map( that.classesElementLookup, function( elements ) { 515 return elements; 516 } ) 517 .some( function( elements ) { 518 return elements.is( element ); 519 } ); 520 521 if ( !isTracked ) { 522 that._on( $( element ), { 523 remove: "_untrackClassesElement" 524 } ); 525 } 526 } ); 527 } 528 529 function processClassString( classes, checkOption ) { 530 var current, i; 531 for ( i = 0; i < classes.length; i++ ) { 532 current = that.classesElementLookup[ classes[ i ] ] || $(); 533 if ( options.add ) { 534 bindRemoveEvent(); 535 current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) ); 536 } else { 537 current = $( current.not( options.element ).get() ); 538 } 539 that.classesElementLookup[ classes[ i ] ] = current; 540 full.push( classes[ i ] ); 541 if ( checkOption && options.classes[ classes[ i ] ] ) { 542 full.push( options.classes[ classes[ i ] ] ); 543 } 544 } 545 } 546 547 if ( options.keys ) { 548 processClassString( options.keys.match( /\S+/g ) || [], true ); 549 } 550 if ( options.extra ) { 551 processClassString( options.extra.match( /\S+/g ) || [] ); 552 } 553 554 return full.join( " " ); 555 }, 556 557 _untrackClassesElement: function( event ) { 558 var that = this; 559 $.each( that.classesElementLookup, function( key, value ) { 560 if ( $.inArray( event.target, value ) !== -1 ) { 561 that.classesElementLookup[ key ] = $( value.not( event.target ).get() ); 562 } 563 } ); 564 565 this._off( $( event.target ) ); 566 }, 567 568 _removeClass: function( element, keys, extra ) { 569 return this._toggleClass( element, keys, extra, false ); 570 }, 571 572 _addClass: function( element, keys, extra ) { 573 return this._toggleClass( element, keys, extra, true ); 574 }, 575 576 _toggleClass: function( element, keys, extra, add ) { 577 add = ( typeof add === "boolean" ) ? add : extra; 578 var shift = ( typeof element === "string" || element === null ), 579 options = { 580 extra: shift ? keys : extra, 581 keys: shift ? element : keys, 582 element: shift ? this.element : element, 583 add: add 584 }; 585 options.element.toggleClass( this._classes( options ), add ); 586 return this; 587 }, 588 589 _on: function( suppressDisabledCheck, element, handlers ) { 590 var delegateElement; 591 var instance = this; 592 593 // No suppressDisabledCheck flag, shuffle arguments 594 if ( typeof suppressDisabledCheck !== "boolean" ) { 595 handlers = element; 596 element = suppressDisabledCheck; 597 suppressDisabledCheck = false; 598 } 599 600 // No element argument, shuffle and use this.element 601 if ( !handlers ) { 602 handlers = element; 603 element = this.element; 604 delegateElement = this.widget(); 605 } else { 606 element = delegateElement = $( element ); 607 this.bindings = this.bindings.add( element ); 608 } 609 610 $.each( handlers, function( event, handler ) { 611 function handlerProxy() { 612 613 // Allow widgets to customize the disabled handling 614 // - disabled as an array instead of boolean 615 // - disabled class as method for disabling individual parts 616 if ( !suppressDisabledCheck && 617 ( instance.options.disabled === true || 618 $( this ).hasClass( "ui-state-disabled" ) ) ) { 619 return; 620 } 621 return ( typeof handler === "string" ? instance[ handler ] : handler ) 622 .apply( instance, arguments ); 623 } 624 625 // Copy the guid so direct unbinding works 626 if ( typeof handler !== "string" ) { 627 handlerProxy.guid = handler.guid = 628 handler.guid || handlerProxy.guid || $.guid++; 629 } 630 631 var match = event.match( /^([\w:-]*)\s*(.*)$/ ); 632 var eventName = match[ 1 ] + instance.eventNamespace; 633 var selector = match[ 2 ]; 634 635 if ( selector ) { 636 delegateElement.on( eventName, selector, handlerProxy ); 637 } else { 638 element.on( eventName, handlerProxy ); 639 } 640 } ); 641 }, 642 643 _off: function( element, eventName ) { 644 eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) + 645 this.eventNamespace; 646 element.off( eventName ); 647 648 // Clear the stack to avoid memory leaks (#10056) 649 this.bindings = $( this.bindings.not( element ).get() ); 650 this.focusable = $( this.focusable.not( element ).get() ); 651 this.hoverable = $( this.hoverable.not( element ).get() ); 652 }, 653 654 _delay: function( handler, delay ) { 655 function handlerProxy() { 656 return ( typeof handler === "string" ? instance[ handler ] : handler ) 657 .apply( instance, arguments ); 658 } 659 var instance = this; 660 return setTimeout( handlerProxy, delay || 0 ); 661 }, 662 663 _hoverable: function( element ) { 664 this.hoverable = this.hoverable.add( element ); 665 this._on( element, { 666 mouseenter: function( event ) { 667 this._addClass( $( event.currentTarget ), null, "ui-state-hover" ); 668 }, 669 mouseleave: function( event ) { 670 this._removeClass( $( event.currentTarget ), null, "ui-state-hover" ); 671 } 672 } ); 673 }, 674 675 _focusable: function( element ) { 676 this.focusable = this.focusable.add( element ); 677 this._on( element, { 678 focusin: function( event ) { 679 this._addClass( $( event.currentTarget ), null, "ui-state-focus" ); 680 }, 681 focusout: function( event ) { 682 this._removeClass( $( event.currentTarget ), null, "ui-state-focus" ); 683 } 684 } ); 685 }, 686 687 _trigger: function( type, event, data ) { 688 var prop, orig; 689 var callback = this.options[ type ]; 690 691 data = data || {}; 692 event = $.Event( event ); 693 event.type = ( type === this.widgetEventPrefix ? 694 type : 695 this.widgetEventPrefix + type ).toLowerCase(); 696 697 // The original event may come from any element 698 // so we need to reset the target on the new event 699 event.target = this.element[ 0 ]; 700 701 // Copy original event properties over to the new event 702 orig = event.originalEvent; 703 if ( orig ) { 704 for ( prop in orig ) { 705 if ( !( prop in event ) ) { 706 event[ prop ] = orig[ prop ]; 707 } 708 } 709 } 710 711 this.element.trigger( event, data ); 712 return !( typeof callback === "function" && 713 callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false || 714 event.isDefaultPrevented() ); 715 } 716}; 717 718$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) { 719 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) { 720 if ( typeof options === "string" ) { 721 options = { effect: options }; 722 } 723 724 var hasOptions; 725 var effectName = !options ? 726 method : 727 options === true || typeof options === "number" ? 728 defaultEffect : 729 options.effect || defaultEffect; 730 731 options = options || {}; 732 if ( typeof options === "number" ) { 733 options = { duration: options }; 734 } else if ( options === true ) { 735 options = {}; 736 } 737 738 hasOptions = !$.isEmptyObject( options ); 739 options.complete = callback; 740 741 if ( options.delay ) { 742 element.delay( options.delay ); 743 } 744 745 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) { 746 element[ method ]( options ); 747 } else if ( effectName !== method && element[ effectName ] ) {
vendor: 28,405 bytes, lines 748-1856
748 element[ effectName ]( options.duration, options.easing, callback ); 749 } else { 750 element.queue( function( next ) { 751 $( this )[ method ](); 752 if ( callback ) { 753 callback.call( element[ 0 ] ); 754 } 755 next(); 756 } ); 757 } 758 }; 759} ); 760 761var widget = $.widget; 762 763 764 765// Create a local jQuery because jQuery Color relies on it and the 766// global may not exist with AMD and a custom build (#10199). 767// This module is a noop if used as a regular AMD module. 768// eslint-disable-next-line no-unused-vars 769var jQuery = $; 770 771 772/*! 773 * jQuery Color Animations v2.2.0 774 * https://github.com/jquery/jquery-color 775 * 776 * Copyright OpenJS Foundation and other contributors 777 * Released under the MIT license. 778 * http://jquery.org/license 779 * 780 * Date: Sun May 10 09:02:36 2020 +0200 781 */ 782 783 784 785 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor " + 786 "borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor", 787 788 class2type = {}, 789 toString = class2type.toString, 790 791 // plusequals test for += 100 -= 100 792 rplusequals = /^([\-+])=\s*(\d+\.?\d*)/, 793 794 // a set of RE's that can match strings and generate color tuples. 795 stringParsers = [ { 796 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 797 parse: function( execResult ) { 798 return [ 799 execResult[ 1 ], 800 execResult[ 2 ], 801 execResult[ 3 ], 802 execResult[ 4 ] 803 ]; 804 } 805 }, { 806 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 807 parse: function( execResult ) { 808 return [ 809 execResult[ 1 ] * 2.55, 810 execResult[ 2 ] * 2.55, 811 execResult[ 3 ] * 2.55, 812 execResult[ 4 ] 813 ]; 814 } 815 }, { 816 817 // this regex ignores A-F because it's compared against an already lowercased string 818 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?/, 819 parse: function( execResult ) { 820 return [ 821 parseInt( execResult[ 1 ], 16 ), 822 parseInt( execResult[ 2 ], 16 ), 823 parseInt( execResult[ 3 ], 16 ), 824 execResult[ 4 ] ? 825 ( parseInt( execResult[ 4 ], 16 ) / 255 ).toFixed( 2 ) : 826 1 827 ]; 828 } 829 }, { 830 831 // this regex ignores A-F because it's compared against an already lowercased string 832 re: /#([a-f0-9])([a-f0-9])([a-f0-9])([a-f0-9])?/, 833 parse: function( execResult ) { 834 return [ 835 parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ), 836 parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ), 837 parseInt( execResult[ 3 ] + execResult[ 3 ], 16 ), 838 execResult[ 4 ] ? 839 ( parseInt( execResult[ 4 ] + execResult[ 4 ], 16 ) / 255 ) 840 .toFixed( 2 ) : 841 1 842 ]; 843 } 844 }, { 845 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/, 846 space: "hsla", 847 parse: function( execResult ) { 848 return [ 849 execResult[ 1 ], 850 execResult[ 2 ] / 100, 851 execResult[ 3 ] / 100, 852 execResult[ 4 ] 853 ]; 854 } 855 } ], 856 857 // jQuery.Color( ) 858 color = jQuery.Color = function( color, green, blue, alpha ) { 859 return new jQuery.Color.fn.parse( color, green, blue, alpha ); 860 }, 861 spaces = { 862 rgba: { 863 props: { 864 red: { 865 idx: 0, 866 type: "byte" 867 }, 868 green: { 869 idx: 1, 870 type: "byte" 871 }, 872 blue: { 873 idx: 2, 874 type: "byte" 875 } 876 } 877 }, 878 879 hsla: { 880 props: { 881 hue: { 882 idx: 0, 883 type: "degrees" 884 }, 885 saturation: { 886 idx: 1, 887 type: "percent" 888 }, 889 lightness: { 890 idx: 2, 891 type: "percent" 892 } 893 } 894 } 895 }, 896 propTypes = { 897 "byte": { 898 floor: true, 899 max: 255 900 }, 901 "percent": { 902 max: 1 903 }, 904 "degrees": { 905 mod: 360, 906 floor: true 907 } 908 }, 909 support = color.support = {}, 910 911 // element for support tests 912 supportElem = jQuery( "<p>" )[ 0 ], 913 914 // colors = jQuery.Color.names 915 colors, 916 917 // local aliases of functions called often 918 each = jQuery.each; 919 920// determine rgba support immediately 921supportElem.style.cssText = "background-color:rgba(1,1,1,.5)"; 922support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1; 923 924// define cache name and alpha properties 925// for rgba and hsla spaces 926each( spaces, function( spaceName, space ) { 927 space.cache = "_" + spaceName; 928 space.props.alpha = { 929 idx: 3, 930 type: "percent", 931 def: 1 932 }; 933} ); 934 935// Populate the class2type map 936jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), 937 function( _i, name ) { 938 class2type[ "[object " + name + "]" ] = name.toLowerCase(); 939 } ); 940 941function getType( obj ) { 942 if ( obj == null ) { 943 return obj + ""; 944 } 945 946 return typeof obj === "object" ? 947 class2type[ toString.call( obj ) ] || "object" : 948 typeof obj; 949} 950 951function clamp( value, prop, allowEmpty ) { 952 var type = propTypes[ prop.type ] || {}; 953 954 if ( value == null ) { 955 return ( allowEmpty || !prop.def ) ? null : prop.def; 956 } 957 958 // ~~ is an short way of doing floor for positive numbers 959 value = type.floor ? ~~value : parseFloat( value ); 960 961 // IE will pass in empty strings as value for alpha, 962 // which will hit this case 963 if ( isNaN( value ) ) { 964 return prop.def; 965 } 966 967 if ( type.mod ) { 968 969 // we add mod before modding to make sure that negatives values 970 // get converted properly: -10 -> 350 971 return ( value + type.mod ) % type.mod; 972 } 973 974 // for now all property types without mod have min and max 975 return Math.min( type.max, Math.max( 0, value ) ); 976} 977 978function stringParse( string ) { 979 var inst = color(), 980 rgba = inst._rgba = []; 981 982 string = string.toLowerCase(); 983 984 each( stringParsers, function( _i, parser ) { 985 var parsed, 986 match = parser.re.exec( string ), 987 values = match && parser.parse( match ), 988 spaceName = parser.space || "rgba"; 989 990 if ( values ) { 991 parsed = inst[ spaceName ]( values ); 992 993 // if this was an rgba parse the assignment might happen twice 994 // oh well.... 995 inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ]; 996 rgba = inst._rgba = parsed._rgba; 997 998 // exit each( stringParsers ) here because we matched 999 return false; 1000 } 1001 } ); 1002 1003 // Found a stringParser that handled it 1004 if ( rgba.length ) { 1005 1006 // if this came from a parsed string, force "transparent" when alpha is 0 1007 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0) 1008 if ( rgba.join() === "0,0,0,0" ) { 1009 jQuery.extend( rgba, colors.transparent ); 1010 } 1011 return inst; 1012 } 1013 1014 // named colors 1015 return colors[ string ]; 1016} 1017 1018color.fn = jQuery.extend( color.prototype, { 1019 parse: function( red, green, blue, alpha ) { 1020 if ( red === undefined ) { 1021 this._rgba = [ null, null, null, null ]; 1022 return this; 1023 } 1024 if ( red.jquery || red.nodeType ) { 1025 red = jQuery( red ).css( green ); 1026 green = undefined; 1027 } 1028 1029 var inst = this, 1030 type = getType( red ), 1031 rgba = this._rgba = []; 1032 1033 // more than 1 argument specified - assume ( red, green, blue, alpha ) 1034 if ( green !== undefined ) { 1035 red = [ red, green, blue, alpha ]; 1036 type = "array"; 1037 } 1038 1039 if ( type === "string" ) { 1040 return this.parse( stringParse( red ) || colors._default ); 1041 } 1042 1043 if ( type === "array" ) { 1044 each( spaces.rgba.props, function( _key, prop ) { 1045 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop ); 1046 } ); 1047 return this; 1048 } 1049 1050 if ( type === "object" ) { 1051 if ( red instanceof color ) { 1052 each( spaces, function( _spaceName, space ) { 1053 if ( red[ space.cache ] ) { 1054 inst[ space.cache ] = red[ space.cache ].slice(); 1055 } 1056 } ); 1057 } else { 1058 each( spaces, function( _spaceName, space ) { 1059 var cache = space.cache; 1060 each( space.props, function( key, prop ) { 1061 1062 // if the cache doesn't exist, and we know how to convert 1063 if ( !inst[ cache ] && space.to ) { 1064 1065 // if the value was null, we don't need to copy it 1066 // if the key was alpha, we don't need to copy it either 1067 if ( key === "alpha" || red[ key ] == null ) { 1068 return; 1069 } 1070 inst[ cache ] = space.to( inst._rgba ); 1071 } 1072 1073 // this is the only case where we allow nulls for ALL properties. 1074 // call clamp with alwaysAllowEmpty 1075 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true ); 1076 } ); 1077 1078 // everything defined but alpha? 1079 if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) { 1080 1081 // use the default of 1 1082 if ( inst[ cache ][ 3 ] == null ) { 1083 inst[ cache ][ 3 ] = 1; 1084 } 1085 1086 if ( space.from ) { 1087 inst._rgba = space.from( inst[ cache ] ); 1088 } 1089 } 1090 } ); 1091 } 1092 return this; 1093 } 1094 }, 1095 is: function( compare ) { 1096 var is = color( compare ), 1097 same = true, 1098 inst = this; 1099 1100 each( spaces, function( _, space ) { 1101 var localCache, 1102 isCache = is[ space.cache ]; 1103 if ( isCache ) { 1104 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || []; 1105 each( space.props, function( _, prop ) { 1106 if ( isCache[ prop.idx ] != null ) { 1107 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] ); 1108 return same; 1109 } 1110 } ); 1111 } 1112 return same; 1113 } ); 1114 return same; 1115 }, 1116 _space: function() { 1117 var used = [], 1118 inst = this; 1119 each( spaces, function( spaceName, space ) { 1120 if ( inst[ space.cache ] ) { 1121 used.push( spaceName ); 1122 } 1123 } ); 1124 return used.pop(); 1125 }, 1126 transition: function( other, distance ) { 1127 var end = color( other ), 1128 spaceName = end._space(), 1129 space = spaces[ spaceName ], 1130 startColor = this.alpha() === 0 ? color( "transparent" ) : this, 1131 start = startColor[ space.cache ] || space.to( startColor._rgba ), 1132 result = start.slice(); 1133 1134 end = end[ space.cache ]; 1135 each( space.props, function( _key, prop ) { 1136 var index = prop.idx, 1137 startValue = start[ index ], 1138 endValue = end[ index ], 1139 type = propTypes[ prop.type ] || {}; 1140 1141 // if null, don't override start value 1142 if ( endValue === null ) { 1143 return; 1144 } 1145 1146 // if null - use end 1147 if ( startValue === null ) { 1148 result[ index ] = endValue; 1149 } else { 1150 if ( type.mod ) { 1151 if ( endValue - startValue > type.mod / 2 ) { 1152 startValue += type.mod; 1153 } else if ( startValue - endValue > type.mod / 2 ) { 1154 startValue -= type.mod; 1155 } 1156 } 1157 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop ); 1158 } 1159 } ); 1160 return this[ spaceName ]( result ); 1161 }, 1162 blend: function( opaque ) { 1163 1164 // if we are already opaque - return ourself 1165 if ( this._rgba[ 3 ] === 1 ) { 1166 return this; 1167 } 1168 1169 var rgb = this._rgba.slice(), 1170 a = rgb.pop(), 1171 blend = color( opaque )._rgba; 1172 1173 return color( jQuery.map( rgb, function( v, i ) { 1174 return ( 1 - a ) * blend[ i ] + a * v; 1175 } ) ); 1176 }, 1177 toRgbaString: function() { 1178 var prefix = "rgba(", 1179 rgba = jQuery.map( this._rgba, function( v, i ) { 1180 if ( v != null ) { 1181 return v; 1182 } 1183 return i > 2 ? 1 : 0; 1184 } ); 1185 1186 if ( rgba[ 3 ] === 1 ) { 1187 rgba.pop(); 1188 prefix = "rgb("; 1189 } 1190 1191 return prefix + rgba.join() + ")"; 1192 }, 1193 toHslaString: function() { 1194 var prefix = "hsla(", 1195 hsla = jQuery.map( this.hsla(), function( v, i ) { 1196 if ( v == null ) { 1197 v = i > 2 ? 1 : 0; 1198 } 1199 1200 // catch 1 and 2 1201 if ( i && i < 3 ) { 1202 v = Math.round( v * 100 ) + "%"; 1203 } 1204 return v; 1205 } ); 1206 1207 if ( hsla[ 3 ] === 1 ) { 1208 hsla.pop(); 1209 prefix = "hsl("; 1210 } 1211 return prefix + hsla.join() + ")"; 1212 }, 1213 toHexString: function( includeAlpha ) { 1214 var rgba = this._rgba.slice(), 1215 alpha = rgba.pop(); 1216 1217 if ( includeAlpha ) { 1218 rgba.push( ~~( alpha * 255 ) ); 1219 } 1220 1221 return "#" + jQuery.map( rgba, function( v ) { 1222 1223 // default to 0 when nulls exist 1224 v = ( v || 0 ).toString( 16 ); 1225 return v.length === 1 ? "0" + v : v; 1226 } ).join( "" ); 1227 }, 1228 toString: function() { 1229 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString(); 1230 } 1231} ); 1232color.fn.parse.prototype = color.fn; 1233 1234// hsla conversions adapted from: 1235// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021 1236 1237function hue2rgb( p, q, h ) { 1238 h = ( h + 1 ) % 1; 1239 if ( h * 6 < 1 ) { 1240 return p + ( q - p ) * h * 6; 1241 } 1242 if ( h * 2 < 1 ) { 1243 return q; 1244 } 1245 if ( h * 3 < 2 ) { 1246 return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6; 1247 } 1248 return p; 1249} 1250 1251spaces.hsla.to = function( rgba ) { 1252 if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) { 1253 return [ null, null, null, rgba[ 3 ] ]; 1254 } 1255 var r = rgba[ 0 ] / 255, 1256 g = rgba[ 1 ] / 255, 1257 b = rgba[ 2 ] / 255, 1258 a = rgba[ 3 ], 1259 max = Math.max( r, g, b ), 1260 min = Math.min( r, g, b ), 1261 diff = max - min, 1262 add = max + min, 1263 l = add * 0.5, 1264 h, s; 1265 1266 if ( min === max ) { 1267 h = 0; 1268 } else if ( r === max ) { 1269 h = ( 60 * ( g - b ) / diff ) + 360; 1270 } else if ( g === max ) { 1271 h = ( 60 * ( b - r ) / diff ) + 120; 1272 } else { 1273 h = ( 60 * ( r - g ) / diff ) + 240; 1274 } 1275 1276 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0% 1277 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add) 1278 if ( diff === 0 ) { 1279 s = 0; 1280 } else if ( l <= 0.5 ) { 1281 s = diff / add; 1282 } else { 1283 s = diff / ( 2 - add ); 1284 } 1285 return [ Math.round( h ) % 360, s, l, a == null ? 1 : a ]; 1286}; 1287 1288spaces.hsla.from = function( hsla ) { 1289 if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) { 1290 return [ null, null, null, hsla[ 3 ] ]; 1291 } 1292 var h = hsla[ 0 ] / 360, 1293 s = hsla[ 1 ], 1294 l = hsla[ 2 ], 1295 a = hsla[ 3 ], 1296 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s, 1297 p = 2 * l - q; 1298 1299 return [ 1300 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ), 1301 Math.round( hue2rgb( p, q, h ) * 255 ), 1302 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ), 1303 a 1304 ]; 1305}; 1306 1307 1308each( spaces, function( spaceName, space ) { 1309 var props = space.props, 1310 cache = space.cache, 1311 to = space.to, 1312 from = space.from; 1313 1314 // makes rgba() and hsla() 1315 color.fn[ spaceName ] = function( value ) { 1316 1317 // generate a cache for this space if it doesn't exist 1318 if ( to && !this[ cache ] ) { 1319 this[ cache ] = to( this._rgba ); 1320 } 1321 if ( value === undefined ) { 1322 return this[ cache ].slice(); 1323 } 1324 1325 var ret, 1326 type = getType( value ), 1327 arr = ( type === "array" || type === "object" ) ? value : arguments, 1328 local = this[ cache ].slice(); 1329 1330 each( props, function( key, prop ) { 1331 var val = arr[ type === "object" ? key : prop.idx ]; 1332 if ( val == null ) { 1333 val = local[ prop.idx ]; 1334 } 1335 local[ prop.idx ] = clamp( val, prop ); 1336 } ); 1337 1338 if ( from ) { 1339 ret = color( from( local ) ); 1340 ret[ cache ] = local; 1341 return ret; 1342 } else { 1343 return color( local ); 1344 } 1345 }; 1346 1347 // makes red() green() blue() alpha() hue() saturation() lightness() 1348 each( props, function( key, prop ) { 1349 1350 // alpha is included in more than one space 1351 if ( color.fn[ key ] ) { 1352 return; 1353 } 1354 color.fn[ key ] = function( value ) { 1355 var local, cur, match, fn, 1356 vtype = getType( value ); 1357 1358 if ( key === "alpha" ) { 1359 fn = this._hsla ? "hsla" : "rgba"; 1360 } else { 1361 fn = spaceName; 1362 } 1363 local = this[ fn ](); 1364 cur = local[ prop.idx ]; 1365 1366 if ( vtype === "undefined" ) { 1367 return cur; 1368 } 1369 1370 if ( vtype === "function" ) { 1371 value = value.call( this, cur ); 1372 vtype = getType( value ); 1373 } 1374 if ( value == null && prop.empty ) { 1375 return this; 1376 } 1377 if ( vtype === "string" ) { 1378 match = rplusequals.exec( value ); 1379 if ( match ) { 1380 value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 ); 1381 } 1382 } 1383 local[ prop.idx ] = value; 1384 return this[ fn ]( local ); 1385 }; 1386 } ); 1387} ); 1388 1389// add cssHook and .fx.step function for each named hook. 1390// accept a space separated string of properties 1391color.hook = function( hook ) { 1392 var hooks = hook.split( " " ); 1393 each( hooks, function( _i, hook ) { 1394 jQuery.cssHooks[ hook ] = { 1395 set: function( elem, value ) { 1396 var parsed, curElem, 1397 backgroundColor = ""; 1398 1399 if ( value !== "transparent" && ( getType( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) { 1400 value = color( parsed || value ); 1401 if ( !support.rgba && value._rgba[ 3 ] !== 1 ) { 1402 curElem = hook === "backgroundColor" ? elem.parentNode : elem; 1403 while ( 1404 ( backgroundColor === "" || backgroundColor === "transparent" ) && 1405 curElem && curElem.style 1406 ) { 1407 try { 1408 backgroundColor = jQuery.css( curElem, "backgroundColor" ); 1409 curElem = curElem.parentNode; 1410 } catch ( e ) { 1411 } 1412 } 1413 1414 value = value.blend( backgroundColor && backgroundColor !== "transparent" ? 1415 backgroundColor : 1416 "_default" ); 1417 } 1418 1419 value = value.toRgbaString(); 1420 } 1421 try { 1422 elem.style[ hook ] = value; 1423 } catch ( e ) { 1424 1425 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit' 1426 } 1427 } 1428 }; 1429 jQuery.fx.step[ hook ] = function( fx ) { 1430 if ( !fx.colorInit ) { 1431 fx.start = color( fx.elem, hook ); 1432 fx.end = color( fx.end ); 1433 fx.colorInit = true; 1434 } 1435 jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) ); 1436 }; 1437 } ); 1438 1439}; 1440 1441color.hook( stepHooks ); 1442 1443jQuery.cssHooks.borderColor = { 1444 expand: function( value ) { 1445 var expanded = {}; 1446 1447 each( [ "Top", "Right", "Bottom", "Left" ], function( _i, part ) { 1448 expanded[ "border" + part + "Color" ] = value; 1449 } ); 1450 return expanded; 1451 } 1452}; 1453 1454// Basic color names only. 1455// Usage of any of the other color names requires adding yourself or including 1456// jquery.color.svg-names.js. 1457colors = jQuery.Color.names = { 1458 1459 // 4.1. Basic color keywords 1460 aqua: "#00ffff", 1461 black: "#000000", 1462 blue: "#0000ff", 1463 fuchsia: "#ff00ff", 1464 gray: "#808080", 1465 green: "#008000", 1466 lime: "#00ff00", 1467 maroon: "#800000", 1468 navy: "#000080", 1469 olive: "#808000", 1470 purple: "#800080", 1471 red: "#ff0000", 1472 silver: "#c0c0c0", 1473 teal: "#008080", 1474 white: "#ffffff", 1475 yellow: "#ffff00", 1476 1477 // 4.2.3. "transparent" color keyword 1478 transparent: [ null, null, null, 0 ], 1479 1480 _default: "#ffffff" 1481}; 1482 1483 1484/*! 1485 * jQuery UI Effects 1.13.0 1486 * http://jqueryui.com 1487 * 1488 * Copyright jQuery Foundation and other contributors 1489 * Released under the MIT license. 1490 * http://jquery.org/license 1491 */ 1492 1493//>>label: Effects Core 1494//>>group: Effects 1495/* eslint-disable max-len */ 1496//>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects. 1497/* eslint-enable max-len */ 1498//>>docs: http://api.jqueryui.com/category/effects-core/ 1499//>>demos: http://jqueryui.com/effect/ 1500 1501 1502var dataSpace = "ui-effects-", 1503 dataSpaceStyle = "ui-effects-style", 1504 dataSpaceAnimated = "ui-effects-animated"; 1505 1506$.effects = { 1507 effect: {} 1508}; 1509 1510/******************************************************************************/ 1511/****************************** CLASS ANIMATIONS ******************************/ 1512/******************************************************************************/ 1513( function() { 1514 1515var classAnimationActions = [ "add", "remove", "toggle" ], 1516 shorthandStyles = { 1517 border: 1, 1518 borderBottom: 1, 1519 borderColor: 1, 1520 borderLeft: 1, 1521 borderRight: 1, 1522 borderTop: 1, 1523 borderWidth: 1, 1524 margin: 1, 1525 padding: 1 1526 }; 1527 1528$.each( 1529 [ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], 1530 function( _, prop ) { 1531 $.fx.step[ prop ] = function( fx ) { 1532 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) { 1533 jQuery.style( fx.elem, prop, fx.end ); 1534 fx.setAttr = true; 1535 } 1536 }; 1537 } 1538); 1539 1540function camelCase( string ) { 1541 return string.replace( /-([\da-z])/gi, function( all, letter ) { 1542 return letter.toUpperCase(); 1543 } ); 1544} 1545 1546function getElementStyles( elem ) { 1547 var key, len, 1548 style = elem.ownerDocument.defaultView ? 1549 elem.ownerDocument.defaultView.getComputedStyle( elem, null ) : 1550 elem.currentStyle, 1551 styles = {}; 1552 1553 if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) { 1554 len = style.length; 1555 while ( len-- ) { 1556 key = style[ len ]; 1557 if ( typeof style[ key ] === "string" ) { 1558 styles[ camelCase( key ) ] = style[ key ]; 1559 } 1560 } 1561 1562 // Support: Opera, IE <9 1563 } else { 1564 for ( key in style ) { 1565 if ( typeof style[ key ] === "string" ) { 1566 styles[ key ] = style[ key ]; 1567 } 1568 } 1569 } 1570 1571 return styles; 1572} 1573 1574function styleDifference( oldStyle, newStyle ) { 1575 var diff = {}, 1576 name, value; 1577 1578 for ( name in newStyle ) { 1579 value = newStyle[ name ]; 1580 if ( oldStyle[ name ] !== value ) { 1581 if ( !shorthandStyles[ name ] ) { 1582 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) { 1583 diff[ name ] = value; 1584 } 1585 } 1586 } 1587 } 1588 1589 return diff; 1590} 1591 1592// Support: jQuery <1.8 1593if ( !$.fn.addBack ) { 1594 $.fn.addBack = function( selector ) { 1595 return this.add( selector == null ? 1596 this.prevObject : this.prevObject.filter( selector ) 1597 ); 1598 }; 1599} 1600 1601$.effects.animateClass = function( value, duration, easing, callback ) { 1602 var o = $.speed( duration, easing, callback ); 1603 1604 return this.queue( function() { 1605 var animated = $( this ), 1606 baseClass = animated.attr( "class" ) || "", 1607 applyClassChange, 1608 allAnimations = o.children ? animated.find( "*" ).addBack() : animated; 1609 1610 // Map the animated objects to store the original styles. 1611 allAnimations = allAnimations.map( function() { 1612 var el = $( this ); 1613 return { 1614 el: el, 1615 start: getElementStyles( this ) 1616 }; 1617 } ); 1618 1619 // Apply class change 1620 applyClassChange = function() { 1621 $.each( classAnimationActions, function( i, action ) { 1622 if ( value[ action ] ) { 1623 animated[ action + "Class" ]( value[ action ] ); 1624 } 1625 } ); 1626 }; 1627 applyClassChange(); 1628 1629 // Map all animated objects again - calculate new styles and diff 1630 allAnimations = allAnimations.map( function() { 1631 this.end = getElementStyles( this.el[ 0 ] ); 1632 this.diff = styleDifference( this.start, this.end ); 1633 return this; 1634 } ); 1635 1636 // Apply original class 1637 animated.attr( "class", baseClass ); 1638 1639 // Map all animated objects again - this time collecting a promise 1640 allAnimations = allAnimations.map( function() { 1641 var styleInfo = this, 1642 dfd = $.Deferred(), 1643 opts = $.extend( {}, o, { 1644 queue: false, 1645 complete: function() { 1646 dfd.resolve( styleInfo ); 1647 } 1648 } ); 1649 1650 this.el.animate( this.diff, opts ); 1651 return dfd.promise(); 1652 } ); 1653 1654 // Once all animations have completed: 1655 $.when.apply( $, allAnimations.get() ).done( function() { 1656 1657 // Set the final class 1658 applyClassChange(); 1659 1660 // For each animated element, 1661 // clear all css properties that were animated 1662 $.each( arguments, function() { 1663 var el = this.el; 1664 $.each( this.diff, function( key ) { 1665 el.css( key, "" ); 1666 } ); 1667 } ); 1668 1669 // This is guarnteed to be there if you use jQuery.speed() 1670 // it also handles dequeuing the next anim... 1671 o.complete.call( animated[ 0 ] ); 1672 } ); 1673 } ); 1674}; 1675 1676$.fn.extend( { 1677 addClass: ( function( orig ) { 1678 return function( classNames, speed, easing, callback ) { 1679 return speed ? 1680 $.effects.animateClass.call( this, 1681 { add: classNames }, speed, easing, callback ) : 1682 orig.apply( this, arguments ); 1683 }; 1684 } )( $.fn.addClass ), 1685 1686 removeClass: ( function( orig ) { 1687 return function( classNames, speed, easing, callback ) { 1688 return arguments.length > 1 ? 1689 $.effects.animateClass.call( this, 1690 { remove: classNames }, speed, easing, callback ) : 1691 orig.apply( this, arguments ); 1692 }; 1693 } )( $.fn.removeClass ), 1694 1695 toggleClass: ( function( orig ) { 1696 return function( classNames, force, speed, easing, callback ) { 1697 if ( typeof force === "boolean" || force === undefined ) { 1698 if ( !speed ) { 1699 1700 // Without speed parameter 1701 return orig.apply( this, arguments ); 1702 } else { 1703 return $.effects.animateClass.call( this, 1704 ( force ? { add: classNames } : { remove: classNames } ), 1705 speed, easing, callback ); 1706 } 1707 } else { 1708 1709 // Without force parameter 1710 return $.effects.animateClass.call( this, 1711 { toggle: classNames }, force, speed, easing ); 1712 } 1713 }; 1714 } )( $.fn.toggleClass ), 1715 1716 switchClass: function( remove, add, speed, easing, callback ) { 1717 return $.effects.animateClass.call( this, { 1718 add: add, 1719 remove: remove 1720 }, speed, easing, callback ); 1721 } 1722} ); 1723 1724} )(); 1725 1726/******************************************************************************/ 1727/*********************************** EFFECTS **********************************/ 1728/******************************************************************************/ 1729 1730( function() { 1731 1732if ( $.expr && $.expr.pseudos && $.expr.pseudos.animated ) { 1733 $.expr.pseudos.animated = ( function( orig ) { 1734 return function( elem ) { 1735 return !!$( elem ).data( dataSpaceAnimated ) || orig( elem ); 1736 }; 1737 } )( $.expr.pseudos.animated ); 1738} 1739 1740if ( $.uiBackCompat !== false ) { 1741 $.extend( $.effects, { 1742 1743 // Saves a set of properties in a data storage 1744 save: function( element, set ) { 1745 var i = 0, length = set.length; 1746 for ( ; i < length; i++ ) { 1747 if ( set[ i ] !== null ) { 1748 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] ); 1749 } 1750 } 1751 }, 1752 1753 // Restores a set of previously saved properties from a data storage 1754 restore: function( element, set ) { 1755 var val, i = 0, length = set.length; 1756 for ( ; i < length; i++ ) { 1757 if ( set[ i ] !== null ) { 1758 val = element.data( dataSpace + set[ i ] ); 1759 element.css( set[ i ], val ); 1760 } 1761 } 1762 }, 1763 1764 setMode: function( el, mode ) { 1765 if ( mode === "toggle" ) { 1766 mode = el.is( ":hidden" ) ? "show" : "hide"; 1767 } 1768 return mode; 1769 }, 1770 1771 // Wraps the element around a wrapper that copies position properties 1772 createWrapper: function( element ) { 1773 1774 // If the element is already wrapped, return it 1775 if ( element.parent().is( ".ui-effects-wrapper" ) ) { 1776 return element.parent(); 1777 } 1778 1779 // Wrap the element 1780 var props = { 1781 width: element.outerWidth( true ), 1782 height: element.outerHeight( true ), 1783 "float": element.css( "float" ) 1784 }, 1785 wrapper = $( "<div></div>" ) 1786 .addClass( "ui-effects-wrapper" ) 1787 .css( { 1788 fontSize: "100%", 1789 background: "transparent", 1790 border: "none", 1791 margin: 0, 1792 padding: 0 1793 } ), 1794 1795 // Store the size in case width/height are defined in % - Fixes #5245 1796 size = { 1797 width: element.width(), 1798 height: element.height() 1799 }, 1800 active = document.activeElement; 1801 1802 // Support: Firefox 1803 // Firefox incorrectly exposes anonymous content 1804 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664 1805 try { 1806 // eslint-disable-next-line no-unused-expressions 1807 active.id; 1808 } catch ( e ) { 1809 active = document.body; 1810 } 1811 1812 element.wrap( wrapper ); 1813 1814 // Fixes #7595 - Elements lose focus when wrapped. 1815 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) { 1816 $( active ).trigger( "focus" ); 1817 } 1818 1819 // Hotfix for jQuery 1.4 since some change in wrap() seems to actually 1820 // lose the reference to the wrapped element 1821 wrapper = element.parent(); 1822 1823 // Transfer positioning properties to the wrapper 1824 if ( element.css( "position" ) === "static" ) { 1825 wrapper.css( { position: "relative" } ); 1826 element.css( { position: "relative" } ); 1827 } else { 1828 $.extend( props, { 1829 position: element.css( "position" ), 1830 zIndex: element.css( "z-index" ) 1831 } ); 1832 $.each( [ "top", "left", "bottom", "right" ], function( i, pos ) { 1833 props[ pos ] = element.css( pos ); 1834 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) { 1835 props[ pos ] = "auto"; 1836 } 1837 } ); 1838 element.css( { 1839 position: "relative", 1840 top: 0, 1841 left: 0, 1842 right: "auto", 1843 bottom: "auto" 1844 } ); 1845 } 1846 element.css( size ); 1847 1848 return wrapper.css( props ).show(); 1849 }, 1850 1851 removeWrapper: function( element ) { 1852 var active = document.activeElement; 1853 1854 if ( element.parent().is( ".ui-effects-wrapper" ) ) { 1855 element.parent().replaceWith( element ); 1856
vendor: 6,832 bytes, lines 1857-2137
1857 // Fixes #7595 - Elements lose focus when wrapped. 1858 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) { 1859 $( active ).trigger( "focus" ); 1860 } 1861 } 1862 1863 return element; 1864 } 1865 } ); 1866} 1867 1868$.extend( $.effects, { 1869 version: "1.13.0", 1870 1871 define: function( name, mode, effect ) { 1872 if ( !effect ) { 1873 effect = mode; 1874 mode = "effect"; 1875 } 1876 1877 $.effects.effect[ name ] = effect; 1878 $.effects.effect[ name ].mode = mode; 1879 1880 return effect; 1881 }, 1882 1883 scaledDimensions: function( element, percent, direction ) { 1884 if ( percent === 0 ) { 1885 return { 1886 height: 0, 1887 width: 0, 1888 outerHeight: 0, 1889 outerWidth: 0 1890 }; 1891 } 1892 1893 var x = direction !== "horizontal" ? ( ( percent || 100 ) / 100 ) : 1, 1894 y = direction !== "vertical" ? ( ( percent || 100 ) / 100 ) : 1; 1895 1896 return { 1897 height: element.height() * y, 1898 width: element.width() * x, 1899 outerHeight: element.outerHeight() * y, 1900 outerWidth: element.outerWidth() * x 1901 }; 1902 1903 }, 1904 1905 clipToBox: function( animation ) { 1906 return { 1907 width: animation.clip.right - animation.clip.left, 1908 height: animation.clip.bottom - animation.clip.top, 1909 left: animation.clip.left, 1910 top: animation.clip.top 1911 }; 1912 }, 1913 1914 // Injects recently queued functions to be first in line (after "inprogress") 1915 unshift: function( element, queueLength, count ) { 1916 var queue = element.queue(); 1917 1918 if ( queueLength > 1 ) { 1919 queue.splice.apply( queue, 1920 [ 1, 0 ].concat( queue.splice( queueLength, count ) ) ); 1921 } 1922 element.dequeue(); 1923 }, 1924 1925 saveStyle: function( element ) { 1926 element.data( dataSpaceStyle, element[ 0 ].style.cssText ); 1927 }, 1928 1929 restoreStyle: function( element ) { 1930 element[ 0 ].style.cssText = element.data( dataSpaceStyle ) || ""; 1931 element.removeData( dataSpaceStyle ); 1932 }, 1933 1934 mode: function( element, mode ) { 1935 var hidden = element.is( ":hidden" ); 1936 1937 if ( mode === "toggle" ) { 1938 mode = hidden ? "show" : "hide"; 1939 } 1940 if ( hidden ? mode === "hide" : mode === "show" ) { 1941 mode = "none"; 1942 } 1943 return mode; 1944 }, 1945 1946 // Translates a [top,left] array into a baseline value 1947 getBaseline: function( origin, original ) { 1948 var y, x; 1949 1950 switch ( origin[ 0 ] ) { 1951 case "top": 1952 y = 0; 1953 break; 1954 case "middle": 1955 y = 0.5; 1956 break; 1957 case "bottom": 1958 y = 1; 1959 break; 1960 default: 1961 y = origin[ 0 ] / original.height; 1962 } 1963 1964 switch ( origin[ 1 ] ) { 1965 case "left": 1966 x = 0; 1967 break; 1968 case "center": 1969 x = 0.5; 1970 break; 1971 case "right": 1972 x = 1; 1973 break; 1974 default: 1975 x = origin[ 1 ] / original.width; 1976 } 1977 1978 return { 1979 x: x, 1980 y: y 1981 }; 1982 }, 1983 1984 // Creates a placeholder element so that the original element can be made absolute 1985 createPlaceholder: function( element ) { 1986 var placeholder, 1987 cssPosition = element.css( "position" ), 1988 position = element.position(); 1989 1990 // Lock in margins first to account for form elements, which 1991 // will change margin if you explicitly set height 1992 // see: http://jsfiddle.net/JZSMt/3/ https://bugs.webkit.org/show_bug.cgi?id=107380 1993 // Support: Safari 1994 element.css( { 1995 marginTop: element.css( "marginTop" ), 1996 marginBottom: element.css( "marginBottom" ), 1997 marginLeft: element.css( "marginLeft" ), 1998 marginRight: element.css( "marginRight" ) 1999 } ) 2000 .outerWidth( element.outerWidth() ) 2001 .outerHeight( element.outerHeight() ); 2002 2003 if ( /^(static|relative)/.test( cssPosition ) ) { 2004 cssPosition = "absolute"; 2005 2006 placeholder = $( "<" + element[ 0 ].nodeName + ">" ).insertAfter( element ).css( { 2007 2008 // Convert inline to inline block to account for inline elements 2009 // that turn to inline block based on content (like img) 2010 display: /^(inline|ruby)/.test( element.css( "display" ) ) ? 2011 "inline-block" : 2012 "block", 2013 visibility: "hidden", 2014 2015 // Margins need to be set to account for margin collapse 2016 marginTop: element.css( "marginTop" ), 2017 marginBottom: element.css( "marginBottom" ), 2018 marginLeft: element.css( "marginLeft" ), 2019 marginRight: element.css( "marginRight" ), 2020 "float": element.css( "float" ) 2021 } ) 2022 .outerWidth( element.outerWidth() ) 2023 .outerHeight( element.outerHeight() ) 2024 .addClass( "ui-effects-placeholder" ); 2025 2026 element.data( dataSpace + "placeholder", placeholder ); 2027 } 2028 2029 element.css( { 2030 position: cssPosition, 2031 left: position.left, 2032 top: position.top 2033 } ); 2034 2035 return placeholder; 2036 }, 2037 2038 removePlaceholder: function( element ) { 2039 var dataKey = dataSpace + "placeholder", 2040 placeholder = element.data( dataKey ); 2041 2042 if ( placeholder ) { 2043 placeholder.remove(); 2044 element.removeData( dataKey ); 2045 } 2046 }, 2047 2048 // Removes a placeholder if it exists and restores 2049 // properties that were modified during placeholder creation 2050 cleanUp: function( element ) { 2051 $.effects.restoreStyle( element ); 2052 $.effects.removePlaceholder( element ); 2053 }, 2054 2055 setTransition: function( element, list, factor, value ) { 2056 value = value || {}; 2057 $.each( list, function( i, x ) { 2058 var unit = element.cssUnit( x ); 2059 if ( unit[ 0 ] > 0 ) { 2060 value[ x ] = unit[ 0 ] * factor + unit[ 1 ]; 2061 } 2062 } ); 2063 return value; 2064 } 2065} ); 2066 2067// Return an effect options object for the given parameters: 2068function _normalizeArguments( effect, options, speed, callback ) { 2069 2070 // Allow passing all options as the first parameter 2071 if ( $.isPlainObject( effect ) ) { 2072 options = effect; 2073 effect = effect.effect; 2074 } 2075 2076 // Convert to an object 2077 effect = { effect: effect }; 2078 2079 // Catch (effect, null, ...) 2080 if ( options == null ) { 2081 options = {}; 2082 } 2083 2084 // Catch (effect, callback) 2085 if ( typeof options === "function" ) { 2086 callback = options; 2087 speed = null; 2088 options = {}; 2089 } 2090 2091 // Catch (effect, speed, ?) 2092 if ( typeof options === "number" || $.fx.speeds[ options ] ) { 2093 callback = speed; 2094 speed = options; 2095 options = {}; 2096 } 2097 2098 // Catch (effect, options, callback) 2099 if ( typeof speed === "function" ) { 2100 callback = speed; 2101 speed = null; 2102 } 2103 2104 // Add options to effect 2105 if ( options ) { 2106 $.extend( effect, options ); 2107 } 2108 2109 speed = speed || options.duration; 2110 effect.duration = $.fx.off ? 0 : 2111 typeof speed === "number" ? speed : 2112 speed in $.fx.speeds ? $.fx.speeds[ speed ] : 2113 $.fx.speeds._default; 2114 2115 effect.complete = callback || options.complete; 2116 2117 return effect; 2118} 2119 2120function standardAnimationOption( option ) { 2121 2122 // Valid standard speeds (nothing, number, named speed) 2123 if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) { 2124 return true; 2125 } 2126 2127 // Invalid strings - treat as "normal" speed 2128 if ( typeof option === "string" && !$.effects.effect[ option ] ) { 2129 return true; 2130 } 2131 2132 // Complete callback 2133 if ( typeof option === "function" ) { 2134 return true; 2135 } 2136 2137 // Options hash (but not naming an effect)
vendor: 4,998 bytes, lines 2138-2321
2138 if ( typeof option === "object" && !option.effect ) { 2139 return true; 2140 } 2141 2142 // Didn't match any standard API 2143 return false; 2144} 2145 2146$.fn.extend( { 2147 effect: function( /* effect, options, speed, callback */ ) { 2148 var args = _normalizeArguments.apply( this, arguments ), 2149 effectMethod = $.effects.effect[ args.effect ], 2150 defaultMode = effectMethod.mode, 2151 queue = args.queue, 2152 queueName = queue || "fx", 2153 complete = args.complete, 2154 mode = args.mode, 2155 modes = [], 2156 prefilter = function( next ) { 2157 var el = $( this ), 2158 normalizedMode = $.effects.mode( el, mode ) || defaultMode; 2159 2160 // Sentinel for duck-punching the :animated pseudo-selector 2161 el.data( dataSpaceAnimated, true ); 2162 2163 // Save effect mode for later use, 2164 // we can't just call $.effects.mode again later, 2165 // as the .show() below destroys the initial state 2166 modes.push( normalizedMode ); 2167 2168 // See $.uiBackCompat inside of run() for removal of defaultMode in 1.14 2169 if ( defaultMode && ( normalizedMode === "show" || 2170 ( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) { 2171 el.show(); 2172 } 2173 2174 if ( !defaultMode || normalizedMode !== "none" ) { 2175 $.effects.saveStyle( el ); 2176 } 2177 2178 if ( typeof next === "function" ) { 2179 next(); 2180 } 2181 }; 2182 2183 if ( $.fx.off || !effectMethod ) { 2184 2185 // Delegate to the original method (e.g., .show()) if possible 2186 if ( mode ) { 2187 return this[ mode ]( args.duration, complete ); 2188 } else { 2189 return this.each( function() { 2190 if ( complete ) { 2191 complete.call( this ); 2192 } 2193 } ); 2194 } 2195 } 2196 2197 function run( next ) { 2198 var elem = $( this ); 2199 2200 function cleanup() { 2201 elem.removeData( dataSpaceAnimated ); 2202 2203 $.effects.cleanUp( elem ); 2204 2205 if ( args.mode === "hide" ) { 2206 elem.hide(); 2207 } 2208 2209 done(); 2210 } 2211 2212 function done() { 2213 if ( typeof complete === "function" ) { 2214 complete.call( elem[ 0 ] ); 2215 } 2216 2217 if ( typeof next === "function" ) { 2218 next(); 2219 } 2220 } 2221 2222 // Override mode option on a per element basis, 2223 // as toggle can be either show or hide depending on element state 2224 args.mode = modes.shift(); 2225 2226 if ( $.uiBackCompat !== false && !defaultMode ) { 2227 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) { 2228 2229 // Call the core method to track "olddisplay" properly 2230 elem[ mode ](); 2231 done(); 2232 } else { 2233 effectMethod.call( elem[ 0 ], args, done ); 2234 } 2235 } else { 2236 if ( args.mode === "none" ) { 2237 2238 // Call the core method to track "olddisplay" properly 2239 elem[ mode ](); 2240 done(); 2241 } else { 2242 effectMethod.call( elem[ 0 ], args, cleanup ); 2243 } 2244 } 2245 } 2246 2247 // Run prefilter on all elements first to ensure that 2248 // any showing or hiding happens before placeholder creation, 2249 // which ensures that any layout changes are correctly captured. 2250 return queue === false ? 2251 this.each( prefilter ).each( run ) : 2252 this.queue( queueName, prefilter ).queue( queueName, run ); 2253 }, 2254 2255 show: ( function( orig ) { 2256 return function( option ) { 2257 if ( standardAnimationOption( option ) ) { 2258 return orig.apply( this, arguments ); 2259 } else { 2260 var args = _normalizeArguments.apply( this, arguments ); 2261 args.mode = "show"; 2262 return this.effect.call( this, args ); 2263 } 2264 }; 2265 } )( $.fn.show ), 2266 2267 hide: ( function( orig ) { 2268 return function( option ) { 2269 if ( standardAnimationOption( option ) ) { 2270 return orig.apply( this, arguments ); 2271 } else { 2272 var args = _normalizeArguments.apply( this, arguments ); 2273 args.mode = "hide"; 2274 return this.effect.call( this, args ); 2275 } 2276 }; 2277 } )( $.fn.hide ), 2278 2279 toggle: ( function( orig ) { 2280 return function( option ) { 2281 if ( standardAnimationOption( option ) || typeof option === "boolean" ) { 2282 return orig.apply( this, arguments ); 2283 } else { 2284 var args = _normalizeArguments.apply( this, arguments ); 2285 args.mode = "toggle"; 2286 return this.effect.call( this, args ); 2287 } 2288 }; 2289 } )( $.fn.toggle ), 2290 2291 cssUnit: function( key ) { 2292 var style = this.css( key ), 2293 val = []; 2294 2295 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) { 2296 if ( style.indexOf( unit ) > 0 ) { 2297 val = [ parseFloat( style ), unit ]; 2298 } 2299 } ); 2300 return val; 2301 }, 2302 2303 cssClip: function( clipObj ) { 2304 if ( clipObj ) { 2305 return this.css( "clip", "rect(" + clipObj.top + "px " + clipObj.right + "px " + 2306 clipObj.bottom + "px " + clipObj.left + "px)" ); 2307 } 2308 return parseClip( this.css( "clip" ), this ); 2309 }, 2310 2311 transfer: function( options, done ) { 2312 var element = $( this ), 2313 target = $( options.to ), 2314 targetFixed = target.css( "position" ) === "fixed", 2315 body = $( "body" ), 2316 fixTop = targetFixed ? body.scrollTop() : 0, 2317 fixLeft = targetFixed ? body.scrollLeft() : 0, 2318 endPosition = target.offset(), 2319 animation = { 2320 top: endPosition.top - fixTop, 2321 left: endPosition.left - fixLeft,
vendor: 3,315 bytes, lines 2322-2438
2322 height: target.innerHeight(), 2323 width: target.innerWidth() 2324 }, 2325 startPosition = element.offset(), 2326 transfer = $( "<div class='ui-effects-transfer'></div>" ); 2327 2328 transfer 2329 .appendTo( "body" ) 2330 .addClass( options.className ) 2331 .css( { 2332 top: startPosition.top - fixTop, 2333 left: startPosition.left - fixLeft, 2334 height: element.innerHeight(), 2335 width: element.innerWidth(), 2336 position: targetFixed ? "fixed" : "absolute" 2337 } ) 2338 .animate( animation, options.duration, options.easing, function() { 2339 transfer.remove(); 2340 if ( typeof done === "function" ) { 2341 done(); 2342 } 2343 } ); 2344 } 2345} ); 2346 2347function parseClip( str, element ) { 2348 var outerWidth = element.outerWidth(), 2349 outerHeight = element.outerHeight(), 2350 clipRegex = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/, 2351 values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ]; 2352 2353 return { 2354 top: parseFloat( values[ 1 ] ) || 0, 2355 right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ), 2356 bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ), 2357 left: parseFloat( values[ 4 ] ) || 0 2358 }; 2359} 2360 2361$.fx.step.clip = function( fx ) { 2362 if ( !fx.clipInit ) { 2363 fx.start = $( fx.elem ).cssClip(); 2364 if ( typeof fx.end === "string" ) { 2365 fx.end = parseClip( fx.end, fx.elem ); 2366 } 2367 fx.clipInit = true; 2368 } 2369 2370 $( fx.elem ).cssClip( { 2371 top: fx.pos * ( fx.end.top - fx.start.top ) + fx.start.top, 2372 right: fx.pos * ( fx.end.right - fx.start.right ) + fx.start.right, 2373 bottom: fx.pos * ( fx.end.bottom - fx.start.bottom ) + fx.start.bottom, 2374 left: fx.pos * ( fx.end.left - fx.start.left ) + fx.start.left 2375 } ); 2376}; 2377 2378} )(); 2379 2380/******************************************************************************/ 2381/*********************************** EASING ***********************************/ 2382/******************************************************************************/ 2383 2384( function() { 2385 2386// Based on easing equations from Robert Penner (http://www.robertpenner.com/easing) 2387 2388var baseEasings = {}; 2389 2390$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) { 2391 baseEasings[ name ] = function( p ) { 2392 return Math.pow( p, i + 2 ); 2393 }; 2394} ); 2395 2396$.extend( baseEasings, { 2397 Sine: function( p ) { 2398 return 1 - Math.cos( p * Math.PI / 2 ); 2399 }, 2400 Circ: function( p ) { 2401 return 1 - Math.sqrt( 1 - p * p ); 2402 }, 2403 Elastic: function( p ) { 2404 return p === 0 || p === 1 ? p : 2405 -Math.pow( 2, 8 * ( p - 1 ) ) * Math.sin( ( ( p - 1 ) * 80 - 7.5 ) * Math.PI / 15 ); 2406 }, 2407 Back: function( p ) { 2408 return p * p * ( 3 * p - 2 ); 2409 }, 2410 Bounce: function( p ) { 2411 var pow2, 2412 bounce = 4; 2413 2414 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {} 2415 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 ); 2416 } 2417} ); 2418 2419$.each( baseEasings, function( name, easeIn ) { 2420 $.easing[ "easeIn" + name ] = easeIn; 2421 $.easing[ "easeOut" + name ] = function( p ) { 2422 return 1 - easeIn( 1 - p ); 2423 }; 2424 $.easing[ "easeInOut" + name ] = function( p ) { 2425 return p < 0.5 ? 2426 easeIn( p * 2 ) / 2 : 2427 1 - easeIn( p * -2 + 2 ) / 2; 2428 }; 2429} ); 2430 2431} )(); 2432 2433var effect = $.effects; 2434 2435 2436 2437 2438} );
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.