source/tools/profiler2/jquery-1.6.4.js

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