js/jquery/jquery-1.6.1.js

   1 /*!
   2  * jQuery JavaScript Library v1.6.1
   3  * http://jquery.com/
   4  *
   5  * Copyright 2011, John Resig
   6  * Dual licensed under the MIT or GPL Version 2 licenses.
   7  * http://jquery.org/license
   8  *
   9  * Includes Sizzle.js
  10  * http://sizzlejs.com/
  11  * Copyright 2011, The Dojo Foundation
  12  * Released under the MIT, BSD, and GPL Licenses.
  13  *
  14  * Date: Thu May 12 15:04:36 2011 -0400
  15  */
  16 (function( window, undefined ) {
  17
  18 // Use the correct document accordingly with window argument (sandbox)
  19 var document = window.document,
  20         navigator = window.navigator,
  21         location = window.location;
  22 var jQuery = (function() {
  23
  24 // Define a local copy of jQuery
  25 var jQuery = function( selector, context ) {
  26                 // The jQuery object is actually just the init constructor 'enhanced'
  27                 return new jQuery.fn.init( selector, context, rootjQuery );
  28         },
  29
  30         // Map over jQuery in case of overwrite
  31         _jQuery = window.jQuery,
  32
  33         // Map over the $ in case of overwrite
  34         _$ = window.$,
  35
  36         // A central reference to the root jQuery(document)
  37         rootjQuery,
  38
  39         // A simple way to check for HTML strings or ID strings
  40         // (both of which we optimize for)
  41         quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
  42
  43         // Check if a string has a non-whitespace character in it
  44         rnotwhite = /\S/,
  45
  46         // Used for trimming whitespace
  47         trimLeft = /^\s+/,
  48         trimRight = /\s+$/,
  49
  50         // Check for digits
  51         rdigit = /\d/,
  52
  53         // Match a standalone tag
  54         rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
  55
  56         // JSON RegExp
  57         rvalidchars = /^[\],:{}\s]*$/,
  58         rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  59         rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  60         rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
  61
  62         // Useragent RegExp
  63         rwebkit = /(webkit)[ \/]([\w.]+)/,
  64         ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
  65         rmsie = /(msie) ([\w.]+)/,
  66         rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
  67
  68         // Keep a UserAgent string for use with jQuery.browser
  69         userAgent = navigator.userAgent,
  70
  71         // For matching the engine and version of the browser
  72         browserMatch,
  73
  74         // The deferred used on DOM ready
  75         readyList,
  76
  77         // The ready event handler
  78         DOMContentLoaded,
  79
  80         // Save a reference to some core methods
  81         toString = Object.prototype.toString,
  82         hasOwn = Object.prototype.hasOwnProperty,
  83         push = Array.prototype.push,
  84         slice = Array.prototype.slice,
  85         trim = String.prototype.trim,
  86         indexOf = Array.prototype.indexOf,
  87
  88         // [[Class]] -> type pairs
  89         class2type = {};
  90
  91 jQuery.fn = jQuery.prototype = {
  92         constructor: jQuery,
  93         init: function( selector, context, rootjQuery ) {
  94                 var match, elem, ret, doc;
  95
  96                 // Handle $(""), $(null), or $(undefined)
  97                 if ( !selector ) {
  98                         return this;
  99                 }
 100
 101                 // Handle $(DOMElement)
 102                 if ( selector.nodeType ) {
 103                         this.context = this[0] = selector;
 104                         this.length = 1;
 105                         return this;
 106                 }
 107
 108                 // The body element only exists once, optimize finding it
 109                 if ( selector === "body" && !context && document.body ) {
 110                         this.context = document;
 111                         this[0] = document.body;
 112                         this.selector = selector;
 113                         this.length = 1;
 114                         return this;
 115                 }
 116
 117                 // Handle HTML strings
 118                 if ( typeof selector === "string" ) {
 119                         // Are we dealing with HTML string or an ID?
 120                         if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
 121                                 // Assume that strings that start and end with <> are HTML and skip the regex check
 122                                 match = [ null, selector, null ];
 123
 124                         } else {
 125                                 match = quickExpr.exec( selector );
 126                         }
 127
 128                         // Verify a match, and that no context was specified for #id
 129                         if ( match && (match[1] || !context) ) {
 130
 131                                 // HANDLE: $(html) -> $(array)
 132                                 if ( match[1] ) {
 133                                         context = context instanceof jQuery ? context[0] : context;
 134                                         doc = (context ? context.ownerDocument || context : document);
 135
 136                                         // If a single string is passed in and it's a single tag
 137                                         // just do a createElement and skip the rest
 138                                         ret = rsingleTag.exec( selector );
 139
 140                                         if ( ret ) {
 141                                                 if ( jQuery.isPlainObject( context ) ) {
 142                                                         selector = [ document.createElement( ret[1] ) ];
 143                                                         jQuery.fn.attr.call( selector, context, true );
 144
 145                                                 } else {
 146                                                         selector = [ doc.createElement( ret[1] ) ];
 147                                                 }
 148
 149                                         } else {
 150                                                 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
 151                                                 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
 152                                         }
 153
 154                                         return jQuery.merge( this, selector );
 155
 156                                 // HANDLE: $("#id")
 157                                 } else {
 158                                         elem = document.getElementById( match[2] );
 159
 160                                         // Check parentNode to catch when Blackberry 4.6 returns
 161                                         // nodes that are no longer in the document #6963
 162                                         if ( elem && elem.parentNode ) {
 163                                                 // Handle the case where IE and Opera return items
 164                                                 // by name instead of ID
 165                                                 if ( elem.id !== match[2] ) {
 166                                                         return rootjQuery.find( selector );
 167                                                 }
 168
 169                                                 // Otherwise, we inject the element directly into the jQuery object
 170                                                 this.length = 1;
 171                                                 this[0] = elem;
 172                                         }
 173
 174                                         this.context = document;
 175                                         this.selector = selector;
 176                                         return this;
 177                                 }
 178
 179                         // HANDLE: $(expr, $(...))
 180                         } else if ( !context || context.jquery ) {
 181                                 return (context || rootjQuery).find( selector );
 182
 183                         // HANDLE: $(expr, context)
 184                         // (which is just equivalent to: $(context).find(expr)
 185                         } else {
 186                                 return this.constructor( context ).find( selector );
 187                         }
 188
 189                 // HANDLE: $(function)
 190                 // Shortcut for document ready
 191                 } else if ( jQuery.isFunction( selector ) ) {
 192                         return rootjQuery.ready( selector );
 193                 }
 194
 195                 if (selector.selector !== undefined) {
 196                         this.selector = selector.selector;
 197                         this.context = selector.context;
 198                 }
 199
 200                 return jQuery.makeArray( selector, this );
 201         },
 202
 203         // Start with an empty selector
 204         selector: "",
 205
 206         // The current version of jQuery being used
 207         jquery: "1.6.1",
 208
 209         // The default length of a jQuery object is 0
 210         length: 0,
 211
 212         // The number of elements contained in the matched element set
 213         size: function() {
 214                 return this.length;
 215         },
 216
 217         toArray: function() {
 218                 return slice.call( this, 0 );
 219         },
 220
 221         // Get the Nth element in the matched element set OR
 222         // Get the whole matched element set as a clean array
 223         get: function( num ) {
 224                 return num == null ?
 225
 226                         // Return a 'clean' array
 227                         this.toArray() :
 228
 229                         // Return just the object
 230                         ( num < 0 ? this[ this.length + num ] : this[ num ] );
 231         },
 232
 233         // Take an array of elements and push it onto the stack
 234         // (returning the new matched element set)
 235         pushStack: function( elems, name, selector ) {
 236                 // Build a new jQuery matched element set
 237                 var ret = this.constructor();
 238
 239                 if ( jQuery.isArray( elems ) ) {
 240                         push.apply( ret, elems );
 241
 242                 } else {
 243                         jQuery.merge( ret, elems );
 244                 }
 245
 246                 // Add the old object onto the stack (as a reference)
 247                 ret.prevObject = this;
 248
 249                 ret.context = this.context;
 250
 251                 if ( name === "find" ) {
 252                         ret.selector = this.selector + (this.selector ? " " : "") + selector;
 253                 } else if ( name ) {
 254                         ret.selector = this.selector + "." + name + "(" + selector + ")";
 255                 }
 256
 257                 // Return the newly-formed element set
 258                 return ret;
 259         },
 260
 261         // Execute a callback for every element in the matched set.
 262         // (You can seed the arguments with an array of args, but this is
 263         // only used internally.)
 264         each: function( callback, args ) {
 265                 return jQuery.each( this, callback, args );
 266         },
 267
 268         ready: function( fn ) {
 269                 // Attach the listeners
 270                 jQuery.bindReady();
 271
 272                 // Add the callback
 273                 readyList.done( fn );
 274
 275                 return this;
 276         },
 277
 278         eq: function( i ) {
 279                 return i === -1 ?
 280                         this.slice( i ) :
 281                         this.slice( i, +i + 1 );
 282         },
 283
 284         first: function() {
 285                 return this.eq( 0 );
 286         },
 287
 288         last: function() {
 289                 return this.eq( -1 );
 290         },
 291
 292         slice: function() {
 293                 return this.pushStack( slice.apply( this, arguments ),
 294                         "slice", slice.call(arguments).join(",") );
 295         },
 296
 297         map: function( callback ) {
 298                 return this.pushStack( jQuery.map(this, function( elem, i ) {
 299                         return callback.call( elem, i, elem );
 300                 }));
 301         },
 302
 303         end: function() {
 304                 return this.prevObject || this.constructor(null);
 305         },
 306
 307         // For internal use only.
 308         // Behaves like an Array's method, not like a jQuery method.
 309         push: push,
 310         sort: [].sort,
 311         splice: [].splice
 312 };
 313
 314 // Give the init function the jQuery prototype for later instantiation
 315 jQuery.fn.init.prototype = jQuery.fn;
 316
 317 jQuery.extend = jQuery.fn.extend = function() {
 318         var options, name, src, copy, copyIsArray, clone,
 319                 target = arguments[0] || {},
 320                 i = 1,
 321                 length = arguments.length,
 322                 deep = false;
 323
 324         // Handle a deep copy situation
 325         if ( typeof target === "boolean" ) {
 326                 deep = target;
 327                 target = arguments[1] || {};
 328                 // skip the boolean and the target
 329                 i = 2;
 330         }
 331
 332         // Handle case when target is a string or something (possible in deep copy)
 333         if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
 334                 target = {};
 335         }
 336
 337         // extend jQuery itself if only one argument is passed
 338         if ( length === i ) {
 339                 target = this;
 340                 --i;
 341         }
 342
 343         for ( ; i < length; i++ ) {
 344                 // Only deal with non-null/undefined values
 345                 if ( (options = arguments[ i ]) != null ) {
 346                         // Extend the base object
 347                         for ( name in options ) {
 348                                 src = target[ name ];
 349                                 copy = options[ name ];
 350
 351                                 // Prevent never-ending loop
 352                                 if ( target === copy ) {
 353                                         continue;
 354                                 }
 355
 356                                 // Recurse if we're merging plain objects or arrays
 357                                 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
 358                                         if ( copyIsArray ) {
 359                                                 copyIsArray = false;
 360                                                 clone = src && jQuery.isArray(src) ? src : [];
 361
 362                                         } else {
 363                                                 clone = src && jQuery.isPlainObject(src) ? src : {};
 364                                         }
 365
 366                                         // Never move original objects, clone them
 367                                         target[ name ] = jQuery.extend( deep, clone, copy );
 368
 369                                 // Don't bring in undefined values
 370                                 } else if ( copy !== undefined ) {
 371                                         target[ name ] = copy;
 372                                 }
 373                         }
 374                 }
 375         }
 376
 377         // Return the modified object
 378         return target;
 379 };
 380
 381 jQuery.extend({
 382         noConflict: function( deep ) {
 383                 if ( window.$ === jQuery ) {
 384                         window.$ = _$;
 385                 }
 386
 387                 if ( deep && window.jQuery === jQuery ) {
 388                         window.jQuery = _jQuery;
 389                 }
 390
 391                 return jQuery;
 392         },
 393
 394         // Is the DOM ready to be used? Set to true once it occurs.
 395         isReady: false,
 396
 397         // A counter to track how many items to wait for before
 398         // the ready event fires. See #6781
 399         readyWait: 1,
 400
 401         // Hold (or release) the ready event
 402         holdReady: function( hold ) {
 403                 if ( hold ) {
 404                         jQuery.readyWait++;
 405                 } else {
 406                         jQuery.ready( true );
 407                 }
 408         },
 409
 410         // Handle when the DOM is ready
 411         ready: function( wait ) {
 412                 // Either a released hold or an DOMready/load event and not yet ready
 413                 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
 414                         // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
 415                         if ( !document.body ) {
 416                                 return setTimeout( jQuery.ready, 1 );
 417                         }
 418
 419                         // Remember that the DOM is ready
 420                         jQuery.isReady = true;
 421
 422                         // If a normal DOM Ready event fired, decrement, and wait if need be
 423                         if ( wait !== true && --jQuery.readyWait > 0 ) {
 424                                 return;
 425                         }
 426
 427                         // If there are functions bound, to execute
 428                         readyList.resolveWith( document, [ jQuery ] );
 429
 430                         // Trigger any bound ready events
 431                         if ( jQuery.fn.trigger ) {
 432                                 jQuery( document ).trigger( "ready" ).unbind( "ready" );
 433                         }
 434                 }
 435         },
 436
 437         bindReady: function() {
 438                 if ( readyList ) {
 439                         return;
 440                 }
 441
 442                 readyList = jQuery._Deferred();
 443
 444                 // Catch cases where $(document).ready() is called after the
 445                 // browser event has already occurred.
 446                 if ( document.readyState === "complete" ) {
 447                         // Handle it asynchronously to allow scripts the opportunity to delay ready
 448                         return setTimeout( jQuery.ready, 1 );
 449                 }
 450
 451                 // Mozilla, Opera and webkit nightlies currently support this event
 452                 if ( document.addEventListener ) {
 453                         // Use the handy event callback
 454                         document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 455
 456                         // A fallback to window.onload, that will always work
 457                         window.addEventListener( "load", jQuery.ready, false );
 458
 459                 // If IE event model is used
 460                 } else if ( document.attachEvent ) {
 461                         // ensure firing before onload,
 462                         // maybe late but safe also for iframes
 463                         document.attachEvent( "onreadystatechange", DOMContentLoaded );
 464
 465                         // A fallback to window.onload, that will always work
 466                         window.attachEvent( "onload", jQuery.ready );
 467
 468                         // If IE and not a frame
 469                         // continually check to see if the document is ready
 470                         var toplevel = false;
 471
 472                         try {
 473                                 toplevel = window.frameElement == null;
 474                         } catch(e) {}
 475
 476                         if ( document.documentElement.doScroll && toplevel ) {
 477                                 doScrollCheck();
 478                         }
 479                 }
 480         },
 481
 482         // See test/unit/core.js for details concerning isFunction.
 483         // Since version 1.3, DOM methods and functions like alert
 484         // aren't supported. They return false on IE (#2968).
 485         isFunction: function( obj ) {
 486                 return jQuery.type(obj) === "function";
 487         },
 488
 489         isArray: Array.isArray || function( obj ) {
 490                 return jQuery.type(obj) === "array";
 491         },
 492
 493         // A crude way of determining if an object is a window
 494         isWindow: function( obj ) {
 495                 return obj && typeof obj === "object" && "setInterval" in obj;
 496         },
 497
 498         isNaN: function( obj ) {
 499                 return obj == null || !rdigit.test( obj ) || isNaN( obj );
 500         },
 501
 502         type: function( obj ) {
 503                 return obj == null ?
 504                         String( obj ) :
 505                         class2type[ toString.call(obj) ] || "object";
 506         },
 507
 508         isPlainObject: function( obj ) {
 509                 // Must be an Object.
 510                 // Because of IE, we also have to check the presence of the constructor property.
 511                 // Make sure that DOM nodes and window objects don't pass through, as well
 512                 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
 513                         return false;
 514                 }
 515
 516                 // Not own constructor property must be Object
 517                 if ( obj.constructor &&
 518                         !hasOwn.call(obj, "constructor") &&
 519                         !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
 520                         return false;
 521                 }
 522
 523                 // Own properties are enumerated firstly, so to speed up,
 524                 // if last one is own, then all properties are own.
 525
 526                 var key;
 527                 for ( key in obj ) {}
 528
 529                 return key === undefined || hasOwn.call( obj, key );
 530         },
 531
 532         isEmptyObject: function( obj ) {
 533                 for ( var name in obj ) {
 534                         return false;
 535                 }
 536                 return true;
 537         },
 538
 539         error: function( msg ) {
 540                 throw msg;
 541         },
 542
 543         parseJSON: function( data ) {
 544                 if ( typeof data !== "string" || !data ) {
 545                         return null;
 546                 }
 547
 548                 // Make sure leading/trailing whitespace is removed (IE can't handle it)
 549                 data = jQuery.trim( data );
 550
 551                 // Attempt to parse using the native JSON parser first
 552                 if ( window.JSON && window.JSON.parse ) {
 553                         return window.JSON.parse( data );
 554                 }
 555
 556                 // Make sure the incoming data is actual JSON
 557                 // Logic borrowed from http://json.org/json2.js
 558                 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
 559                         .replace( rvalidtokens, "]" )
 560                         .replace( rvalidbraces, "")) ) {
 561
 562                         return (new Function( "return " + data ))();
 563
 564                 }
 565                 jQuery.error( "Invalid JSON: " + data );
 566         },
 567
 568         // Cross-browser xml parsing
 569         // (xml & tmp used internally)
 570         parseXML: function( data , xml , tmp ) {
 571
 572                 if ( window.DOMParser ) { // Standard
 573                         tmp = new DOMParser();
 574                         xml = tmp.parseFromString( data , "text/xml" );
 575                 } else { // IE
 576                         xml = new ActiveXObject( "Microsoft.XMLDOM" );
 577                         xml.async = "false";
 578                         xml.loadXML( data );
 579                 }
 580
 581                 tmp = xml.documentElement;
 582
 583                 if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
 584                         jQuery.error( "Invalid XML: " + data );
 585                 }
 586
 587                 return xml;
 588         },
 589
 590         noop: function() {},
 591
 592         // Evaluates a script in a global context
 593         // Workarounds based on findings by Jim Driscoll
 594         // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
 595         globalEval: function( data ) {
 596                 if ( data && rnotwhite.test( data ) ) {
 597                         // We use execScript on Internet Explorer
 598                         // We use an anonymous function so that context is window
 599                         // rather than jQuery in Firefox
 600                         ( window.execScript || function( data ) {
 601                                 window[ "eval" ].call( window, data );
 602                         } )( data );
 603                 }
 604         },
 605
 606         nodeName: function( elem, name ) {
 607                 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
 608         },
 609
 610         // args is for internal usage only
 611         each: function( object, callback, args ) {
 612                 var name, i = 0,
 613                         length = object.length,
 614                         isObj = length === undefined || jQuery.isFunction( object );
 615
 616                 if ( args ) {
 617                         if ( isObj ) {
 618                                 for ( name in object ) {
 619                                         if ( callback.apply( object[ name ], args ) === false ) {
 620                                                 break;
 621                                         }
 622                                 }
 623                         } else {
 624                                 for ( ; i < length; ) {
 625                                         if ( callback.apply( object[ i++ ], args ) === false ) {
 626                                                 break;
 627                                         }
 628                                 }
 629                         }
 630
 631                 // A special, fast, case for the most common use of each
 632                 } else {
 633                         if ( isObj ) {
 634                                 for ( name in object ) {
 635                                         if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
 636                                                 break;
 637                                         }
 638                                 }
 639                         } else {
 640                                 for ( ; i < length; ) {
 641                                         if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
 642                                                 break;
 643                                         }
 644                                 }
 645                         }
 646                 }
 647
 648                 return object;
 649         },
 650
 651         // Use native String.trim function wherever possible
 652         trim: trim ?
 653                 function( text ) {
 654                         return text == null ?
 655                                 "" :
 656                                 trim.call( text );
 657                 } :
 658
 659                 // Otherwise use our own trimming functionality
 660                 function( text ) {
 661                         return text == null ?
 662                                 "" :
 663                                 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
 664                 },
 665
 666         // results is for internal usage only
 667         makeArray: function( array, results ) {
 668                 var ret = results || [];
 669
 670                 if ( array != null ) {
 671                         // The window, strings (and functions) also have 'length'
 672                         // The extra typeof function check is to prevent crashes
 673                         // in Safari 2 (See: #3039)
 674                         // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
 675                         var type = jQuery.type( array );
 676
 677                         if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
 678                                 push.call( ret, array );
 679                         } else {
 680                                 jQuery.merge( ret, array );
 681                         }
 682                 }
 683
 684                 return ret;
 685         },
 686
 687         inArray: function( elem, array ) {
 688
 689                 if ( indexOf ) {
 690                         return indexOf.call( array, elem );
 691                 }
 692
 693                 for ( var i = 0, length = array.length; i < length; i++ ) {
 694                         if ( array[ i ] === elem ) {
 695                                 return i;
 696                         }
 697                 }
 698
 699                 return -1;
 700         },
 701
 702         merge: function( first, second ) {
 703                 var i = first.length,
 704                         j = 0;
 705
 706                 if ( typeof second.length === "number" ) {
 707                         for ( var l = second.length; j < l; j++ ) {
 708                                 first[ i++ ] = second[ j ];
 709                         }
 710
 711                 } else {
 712                         while ( second[j] !== undefined ) {
 713                                 first[ i++ ] = second[ j++ ];
 714                         }
 715                 }
 716
 717                 first.length = i;
 718
 719                 return first;
 720         },
 721
 722         grep: function( elems, callback, inv ) {
 723                 var ret = [], retVal;
 724                 inv = !!inv;
 725
 726                 // Go through the array, only saving the items
 727                 // that pass the validator function
 728                 for ( var i = 0, length = elems.length; i < length; i++ ) {
 729                         retVal = !!callback( elems[ i ], i );
 730                         if ( inv !== retVal ) {
 731                                 ret.push( elems[ i ] );
 732                         }
 733                 }
 734
 735                 return ret;
 736         },
 737
 738         // arg is for internal usage only
 739         map: function( elems, callback, arg ) {
 740                 var value, key, ret = [],
 741                         i = 0,
 742                         length = elems.length,
 743                         // jquery objects are treated as arrays
 744                         isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
 745
 746                 // Go through the array, translating each of the items to their
 747                 if ( isArray ) {
 748                         for ( ; i < length; i++ ) {
 749                                 value = callback( elems[ i ], i, arg );
 750
 751                                 if ( value != null ) {
 752                                         ret[ ret.length ] = value;
 753                                 }
 754                         }
 755
 756                 // Go through every key on the object,
 757                 } else {
 758                         for ( key in elems ) {
 759                                 value = callback( elems[ key ], key, arg );
 760
 761                                 if ( value != null ) {
 762                                         ret[ ret.length ] = value;
 763                                 }
 764                         }
 765                 }
 766
 767                 // Flatten any nested arrays
 768                 return ret.concat.apply( [], ret );
 769         },
 770
 771         // A global GUID counter for objects
 772         guid: 1,
 773
 774         // Bind a function to a context, optionally partially applying any
 775         // arguments.
 776         proxy: function( fn, context ) {
 777                 if ( typeof context === "string" ) {
 778                         var tmp = fn[ context ];
 779                         context = fn;
 780                         fn = tmp;
 781                 }
 782
 783                 // Quick check to determine if target is callable, in the spec
 784                 // this throws a TypeError, but we will just return undefined.
 785                 if ( !jQuery.isFunction( fn ) ) {
 786                         return undefined;
 787                 }
 788
 789                 // Simulated bind
 790                 var args = slice.call( arguments, 2 ),
 791                         proxy = function() {
 792                                 return fn.apply( context, args.concat( slice.call( arguments ) ) );
 793                         };
 794
 795                 // Set the guid of unique handler to the same of original handler, so it can be removed
 796                 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
 797
 798                 return proxy;
 799         },
 800
 801         // Mutifunctional method to get and set values to a collection
 802         // The value/s can be optionally by executed if its a function
 803         access: function( elems, key, value, exec, fn, pass ) {
 804                 var length = elems.length;
 805
 806                 // Setting many attributes
 807                 if ( typeof key === "object" ) {
 808                         for ( var k in key ) {
 809                                 jQuery.access( elems, k, key[k], exec, fn, value );
 810                         }
 811                         return elems;
 812                 }
 813
 814                 // Setting one attribute
 815                 if ( value !== undefined ) {
 816                         // Optionally, function values get executed if exec is true
 817                         exec = !pass && exec && jQuery.isFunction(value);
 818
 819                         for ( var i = 0; i < length; i++ ) {
 820                                 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
 821                         }
 822
 823                         return elems;
 824                 }
 825
 826                 // Getting an attribute
 827                 return length ? fn( elems[0], key ) : undefined;
 828         },
 829
 830         now: function() {
 831                 return (new Date()).getTime();
 832         },
 833
 834         // Use of jQuery.browser is frowned upon.
 835         // More details: http://docs.jquery.com/Utilities/jQuery.browser
 836         uaMatch: function( ua ) {
 837                 ua = ua.toLowerCase();
 838
 839                 var match = rwebkit.exec( ua ) ||
 840                         ropera.exec( ua ) ||
 841                         rmsie.exec( ua ) ||
 842                         ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
 843                         [];
 844
 845                 return { browser: match[1] || "", version: match[2] || "0" };
 846         },
 847
 848         sub: function() {
 849                 function jQuerySub( selector, context ) {
 850                         return new jQuerySub.fn.init( selector, context );
 851                 }
 852                 jQuery.extend( true, jQuerySub, this );
 853                 jQuerySub.superclass = this;
 854                 jQuerySub.fn = jQuerySub.prototype = this();
 855                 jQuerySub.fn.constructor = jQuerySub;
 856                 jQuerySub.sub = this.sub;
 857                 jQuerySub.fn.init = function init( selector, context ) {
 858                         if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
 859                                 context = jQuerySub( context );
 860                         }
 861
 862                         return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
 863                 };
 864                 jQuerySub.fn.init.prototype = jQuerySub.fn;
 865                 var rootjQuerySub = jQuerySub(document);
 866                 return jQuerySub;
 867         },
 868
 869         browser: {}
 870 });
 871
 872 // Populate the class2type map
 873 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
 874         class2type[ "[object " + name + "]" ] = name.toLowerCase();
 875 });
 876
 877 browserMatch = jQuery.uaMatch( userAgent );
 878 if ( browserMatch.browser ) {
 879         jQuery.browser[ browserMatch.browser ] = true;
 880         jQuery.browser.version = browserMatch.version;
 881 }
 882
 883 // Deprecated, use jQuery.browser.webkit instead
 884 if ( jQuery.browser.webkit ) {
 885         jQuery.browser.safari = true;
 886 }
 887
 888 // IE doesn't match non-breaking spaces with \s
 889 if ( rnotwhite.test( "\xA0" ) ) {
 890         trimLeft = /^[\s\xA0]+/;
 891         trimRight = /[\s\xA0]+$/;
 892 }
 893
 894 // All jQuery objects should point back to these
 895 rootjQuery = jQuery(document);
 896
 897 // Cleanup functions for the document ready method
 898 if ( document.addEventListener ) {
 899         DOMContentLoaded = function() {
 900                 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 901                 jQuery.ready();
 902         };
 903
 904 } else if ( document.attachEvent ) {
 905         DOMContentLoaded = function() {
 906                 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
 907                 if ( document.readyState === "complete" ) {
 908                         document.detachEvent( "onreadystatechange", DOMContentLoaded );
 909                         jQuery.ready();
 910                 }
 911         };
 912 }
 913
 914 // The DOM ready check for Internet Explorer
 915 function doScrollCheck() {
 916         if ( jQuery.isReady ) {
 917                 return;
 918         }
 919
 920         try {
 921                 // If IE is used, use the trick by Diego Perini
 922                 // http://javascript.nwbox.com/IEContentLoaded/
 923                 document.documentElement.doScroll("left");
 924         } catch(e) {
 925                 setTimeout( doScrollCheck, 1 );
 926                 return;
 927         }
 928
 929         // and execute any waiting functions
 930         jQuery.ready();
 931 }
 932
 933 // Expose jQuery to the global object
 934 return jQuery;
 935
 936 })();
 937
 938
 939 var // Promise methods
 940         promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
 941         // Static reference to slice
 942         sliceDeferred = [].slice;
 943
 944 jQuery.extend({
 945         // Create a simple deferred (one callbacks list)
 946         _Deferred: function() {
 947                 var // callbacks list
 948                         callbacks = [],
 949                         // stored [ context , args ]
 950                         fired,
 951                         // to avoid firing when already doing so
 952                         firing,
 953                         // flag to know if the deferred has been cancelled
 954                         cancelled,
 955                         // the deferred itself
 956                         deferred  = {
 957
 958                                 // done( f1, f2, ...)
 959                                 done: function() {
 960                                         if ( !cancelled ) {
 961                                                 var args = arguments,
 962                                                         i,
 963                                                         length,
 964                                                         elem,
 965                                                         type,
 966                                                         _fired;
 967                                                 if ( fired ) {
 968                                                         _fired = fired;
 969                                                         fired = 0;
 970                                                 }
 971                                                 for ( i = 0, length = args.length; i < length; i++ ) {
 972                                                         elem = args[ i ];
 973                                                         type = jQuery.type( elem );
 974                                                         if ( type === "array" ) {
 975                                                                 deferred.done.apply( deferred, elem );
 976                                                         } else if ( type === "function" ) {
 977                                                                 callbacks.push( elem );
 978                                                         }
 979                                                 }
 980                                                 if ( _fired ) {
 981                                                         deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
 982                                                 }
 983                                         }
 984                                         return this;
 985                                 },
 986
 987                                 // resolve with given context and args
 988                                 resolveWith: function( context, args ) {
 989                                         if ( !cancelled && !fired && !firing ) {
 990                                                 // make sure args are available (#8421)
 991                                                 args = args || [];
 992                                                 firing = 1;
 993                                                 try {
 994                                                         while( callbacks[ 0 ] ) {
 995                                                                 callbacks.shift().apply( context, args );
 996                                                         }
 997                                                 }
 998                                                 finally {
 999                                                         fired = [ context, args ];
1000                                                         firing = 0;
1001                                                 }
1002                                         }
1003                                         return this;
1004                                 },
1005
1006                                 // resolve with this as context and given arguments
1007                                 resolve: function() {
1008                                         deferred.resolveWith( this, arguments );
1009                                         return this;
1010                                 },
1011
1012                                 // Has this deferred been resolved?
1013                                 isResolved: function() {
1014                                         return !!( firing || fired );
1015                                 },
1016
1017                                 // Cancel
1018                                 cancel: function() {
1019                                         cancelled = 1;
1020                                         callbacks = [];
1021                                         return this;
1022                                 }
1023                         };
1024
1025                 return deferred;
1026         },
1027
1028         // Full fledged deferred (two callbacks list)
1029         Deferred: function( func ) {
1030                 var deferred = jQuery._Deferred(),
1031                         failDeferred = jQuery._Deferred(),
1032                         promise;
1033                 // Add errorDeferred methods, then and promise
1034                 jQuery.extend( deferred, {
1035                         then: function( doneCallbacks, failCallbacks ) {
1036                                 deferred.done( doneCallbacks ).fail( failCallbacks );
1037                                 return this;
1038                         },
1039                         always: function() {
1040                                 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1041                         },
1042                         fail: failDeferred.done,
1043                         rejectWith: failDeferred.resolveWith,
1044                         reject: failDeferred.resolve,
1045                         isRejected: failDeferred.isResolved,
1046                         pipe: function( fnDone, fnFail ) {
1047                                 return jQuery.Deferred(function( newDefer ) {
1048                                         jQuery.each( {
1049                                                 done: [ fnDone, "resolve" ],
1050                                                 fail: [ fnFail, "reject" ]
1051                                         }, function( handler, data ) {
1052                                                 var fn = data[ 0 ],
1053                                                         action = data[ 1 ],
1054                                                         returned;
1055                                                 if ( jQuery.isFunction( fn ) ) {
1056                                                         deferred[ handler ](function() {
1057                                                                 returned = fn.apply( this, arguments );
1058                                                                 if ( returned && jQuery.isFunction( returned.promise ) ) {
1059                                                                         returned.promise().then( newDefer.resolve, newDefer.reject );
1060                                                                 } else {
1061                                                                         newDefer[ action ]( returned );
1062                                                                 }
1063                                                         });
1064                                                 } else {
1065                                                         deferred[ handler ]( newDefer[ action ] );
1066                                                 }
1067                                         });
1068                                 }).promise();
1069                         },
1070                         // Get a promise for this deferred
1071                         // If obj is provided, the promise aspect is added to the object
1072                         promise: function( obj ) {
1073                                 if ( obj == null ) {
1074                                         if ( promise ) {
1075                                                 return promise;
1076                                         }
1077                                         promise = obj = {};
1078                                 }
1079                                 var i = promiseMethods.length;
1080                                 while( i-- ) {
1081                                         obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1082                                 }
1083                                 return obj;
1084                         }
1085                 });
1086                 // Make sure only one callback list will be used
1087                 deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1088                 // Unexpose cancel
1089                 delete deferred.cancel;
1090                 // Call given func if any
1091                 if ( func ) {
1092                         func.call( deferred, deferred );
1093                 }
1094                 return deferred;
1095         },
1096
1097         // Deferred helper
1098         when: function( firstParam ) {
1099                 var args = arguments,
1100                         i = 0,
1101                         length = args.length,
1102                         count = length,
1103                         deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1104                                 firstParam :
1105                                 jQuery.Deferred();
1106                 function resolveFunc( i ) {
1107                         return function( value ) {
1108                                 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1109                                 if ( !( --count ) ) {
1110                                         // Strange bug in FF4:
1111                                         // Values changed onto the arguments object sometimes end up as undefined values
1112                                         // outside the $.when method. Cloning the object into a fresh array solves the issue
1113                                         deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1114                                 }
1115                         };
1116                 }
1117                 if ( length > 1 ) {
1118                         for( ; i < length; i++ ) {
1119                                 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1120                                         args[ i ].promise().then( resolveFunc(i), deferred.reject );
1121                                 } else {
1122                                         --count;
1123                                 }
1124                         }
1125                         if ( !count ) {
1126                                 deferred.resolveWith( deferred, args );
1127                         }
1128                 } else if ( deferred !== firstParam ) {
1129                         deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1130                 }
1131                 return deferred.promise();
1132         }
1133 });
1134
1135
1136
1137 jQuery.support = (function() {
1138
1139         var div = document.createElement( "div" ),
1140                 documentElement = document.documentElement,
1141                 all,
1142                 a,
1143                 select,
1144                 opt,
1145                 input,
1146                 marginDiv,
1147                 support,
1148                 fragment,
1149                 body,
1150                 bodyStyle,
1151                 tds,
1152                 events,
1153                 eventName,
1154                 i,
1155                 isSupported;
1156
1157         // Preliminary tests
1158         div.setAttribute("className", "t");
1159         div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1160
1161         all = div.getElementsByTagName( "*" );
1162         a = div.getElementsByTagName( "a" )[ 0 ];
1163
1164         // Can't get basic test support
1165         if ( !all || !all.length || !a ) {
1166                 return {};
1167         }
1168
1169         // First batch of supports tests
1170         select = document.createElement( "select" );
1171         opt = select.appendChild( document.createElement("option") );
1172         input = div.getElementsByTagName( "input" )[ 0 ];
1173
1174         support = {
1175                 // IE strips leading whitespace when .innerHTML is used
1176                 leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1177
1178                 // Make sure that tbody elements aren't automatically inserted
1179                 // IE will insert them into empty tables
1180                 tbody: !div.getElementsByTagName( "tbody" ).length,
1181
1182                 // Make sure that link elements get serialized correctly by innerHTML
1183                 // This requires a wrapper element in IE
1184                 htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1185
1186                 // Get the style information from getAttribute
1187                 // (IE uses .cssText instead)
1188                 style: /top/.test( a.getAttribute("style") ),
1189
1190                 // Make sure that URLs aren't manipulated
1191                 // (IE normalizes it by default)
1192                 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1193
1194                 // Make sure that element opacity exists
1195                 // (IE uses filter instead)
1196                 // Use a regex to work around a WebKit issue. See #5145
1197                 opacity: /^0.55$/.test( a.style.opacity ),
1198
1199                 // Verify style float existence
1200                 // (IE uses styleFloat instead of cssFloat)
1201                 cssFloat: !!a.style.cssFloat,
1202
1203                 // Make sure that if no value is specified for a checkbox
1204                 // that it defaults to "on".
1205                 // (WebKit defaults to "" instead)
1206                 checkOn: ( input.value === "on" ),
1207
1208                 // Make sure that a selected-by-default option has a working selected property.
1209                 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1210                 optSelected: opt.selected,
1211
1212                 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1213                 getSetAttribute: div.className !== "t",
1214
1215                 // Will be defined later
1216                 submitBubbles: true,
1217                 changeBubbles: true,
1218                 focusinBubbles: false,
1219                 deleteExpando: true,
1220                 noCloneEvent: true,
1221                 inlineBlockNeedsLayout: false,
1222                 shrinkWrapBlocks: false,
1223                 reliableMarginRight: true
1224         };
1225
1226         // Make sure checked status is properly cloned
1227         input.checked = true;
1228         support.noCloneChecked = input.cloneNode( true ).checked;
1229
1230         // Make sure that the options inside disabled selects aren't marked as disabled
1231         // (WebKit marks them as disabled)
1232         select.disabled = true;
1233         support.optDisabled = !opt.disabled;
1234
1235         // Test to see if it's possible to delete an expando from an element
1236         // Fails in Internet Explorer
1237         try {
1238                 delete div.test;
1239         } catch( e ) {
1240                 support.deleteExpando = false;
1241         }
1242
1243         if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1244                 div.attachEvent( "onclick", function click() {
1245                         // Cloning a node shouldn't copy over any
1246                         // bound event handlers (IE does this)
1247                         support.noCloneEvent = false;
1248                         div.detachEvent( "onclick", click );
1249                 });
1250                 div.cloneNode( true ).fireEvent( "onclick" );
1251         }
1252
1253         // Check if a radio maintains it's value
1254         // after being appended to the DOM
1255         input = document.createElement("input");
1256         input.value = "t";
1257         input.setAttribute("type", "radio");
1258         support.radioValue = input.value === "t";
1259
1260         input.setAttribute("checked", "checked");
1261         div.appendChild( input );
1262         fragment = document.createDocumentFragment();
1263         fragment.appendChild( div.firstChild );
1264
1265         // WebKit doesn't clone checked state correctly in fragments
1266         support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1267
1268         div.innerHTML = "";
1269
1270         // Figure out if the W3C box model works as expected
1271         div.style.width = div.style.paddingLeft = "1px";
1272
1273         // We use our own, invisible, body
1274         body = document.createElement( "body" );
1275         bodyStyle = {
1276                 visibility: "hidden",
1277                 width: 0,
1278                 height: 0,
1279                 border: 0,
1280                 margin: 0,
1281                 // Set background to avoid IE crashes when removing (#9028)
1282                 background: "none"
1283         };
1284         for ( i in bodyStyle ) {
1285                 body.style[ i ] = bodyStyle[ i ];
1286         }
1287         body.appendChild( div );
1288         documentElement.insertBefore( body, documentElement.firstChild );
1289
1290         // Check if a disconnected checkbox will retain its checked
1291         // value of true after appended to the DOM (IE6/7)
1292         support.appendChecked = input.checked;
1293
1294         support.boxModel = div.offsetWidth === 2;
1295
1296         if ( "zoom" in div.style ) {
1297                 // Check if natively block-level elements act like inline-block
1298                 // elements when setting their display to 'inline' and giving
1299                 // them layout
1300                 // (IE < 8 does this)
1301                 div.style.display = "inline";
1302                 div.style.zoom = 1;
1303                 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1304
1305                 // Check if elements with layout shrink-wrap their children
1306                 // (IE 6 does this)
1307                 div.style.display = "";
1308                 div.innerHTML = "<div style='width:4px;'></div>";
1309                 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1310         }
1311
1312         div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1313         tds = div.getElementsByTagName( "td" );
1314
1315         // Check if table cells still have offsetWidth/Height when they are set
1316         // to display:none and there are still other visible table cells in a
1317         // table row; if so, offsetWidth/Height are not reliable for use when
1318         // determining if an element has been hidden directly using
1319         // display:none (it is still safe to use offsets if a parent element is
1320         // hidden; don safety goggles and see bug #4512 for more information).
1321         // (only IE 8 fails this test)
1322         isSupported = ( tds[ 0 ].offsetHeight === 0 );
1323
1324         tds[ 0 ].style.display = "";
1325         tds[ 1 ].style.display = "none";
1326
1327         // Check if empty table cells still have offsetWidth/Height
1328         // (IE < 8 fail this test)
1329         support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1330         div.innerHTML = "";
1331
1332         // Check if div with explicit width and no margin-right incorrectly
1333         // gets computed margin-right based on width of container. For more
1334         // info see bug #3333
1335         // Fails in WebKit before Feb 2011 nightlies
1336         // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1337         if ( document.defaultView && document.defaultView.getComputedStyle ) {
1338                 marginDiv = document.createElement( "div" );
1339                 marginDiv.style.width = "0";
1340                 marginDiv.style.marginRight = "0";
1341                 div.appendChild( marginDiv );
1342                 support.reliableMarginRight =
1343                         ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1344         }
1345
1346         // Remove the body element we added
1347         body.innerHTML = "";
1348         documentElement.removeChild( body );
1349
1350         // Technique from Juriy Zaytsev
1351         // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1352         // We only care about the case where non-standard event systems
1353         // are used, namely in IE. Short-circuiting here helps us to
1354         // avoid an eval call (in setAttribute) which can cause CSP
1355         // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1356         if ( div.attachEvent ) {
1357                 for( i in {
1358                         submit: 1,
1359                         change: 1,
1360                         focusin: 1
1361                 } ) {
1362                         eventName = "on" + i;
1363                         isSupported = ( eventName in div );
1364                         if ( !isSupported ) {
1365                                 div.setAttribute( eventName, "return;" );
1366                                 isSupported = ( typeof div[ eventName ] === "function" );
1367                         }
1368                         support[ i + "Bubbles" ] = isSupported;
1369                 }
1370         }
1371
1372         return support;
1373 })();
1374
1375 // Keep track of boxModel
1376 jQuery.boxModel = jQuery.support.boxModel;
1377
1378
1379
1380
1381 var rbrace = /^(?:\{.*\}|\[.*\])$/,
1382         rmultiDash = /([a-z])([A-Z])/g;
1383
1384 jQuery.extend({
1385         cache: {},
1386
1387         // Please use with caution
1388         uuid: 0,
1389
1390         // Unique for each copy of jQuery on the page
1391         // Non-digits removed to match rinlinejQuery
1392         expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1393
1394         // The following elements throw uncatchable exceptions if you
1395         // attempt to add expando properties to them.
1396         noData: {
1397                 "embed": true,
1398                 // Ban all objects except for Flash (which handle expandos)
1399                 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1400                 "applet": true
1401         },
1402
1403         hasData: function( elem ) {
1404                 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1405
1406                 return !!elem && !isEmptyDataObject( elem );
1407         },
1408
1409         data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1410                 if ( !jQuery.acceptData( elem ) ) {
1411                         return;
1412                 }
1413
1414                 var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1415
1416                         // We have to handle DOM nodes and JS objects differently because IE6-7
1417                         // can't GC object references properly across the DOM-JS boundary
1418                         isNode = elem.nodeType,
1419
1420                         // Only DOM nodes need the global jQuery cache; JS object data is
1421                         // attached directly to the object so GC can occur automatically
1422                         cache = isNode ? jQuery.cache : elem,
1423
1424                         // Only defining an ID for JS objects if its cache already exists allows
1425                         // the code to shortcut on the same path as a DOM node with no cache
1426                         id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1427
1428                 // Avoid doing any more work than we need to when trying to get data on an
1429                 // object that has no data at all
1430                 if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1431                         return;
1432                 }
1433
1434                 if ( !id ) {
1435                         // Only DOM nodes need a new unique ID for each element since their data
1436                         // ends up in the global cache
1437                         if ( isNode ) {
1438                                 elem[ jQuery.expando ] = id = ++jQuery.uuid;
1439                         } else {
1440                                 id = jQuery.expando;
1441                         }
1442                 }
1443
1444                 if ( !cache[ id ] ) {
1445                         cache[ id ] = {};
1446
1447                         // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1448                         // metadata on plain JS objects when the object is serialized using
1449                         // JSON.stringify
1450                         if ( !isNode ) {
1451                                 cache[ id ].toJSON = jQuery.noop;
1452                         }
1453                 }
1454
1455                 // An object can be passed to jQuery.data instead of a key/value pair; this gets
1456                 // shallow copied over onto the existing cache
1457                 if ( typeof name === "object" || typeof name === "function" ) {
1458                         if ( pvt ) {
1459                                 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1460                         } else {
1461                                 cache[ id ] = jQuery.extend(cache[ id ], name);
1462                         }
1463                 }
1464
1465                 thisCache = cache[ id ];
1466
1467                 // Internal jQuery data is stored in a separate object inside the object's data
1468                 // cache in order to avoid key collisions between internal data and user-defined
1469                 // data
1470                 if ( pvt ) {
1471                         if ( !thisCache[ internalKey ] ) {
1472                                 thisCache[ internalKey ] = {};
1473                         }
1474
1475                         thisCache = thisCache[ internalKey ];
1476                 }
1477
1478                 if ( data !== undefined ) {
1479                         thisCache[ jQuery.camelCase( name ) ] = data;
1480                 }
1481
1482                 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1483                 // not attempt to inspect the internal events object using jQuery.data, as this
1484                 // internal data object is undocumented and subject to change.
1485                 if ( name === "events" && !thisCache[name] ) {
1486                         return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1487                 }
1488
1489                 return getByName ? thisCache[ jQuery.camelCase( name ) ] : thisCache;
1490         },
1491
1492         removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1493                 if ( !jQuery.acceptData( elem ) ) {
1494                         return;
1495                 }
1496
1497                 var internalKey = jQuery.expando, isNode = elem.nodeType,
1498
1499                         // See jQuery.data for more information
1500                         cache = isNode ? jQuery.cache : elem,
1501
1502                         // See jQuery.data for more information
1503                         id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1504
1505                 // If there is already no cache entry for this object, there is no
1506                 // purpose in continuing
1507                 if ( !cache[ id ] ) {
1508                         return;
1509                 }
1510
1511                 if ( name ) {
1512                         var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1513
1514                         if ( thisCache ) {
1515                                 delete thisCache[ name ];
1516
1517                                 // If there is no data left in the cache, we want to continue
1518                                 // and let the cache object itself get destroyed
1519                                 if ( !isEmptyDataObject(thisCache) ) {
1520                                         return;
1521                                 }
1522                         }
1523                 }
1524
1525                 // See jQuery.data for more information
1526                 if ( pvt ) {
1527                         delete cache[ id ][ internalKey ];
1528
1529                         // Don't destroy the parent cache unless the internal data object
1530                         // had been the only thing left in it
1531                         if ( !isEmptyDataObject(cache[ id ]) ) {
1532                                 return;
1533                         }
1534                 }
1535
1536                 var internalCache = cache[ id ][ internalKey ];
1537
1538                 // Browsers that fail expando deletion also refuse to delete expandos on
1539                 // the window, but it will allow it on all other JS objects; other browsers
1540                 // don't care
1541                 if ( jQuery.support.deleteExpando || cache != window ) {
1542                         delete cache[ id ];
1543                 } else {
1544                         cache[ id ] = null;
1545                 }
1546
1547                 // We destroyed the entire user cache at once because it's faster than
1548                 // iterating through each key, but we need to continue to persist internal
1549                 // data if it existed
1550                 if ( internalCache ) {
1551                         cache[ id ] = {};
1552                         // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1553                         // metadata on plain JS objects when the object is serialized using
1554                         // JSON.stringify
1555                         if ( !isNode ) {
1556                                 cache[ id ].toJSON = jQuery.noop;
1557                         }
1558
1559                         cache[ id ][ internalKey ] = internalCache;
1560
1561                 // Otherwise, we need to eliminate the expando on the node to avoid
1562                 // false lookups in the cache for entries that no longer exist
1563                 } else if ( isNode ) {
1564                         // IE does not allow us to delete expando properties from nodes,
1565                         // nor does it have a removeAttribute function on Document nodes;
1566                         // we must handle all of these cases
1567                         if ( jQuery.support.deleteExpando ) {
1568                                 delete elem[ jQuery.expando ];
1569                         } else if ( elem.removeAttribute ) {
1570                                 elem.removeAttribute( jQuery.expando );
1571                         } else {
1572                                 elem[ jQuery.expando ] = null;
1573                         }
1574                 }
1575         },
1576
1577         // For internal use only.
1578         _data: function( elem, name, data ) {
1579                 return jQuery.data( elem, name, data, true );
1580         },
1581
1582         // A method for determining if a DOM node can handle the data expando
1583         acceptData: function( elem ) {
1584                 if ( elem.nodeName ) {
1585                         var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1586
1587                         if ( match ) {
1588                                 return !(match === true || elem.getAttribute("classid") !== match);
1589                         }
1590                 }
1591
1592                 return true;
1593         }
1594 });
1595
1596 jQuery.fn.extend({
1597         data: function( key, value ) {
1598                 var data = null;
1599
1600                 if ( typeof key === "undefined" ) {
1601                         if ( this.length ) {
1602                                 data = jQuery.data( this[0] );
1603
1604                                 if ( this[0].nodeType === 1 ) {
1605                             var attr = this[0].attributes, name;
1606                                         for ( var i = 0, l = attr.length; i < l; i++ ) {
1607                                                 name = attr[i].name;
1608
1609                                                 if ( name.indexOf( "data-" ) === 0 ) {
1610                                                         name = jQuery.camelCase( name.substring(5) );
1611
1612                                                         dataAttr( this[0], name, data[ name ] );
1613                                                 }
1614                                         }
1615                                 }
1616                         }
1617
1618                         return data;
1619
1620                 } else if ( typeof key === "object" ) {
1621                         return this.each(function() {
1622                                 jQuery.data( this, key );
1623                         });
1624                 }
1625
1626                 var parts = key.split(".");
1627                 parts[1] = parts[1] ? "." + parts[1] : "";
1628
1629                 if ( value === undefined ) {
1630                         data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1631
1632                         // Try to fetch any internally stored data first
1633                         if ( data === undefined && this.length ) {
1634                                 data = jQuery.data( this[0], key );
1635                                 data = dataAttr( this[0], key, data );
1636                         }
1637
1638                         return data === undefined && parts[1] ?
1639                                 this.data( parts[0] ) :
1640                                 data;
1641
1642                 } else {
1643                         return this.each(function() {
1644                                 var $this = jQuery( this ),
1645                                         args = [ parts[0], value ];
1646
1647                                 $this.triggerHandler( "setData" + parts[1] + "!", args );
1648                                 jQuery.data( this, key, value );
1649                                 $this.triggerHandler( "changeData" + parts[1] + "!", args );
1650                         });
1651                 }
1652         },
1653
1654         removeData: function( key ) {
1655                 return this.each(function() {
1656                         jQuery.removeData( this, key );
1657                 });
1658         }
1659 });
1660
1661 function dataAttr( elem, key, data ) {
1662         // If nothing was found internally, try to fetch any
1663         // data from the HTML5 data-* attribute
1664         if ( data === undefined && elem.nodeType === 1 ) {
1665                 var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
1666
1667                 data = elem.getAttribute( name );
1668
1669                 if ( typeof data === "string" ) {
1670                         try {
1671                                 data = data === "true" ? true :
1672                                 data === "false" ? false :
1673                                 data === "null" ? null :
1674                                 !jQuery.isNaN( data ) ? parseFloat( data ) :
1675                                         rbrace.test( data ) ? jQuery.parseJSON( data ) :
1676                                         data;
1677                         } catch( e ) {}
1678
1679                         // Make sure we set the data so it isn't changed later
1680                         jQuery.data( elem, key, data );
1681
1682                 } else {
1683                         data = undefined;
1684                 }
1685         }
1686
1687         return data;
1688 }
1689
1690 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1691 // property to be considered empty objects; this property always exists in
1692 // order to make sure JSON.stringify does not expose internal metadata
1693 function isEmptyDataObject( obj ) {
1694         for ( var name in obj ) {
1695                 if ( name !== "toJSON" ) {
1696                         return false;
1697                 }
1698         }
1699
1700         return true;
1701 }
1702
1703
1704
1705
1706 function handleQueueMarkDefer( elem, type, src ) {
1707         var deferDataKey = type + "defer",
1708                 queueDataKey = type + "queue",
1709                 markDataKey = type + "mark",
1710                 defer = jQuery.data( elem, deferDataKey, undefined, true );
1711         if ( defer &&
1712                 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1713                 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1714                 // Give room for hard-coded callbacks to fire first
1715                 // and eventually mark/queue something else on the element
1716                 setTimeout( function() {
1717                         if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1718                                 !jQuery.data( elem, markDataKey, undefined, true ) ) {
1719                                 jQuery.removeData( elem, deferDataKey, true );
1720                                 defer.resolve();
1721                         }
1722                 }, 0 );
1723         }
1724 }
1725
1726 jQuery.extend({
1727
1728         _mark: function( elem, type ) {
1729                 if ( elem ) {
1730                         type = (type || "fx") + "mark";
1731                         jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
1732                 }
1733         },
1734
1735         _unmark: function( force, elem, type ) {
1736                 if ( force !== true ) {
1737                         type = elem;
1738                         elem = force;
1739                         force = false;
1740                 }
1741                 if ( elem ) {
1742                         type = type || "fx";
1743                         var key = type + "mark",
1744                                 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
1745                         if ( count ) {
1746                                 jQuery.data( elem, key, count, true );
1747                         } else {
1748                                 jQuery.removeData( elem, key, true );
1749                                 handleQueueMarkDefer( elem, type, "mark" );
1750                         }
1751                 }
1752         },
1753
1754         queue: function( elem, type, data ) {
1755                 if ( elem ) {
1756                         type = (type || "fx") + "queue";
1757                         var q = jQuery.data( elem, type, undefined, true );
1758                         // Speed up dequeue by getting out quickly if this is just a lookup
1759                         if ( data ) {
1760                                 if ( !q || jQuery.isArray(data) ) {
1761                                         q = jQuery.data( elem, type, jQuery.makeArray(data), true );
1762                                 } else {
1763                                         q.push( data );
1764                                 }
1765                         }
1766                         return q || [];
1767                 }
1768         },
1769
1770         dequeue: function( elem, type ) {
1771                 type = type || "fx";
1772
1773                 var queue = jQuery.queue( elem, type ),
1774                         fn = queue.shift(),
1775                         defer;
1776
1777                 // If the fx queue is dequeued, always remove the progress sentinel
1778                 if ( fn === "inprogress" ) {
1779                         fn = queue.shift();
1780                 }
1781
1782                 if ( fn ) {
1783                         // Add a progress sentinel to prevent the fx queue from being
1784                         // automatically dequeued
1785                         if ( type === "fx" ) {
1786                                 queue.unshift("inprogress");
1787                         }
1788
1789                         fn.call(elem, function() {
1790                                 jQuery.dequeue(elem, type);
1791                         });
1792                 }
1793
1794                 if ( !queue.length ) {
1795                         jQuery.removeData( elem, type + "queue", true );
1796                         handleQueueMarkDefer( elem, type, "queue" );
1797                 }
1798         }
1799 });
1800
1801 jQuery.fn.extend({
1802         queue: function( type, data ) {
1803                 if ( typeof type !== "string" ) {
1804                         data = type;
1805                         type = "fx";
1806                 }
1807
1808                 if ( data === undefined ) {
1809                         return jQuery.queue( this[0], type );
1810                 }
1811                 return this.each(function() {
1812                         var queue = jQuery.queue( this, type, data );
1813
1814                         if ( type === "fx" && queue[0] !== "inprogress" ) {
1815                                 jQuery.dequeue( this, type );
1816                         }
1817                 });
1818         },
1819         dequeue: function( type ) {
1820                 return this.each(function() {
1821                         jQuery.dequeue( this, type );
1822                 });
1823         },
1824         // Based off of the plugin by Clint Helfers, with permission.
1825         // http://blindsignals.com/index.php/2009/07/jquery-delay/
1826         delay: function( time, type ) {
1827                 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1828                 type = type || "fx";
1829
1830                 return this.queue( type, function() {
1831                         var elem = this;
1832                         setTimeout(function() {
1833                                 jQuery.dequeue( elem, type );
1834                         }, time );
1835                 });
1836         },
1837         clearQueue: function( type ) {
1838                 return this.queue( type || "fx", [] );
1839         },
1840         // Get a promise resolved when queues of a certain type
1841         // are emptied (fx is the type by default)
1842         promise: function( type, object ) {
1843                 if ( typeof type !== "string" ) {
1844                         object = type;
1845                         type = undefined;
1846                 }
1847                 type = type || "fx";
1848                 var defer = jQuery.Deferred(),
1849                         elements = this,
1850                         i = elements.length,
1851                         count = 1,
1852                         deferDataKey = type + "defer",
1853                         queueDataKey = type + "queue",
1854                         markDataKey = type + "mark",
1855                         tmp;
1856                 function resolve() {
1857                         if ( !( --count ) ) {
1858                                 defer.resolveWith( elements, [ elements ] );
1859                         }
1860                 }
1861                 while( i-- ) {
1862                         if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
1863                                         ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
1864                                                 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1865                                         jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
1866                                 count++;
1867                                 tmp.done( resolve );
1868                         }
1869                 }
1870                 resolve();
1871                 return defer.promise();
1872         }
1873 });
1874
1875
1876
1877
1878 var rclass = /[\n\t\r]/g,
1879         rspace = /\s+/,
1880         rreturn = /\r/g,
1881         rtype = /^(?:button|input)$/i,
1882         rfocusable = /^(?:button|input|object|select|textarea)$/i,
1883         rclickable = /^a(?:rea)?$/i,
1884         rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
1885         rinvalidChar = /\:/,
1886         formHook, boolHook;
1887
1888 jQuery.fn.extend({
1889         attr: function( name, value ) {
1890                 return jQuery.access( this, name, value, true, jQuery.attr );
1891         },
1892
1893         removeAttr: function( name ) {
1894                 return this.each(function() {
1895                         jQuery.removeAttr( this, name );
1896                 });
1897         },
1898
1899         prop: function( name, value ) {
1900                 return jQuery.access( this, name, value, true, jQuery.prop );
1901         },
1902
1903         removeProp: function( name ) {
1904                 name = jQuery.propFix[ name ] || name;
1905                 return this.each(function() {
1906                         // try/catch handles cases where IE balks (such as removing a property on window)
1907                         try {
1908                                 this[ name ] = undefined;
1909                                 delete this[ name ];
1910                         } catch( e ) {}
1911                 });
1912         },
1913
1914         addClass: function( value ) {
1915                 if ( jQuery.isFunction( value ) ) {
1916                         return this.each(function(i) {
1917                                 var self = jQuery(this);
1918                                 self.addClass( value.call(this, i, self.attr("class") || "") );
1919                         });
1920                 }
1921
1922                 if ( value && typeof value === "string" ) {
1923                         var classNames = (value || "").split( rspace );
1924
1925                         for ( var i = 0, l = this.length; i < l; i++ ) {
1926                                 var elem = this[i];
1927
1928                                 if ( elem.nodeType === 1 ) {
1929                                         if ( !elem.className ) {
1930                                                 elem.className = value;
1931
1932                                         } else {
1933                                                 var className = " " + elem.className + " ",
1934                                                         setClass = elem.className;
1935
1936                                                 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1937                                                         if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1938                                                                 setClass += " " + classNames[c];
1939                                                         }
1940                                                 }
1941                                                 elem.className = jQuery.trim( setClass );
1942                                         }
1943                                 }
1944                         }
1945                 }
1946
1947                 return this;
1948         },
1949
1950         removeClass: function( value ) {
1951                 if ( jQuery.isFunction(value) ) {
1952                         return this.each(function(i) {
1953                                 var self = jQuery(this);
1954                                 self.removeClass( value.call(this, i, self.attr("class")) );
1955                         });
1956                 }
1957
1958                 if ( (value && typeof value === "string") || value === undefined ) {
1959                         var classNames = (value || "").split( rspace );
1960
1961                         for ( var i = 0, l = this.length; i < l; i++ ) {
1962                                 var elem = this[i];
1963
1964                                 if ( elem.nodeType === 1 && elem.className ) {
1965                                         if ( value ) {
1966                                                 var className = (" " + elem.className + " ").replace(rclass, " ");
1967                                                 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1968                                                         className = className.replace(" " + classNames[c] + " ", " ");
1969                                                 }
1970                                                 elem.className = jQuery.trim( className );
1971
1972                                         } else {
1973                                                 elem.className = "";
1974                                         }
1975                                 }
1976                         }
1977                 }
1978
1979                 return this;
1980         },
1981
1982         toggleClass: function( value, stateVal ) {
1983                 var type = typeof value,
1984                         isBool = typeof stateVal === "boolean";
1985
1986                 if ( jQuery.isFunction( value ) ) {
1987                         return this.each(function(i) {
1988                                 var self = jQuery(this);
1989                                 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1990                         });
1991                 }
1992
1993                 return this.each(function() {
1994                         if ( type === "string" ) {
1995                                 // toggle individual class names
1996                                 var className,
1997                                         i = 0,
1998                                         self = jQuery( this ),
1999                                         state = stateVal,
2000                                         classNames = value.split( rspace );
2001
2002                                 while ( (className = classNames[ i++ ]) ) {
2003                                         // check each className given, space seperated list
2004                                         state = isBool ? state : !self.hasClass( className );
2005                                         self[ state ? "addClass" : "removeClass" ]( className );
2006                                 }
2007
2008                         } else if ( type === "undefined" || type === "boolean" ) {
2009                                 if ( this.className ) {
2010                                         // store className if set
2011                                         jQuery._data( this, "__className__", this.className );
2012                                 }
2013
2014                                 // toggle whole className
2015                                 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2016                         }
2017                 });
2018         },
2019
2020         hasClass: function( selector ) {
2021                 var className = " " + selector + " ";
2022                 for ( var i = 0, l = this.length; i < l; i++ ) {
2023                         if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2024                                 return true;
2025                         }
2026                 }
2027
2028                 return false;
2029         },
2030
2031         val: function( value ) {
2032                 var hooks, ret,
2033                         elem = this[0];
2034
2035                 if ( !arguments.length ) {
2036                         if ( elem ) {
2037                                 hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2038
2039                                 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2040                                         return ret;
2041                                 }
2042
2043                                 return (elem.value || "").replace(rreturn, "");
2044                         }
2045
2046                         return undefined;
2047                 }
2048
2049                 var isFunction = jQuery.isFunction( value );
2050
2051                 return this.each(function( i ) {
2052                         var self = jQuery(this), val;
2053
2054                         if ( this.nodeType !== 1 ) {
2055                                 return;
2056                         }
2057
2058                         if ( isFunction ) {
2059                                 val = value.call( this, i, self.val() );
2060                         } else {
2061                                 val = value;
2062                         }
2063
2064                         // Treat null/undefined as ""; convert numbers to string
2065                         if ( val == null ) {
2066                                 val = "";
2067                         } else if ( typeof val === "number" ) {
2068                                 val += "";
2069                         } else if ( jQuery.isArray( val ) ) {
2070                                 val = jQuery.map(val, function ( value ) {
2071                                         return value == null ? "" : value + "";
2072                                 });
2073                         }
2074
2075                         hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2076
2077                         // If set returns undefined, fall back to normal setting
2078                         if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2079                                 this.value = val;
2080                         }
2081                 });
2082         }
2083 });
2084
2085 jQuery.extend({
2086         valHooks: {
2087                 option: {
2088                         get: function( elem ) {
2089                                 // attributes.value is undefined in Blackberry 4.7 but
2090                                 // uses .value. See #6932
2091                                 var val = elem.attributes.value;
2092                                 return !val || val.specified ? elem.value : elem.text;
2093                         }
2094                 },
2095                 select: {
2096                         get: function( elem ) {
2097                                 var value,
2098                                         index = elem.selectedIndex,
2099                                         values = [],
2100                                         options = elem.options,
2101                                         one = elem.type === "select-one";
2102
2103                                 // Nothing was selected
2104                                 if ( index < 0 ) {
2105                                         return null;
2106                                 }
2107
2108                                 // Loop through all the selected options
2109                                 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2110                                         var option = options[ i ];
2111
2112                                         // Don't return options that are disabled or in a disabled optgroup
2113                                         if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2114                                                         (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2115
2116                                                 // Get the specific value for the option
2117                                                 value = jQuery( option ).val();
2118
2119                                                 // We don't need an array for one selects
2120                                                 if ( one ) {
2121                                                         return value;
2122                                                 }
2123
2124                                                 // Multi-Selects return an array
2125                                                 values.push( value );
2126                                         }
2127                                 }
2128
2129                                 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2130                                 if ( one && !values.length && options.length ) {
2131                                         return jQuery( options[ index ] ).val();
2132                                 }
2133
2134                                 return values;
2135                         },
2136
2137                         set: function( elem, value ) {
2138                                 var values = jQuery.makeArray( value );
2139
2140                                 jQuery(elem).find("option").each(function() {
2141                                         this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2142                                 });
2143
2144                                 if ( !values.length ) {
2145                                         elem.selectedIndex = -1;
2146                                 }
2147                                 return values;
2148                         }
2149                 }
2150         },
2151
2152         attrFn: {
2153                 val: true,
2154                 css: true,
2155                 html: true,
2156                 text: true,
2157                 data: true,
2158                 width: true,
2159                 height: true,
2160                 offset: true
2161         },
2162
2163         attrFix: {
2164                 // Always normalize to ensure hook usage
2165                 tabindex: "tabIndex"
2166         },
2167
2168         attr: function( elem, name, value, pass ) {
2169                 var nType = elem.nodeType;
2170
2171                 // don't get/set attributes on text, comment and attribute nodes
2172                 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2173                         return undefined;
2174                 }
2175
2176                 if ( pass && name in jQuery.attrFn ) {
2177                         return jQuery( elem )[ name ]( value );
2178                 }
2179
2180                 // Fallback to prop when attributes are not supported
2181                 if ( !("getAttribute" in elem) ) {
2182                         return jQuery.prop( elem, name, value );
2183                 }
2184
2185                 var ret, hooks,
2186                         notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2187
2188                 // Normalize the name if needed
2189                 name = notxml && jQuery.attrFix[ name ] || name;
2190
2191                 hooks = jQuery.attrHooks[ name ];
2192
2193                 if ( !hooks ) {
2194                         // Use boolHook for boolean attributes
2195                         if ( rboolean.test( name ) &&
2196                                 (typeof value === "boolean" || value === undefined || value.toLowerCase() === name.toLowerCase()) ) {
2197
2198                                 hooks = boolHook;
2199
2200                         // Use formHook for forms and if the name contains certain characters
2201                         } else if ( formHook && (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
2202                                 hooks = formHook;
2203                         }
2204                 }
2205
2206                 if ( value !== undefined ) {
2207
2208                         if ( value === null ) {
2209                                 jQuery.removeAttr( elem, name );
2210                                 return undefined;
2211
2212                         } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2213                                 return ret;
2214
2215                         } else {
2216                                 elem.setAttribute( name, "" + value );
2217                                 return value;
2218                         }
2219
2220                 } else if ( hooks && "get" in hooks && notxml ) {
2221                         return hooks.get( elem, name );
2222
2223                 } else {
2224
2225                         ret = elem.getAttribute( name );
2226
2227                         // Non-existent attributes return null, we normalize to undefined
2228                         return ret === null ?
2229                                 undefined :
2230                                 ret;
2231                 }
2232         },
2233
2234         removeAttr: function( elem, name ) {
2235                 var propName;
2236                 if ( elem.nodeType === 1 ) {
2237                         name = jQuery.attrFix[ name ] || name;
2238
2239                         if ( jQuery.support.getSetAttribute ) {
2240                                 // Use removeAttribute in browsers that support it
2241                                 elem.removeAttribute( name );
2242                         } else {
2243                                 jQuery.attr( elem, name, "" );
2244                                 elem.removeAttributeNode( elem.getAttributeNode( name ) );
2245                         }
2246
2247                         // Set corresponding property to false for boolean attributes
2248                         if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
2249                                 elem[ propName ] = false;
2250                         }
2251                 }
2252         },
2253
2254         attrHooks: {
2255                 type: {
2256                         set: function( elem, value ) {
2257                                 // We can't allow the type property to be changed (since it causes problems in IE)
2258                                 if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2259                                         jQuery.error( "type property can't be changed" );
2260                                 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2261                                         // Setting the type on a radio button after the value resets the value in IE6-9
2262                                         // Reset value to it's default in case type is set after value
2263                                         // This is for element creation
2264                                         var val = elem.value;
2265                                         elem.setAttribute( "type", value );
2266                                         if ( val ) {
2267                                                 elem.value = val;
2268                                         }
2269                                         return value;
2270                                 }
2271                         }
2272                 },
2273                 tabIndex: {
2274                         get: function( elem ) {
2275                                 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2276                                 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2277                                 var attributeNode = elem.getAttributeNode("tabIndex");
2278
2279                                 return attributeNode && attributeNode.specified ?
2280                                         parseInt( attributeNode.value, 10 ) :
2281                                         rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2282                                                 0 :
2283                                                 undefined;
2284                         }
2285                 }
2286         },
2287
2288         propFix: {
2289                 tabindex: "tabIndex",
2290                 readonly: "readOnly",
2291                 "for": "htmlFor",
2292                 "class": "className",
2293                 maxlength: "maxLength",
2294                 cellspacing: "cellSpacing",
2295                 cellpadding: "cellPadding",
2296                 rowspan: "rowSpan",
2297                 colspan: "colSpan",
2298                 usemap: "useMap",
2299                 frameborder: "frameBorder",
2300                 contenteditable: "contentEditable"
2301         },
2302
2303         prop: function( elem, name, value ) {
2304                 var nType = elem.nodeType;
2305
2306                 // don't get/set properties on text, comment and attribute nodes
2307                 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2308                         return undefined;
2309                 }
2310
2311                 var ret, hooks,
2312                         notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2313
2314                 // Try to normalize/fix the name
2315                 name = notxml && jQuery.propFix[ name ] || name;
2316
2317                 hooks = jQuery.propHooks[ name ];
2318
2319                 if ( value !== undefined ) {
2320                         if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2321                                 return ret;
2322
2323                         } else {
2324                                 return (elem[ name ] = value);
2325                         }
2326
2327                 } else {
2328                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
2329                                 return ret;
2330
2331                         } else {
2332                                 return elem[ name ];
2333                         }
2334                 }
2335         },
2336
2337         propHooks: {}
2338 });
2339
2340 // Hook for boolean attributes
2341 boolHook = {
2342         get: function( elem, name ) {
2343                 // Align boolean attributes with corresponding properties
2344                 return elem[ jQuery.propFix[ name ] || name ] ?
2345                         name.toLowerCase() :
2346                         undefined;
2347         },
2348         set: function( elem, value, name ) {
2349                 var propName;
2350                 if ( value === false ) {
2351                         // Remove boolean attributes when set to false
2352                         jQuery.removeAttr( elem, name );
2353                 } else {
2354                         // value is true since we know at this point it's type boolean and not false
2355                         // Set boolean attributes to the same name and set the DOM property
2356                         propName = jQuery.propFix[ name ] || name;
2357                         if ( propName in elem ) {
2358                                 // Only set the IDL specifically if it already exists on the element
2359                                 elem[ propName ] = value;
2360                         }
2361
2362                         elem.setAttribute( name, name.toLowerCase() );
2363                 }
2364                 return name;
2365         }
2366 };
2367
2368 // Use the value property for back compat
2369 // Use the formHook for button elements in IE6/7 (#1954)
2370 jQuery.attrHooks.value = {
2371         get: function( elem, name ) {
2372                 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2373                         return formHook.get( elem, name );
2374                 }
2375                 return elem.value;
2376         },
2377         set: function( elem, value, name ) {
2378                 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2379                         return formHook.set( elem, value, name );
2380                 }
2381                 // Does not return so that setAttribute is also used
2382                 elem.value = value;
2383         }
2384 };
2385
2386 // IE6/7 do not support getting/setting some attributes with get/setAttribute
2387 if ( !jQuery.support.getSetAttribute ) {
2388
2389         // propFix is more comprehensive and contains all fixes
2390         jQuery.attrFix = jQuery.propFix;
2391
2392         // Use this for any attribute on a form in IE6/7
2393         formHook = jQuery.attrHooks.name = jQuery.valHooks.button = {
2394                 get: function( elem, name ) {
2395                         var ret;
2396                         ret = elem.getAttributeNode( name );
2397                         // Return undefined if nodeValue is empty string
2398                         return ret && ret.nodeValue !== "" ?
2399                                 ret.nodeValue :
2400                                 undefined;
2401                 },
2402                 set: function( elem, value, name ) {
2403                         // Check form objects in IE (multiple bugs related)
2404                         // Only use nodeValue if the attribute node exists on the form
2405                         var ret = elem.getAttributeNode( name );
2406                         if ( ret ) {
2407                                 ret.nodeValue = value;
2408                                 return value;
2409                         }
2410                 }
2411         };
2412
2413         // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2414         // This is for removals
2415         jQuery.each([ "width", "height" ], function( i, name ) {
2416                 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2417                         set: function( elem, value ) {
2418                                 if ( value === "" ) {
2419                                         elem.setAttribute( name, "auto" );
2420                                         return value;
2421                                 }
2422                         }
2423                 });
2424         });
2425 }
2426
2427
2428 // Some attributes require a special call on IE
2429 if ( !jQuery.support.hrefNormalized ) {
2430         jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2431                 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2432                         get: function( elem ) {
2433                                 var ret = elem.getAttribute( name, 2 );
2434                                 return ret === null ? undefined : ret;
2435                         }
2436                 });
2437         });
2438 }
2439
2440 if ( !jQuery.support.style ) {
2441         jQuery.attrHooks.style = {
2442                 get: function( elem ) {
2443                         // Return undefined in the case of empty string
2444                         // Normalize to lowercase since IE uppercases css property names
2445                         return elem.style.cssText.toLowerCase() || undefined;
2446                 },
2447                 set: function( elem, value ) {
2448                         return (elem.style.cssText = "" + value);
2449                 }
2450         };
2451 }
2452
2453 // Safari mis-reports the default selected property of an option
2454 // Accessing the parent's selectedIndex property fixes it
2455 if ( !jQuery.support.optSelected ) {
2456         jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2457                 get: function( elem ) {
2458                         var parent = elem.parentNode;
2459
2460                         if ( parent ) {
2461                                 parent.selectedIndex;
2462
2463                                 // Make sure that it also works with optgroups, see #5701
2464                                 if ( parent.parentNode ) {
2465                                         parent.parentNode.selectedIndex;
2466                                 }
2467                         }
2468                 }
2469         });
2470 }
2471
2472 // Radios and checkboxes getter/setter
2473 if ( !jQuery.support.checkOn ) {
2474         jQuery.each([ "radio", "checkbox" ], function() {
2475                 jQuery.valHooks[ this ] = {
2476                         get: function( elem ) {
2477                                 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2478                                 return elem.getAttribute("value") === null ? "on" : elem.value;
2479                         }
2480                 };
2481         });
2482 }
2483 jQuery.each([ "radio", "checkbox" ], function() {
2484         jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2485                 set: function( elem, value ) {
2486                         if ( jQuery.isArray( value ) ) {
2487                                 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2488                         }
2489                 }
2490         });
2491 });
2492
2493
2494
2495
2496 var hasOwn = Object.prototype.hasOwnProperty,
2497         rnamespaces = /\.(.*)$/,
2498         rformElems = /^(?:textarea|input|select)$/i,
2499         rperiod = /\./g,
2500         rspaces = / /g,
2501         rescape = /[^\w\s.|`]/g,
2502         fcleanup = function( nm ) {
2503                 return nm.replace(rescape, "\\$&");
2504         };
2505
2506 /*
2507  * A number of helper functions used for managing events.
2508  * Many of the ideas behind this code originated from
2509  * Dean Edwards' addEvent library.
2510  */
2511 jQuery.event = {
2512
2513         // Bind an event to an element
2514         // Original by Dean Edwards
2515         add: function( elem, types, handler, data ) {
2516                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2517                         return;
2518                 }
2519
2520                 if ( handler === false ) {
2521                         handler = returnFalse;
2522                 } else if ( !handler ) {
2523                         // Fixes bug #7229. Fix recommended by jdalton
2524                         return;
2525                 }
2526
2527                 var handleObjIn, handleObj;
2528
2529                 if ( handler.handler ) {
2530                         handleObjIn = handler;
2531                         handler = handleObjIn.handler;
2532                 }
2533
2534                 // Make sure that the function being executed has a unique ID
2535                 if ( !handler.guid ) {
2536                         handler.guid = jQuery.guid++;
2537                 }
2538
2539                 // Init the element's event structure
2540                 var elemData = jQuery._data( elem );
2541
2542                 // If no elemData is found then we must be trying to bind to one of the
2543                 // banned noData elements
2544                 if ( !elemData ) {
2545                         return;
2546                 }
2547
2548                 var events = elemData.events,
2549                         eventHandle = elemData.handle;
2550
2551                 if ( !events ) {
2552                         elemData.events = events = {};
2553                 }
2554
2555                 if ( !eventHandle ) {
2556                         elemData.handle = eventHandle = function( e ) {
2557                                 // Discard the second event of a jQuery.event.trigger() and
2558                                 // when an event is called after a page has unloaded
2559                                 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2560                                         jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2561                                         undefined;
2562                         };
2563                 }
2564
2565                 // Add elem as a property of the handle function
2566                 // This is to prevent a memory leak with non-native events in IE.
2567                 eventHandle.elem = elem;
2568
2569                 // Handle multiple events separated by a space
2570                 // jQuery(...).bind("mouseover mouseout", fn);
2571                 types = types.split(" ");
2572
2573                 var type, i = 0, namespaces;
2574
2575                 while ( (type = types[ i++ ]) ) {
2576                         handleObj = handleObjIn ?
2577                                 jQuery.extend({}, handleObjIn) :
2578                                 { handler: handler, data: data };
2579
2580                         // Namespaced event handlers
2581                         if ( type.indexOf(".") > -1 ) {
2582                                 namespaces = type.split(".");
2583                                 type = namespaces.shift();
2584                                 handleObj.namespace = namespaces.slice(0).sort().join(".");
2585
2586                         } else {
2587                                 namespaces = [];
2588                                 handleObj.namespace = "";
2589                         }
2590
2591                         handleObj.type = type;
2592                         if ( !handleObj.guid ) {
2593                                 handleObj.guid = handler.guid;
2594                         }
2595
2596                         // Get the current list of functions bound to this event
2597                         var handlers = events[ type ],
2598                                 special = jQuery.event.special[ type ] || {};
2599
2600                         // Init the event handler queue
2601                         if ( !handlers ) {
2602                                 handlers = events[ type ] = [];
2603
2604                                 // Check for a special event handler
2605                                 // Only use addEventListener/attachEvent if the special
2606                                 // events handler returns false
2607                                 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2608                                         // Bind the global event handler to the element
2609                                         if ( elem.addEventListener ) {
2610                                                 elem.addEventListener( type, eventHandle, false );
2611
2612                                         } else if ( elem.attachEvent ) {
2613                                                 elem.attachEvent( "on" + type, eventHandle );
2614                                         }
2615                                 }
2616                         }
2617
2618                         if ( special.add ) {
2619                                 special.add.call( elem, handleObj );
2620
2621                                 if ( !handleObj.handler.guid ) {
2622                                         handleObj.handler.guid = handler.guid;
2623                                 }
2624                         }
2625
2626                         // Add the function to the element's handler list
2627                         handlers.push( handleObj );
2628
2629                         // Keep track of which events have been used, for event optimization
2630                         jQuery.event.global[ type ] = true;
2631                 }
2632
2633                 // Nullify elem to prevent memory leaks in IE
2634                 elem = null;
2635         },
2636
2637         global: {},
2638
2639         // Detach an event or set of events from an element
2640         remove: function( elem, types, handler, pos ) {
2641                 // don't do events on text and comment nodes
2642                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2643                         return;
2644                 }
2645
2646                 if ( handler === false ) {
2647                         handler = returnFalse;
2648                 }
2649
2650                 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2651                         elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2652                         events = elemData && elemData.events;
2653
2654                 if ( !elemData || !events ) {
2655                         return;
2656                 }
2657
2658                 // types is actually an event object here
2659                 if ( types && types.type ) {
2660                         handler = types.handler;
2661                         types = types.type;
2662                 }
2663
2664                 // Unbind all events for the element
2665                 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2666                         types = types || "";
2667
2668                         for ( type in events ) {
2669                                 jQuery.event.remove( elem, type + types );
2670                         }
2671
2672                         return;
2673                 }
2674
2675                 // Handle multiple events separated by a space
2676                 // jQuery(...).unbind("mouseover mouseout", fn);
2677                 types = types.split(" ");
2678
2679                 while ( (type = types[ i++ ]) ) {
2680                         origType = type;
2681                         handleObj = null;
2682                         all = type.indexOf(".") < 0;
2683                         namespaces = [];
2684
2685                         if ( !all ) {
2686                                 // Namespaced event handlers
2687                                 namespaces = type.split(".");
2688                                 type = namespaces.shift();
2689
2690                                 namespace = new RegExp("(^|\\.)" +
2691                                         jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2692                         }
2693
2694                         eventType = events[ type ];
2695
2696                         if ( !eventType ) {
2697                                 continue;
2698                         }
2699
2700                         if ( !handler ) {
2701                                 for ( j = 0; j < eventType.length; j++ ) {
2702                                         handleObj = eventType[ j ];
2703
2704                                         if ( all || namespace.test( handleObj.namespace ) ) {
2705                                                 jQuery.event.remove( elem, origType, handleObj.handler, j );
2706                                                 eventType.splice( j--, 1 );
2707                                         }
2708                                 }
2709
2710                                 continue;
2711                         }
2712
2713                         special = jQuery.event.special[ type ] || {};
2714
2715                         for ( j = pos || 0; j < eventType.length; j++ ) {
2716                                 handleObj = eventType[ j ];
2717
2718                                 if ( handler.guid === handleObj.guid ) {
2719                                         // remove the given handler for the given type
2720                                         if ( all || namespace.test( handleObj.namespace ) ) {
2721                                                 if ( pos == null ) {
2722                                                         eventType.splice( j--, 1 );
2723                                                 }
2724
2725                                                 if ( special.remove ) {
2726                                                         special.remove.call( elem, handleObj );
2727                                                 }
2728                                         }
2729
2730                                         if ( pos != null ) {
2731                                                 break;
2732                                         }
2733                                 }
2734                         }
2735
2736                         // remove generic event handler if no more handlers exist
2737                         if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2738                                 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2739                                         jQuery.removeEvent( elem, type, elemData.handle );
2740                                 }
2741
2742                                 ret = null;
2743                                 delete events[ type ];
2744                         }
2745                 }
2746
2747                 // Remove the expando if it's no longer used
2748                 if ( jQuery.isEmptyObject( events ) ) {
2749                         var handle = elemData.handle;
2750                         if ( handle ) {
2751                                 handle.elem = null;
2752                         }
2753
2754                         delete elemData.events;
2755                         delete elemData.handle;
2756
2757                         if ( jQuery.isEmptyObject( elemData ) ) {
2758                                 jQuery.removeData( elem, undefined, true );
2759                         }
2760                 }
2761         },
2762
2763         // Events that are safe to short-circuit if no handlers are attached.
2764         // Native DOM events should not be added, they may have inline handlers.
2765         customEvent: {
2766                 "getData": true,
2767                 "setData": true,
2768                 "changeData": true
2769         },
2770
2771         trigger: function( event, data, elem, onlyHandlers ) {
2772                 // Event object or event type
2773                 var type = event.type || event,
2774                         namespaces = [],
2775                         exclusive;
2776
2777                 if ( type.indexOf("!") >= 0 ) {
2778                         // Exclusive events trigger only for the exact event (no namespaces)
2779                         type = type.slice(0, -1);
2780                         exclusive = true;
2781                 }
2782
2783                 if ( type.indexOf(".") >= 0 ) {
2784                         // Namespaced trigger; create a regexp to match event type in handle()
2785                         namespaces = type.split(".");
2786                         type = namespaces.shift();
2787                         namespaces.sort();
2788                 }
2789
2790                 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2791                         // No jQuery handlers for this event type, and it can't have inline handlers
2792                         return;
2793                 }
2794
2795                 // Caller can pass in an Event, Object, or just an event type string
2796                 event = typeof event === "object" ?
2797                         // jQuery.Event object
2798                         event[ jQuery.expando ] ? event :
2799                         // Object literal
2800                         new jQuery.Event( type, event ) :
2801                         // Just the event type (string)
2802                         new jQuery.Event( type );
2803
2804                 event.type = type;
2805                 event.exclusive = exclusive;
2806                 event.namespace = namespaces.join(".");
2807                 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
2808
2809                 // triggerHandler() and global events don't bubble or run the default action
2810                 if ( onlyHandlers || !elem ) {
2811                         event.preventDefault();
2812                         event.stopPropagation();
2813                 }
2814
2815                 // Handle a global trigger
2816                 if ( !elem ) {
2817                         // TODO: Stop taunting the data cache; remove global events and always attach to document
2818                         jQuery.each( jQuery.cache, function() {
2819                                 // internalKey variable is just used to make it easier to find
2820                                 // and potentially change this stuff later; currently it just
2821                                 // points to jQuery.expando
2822                                 var internalKey = jQuery.expando,
2823                                         internalCache = this[ internalKey ];
2824                                 if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2825                                         jQuery.event.trigger( event, data, internalCache.handle.elem );
2826                                 }
2827                         });
2828                         return;
2829                 }
2830
2831                 // Don't do events on text and comment nodes
2832                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2833                         return;
2834                 }
2835
2836                 // Clean up the event in case it is being reused
2837                 event.result = undefined;
2838                 event.target = elem;
2839
2840                 // Clone any incoming data and prepend the event, creating the handler arg list
2841                 data = data ? jQuery.makeArray( data ) : [];
2842                 data.unshift( event );
2843
2844                 var cur = elem,
2845                         // IE doesn't like method names with a colon (#3533, #8272)
2846                         ontype = type.indexOf(":") < 0 ? "on" + type : "";
2847
2848                 // Fire event on the current element, then bubble up the DOM tree
2849                 do {
2850                         var handle = jQuery._data( cur, "handle" );
2851
2852                         event.currentTarget = cur;
2853                         if ( handle ) {
2854                                 handle.apply( cur, data );
2855                         }
2856
2857                         // Trigger an inline bound script
2858                         if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
2859                                 event.result = false;
2860                                 event.preventDefault();
2861                         }
2862
2863                         // Bubble up to document, then to window
2864                         cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
2865                 } while ( cur && !event.isPropagationStopped() );
2866
2867                 // If nobody prevented the default action, do it now
2868                 if ( !event.isDefaultPrevented() ) {
2869                         var old,
2870                                 special = jQuery.event.special[ type ] || {};
2871
2872                         if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
2873                                 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2874
2875                                 // Call a native DOM method on the target with the same name name as the event.
2876                                 // Can't use an .isFunction)() check here because IE6/7 fails that test.
2877                                 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
2878                                 try {
2879                                         if ( ontype && elem[ type ] ) {
2880                                                 // Don't re-trigger an onFOO event when we call its FOO() method
2881                                                 old = elem[ ontype ];
2882
2883                                                 if ( old ) {
2884                                                         elem[ ontype ] = null;
2885                                                 }
2886
2887                                                 jQuery.event.triggered = type;
2888                                                 elem[ type ]();
2889                                         }
2890                                 } catch ( ieError ) {}
2891
2892                                 if ( old ) {
2893                                         elem[ ontype ] = old;
2894                                 }
2895
2896                                 jQuery.event.triggered = undefined;
2897                         }
2898                 }
2899
2900                 return event.result;
2901         },
2902
2903         handle: function( event ) {
2904                 event = jQuery.event.fix( event || window.event );
2905                 // Snapshot the handlers list since a called handler may add/remove events.
2906                 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
2907                         run_all = !event.exclusive && !event.namespace,
2908                         args = Array.prototype.slice.call( arguments, 0 );
2909
2910                 // Use the fix-ed Event rather than the (read-only) native event
2911                 args[0] = event;
2912                 event.currentTarget = this;
2913
2914                 for ( var j = 0, l = handlers.length; j < l; j++ ) {
2915                         var handleObj = handlers[ j ];
2916
2917                         // Triggered event must 1) be non-exclusive and have no namespace, or
2918                         // 2) have namespace(s) a subset or equal to those in the bound event.
2919                         if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
2920                                 // Pass in a reference to the handler function itself
2921                                 // So that we can later remove it
2922                                 event.handler = handleObj.handler;
2923                                 event.data = handleObj.data;
2924                                 event.handleObj = handleObj;
2925
2926                                 var ret = handleObj.handler.apply( this, args );
2927
2928                                 if ( ret !== undefined ) {
2929                                         event.result = ret;
2930                                         if ( ret === false ) {
2931                                                 event.preventDefault();
2932                                                 event.stopPropagation();
2933                                         }
2934                                 }
2935
2936                                 if ( event.isImmediatePropagationStopped() ) {
2937                                         break;
2938                                 }
2939                         }
2940                 }
2941                 return event.result;
2942         },
2943
2944         props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2945
2946         fix: function( event ) {
2947                 if ( event[ jQuery.expando ] ) {
2948                         return event;
2949                 }
2950
2951                 // store a copy of the original event object
2952                 // and "clone" to set read-only properties
2953                 var originalEvent = event;
2954                 event = jQuery.Event( originalEvent );
2955
2956                 for ( var i = this.props.length, prop; i; ) {
2957                         prop = this.props[ --i ];
2958                         event[ prop ] = originalEvent[ prop ];
2959                 }
2960
2961                 // Fix target property, if necessary
2962                 if ( !event.target ) {
2963                         // Fixes #1925 where srcElement might not be defined either
2964                         event.target = event.srcElement || document;
2965                 }
2966
2967                 // check if target is a textnode (safari)
2968                 if ( event.target.nodeType === 3 ) {
2969                         event.target = event.target.parentNode;
2970                 }
2971
2972                 // Add relatedTarget, if necessary
2973                 if ( !event.relatedTarget && event.fromElement ) {
2974                         event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2975                 }
2976
2977                 // Calculate pageX/Y if missing and clientX/Y available
2978                 if ( event.pageX == null && event.clientX != null ) {
2979                         var eventDocument = event.target.ownerDocument || document,
2980                                 doc = eventDocument.documentElement,
2981                                 body = eventDocument.body;
2982
2983                         event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2984                         event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
2985                 }
2986
2987                 // Add which for key events
2988                 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2989                         event.which = event.charCode != null ? event.charCode : event.keyCode;
2990                 }
2991
2992                 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2993                 if ( !event.metaKey && event.ctrlKey ) {
2994                         event.metaKey = event.ctrlKey;
2995                 }
2996
2997                 // Add which for click: 1 === left; 2 === middle; 3 === right
2998                 // Note: button is not normalized, so don't use it
2999                 if ( !event.which && event.button !== undefined ) {
3000                         event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
3001                 }
3002
3003                 return event;
3004         },
3005
3006         // Deprecated, use jQuery.guid instead
3007         guid: 1E8,
3008
3009         // Deprecated, use jQuery.proxy instead
3010         proxy: jQuery.proxy,
3011
3012         special: {
3013                 ready: {
3014                         // Make sure the ready event is setup
3015                         setup: jQuery.bindReady,
3016                         teardown: jQuery.noop
3017                 },
3018
3019                 live: {
3020                         add: function( handleObj ) {
3021                                 jQuery.event.add( this,
3022                                         liveConvert( handleObj.origType, handleObj.selector ),
3023                                         jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
3024                         },
3025
3026                         remove: function( handleObj ) {
3027                                 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
3028                         }
3029                 },
3030
3031                 beforeunload: {
3032                         setup: function( data, namespaces, eventHandle ) {
3033                                 // We only want to do this special case on windows
3034                                 if ( jQuery.isWindow( this ) ) {
3035                                         this.onbeforeunload = eventHandle;
3036                                 }
3037                         },
3038
3039                         teardown: function( namespaces, eventHandle ) {
3040                                 if ( this.onbeforeunload === eventHandle ) {
3041                                         this.onbeforeunload = null;
3042                                 }
3043                         }
3044                 }
3045         }
3046 };
3047
3048 jQuery.removeEvent = document.removeEventListener ?
3049         function( elem, type, handle ) {
3050                 if ( elem.removeEventListener ) {
3051                         elem.removeEventListener( type, handle, false );
3052                 }
3053         } :
3054         function( elem, type, handle ) {
3055                 if ( elem.detachEvent ) {
3056                         elem.detachEvent( "on" + type, handle );
3057                 }
3058         };
3059
3060 jQuery.Event = function( src, props ) {
3061         // Allow instantiation without the 'new' keyword
3062         if ( !this.preventDefault ) {
3063                 return new jQuery.Event( src, props );
3064         }
3065
3066         // Event object
3067         if ( src && src.type ) {
3068                 this.originalEvent = src;
3069                 this.type = src.type;
3070
3071                 // Events bubbling up the document may have been marked as prevented
3072                 // by a handler lower down the tree; reflect the correct value.
3073                 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
3074                         src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
3075
3076         // Event type
3077         } else {
3078                 this.type = src;
3079         }
3080
3081         // Put explicitly provided properties onto the event object
3082         if ( props ) {
3083                 jQuery.extend( this, props );
3084         }
3085
3086         // timeStamp is buggy for some events on Firefox(#3843)
3087         // So we won't rely on the native value
3088         this.timeStamp = jQuery.now();
3089
3090         // Mark it as fixed
3091         this[ jQuery.expando ] = true;
3092 };
3093
3094 function returnFalse() {
3095         return false;
3096 }
3097 function returnTrue() {
3098         return true;
3099 }
3100
3101 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3102 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3103 jQuery.Event.prototype = {
3104         preventDefault: function() {
3105                 this.isDefaultPrevented = returnTrue;
3106
3107                 var e = this.originalEvent;
3108                 if ( !e ) {
3109                         return;
3110                 }
3111
3112                 // if preventDefault exists run it on the original event
3113                 if ( e.preventDefault ) {
3114                         e.preventDefault();
3115
3116                 // otherwise set the returnValue property of the original event to false (IE)
3117                 } else {
3118                         e.returnValue = false;
3119                 }
3120         },
3121         stopPropagation: function() {
3122                 this.isPropagationStopped = returnTrue;
3123
3124                 var e = this.originalEvent;
3125                 if ( !e ) {
3126                         return;
3127                 }
3128                 // if stopPropagation exists run it on the original event
3129                 if ( e.stopPropagation ) {
3130                         e.stopPropagation();
3131                 }
3132                 // otherwise set the cancelBubble property of the original event to true (IE)
3133                 e.cancelBubble = true;
3134         },
3135         stopImmediatePropagation: function() {
3136                 this.isImmediatePropagationStopped = returnTrue;
3137                 this.stopPropagation();
3138         },
3139         isDefaultPrevented: returnFalse,
3140         isPropagationStopped: returnFalse,
3141         isImmediatePropagationStopped: returnFalse
3142 };
3143
3144 // Checks if an event happened on an element within another element
3145 // Used in jQuery.event.special.mouseenter and mouseleave handlers
3146 var withinElement = function( event ) {
3147         // Check if mouse(over|out) are still within the same parent element
3148         var parent = event.relatedTarget;
3149
3150         // set the correct event type
3151         event.type = event.data;
3152
3153         // Firefox sometimes assigns relatedTarget a XUL element
3154         // which we cannot access the parentNode property of
3155         try {
3156
3157                 // Chrome does something similar, the parentNode property
3158                 // can be accessed but is null.
3159                 if ( parent && parent !== document && !parent.parentNode ) {
3160                         return;
3161                 }
3162
3163                 // Traverse up the tree
3164                 while ( parent && parent !== this ) {
3165                         parent = parent.parentNode;
3166                 }
3167
3168                 if ( parent !== this ) {
3169                         // handle event if we actually just moused on to a non sub-element
3170                         jQuery.event.handle.apply( this, arguments );
3171                 }
3172
3173         // assuming we've left the element since we most likely mousedover a xul element
3174         } catch(e) { }
3175 },
3176
3177 // In case of event delegation, we only need to rename the event.type,
3178 // liveHandler will take care of the rest.
3179 delegate = function( event ) {
3180         event.type = event.data;
3181         jQuery.event.handle.apply( this, arguments );
3182 };
3183
3184 // Create mouseenter and mouseleave events
3185 jQuery.each({
3186         mouseenter: "mouseover",
3187         mouseleave: "mouseout"
3188 }, function( orig, fix ) {
3189         jQuery.event.special[ orig ] = {
3190                 setup: function( data ) {
3191                         jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
3192                 },
3193                 teardown: function( data ) {
3194                         jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
3195                 }
3196         };
3197 });
3198
3199 // submit delegation
3200 if ( !jQuery.support.submitBubbles ) {
3201
3202         jQuery.event.special.submit = {
3203                 setup: function( data, namespaces ) {
3204                         if ( !jQuery.nodeName( this, "form" ) ) {
3205                                 jQuery.event.add(this, "click.specialSubmit", function( e ) {
3206                                         var elem = e.target,
3207                                                 type = elem.type;
3208
3209                                         if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
3210                                                 trigger( "submit", this, arguments );
3211                                         }
3212                                 });
3213
3214                                 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
3215                                         var elem = e.target,
3216                                                 type = elem.type;
3217
3218                                         if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
3219                                                 trigger( "submit", this, arguments );
3220                                         }
3221                                 });
3222
3223                         } else {
3224                                 return false;
3225                         }
3226                 },
3227
3228                 teardown: function( namespaces ) {
3229                         jQuery.event.remove( this, ".specialSubmit" );
3230                 }
3231         };
3232
3233 }
3234
3235 // change delegation, happens here so we have bind.
3236 if ( !jQuery.support.changeBubbles ) {
3237
3238         var changeFilters,
3239
3240         getVal = function( elem ) {
3241                 var type = elem.type, val = elem.value;
3242
3243                 if ( type === "radio" || type === "checkbox" ) {
3244                         val = elem.checked;
3245
3246                 } else if ( type === "select-multiple" ) {
3247                         val = elem.selectedIndex > -1 ?
3248                                 jQuery.map( elem.options, function( elem ) {
3249                                         return elem.selected;
3250                                 }).join("-") :
3251                                 "";
3252
3253                 } else if ( jQuery.nodeName( elem, "select" ) ) {
3254                         val = elem.selectedIndex;
3255                 }
3256
3257                 return val;
3258         },
3259
3260         testChange = function testChange( e ) {
3261                 var elem = e.target, data, val;
3262
3263                 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
3264                         return;
3265                 }
3266
3267                 data = jQuery._data( elem, "_change_data" );
3268                 val = getVal(elem);
3269
3270                 // the current data will be also retrieved by beforeactivate
3271                 if ( e.type !== "focusout" || elem.type !== "radio" ) {
3272                         jQuery._data( elem, "_change_data", val );
3273                 }
3274
3275                 if ( data === undefined || val === data ) {
3276                         return;
3277                 }
3278
3279                 if ( data != null || val ) {
3280                         e.type = "change";
3281                         e.liveFired = undefined;
3282                         jQuery.event.trigger( e, arguments[1], elem );
3283                 }
3284         };
3285
3286         jQuery.event.special.change = {
3287                 filters: {
3288                         focusout: testChange,
3289
3290                         beforedeactivate: testChange,
3291
3292                         click: function( e ) {
3293                                 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3294
3295                                 if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
3296                                         testChange.call( this, e );
3297                                 }
3298                         },
3299
3300                         // Change has to be called before submit
3301                         // Keydown will be called before keypress, which is used in submit-event delegation
3302                         keydown: function( e ) {
3303                                 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3304
3305                                 if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
3306                                         (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
3307                                         type === "select-multiple" ) {
3308                                         testChange.call( this, e );
3309                                 }
3310                         },
3311
3312                         // Beforeactivate happens also before the previous element is blurred
3313                         // with this event you can't trigger a change event, but you can store
3314                         // information
3315                         beforeactivate: function( e ) {
3316                                 var elem = e.target;
3317                                 jQuery._data( elem, "_change_data", getVal(elem) );
3318                         }
3319                 },
3320
3321                 setup: function( data, namespaces ) {
3322                         if ( this.type === "file" ) {
3323                                 return false;
3324                         }
3325
3326                         for ( var type in changeFilters ) {
3327                                 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
3328                         }
3329
3330                         return rformElems.test( this.nodeName );
3331                 },
3332
3333                 teardown: function( namespaces ) {
3334                         jQuery.event.remove( this, ".specialChange" );
3335
3336                         return rformElems.test( this.nodeName );
3337                 }
3338         };
3339
3340         changeFilters = jQuery.event.special.change.filters;
3341
3342         // Handle when the input is .focus()'d
3343         changeFilters.focus = changeFilters.beforeactivate;
3344 }
3345
3346 function trigger( type, elem, args ) {
3347         // Piggyback on a donor event to simulate a different one.
3348         // Fake originalEvent to avoid donor's stopPropagation, but if the
3349         // simulated event prevents default then we do the same on the donor.
3350         // Don't pass args or remember liveFired; they apply to the donor event.
3351         var event = jQuery.extend( {}, args[ 0 ] );
3352         event.type = type;
3353         event.originalEvent = {};
3354         event.liveFired = undefined;
3355         jQuery.event.handle.call( elem, event );
3356         if ( event.isDefaultPrevented() ) {
3357                 args[ 0 ].preventDefault();
3358         }
3359 }
3360
3361 // Create "bubbling" focus and blur events
3362 if ( !jQuery.support.focusinBubbles ) {
3363         jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3364
3365                 // Attach a single capturing handler while someone wants focusin/focusout
3366                 var attaches = 0;
3367
3368                 jQuery.event.special[ fix ] = {
3369                         setup: function() {
3370                                 if ( attaches++ === 0 ) {
3371                                         document.addEventListener( orig, handler, true );
3372                                 }
3373                         },
3374                         teardown: function() {
3375                                 if ( --attaches === 0 ) {
3376                                         document.removeEventListener( orig, handler, true );
3377                                 }
3378                         }
3379                 };
3380
3381                 function handler( donor ) {
3382                         // Donor event is always a native one; fix it and switch its type.
3383                         // Let focusin/out handler cancel the donor focus/blur event.
3384                         var e = jQuery.event.fix( donor );
3385                         e.type = fix;
3386                         e.originalEvent = {};
3387                         jQuery.event.trigger( e, null, e.target );
3388                         if ( e.isDefaultPrevented() ) {
3389                                 donor.preventDefault();
3390                         }
3391                 }
3392         });
3393 }
3394
3395 jQuery.each(["bind", "one"], function( i, name ) {
3396         jQuery.fn[ name ] = function( type, data, fn ) {
3397                 var handler;
3398
3399                 // Handle object literals
3400                 if ( typeof type === "object" ) {
3401                         for ( var key in type ) {
3402                                 this[ name ](key, data, type[key], fn);
3403                         }
3404                         return this;
3405                 }
3406
3407                 if ( arguments.length === 2 || data === false ) {
3408                         fn = data;
3409                         data = undefined;
3410                 }
3411
3412                 if ( name === "one" ) {
3413                         handler = function( event ) {
3414                                 jQuery( this ).unbind( event, handler );
3415                                 return fn.apply( this, arguments );
3416                         };
3417                         handler.guid = fn.guid || jQuery.guid++;
3418                 } else {
3419                         handler = fn;
3420                 }
3421
3422                 if ( type === "unload" && name !== "one" ) {
3423                         this.one( type, data, fn );
3424
3425                 } else {
3426                         for ( var i = 0, l = this.length; i < l; i++ ) {
3427                                 jQuery.event.add( this[i], type, handler, data );
3428                         }
3429                 }
3430
3431                 return this;
3432         };
3433 });
3434
3435 jQuery.fn.extend({
3436         unbind: function( type, fn ) {
3437                 // Handle object literals
3438                 if ( typeof type === "object" && !type.preventDefault ) {
3439                         for ( var key in type ) {
3440                                 this.unbind(key, type[key]);
3441                         }
3442
3443                 } else {
3444                         for ( var i = 0, l = this.length; i < l; i++ ) {
3445                                 jQuery.event.remove( this[i], type, fn );
3446                         }
3447                 }
3448
3449                 return this;
3450         },
3451
3452         delegate: function( selector, types, data, fn ) {
3453                 return this.live( types, data, fn, selector );
3454         },
3455
3456         undelegate: function( selector, types, fn ) {
3457                 if ( arguments.length === 0 ) {
3458                         return this.unbind( "live" );
3459
3460                 } else {
3461                         return this.die( types, null, fn, selector );
3462                 }
3463         },
3464
3465         trigger: function( type, data ) {
3466                 return this.each(function() {
3467                         jQuery.event.trigger( type, data, this );
3468                 });
3469         },
3470
3471         triggerHandler: function( type, data ) {
3472                 if ( this[0] ) {
3473                         return jQuery.event.trigger( type, data, this[0], true );
3474                 }
3475         },
3476
3477         toggle: function( fn ) {
3478                 // Save reference to arguments for access in closure
3479                 var args = arguments,
3480                         guid = fn.guid || jQuery.guid++,
3481                         i = 0,
3482                         toggler = function( event ) {
3483                                 // Figure out which function to execute
3484                                 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3485                                 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3486
3487                                 // Make sure that clicks stop
3488                                 event.preventDefault();
3489
3490                                 // and execute the function
3491                                 return args[ lastToggle ].apply( this, arguments ) || false;
3492                         };
3493
3494                 // link all the functions, so any of them can unbind this click handler
3495                 toggler.guid = guid;
3496                 while ( i < args.length ) {
3497                         args[ i++ ].guid = guid;
3498                 }
3499
3500                 return this.click( toggler );
3501         },
3502
3503         hover: function( fnOver, fnOut ) {
3504                 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3505         }
3506 });
3507
3508 var liveMap = {
3509         focus: "focusin",
3510         blur: "focusout",
3511         mouseenter: "mouseover",
3512         mouseleave: "mouseout"
3513 };
3514
3515 jQuery.each(["live", "die"], function( i, name ) {
3516         jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
3517                 var type, i = 0, match, namespaces, preType,
3518                         selector = origSelector || this.selector,
3519                         context = origSelector ? this : jQuery( this.context );
3520
3521                 if ( typeof types === "object" && !types.preventDefault ) {
3522                         for ( var key in types ) {
3523                                 context[ name ]( key, data, types[key], selector );
3524                         }
3525
3526                         return this;
3527                 }
3528
3529                 if ( name === "die" && !types &&
3530                                         origSelector && origSelector.charAt(0) === "." ) {
3531
3532                         context.unbind( origSelector );
3533
3534                         return this;
3535                 }
3536
3537                 if ( data === false || jQuery.isFunction( data ) ) {
3538                         fn = data || returnFalse;
3539                         data = undefined;
3540                 }
3541
3542                 types = (types || "").split(" ");
3543
3544                 while ( (type = types[ i++ ]) != null ) {
3545                         match = rnamespaces.exec( type );
3546                         namespaces = "";
3547
3548                         if ( match )  {
3549                                 namespaces = match[0];
3550                                 type = type.replace( rnamespaces, "" );
3551                         }
3552
3553                         if ( type === "hover" ) {
3554                                 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
3555                                 continue;
3556                         }
3557
3558                         preType = type;
3559
3560                         if ( liveMap[ type ] ) {
3561                                 types.push( liveMap[ type ] + namespaces );
3562                                 type = type + namespaces;
3563
3564                         } else {
3565                                 type = (liveMap[ type ] || type) + namespaces;
3566                         }
3567
3568                         if ( name === "live" ) {
3569                                 // bind live handler
3570                                 for ( var j = 0, l = context.length; j < l; j++ ) {
3571                                         jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
3572                                                 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
3573                                 }
3574
3575                         } else {
3576                                 // unbind live handler
3577                                 context.unbind( "live." + liveConvert( type, selector ), fn );
3578                         }
3579                 }
3580
3581                 return this;
3582         };
3583 });
3584
3585 function liveHandler( event ) {
3586         var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
3587                 elems = [],
3588                 selectors = [],
3589                 events = jQuery._data( this, "events" );
3590
3591         // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
3592         if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
3593                 return;
3594         }
3595
3596         if ( event.namespace ) {
3597                 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
3598         }
3599
3600         event.liveFired = this;
3601
3602         var live = events.live.slice(0);
3603
3604         for ( j = 0; j < live.length; j++ ) {
3605                 handleObj = live[j];
3606
3607                 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
3608                         selectors.push( handleObj.selector );
3609
3610                 } else {
3611                         live.splice( j--, 1 );
3612                 }
3613         }
3614
3615         match = jQuery( event.target ).closest( selectors, event.currentTarget );
3616
3617         for ( i = 0, l = match.length; i < l; i++ ) {
3618                 close = match[i];
3619
3620                 for ( j = 0; j < live.length; j++ ) {
3621                         handleObj = live[j];
3622
3623                         if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
3624                                 elem = close.elem;
3625                                 related = null;
3626
3627                                 // Those two events require additional checking
3628                                 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
3629                                         event.type = handleObj.preType;
3630                                         related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
3631
3632                                         // Make sure not to accidentally match a child element with the same selector
3633                                         if ( related && jQuery.contains( elem, related ) ) {
3634                                                 related = elem;
3635                                         }
3636                                 }
3637
3638                                 if ( !related || related !== elem ) {
3639                                         elems.push({ elem: elem, handleObj: handleObj, level: close.level });
3640                                 }
3641                         }
3642                 }
3643         }
3644
3645         for ( i = 0, l = elems.length; i < l; i++ ) {
3646                 match = elems[i];
3647
3648                 if ( maxLevel && match.level > maxLevel ) {
3649                         break;
3650                 }
3651
3652                 event.currentTarget = match.elem;
3653                 event.data = match.handleObj.data;
3654                 event.handleObj = match.handleObj;
3655
3656                 ret = match.handleObj.origHandler.apply( match.elem, arguments );
3657
3658                 if ( ret === false || event.isPropagationStopped() ) {
3659                         maxLevel = match.level;
3660
3661                         if ( ret === false ) {
3662                                 stop = false;
3663                         }
3664                         if ( event.isImmediatePropagationStopped() ) {
3665                                 break;
3666                         }
3667                 }
3668         }
3669
3670         return stop;
3671 }
3672
3673 function liveConvert( type, selector ) {
3674         return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
3675 }
3676
3677 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3678         "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3679         "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
3680
3681         // Handle event binding
3682         jQuery.fn[ name ] = function( data, fn ) {
3683                 if ( fn == null ) {
3684                         fn = data;
3685                         data = null;
3686                 }
3687
3688                 return arguments.length > 0 ?
3689                         this.bind( name, data, fn ) :
3690                         this.trigger( name );
3691         };
3692
3693         if ( jQuery.attrFn ) {
3694                 jQuery.attrFn[ name ] = true;
3695         }
3696 });
3697
3698
3699
3700 /*!
3701  * Sizzle CSS Selector Engine
3702  *  Copyright 2011, The Dojo Foundation
3703  *  Released under the MIT, BSD, and GPL Licenses.
3704  *  More information: http://sizzlejs.com/
3705  */
3706 (function(){
3707
3708 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3709         done = 0,
3710         toString = Object.prototype.toString,
3711         hasDuplicate = false,
3712         baseHasDuplicate = true,
3713         rBackslash = /\\/g,
3714         rNonWord = /\W/;
3715
3716 // Here we check if the JavaScript engine is using some sort of
3717 // optimization where it does not always call our comparision
3718 // function. If that is the case, discard the hasDuplicate value.
3719 //   Thus far that includes Google Chrome.
3720 [0, 0].sort(function() {
3721         baseHasDuplicate = false;
3722         return 0;
3723 });
3724
3725 var Sizzle = function( selector, context, results, seed ) {
3726         results = results || [];
3727         context = context || document;
3728
3729         var origContext = context;
3730
3731         if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3732                 return [];
3733         }
3734
3735         if ( !selector || typeof selector !== "string" ) {
3736                 return results;
3737         }
3738
3739         var m, set, checkSet, extra, ret, cur, pop, i,
3740                 prune = true,
3741                 contextXML = Sizzle.isXML( context ),
3742                 parts = [],
3743                 soFar = selector;
3744
3745         // Reset the position of the chunker regexp (start from head)
3746         do {
3747                 chunker.exec( "" );
3748                 m = chunker.exec( soFar );
3749
3750                 if ( m ) {
3751                         soFar = m[3];
3752
3753                         parts.push( m[1] );
3754
3755                         if ( m[2] ) {
3756                                 extra = m[3];
3757                                 break;
3758                         }
3759                 }
3760         } while ( m );
3761
3762         if ( parts.length > 1 && origPOS.exec( selector ) ) {
3763
3764                 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3765                         set = posProcess( parts[0] + parts[1], context );
3766
3767                 } else {
3768                         set = Expr.relative[ parts[0] ] ?
3769                                 [ context ] :
3770                                 Sizzle( parts.shift(), context );
3771
3772                         while ( parts.length ) {
3773                                 selector = parts.shift();
3774
3775                                 if ( Expr.relative[ selector ] ) {
3776                                         selector += parts.shift();
3777                                 }
3778
3779                                 set = posProcess( selector, set );
3780                         }
3781                 }
3782
3783         } else {
3784                 // Take a shortcut and set the context if the root selector is an ID
3785                 // (but not if it'll be faster if the inner selector is an ID)
3786                 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3787                                 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3788
3789                         ret = Sizzle.find( parts.shift(), context, contextXML );
3790                         context = ret.expr ?
3791                                 Sizzle.filter( ret.expr, ret.set )[0] :
3792                                 ret.set[0];
3793                 }
3794
3795                 if ( context ) {
3796                         ret = seed ?
3797                                 { expr: parts.pop(), set: makeArray(seed) } :
3798                                 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3799
3800                         set = ret.expr ?
3801                                 Sizzle.filter( ret.expr, ret.set ) :
3802                                 ret.set;
3803
3804                         if ( parts.length > 0 ) {
3805                                 checkSet = makeArray( set );
3806
3807                         } else {
3808                                 prune = false;
3809                         }
3810
3811                         while ( parts.length ) {
3812                                 cur = parts.pop();
3813                                 pop = cur;
3814
3815                                 if ( !Expr.relative[ cur ] ) {
3816                                         cur = "";
3817                                 } else {
3818                                         pop = parts.pop();
3819                                 }
3820
3821                                 if ( pop == null ) {
3822                                         pop = context;
3823                                 }
3824
3825                                 Expr.relative[ cur ]( checkSet, pop, contextXML );
3826                         }
3827
3828                 } else {
3829                         checkSet = parts = [];
3830                 }
3831         }
3832
3833         if ( !checkSet ) {
3834                 checkSet = set;
3835         }
3836
3837         if ( !checkSet ) {
3838                 Sizzle.error( cur || selector );
3839         }
3840
3841         if ( toString.call(checkSet) === "[object Array]" ) {
3842                 if ( !prune ) {
3843                         results.push.apply( results, checkSet );
3844
3845                 } else if ( context && context.nodeType === 1 ) {
3846                         for ( i = 0; checkSet[i] != null; i++ ) {
3847                                 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3848                                         results.push( set[i] );
3849                                 }
3850                         }
3851
3852                 } else {
3853                         for ( i = 0; checkSet[i] != null; i++ ) {
3854                                 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3855                                         results.push( set[i] );
3856                                 }
3857                         }
3858                 }
3859
3860         } else {
3861                 makeArray( checkSet, results );
3862         }
3863
3864         if ( extra ) {
3865                 Sizzle( extra, origContext, results, seed );
3866                 Sizzle.uniqueSort( results );
3867         }
3868
3869         return results;
3870 };
3871
3872 Sizzle.uniqueSort = function( results ) {
3873         if ( sortOrder ) {
3874                 hasDuplicate = baseHasDuplicate;
3875                 results.sort( sortOrder );
3876
3877                 if ( hasDuplicate ) {
3878                         for ( var i = 1; i < results.length; i++ ) {
3879                                 if ( results[i] === results[ i - 1 ] ) {
3880                                         results.splice( i--, 1 );
3881                                 }
3882                         }
3883                 }
3884         }
3885
3886         return results;
3887 };
3888
3889 Sizzle.matches = function( expr, set ) {
3890         return Sizzle( expr, null, null, set );
3891 };
3892
3893 Sizzle.matchesSelector = function( node, expr ) {
3894         return Sizzle( expr, null, null, [node] ).length > 0;
3895 };
3896
3897 Sizzle.find = function( expr, context, isXML ) {
3898         var set;
3899
3900         if ( !expr ) {
3901                 return [];
3902         }
3903
3904         for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3905                 var match,
3906                         type = Expr.order[i];
3907
3908                 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3909                         var left = match[1];
3910                         match.splice( 1, 1 );
3911
3912                         if ( left.substr( left.length - 1 ) !== "\\" ) {
3913                                 match[1] = (match[1] || "").replace( rBackslash, "" );
3914                                 set = Expr.find[ type ]( match, context, isXML );
3915
3916                                 if ( set != null ) {
3917                                         expr = expr.replace( Expr.match[ type ], "" );
3918                                         break;
3919                                 }
3920                         }
3921                 }
3922         }
3923
3924         if ( !set ) {
3925                 set = typeof context.getElementsByTagName !== "undefined" ?
3926                         context.getElementsByTagName( "*" ) :
3927                         [];
3928         }
3929
3930         return { set: set, expr: expr };
3931 };
3932
3933 Sizzle.filter = function( expr, set, inplace, not ) {
3934         var match, anyFound,
3935                 old = expr,
3936                 result = [],
3937                 curLoop = set,
3938                 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
3939
3940         while ( expr && set.length ) {
3941                 for ( var type in Expr.filter ) {
3942                         if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3943                                 var found, item,
3944                                         filter = Expr.filter[ type ],
3945                                         left = match[1];
3946
3947                                 anyFound = false;
3948
3949                                 match.splice(1,1);
3950
3951                                 if ( left.substr( left.length - 1 ) === "\\" ) {
3952                                         continue;
3953                                 }
3954
3955                                 if ( curLoop === result ) {
3956                                         result = [];
3957                                 }
3958
3959                                 if ( Expr.preFilter[ type ] ) {
3960                                         match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3961
3962                                         if ( !match ) {
3963                                                 anyFound = found = true;
3964
3965                                         } else if ( match === true ) {
3966                                                 continue;
3967                                         }
3968                                 }
3969
3970                                 if ( match ) {
3971                                         for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
3972                                                 if ( item ) {
3973                                                         found = filter( item, match, i, curLoop );
3974                                                         var pass = not ^ !!found;
3975
3976                                                         if ( inplace && found != null ) {
3977                                                                 if ( pass ) {
3978                                                                         anyFound = true;
3979
3980                                                                 } else {
3981                                                                         curLoop[i] = false;
3982                                                                 }
3983
3984                                                         } else if ( pass ) {
3985                                                                 result.push( item );
3986                                                                 anyFound = true;
3987                                                         }
3988                                                 }
3989                                         }
3990                                 }
3991
3992                                 if ( found !== undefined ) {
3993                                         if ( !inplace ) {
3994                                                 curLoop = result;
3995                                         }
3996
3997                                         expr = expr.replace( Expr.match[ type ], "" );
3998
3999                                         if ( !anyFound ) {
4000                                                 return [];
4001                                         }
4002
4003                                         break;
4004                                 }
4005                         }
4006                 }
4007
4008                 // Improper expression
4009                 if ( expr === old ) {
4010                         if ( anyFound == null ) {
4011                                 Sizzle.error( expr );
4012
4013                         } else {
4014                                 break;
4015                         }
4016                 }
4017
4018                 old = expr;
4019         }
4020
4021         return curLoop;
4022 };
4023
4024 Sizzle.error = function( msg ) {
4025         throw "Syntax error, unrecognized expression: " + msg;
4026 };
4027
4028 var Expr = Sizzle.selectors = {
4029         order: [ "ID", "NAME", "TAG" ],
4030
4031         match: {
4032                 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4033                 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4034                 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
4035                 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
4036                 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
4037                 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
4038                 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
4039                 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
4040         },
4041
4042         leftMatch: {},
4043
4044         attrMap: {
4045                 "class": "className",
4046                 "for": "htmlFor"
4047         },
4048
4049         attrHandle: {
4050                 href: function( elem ) {
4051                         return elem.getAttribute( "href" );
4052                 },
4053                 type: function( elem ) {
4054                         return elem.getAttribute( "type" );
4055                 }
4056         },
4057
4058         relative: {
4059                 "+": function(checkSet, part){
4060                         var isPartStr = typeof part === "string",
4061                                 isTag = isPartStr && !rNonWord.test( part ),
4062                                 isPartStrNotTag = isPartStr && !isTag;
4063
4064                         if ( isTag ) {
4065                                 part = part.toLowerCase();
4066                         }
4067
4068                         for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4069                                 if ( (elem = checkSet[i]) ) {
4070                                         while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4071
4072                                         checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
4073                                                 elem || false :
4074                                                 elem === part;
4075                                 }
4076                         }
4077
4078                         if ( isPartStrNotTag ) {
4079                                 Sizzle.filter( part, checkSet, true );
4080                         }
4081                 },
4082
4083                 ">": function( checkSet, part ) {
4084                         var elem,
4085                                 isPartStr = typeof part === "string",
4086                                 i = 0,
4087                                 l = checkSet.length;
4088
4089                         if ( isPartStr && !rNonWord.test( part ) ) {
4090                                 part = part.toLowerCase();
4091
4092                                 for ( ; i < l; i++ ) {
4093                                         elem = checkSet[i];
4094
4095                                         if ( elem ) {
4096                                                 var parent = elem.parentNode;
4097                                                 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4098                                         }
4099                                 }
4100
4101                         } else {
4102                                 for ( ; i < l; i++ ) {
4103                                         elem = checkSet[i];
4104
4105                                         if ( elem ) {
4106                                                 checkSet[i] = isPartStr ?
4107                                                         elem.parentNode :
4108                                                         elem.parentNode === part;
4109                                         }
4110                                 }
4111
4112                                 if ( isPartStr ) {
4113                                         Sizzle.filter( part, checkSet, true );
4114                                 }
4115                         }
4116                 },
4117
4118                 "": function(checkSet, part, isXML){
4119                         var nodeCheck,
4120                                 doneName = done++,
4121                                 checkFn = dirCheck;
4122
4123                         if ( typeof part === "string" && !rNonWord.test( part ) ) {
4124                                 part = part.toLowerCase();
4125                                 nodeCheck = part;
4126                                 checkFn = dirNodeCheck;
4127                         }
4128
4129                         checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4130                 },
4131
4132                 "~": function( checkSet, part, isXML ) {
4133                         var nodeCheck,
4134                                 doneName = done++,
4135                                 checkFn = dirCheck;
4136
4137                         if ( typeof part === "string" && !rNonWord.test( part ) ) {
4138                                 part = part.toLowerCase();
4139                                 nodeCheck = part;
4140                                 checkFn = dirNodeCheck;
4141                         }
4142
4143                         checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4144                 }
4145         },
4146
4147         find: {
4148                 ID: function( match, context, isXML ) {
4149                         if ( typeof context.getElementById !== "undefined" && !isXML ) {
4150                                 var m = context.getElementById(match[1]);
4151                                 // Check parentNode to catch when Blackberry 4.6 returns
4152                                 // nodes that are no longer in the document #6963
4153                                 return m && m.parentNode ? [m] : [];
4154                         }
4155                 },
4156
4157                 NAME: function( match, context ) {
4158                         if ( typeof context.getElementsByName !== "undefined" ) {
4159                                 var ret = [],
4160                                         results = context.getElementsByName( match[1] );
4161
4162                                 for ( var i = 0, l = results.length; i < l; i++ ) {
4163                                         if ( results[i].getAttribute("name") === match[1] ) {
4164                                                 ret.push( results[i] );
4165                                         }
4166                                 }
4167
4168                                 return ret.length === 0 ? null : ret;
4169                         }
4170                 },
4171
4172                 TAG: function( match, context ) {
4173                         if ( typeof context.getElementsByTagName !== "undefined" ) {
4174                                 return context.getElementsByTagName( match[1] );
4175                         }
4176                 }
4177         },
4178         preFilter: {
4179                 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4180                         match = " " + match[1].replace( rBackslash, "" ) + " ";
4181
4182                         if ( isXML ) {
4183                                 return match;
4184                         }
4185
4186                         for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4187                                 if ( elem ) {
4188                                         if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4189                                                 if ( !inplace ) {
4190                                                         result.push( elem );
4191                                                 }
4192
4193                                         } else if ( inplace ) {
4194                                                 curLoop[i] = false;
4195                                         }
4196                                 }
4197                         }
4198
4199                         return false;
4200                 },
4201
4202                 ID: function( match ) {
4203                         return match[1].replace( rBackslash, "" );
4204                 },
4205
4206                 TAG: function( match, curLoop ) {
4207                         return match[1].replace( rBackslash, "" ).toLowerCase();
4208                 },
4209
4210                 CHILD: function( match ) {
4211                         if ( match[1] === "nth" ) {
4212                                 if ( !match[2] ) {
4213                                         Sizzle.error( match[0] );
4214                                 }
4215
4216                                 match[2] = match[2].replace(/^\+|\s*/g, '');
4217
4218                                 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4219                                 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
4220                                         match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
4221                                         !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
4222
4223                                 // calculate the numbers (first)n+(last) including if they are negative
4224                                 match[2] = (test[1] + (test[2] || 1)) - 0;
4225                                 match[3] = test[3] - 0;
4226                         }
4227                         else if ( match[2] ) {
4228                                 Sizzle.error( match[0] );
4229                         }
4230
4231                         // TODO: Move to normal caching system
4232                         match[0] = done++;
4233
4234                         return match;
4235                 },
4236
4237                 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4238                         var name = match[1] = match[1].replace( rBackslash, "" );
4239
4240                         if ( !isXML && Expr.attrMap[name] ) {
4241                                 match[1] = Expr.attrMap[name];
4242                         }
4243
4244                         // Handle if an un-quoted value was used
4245                         match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
4246
4247                         if ( match[2] === "~=" ) {
4248                                 match[4] = " " + match[4] + " ";
4249                         }
4250
4251                         return match;
4252                 },
4253
4254                 PSEUDO: function( match, curLoop, inplace, result, not ) {
4255                         if ( match[1] === "not" ) {
4256                                 // If we're dealing with a complex expression, or a simple one
4257                                 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
4258                                         match[3] = Sizzle(match[3], null, null, curLoop);
4259
4260                                 } else {
4261                                         var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4262
4263                                         if ( !inplace ) {
4264                                                 result.push.apply( result, ret );
4265                                         }
4266
4267                                         return false;
4268                                 }
4269
4270                         } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
4271                                 return true;
4272                         }
4273
4274                         return match;
4275                 },
4276
4277                 POS: function( match ) {
4278                         match.unshift( true );
4279
4280                         return match;
4281                 }
4282         },
4283
4284         filters: {
4285                 enabled: function( elem ) {
4286                         return elem.disabled === false && elem.type !== "hidden";
4287                 },
4288
4289                 disabled: function( elem ) {
4290                         return elem.disabled === true;
4291                 },
4292
4293                 checked: function( elem ) {
4294                         return elem.checked === true;
4295                 },
4296
4297                 selected: function( elem ) {
4298                         // Accessing this property makes selected-by-default
4299                         // options in Safari work properly
4300                         if ( elem.parentNode ) {
4301                                 elem.parentNode.selectedIndex;
4302                         }
4303
4304                         return elem.selected === true;
4305                 },
4306
4307                 parent: function( elem ) {
4308                         return !!elem.firstChild;
4309                 },
4310
4311                 empty: function( elem ) {
4312                         return !elem.firstChild;
4313                 },
4314
4315                 has: function( elem, i, match ) {
4316                         return !!Sizzle( match[3], elem ).length;
4317                 },
4318
4319                 header: function( elem ) {
4320                         return (/h\d/i).test( elem.nodeName );
4321                 },
4322
4323                 text: function( elem ) {
4324                         var attr = elem.getAttribute( "type" ), type = elem.type;
4325                         // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4326                         // use getAttribute instead to test this case
4327                         return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
4328                 },
4329
4330                 radio: function( elem ) {
4331                         return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4332                 },
4333
4334                 checkbox: function( elem ) {
4335                         return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4336                 },
4337
4338                 file: function( elem ) {
4339                         return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4340                 },
4341
4342                 password: function( elem ) {
4343                         return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4344                 },
4345
4346                 submit: function( elem ) {
4347                         var name = elem.nodeName.toLowerCase();
4348                         return (name === "input" || name === "button") && "submit" === elem.type;
4349                 },
4350
4351                 image: function( elem ) {
4352                         return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4353                 },
4354
4355                 reset: function( elem ) {
4356                         var name = elem.nodeName.toLowerCase();
4357                         return (name === "input" || name === "button") && "reset" === elem.type;
4358                 },
4359
4360                 button: function( elem ) {
4361                         var name = elem.nodeName.toLowerCase();
4362                         return name === "input" && "button" === elem.type || name === "button";
4363                 },
4364
4365                 input: function( elem ) {
4366                         return (/input|select|textarea|button/i).test( elem.nodeName );
4367                 },
4368
4369                 focus: function( elem ) {
4370                         return elem === elem.ownerDocument.activeElement;
4371                 }
4372         },
4373         setFilters: {
4374                 first: function( elem, i ) {
4375                         return i === 0;
4376                 },
4377
4378                 last: function( elem, i, match, array ) {
4379                         return i === array.length - 1;
4380                 },
4381
4382                 even: function( elem, i ) {
4383                         return i % 2 === 0;
4384                 },
4385
4386                 odd: function( elem, i ) {
4387                         return i % 2 === 1;
4388                 },
4389
4390                 lt: function( elem, i, match ) {
4391                         return i < match[3] - 0;
4392                 },
4393
4394                 gt: function( elem, i, match ) {
4395                         return i > match[3] - 0;
4396                 },
4397
4398                 nth: function( elem, i, match ) {
4399                         return match[3] - 0 === i;
4400                 },
4401
4402                 eq: function( elem, i, match ) {
4403                         return match[3] - 0 === i;
4404                 }
4405         },
4406         filter: {
4407                 PSEUDO: function( elem, match, i, array ) {
4408                         var name = match[1],
4409                                 filter = Expr.filters[ name ];
4410
4411                         if ( filter ) {
4412                                 return filter( elem, i, match, array );
4413
4414                         } else if ( name === "contains" ) {
4415                                 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
4416
4417                         } else if ( name === "not" ) {
4418                                 var not = match[3];
4419
4420                                 for ( var j = 0, l = not.length; j < l; j++ ) {
4421                                         if ( not[j] === elem ) {
4422                                                 return false;
4423                                         }
4424                                 }
4425
4426                                 return true;
4427
4428                         } else {
4429                                 Sizzle.error( name );
4430                         }
4431                 },
4432
4433                 CHILD: function( elem, match ) {
4434                         var type = match[1],
4435                                 node = elem;
4436
4437                         switch ( type ) {
4438                                 case "only":
4439                                 case "first":
4440                                         while ( (node = node.previousSibling) )  {
4441                                                 if ( node.nodeType === 1 ) {
4442                                                         return false;
4443                                                 }
4444                                         }
4445
4446                                         if ( type === "first" ) {
4447                                                 return true;
4448                                         }
4449
4450                                         node = elem;
4451
4452                                 case "last":
4453                                         while ( (node = node.nextSibling) )      {
4454                                                 if ( node.nodeType === 1 ) {
4455                                                         return false;
4456                                                 }
4457                                         }
4458
4459                                         return true;
4460
4461                                 case "nth":
4462                                         var first = match[2],
4463                                                 last = match[3];
4464
4465                                         if ( first === 1 && last === 0 ) {
4466                                                 return true;
4467                                         }
4468
4469                                         var doneName = match[0],
4470                                                 parent = elem.parentNode;
4471
4472                                         if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
4473                                                 var count = 0;
4474
4475                                                 for ( node = parent.firstChild; node; node = node.nextSibling ) {
4476                                                         if ( node.nodeType === 1 ) {
4477                                                                 node.nodeIndex = ++count;
4478                                                         }
4479                                                 }
4480
4481                                                 parent.sizcache = doneName;
4482                                         }
4483
4484                                         var diff = elem.nodeIndex - last;
4485
4486                                         if ( first === 0 ) {
4487                                                 return diff === 0;
4488
4489                                         } else {
4490                                                 return ( diff % first === 0 && diff / first >= 0 );
4491                                         }
4492                         }
4493                 },
4494
4495                 ID: function( elem, match ) {
4496                         return elem.nodeType === 1 && elem.getAttribute("id") === match;
4497                 },
4498
4499                 TAG: function( elem, match ) {
4500                         return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
4501                 },
4502
4503                 CLASS: function( elem, match ) {
4504                         return (" " + (elem.className || elem.getAttribute("class")) + " ")
4505                                 .indexOf( match ) > -1;
4506                 },
4507
4508                 ATTR: function( elem, match ) {
4509                         var name = match[1],
4510                                 result = Expr.attrHandle[ name ] ?
4511                                         Expr.attrHandle[ name ]( elem ) :
4512                                         elem[ name ] != null ?
4513                                                 elem[ name ] :
4514                                                 elem.getAttribute( name ),
4515                                 value = result + "",
4516                                 type = match[2],
4517                                 check = match[4];
4518
4519                         return result == null ?
4520                                 type === "!=" :
4521                                 type === "=" ?
4522                                 value === check :
4523                                 type === "*=" ?
4524                                 value.indexOf(check) >= 0 :
4525                                 type === "~=" ?
4526                                 (" " + value + " ").indexOf(check) >= 0 :
4527                                 !check ?
4528                                 value && result !== false :
4529                                 type === "!=" ?
4530                                 value !== check :
4531                                 type === "^=" ?
4532                                 value.indexOf(check) === 0 :
4533                                 type === "$=" ?
4534                                 value.substr(value.length - check.length) === check :
4535                                 type === "|=" ?
4536                                 value === check || value.substr(0, check.length + 1) === check + "-" :
4537                                 false;
4538                 },
4539
4540                 POS: function( elem, match, i, array ) {
4541                         var name = match[2],
4542                                 filter = Expr.setFilters[ name ];
4543
4544                         if ( filter ) {
4545                                 return filter( elem, i, match, array );
4546                         }
4547                 }
4548         }
4549 };
4550
4551 var origPOS = Expr.match.POS,
4552         fescape = function(all, num){
4553                 return "\\" + (num - 0 + 1);
4554         };
4555
4556 for ( var type in Expr.match ) {
4557         Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
4558         Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4559 }
4560
4561 var makeArray = function( array, results ) {
4562         array = Array.prototype.slice.call( array, 0 );
4563
4564         if ( results ) {
4565                 results.push.apply( results, array );
4566                 return results;
4567         }
4568
4569         return array;
4570 };
4571
4572 // Perform a simple check to determine if the browser is capable of
4573 // converting a NodeList to an array using builtin methods.
4574 // Also verifies that the returned array holds DOM nodes
4575 // (which is not the case in the Blackberry browser)
4576 try {
4577         Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4578
4579 // Provide a fallback method if it does not work
4580 } catch( e ) {
4581         makeArray = function( array, results ) {
4582                 var i = 0,
4583                         ret = results || [];
4584
4585                 if ( toString.call(array) === "[object Array]" ) {
4586                         Array.prototype.push.apply( ret, array );
4587
4588                 } else {
4589                         if ( typeof array.length === "number" ) {
4590                                 for ( var l = array.length; i < l; i++ ) {
4591                                         ret.push( array[i] );
4592                                 }
4593
4594                         } else {
4595                                 for ( ; array[i]; i++ ) {
4596                                         ret.push( array[i] );
4597                                 }
4598                         }
4599                 }
4600
4601                 return ret;
4602         };
4603 }
4604
4605 var sortOrder, siblingCheck;
4606
4607 if ( document.documentElement.compareDocumentPosition ) {
4608         sortOrder = function( a, b ) {
4609                 if ( a === b ) {
4610                         hasDuplicate = true;
4611                         return 0;
4612                 }
4613
4614                 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
4615                         return a.compareDocumentPosition ? -1 : 1;
4616                 }
4617
4618                 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4619         };
4620
4621 } else {
4622         sortOrder = function( a, b ) {
4623                 // The nodes are identical, we can exit early
4624                 if ( a === b ) {
4625                         hasDuplicate = true;
4626                         return 0;
4627
4628                 // Fallback to using sourceIndex (in IE) if it's available on both nodes
4629                 } else if ( a.sourceIndex && b.sourceIndex ) {
4630                         return a.sourceIndex - b.sourceIndex;
4631                 }
4632
4633                 var al, bl,
4634                         ap = [],
4635                         bp = [],
4636                         aup = a.parentNode,
4637                         bup = b.parentNode,
4638                         cur = aup;
4639
4640                 // If the nodes are siblings (or identical) we can do a quick check
4641                 if ( aup === bup ) {
4642                         return siblingCheck( a, b );
4643
4644                 // If no parents were found then the nodes are disconnected
4645                 } else if ( !aup ) {
4646                         return -1;
4647
4648                 } else if ( !bup ) {
4649                         return 1;
4650                 }
4651
4652                 // Otherwise they're somewhere else in the tree so we need
4653                 // to build up a full list of the parentNodes for comparison
4654                 while ( cur ) {
4655                         ap.unshift( cur );
4656                         cur = cur.parentNode;
4657                 }
4658
4659                 cur = bup;
4660
4661                 while ( cur ) {
4662                         bp.unshift( cur );
4663                         cur = cur.parentNode;
4664                 }
4665
4666                 al = ap.length;
4667                 bl = bp.length;
4668
4669                 // Start walking down the tree looking for a discrepancy
4670                 for ( var i = 0; i < al && i < bl; i++ ) {
4671                         if ( ap[i] !== bp[i] ) {
4672                                 return siblingCheck( ap[i], bp[i] );
4673                         }
4674                 }
4675
4676                 // We ended someplace up the tree so do a sibling check
4677                 return i === al ?
4678                         siblingCheck( a, bp[i], -1 ) :
4679                         siblingCheck( ap[i], b, 1 );
4680         };
4681
4682         siblingCheck = function( a, b, ret ) {
4683                 if ( a === b ) {
4684                         return ret;
4685                 }
4686
4687                 var cur = a.nextSibling;
4688
4689                 while ( cur ) {
4690                         if ( cur === b ) {
4691                                 return -1;
4692                         }
4693
4694                         cur = cur.nextSibling;
4695                 }
4696
4697                 return 1;
4698         };
4699 }
4700
4701 // Utility function for retreiving the text value of an array of DOM nodes
4702 Sizzle.getText = function( elems ) {
4703         var ret = "", elem;
4704
4705         for ( var i = 0; elems[i]; i++ ) {
4706                 elem = elems[i];
4707
4708                 // Get the text from text nodes and CDATA nodes
4709                 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
4710                         ret += elem.nodeValue;
4711
4712                 // Traverse everything else, except comment nodes
4713                 } else if ( elem.nodeType !== 8 ) {
4714                         ret += Sizzle.getText( elem.childNodes );
4715                 }
4716         }
4717
4718         return ret;
4719 };
4720
4721 // Check to see if the browser returns elements by name when
4722 // querying by getElementById (and provide a workaround)
4723 (function(){
4724         // We're going to inject a fake input element with a specified name
4725         var form = document.createElement("div"),
4726                 id = "script" + (new Date()).getTime(),
4727                 root = document.documentElement;
4728
4729         form.innerHTML = "<a name='" + id + "'/>";
4730
4731         // Inject it into the root element, check its status, and remove it quickly
4732         root.insertBefore( form, root.firstChild );
4733
4734         // The workaround has to do additional checks after a getElementById
4735         // Which slows things down for other browsers (hence the branching)
4736         if ( document.getElementById( id ) ) {
4737                 Expr.find.ID = function( match, context, isXML ) {
4738                         if ( typeof context.getElementById !== "undefined" && !isXML ) {
4739                                 var m = context.getElementById(match[1]);
4740
4741                                 return m ?
4742                                         m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4743                                                 [m] :
4744                                                 undefined :
4745                                         [];
4746                         }
4747                 };
4748
4749                 Expr.filter.ID = function( elem, match ) {
4750                         var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4751
4752                         return elem.nodeType === 1 && node && node.nodeValue === match;
4753                 };
4754         }
4755
4756         root.removeChild( form );
4757
4758         // release memory in IE
4759         root = form = null;
4760 })();
4761
4762 (function(){
4763         // Check to see if the browser returns only elements
4764         // when doing getElementsByTagName("*")
4765
4766         // Create a fake element
4767         var div = document.createElement("div");
4768         div.appendChild( document.createComment("") );
4769
4770         // Make sure no comments are found
4771         if ( div.getElementsByTagName("*").length > 0 ) {
4772                 Expr.find.TAG = function( match, context ) {
4773                         var results = context.getElementsByTagName( match[1] );
4774
4775                         // Filter out possible comments
4776                         if ( match[1] === "*" ) {
4777                                 var tmp = [];
4778
4779                                 for ( var i = 0; results[i]; i++ ) {
4780                                         if ( results[i].nodeType === 1 ) {
4781                                                 tmp.push( results[i] );
4782                                         }
4783                                 }
4784
4785                                 results = tmp;
4786                         }
4787
4788                         return results;
4789                 };
4790         }
4791
4792         // Check to see if an attribute returns normalized href attributes
4793         div.innerHTML = "<a href='#'></a>";
4794
4795         if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4796                         div.firstChild.getAttribute("href") !== "#" ) {
4797
4798                 Expr.attrHandle.href = function( elem ) {
4799                         return elem.getAttribute( "href", 2 );
4800                 };
4801         }
4802
4803         // release memory in IE
4804         div = null;
4805 })();
4806
4807 if ( document.querySelectorAll ) {
4808         (function(){
4809                 var oldSizzle = Sizzle,
4810                         div = document.createElement("div"),
4811                         id = "__sizzle__";
4812
4813                 div.innerHTML = "<p class='TEST'></p>";
4814
4815                 // Safari can't handle uppercase or unicode characters when
4816                 // in quirks mode.
4817                 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4818                         return;
4819                 }
4820
4821                 Sizzle = function( query, context, extra, seed ) {
4822                         context = context || document;
4823
4824                         // Only use querySelectorAll on non-XML documents
4825                         // (ID selectors don't work in non-HTML documents)
4826                         if ( !seed && !Sizzle.isXML(context) ) {
4827                                 // See if we find a selector to speed up
4828                                 var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
4829
4830                                 if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
4831                                         // Speed-up: Sizzle("TAG")
4832                                         if ( match[1] ) {
4833                                                 return makeArray( context.getElementsByTagName( query ), extra );
4834
4835                                         // Speed-up: Sizzle(".CLASS")
4836                                         } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
4837                                                 return makeArray( context.getElementsByClassName( match[2] ), extra );
4838                                         }
4839                                 }
4840
4841                                 if ( context.nodeType === 9 ) {
4842                                         // Speed-up: Sizzle("body")
4843                                         // The body element only exists once, optimize finding it
4844                                         if ( query === "body" && context.body ) {
4845                                                 return makeArray( [ context.body ], extra );
4846
4847                                         // Speed-up: Sizzle("#ID")
4848                                         } else if ( match && match[3] ) {
4849                                                 var elem = context.getElementById( match[3] );
4850
4851                                                 // Check parentNode to catch when Blackberry 4.6 returns
4852                                                 // nodes that are no longer in the document #6963
4853                                                 if ( elem && elem.parentNode ) {
4854                                                         // Handle the case where IE and Opera return items
4855                                                         // by name instead of ID
4856                                                         if ( elem.id === match[3] ) {
4857                                                                 return makeArray( [ elem ], extra );
4858                                                         }
4859
4860                                                 } else {
4861                                                         return makeArray( [], extra );
4862                                                 }
4863                                         }
4864
4865                                         try {
4866                                                 return makeArray( context.querySelectorAll(query), extra );
4867                                         } catch(qsaError) {}
4868
4869                                 // qSA works strangely on Element-rooted queries
4870                                 // We can work around this by specifying an extra ID on the root
4871                                 // and working up from there (Thanks to Andrew Dupont for the technique)
4872                                 // IE 8 doesn't work on object elements
4873                                 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4874                                         var oldContext = context,
4875                                                 old = context.getAttribute( "id" ),
4876                                                 nid = old || id,
4877                                                 hasParent = context.parentNode,
4878                                                 relativeHierarchySelector = /^\s*[+~]/.test( query );
4879
4880                                         if ( !old ) {
4881                                                 context.setAttribute( "id", nid );
4882                                         } else {
4883                                                 nid = nid.replace( /'/g, "\\$&" );
4884                                         }
4885                                         if ( relativeHierarchySelector && hasParent ) {
4886                                                 context = context.parentNode;
4887                                         }
4888
4889                                         try {
4890                                                 if ( !relativeHierarchySelector || hasParent ) {
4891                                                         return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
4892                                                 }
4893
4894                                         } catch(pseudoError) {
4895                                         } finally {
4896                                                 if ( !old ) {
4897                                                         oldContext.removeAttribute( "id" );
4898                                                 }
4899                                         }
4900                                 }
4901                         }
4902
4903                         return oldSizzle(query, context, extra, seed);
4904                 };
4905
4906                 for ( var prop in oldSizzle ) {
4907                         Sizzle[ prop ] = oldSizzle[ prop ];
4908                 }
4909
4910                 // release memory in IE
4911                 div = null;
4912         })();
4913 }
4914
4915 (function(){
4916         var html = document.documentElement,
4917                 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
4918
4919         if ( matches ) {
4920                 // Check to see if it's possible to do matchesSelector
4921                 // on a disconnected node (IE 9 fails this)
4922                 var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
4923                         pseudoWorks = false;
4924
4925                 try {
4926                         // This should fail with an exception
4927                         // Gecko does not error, returns false instead
4928                         matches.call( document.documentElement, "[test!='']:sizzle" );
4929
4930                 } catch( pseudoError ) {
4931                         pseudoWorks = true;
4932                 }
4933
4934                 Sizzle.matchesSelector = function( node, expr ) {
4935                         // Make sure that attribute selectors are quoted
4936                         expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4937
4938                         if ( !Sizzle.isXML( node ) ) {
4939                                 try {
4940                                         if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
4941                                                 var ret = matches.call( node, expr );
4942
4943                                                 // IE 9's matchesSelector returns false on disconnected nodes
4944                                                 if ( ret || !disconnectedMatch ||
4945                                                                 // As well, disconnected nodes are said to be in a document
4946                                                                 // fragment in IE 9, so check for that
4947                                                                 node.document && node.document.nodeType !== 11 ) {
4948                                                         return ret;
4949                                                 }
4950                                         }
4951                                 } catch(e) {}
4952                         }
4953
4954                         return Sizzle(expr, null, null, [node]).length > 0;
4955                 };
4956         }
4957 })();
4958
4959 (function(){
4960         var div = document.createElement("div");
4961
4962         div.innerHTML = "<div class='test e'></div><div class='test'></div>";
4963
4964         // Opera can't find a second classname (in 9.6)
4965         // Also, make sure that getElementsByClassName actually exists
4966         if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
4967                 return;
4968         }
4969
4970         // Safari caches class attributes, doesn't catch changes (in 3.2)
4971         div.lastChild.className = "e";
4972
4973         if ( div.getElementsByClassName("e").length === 1 ) {
4974                 return;
4975         }
4976
4977         Expr.order.splice(1, 0, "CLASS");
4978         Expr.find.CLASS = function( match, context, isXML ) {
4979                 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
4980                         return context.getElementsByClassName(match[1]);
4981                 }
4982         };
4983
4984         // release memory in IE
4985         div = null;
4986 })();
4987
4988 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4989         for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4990                 var elem = checkSet[i];
4991
4992                 if ( elem ) {
4993                         var match = false;
4994
4995                         elem = elem[dir];
4996
4997                         while ( elem ) {
4998                                 if ( elem.sizcache === doneName ) {
4999                                         match = checkSet[elem.sizset];
5000                                         break;
5001                                 }
5002
5003                                 if ( elem.nodeType === 1 && !isXML ){
5004                                         elem.sizcache = doneName;
5005                                         elem.sizset = i;
5006                                 }
5007
5008                                 if ( elem.nodeName.toLowerCase() === cur ) {
5009                                         match = elem;
5010                                         break;
5011                                 }
5012
5013                                 elem = elem[dir];
5014                         }
5015
5016                         checkSet[i] = match;
5017                 }
5018         }
5019 }
5020
5021 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5022         for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5023                 var elem = checkSet[i];
5024
5025                 if ( elem ) {
5026                         var match = false;
5027
5028                         elem = elem[dir];
5029
5030                         while ( elem ) {
5031                                 if ( elem.sizcache === doneName ) {
5032                                         match = checkSet[elem.sizset];
5033                                         break;
5034                                 }
5035
5036                                 if ( elem.nodeType === 1 ) {
5037                                         if ( !isXML ) {
5038                                                 elem.sizcache = doneName;
5039                                                 elem.sizset = i;
5040                                         }
5041
5042                                         if ( typeof cur !== "string" ) {
5043                                                 if ( elem === cur ) {
5044                                                         match = true;
5045                                                         break;
5046                                                 }
5047
5048                                         } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5049                                                 match = elem;
5050                                                 break;
5051                                         }
5052                                 }
5053
5054                                 elem = elem[dir];
5055                         }
5056
5057                         checkSet[i] = match;
5058                 }
5059         }
5060 }
5061
5062 if ( document.documentElement.contains ) {
5063         Sizzle.contains = function( a, b ) {
5064                 return a !== b && (a.contains ? a.contains(b) : true);
5065         };
5066
5067 } else if ( document.documentElement.compareDocumentPosition ) {
5068         Sizzle.contains = function( a, b ) {
5069                 return !!(a.compareDocumentPosition(b) & 16);
5070         };
5071
5072 } else {
5073         Sizzle.contains = function() {
5074                 return false;
5075         };
5076 }
5077
5078 Sizzle.isXML = function( elem ) {
5079         // documentElement is verified for cases where it doesn't yet exist
5080         // (such as loading iframes in IE - #4833)
5081         var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
5082
5083         return documentElement ? documentElement.nodeName !== "HTML" : false;
5084 };
5085
5086 var posProcess = function( selector, context ) {
5087         var match,
5088                 tmpSet = [],
5089                 later = "",
5090                 root = context.nodeType ? [context] : context;
5091
5092         // Position selectors must be done after the filter
5093         // And so must :not(positional) so we move all PSEUDOs to the end
5094         while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5095                 later += match[0];
5096                 selector = selector.replace( Expr.match.PSEUDO, "" );
5097         }
5098
5099         selector = Expr.relative[selector] ? selector + "*" : selector;
5100
5101         for ( var i = 0, l = root.length; i < l; i++ ) {
5102                 Sizzle( selector, root[i], tmpSet );
5103         }
5104
5105         return Sizzle.filter( later, tmpSet );
5106 };
5107
5108 // EXPOSE
5109 jQuery.find = Sizzle;
5110 jQuery.expr = Sizzle.selectors;
5111 jQuery.expr[":"] = jQuery.expr.filters;
5112 jQuery.unique = Sizzle.uniqueSort;
5113 jQuery.text = Sizzle.getText;
5114 jQuery.isXMLDoc = Sizzle.isXML;
5115 jQuery.contains = Sizzle.contains;
5116
5117
5118 })();
5119
5120
5121 var runtil = /Until$/,
5122         rparentsprev = /^(?:parents|prevUntil|prevAll)/,
5123         // Note: This RegExp should be improved, or likely pulled from Sizzle
5124         rmultiselector = /,/,
5125         isSimple = /^.[^:#\[\.,]*$/,
5126         slice = Array.prototype.slice,
5127         POS = jQuery.expr.match.POS,
5128         // methods guaranteed to produce a unique set when starting from a unique set
5129         guaranteedUnique = {
5130                 children: true,
5131                 contents: true,
5132                 next: true,
5133                 prev: true
5134         };
5135
5136 jQuery.fn.extend({
5137         find: function( selector ) {
5138                 var self = this,
5139                         i, l;
5140
5141                 if ( typeof selector !== "string" ) {
5142                         return jQuery( selector ).filter(function() {
5143                                 for ( i = 0, l = self.length; i < l; i++ ) {
5144                                         if ( jQuery.contains( self[ i ], this ) ) {
5145                                                 return true;
5146                                         }
5147                                 }
5148                         });
5149                 }
5150
5151                 var ret = this.pushStack( "", "find", selector ),
5152                         length, n, r;
5153
5154                 for ( i = 0, l = this.length; i < l; i++ ) {
5155                         length = ret.length;
5156                         jQuery.find( selector, this[i], ret );
5157
5158                         if ( i > 0 ) {
5159                                 // Make sure that the results are unique
5160                                 for ( n = length; n < ret.length; n++ ) {
5161                                         for ( r = 0; r < length; r++ ) {
5162                                                 if ( ret[r] === ret[n] ) {
5163                                                         ret.splice(n--, 1);
5164                                                         break;
5165                                                 }
5166                                         }
5167                                 }
5168                         }
5169                 }
5170
5171                 return ret;
5172         },
5173
5174         has: function( target ) {
5175                 var targets = jQuery( target );
5176                 return this.filter(function() {
5177                         for ( var i = 0, l = targets.length; i < l; i++ ) {
5178                                 if ( jQuery.contains( this, targets[i] ) ) {
5179                                         return true;
5180                                 }
5181                         }
5182                 });
5183         },
5184
5185         not: function( selector ) {
5186                 return this.pushStack( winnow(this, selector, false), "not", selector);
5187         },
5188
5189         filter: function( selector ) {
5190                 return this.pushStack( winnow(this, selector, true), "filter", selector );
5191         },
5192
5193         is: function( selector ) {
5194                 return !!selector && ( typeof selector === "string" ?
5195                         jQuery.filter( selector, this ).length > 0 :
5196                         this.filter( selector ).length > 0 );
5197         },
5198
5199         closest: function( selectors, context ) {
5200                 var ret = [], i, l, cur = this[0];
5201
5202                 // Array
5203                 if ( jQuery.isArray( selectors ) ) {
5204                         var match, selector,
5205                                 matches = {},
5206                                 level = 1;
5207
5208                         if ( cur && selectors.length ) {
5209                                 for ( i = 0, l = selectors.length; i < l; i++ ) {
5210                                         selector = selectors[i];
5211
5212                                         if ( !matches[ selector ] ) {
5213                                                 matches[ selector ] = POS.test( selector ) ?
5214                                                         jQuery( selector, context || this.context ) :
5215                                                         selector;
5216                                         }
5217                                 }
5218
5219                                 while ( cur && cur.ownerDocument && cur !== context ) {
5220                                         for ( selector in matches ) {
5221                                                 match = matches[ selector ];
5222
5223                                                 if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
5224                                                         ret.push({ selector: selector, elem: cur, level: level });
5225                                                 }
5226                                         }
5227
5228                                         cur = cur.parentNode;
5229                                         level++;
5230                                 }
5231                         }
5232
5233                         return ret;
5234                 }
5235
5236                 // String
5237                 var pos = POS.test( selectors ) || typeof selectors !== "string" ?
5238                                 jQuery( selectors, context || this.context ) :
5239                                 0;
5240
5241                 for ( i = 0, l = this.length; i < l; i++ ) {
5242                         cur = this[i];
5243
5244                         while ( cur ) {
5245                                 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5246                                         ret.push( cur );
5247                                         break;
5248
5249                                 } else {
5250                                         cur = cur.parentNode;
5251                                         if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
5252                                                 break;
5253                                         }
5254                                 }
5255                         }
5256                 }
5257
5258                 ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5259
5260                 return this.pushStack( ret, "closest", selectors );
5261         },
5262
5263         // Determine the position of an element within
5264         // the matched set of elements
5265         index: function( elem ) {
5266                 if ( !elem || typeof elem === "string" ) {
5267                         return jQuery.inArray( this[0],
5268                                 // If it receives a string, the selector is used
5269                                 // If it receives nothing, the siblings are used
5270                                 elem ? jQuery( elem ) : this.parent().children() );
5271                 }
5272                 // Locate the position of the desired element
5273                 return jQuery.inArray(
5274                         // If it receives a jQuery object, the first element is used
5275                         elem.jquery ? elem[0] : elem, this );
5276         },
5277
5278         add: function( selector, context ) {
5279                 var set = typeof selector === "string" ?
5280                                 jQuery( selector, context ) :
5281                                 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5282                         all = jQuery.merge( this.get(), set );
5283
5284                 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
5285                         all :
5286                         jQuery.unique( all ) );
5287         },
5288
5289         andSelf: function() {
5290                 return this.add( this.prevObject );
5291         }
5292 });
5293
5294 // A painfully simple check to see if an element is disconnected
5295 // from a document (should be improved, where feasible).
5296 function isDisconnected( node ) {
5297         return !node || !node.parentNode || node.parentNode.nodeType === 11;
5298 }
5299
5300 jQuery.each({
5301         parent: function( elem ) {
5302                 var parent = elem.parentNode;
5303                 return parent && parent.nodeType !== 11 ? parent : null;
5304         },
5305         parents: function( elem ) {
5306                 return jQuery.dir( elem, "parentNode" );
5307         },
5308         parentsUntil: function( elem, i, until ) {
5309                 return jQuery.dir( elem, "parentNode", until );
5310         },
5311         next: function( elem ) {
5312                 return jQuery.nth( elem, 2, "nextSibling" );
5313         },
5314         prev: function( elem ) {
5315                 return jQuery.nth( elem, 2, "previousSibling" );
5316         },
5317         nextAll: function( elem ) {
5318                 return jQuery.dir( elem, "nextSibling" );
5319         },
5320         prevAll: function( elem ) {
5321                 return jQuery.dir( elem, "previousSibling" );
5322         },
5323         nextUntil: function( elem, i, until ) {
5324                 return jQuery.dir( elem, "nextSibling", until );
5325         },
5326         prevUntil: function( elem, i, until ) {
5327                 return jQuery.dir( elem, "previousSibling", until );
5328         },
5329         siblings: function( elem ) {
5330                 return jQuery.sibling( elem.parentNode.firstChild, elem );
5331         },
5332         children: function( elem ) {
5333                 return jQuery.sibling( elem.firstChild );
5334         },
5335         contents: function( elem ) {
5336                 return jQuery.nodeName( elem, "iframe" ) ?
5337                         elem.contentDocument || elem.contentWindow.document :
5338                         jQuery.makeArray( elem.childNodes );
5339         }
5340 }, function( name, fn ) {
5341         jQuery.fn[ name ] = function( until, selector ) {
5342                 var ret = jQuery.map( this, fn, until ),
5343                         // The variable 'args' was introduced in
5344                         // https://github.com/jquery/jquery/commit/52a0238
5345                         // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
5346                         // http://code.google.com/p/v8/issues/detail?id=1050
5347                         args = slice.call(arguments);
5348
5349                 if ( !runtil.test( name ) ) {
5350                         selector = until;
5351                 }
5352
5353                 if ( selector && typeof selector === "string" ) {
5354                         ret = jQuery.filter( selector, ret );
5355                 }
5356
5357                 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5358
5359                 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5360                         ret = ret.reverse();
5361                 }
5362
5363                 return this.pushStack( ret, name, args.join(",") );
5364         };
5365 });
5366
5367 jQuery.extend({
5368         filter: function( expr, elems, not ) {
5369                 if ( not ) {
5370                         expr = ":not(" + expr + ")";
5371                 }
5372
5373                 return elems.length === 1 ?
5374                         jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5375                         jQuery.find.matches(expr, elems);
5376         },
5377
5378         dir: function( elem, dir, until ) {
5379                 var matched = [],
5380                         cur = elem[ dir ];
5381
5382                 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
5383                         if ( cur.nodeType === 1 ) {
5384                                 matched.push( cur );
5385                         }
5386                         cur = cur[dir];
5387                 }
5388                 return matched;
5389         },
5390
5391         nth: function( cur, result, dir, elem ) {
5392                 result = result || 1;
5393                 var num = 0;
5394
5395                 for ( ; cur; cur = cur[dir] ) {
5396                         if ( cur.nodeType === 1 && ++num === result ) {
5397                                 break;
5398                         }
5399                 }
5400
5401                 return cur;
5402         },
5403
5404         sibling: function( n, elem ) {
5405                 var r = [];
5406
5407                 for ( ; n; n = n.nextSibling ) {
5408                         if ( n.nodeType === 1 && n !== elem ) {
5409                                 r.push( n );
5410                         }
5411                 }
5412
5413                 return r;
5414         }
5415 });
5416
5417 // Implement the identical functionality for filter and not
5418 function winnow( elements, qualifier, keep ) {
5419
5420         // Can't pass null or undefined to indexOf in Firefox 4
5421         // Set to 0 to skip string check
5422         qualifier = qualifier || 0;
5423
5424         if ( jQuery.isFunction( qualifier ) ) {
5425                 return jQuery.grep(elements, function( elem, i ) {
5426                         var retVal = !!qualifier.call( elem, i, elem );
5427                         return retVal === keep;
5428                 });
5429
5430         } else if ( qualifier.nodeType ) {
5431                 return jQuery.grep(elements, function( elem, i ) {
5432                         return (elem === qualifier) === keep;
5433                 });
5434
5435         } else if ( typeof qualifier === "string" ) {
5436                 var filtered = jQuery.grep(elements, function( elem ) {
5437                         return elem.nodeType === 1;
5438                 });
5439
5440                 if ( isSimple.test( qualifier ) ) {
5441                         return jQuery.filter(qualifier, filtered, !keep);
5442                 } else {
5443                         qualifier = jQuery.filter( qualifier, filtered );
5444                 }
5445         }
5446
5447         return jQuery.grep(elements, function( elem, i ) {
5448                 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
5449         });
5450 }
5451
5452
5453
5454
5455 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5456         rleadingWhitespace = /^\s+/,
5457         rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
5458         rtagName = /<([\w:]+)/,
5459         rtbody = /<tbody/i,
5460         rhtml = /<|&#?\w+;/,
5461         rnocache = /<(?:script|object|embed|option|style)/i,
5462         // checked="checked" or checked
5463         rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5464         rscriptType = /\/(java|ecma)script/i,
5465         rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
5466         wrapMap = {
5467                 option: [ 1, "<select multiple='multiple'>", "</select>" ],
5468                 legend: [ 1, "<fieldset>", "</fieldset>" ],
5469                 thead: [ 1, "<table>", "</table>" ],
5470                 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5471                 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5472                 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5473                 area: [ 1, "<map>", "</map>" ],
5474                 _default: [ 0, "", "" ]
5475         };
5476
5477 wrapMap.optgroup = wrapMap.option;
5478 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5479 wrapMap.th = wrapMap.td;
5480
5481 // IE can't serialize <link> and <script> tags normally
5482 if ( !jQuery.support.htmlSerialize ) {
5483         wrapMap._default = [ 1, "div<div>", "</div>" ];
5484 }
5485
5486 jQuery.fn.extend({
5487         text: function( text ) {
5488                 if ( jQuery.isFunction(text) ) {
5489                         return this.each(function(i) {
5490                                 var self = jQuery( this );
5491
5492                                 self.text( text.call(this, i, self.text()) );
5493                         });
5494                 }
5495
5496                 if ( typeof text !== "object" && text !== undefined ) {
5497                         return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
5498                 }
5499
5500                 return jQuery.text( this );
5501         },
5502
5503         wrapAll: function( html ) {
5504                 if ( jQuery.isFunction( html ) ) {
5505                         return this.each(function(i) {
5506                                 jQuery(this).wrapAll( html.call(this, i) );
5507                         });
5508                 }
5509
5510                 if ( this[0] ) {
5511                         // The elements to wrap the target around
5512                         var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5513
5514                         if ( this[0].parentNode ) {
5515                                 wrap.insertBefore( this[0] );
5516                         }
5517
5518                         wrap.map(function() {
5519                                 var elem = this;
5520
5521                                 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5522                                         elem = elem.firstChild;
5523                                 }
5524
5525                                 return elem;
5526                         }).append( this );
5527                 }
5528
5529                 return this;
5530         },
5531
5532         wrapInner: function( html ) {
5533                 if ( jQuery.isFunction( html ) ) {
5534                         return this.each(function(i) {
5535                                 jQuery(this).wrapInner( html.call(this, i) );
5536                         });
5537                 }
5538
5539                 return this.each(function() {
5540                         var self = jQuery( this ),
5541                                 contents = self.contents();
5542
5543                         if ( contents.length ) {
5544                                 contents.wrapAll( html );
5545
5546                         } else {
5547                                 self.append( html );
5548                         }
5549                 });
5550         },
5551
5552         wrap: function( html ) {
5553                 return this.each(function() {
5554                         jQuery( this ).wrapAll( html );
5555                 });
5556         },
5557
5558         unwrap: function() {
5559                 return this.parent().each(function() {
5560                         if ( !jQuery.nodeName( this, "body" ) ) {
5561                                 jQuery( this ).replaceWith( this.childNodes );
5562                         }
5563                 }).end();
5564         },
5565
5566         append: function() {
5567                 return this.domManip(arguments, true, function( elem ) {
5568                         if ( this.nodeType === 1 ) {
5569                                 this.appendChild( elem );
5570                         }
5571                 });
5572         },
5573
5574         prepend: function() {
5575                 return this.domManip(arguments, true, function( elem ) {
5576                         if ( this.nodeType === 1 ) {
5577                                 this.insertBefore( elem, this.firstChild );
5578                         }
5579                 });
5580         },
5581
5582         before: function() {
5583                 if ( this[0] && this[0].parentNode ) {
5584                         return this.domManip(arguments, false, function( elem ) {
5585                                 this.parentNode.insertBefore( elem, this );
5586                         });
5587                 } else if ( arguments.length ) {
5588                         var set = jQuery(arguments[0]);
5589                         set.push.apply( set, this.toArray() );
5590                         return this.pushStack( set, "before", arguments );
5591                 }
5592         },
5593
5594         after: function() {
5595                 if ( this[0] && this[0].parentNode ) {
5596                         return this.domManip(arguments, false, function( elem ) {
5597                                 this.parentNode.insertBefore( elem, this.nextSibling );
5598                         });
5599                 } else if ( arguments.length ) {
5600                         var set = this.pushStack( this, "after", arguments );
5601                         set.push.apply( set, jQuery(arguments[0]).toArray() );
5602                         return set;
5603                 }
5604         },
5605
5606         // keepData is for internal use only--do not document
5607         remove: function( selector, keepData ) {
5608                 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5609                         if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5610                                 if ( !keepData && elem.nodeType === 1 ) {
5611                                         jQuery.cleanData( elem.getElementsByTagName("*") );
5612                                         jQuery.cleanData( [ elem ] );
5613                                 }
5614
5615                                 if ( elem.parentNode ) {
5616                                         elem.parentNode.removeChild( elem );
5617                                 }
5618                         }
5619                 }
5620
5621                 return this;
5622         },
5623
5624         empty: function() {
5625                 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5626                         // Remove element nodes and prevent memory leaks
5627                         if ( elem.nodeType === 1 ) {
5628                                 jQuery.cleanData( elem.getElementsByTagName("*") );
5629                         }
5630
5631                         // Remove any remaining nodes
5632                         while ( elem.firstChild ) {
5633                                 elem.removeChild( elem.firstChild );
5634                         }
5635                 }
5636
5637                 return this;
5638         },
5639
5640         clone: function( dataAndEvents, deepDataAndEvents ) {
5641                 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5642                 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5643
5644                 return this.map( function () {
5645                         return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5646                 });
5647         },
5648
5649         html: function( value ) {
5650                 if ( value === undefined ) {
5651                         return this[0] && this[0].nodeType === 1 ?
5652                                 this[0].innerHTML.replace(rinlinejQuery, "") :
5653                                 null;
5654
5655                 // See if we can take a shortcut and just use innerHTML
5656                 } else if ( typeof value === "string" && !rnocache.test( value ) &&
5657                         (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5658                         !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5659
5660                         value = value.replace(rxhtmlTag, "<$1></$2>");
5661
5662                         try {
5663                                 for ( var i = 0, l = this.length; i < l; i++ ) {
5664                                         // Remove element nodes and prevent memory leaks
5665                                         if ( this[i].nodeType === 1 ) {
5666                                                 jQuery.cleanData( this[i].getElementsByTagName("*") );
5667                                                 this[i].innerHTML = value;
5668                                         }
5669                                 }
5670
5671                         // If using innerHTML throws an exception, use the fallback method
5672                         } catch(e) {
5673                                 this.empty().append( value );
5674                         }
5675
5676                 } else if ( jQuery.isFunction( value ) ) {
5677                         this.each(function(i){
5678                                 var self = jQuery( this );
5679
5680                                 self.html( value.call(this, i, self.html()) );
5681                         });
5682
5683                 } else {
5684                         this.empty().append( value );
5685                 }
5686
5687                 return this;
5688         },
5689
5690         replaceWith: function( value ) {
5691                 if ( this[0] && this[0].parentNode ) {
5692                         // Make sure that the elements are removed from the DOM before they are inserted
5693                         // this can help fix replacing a parent with child elements
5694                         if ( jQuery.isFunction( value ) ) {
5695                                 return this.each(function(i) {
5696                                         var self = jQuery(this), old = self.html();
5697                                         self.replaceWith( value.call( this, i, old ) );
5698                                 });
5699                         }
5700
5701                         if ( typeof value !== "string" ) {
5702                                 value = jQuery( value ).detach();
5703                         }
5704
5705                         return this.each(function() {
5706                                 var next = this.nextSibling,
5707                                         parent = this.parentNode;
5708
5709                                 jQuery( this ).remove();
5710
5711                                 if ( next ) {
5712                                         jQuery(next).before( value );
5713                                 } else {
5714                                         jQuery(parent).append( value );
5715                                 }
5716                         });
5717                 } else {
5718                         return this.length ?
5719                                 this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5720                                 this;
5721                 }
5722         },
5723
5724         detach: function( selector ) {
5725                 return this.remove( selector, true );
5726         },
5727
5728         domManip: function( args, table, callback ) {
5729                 var results, first, fragment, parent,
5730                         value = args[0],
5731                         scripts = [];
5732
5733                 // We can't cloneNode fragments that contain checked, in WebKit
5734                 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5735                         return this.each(function() {
5736                                 jQuery(this).domManip( args, table, callback, true );
5737                         });
5738                 }
5739
5740                 if ( jQuery.isFunction(value) ) {
5741                         return this.each(function(i) {
5742                                 var self = jQuery(this);
5743                                 args[0] = value.call(this, i, table ? self.html() : undefined);
5744                                 self.domManip( args, table, callback );
5745                         });
5746                 }
5747
5748                 if ( this[0] ) {
5749                         parent = value && value.parentNode;
5750
5751                         // If we're in a fragment, just use that instead of building a new one
5752                         if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5753                                 results = { fragment: parent };
5754
5755                         } else {
5756                                 results = jQuery.buildFragment( args, this, scripts );
5757                         }
5758
5759                         fragment = results.fragment;
5760
5761                         if ( fragment.childNodes.length === 1 ) {
5762                                 first = fragment = fragment.firstChild;
5763                         } else {
5764                                 first = fragment.firstChild;
5765                         }
5766
5767                         if ( first ) {
5768                                 table = table && jQuery.nodeName( first, "tr" );
5769
5770                                 for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5771                                         callback.call(
5772                                                 table ?
5773                                                         root(this[i], first) :
5774                                                         this[i],
5775                                                 // Make sure that we do not leak memory by inadvertently discarding
5776                                                 // the original fragment (which might have attached data) instead of
5777                                                 // using it; in addition, use the original fragment object for the last
5778                                                 // item instead of first because it can end up being emptied incorrectly
5779                                                 // in certain situations (Bug #8070).
5780                                                 // Fragments from the fragment cache must always be cloned and never used
5781                                                 // in place.
5782                                                 results.cacheable || (l > 1 && i < lastIndex) ?
5783                                                         jQuery.clone( fragment, true, true ) :
5784                                                         fragment
5785                                         );
5786                                 }
5787                         }
5788
5789                         if ( scripts.length ) {
5790                                 jQuery.each( scripts, evalScript );
5791                         }
5792                 }
5793
5794                 return this;
5795         }
5796 });
5797
5798 function root( elem, cur ) {
5799         return jQuery.nodeName(elem, "table") ?
5800                 (elem.getElementsByTagName("tbody")[0] ||
5801                 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5802                 elem;
5803 }
5804
5805 function cloneCopyEvent( src, dest ) {
5806
5807         if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
5808                 return;
5809         }
5810
5811         var internalKey = jQuery.expando,
5812                 oldData = jQuery.data( src ),
5813                 curData = jQuery.data( dest, oldData );
5814
5815         // Switch to use the internal data object, if it exists, for the next
5816         // stage of data copying
5817         if ( (oldData = oldData[ internalKey ]) ) {
5818                 var events = oldData.events;
5819                                 curData = curData[ internalKey ] = jQuery.extend({}, oldData);
5820
5821                 if ( events ) {
5822                         delete curData.handle;
5823                         curData.events = {};
5824
5825                         for ( var type in events ) {
5826                                 for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
5827                                         jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
5828                                 }
5829                         }
5830                 }
5831         }
5832 }
5833
5834 function cloneFixAttributes( src, dest ) {
5835         var nodeName;
5836
5837         // We do not need to do anything for non-Elements
5838         if ( dest.nodeType !== 1 ) {
5839                 return;
5840         }
5841
5842         // clearAttributes removes the attributes, which we don't want,
5843         // but also removes the attachEvent events, which we *do* want
5844         if ( dest.clearAttributes ) {
5845                 dest.clearAttributes();
5846         }
5847
5848         // mergeAttributes, in contrast, only merges back on the
5849         // original attributes, not the events
5850         if ( dest.mergeAttributes ) {
5851                 dest.mergeAttributes( src );
5852         }
5853
5854         nodeName = dest.nodeName.toLowerCase();
5855
5856         // IE6-8 fail to clone children inside object elements that use
5857         // the proprietary classid attribute value (rather than the type
5858         // attribute) to identify the type of content to display
5859         if ( nodeName === "object" ) {
5860                 dest.outerHTML = src.outerHTML;
5861
5862         } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
5863                 // IE6-8 fails to persist the checked state of a cloned checkbox
5864                 // or radio button. Worse, IE6-7 fail to give the cloned element
5865                 // a checked appearance if the defaultChecked value isn't also set
5866                 if ( src.checked ) {
5867                         dest.defaultChecked = dest.checked = src.checked;
5868                 }
5869
5870                 // IE6-7 get confused and end up setting the value of a cloned
5871                 // checkbox/radio button to an empty string instead of "on"
5872                 if ( dest.value !== src.value ) {
5873                         dest.value = src.value;
5874                 }
5875
5876         // IE6-8 fails to return the selected option to the default selected
5877         // state when cloning options
5878         } else if ( nodeName === "option" ) {
5879                 dest.selected = src.defaultSelected;
5880
5881         // IE6-8 fails to set the defaultValue to the correct value when
5882         // cloning other types of input fields
5883         } else if ( nodeName === "input" || nodeName === "textarea" ) {
5884                 dest.defaultValue = src.defaultValue;
5885         }
5886
5887         // Event data gets referenced instead of copied if the expando
5888         // gets copied too
5889         dest.removeAttribute( jQuery.expando );
5890 }
5891
5892 jQuery.buildFragment = function( args, nodes, scripts ) {
5893         var fragment, cacheable, cacheresults,
5894                 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
5895
5896         // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
5897         // Cloning options loses the selected state, so don't cache them
5898         // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5899         // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5900         if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5901                 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
5902
5903                 cacheable = true;
5904
5905                 cacheresults = jQuery.fragments[ args[0] ];
5906                 if ( cacheresults && cacheresults !== 1 ) {
5907                         fragment = cacheresults;
5908                 }
5909         }
5910
5911         if ( !fragment ) {
5912                 fragment = doc.createDocumentFragment();
5913                 jQuery.clean( args, doc, fragment, scripts );
5914         }
5915
5916         if ( cacheable ) {
5917                 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
5918         }
5919
5920         return { fragment: fragment, cacheable: cacheable };
5921 };
5922
5923 jQuery.fragments = {};
5924
5925 jQuery.each({
5926         appendTo: "append",
5927         prependTo: "prepend",
5928         insertBefore: "before",
5929         insertAfter: "after",
5930         replaceAll: "replaceWith"
5931 }, function( name, original ) {
5932         jQuery.fn[ name ] = function( selector ) {
5933                 var ret = [],
5934                         insert = jQuery( selector ),
5935                         parent = this.length === 1 && this[0].parentNode;
5936
5937                 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5938                         insert[ original ]( this[0] );
5939                         return this;
5940
5941                 } else {
5942                         for ( var i = 0, l = insert.length; i < l; i++ ) {
5943                                 var elems = (i > 0 ? this.clone(true) : this).get();
5944                                 jQuery( insert[i] )[ original ]( elems );
5945                                 ret = ret.concat( elems );
5946                         }
5947
5948                         return this.pushStack( ret, name, insert.selector );
5949                 }
5950         };
5951 });
5952
5953 function getAll( elem ) {
5954         if ( "getElementsByTagName" in elem ) {
5955                 return elem.getElementsByTagName( "*" );
5956
5957         } else if ( "querySelectorAll" in elem ) {
5958                 return elem.querySelectorAll( "*" );
5959
5960         } else {
5961                 return [];
5962         }
5963 }
5964
5965 // Used in clean, fixes the defaultChecked property
5966 function fixDefaultChecked( elem ) {
5967         if ( elem.type === "checkbox" || elem.type === "radio" ) {
5968                 elem.defaultChecked = elem.checked;
5969         }
5970 }
5971 // Finds all inputs and passes them to fixDefaultChecked
5972 function findInputs( elem ) {
5973         if ( jQuery.nodeName( elem, "input" ) ) {
5974                 fixDefaultChecked( elem );
5975         } else if ( elem.getElementsByTagName ) {
5976                 jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
5977         }
5978 }
5979
5980 jQuery.extend({
5981         clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5982                 var clone = elem.cloneNode(true),
5983                                 srcElements,
5984                                 destElements,
5985                                 i;
5986
5987                 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
5988                                 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
5989                         // IE copies events bound via attachEvent when using cloneNode.
5990                         // Calling detachEvent on the clone will also remove the events
5991                         // from the original. In order to get around this, we use some
5992                         // proprietary methods to clear the events. Thanks to MooTools
5993                         // guys for this hotness.
5994
5995                         cloneFixAttributes( elem, clone );
5996
5997                         // Using Sizzle here is crazy slow, so we use getElementsByTagName
5998                         // instead
5999                         srcElements = getAll( elem );
6000                         destElements = getAll( clone );
6001
6002                         // Weird iteration because IE will replace the length property
6003                         // with an element if you are cloning the body and one of the
6004                         // elements on the page has a name or id of "length"
6005                         for ( i = 0; srcElements[i]; ++i ) {
6006                                 cloneFixAttributes( srcElements[i], destElements[i] );
6007                         }
6008                 }
6009
6010                 // Copy the events from the original to the clone
6011                 if ( dataAndEvents ) {
6012                         cloneCopyEvent( elem, clone );
6013
6014                         if ( deepDataAndEvents ) {
6015                                 srcElements = getAll( elem );
6016                                 destElements = getAll( clone );
6017
6018                                 for ( i = 0; srcElements[i]; ++i ) {
6019                                         cloneCopyEvent( srcElements[i], destElements[i] );
6020                                 }
6021                         }
6022                 }
6023
6024                 // Return the cloned set
6025                 return clone;
6026         },
6027
6028         clean: function( elems, context, fragment, scripts ) {
6029                 var checkScriptType;
6030
6031                 context = context || document;
6032
6033                 // !context.createElement fails in IE with an error but returns typeof 'object'
6034                 if ( typeof context.createElement === "undefined" ) {
6035                         context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
6036                 }
6037
6038                 var ret = [], j;
6039
6040                 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6041                         if ( typeof elem === "number" ) {
6042                                 elem += "";
6043                         }
6044
6045                         if ( !elem ) {
6046                                 continue;
6047                         }
6048
6049                         // Convert html string into DOM nodes
6050                         if ( typeof elem === "string" ) {
6051                                 if ( !rhtml.test( elem ) ) {
6052                                         elem = context.createTextNode( elem );
6053                                 } else {
6054                                         // Fix "XHTML"-style tags in all browsers
6055                                         elem = elem.replace(rxhtmlTag, "<$1></$2>");
6056
6057                                         // Trim whitespace, otherwise indexOf won't work as expected
6058                                         var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
6059                                                 wrap = wrapMap[ tag ] || wrapMap._default,
6060                                                 depth = wrap[0],
6061                                                 div = context.createElement("div");
6062
6063                                         // Go to html and back, then peel off extra wrappers
6064                                         div.innerHTML = wrap[1] + elem + wrap[2];
6065
6066                                         // Move to the right depth
6067                                         while ( depth-- ) {
6068                                                 div = div.lastChild;
6069                                         }
6070
6071                                         // Remove IE's autoinserted <tbody> from table fragments
6072                                         if ( !jQuery.support.tbody ) {
6073
6074                                                 // String was a <table>, *may* have spurious <tbody>
6075                                                 var hasBody = rtbody.test(elem),
6076                                                         tbody = tag === "table" && !hasBody ?
6077                                                                 div.firstChild && div.firstChild.childNodes :
6078
6079                                                                 // String was a bare <thead> or <tfoot>
6080                                                                 wrap[1] === "<table>" && !hasBody ?
6081                                                                         div.childNodes :
6082                                                                         [];
6083
6084                                                 for ( j = tbody.length - 1; j >= 0 ; --j ) {
6085                                                         if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6086                                                                 tbody[ j ].parentNode.removeChild( tbody[ j ] );
6087                                                         }
6088                                                 }
6089                                         }
6090
6091                                         // IE completely kills leading whitespace when innerHTML is used
6092                                         if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6093                                                 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6094                                         }
6095
6096                                         elem = div.childNodes;
6097                                 }
6098                         }
6099
6100                         // Resets defaultChecked for any radios and checkboxes
6101                         // about to be appended to the DOM in IE 6/7 (#8060)
6102                         var len;
6103                         if ( !jQuery.support.appendChecked ) {
6104                                 if ( elem[0] && typeof (len = elem.length) === "number" ) {
6105                                         for ( j = 0; j < len; j++ ) {
6106                                                 findInputs( elem[j] );
6107                                         }
6108                                 } else {
6109                                         findInputs( elem );
6110                                 }
6111                         }
6112
6113                         if ( elem.nodeType ) {
6114                                 ret.push( elem );
6115                         } else {
6116                                 ret = jQuery.merge( ret, elem );
6117                         }
6118                 }
6119
6120                 if ( fragment ) {
6121                         checkScriptType = function( elem ) {
6122                                 return !elem.type || rscriptType.test( elem.type );
6123                         };
6124                         for ( i = 0; ret[i]; i++ ) {
6125                                 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
6126                                         scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6127
6128                                 } else {
6129                                         if ( ret[i].nodeType === 1 ) {
6130                                                 var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6131
6132                                                 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6133                                         }
6134                                         fragment.appendChild( ret[i] );
6135                                 }
6136                         }
6137                 }
6138
6139                 return ret;
6140         },
6141
6142         cleanData: function( elems ) {
6143                 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
6144                         deleteExpando = jQuery.support.deleteExpando;
6145
6146                 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6147                         if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6148                                 continue;
6149                         }
6150
6151                         id = elem[ jQuery.expando ];
6152
6153                         if ( id ) {
6154                                 data = cache[ id ] && cache[ id ][ internalKey ];
6155
6156                                 if ( data && data.events ) {
6157                                         for ( var type in data.events ) {
6158                                                 if ( special[ type ] ) {
6159                                                         jQuery.event.remove( elem, type );
6160
6161                                                 // This is a shortcut to avoid jQuery.event.remove's overhead
6162                                                 } else {
6163                                                         jQuery.removeEvent( elem, type, data.handle );
6164                                                 }
6165                                         }
6166
6167                                         // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6168                                         if ( data.handle ) {
6169                                                 data.handle.elem = null;
6170                                         }
6171                                 }
6172
6173                                 if ( deleteExpando ) {
6174                                         delete elem[ jQuery.expando ];
6175
6176                                 } else if ( elem.removeAttribute ) {
6177                                         elem.removeAttribute( jQuery.expando );
6178                                 }
6179
6180                                 delete cache[ id ];
6181                         }
6182                 }
6183         }
6184 });
6185
6186 function evalScript( i, elem ) {
6187         if ( elem.src ) {
6188                 jQuery.ajax({
6189                         url: elem.src,
6190                         async: false,
6191                         dataType: "script"
6192                 });
6193         } else {
6194                 jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
6195         }
6196
6197         if ( elem.parentNode ) {
6198                 elem.parentNode.removeChild( elem );
6199         }
6200 }
6201
6202
6203
6204
6205 var ralpha = /alpha\([^)]*\)/i,
6206         ropacity = /opacity=([^)]*)/,
6207         rdashAlpha = /-([a-z])/ig,
6208         // fixed for IE9, see #8346
6209         rupper = /([A-Z]|^ms)/g,
6210         rnumpx = /^-?\d+(?:px)?$/i,
6211         rnum = /^-?\d/,
6212         rrelNum = /^[+\-]=/,
6213         rrelNumFilter = /[^+\-\.\de]+/g,
6214
6215         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6216         cssWidth = [ "Left", "Right" ],
6217         cssHeight = [ "Top", "Bottom" ],
6218         curCSS,
6219
6220         getComputedStyle,
6221         currentStyle,
6222
6223         fcamelCase = function( all, letter ) {
6224                 return letter.toUpperCase();
6225         };
6226
6227 jQuery.fn.css = function( name, value ) {
6228         // Setting 'undefined' is a no-op
6229         if ( arguments.length === 2 && value === undefined ) {
6230                 return this;
6231         }
6232
6233         return jQuery.access( this, name, value, true, function( elem, name, value ) {
6234                 return value !== undefined ?
6235                         jQuery.style( elem, name, value ) :
6236                         jQuery.css( elem, name );
6237         });
6238 };
6239
6240 jQuery.extend({
6241         // Add in style property hooks for overriding the default
6242         // behavior of getting and setting a style property
6243         cssHooks: {
6244                 opacity: {
6245                         get: function( elem, computed ) {
6246                                 if ( computed ) {
6247                                         // We should always get a number back from opacity
6248                                         var ret = curCSS( elem, "opacity", "opacity" );
6249                                         return ret === "" ? "1" : ret;
6250
6251                                 } else {
6252                                         return elem.style.opacity;
6253                                 }
6254                         }
6255                 }
6256         },
6257
6258         // Exclude the following css properties to add px
6259         cssNumber: {
6260                 "zIndex": true,
6261                 "fontWeight": true,
6262                 "opacity": true,
6263                 "zoom": true,
6264                 "lineHeight": true,
6265                 "widows": true,
6266                 "orphans": true
6267         },
6268
6269         // Add in properties whose names you wish to fix before
6270         // setting or getting the value
6271         cssProps: {
6272                 // normalize float css property
6273                 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6274         },
6275
6276         // Get and set the style property on a DOM Node
6277         style: function( elem, name, value, extra ) {
6278                 // Don't set styles on text and comment nodes
6279                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6280                         return;
6281                 }
6282
6283                 // Make sure that we're working with the right name
6284                 var ret, type, origName = jQuery.camelCase( name ),
6285                         style = elem.style, hooks = jQuery.cssHooks[ origName ];
6286
6287                 name = jQuery.cssProps[ origName ] || origName;
6288
6289                 // Check if we're setting a value
6290                 if ( value !== undefined ) {
6291                         type = typeof value;
6292
6293                         // Make sure that NaN and null values aren't set. See: #7116
6294                         if ( type === "number" && isNaN( value ) || value == null ) {
6295                                 return;
6296                         }
6297
6298                         // convert relative number strings (+= or -=) to relative numbers. #7345
6299                         if ( type === "string" && rrelNum.test( value ) ) {
6300                                 value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
6301                         }
6302
6303                         // If a number was passed in, add 'px' to the (except for certain CSS properties)
6304                         if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6305                                 value += "px";
6306                         }
6307
6308                         // If a hook was provided, use that value, otherwise just set the specified value
6309                         if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
6310                                 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6311                                 // Fixes bug #5509
6312                                 try {
6313                                         style[ name ] = value;
6314                                 } catch(e) {}
6315                         }
6316
6317                 } else {
6318                         // If a hook was provided get the non-computed value from there
6319                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6320                                 return ret;
6321                         }
6322
6323                         // Otherwise just get the value from the style object
6324                         return style[ name ];
6325                 }
6326         },
6327
6328         css: function( elem, name, extra ) {
6329                 var ret, hooks;
6330
6331                 // Make sure that we're working with the right name
6332                 name = jQuery.camelCase( name );
6333                 hooks = jQuery.cssHooks[ name ];
6334                 name = jQuery.cssProps[ name ] || name;
6335
6336                 // cssFloat needs a special treatment
6337                 if ( name === "cssFloat" ) {
6338                         name = "float";
6339                 }
6340
6341                 // If a hook was provided get the computed value from there
6342                 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6343                         return ret;
6344
6345                 // Otherwise, if a way to get the computed value exists, use that
6346                 } else if ( curCSS ) {
6347                         return curCSS( elem, name );
6348                 }
6349         },
6350
6351         // A method for quickly swapping in/out CSS properties to get correct calculations
6352         swap: function( elem, options, callback ) {
6353                 var old = {};
6354
6355                 // Remember the old values, and insert the new ones
6356                 for ( var name in options ) {
6357                         old[ name ] = elem.style[ name ];
6358                         elem.style[ name ] = options[ name ];
6359                 }
6360
6361                 callback.call( elem );
6362
6363                 // Revert the old values
6364                 for ( name in options ) {
6365                         elem.style[ name ] = old[ name ];
6366                 }
6367         },
6368
6369         camelCase: function( string ) {
6370                 return string.replace( rdashAlpha, fcamelCase );
6371         }
6372 });
6373
6374 // DEPRECATED, Use jQuery.css() instead
6375 jQuery.curCSS = jQuery.css;
6376
6377 jQuery.each(["height", "width"], function( i, name ) {
6378         jQuery.cssHooks[ name ] = {
6379                 get: function( elem, computed, extra ) {
6380                         var val;
6381
6382                         if ( computed ) {
6383                                 if ( elem.offsetWidth !== 0 ) {
6384                                         val = getWH( elem, name, extra );
6385
6386                                 } else {
6387                                         jQuery.swap( elem, cssShow, function() {
6388                                                 val = getWH( elem, name, extra );
6389                                         });
6390                                 }
6391
6392                                 if ( val <= 0 ) {
6393                                         val = curCSS( elem, name, name );
6394
6395                                         if ( val === "0px" && currentStyle ) {
6396                                                 val = currentStyle( elem, name, name );
6397                                         }
6398
6399                                         if ( val != null ) {
6400                                                 // Should return "auto" instead of 0, use 0 for
6401                                                 // temporary backwards-compat
6402                                                 return val === "" || val === "auto" ? "0px" : val;
6403                                         }
6404                                 }
6405
6406                                 if ( val < 0 || val == null ) {
6407                                         val = elem.style[ name ];
6408
6409                                         // Should return "auto" instead of 0, use 0 for
6410                                         // temporary backwards-compat
6411                                         return val === "" || val === "auto" ? "0px" : val;
6412                                 }
6413
6414                                 return typeof val === "string" ? val : val + "px";
6415                         }
6416                 },
6417
6418                 set: function( elem, value ) {
6419                         if ( rnumpx.test( value ) ) {
6420                                 // ignore negative width and height values #1599
6421                                 value = parseFloat(value);
6422
6423                                 if ( value >= 0 ) {
6424                                         return value + "px";
6425                                 }
6426
6427                         } else {
6428                                 return value;
6429                         }
6430                 }
6431         };
6432 });
6433
6434 if ( !jQuery.support.opacity ) {
6435         jQuery.cssHooks.opacity = {
6436                 get: function( elem, computed ) {
6437                         // IE uses filters for opacity
6438                         return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
6439                                 ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6440                                 computed ? "1" : "";
6441                 },
6442
6443                 set: function( elem, value ) {
6444                         var style = elem.style,
6445                                 currentStyle = elem.currentStyle;
6446
6447                         // IE has trouble with opacity if it does not have layout
6448                         // Force it by setting the zoom level
6449                         style.zoom = 1;
6450
6451                         // Set the alpha filter to set the opacity
6452                         var opacity = jQuery.isNaN( value ) ?
6453                                 "" :
6454                                 "alpha(opacity=" + value * 100 + ")",
6455                                 filter = currentStyle && currentStyle.filter || style.filter || "";
6456
6457                         style.filter = ralpha.test( filter ) ?
6458                                 filter.replace( ralpha, opacity ) :
6459                                 filter + " " + opacity;
6460                 }
6461         };
6462 }
6463
6464 jQuery(function() {
6465         // This hook cannot be added until DOM ready because the support test
6466         // for it is not run until after DOM ready
6467         if ( !jQuery.support.reliableMarginRight ) {
6468                 jQuery.cssHooks.marginRight = {
6469                         get: function( elem, computed ) {
6470                                 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6471                                 // Work around by temporarily setting element display to inline-block
6472                                 var ret;
6473                                 jQuery.swap( elem, { "display": "inline-block" }, function() {
6474                                         if ( computed ) {
6475                                                 ret = curCSS( elem, "margin-right", "marginRight" );
6476                                         } else {
6477                                                 ret = elem.style.marginRight;
6478                                         }
6479                                 });
6480                                 return ret;
6481                         }
6482                 };
6483         }
6484 });
6485
6486 if ( document.defaultView && document.defaultView.getComputedStyle ) {
6487         getComputedStyle = function( elem, name ) {
6488                 var ret, defaultView, computedStyle;
6489
6490                 name = name.replace( rupper, "-$1" ).toLowerCase();
6491
6492                 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
6493                         return undefined;
6494                 }
6495
6496                 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6497                         ret = computedStyle.getPropertyValue( name );
6498                         if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6499                                 ret = jQuery.style( elem, name );
6500                         }
6501                 }
6502
6503                 return ret;
6504         };
6505 }
6506
6507 if ( document.documentElement.currentStyle ) {
6508         currentStyle = function( elem, name ) {
6509                 var left,
6510                         ret = elem.currentStyle && elem.currentStyle[ name ],
6511                         rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
6512                         style = elem.style;
6513
6514                 // From the awesome hack by Dean Edwards
6515                 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6516
6517                 // If we're not dealing with a regular pixel number
6518                 // but a number that has a weird ending, we need to convert it to pixels
6519                 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6520                         // Remember the original values
6521                         left = style.left;
6522
6523                         // Put in the new values to get a computed value out
6524                         if ( rsLeft ) {
6525                                 elem.runtimeStyle.left = elem.currentStyle.left;
6526                         }
6527                         style.left = name === "fontSize" ? "1em" : (ret || 0);
6528                         ret = style.pixelLeft + "px";
6529
6530                         // Revert the changed values
6531                         style.left = left;
6532                         if ( rsLeft ) {
6533                                 elem.runtimeStyle.left = rsLeft;
6534                         }
6535                 }
6536
6537                 return ret === "" ? "auto" : ret;
6538         };
6539 }
6540
6541 curCSS = getComputedStyle || currentStyle;
6542
6543 function getWH( elem, name, extra ) {
6544         var which = name === "width" ? cssWidth : cssHeight,
6545                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
6546
6547         if ( extra === "border" ) {
6548                 return val;
6549         }
6550
6551         jQuery.each( which, function() {
6552                 if ( !extra ) {
6553                         val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
6554                 }
6555
6556                 if ( extra === "margin" ) {
6557                         val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
6558
6559                 } else {
6560                         val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
6561                 }
6562         });
6563
6564         return val;
6565 }
6566
6567 if ( jQuery.expr && jQuery.expr.filters ) {
6568         jQuery.expr.filters.hidden = function( elem ) {
6569                 var width = elem.offsetWidth,
6570                         height = elem.offsetHeight;
6571
6572                 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
6573         };
6574
6575         jQuery.expr.filters.visible = function( elem ) {
6576                 return !jQuery.expr.filters.hidden( elem );
6577         };
6578 }
6579
6580
6581
6582
6583 var r20 = /%20/g,
6584         rbracket = /\[\]$/,
6585         rCRLF = /\r?\n/g,
6586         rhash = /#.*$/,
6587         rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6588         rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
6589         // #7653, #8125, #8152: local protocol detection
6590         rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/,
6591         rnoContent = /^(?:GET|HEAD)$/,
6592         rprotocol = /^\/\//,
6593         rquery = /\?/,
6594         rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
6595         rselectTextarea = /^(?:select|textarea)/i,
6596         rspacesAjax = /\s+/,
6597         rts = /([?&])_=[^&]*/,
6598         rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6599
6600         // Keep a copy of the old load method
6601         _load = jQuery.fn.load,
6602
6603         /* Prefilters
6604          * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6605          * 2) These are called:
6606          *    - BEFORE asking for a transport
6607          *    - AFTER param serialization (s.data is a string if s.processData is true)
6608          * 3) key is the dataType
6609          * 4) the catchall symbol "*" can be used
6610          * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6611          */
6612         prefilters = {},
6613
6614         /* Transports bindings
6615          * 1) key is the dataType
6616          * 2) the catchall symbol "*" can be used
6617          * 3) selection will start with transport dataType and THEN go to "*" if needed
6618          */
6619         transports = {},
6620
6621         // Document location
6622         ajaxLocation,
6623
6624         // Document location segments
6625         ajaxLocParts;
6626
6627 // #8138, IE may throw an exception when accessing
6628 // a field from window.location if document.domain has been set
6629 try {
6630         ajaxLocation = location.href;
6631 } catch( e ) {
6632         // Use the href attribute of an A element
6633         // since IE will modify it given document.location
6634         ajaxLocation = document.createElement( "a" );
6635         ajaxLocation.href = "";
6636         ajaxLocation = ajaxLocation.href;
6637 }
6638
6639 // Segment location into parts
6640 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
6641
6642 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6643 function addToPrefiltersOrTransports( structure ) {
6644
6645         // dataTypeExpression is optional and defaults to "*"
6646         return function( dataTypeExpression, func ) {
6647
6648                 if ( typeof dataTypeExpression !== "string" ) {
6649                         func = dataTypeExpression;
6650                         dataTypeExpression = "*";
6651                 }
6652
6653                 if ( jQuery.isFunction( func ) ) {
6654                         var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6655                                 i = 0,
6656                                 length = dataTypes.length,
6657                                 dataType,
6658                                 list,
6659                                 placeBefore;
6660
6661                         // For each dataType in the dataTypeExpression
6662                         for(; i < length; i++ ) {
6663                                 dataType = dataTypes[ i ];
6664                                 // We control if we're asked to add before
6665                                 // any existing element
6666                                 placeBefore = /^\+/.test( dataType );
6667                                 if ( placeBefore ) {
6668                                         dataType = dataType.substr( 1 ) || "*";
6669                                 }
6670                                 list = structure[ dataType ] = structure[ dataType ] || [];
6671                                 // then we add to the structure accordingly
6672                                 list[ placeBefore ? "unshift" : "push" ]( func );
6673                         }
6674                 }
6675         };
6676 }
6677
6678 // Base inspection function for prefilters and transports
6679 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6680                 dataType /* internal */, inspected /* internal */ ) {
6681
6682         dataType = dataType || options.dataTypes[ 0 ];
6683         inspected = inspected || {};
6684
6685         inspected[ dataType ] = true;
6686
6687         var list = structure[ dataType ],
6688                 i = 0,
6689                 length = list ? list.length : 0,
6690                 executeOnly = ( structure === prefilters ),
6691                 selection;
6692
6693         for(; i < length && ( executeOnly || !selection ); i++ ) {
6694                 selection = list[ i ]( options, originalOptions, jqXHR );
6695                 // If we got redirected to another dataType
6696                 // we try there if executing only and not done already
6697                 if ( typeof selection === "string" ) {
6698                         if ( !executeOnly || inspected[ selection ] ) {
6699                                 selection = undefined;
6700                         } else {
6701                                 options.dataTypes.unshift( selection );
6702                                 selection = inspectPrefiltersOrTransports(
6703                                                 structure, options, originalOptions, jqXHR, selection, inspected );
6704                         }
6705                 }
6706         }
6707         // If we're only executing or nothing was selected
6708         // we try the catchall dataType if not done already
6709         if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
6710                 selection = inspectPrefiltersOrTransports(
6711                                 structure, options, originalOptions, jqXHR, "*", inspected );
6712         }
6713         // unnecessary when only executing (prefilters)
6714         // but it'll be ignored by the caller in that case
6715         return selection;
6716 }
6717
6718 jQuery.fn.extend({
6719         load: function( url, params, callback ) {
6720                 if ( typeof url !== "string" && _load ) {
6721                         return _load.apply( this, arguments );
6722
6723                 // Don't do a request if no elements are being requested
6724                 } else if ( !this.length ) {
6725                         return this;
6726                 }
6727
6728                 var off = url.indexOf( " " );
6729                 if ( off >= 0 ) {
6730                         var selector = url.slice( off, url.length );
6731                         url = url.slice( 0, off );
6732                 }
6733
6734                 // Default to a GET request
6735                 var type = "GET";
6736
6737                 // If the second parameter was provided
6738                 if ( params ) {
6739                         // If it's a function
6740                         if ( jQuery.isFunction( params ) ) {
6741                                 // We assume that it's the callback
6742                                 callback = params;
6743                                 params = undefined;
6744
6745                         // Otherwise, build a param string
6746                         } else if ( typeof params === "object" ) {
6747                                 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
6748                                 type = "POST";
6749                         }
6750                 }
6751
6752                 var self = this;
6753
6754                 // Request the remote document
6755                 jQuery.ajax({
6756                         url: url,
6757                         type: type,
6758                         dataType: "html",
6759                         data: params,
6760                         // Complete callback (responseText is used internally)
6761                         complete: function( jqXHR, status, responseText ) {
6762                                 // Store the response as specified by the jqXHR object
6763                                 responseText = jqXHR.responseText;
6764                                 // If successful, inject the HTML into all the matched elements
6765                                 if ( jqXHR.isResolved() ) {
6766                                         // #4825: Get the actual response in case
6767                                         // a dataFilter is present in ajaxSettings
6768                                         jqXHR.done(function( r ) {
6769                                                 responseText = r;
6770                                         });
6771                                         // See if a selector was specified
6772                                         self.html( selector ?
6773                                                 // Create a dummy div to hold the results
6774                                                 jQuery("<div>")
6775                                                         // inject the contents of the document in, removing the scripts
6776                                                         // to avoid any 'Permission Denied' errors in IE
6777                                                         .append(responseText.replace(rscript, ""))
6778
6779                                                         // Locate the specified elements
6780                                                         .find(selector) :
6781
6782                                                 // If not, just inject the full result
6783                                                 responseText );
6784                                 }
6785
6786                                 if ( callback ) {
6787                                         self.each( callback, [ responseText, status, jqXHR ] );
6788                                 }
6789                         }
6790                 });
6791
6792                 return this;
6793         },
6794
6795         serialize: function() {
6796                 return jQuery.param( this.serializeArray() );
6797         },
6798
6799         serializeArray: function() {
6800                 return this.map(function(){
6801                         return this.elements ? jQuery.makeArray( this.elements ) : this;
6802                 })
6803                 .filter(function(){
6804                         return this.name && !this.disabled &&
6805                                 ( this.checked || rselectTextarea.test( this.nodeName ) ||
6806                                         rinput.test( this.type ) );
6807                 })
6808                 .map(function( i, elem ){
6809                         var val = jQuery( this ).val();
6810
6811                         return val == null ?
6812                                 null :
6813                                 jQuery.isArray( val ) ?
6814                                         jQuery.map( val, function( val, i ){
6815                                                 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6816                                         }) :
6817                                         { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6818                 }).get();
6819         }
6820 });
6821
6822 // Attach a bunch of functions for handling common AJAX events
6823 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
6824         jQuery.fn[ o ] = function( f ){
6825                 return this.bind( o, f );
6826         };
6827 });
6828
6829 jQuery.each( [ "get", "post" ], function( i, method ) {
6830         jQuery[ method ] = function( url, data, callback, type ) {
6831                 // shift arguments if data argument was omitted
6832                 if ( jQuery.isFunction( data ) ) {
6833                         type = type || callback;
6834                         callback = data;
6835                         data = undefined;
6836                 }
6837
6838                 return jQuery.ajax({
6839                         type: method,
6840                         url: url,
6841                         data: data,
6842                         success: callback,
6843                         dataType: type
6844                 });
6845         };
6846 });
6847
6848 jQuery.extend({
6849
6850         getScript: function( url, callback ) {
6851                 return jQuery.get( url, undefined, callback, "script" );
6852         },
6853
6854         getJSON: function( url, data, callback ) {
6855                 return jQuery.get( url, data, callback, "json" );
6856         },
6857
6858         // Creates a full fledged settings object into target
6859         // with both ajaxSettings and settings fields.
6860         // If target is omitted, writes into ajaxSettings.
6861         ajaxSetup: function ( target, settings ) {
6862                 if ( !settings ) {
6863                         // Only one parameter, we extend ajaxSettings
6864                         settings = target;
6865                         target = jQuery.extend( true, jQuery.ajaxSettings, settings );
6866                 } else {
6867                         // target was provided, we extend into it
6868                         jQuery.extend( true, target, jQuery.ajaxSettings, settings );
6869                 }
6870                 // Flatten fields we don't want deep extended
6871                 for( var field in { context: 1, url: 1 } ) {
6872                         if ( field in settings ) {
6873                                 target[ field ] = settings[ field ];
6874                         } else if( field in jQuery.ajaxSettings ) {
6875                                 target[ field ] = jQuery.ajaxSettings[ field ];
6876                         }
6877                 }
6878                 return target;
6879         },
6880
6881         ajaxSettings: {
6882                 url: ajaxLocation,
6883                 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
6884                 global: true,
6885                 type: "GET",
6886                 contentType: "application/x-www-form-urlencoded",
6887                 processData: true,
6888                 async: true,
6889                 /*
6890                 timeout: 0,
6891                 data: null,
6892                 dataType: null,
6893                 username: null,
6894                 password: null,
6895                 cache: null,
6896                 traditional: false,
6897                 headers: {},
6898                 */
6899
6900                 accepts: {
6901                         xml: "application/xml, text/xml",
6902                         html: "text/html",
6903                         text: "text/plain",
6904                         json: "application/json, text/javascript",
6905                         "*": "*/*"
6906                 },
6907
6908                 contents: {
6909                         xml: /xml/,
6910                         html: /html/,
6911                         json: /json/
6912                 },
6913
6914                 responseFields: {
6915                         xml: "responseXML",
6916                         text: "responseText"
6917                 },
6918
6919                 // List of data converters
6920                 // 1) key format is "source_type destination_type" (a single space in-between)
6921                 // 2) the catchall symbol "*" can be used for source_type
6922                 converters: {
6923
6924                         // Convert anything to text
6925                         "* text": window.String,
6926
6927                         // Text to html (true = no transformation)
6928                         "text html": true,
6929
6930                         // Evaluate text as a json expression
6931                         "text json": jQuery.parseJSON,
6932
6933                         // Parse text as xml
6934                         "text xml": jQuery.parseXML
6935                 }
6936         },
6937
6938         ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
6939         ajaxTransport: addToPrefiltersOrTransports( transports ),
6940
6941         // Main method
6942         ajax: function( url, options ) {
6943
6944                 // If url is an object, simulate pre-1.5 signature
6945                 if ( typeof url === "object" ) {
6946                         options = url;
6947                         url = undefined;
6948                 }
6949
6950                 // Force options to be an object
6951                 options = options || {};
6952
6953                 var // Create the final options object
6954                         s = jQuery.ajaxSetup( {}, options ),
6955                         // Callbacks context
6956                         callbackContext = s.context || s,
6957                         // Context for global events
6958                         // It's the callbackContext if one was provided in the options
6959                         // and if it's a DOM node or a jQuery collection
6960                         globalEventContext = callbackContext !== s &&
6961                                 ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
6962                                                 jQuery( callbackContext ) : jQuery.event,
6963                         // Deferreds
6964                         deferred = jQuery.Deferred(),
6965                         completeDeferred = jQuery._Deferred(),
6966                         // Status-dependent callbacks
6967                         statusCode = s.statusCode || {},
6968                         // ifModified key
6969                         ifModifiedKey,
6970                         // Headers (they are sent all at once)
6971                         requestHeaders = {},
6972                         requestHeadersNames = {},
6973                         // Response headers
6974                         responseHeadersString,
6975                         responseHeaders,
6976                         // transport
6977                         transport,
6978                         // timeout handle
6979                         timeoutTimer,
6980                         // Cross-domain detection vars
6981                         parts,
6982                         // The jqXHR state
6983                         state = 0,
6984                         // To know if global events are to be dispatched
6985                         fireGlobals,
6986                         // Loop variable
6987                         i,
6988                         // Fake xhr
6989                         jqXHR = {
6990
6991                                 readyState: 0,
6992
6993                                 // Caches the header
6994                                 setRequestHeader: function( name, value ) {
6995                                         if ( !state ) {
6996                                                 var lname = name.toLowerCase();
6997                                                 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
6998                                                 requestHeaders[ name ] = value;
6999                                         }
7000                                         return this;
7001                                 },
7002
7003                                 // Raw string
7004                                 getAllResponseHeaders: function() {
7005                                         return state === 2 ? responseHeadersString : null;
7006                                 },
7007
7008                                 // Builds headers hashtable if needed
7009                                 getResponseHeader: function( key ) {
7010                                         var match;
7011                                         if ( state === 2 ) {
7012                                                 if ( !responseHeaders ) {
7013                                                         responseHeaders = {};
7014                                                         while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7015                                                                 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7016                                                         }
7017                                                 }
7018                                                 match = responseHeaders[ key.toLowerCase() ];
7019                                         }
7020                                         return match === undefined ? null : match;
7021                                 },
7022
7023                                 // Overrides response content-type header
7024                                 overrideMimeType: function( type ) {
7025                                         if ( !state ) {
7026                                                 s.mimeType = type;
7027                                         }
7028                                         return this;
7029                                 },
7030
7031                                 // Cancel the request
7032                                 abort: function( statusText ) {
7033                                         statusText = statusText || "abort";
7034                                         if ( transport ) {
7035                                                 transport.abort( statusText );
7036                                         }
7037                                         done( 0, statusText );
7038                                         return this;
7039                                 }
7040                         };
7041
7042                 // Callback for when everything is done
7043                 // It is defined here because jslint complains if it is declared
7044                 // at the end of the function (which would be more logical and readable)
7045                 function done( status, statusText, responses, headers ) {
7046
7047                         // Called once
7048                         if ( state === 2 ) {
7049                                 return;
7050                         }
7051
7052                         // State is "done" now
7053                         state = 2;
7054
7055                         // Clear timeout if it exists
7056                         if ( timeoutTimer ) {
7057                                 clearTimeout( timeoutTimer );
7058                         }
7059
7060                         // Dereference transport for early garbage collection
7061                         // (no matter how long the jqXHR object will be used)
7062                         transport = undefined;
7063
7064                         // Cache response headers
7065                         responseHeadersString = headers || "";
7066
7067                         // Set readyState
7068                         jqXHR.readyState = status ? 4 : 0;
7069
7070                         var isSuccess,
7071                                 success,
7072                                 error,
7073                                 response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7074                                 lastModified,
7075                                 etag;
7076
7077                         // If successful, handle type chaining
7078                         if ( status >= 200 && status < 300 || status === 304 ) {
7079
7080                                 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7081                                 if ( s.ifModified ) {
7082
7083                                         if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7084                                                 jQuery.lastModified[ ifModifiedKey ] = lastModified;
7085                                         }
7086                                         if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7087                                                 jQuery.etag[ ifModifiedKey ] = etag;
7088                                         }
7089                                 }
7090
7091                                 // If not modified
7092                                 if ( status === 304 ) {
7093
7094                                         statusText = "notmodified";
7095                                         isSuccess = true;
7096
7097                                 // If we have data
7098                                 } else {
7099
7100                                         try {
7101                                                 success = ajaxConvert( s, response );
7102                                                 statusText = "success";
7103                                                 isSuccess = true;
7104                                         } catch(e) {
7105                                                 // We have a parsererror
7106                                                 statusText = "parsererror";
7107                                                 error = e;
7108                                         }
7109                                 }
7110                         } else {
7111                                 // We extract error from statusText
7112                                 // then normalize statusText and status for non-aborts
7113                                 error = statusText;
7114                                 if( !statusText || status ) {
7115                                         statusText = "error";
7116                                         if ( status < 0 ) {
7117                                                 status = 0;
7118                                         }
7119                                 }
7120                         }
7121
7122                         // Set data for the fake xhr object
7123                         jqXHR.status = status;
7124                         jqXHR.statusText = statusText;
7125
7126                         // Success/Error
7127                         if ( isSuccess ) {
7128                                 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7129                         } else {
7130                                 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7131                         }
7132
7133                         // Status-dependent callbacks
7134                         jqXHR.statusCode( statusCode );
7135                         statusCode = undefined;
7136
7137                         if ( fireGlobals ) {
7138                                 globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7139                                                 [ jqXHR, s, isSuccess ? success : error ] );
7140                         }
7141
7142                         // Complete
7143                         completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
7144
7145                         if ( fireGlobals ) {
7146                                 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
7147                                 // Handle the global AJAX counter
7148                                 if ( !( --jQuery.active ) ) {
7149                                         jQuery.event.trigger( "ajaxStop" );
7150                                 }
7151                         }
7152                 }
7153
7154                 // Attach deferreds
7155                 deferred.promise( jqXHR );
7156                 jqXHR.success = jqXHR.done;
7157                 jqXHR.error = jqXHR.fail;
7158                 jqXHR.complete = completeDeferred.done;
7159
7160                 // Status-dependent callbacks
7161                 jqXHR.statusCode = function( map ) {
7162                         if ( map ) {
7163                                 var tmp;
7164                                 if ( state < 2 ) {
7165                                         for( tmp in map ) {
7166                                                 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7167                                         }
7168                                 } else {
7169                                         tmp = map[ jqXHR.status ];
7170                                         jqXHR.then( tmp, tmp );
7171                                 }
7172                         }
7173                         return this;
7174                 };
7175
7176                 // Remove hash character (#7531: and string promotion)
7177                 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7178                 // We also use the url parameter if available
7179                 s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7180
7181                 // Extract dataTypes list
7182                 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
7183
7184                 // Determine if a cross-domain request is in order
7185                 if ( s.crossDomain == null ) {
7186                         parts = rurl.exec( s.url.toLowerCase() );
7187                         s.crossDomain = !!( parts &&
7188                                 ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
7189                                         ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7190                                                 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7191                         );
7192                 }
7193
7194                 // Convert data if not already a string
7195                 if ( s.data && s.processData && typeof s.data !== "string" ) {
7196                         s.data = jQuery.param( s.data, s.traditional );
7197                 }
7198
7199                 // Apply prefilters
7200                 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7201
7202                 // If request was aborted inside a prefiler, stop there
7203                 if ( state === 2 ) {
7204                         return false;
7205                 }
7206
7207                 // We can fire global events as of now if asked to
7208                 fireGlobals = s.global;
7209
7210                 // Uppercase the type
7211                 s.type = s.type.toUpperCase();
7212
7213                 // Determine if request has content
7214                 s.hasContent = !rnoContent.test( s.type );
7215
7216                 // Watch for a new set of requests
7217                 if ( fireGlobals && jQuery.active++ === 0 ) {
7218                         jQuery.event.trigger( "ajaxStart" );
7219                 }
7220
7221                 // More options handling for requests with no content
7222                 if ( !s.hasContent ) {
7223
7224                         // If data is available, append data to url
7225                         if ( s.data ) {
7226                                 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7227                         }
7228
7229                         // Get ifModifiedKey before adding the anti-cache parameter
7230                         ifModifiedKey = s.url;
7231
7232                         // Add anti-cache in url if needed
7233                         if ( s.cache === false ) {
7234
7235                                 var ts = jQuery.now(),
7236                                         // try replacing _= if it is there
7237                                         ret = s.url.replace( rts, "$1_=" + ts );
7238
7239                                 // if nothing was replaced, add timestamp to the end
7240                                 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7241                         }
7242                 }
7243
7244                 // Set the correct header, if data is being sent
7245                 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
7246                         jqXHR.setRequestHeader( "Content-Type", s.contentType );
7247                 }
7248
7249                 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7250                 if ( s.ifModified ) {
7251                         ifModifiedKey = ifModifiedKey || s.url;
7252                         if ( jQuery.lastModified[ ifModifiedKey ] ) {
7253                                 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7254                         }
7255                         if ( jQuery.etag[ ifModifiedKey ] ) {
7256                                 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7257                         }
7258                 }
7259
7260                 // Set the Accepts header for the server, depending on the dataType
7261                 jqXHR.setRequestHeader(
7262                         "Accept",
7263                         s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7264                                 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
7265                                 s.accepts[ "*" ]
7266                 );
7267
7268                 // Check for headers option
7269                 for ( i in s.headers ) {
7270                         jqXHR.setRequestHeader( i, s.headers[ i ] );
7271                 }
7272
7273                 // Allow custom headers/mimetypes and early abort
7274                 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
7275                                 // Abort if not done already
7276                                 jqXHR.abort();
7277                                 return false;
7278
7279                 }
7280
7281                 // Install callbacks on deferreds
7282                 for ( i in { success: 1, error: 1, complete: 1 } ) {
7283                         jqXHR[ i ]( s[ i ] );
7284                 }
7285
7286                 // Get transport
7287                 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7288
7289                 // If no transport, we auto-abort
7290                 if ( !transport ) {
7291                         done( -1, "No Transport" );
7292                 } else {
7293                         jqXHR.readyState = 1;
7294                         // Send global event
7295                         if ( fireGlobals ) {
7296                                 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7297                         }
7298                         // Timeout
7299                         if ( s.async && s.timeout > 0 ) {
7300                                 timeoutTimer = setTimeout( function(){
7301                                         jqXHR.abort( "timeout" );
7302                                 }, s.timeout );
7303                         }
7304
7305                         try {
7306                                 state = 1;
7307                                 transport.send( requestHeaders, done );
7308                         } catch (e) {
7309                                 // Propagate exception as error if not done
7310                                 if ( status < 2 ) {
7311                                         done( -1, e );
7312                                 // Simply rethrow otherwise
7313                                 } else {
7314                                         jQuery.error( e );
7315                                 }
7316                         }
7317                 }
7318
7319                 return jqXHR;
7320         },
7321
7322         // Serialize an array of form elements or a set of
7323         // key/values into a query string
7324         param: function( a, traditional ) {
7325                 var s = [],
7326                         add = function( key, value ) {
7327                                 // If value is a function, invoke it and return its value
7328                                 value = jQuery.isFunction( value ) ? value() : value;
7329                                 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7330                         };
7331
7332                 // Set traditional to true for jQuery <= 1.3.2 behavior.
7333                 if ( traditional === undefined ) {
7334                         traditional = jQuery.ajaxSettings.traditional;
7335                 }
7336
7337                 // If an array was passed in, assume that it is an array of form elements.
7338                 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7339                         // Serialize the form elements
7340                         jQuery.each( a, function() {
7341                                 add( this.name, this.value );
7342                         });
7343
7344                 } else {
7345                         // If traditional, encode the "old" way (the way 1.3.2 or older
7346                         // did it), otherwise encode params recursively.
7347                         for ( var prefix in a ) {
7348                                 buildParams( prefix, a[ prefix ], traditional, add );
7349                         }
7350                 }
7351
7352                 // Return the resulting serialization
7353                 return s.join( "&" ).replace( r20, "+" );
7354         }
7355 });
7356
7357 function buildParams( prefix, obj, traditional, add ) {
7358         if ( jQuery.isArray( obj ) ) {
7359                 // Serialize array item.
7360                 jQuery.each( obj, function( i, v ) {
7361                         if ( traditional || rbracket.test( prefix ) ) {
7362                                 // Treat each array item as a scalar.
7363                                 add( prefix, v );
7364
7365                         } else {
7366                                 // If array item is non-scalar (array or object), encode its
7367                                 // numeric index to resolve deserialization ambiguity issues.
7368                                 // Note that rack (as of 1.0.0) can't currently deserialize
7369                                 // nested arrays properly, and attempting to do so may cause
7370                                 // a server error. Possible fixes are to modify rack's
7371                                 // deserialization algorithm or to provide an option or flag
7372                                 // to force array serialization to be shallow.
7373                                 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7374                         }
7375                 });
7376
7377         } else if ( !traditional && obj != null && typeof obj === "object" ) {
7378                 // Serialize object item.
7379                 for ( var name in obj ) {
7380                         buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7381                 }
7382
7383         } else {
7384                 // Serialize scalar item.
7385                 add( prefix, obj );
7386         }
7387 }
7388
7389 // This is still on the jQuery object... for now
7390 // Want to move this to jQuery.ajax some day
7391 jQuery.extend({
7392
7393         // Counter for holding the number of active queries
7394         active: 0,
7395
7396         // Last-Modified header cache for next request
7397         lastModified: {},
7398         etag: {}
7399
7400 });
7401
7402 /* Handles responses to an ajax request:
7403  * - sets all responseXXX fields accordingly
7404  * - finds the right dataType (mediates between content-type and expected dataType)
7405  * - returns the corresponding response
7406  */
7407 function ajaxHandleResponses( s, jqXHR, responses ) {
7408
7409         var contents = s.contents,
7410                 dataTypes = s.dataTypes,
7411                 responseFields = s.responseFields,
7412                 ct,
7413                 type,
7414                 finalDataType,
7415                 firstDataType;
7416
7417         // Fill responseXXX fields
7418         for( type in responseFields ) {
7419                 if ( type in responses ) {
7420                         jqXHR[ responseFields[type] ] = responses[ type ];
7421                 }
7422         }
7423
7424         // Remove auto dataType and get content-type in the process
7425         while( dataTypes[ 0 ] === "*" ) {
7426                 dataTypes.shift();
7427                 if ( ct === undefined ) {
7428                         ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
7429                 }
7430         }
7431
7432         // Check if we're dealing with a known content-type
7433         if ( ct ) {
7434                 for ( type in contents ) {
7435                         if ( contents[ type ] && contents[ type ].test( ct ) ) {
7436                                 dataTypes.unshift( type );
7437                                 break;
7438                         }
7439                 }
7440         }
7441
7442         // Check to see if we have a response for the expected dataType
7443         if ( dataTypes[ 0 ] in responses ) {
7444                 finalDataType = dataTypes[ 0 ];
7445         } else {
7446                 // Try convertible dataTypes
7447                 for ( type in responses ) {
7448                         if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
7449                                 finalDataType = type;
7450                                 break;
7451                         }
7452                         if ( !firstDataType ) {
7453                                 firstDataType = type;
7454                         }
7455                 }
7456                 // Or just use first one
7457                 finalDataType = finalDataType || firstDataType;
7458         }
7459
7460         // If we found a dataType
7461         // We add the dataType to the list if needed
7462         // and return the corresponding response
7463         if ( finalDataType ) {
7464                 if ( finalDataType !== dataTypes[ 0 ] ) {
7465                         dataTypes.unshift( finalDataType );
7466                 }
7467                 return responses[ finalDataType ];
7468         }
7469 }
7470
7471 // Chain conversions given the request and the original response
7472 function ajaxConvert( s, response ) {
7473
7474         // Apply the dataFilter if provided
7475         if ( s.dataFilter ) {
7476                 response = s.dataFilter( response, s.dataType );
7477         }
7478
7479         var dataTypes = s.dataTypes,
7480                 converters = {},
7481                 i,
7482                 key,
7483                 length = dataTypes.length,
7484                 tmp,
7485                 // Current and previous dataTypes
7486                 current = dataTypes[ 0 ],
7487                 prev,
7488                 // Conversion expression
7489                 conversion,
7490                 // Conversion function
7491                 conv,
7492                 // Conversion functions (transitive conversion)
7493                 conv1,
7494                 conv2;
7495
7496         // For each dataType in the chain
7497         for( i = 1; i < length; i++ ) {
7498
7499                 // Create converters map
7500                 // with lowercased keys
7501                 if ( i === 1 ) {
7502                         for( key in s.converters ) {
7503                                 if( typeof key === "string" ) {
7504                                         converters[ key.toLowerCase() ] = s.converters[ key ];
7505                                 }
7506                         }
7507                 }
7508
7509                 // Get the dataTypes
7510                 prev = current;
7511                 current = dataTypes[ i ];
7512
7513                 // If current is auto dataType, update it to prev
7514                 if( current === "*" ) {
7515                         current = prev;
7516                 // If no auto and dataTypes are actually different
7517                 } else if ( prev !== "*" && prev !== current ) {
7518
7519                         // Get the converter
7520                         conversion = prev + " " + current;
7521                         conv = converters[ conversion ] || converters[ "* " + current ];
7522
7523                         // If there is no direct converter, search transitively
7524                         if ( !conv ) {
7525                                 conv2 = undefined;
7526                                 for( conv1 in converters ) {
7527                                         tmp = conv1.split( " " );
7528                                         if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
7529                                                 conv2 = converters[ tmp[1] + " " + current ];
7530                                                 if ( conv2 ) {
7531                                                         conv1 = converters[ conv1 ];
7532                                                         if ( conv1 === true ) {
7533                                                                 conv = conv2;
7534                                                         } else if ( conv2 === true ) {
7535                                                                 conv = conv1;
7536                                                         }
7537                                                         break;
7538                                                 }
7539                                         }
7540                                 }
7541                         }
7542                         // If we found no converter, dispatch an error
7543                         if ( !( conv || conv2 ) ) {
7544                                 jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7545                         }
7546                         // If found converter is not an equivalence
7547                         if ( conv !== true ) {
7548                                 // Convert with 1 or 2 converters accordingly
7549                                 response = conv ? conv( response ) : conv2( conv1(response) );
7550                         }
7551                 }
7552         }
7553         return response;
7554 }
7555
7556
7557
7558
7559 var jsc = jQuery.now(),
7560         jsre = /(\=)\?(&|$)|\?\?/i;
7561
7562 // Default jsonp settings
7563 jQuery.ajaxSetup({
7564         jsonp: "callback",
7565         jsonpCallback: function() {
7566                 return jQuery.expando + "_" + ( jsc++ );
7567         }
7568 });
7569
7570 // Detect, normalize options and install callbacks for jsonp requests
7571 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7572
7573         var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7574                 ( typeof s.data === "string" );
7575
7576         if ( s.dataTypes[ 0 ] === "jsonp" ||
7577                 s.jsonp !== false && ( jsre.test( s.url ) ||
7578                                 inspectData && jsre.test( s.data ) ) ) {
7579
7580                 var responseContainer,
7581                         jsonpCallback = s.jsonpCallback =
7582                                 jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7583                         previous = window[ jsonpCallback ],
7584                         url = s.url,
7585                         data = s.data,
7586                         replace = "$1" + jsonpCallback + "$2";
7587
7588                 if ( s.jsonp !== false ) {
7589                         url = url.replace( jsre, replace );
7590                         if ( s.url === url ) {
7591                                 if ( inspectData ) {
7592                                         data = data.replace( jsre, replace );
7593                                 }
7594                                 if ( s.data === data ) {
7595                                         // Add callback manually
7596                                         url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7597                                 }
7598                         }
7599                 }
7600
7601                 s.url = url;
7602                 s.data = data;
7603
7604                 // Install callback
7605                 window[ jsonpCallback ] = function( response ) {
7606                         responseContainer = [ response ];
7607                 };
7608
7609                 // Clean-up function
7610                 jqXHR.always(function() {
7611                         // Set callback back to previous value
7612                         window[ jsonpCallback ] = previous;
7613                         // Call if it was a function and we have a response
7614                         if ( responseContainer && jQuery.isFunction( previous ) ) {
7615                                 window[ jsonpCallback ]( responseContainer[ 0 ] );
7616                         }
7617                 });
7618
7619                 // Use data converter to retrieve json after script execution
7620                 s.converters["script json"] = function() {
7621                         if ( !responseContainer ) {
7622                                 jQuery.error( jsonpCallback + " was not called" );
7623                         }
7624                         return responseContainer[ 0 ];
7625                 };
7626
7627                 // force json dataType
7628                 s.dataTypes[ 0 ] = "json";
7629
7630                 // Delegate to script
7631                 return "script";
7632         }
7633 });
7634
7635
7636
7637
7638 // Install script dataType
7639 jQuery.ajaxSetup({
7640         accepts: {
7641                 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7642         },
7643         contents: {
7644                 script: /javascript|ecmascript/
7645         },
7646         converters: {
7647                 "text script": function( text ) {
7648                         jQuery.globalEval( text );
7649                         return text;
7650                 }
7651         }
7652 });
7653
7654 // Handle cache's special case and global
7655 jQuery.ajaxPrefilter( "script", function( s ) {
7656         if ( s.cache === undefined ) {
7657                 s.cache = false;
7658         }
7659         if ( s.crossDomain ) {
7660                 s.type = "GET";
7661                 s.global = false;
7662         }
7663 });
7664
7665 // Bind script tag hack transport
7666 jQuery.ajaxTransport( "script", function(s) {
7667
7668         // This transport only deals with cross domain requests
7669         if ( s.crossDomain ) {
7670
7671                 var script,
7672                         head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
7673
7674                 return {
7675
7676                         send: function( _, callback ) {
7677
7678                                 script = document.createElement( "script" );
7679
7680                                 script.async = "async";
7681
7682                                 if ( s.scriptCharset ) {
7683                                         script.charset = s.scriptCharset;
7684                                 }
7685
7686                                 script.src = s.url;
7687
7688                                 // Attach handlers for all browsers
7689                                 script.onload = script.onreadystatechange = function( _, isAbort ) {
7690
7691                                         if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
7692
7693                                                 // Handle memory leak in IE
7694                                                 script.onload = script.onreadystatechange = null;
7695
7696                                                 // Remove the script
7697                                                 if ( head && script.parentNode ) {
7698                                                         head.removeChild( script );
7699                                                 }
7700
7701                                                 // Dereference the script
7702                                                 script = undefined;
7703
7704                                                 // Callback if not abort
7705                                                 if ( !isAbort ) {
7706                                                         callback( 200, "success" );
7707                                                 }
7708                                         }
7709                                 };
7710                                 // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
7711                                 // This arises when a base node is used (#2709 and #4378).
7712                                 head.insertBefore( script, head.firstChild );
7713                         },
7714
7715                         abort: function() {
7716                                 if ( script ) {
7717                                         script.onload( 0, 1 );
7718                                 }
7719                         }
7720                 };
7721         }
7722 });
7723
7724
7725
7726
7727 var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
7728         xhrOnUnloadAbort = window.ActiveXObject ? function() {
7729                 // Abort all pending requests
7730                 for ( var key in xhrCallbacks ) {
7731                         xhrCallbacks[ key ]( 0, 1 );
7732                 }
7733         } : false,
7734         xhrId = 0,
7735         xhrCallbacks;
7736
7737 // Functions to create xhrs
7738 function createStandardXHR() {
7739         try {
7740                 return new window.XMLHttpRequest();
7741         } catch( e ) {}
7742 }
7743
7744 function createActiveXHR() {
7745         try {
7746                 return new window.ActiveXObject( "Microsoft.XMLHTTP" );
7747         } catch( e ) {}
7748 }
7749
7750 // Create the request object
7751 // (This is still attached to ajaxSettings for backward compatibility)
7752 jQuery.ajaxSettings.xhr = window.ActiveXObject ?
7753         /* Microsoft failed to properly
7754          * implement the XMLHttpRequest in IE7 (can't request local files),
7755          * so we use the ActiveXObject when it is available
7756          * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
7757          * we need a fallback.
7758          */
7759         function() {
7760                 return !this.isLocal && createStandardXHR() || createActiveXHR();
7761         } :
7762         // For all other browsers, use the standard XMLHttpRequest object
7763         createStandardXHR;
7764
7765 // Determine support properties
7766 (function( xhr ) {
7767         jQuery.extend( jQuery.support, {
7768                 ajax: !!xhr,
7769                 cors: !!xhr && ( "withCredentials" in xhr )
7770         });
7771 })( jQuery.ajaxSettings.xhr() );
7772
7773 // Create transport if the browser can provide an xhr
7774 if ( jQuery.support.ajax ) {
7775
7776         jQuery.ajaxTransport(function( s ) {
7777                 // Cross domain only allowed if supported through XMLHttpRequest
7778                 if ( !s.crossDomain || jQuery.support.cors ) {
7779
7780                         var callback;
7781
7782                         return {
7783                                 send: function( headers, complete ) {
7784
7785                                         // Get a new xhr
7786                                         var xhr = s.xhr(),
7787                                                 handle,
7788                                                 i;
7789
7790                                         // Open the socket
7791                                         // Passing null username, generates a login popup on Opera (#2865)
7792                                         if ( s.username ) {
7793                                                 xhr.open( s.type, s.url, s.async, s.username, s.password );
7794                                         } else {
7795                                                 xhr.open( s.type, s.url, s.async );
7796                                         }
7797
7798                                         // Apply custom fields if provided
7799                                         if ( s.xhrFields ) {
7800                                                 for ( i in s.xhrFields ) {
7801                                                         xhr[ i ] = s.xhrFields[ i ];
7802                                                 }
7803                                         }
7804
7805                                         // Override mime type if needed
7806                                         if ( s.mimeType && xhr.overrideMimeType ) {
7807                                                 xhr.overrideMimeType( s.mimeType );
7808                                         }
7809
7810                                         // X-Requested-With header
7811                                         // For cross-domain requests, seeing as conditions for a preflight are
7812                                         // akin to a jigsaw puzzle, we simply never set it to be sure.
7813                                         // (it can always be set on a per-request basis or even using ajaxSetup)
7814                                         // For same-domain requests, won't change header if already provided.
7815                                         if ( !s.crossDomain && !headers["X-Requested-With"] ) {
7816                                                 headers[ "X-Requested-With" ] = "XMLHttpRequest";
7817                                         }
7818
7819                                         // Need an extra try/catch for cross domain requests in Firefox 3
7820                                         try {
7821                                                 for ( i in headers ) {
7822                                                         xhr.setRequestHeader( i, headers[ i ] );
7823                                                 }
7824                                         } catch( _ ) {}
7825
7826                                         // Do send the request
7827                                         // This may raise an exception which is actually
7828                                         // handled in jQuery.ajax (so no try/catch here)
7829                                         xhr.send( ( s.hasContent && s.data ) || null );
7830
7831                                         // Listener
7832                                         callback = function( _, isAbort ) {
7833
7834                                                 var status,
7835                                                         statusText,
7836                                                         responseHeaders,
7837                                                         responses,
7838                                                         xml;
7839
7840                                                 // Firefox throws exceptions when accessing properties
7841                                                 // of an xhr when a network error occured
7842                                                 // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
7843                                                 try {
7844
7845                                                         // Was never called and is aborted or complete
7846                                                         if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
7847
7848                                                                 // Only called once
7849                                                                 callback = undefined;
7850
7851                                                                 // Do not keep as active anymore
7852                                                                 if ( handle ) {
7853                                                                         xhr.onreadystatechange = jQuery.noop;
7854                                                                         if ( xhrOnUnloadAbort ) {
7855                                                                                 delete xhrCallbacks[ handle ];
7856                                                                         }
7857                                                                 }
7858
7859                                                                 // If it's an abort
7860                                                                 if ( isAbort ) {
7861                                                                         // Abort it manually if needed
7862                                                                         if ( xhr.readyState !== 4 ) {
7863                                                                                 xhr.abort();
7864                                                                         }
7865                                                                 } else {
7866                                                                         status = xhr.status;
7867                                                                         responseHeaders = xhr.getAllResponseHeaders();
7868                                                                         responses = {};
7869                                                                         xml = xhr.responseXML;
7870
7871                                                                         // Construct response list
7872                                                                         if ( xml && xml.documentElement /* #4958 */ ) {
7873                                                                                 responses.xml = xml;
7874                                                                         }
7875                                                                         responses.text = xhr.responseText;
7876
7877                                                                         // Firefox throws an exception when accessing
7878                                                                         // statusText for faulty cross-domain requests
7879                                                                         try {
7880                                                                                 statusText = xhr.statusText;
7881                                                                         } catch( e ) {
7882                                                                                 // We normalize with Webkit giving an empty statusText
7883                                                                                 statusText = "";
7884                                                                         }
7885
7886                                                                         // Filter status for non standard behaviors
7887
7888                                                                         // If the request is local and we have data: assume a success
7889                                                                         // (success with no data won't get notified, that's the best we
7890                                                                         // can do given current implementations)
7891                                                                         if ( !status && s.isLocal && !s.crossDomain ) {
7892                                                                                 status = responses.text ? 200 : 404;
7893                                                                         // IE - #1450: sometimes returns 1223 when it should be 204
7894                                                                         } else if ( status === 1223 ) {
7895                                                                                 status = 204;
7896                                                                         }
7897                                                                 }
7898                                                         }
7899                                                 } catch( firefoxAccessException ) {
7900                                                         if ( !isAbort ) {
7901                                                                 complete( -1, firefoxAccessException );
7902                                                         }
7903                                                 }
7904
7905                                                 // Call complete if needed
7906                                                 if ( responses ) {
7907                                                         complete( status, statusText, responses, responseHeaders );
7908                                                 }
7909                                         };
7910
7911                                         // if we're in sync mode or it's in cache
7912                                         // and has been retrieved directly (IE6 & IE7)
7913                                         // we need to manually fire the callback
7914                                         if ( !s.async || xhr.readyState === 4 ) {
7915                                                 callback();
7916                                         } else {
7917                                                 handle = ++xhrId;
7918                                                 if ( xhrOnUnloadAbort ) {
7919                                                         // Create the active xhrs callbacks list if needed
7920                                                         // and attach the unload handler
7921                                                         if ( !xhrCallbacks ) {
7922                                                                 xhrCallbacks = {};
7923                                                                 jQuery( window ).unload( xhrOnUnloadAbort );
7924                                                         }
7925                                                         // Add to list of active xhrs callbacks
7926                                                         xhrCallbacks[ handle ] = callback;
7927                                                 }
7928                                                 xhr.onreadystatechange = callback;
7929                                         }
7930                                 },
7931
7932                                 abort: function() {
7933                                         if ( callback ) {
7934                                                 callback(0,1);
7935                                         }
7936                                 }
7937                         };
7938                 }
7939         });
7940 }
7941
7942
7943
7944
7945 var elemdisplay = {},
7946         iframe, iframeDoc,
7947         rfxtypes = /^(?:toggle|show|hide)$/,
7948         rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
7949         timerId,
7950         fxAttrs = [
7951                 // height animations
7952                 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
7953                 // width animations
7954                 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
7955                 // opacity animations
7956                 [ "opacity" ]
7957         ],
7958         fxNow,
7959         requestAnimationFrame = window.webkitRequestAnimationFrame ||
7960             window.mozRequestAnimationFrame ||
7961             window.oRequestAnimationFrame;
7962
7963 jQuery.fn.extend({
7964         show: function( speed, easing, callback ) {
7965                 var elem, display;
7966
7967                 if ( speed || speed === 0 ) {
7968                         return this.animate( genFx("show", 3), speed, easing, callback);
7969
7970                 } else {
7971                         for ( var i = 0, j = this.length; i < j; i++ ) {
7972                                 elem = this[i];
7973
7974                                 if ( elem.style ) {
7975                                         display = elem.style.display;
7976
7977                                         // Reset the inline display of this element to learn if it is
7978                                         // being hidden by cascaded rules or not
7979                                         if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
7980                                                 display = elem.style.display = "";
7981                                         }
7982
7983                                         // Set elements which have been overridden with display: none
7984                                         // in a stylesheet to whatever the default browser style is
7985                                         // for such an element
7986                                         if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
7987                                                 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
7988                                         }
7989                                 }
7990                         }
7991
7992                         // Set the display of most of the elements in a second loop
7993                         // to avoid the constant reflow
7994                         for ( i = 0; i < j; i++ ) {
7995                                 elem = this[i];
7996
7997                                 if ( elem.style ) {
7998                                         display = elem.style.display;
7999
8000                                         if ( display === "" || display === "none" ) {
8001                                                 elem.style.display = jQuery._data(elem, "olddisplay") || "";
8002                                         }
8003                                 }
8004                         }
8005
8006                         return this;
8007                 }
8008         },
8009
8010         hide: function( speed, easing, callback ) {
8011                 if ( speed || speed === 0 ) {
8012                         return this.animate( genFx("hide", 3), speed, easing, callback);
8013
8014                 } else {
8015                         for ( var i = 0, j = this.length; i < j; i++ ) {
8016                                 if ( this[i].style ) {
8017                                         var display = jQuery.css( this[i], "display" );
8018
8019                                         if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
8020                                                 jQuery._data( this[i], "olddisplay", display );
8021                                         }
8022                                 }
8023                         }
8024
8025                         // Set the display of the elements in a second loop
8026                         // to avoid the constant reflow
8027                         for ( i = 0; i < j; i++ ) {
8028                                 if ( this[i].style ) {
8029                                         this[i].style.display = "none";
8030                                 }
8031                         }
8032
8033                         return this;
8034                 }
8035         },
8036
8037         // Save the old toggle function
8038         _toggle: jQuery.fn.toggle,
8039
8040         toggle: function( fn, fn2, callback ) {
8041                 var bool = typeof fn === "boolean";
8042
8043                 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8044                         this._toggle.apply( this, arguments );
8045
8046                 } else if ( fn == null || bool ) {
8047                         this.each(function() {
8048                                 var state = bool ? fn : jQuery(this).is(":hidden");
8049                                 jQuery(this)[ state ? "show" : "hide" ]();
8050                         });
8051
8052                 } else {
8053                         this.animate(genFx("toggle", 3), fn, fn2, callback);
8054                 }
8055
8056                 return this;
8057         },
8058
8059         fadeTo: function( speed, to, easing, callback ) {
8060                 return this.filter(":hidden").css("opacity", 0).show().end()
8061                                         .animate({opacity: to}, speed, easing, callback);
8062         },
8063
8064         animate: function( prop, speed, easing, callback ) {
8065                 var optall = jQuery.speed(speed, easing, callback);
8066
8067                 if ( jQuery.isEmptyObject( prop ) ) {
8068                         return this.each( optall.complete, [ false ] );
8069                 }
8070
8071                 // Do not change referenced properties as per-property easing will be lost
8072                 prop = jQuery.extend( {}, prop );
8073
8074                 return this[ optall.queue === false ? "each" : "queue" ](function() {
8075                         // XXX 'this' does not always have a nodeName when running the
8076                         // test suite
8077
8078                         if ( optall.queue === false ) {
8079                                 jQuery._mark( this );
8080                         }
8081
8082                         var opt = jQuery.extend( {}, optall ),
8083                                 isElement = this.nodeType === 1,
8084                                 hidden = isElement && jQuery(this).is(":hidden"),
8085                                 name, val, p,
8086                                 display, e,
8087                                 parts, start, end, unit;
8088
8089                         // will store per property easing and be used to determine when an animation is complete
8090                         opt.animatedProperties = {};
8091
8092                         for ( p in prop ) {
8093
8094                                 // property name normalization
8095                                 name = jQuery.camelCase( p );
8096                                 if ( p !== name ) {
8097                                         prop[ name ] = prop[ p ];
8098                                         delete prop[ p ];
8099                                 }
8100
8101                                 val = prop[ name ];
8102
8103                                 // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8104                                 if ( jQuery.isArray( val ) ) {
8105                                         opt.animatedProperties[ name ] = val[ 1 ];
8106                                         val = prop[ name ] = val[ 0 ];
8107                                 } else {
8108                                         opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
8109                                 }
8110
8111                                 if ( val === "hide" && hidden || val === "show" && !hidden ) {
8112                                         return opt.complete.call( this );
8113                                 }
8114
8115                                 if ( isElement && ( name === "height" || name === "width" ) ) {
8116                                         // Make sure that nothing sneaks out
8117                                         // Record all 3 overflow attributes because IE does not
8118                                         // change the overflow attribute when overflowX and
8119                                         // overflowY are set to the same value
8120                                         opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8121
8122                                         // Set display property to inline-block for height/width
8123                                         // animations on inline elements that are having width/height
8124                                         // animated
8125                                         if ( jQuery.css( this, "display" ) === "inline" &&
8126                                                         jQuery.css( this, "float" ) === "none" ) {
8127                                                 if ( !jQuery.support.inlineBlockNeedsLayout ) {
8128                                                         this.style.display = "inline-block";
8129
8130                                                 } else {
8131                                                         display = defaultDisplay( this.nodeName );
8132
8133                                                         // inline-level elements accept inline-block;
8134                                                         // block-level elements need to be inline with layout
8135                                                         if ( display === "inline" ) {
8136                                                                 this.style.display = "inline-block";
8137
8138                                                         } else {
8139                                                                 this.style.display = "inline";
8140                                                                 this.style.zoom = 1;
8141                                                         }
8142                                                 }
8143                                         }
8144                                 }
8145                         }
8146
8147                         if ( opt.overflow != null ) {
8148                                 this.style.overflow = "hidden";
8149                         }
8150
8151                         for ( p in prop ) {
8152                                 e = new jQuery.fx( this, opt, p );
8153                                 val = prop[ p ];
8154
8155                                 if ( rfxtypes.test(val) ) {
8156                                         e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
8157
8158                                 } else {
8159                                         parts = rfxnum.exec( val );
8160                                         start = e.cur();
8161
8162                                         if ( parts ) {
8163                                                 end = parseFloat( parts[2] );
8164                                                 unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
8165
8166                                                 // We need to compute starting value
8167                                                 if ( unit !== "px" ) {
8168                                                         jQuery.style( this, p, (end || 1) + unit);
8169                                                         start = ((end || 1) / e.cur()) * start;
8170                                                         jQuery.style( this, p, start + unit);
8171                                                 }
8172
8173                                                 // If a +=/-= token was provided, we're doing a relative animation
8174                                                 if ( parts[1] ) {
8175                                                         end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8176                                                 }
8177
8178                                                 e.custom( start, end, unit );
8179
8180                                         } else {
8181                                                 e.custom( start, val, "" );
8182                                         }
8183                                 }
8184                         }
8185
8186                         // For JS strict compliance
8187                         return true;
8188                 });
8189         },
8190
8191         stop: function( clearQueue, gotoEnd ) {
8192                 if ( clearQueue ) {
8193                         this.queue([]);
8194                 }
8195
8196                 this.each(function() {
8197                         var timers = jQuery.timers,
8198                                 i = timers.length;
8199                         // clear marker counters if we know they won't be
8200                         if ( !gotoEnd ) {
8201                                 jQuery._unmark( true, this );
8202                         }
8203                         while ( i-- ) {
8204                                 if ( timers[i].elem === this ) {
8205                                         if (gotoEnd) {
8206                                                 // force the next step to be the last
8207                                                 timers[i](true);
8208                                         }
8209
8210                                         timers.splice(i, 1);
8211                                 }
8212                         }
8213                 });
8214
8215                 // start the next in the queue if the last step wasn't forced
8216                 if ( !gotoEnd ) {
8217                         this.dequeue();
8218                 }
8219
8220                 return this;
8221         }
8222
8223 });
8224
8225 // Animations created synchronously will run synchronously
8226 function createFxNow() {
8227         setTimeout( clearFxNow, 0 );
8228         return ( fxNow = jQuery.now() );
8229 }
8230
8231 function clearFxNow() {
8232         fxNow = undefined;
8233 }
8234
8235 // Generate parameters to create a standard animation
8236 function genFx( type, num ) {
8237         var obj = {};
8238
8239         jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
8240                 obj[ this ] = type;
8241         });
8242
8243         return obj;
8244 }
8245
8246 // Generate shortcuts for custom animations
8247 jQuery.each({
8248         slideDown: genFx("show", 1),
8249         slideUp: genFx("hide", 1),
8250         slideToggle: genFx("toggle", 1),
8251         fadeIn: { opacity: "show" },
8252         fadeOut: { opacity: "hide" },
8253         fadeToggle: { opacity: "toggle" }
8254 }, function( name, props ) {
8255         jQuery.fn[ name ] = function( speed, easing, callback ) {
8256                 return this.animate( props, speed, easing, callback );
8257         };
8258 });
8259
8260 jQuery.extend({
8261         speed: function( speed, easing, fn ) {
8262                 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
8263                         complete: fn || !fn && easing ||
8264                                 jQuery.isFunction( speed ) && speed,
8265                         duration: speed,
8266                         easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
8267                 };
8268
8269                 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8270                         opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
8271
8272                 // Queueing
8273                 opt.old = opt.complete;
8274                 opt.complete = function( noUnmark ) {
8275                         if ( opt.queue !== false ) {
8276                                 jQuery.dequeue( this );
8277                         } else if ( noUnmark !== false ) {
8278                                 jQuery._unmark( this );
8279                         }
8280
8281                         if ( jQuery.isFunction( opt.old ) ) {
8282                                 opt.old.call( this );
8283                         }
8284                 };
8285
8286                 return opt;
8287         },
8288
8289         easing: {
8290                 linear: function( p, n, firstNum, diff ) {
8291                         return firstNum + diff * p;
8292                 },
8293                 swing: function( p, n, firstNum, diff ) {
8294                         return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
8295                 }
8296         },
8297
8298         timers: [],
8299
8300         fx: function( elem, options, prop ) {
8301                 this.options = options;
8302                 this.elem = elem;
8303                 this.prop = prop;
8304
8305                 options.orig = options.orig || {};
8306         }
8307
8308 });
8309
8310 jQuery.fx.prototype = {
8311         // Simple function for setting a style value
8312         update: function() {
8313                 if ( this.options.step ) {
8314                         this.options.step.call( this.elem, this.now, this );
8315                 }
8316
8317                 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
8318         },
8319
8320         // Get the current size
8321         cur: function() {
8322                 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
8323                         return this.elem[ this.prop ];
8324                 }
8325
8326                 var parsed,
8327                         r = jQuery.css( this.elem, this.prop );
8328                 // Empty strings, null, undefined and "auto" are converted to 0,
8329                 // complex values such as "rotate(1rad)" are returned as is,
8330                 // simple values such as "10px" are parsed to Float.
8331                 return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
8332         },
8333
8334         // Start an animation from one number to another
8335         custom: function( from, to, unit ) {
8336                 var self = this,
8337                         fx = jQuery.fx,
8338                         raf;
8339
8340                 this.startTime = fxNow || createFxNow();
8341                 this.start = from;
8342                 this.end = to;
8343                 this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8344                 this.now = this.start;
8345                 this.pos = this.state = 0;
8346
8347                 function t( gotoEnd ) {
8348                         return self.step(gotoEnd);
8349                 }
8350
8351                 t.elem = this.elem;
8352
8353                 if ( t() && jQuery.timers.push(t) && !timerId ) {
8354                         // Use requestAnimationFrame instead of setInterval if available
8355                         if ( requestAnimationFrame ) {
8356                                 timerId = 1;
8357                                 raf = function() {
8358                                         // When timerId gets set to null at any point, this stops
8359                                         if ( timerId ) {
8360                                                 requestAnimationFrame( raf );
8361                                                 fx.tick();
8362                                         }
8363                                 };
8364                                 requestAnimationFrame( raf );
8365                         } else {
8366                                 timerId = setInterval( fx.tick, fx.interval );
8367                         }
8368                 }
8369         },
8370
8371         // Simple 'show' function
8372         show: function() {
8373                 // Remember where we started, so that we can go back to it later
8374                 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8375                 this.options.show = true;
8376
8377                 // Begin the animation
8378                 // Make sure that we start at a small width/height to avoid any
8379                 // flash of content
8380                 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
8381
8382                 // Start by showing the element
8383                 jQuery( this.elem ).show();
8384         },
8385
8386         // Simple 'hide' function
8387         hide: function() {
8388                 // Remember where we started, so that we can go back to it later
8389                 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8390                 this.options.hide = true;
8391
8392                 // Begin the animation
8393                 this.custom(this.cur(), 0);
8394         },
8395
8396         // Each step of an animation
8397         step: function( gotoEnd ) {
8398                 var t = fxNow || createFxNow(),
8399                         done = true,
8400                         elem = this.elem,
8401                         options = this.options,
8402                         i, n;
8403
8404                 if ( gotoEnd || t >= options.duration + this.startTime ) {
8405                         this.now = this.end;
8406                         this.pos = this.state = 1;
8407                         this.update();
8408
8409                         options.animatedProperties[ this.prop ] = true;
8410
8411                         for ( i in options.animatedProperties ) {
8412                                 if ( options.animatedProperties[i] !== true ) {
8413                                         done = false;
8414                                 }
8415                         }
8416
8417                         if ( done ) {
8418                                 // Reset the overflow
8419                                 if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8420
8421                                         jQuery.each( [ "", "X", "Y" ], function (index, value) {
8422                                                 elem.style[ "overflow" + value ] = options.overflow[index];
8423                                         });
8424                                 }
8425
8426                                 // Hide the element if the "hide" operation was done
8427                                 if ( options.hide ) {
8428                                         jQuery(elem).hide();
8429                                 }
8430
8431                                 // Reset the properties, if the item has been hidden or shown
8432                                 if ( options.hide || options.show ) {
8433                                         for ( var p in options.animatedProperties ) {
8434                                                 jQuery.style( elem, p, options.orig[p] );
8435                                         }
8436                                 }
8437
8438                                 // Execute the complete function
8439                                 options.complete.call( elem );
8440                         }
8441
8442                         return false;
8443
8444                 } else {
8445                         // classical easing cannot be used with an Infinity duration
8446                         if ( options.duration == Infinity ) {
8447                                 this.now = t;
8448                         } else {
8449                                 n = t - this.startTime;
8450                                 this.state = n / options.duration;
8451
8452                                 // Perform the easing function, defaults to swing
8453                                 this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
8454                                 this.now = this.start + ((this.end - this.start) * this.pos);
8455                         }
8456                         // Perform the next step of the animation
8457                         this.update();
8458                 }
8459
8460                 return true;
8461         }
8462 };
8463
8464 jQuery.extend( jQuery.fx, {
8465         tick: function() {
8466                 for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
8467                         if ( !timers[i]() ) {
8468                                 timers.splice(i--, 1);
8469                         }
8470                 }
8471
8472                 if ( !timers.length ) {
8473                         jQuery.fx.stop();
8474                 }
8475         },
8476
8477         interval: 13,
8478
8479         stop: function() {
8480                 clearInterval( timerId );
8481                 timerId = null;
8482         },
8483
8484         speeds: {
8485                 slow: 600,
8486                 fast: 200,
8487                 // Default speed
8488                 _default: 400
8489         },
8490
8491         step: {
8492                 opacity: function( fx ) {
8493                         jQuery.style( fx.elem, "opacity", fx.now );
8494                 },
8495
8496                 _default: function( fx ) {
8497                         if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8498                                 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
8499                         } else {
8500                                 fx.elem[ fx.prop ] = fx.now;
8501                         }
8502                 }
8503         }
8504 });
8505
8506 if ( jQuery.expr && jQuery.expr.filters ) {
8507         jQuery.expr.filters.animated = function( elem ) {
8508                 return jQuery.grep(jQuery.timers, function( fn ) {
8509                         return elem === fn.elem;
8510                 }).length;
8511         };
8512 }
8513
8514 // Try to restore the default display value of an element
8515 function defaultDisplay( nodeName ) {
8516
8517         if ( !elemdisplay[ nodeName ] ) {
8518
8519                 var elem = jQuery( "<" + nodeName + ">" ).appendTo( "body" ),
8520                         display = elem.css( "display" );
8521
8522                 elem.remove();
8523
8524                 // If the simple way fails,
8525                 // get element's real default display by attaching it to a temp iframe
8526                 if ( display === "none" || display === "" ) {
8527                         // No iframe to use yet, so create it
8528                         if ( !iframe ) {
8529                                 iframe = document.createElement( "iframe" );
8530                                 iframe.frameBorder = iframe.width = iframe.height = 0;
8531                         }
8532
8533                         document.body.appendChild( iframe );
8534
8535                         // Create a cacheable copy of the iframe document on first call.
8536                         // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake html
8537                         // document to it, Webkit & Firefox won't allow reusing the iframe document
8538                         if ( !iframeDoc || !iframe.createElement ) {
8539                                 iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
8540                                 iframeDoc.write( "<!doctype><html><body></body></html>" );
8541                         }
8542
8543                         elem = iframeDoc.createElement( nodeName );
8544
8545                         iframeDoc.body.appendChild( elem );
8546
8547                         display = jQuery.css( elem, "display" );
8548
8549                         document.body.removeChild( iframe );
8550                 }
8551
8552                 // Store the correct default display
8553                 elemdisplay[ nodeName ] = display;
8554         }
8555
8556         return elemdisplay[ nodeName ];
8557 }
8558
8559
8560
8561
8562 var rtable = /^t(?:able|d|h)$/i,
8563         rroot = /^(?:body|html)$/i;
8564
8565 if ( "getBoundingClientRect" in document.documentElement ) {
8566         jQuery.fn.offset = function( options ) {
8567                 var elem = this[0], box;
8568
8569                 if ( options ) {
8570                         return this.each(function( i ) {
8571                                 jQuery.offset.setOffset( this, options, i );
8572                         });
8573                 }
8574
8575                 if ( !elem || !elem.ownerDocument ) {
8576                         return null;
8577                 }
8578
8579                 if ( elem === elem.ownerDocument.body ) {
8580                         return jQuery.offset.bodyOffset( elem );
8581                 }
8582
8583                 try {
8584                         box = elem.getBoundingClientRect();
8585                 } catch(e) {}
8586
8587                 var doc = elem.ownerDocument,
8588                         docElem = doc.documentElement;
8589
8590                 // Make sure we're not dealing with a disconnected DOM node
8591                 if ( !box || !jQuery.contains( docElem, elem ) ) {
8592                         return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8593                 }
8594
8595                 var body = doc.body,
8596                         win = getWindow(doc),
8597                         clientTop  = docElem.clientTop  || body.clientTop  || 0,
8598                         clientLeft = docElem.clientLeft || body.clientLeft || 0,
8599                         scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
8600                         scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
8601                         top  = box.top  + scrollTop  - clientTop,
8602                         left = box.left + scrollLeft - clientLeft;
8603
8604                 return { top: top, left: left };
8605         };
8606
8607 } else {
8608         jQuery.fn.offset = function( options ) {
8609                 var elem = this[0];
8610
8611                 if ( options ) {
8612                         return this.each(function( i ) {
8613                                 jQuery.offset.setOffset( this, options, i );
8614                         });
8615                 }
8616
8617                 if ( !elem || !elem.ownerDocument ) {
8618                         return null;
8619                 }
8620
8621                 if ( elem === elem.ownerDocument.body ) {
8622                         return jQuery.offset.bodyOffset( elem );
8623                 }
8624
8625                 jQuery.offset.initialize();
8626
8627                 var computedStyle,
8628                         offsetParent = elem.offsetParent,
8629                         prevOffsetParent = elem,
8630                         doc = elem.ownerDocument,
8631                         docElem = doc.documentElement,
8632                         body = doc.body,
8633                         defaultView = doc.defaultView,
8634                         prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8635                         top = elem.offsetTop,
8636                         left = elem.offsetLeft;
8637
8638                 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8639                         if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8640                                 break;
8641                         }
8642
8643                         computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8644                         top  -= elem.scrollTop;
8645                         left -= elem.scrollLeft;
8646
8647                         if ( elem === offsetParent ) {
8648                                 top  += elem.offsetTop;
8649                                 left += elem.offsetLeft;
8650
8651                                 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8652                                         top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8653                                         left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8654                                 }
8655
8656                                 prevOffsetParent = offsetParent;
8657                                 offsetParent = elem.offsetParent;
8658                         }
8659
8660                         if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8661                                 top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8662                                 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8663                         }
8664
8665                         prevComputedStyle = computedStyle;
8666                 }
8667
8668                 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
8669                         top  += body.offsetTop;
8670                         left += body.offsetLeft;
8671                 }
8672
8673                 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8674                         top  += Math.max( docElem.scrollTop, body.scrollTop );
8675                         left += Math.max( docElem.scrollLeft, body.scrollLeft );
8676                 }
8677
8678                 return { top: top, left: left };
8679         };
8680 }
8681
8682 jQuery.offset = {
8683         initialize: function() {
8684                 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
8685                         html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
8686
8687                 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
8688
8689                 container.innerHTML = html;
8690                 body.insertBefore( container, body.firstChild );
8691                 innerDiv = container.firstChild;
8692                 checkDiv = innerDiv.firstChild;
8693                 td = innerDiv.nextSibling.firstChild.firstChild;
8694
8695                 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
8696                 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
8697
8698                 checkDiv.style.position = "fixed";
8699                 checkDiv.style.top = "20px";
8700
8701                 // safari subtracts parent border width here which is 5px
8702                 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
8703                 checkDiv.style.position = checkDiv.style.top = "";
8704
8705                 innerDiv.style.overflow = "hidden";
8706                 innerDiv.style.position = "relative";
8707
8708                 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
8709
8710                 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
8711
8712                 body.removeChild( container );
8713                 jQuery.offset.initialize = jQuery.noop;
8714         },
8715
8716         bodyOffset: function( body ) {
8717                 var top = body.offsetTop,
8718                         left = body.offsetLeft;
8719
8720                 jQuery.offset.initialize();
8721
8722                 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
8723                         top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
8724                         left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
8725                 }
8726
8727                 return { top: top, left: left };
8728         },
8729
8730         setOffset: function( elem, options, i ) {
8731                 var position = jQuery.css( elem, "position" );
8732
8733                 // set position first, in-case top/left are set even on static elem
8734                 if ( position === "static" ) {
8735                         elem.style.position = "relative";
8736                 }
8737
8738                 var curElem = jQuery( elem ),
8739                         curOffset = curElem.offset(),
8740                         curCSSTop = jQuery.css( elem, "top" ),
8741                         curCSSLeft = jQuery.css( elem, "left" ),
8742                         calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
8743                         props = {}, curPosition = {}, curTop, curLeft;
8744
8745                 // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
8746                 if ( calculatePosition ) {
8747                         curPosition = curElem.position();
8748                         curTop = curPosition.top;
8749                         curLeft = curPosition.left;
8750                 } else {
8751                         curTop = parseFloat( curCSSTop ) || 0;
8752                         curLeft = parseFloat( curCSSLeft ) || 0;
8753                 }
8754
8755                 if ( jQuery.isFunction( options ) ) {
8756                         options = options.call( elem, i, curOffset );
8757                 }
8758
8759                 if (options.top != null) {
8760                         props.top = (options.top - curOffset.top) + curTop;
8761                 }
8762                 if (options.left != null) {
8763                         props.left = (options.left - curOffset.left) + curLeft;
8764                 }
8765
8766                 if ( "using" in options ) {
8767                         options.using.call( elem, props );
8768                 } else {
8769                         curElem.css( props );
8770                 }
8771         }
8772 };
8773
8774
8775 jQuery.fn.extend({
8776         position: function() {
8777                 if ( !this[0] ) {
8778                         return null;
8779                 }
8780
8781                 var elem = this[0],
8782
8783                 // Get *real* offsetParent
8784                 offsetParent = this.offsetParent(),
8785
8786                 // Get correct offsets
8787                 offset       = this.offset(),
8788                 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
8789
8790                 // Subtract element margins
8791                 // note: when an element has margin: auto the offsetLeft and marginLeft
8792                 // are the same in Safari causing offset.left to incorrectly be 0
8793                 offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
8794                 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
8795
8796                 // Add offsetParent borders
8797                 parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
8798                 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
8799
8800                 // Subtract the two offsets
8801                 return {
8802                         top:  offset.top  - parentOffset.top,
8803                         left: offset.left - parentOffset.left
8804                 };
8805         },
8806
8807         offsetParent: function() {
8808                 return this.map(function() {
8809                         var offsetParent = this.offsetParent || document.body;
8810                         while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
8811                                 offsetParent = offsetParent.offsetParent;
8812                         }
8813                         return offsetParent;
8814                 });
8815         }
8816 });
8817
8818
8819 // Create scrollLeft and scrollTop methods
8820 jQuery.each( ["Left", "Top"], function( i, name ) {
8821         var method = "scroll" + name;
8822
8823         jQuery.fn[ method ] = function( val ) {
8824                 var elem, win;
8825
8826                 if ( val === undefined ) {
8827                         elem = this[ 0 ];
8828
8829                         if ( !elem ) {
8830                                 return null;
8831                         }
8832
8833                         win = getWindow( elem );
8834
8835                         // Return the scroll offset
8836                         return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
8837                                 jQuery.support.boxModel && win.document.documentElement[ method ] ||
8838                                         win.document.body[ method ] :
8839                                 elem[ method ];
8840                 }
8841
8842                 // Set the scroll offset
8843                 return this.each(function() {
8844                         win = getWindow( this );
8845
8846                         if ( win ) {
8847                                 win.scrollTo(
8848                                         !i ? val : jQuery( win ).scrollLeft(),
8849                                          i ? val : jQuery( win ).scrollTop()
8850                                 );
8851
8852                         } else {
8853                                 this[ method ] = val;
8854                         }
8855                 });
8856         };
8857 });
8858
8859 function getWindow( elem ) {
8860         return jQuery.isWindow( elem ) ?
8861                 elem :
8862                 elem.nodeType === 9 ?
8863                         elem.defaultView || elem.parentWindow :
8864                         false;
8865 }
8866
8867
8868
8869
8870 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
8871 jQuery.each([ "Height", "Width" ], function( i, name ) {
8872
8873         var type = name.toLowerCase();
8874
8875         // innerHeight and innerWidth
8876         jQuery.fn["inner" + name] = function() {
8877                 return this[0] ?
8878                         parseFloat( jQuery.css( this[0], type, "padding" ) ) :
8879                         null;
8880         };
8881
8882         // outerHeight and outerWidth
8883         jQuery.fn["outer" + name] = function( margin ) {
8884                 return this[0] ?
8885                         parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
8886                         null;
8887         };
8888
8889         jQuery.fn[ type ] = function( size ) {
8890                 // Get window width or height
8891                 var elem = this[0];
8892                 if ( !elem ) {
8893                         return size == null ? null : this;
8894                 }
8895
8896                 if ( jQuery.isFunction( size ) ) {
8897                         return this.each(function( i ) {
8898                                 var self = jQuery( this );
8899                                 self[ type ]( size.call( this, i, self[ type ]() ) );
8900                         });
8901                 }
8902
8903                 if ( jQuery.isWindow( elem ) ) {
8904                         // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
8905                         // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
8906                         var docElemProp = elem.document.documentElement[ "client" + name ];
8907                         return elem.document.compatMode === "CSS1Compat" && docElemProp ||
8908                                 elem.document.body[ "client" + name ] || docElemProp;
8909
8910                 // Get document width or height
8911                 } else if ( elem.nodeType === 9 ) {
8912                         // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
8913                         return Math.max(
8914                                 elem.documentElement["client" + name],
8915                                 elem.body["scroll" + name], elem.documentElement["scroll" + name],
8916                                 elem.body["offset" + name], elem.documentElement["offset" + name]
8917                         );
8918
8919                 // Get or set width or height on the element
8920                 } else if ( size === undefined ) {
8921                         var orig = jQuery.css( elem, type ),
8922                                 ret = parseFloat( orig );
8923
8924                         return jQuery.isNaN( ret ) ? orig : ret;
8925
8926                 // Set the width or height on the element (default to pixels if value is unitless)
8927                 } else {
8928                         return this.css( type, typeof size === "string" ? size : size + "px" );
8929                 }
8930         };
8931
8932 });
8933
8934
8935 window.jQuery = window.$ = jQuery;
8936 })(window);