vendor: 15,816 bytes, lines 1-554
1/*! jQuery UI - v1.11.4+CommonJS - 2015-08-28 2* http://jqueryui.com 3* Includes: widget.js 4* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */ 5 6(function( factory ) { 7 if ( typeof define === "function" && define.amd ) { 8 9 // AMD. Register as an anonymous module. 10 define([ "jquery" ], factory ); 11 12 } else if ( typeof exports === "object" ) { 13 14 // Node/CommonJS 15 factory( require( "jquery" ) ); 16 17 } else { 18 19 // Browser globals 20 factory( jQuery ); 21 } 22}(function( $ ) { 23/*! 24 * jQuery UI Widget 1.11.4 25 * http://jqueryui.com 26 * 27 * Copyright jQuery Foundation and other contributors 28 * Released under the MIT license. 29 * http://jquery.org/license 30 * 31 * http://api.jqueryui.com/jQuery.widget/ 32 */ 33 34 35var widget_uuid = 0, 36 widget_slice = Array.prototype.slice; 37 38$.cleanData = (function( orig ) { 39 return function( elems ) { 40 var events, elem, i; 41 for ( i = 0; (elem = elems[i]) != null; i++ ) { 42 try { 43 44 // Only trigger remove when necessary to save time 45 events = $._data( elem, "events" ); 46 if ( events && events.remove ) { 47 $( elem ).triggerHandler( "remove" ); 48 } 49 50 // http://bugs.jquery.com/ticket/8235 51 } catch ( e ) {} 52 } 53 orig( elems ); 54 }; 55})( $.cleanData ); 56 57$.widget = function( name, base, prototype ) { 58 var fullName, existingConstructor, constructor, basePrototype, 59 // proxiedPrototype allows the provided prototype to remain unmodified 60 // so that it can be used as a mixin for multiple widgets (#8876) 61 proxiedPrototype = {}, 62 namespace = name.split( "." )[ 0 ]; 63 64 name = name.split( "." )[ 1 ]; 65 fullName = namespace + "-" + name; 66 67 if ( !prototype ) { 68 prototype = base; 69 base = $.Widget; 70 } 71 72 // create selector for plugin 73 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) { 74 return !!$.data( elem, fullName ); 75 }; 76 77 $[ namespace ] = $[ namespace ] || {}; 78 existingConstructor = $[ namespace ][ name ]; 79 constructor = $[ namespace ][ name ] = function( options, element ) { 80 // allow instantiation without "new" keyword 81 if ( !this._createWidget ) { 82 return new constructor( options, element ); 83 } 84 85 // allow instantiation without initializing for simple inheritance 86 // must use "new" keyword (the code above always passes args) 87 if ( arguments.length ) { 88 this._createWidget( options, element ); 89 } 90 }; 91 // extend with the existing constructor to carry over any static properties 92 $.extend( constructor, existingConstructor, { 93 version: prototype.version, 94 // copy the object used to create the prototype in case we need to 95 // redefine the widget later 96 _proto: $.extend( {}, prototype ), 97 // track widgets that inherit from this widget in case this widget is 98 // redefined after a widget inherits from it 99 _childConstructors: [] 100 }); 101 102 basePrototype = new base(); 103 // we need to make the options hash a property directly on the new instance 104 // otherwise we'll modify the options hash on the prototype that we're 105 // inheriting from 106 basePrototype.options = $.widget.extend( {}, basePrototype.options ); 107 $.each( prototype, function( prop, value ) { 108 if ( !$.isFunction( value ) ) { 109 proxiedPrototype[ prop ] = value; 110 return; 111 } 112 proxiedPrototype[ prop ] = (function() { 113 var _super = function() { 114 return base.prototype[ prop ].apply( this, arguments ); 115 }, 116 _superApply = function( args ) { 117 return base.prototype[ prop ].apply( this, args ); 118 }; 119 return function() { 120 var __super = this._super, 121 __superApply = this._superApply, 122 returnValue; 123 124 this._super = _super; 125 this._superApply = _superApply; 126 127 returnValue = value.apply( this, arguments ); 128 129 this._super = __super; 130 this._superApply = __superApply; 131 132 return returnValue; 133 }; 134 })(); 135 }); 136 constructor.prototype = $.widget.extend( basePrototype, { 137 // TODO: remove support for widgetEventPrefix 138 // always use the name + a colon as the prefix, e.g., draggable:start 139 // don't prefix for widgets that aren't DOM-based 140 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name 141 }, proxiedPrototype, { 142 constructor: constructor, 143 namespace: namespace, 144 widgetName: name, 145 widgetFullName: fullName 146 }); 147 148 // If this widget is being redefined then we need to find all widgets that 149 // are inheriting from it and redefine all of them so that they inherit from 150 // the new version of this widget. We're essentially trying to replace one 151 // level in the prototype chain. 152 if ( existingConstructor ) { 153 $.each( existingConstructor._childConstructors, function( i, child ) { 154 var childPrototype = child.prototype; 155 156 // redefine the child widget using the same prototype that was 157 // originally used, but inherit from the new version of the base 158 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto ); 159 }); 160 // remove the list of existing child constructors from the old constructor 161 // so the old child constructors can be garbage collected 162 delete existingConstructor._childConstructors; 163 } else { 164 base._childConstructors.push( constructor ); 165 } 166 167 $.widget.bridge( name, constructor ); 168 169 return constructor; 170}; 171 172$.widget.extend = function( target ) { 173 var input = widget_slice.call( arguments, 1 ), 174 inputIndex = 0, 175 inputLength = input.length, 176 key, 177 value; 178 for ( ; inputIndex < inputLength; inputIndex++ ) { 179 for ( key in input[ inputIndex ] ) { 180 value = input[ inputIndex ][ key ]; 181 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) { 182 // Clone objects 183 if ( $.isPlainObject( value ) ) { 184 target[ key ] = $.isPlainObject( target[ key ] ) ? 185 $.widget.extend( {}, target[ key ], value ) : 186 // Don't extend strings, arrays, etc. with objects 187 $.widget.extend( {}, value ); 188 // Copy everything else by reference 189 } else { 190 target[ key ] = value; 191 } 192 } 193 } 194 } 195 return target; 196}; 197 198$.widget.bridge = function( name, object ) { 199 var fullName = object.prototype.widgetFullName || name; 200 $.fn[ name ] = function( options ) { 201 var isMethodCall = typeof options === "string", 202 args = widget_slice.call( arguments, 1 ), 203 returnValue = this; 204 205 if ( isMethodCall ) { 206 this.each(function() { 207 var methodValue, 208 instance = $.data( this, fullName ); 209 if ( options === "instance" ) { 210 returnValue = instance; 211 return false; 212 } 213 if ( !instance ) { 214 return $.error( "cannot call methods on " + name + " prior to initialization; " + 215 "attempted to call method '" + options + "'" ); 216 } 217 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) { 218 return $.error( "no such method '" + options + "' for " + name + " widget instance" ); 219 } 220 methodValue = instance[ options ].apply( instance, args ); 221 if ( methodValue !== instance && methodValue !== undefined ) { 222 returnValue = methodValue && methodValue.jquery ? 223 returnValue.pushStack( methodValue.get() ) : 224 methodValue; 225 return false; 226 } 227 }); 228 } else { 229 230 // Allow multiple hashes to be passed on init 231 if ( args.length ) { 232 options = $.widget.extend.apply( null, [ options ].concat(args) ); 233 } 234 235 this.each(function() { 236 var instance = $.data( this, fullName ); 237 if ( instance ) { 238 instance.option( options || {} ); 239 if ( instance._init ) { 240 instance._init(); 241 } 242 } else { 243 $.data( this, fullName, new object( options, this ) ); 244 } 245 }); 246 } 247 248 return returnValue; 249 }; 250}; 251 252$.Widget = function( /* options, element */ ) {}; 253$.Widget._childConstructors = []; 254 255$.Widget.prototype = { 256 widgetName: "widget", 257 widgetEventPrefix: "", 258 defaultElement: "<div>", 259 options: { 260 disabled: false, 261 262 // callbacks 263 create: null 264 }, 265 _createWidget: function( options, element ) { 266 element = $( element || this.defaultElement || this )[ 0 ]; 267 this.element = $( element ); 268 this.uuid = widget_uuid++; 269 this.eventNamespace = "." + this.widgetName + this.uuid; 270 271 this.bindings = $(); 272 this.hoverable = $(); 273 this.focusable = $(); 274 275 if ( element !== this ) { 276 $.data( element, this.widgetFullName, this ); 277 this._on( true, this.element, { 278 remove: function( event ) { 279 if ( event.target === element ) { 280 this.destroy(); 281 } 282 } 283 }); 284 this.document = $( element.style ? 285 // element within the document 286 element.ownerDocument : 287 // element is window or document 288 element.document || element ); 289 this.window = $( this.document[0].defaultView || this.document[0].parentWindow ); 290 } 291 292 this.options = $.widget.extend( {}, 293 this.options, 294 this._getCreateOptions(), 295 options ); 296 297 this._create(); 298 this._trigger( "create", null, this._getCreateEventData() ); 299 this._init(); 300 }, 301 _getCreateOptions: $.noop, 302 _getCreateEventData: $.noop, 303 _create: $.noop, 304 _init: $.noop, 305 306 destroy: function() { 307 this._destroy(); 308 // we can probably remove the unbind calls in 2.0 309 // all event bindings should go through this._on() 310 this.element 311 .unbind( this.eventNamespace ) 312 .removeData( this.widgetFullName ) 313 // support: jquery <1.6.3 314 // http://bugs.jquery.com/ticket/9413 315 .removeData( $.camelCase( this.widgetFullName ) ); 316 this.widget() 317 .unbind( this.eventNamespace ) 318 .removeAttr( "aria-disabled" ) 319 .removeClass( 320 this.widgetFullName + "-disabled " + 321 "ui-state-disabled" ); 322 323 // clean up events and states 324 this.bindings.unbind( this.eventNamespace ); 325 this.hoverable.removeClass( "ui-state-hover" ); 326 this.focusable.removeClass( "ui-state-focus" ); 327 }, 328 _destroy: $.noop, 329 330 widget: function() { 331 return this.element; 332 }, 333 334 option: function( key, value ) { 335 var options = key, 336 parts, 337 curOption, 338 i; 339 340 if ( arguments.length === 0 ) { 341 // don't return a reference to the internal hash 342 return $.widget.extend( {}, this.options ); 343 } 344 345 if ( typeof key === "string" ) { 346 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } } 347 options = {}; 348 parts = key.split( "." ); 349 key = parts.shift(); 350 if ( parts.length ) { 351 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] ); 352 for ( i = 0; i < parts.length - 1; i++ ) { 353 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {}; 354 curOption = curOption[ parts[ i ] ]; 355 } 356 key = parts.pop(); 357 if ( arguments.length === 1 ) { 358 return curOption[ key ] === undefined ? null : curOption[ key ]; 359 } 360 curOption[ key ] = value; 361 } else { 362 if ( arguments.length === 1 ) { 363 return this.options[ key ] === undefined ? null : this.options[ key ]; 364 } 365 options[ key ] = value; 366 } 367 } 368 369 this._setOptions( options ); 370 371 return this; 372 }, 373 _setOptions: function( options ) { 374 var key; 375 376 for ( key in options ) { 377 this._setOption( key, options[ key ] ); 378 } 379 380 return this; 381 }, 382 _setOption: function( key, value ) { 383 this.options[ key ] = value; 384 385 if ( key === "disabled" ) { 386 this.widget() 387 .toggleClass( this.widgetFullName + "-disabled", !!value ); 388 389 // If the widget is becoming disabled, then nothing is interactive 390 if ( value ) { 391 this.hoverable.removeClass( "ui-state-hover" ); 392 this.focusable.removeClass( "ui-state-focus" ); 393 } 394 } 395 396 return this; 397 }, 398 399 enable: function() { 400 return this._setOptions({ disabled: false }); 401 }, 402 disable: function() { 403 return this._setOptions({ disabled: true }); 404 }, 405 406 _on: function( suppressDisabledCheck, element, handlers ) { 407 var delegateElement, 408 instance = this; 409 410 // no suppressDisabledCheck flag, shuffle arguments 411 if ( typeof suppressDisabledCheck !== "boolean" ) { 412 handlers = element; 413 element = suppressDisabledCheck; 414 suppressDisabledCheck = false; 415 } 416 417 // no element argument, shuffle and use this.element 418 if ( !handlers ) { 419 handlers = element; 420 element = this.element; 421 delegateElement = this.widget(); 422 } else { 423 element = delegateElement = $( element ); 424 this.bindings = this.bindings.add( element ); 425 } 426 427 $.each( handlers, function( event, handler ) { 428 function handlerProxy() { 429 // allow widgets to customize the disabled handling 430 // - disabled as an array instead of boolean 431 // - disabled class as method for disabling individual parts 432 if ( !suppressDisabledCheck && 433 ( instance.options.disabled === true || 434 $( this ).hasClass( "ui-state-disabled" ) ) ) { 435 return; 436 } 437 return ( typeof handler === "string" ? instance[ handler ] : handler ) 438 .apply( instance, arguments ); 439 } 440 441 // copy the guid so direct unbinding works 442 if ( typeof handler !== "string" ) { 443 handlerProxy.guid = handler.guid = 444 handler.guid || handlerProxy.guid || $.guid++; 445 } 446 447 var match = event.match( /^([\w:-]*)\s*(.*)$/ ), 448 eventName = match[1] + instance.eventNamespace, 449 selector = match[2]; 450 if ( selector ) { 451 delegateElement.delegate( selector, eventName, handlerProxy ); 452 } else { 453 element.bind( eventName, handlerProxy ); 454 } 455 }); 456 }, 457 458 _off: function( element, eventName ) { 459 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + 460 this.eventNamespace; 461 element.unbind( eventName ).undelegate( eventName ); 462 463 // Clear the stack to avoid memory leaks (#10056) 464 this.bindings = $( this.bindings.not( element ).get() ); 465 this.focusable = $( this.focusable.not( element ).get() ); 466 this.hoverable = $( this.hoverable.not( element ).get() ); 467 }, 468 469 _delay: function( handler, delay ) { 470 function handlerProxy() { 471 return ( typeof handler === "string" ? instance[ handler ] : handler ) 472 .apply( instance, arguments ); 473 } 474 var instance = this; 475 return setTimeout( handlerProxy, delay || 0 ); 476 }, 477 478 _hoverable: function( element ) { 479 this.hoverable = this.hoverable.add( element ); 480 this._on( element, { 481 mouseenter: function( event ) { 482 $( event.currentTarget ).addClass( "ui-state-hover" ); 483 }, 484 mouseleave: function( event ) { 485 $( event.currentTarget ).removeClass( "ui-state-hover" ); 486 } 487 }); 488 }, 489 490 _focusable: function( element ) { 491 this.focusable = this.focusable.add( element ); 492 this._on( element, { 493 focusin: function( event ) { 494 $( event.currentTarget ).addClass( "ui-state-focus" ); 495 }, 496 focusout: function( event ) { 497 $( event.currentTarget ).removeClass( "ui-state-focus" ); 498 } 499 }); 500 }, 501 502 _trigger: function( type, event, data ) { 503 var prop, orig, 504 callback = this.options[ type ]; 505 506 data = data || {}; 507 event = $.Event( event ); 508 event.type = ( type === this.widgetEventPrefix ? 509 type : 510 this.widgetEventPrefix + type ).toLowerCase(); 511 // the original event may come from any element 512 // so we need to reset the target on the new event 513 event.target = this.element[ 0 ]; 514 515 // copy original event properties over to the new event 516 orig = event.originalEvent; 517 if ( orig ) { 518 for ( prop in orig ) { 519 if ( !( prop in event ) ) { 520 event[ prop ] = orig[ prop ]; 521 } 522 } 523 } 524 525 this.element.trigger( event, data ); 526 return !( $.isFunction( callback ) && 527 callback.apply( this.element[0], [ event ].concat( data ) ) === false || 528 event.isDefaultPrevented() ); 529 } 530}; 531 532$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) { 533 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) { 534 if ( typeof options === "string" ) { 535 options = { effect: options }; 536 } 537 var hasOptions, 538 effectName = !options ? 539 method : 540 options === true || typeof options === "number" ? 541 defaultEffect : 542 options.effect || defaultEffect; 543 options = options || {}; 544 if ( typeof options === "number" ) { 545 options = { duration: options }; 546 } 547 hasOptions = !$.isEmptyObject( options ); 548 options.complete = callback; 549 if ( options.delay ) { 550 element.delay( options.delay ); 551 } 552 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) { 553 element[ method ]( options ); 554 } else if ( effectName !== method && element[ effectName ] ) {
555 element[ effectName ]( options.duration, options.easing, callback ); 556 } else { 557 element.queue(function( next ) { 558 $( this )[ method ](); 559 if ( callback ) { 560 callback.call( element[ 0 ] ); 561 } 562 next(); 563 }); 564 } 565 }; 566}); 567 568var widget = $.widget; 569 570 571 572}));
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.