js/jquery/jquery-1.4.4.js

   1 /*!
   2  * jQuery JavaScript Library v1.4.4
   3  * http://jquery.com/
   4  *
   5  * Copyright 2010, 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 2010, The Dojo Foundation
  12  * Released under the MIT, BSD, and GPL Licenses.
  13  *
  14  * Date: Thu Nov 11 19:04:53 2010 -0500
  15  */
  16 (function( window, undefined ) {
  17
  18 // Use the correct document accordingly with window argument (sandbox)
  19 var document = window.document;
  20 var jQuery = (function() {
  21
  22 // Define a local copy of jQuery
  23 var jQuery = function( selector, context ) {
  24                 // The jQuery object is actually just the init constructor 'enhanced'
  25                 return new jQuery.fn.init( selector, context );
  26         },
  27
  28         // Map over jQuery in case of overwrite
  29         _jQuery = window.jQuery,
  30
  31         // Map over the $ in case of overwrite
  32         _$ = window.$,
  33
  34         // A central reference to the root jQuery(document)
  35         rootjQuery,
  36
  37         // A simple way to check for HTML strings or ID strings
  38         // (both of which we optimize for)
  39         quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
  40
  41         // Is it a simple selector
  42         isSimple = /^.[^:#\[\.,]*$/,
  43
  44         // Check if a string has a non-whitespace character in it
  45         rnotwhite = /\S/,
  46         rwhite = /\s/,
  47
  48         // Used for trimming whitespace
  49         trimLeft = /^\s+/,
  50         trimRight = /\s+$/,
  51
  52         // Check for non-word characters
  53         rnonword = /\W/,
  54
  55         // Check for digits
  56         rdigit = /\d/,
  57
  58         // Match a standalone tag
  59         rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
  60
  61         // JSON RegExp
  62         rvalidchars = /^[\],:{}\s]*$/,
  63         rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  64         rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  65         rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
  66
  67         // Useragent RegExp
  68         rwebkit = /(webkit)[ \/]([\w.]+)/,
  69         ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
  70         rmsie = /(msie) ([\w.]+)/,
  71         rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
  72
  73         // Keep a UserAgent string for use with jQuery.browser
  74         userAgent = navigator.userAgent,
  75
  76         // For matching the engine and version of the browser
  77         browserMatch,
  78
  79         // Has the ready events already been bound?
  80         readyBound = false,
  81
  82         // The functions to execute on DOM ready
  83         readyList = [],
  84
  85         // The ready event handler
  86         DOMContentLoaded,
  87
  88         // Save a reference to some core methods
  89         toString = Object.prototype.toString,
  90         hasOwn = Object.prototype.hasOwnProperty,
  91         push = Array.prototype.push,
  92         slice = Array.prototype.slice,
  93         trim = String.prototype.trim,
  94         indexOf = Array.prototype.indexOf,
  95
  96         // [[Class]] -> type pairs
  97         class2type = {};
  98
  99 jQuery.fn = jQuery.prototype = {
 100         init: function( selector, context ) {
 101                 var match, elem, ret, doc;
 102
 103                 // Handle $(""), $(null), or $(undefined)
 104                 if ( !selector ) {
 105                         return this;
 106                 }
 107
 108                 // Handle $(DOMElement)
 109                 if ( selector.nodeType ) {
 110                         this.context = this[0] = selector;
 111                         this.length = 1;
 112                         return this;
 113                 }
 114
 115                 // The body element only exists once, optimize finding it
 116                 if ( selector === "body" && !context && document.body ) {
 117                         this.context = document;
 118                         this[0] = document.body;
 119                         this.selector = "body";
 120                         this.length = 1;
 121                         return this;
 122                 }
 123
 124                 // Handle HTML strings
 125                 if ( typeof selector === "string" ) {
 126                         // Are we dealing with HTML string or an ID?
 127                         match = quickExpr.exec( selector );
 128
 129                         // Verify a match, and that no context was specified for #id
 130                         if ( match && (match[1] || !context) ) {
 131
 132                                 // HANDLE: $(html) -> $(array)
 133                                 if ( match[1] ) {
 134                                         doc = (context ? context.ownerDocument || context : document);
 135
 136                                         // If a single string is passed in and it's a single tag
 137                                         // just do a createElement and skip the rest
 138                                         ret = rsingleTag.exec( selector );
 139
 140                                         if ( ret ) {
 141                                                 if ( jQuery.isPlainObject( context ) ) {
 142                                                         selector = [ document.createElement( ret[1] ) ];
 143                                                         jQuery.fn.attr.call( selector, context, true );
 144
 145                                                 } else {
 146                                                         selector = [ doc.createElement( ret[1] ) ];
 147                                                 }
 148
 149                                         } else {
 150                                                 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
 151                                                 selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
 152                                         }
 153
 154                                         return jQuery.merge( this, selector );
 155
 156                                 // HANDLE: $("#id")
 157                                 } else {
 158                                         elem = document.getElementById( match[2] );
 159
 160                                         // Check parentNode to catch when Blackberry 4.6 returns
 161                                         // nodes that are no longer in the document #6963
 162                                         if ( elem && elem.parentNode ) {
 163                                                 // Handle the case where IE and Opera return items
 164                                                 // by name instead of ID
 165                                                 if ( elem.id !== match[2] ) {
 166                                                         return rootjQuery.find( selector );
 167                                                 }
 168
 169                                                 // Otherwise, we inject the element directly into the jQuery object
 170                                                 this.length = 1;
 171                                                 this[0] = elem;
 172                                         }
 173
 174                                         this.context = document;
 175                                         this.selector = selector;
 176                                         return this;
 177                                 }
 178
 179                         // HANDLE: $("TAG")
 180                         } else if ( !context && !rnonword.test( selector ) ) {
 181                                 this.selector = selector;
 182                                 this.context = document;
 183                                 selector = document.getElementsByTagName( selector );
 184                                 return jQuery.merge( this, selector );
 185
 186                         // HANDLE: $(expr, $(...))
 187                         } else if ( !context || context.jquery ) {
 188                                 return (context || rootjQuery).find( selector );
 189
 190                         // HANDLE: $(expr, context)
 191                         // (which is just equivalent to: $(context).find(expr)
 192                         } else {
 193                                 return jQuery( context ).find( selector );
 194                         }
 195
 196                 // HANDLE: $(function)
 197                 // Shortcut for document ready
 198                 } else if ( jQuery.isFunction( selector ) ) {
 199                         return rootjQuery.ready( selector );
 200                 }
 201
 202                 if (selector.selector !== undefined) {
 203                         this.selector = selector.selector;
 204                         this.context = selector.context;
 205                 }
 206
 207                 return jQuery.makeArray( selector, this );
 208         },
 209
 210         // Start with an empty selector
 211         selector: "",
 212
 213         // The current version of jQuery being used
 214         jquery: "1.4.4",
 215
 216         // The default length of a jQuery object is 0
 217         length: 0,
 218
 219         // The number of elements contained in the matched element set
 220         size: function() {
 221                 return this.length;
 222         },
 223
 224         toArray: function() {
 225                 return slice.call( this, 0 );
 226         },
 227
 228         // Get the Nth element in the matched element set OR
 229         // Get the whole matched element set as a clean array
 230         get: function( num ) {
 231                 return num == null ?
 232
 233                         // Return a 'clean' array
 234                         this.toArray() :
 235
 236                         // Return just the object
 237                         ( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
 238         },
 239
 240         // Take an array of elements and push it onto the stack
 241         // (returning the new matched element set)
 242         pushStack: function( elems, name, selector ) {
 243                 // Build a new jQuery matched element set
 244                 var ret = jQuery();
 245
 246                 if ( jQuery.isArray( elems ) ) {
 247                         push.apply( ret, elems );
 248
 249                 } else {
 250                         jQuery.merge( ret, elems );
 251                 }
 252
 253                 // Add the old object onto the stack (as a reference)
 254                 ret.prevObject = this;
 255
 256                 ret.context = this.context;
 257
 258                 if ( name === "find" ) {
 259                         ret.selector = this.selector + (this.selector ? " " : "") + selector;
 260                 } else if ( name ) {
 261                         ret.selector = this.selector + "." + name + "(" + selector + ")";
 262                 }
 263
 264                 // Return the newly-formed element set
 265                 return ret;
 266         },
 267
 268         // Execute a callback for every element in the matched set.
 269         // (You can seed the arguments with an array of args, but this is
 270         // only used internally.)
 271         each: function( callback, args ) {
 272                 return jQuery.each( this, callback, args );
 273         },
 274
 275         ready: function( fn ) {
 276                 // Attach the listeners
 277                 jQuery.bindReady();
 278
 279                 // If the DOM is already ready
 280                 if ( jQuery.isReady ) {
 281                         // Execute the function immediately
 282                         fn.call( document, jQuery );
 283
 284                 // Otherwise, remember the function for later
 285                 } else if ( readyList ) {
 286                         // Add the function to the wait list
 287                         readyList.push( fn );
 288                 }
 289
 290                 return this;
 291         },
 292
 293         eq: function( i ) {
 294                 return i === -1 ?
 295                         this.slice( i ) :
 296                         this.slice( i, +i + 1 );
 297         },
 298
 299         first: function() {
 300                 return this.eq( 0 );
 301         },
 302
 303         last: function() {
 304                 return this.eq( -1 );
 305         },
 306
 307         slice: function() {
 308                 return this.pushStack( slice.apply( this, arguments ),
 309                         "slice", slice.call(arguments).join(",") );
 310         },
 311
 312         map: function( callback ) {
 313                 return this.pushStack( jQuery.map(this, function( elem, i ) {
 314                         return callback.call( elem, i, elem );
 315                 }));
 316         },
 317
 318         end: function() {
 319                 return this.prevObject || jQuery(null);
 320         },
 321
 322         // For internal use only.
 323         // Behaves like an Array's method, not like a jQuery method.
 324         push: push,
 325         sort: [].sort,
 326         splice: [].splice
 327 };
 328
 329 // Give the init function the jQuery prototype for later instantiation
 330 jQuery.fn.init.prototype = jQuery.fn;
 331
 332 jQuery.extend = jQuery.fn.extend = function() {
 333          var options, name, src, copy, copyIsArray, clone,
 334                 target = arguments[0] || {},
 335                 i = 1,
 336                 length = arguments.length,
 337                 deep = false;
 338
 339         // Handle a deep copy situation
 340         if ( typeof target === "boolean" ) {
 341                 deep = target;
 342                 target = arguments[1] || {};
 343                 // skip the boolean and the target
 344                 i = 2;
 345         }
 346
 347         // Handle case when target is a string or something (possible in deep copy)
 348         if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
 349                 target = {};
 350         }
 351
 352         // extend jQuery itself if only one argument is passed
 353         if ( length === i ) {
 354                 target = this;
 355                 --i;
 356         }
 357
 358         for ( ; i < length; i++ ) {
 359                 // Only deal with non-null/undefined values
 360                 if ( (options = arguments[ i ]) != null ) {
 361                         // Extend the base object
 362                         for ( name in options ) {
 363                                 src = target[ name ];
 364                                 copy = options[ name ];
 365
 366                                 // Prevent never-ending loop
 367                                 if ( target === copy ) {
 368                                         continue;
 369                                 }
 370
 371                                 // Recurse if we're merging plain objects or arrays
 372                                 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
 373                                         if ( copyIsArray ) {
 374                                                 copyIsArray = false;
 375                                                 clone = src && jQuery.isArray(src) ? src : [];
 376
 377                                         } else {
 378                                                 clone = src && jQuery.isPlainObject(src) ? src : {};
 379                                         }
 380
 381                                         // Never move original objects, clone them
 382                                         target[ name ] = jQuery.extend( deep, clone, copy );
 383
 384                                 // Don't bring in undefined values
 385                                 } else if ( copy !== undefined ) {
 386                                         target[ name ] = copy;
 387                                 }
 388                         }
 389                 }
 390         }
 391
 392         // Return the modified object
 393         return target;
 394 };
 395
 396 jQuery.extend({
 397         noConflict: function( deep ) {
 398                 window.$ = _$;
 399
 400                 if ( deep ) {
 401                         window.jQuery = _jQuery;
 402                 }
 403
 404                 return jQuery;
 405         },
 406
 407         // Is the DOM ready to be used? Set to true once it occurs.
 408         isReady: false,
 409
 410         // A counter to track how many items to wait for before
 411         // the ready event fires. See #6781
 412         readyWait: 1,
 413
 414         // Handle when the DOM is ready
 415         ready: function( wait ) {
 416                 // A third-party is pushing the ready event forwards
 417                 if ( wait === true ) {
 418                         jQuery.readyWait--;
 419                 }
 420
 421                 // Make sure that the DOM is not already loaded
 422                 if ( !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                         if ( readyList ) {
 438                                 // Execute all of them
 439                                 var fn,
 440                                         i = 0,
 441                                         ready = readyList;
 442
 443                                 // Reset the list of functions
 444                                 readyList = null;
 445
 446                                 while ( (fn = ready[ i++ ]) ) {
 447                                         fn.call( document, jQuery );
 448                                 }
 449
 450                                 // Trigger any bound ready events
 451                                 if ( jQuery.fn.trigger ) {
 452                                         jQuery( document ).trigger( "ready" ).unbind( "ready" );
 453                                 }
 454                         }
 455                 }
 456         },
 457
 458         bindReady: function() {
 459                 if ( readyBound ) {
 460                         return;
 461                 }
 462
 463                 readyBound = true;
 464
 465                 // Catch cases where $(document).ready() is called after the
 466                 // browser event has already occurred.
 467                 if ( document.readyState === "complete" ) {
 468                         // Handle it asynchronously to allow scripts the opportunity to delay ready
 469                         return setTimeout( jQuery.ready, 1 );
 470                 }
 471
 472                 // Mozilla, Opera and webkit nightlies currently support this event
 473                 if ( document.addEventListener ) {
 474                         // Use the handy event callback
 475                         document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 476
 477                         // A fallback to window.onload, that will always work
 478                         window.addEventListener( "load", jQuery.ready, false );
 479
 480                 // If IE event model is used
 481                 } else if ( document.attachEvent ) {
 482                         // ensure firing before onload,
 483                         // maybe late but safe also for iframes
 484                         document.attachEvent("onreadystatechange", DOMContentLoaded);
 485
 486                         // A fallback to window.onload, that will always work
 487                         window.attachEvent( "onload", jQuery.ready );
 488
 489                         // If IE and not a frame
 490                         // continually check to see if the document is ready
 491                         var toplevel = false;
 492
 493                         try {
 494                                 toplevel = window.frameElement == null;
 495                         } catch(e) {}
 496
 497                         if ( document.documentElement.doScroll && toplevel ) {
 498                                 doScrollCheck();
 499                         }
 500                 }
 501         },
 502
 503         // See test/unit/core.js for details concerning isFunction.
 504         // Since version 1.3, DOM methods and functions like alert
 505         // aren't supported. They return false on IE (#2968).
 506         isFunction: function( obj ) {
 507                 return jQuery.type(obj) === "function";
 508         },
 509
 510         isArray: Array.isArray || function( obj ) {
 511                 return jQuery.type(obj) === "array";
 512         },
 513
 514         // A crude way of determining if an object is a window
 515         isWindow: function( obj ) {
 516                 return obj && typeof obj === "object" && "setInterval" in obj;
 517         },
 518
 519         isNaN: function( obj ) {
 520                 return obj == null || !rdigit.test( obj ) || isNaN( obj );
 521         },
 522
 523         type: function( obj ) {
 524                 return obj == null ?
 525                         String( obj ) :
 526                         class2type[ toString.call(obj) ] || "object";
 527         },
 528
 529         isPlainObject: function( obj ) {
 530                 // Must be an Object.
 531                 // Because of IE, we also have to check the presence of the constructor property.
 532                 // Make sure that DOM nodes and window objects don't pass through, as well
 533                 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
 534                         return false;
 535                 }
 536
 537                 // Not own constructor property must be Object
 538                 if ( obj.constructor &&
 539                         !hasOwn.call(obj, "constructor") &&
 540                         !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
 541                         return false;
 542                 }
 543
 544                 // Own properties are enumerated firstly, so to speed up,
 545                 // if last one is own, then all properties are own.
 546
 547                 var key;
 548                 for ( key in obj ) {}
 549
 550                 return key === undefined || hasOwn.call( obj, key );
 551         },
 552
 553         isEmptyObject: function( obj ) {
 554                 for ( var name in obj ) {
 555                         return false;
 556                 }
 557                 return true;
 558         },
 559
 560         error: function( msg ) {
 561                 throw msg;
 562         },
 563
 564         parseJSON: function( data ) {
 565                 if ( typeof data !== "string" || !data ) {
 566                         return null;
 567                 }
 568
 569                 // Make sure leading/trailing whitespace is removed (IE can't handle it)
 570                 data = jQuery.trim( data );
 571
 572                 // Make sure the incoming data is actual JSON
 573                 // Logic borrowed from http://json.org/json2.js
 574                 if ( rvalidchars.test(data.replace(rvalidescape, "@")
 575                         .replace(rvalidtokens, "]")
 576                         .replace(rvalidbraces, "")) ) {
 577
 578                         // Try to use the native JSON parser first
 579                         return window.JSON && window.JSON.parse ?
 580                                 window.JSON.parse( data ) :
 581                                 (new Function("return " + data))();
 582
 583                 } else {
 584                         jQuery.error( "Invalid JSON: " + data );
 585                 }
 586         },
 587
 588         noop: function() {},
 589
 590         // Evalulates a script in a global context
 591         globalEval: function( data ) {
 592                 if ( data && rnotwhite.test(data) ) {
 593                         // Inspired by code by Andrea Giammarchi
 594                         // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
 595                         var head = document.getElementsByTagName("head")[0] || document.documentElement,
 596                                 script = document.createElement("script");
 597
 598                         script.type = "text/javascript";
 599
 600                         if ( jQuery.support.scriptEval ) {
 601                                 script.appendChild( document.createTextNode( data ) );
 602                         } else {
 603                                 script.text = data;
 604                         }
 605
 606                         // Use insertBefore instead of appendChild to circumvent an IE6 bug.
 607                         // This arises when a base node is used (#2709).
 608                         head.insertBefore( script, head.firstChild );
 609                         head.removeChild( script );
 610                 }
 611         },
 612
 613         nodeName: function( elem, name ) {
 614                 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
 615         },
 616
 617         // args is for internal usage only
 618         each: function( object, callback, args ) {
 619                 var name, i = 0,
 620                         length = object.length,
 621                         isObj = length === undefined || jQuery.isFunction(object);
 622
 623                 if ( args ) {
 624                         if ( isObj ) {
 625                                 for ( name in object ) {
 626                                         if ( callback.apply( object[ name ], args ) === false ) {
 627                                                 break;
 628                                         }
 629                                 }
 630                         } else {
 631                                 for ( ; i < length; ) {
 632                                         if ( callback.apply( object[ i++ ], args ) === false ) {
 633                                                 break;
 634                                         }
 635                                 }
 636                         }
 637
 638                 // A special, fast, case for the most common use of each
 639                 } else {
 640                         if ( isObj ) {
 641                                 for ( name in object ) {
 642                                         if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
 643                                                 break;
 644                                         }
 645                                 }
 646                         } else {
 647                                 for ( var value = object[0];
 648                                         i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
 649                         }
 650                 }
 651
 652                 return object;
 653         },
 654
 655         // Use native String.trim function wherever possible
 656         trim: trim ?
 657                 function( text ) {
 658                         return text == null ?
 659                                 "" :
 660                                 trim.call( text );
 661                 } :
 662
 663                 // Otherwise use our own trimming functionality
 664                 function( text ) {
 665                         return text == null ?
 666                                 "" :
 667                                 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
 668                 },
 669
 670         // results is for internal usage only
 671         makeArray: function( array, results ) {
 672                 var ret = results || [];
 673
 674                 if ( array != null ) {
 675                         // The window, strings (and functions) also have 'length'
 676                         // The extra typeof function check is to prevent crashes
 677                         // in Safari 2 (See: #3039)
 678                         // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
 679                         var type = jQuery.type(array);
 680
 681                         if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
 682                                 push.call( ret, array );
 683                         } else {
 684                                 jQuery.merge( ret, array );
 685                         }
 686                 }
 687
 688                 return ret;
 689         },
 690
 691         inArray: function( elem, array ) {
 692                 if ( array.indexOf ) {
 693                         return array.indexOf( elem );
 694                 }
 695
 696                 for ( var i = 0, length = array.length; i < length; i++ ) {
 697                         if ( array[ i ] === elem ) {
 698                                 return i;
 699                         }
 700                 }
 701
 702                 return -1;
 703         },
 704
 705         merge: function( first, second ) {
 706                 var i = first.length,
 707                         j = 0;
 708
 709                 if ( typeof second.length === "number" ) {
 710                         for ( var l = second.length; j < l; j++ ) {
 711                                 first[ i++ ] = second[ j ];
 712                         }
 713
 714                 } else {
 715                         while ( second[j] !== undefined ) {
 716                                 first[ i++ ] = second[ j++ ];
 717                         }
 718                 }
 719
 720                 first.length = i;
 721
 722                 return first;
 723         },
 724
 725         grep: function( elems, callback, inv ) {
 726                 var ret = [], retVal;
 727                 inv = !!inv;
 728
 729                 // Go through the array, only saving the items
 730                 // that pass the validator function
 731                 for ( var i = 0, length = elems.length; i < length; i++ ) {
 732                         retVal = !!callback( elems[ i ], i );
 733                         if ( inv !== retVal ) {
 734                                 ret.push( elems[ i ] );
 735                         }
 736                 }
 737
 738                 return ret;
 739         },
 740
 741         // arg is for internal usage only
 742         map: function( elems, callback, arg ) {
 743                 var ret = [], value;
 744
 745                 // Go through the array, translating each of the items to their
 746                 // new value (or values).
 747                 for ( var i = 0, length = elems.length; i < length; i++ ) {
 748                         value = callback( elems[ i ], i, arg );
 749
 750                         if ( value != null ) {
 751                                 ret[ ret.length ] = value;
 752                         }
 753                 }
 754
 755                 return ret.concat.apply( [], ret );
 756         },
 757
 758         // A global GUID counter for objects
 759         guid: 1,
 760
 761         proxy: function( fn, proxy, thisObject ) {
 762                 if ( arguments.length === 2 ) {
 763                         if ( typeof proxy === "string" ) {
 764                                 thisObject = fn;
 765                                 fn = thisObject[ proxy ];
 766                                 proxy = undefined;
 767
 768                         } else if ( proxy && !jQuery.isFunction( proxy ) ) {
 769                                 thisObject = proxy;
 770                                 proxy = undefined;
 771                         }
 772                 }
 773
 774                 if ( !proxy && fn ) {
 775                         proxy = function() {
 776                                 return fn.apply( thisObject || this, arguments );
 777                         };
 778                 }
 779
 780                 // Set the guid of unique handler to the same of original handler, so it can be removed
 781                 if ( fn ) {
 782                         proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
 783                 }
 784
 785                 // So proxy can be declared as an argument
 786                 return proxy;
 787         },
 788
 789         // Mutifunctional method to get and set values to a collection
 790         // The value/s can be optionally by executed if its a function
 791         access: function( elems, key, value, exec, fn, pass ) {
 792                 var length = elems.length;
 793
 794                 // Setting many attributes
 795                 if ( typeof key === "object" ) {
 796                         for ( var k in key ) {
 797                                 jQuery.access( elems, k, key[k], exec, fn, value );
 798                         }
 799                         return elems;
 800                 }
 801
 802                 // Setting one attribute
 803                 if ( value !== undefined ) {
 804                         // Optionally, function values get executed if exec is true
 805                         exec = !pass && exec && jQuery.isFunction(value);
 806
 807                         for ( var i = 0; i < length; i++ ) {
 808                                 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
 809                         }
 810
 811                         return elems;
 812                 }
 813
 814                 // Getting an attribute
 815                 return length ? fn( elems[0], key ) : undefined;
 816         },
 817
 818         now: function() {
 819                 return (new Date()).getTime();
 820         },
 821
 822         // Use of jQuery.browser is frowned upon.
 823         // More details: http://docs.jquery.com/Utilities/jQuery.browser
 824         uaMatch: function( ua ) {
 825                 ua = ua.toLowerCase();
 826
 827                 var match = rwebkit.exec( ua ) ||
 828                         ropera.exec( ua ) ||
 829                         rmsie.exec( ua ) ||
 830                         ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
 831                         [];
 832
 833                 return { browser: match[1] || "", version: match[2] || "0" };
 834         },
 835
 836         browser: {}
 837 });
 838
 839 // Populate the class2type map
 840 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
 841         class2type[ "[object " + name + "]" ] = name.toLowerCase();
 842 });
 843
 844 browserMatch = jQuery.uaMatch( userAgent );
 845 if ( browserMatch.browser ) {
 846         jQuery.browser[ browserMatch.browser ] = true;
 847         jQuery.browser.version = browserMatch.version;
 848 }
 849
 850 // Deprecated, use jQuery.browser.webkit instead
 851 if ( jQuery.browser.webkit ) {
 852         jQuery.browser.safari = true;
 853 }
 854
 855 if ( indexOf ) {
 856         jQuery.inArray = function( elem, array ) {
 857                 return indexOf.call( array, elem );
 858         };
 859 }
 860
 861 // Verify that \s matches non-breaking spaces
 862 // (IE fails on this test)
 863 if ( !rwhite.test( "\xA0" ) ) {
 864         trimLeft = /^[\s\xA0]+/;
 865         trimRight = /[\s\xA0]+$/;
 866 }
 867
 868 // All jQuery objects should point back to these
 869 rootjQuery = jQuery(document);
 870
 871 // Cleanup functions for the document ready method
 872 if ( document.addEventListener ) {
 873         DOMContentLoaded = function() {
 874                 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 875                 jQuery.ready();
 876         };
 877
 878 } else if ( document.attachEvent ) {
 879         DOMContentLoaded = function() {
 880                 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
 881                 if ( document.readyState === "complete" ) {
 882                         document.detachEvent( "onreadystatechange", DOMContentLoaded );
 883                         jQuery.ready();
 884                 }
 885         };
 886 }
 887
 888 // The DOM ready check for Internet Explorer
 889 function doScrollCheck() {
 890         if ( jQuery.isReady ) {
 891                 return;
 892         }
 893
 894         try {
 895                 // If IE is used, use the trick by Diego Perini
 896                 // http://javascript.nwbox.com/IEContentLoaded/
 897                 document.documentElement.doScroll("left");
 898         } catch(e) {
 899                 setTimeout( doScrollCheck, 1 );
 900                 return;
 901         }
 902
 903         // and execute any waiting functions
 904         jQuery.ready();
 905 }
 906
 907 // Expose jQuery to the global object
 908 return (window.jQuery = window.$ = jQuery);
 909
 910 })();
 911
 912
 913 (function() {
 914
 915         jQuery.support = {};
 916
 917         var root = document.documentElement,
 918                 script = document.createElement("script"),
 919                 div = document.createElement("div"),
 920                 id = "script" + jQuery.now();
 921
 922         div.style.display = "none";
 923         div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
 924
 925         var all = div.getElementsByTagName("*"),
 926                 a = div.getElementsByTagName("a")[0],
 927                 select = document.createElement("select"),
 928                 opt = select.appendChild( document.createElement("option") );
 929
 930         // Can't get basic test support
 931         if ( !all || !all.length || !a ) {
 932                 return;
 933         }
 934
 935         jQuery.support = {
 936                 // IE strips leading whitespace when .innerHTML is used
 937                 leadingWhitespace: div.firstChild.nodeType === 3,
 938
 939                 // Make sure that tbody elements aren't automatically inserted
 940                 // IE will insert them into empty tables
 941                 tbody: !div.getElementsByTagName("tbody").length,
 942
 943                 // Make sure that link elements get serialized correctly by innerHTML
 944                 // This requires a wrapper element in IE
 945                 htmlSerialize: !!div.getElementsByTagName("link").length,
 946
 947                 // Get the style information from getAttribute
 948                 // (IE uses .cssText insted)
 949                 style: /red/.test( a.getAttribute("style") ),
 950
 951                 // Make sure that URLs aren't manipulated
 952                 // (IE normalizes it by default)
 953                 hrefNormalized: a.getAttribute("href") === "/a",
 954
 955                 // Make sure that element opacity exists
 956                 // (IE uses filter instead)
 957                 // Use a regex to work around a WebKit issue. See #5145
 958                 opacity: /^0.55$/.test( a.style.opacity ),
 959
 960                 // Verify style float existence
 961                 // (IE uses styleFloat instead of cssFloat)
 962                 cssFloat: !!a.style.cssFloat,
 963
 964                 // Make sure that if no value is specified for a checkbox
 965                 // that it defaults to "on".
 966                 // (WebKit defaults to "" instead)
 967                 checkOn: div.getElementsByTagName("input")[0].value === "on",
 968
 969                 // Make sure that a selected-by-default option has a working selected property.
 970                 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
 971                 optSelected: opt.selected,
 972
 973                 // Will be defined later
 974                 deleteExpando: true,
 975                 optDisabled: false,
 976                 checkClone: false,
 977                 scriptEval: false,
 978                 noCloneEvent: true,
 979                 boxModel: null,
 980                 inlineBlockNeedsLayout: false,
 981                 shrinkWrapBlocks: false,
 982                 reliableHiddenOffsets: true
 983         };
 984
 985         // Make sure that the options inside disabled selects aren't marked as disabled
 986         // (WebKit marks them as diabled)
 987         select.disabled = true;
 988         jQuery.support.optDisabled = !opt.disabled;
 989
 990         script.type = "text/javascript";
 991         try {
 992                 script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
 993         } catch(e) {}
 994
 995         root.insertBefore( script, root.firstChild );
 996
 997         // Make sure that the execution of code works by injecting a script
 998         // tag with appendChild/createTextNode
 999         // (IE doesn't support this, fails, and uses .text instead)
1000         if ( window[ id ] ) {
1001                 jQuery.support.scriptEval = true;
1002                 delete window[ id ];
1003         }
1004
1005         // Test to see if it's possible to delete an expando from an element
1006         // Fails in Internet Explorer
1007         try {
1008                 delete script.test;
1009
1010         } catch(e) {
1011                 jQuery.support.deleteExpando = false;
1012         }
1013
1014         root.removeChild( script );
1015
1016         if ( div.attachEvent && div.fireEvent ) {
1017                 div.attachEvent("onclick", function click() {
1018                         // Cloning a node shouldn't copy over any
1019                         // bound event handlers (IE does this)
1020                         jQuery.support.noCloneEvent = false;
1021                         div.detachEvent("onclick", click);
1022                 });
1023                 div.cloneNode(true).fireEvent("onclick");
1024         }
1025
1026         div = document.createElement("div");
1027         div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
1028
1029         var fragment = document.createDocumentFragment();
1030         fragment.appendChild( div.firstChild );
1031
1032         // WebKit doesn't clone checked state correctly in fragments
1033         jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
1034
1035         // Figure out if the W3C box model works as expected
1036         // document.body must exist before we can do this
1037         jQuery(function() {
1038                 var div = document.createElement("div");
1039                 div.style.width = div.style.paddingLeft = "1px";
1040
1041                 document.body.appendChild( div );
1042                 jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
1043
1044                 if ( "zoom" in div.style ) {
1045                         // Check if natively block-level elements act like inline-block
1046                         // elements when setting their display to 'inline' and giving
1047                         // them layout
1048                         // (IE < 8 does this)
1049                         div.style.display = "inline";
1050                         div.style.zoom = 1;
1051                         jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
1052
1053                         // Check if elements with layout shrink-wrap their children
1054                         // (IE 6 does this)
1055                         div.style.display = "";
1056                         div.innerHTML = "<div style='width:4px;'></div>";
1057                         jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
1058                 }
1059
1060                 div.innerHTML = "<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>";
1061                 var tds = div.getElementsByTagName("td");
1062
1063                 // Check if table cells still have offsetWidth/Height when they are set
1064                 // to display:none and there are still other visible table cells in a
1065                 // table row; if so, offsetWidth/Height are not reliable for use when
1066                 // determining if an element has been hidden directly using
1067                 // display:none (it is still safe to use offsets if a parent element is
1068                 // hidden; don safety goggles and see bug #4512 for more information).
1069                 // (only IE 8 fails this test)
1070                 jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
1071
1072                 tds[0].style.display = "";
1073                 tds[1].style.display = "none";
1074
1075                 // Check if empty table cells still have offsetWidth/Height
1076                 // (IE < 8 fail this test)
1077                 jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1078                 div.innerHTML = "";
1079
1080                 document.body.removeChild( div ).style.display = "none";
1081                 div = tds = null;
1082         });
1083
1084         // Technique from Juriy Zaytsev
1085         // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1086         var eventSupported = function( eventName ) {
1087                 var el = document.createElement("div");
1088                 eventName = "on" + eventName;
1089
1090                 var isSupported = (eventName in el);
1091                 if ( !isSupported ) {
1092                         el.setAttribute(eventName, "return;");
1093                         isSupported = typeof el[eventName] === "function";
1094                 }
1095                 el = null;
1096
1097                 return isSupported;
1098         };
1099
1100         jQuery.support.submitBubbles = eventSupported("submit");
1101         jQuery.support.changeBubbles = eventSupported("change");
1102
1103         // release memory in IE
1104         root = script = div = all = a = null;
1105 })();
1106
1107
1108
1109 var windowData = {},
1110         rbrace = /^(?:\{.*\}|\[.*\])$/;
1111
1112 jQuery.extend({
1113         cache: {},
1114
1115         // Please use with caution
1116         uuid: 0,
1117
1118         // Unique for each copy of jQuery on the page
1119         expando: "jQuery" + jQuery.now(),
1120
1121         // The following elements throw uncatchable exceptions if you
1122         // attempt to add expando properties to them.
1123         noData: {
1124                 "embed": true,
1125                 // Ban all objects except for Flash (which handle expandos)
1126                 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1127                 "applet": true
1128         },
1129
1130         data: function( elem, name, data ) {
1131                 if ( !jQuery.acceptData( elem ) ) {
1132                         return;
1133                 }
1134
1135                 elem = elem == window ?
1136                         windowData :
1137                         elem;
1138
1139                 var isNode = elem.nodeType,
1140                         id = isNode ? elem[ jQuery.expando ] : null,
1141                         cache = jQuery.cache, thisCache;
1142
1143                 if ( isNode && !id && typeof name === "string" && data === undefined ) {
1144                         return;
1145                 }
1146
1147                 // Get the data from the object directly
1148                 if ( !isNode ) {
1149                         cache = elem;
1150
1151                 // Compute a unique ID for the element
1152                 } else if ( !id ) {
1153                         elem[ jQuery.expando ] = id = ++jQuery.uuid;
1154                 }
1155
1156                 // Avoid generating a new cache unless none exists and we
1157                 // want to manipulate it.
1158                 if ( typeof name === "object" ) {
1159                         if ( isNode ) {
1160                                 cache[ id ] = jQuery.extend(cache[ id ], name);
1161
1162                         } else {
1163                                 jQuery.extend( cache, name );
1164                         }
1165
1166                 } else if ( isNode && !cache[ id ] ) {
1167                         cache[ id ] = {};
1168                 }
1169
1170                 thisCache = isNode ? cache[ id ] : cache;
1171
1172                 // Prevent overriding the named cache with undefined values
1173                 if ( data !== undefined ) {
1174                         thisCache[ name ] = data;
1175                 }
1176
1177                 return typeof name === "string" ? thisCache[ name ] : thisCache;
1178         },
1179
1180         removeData: function( elem, name ) {
1181                 if ( !jQuery.acceptData( elem ) ) {
1182                         return;
1183                 }
1184
1185                 elem = elem == window ?
1186                         windowData :
1187                         elem;
1188
1189                 var isNode = elem.nodeType,
1190                         id = isNode ? elem[ jQuery.expando ] : elem,
1191                         cache = jQuery.cache,
1192                         thisCache = isNode ? cache[ id ] : id;
1193
1194                 // If we want to remove a specific section of the element's data
1195                 if ( name ) {
1196                         if ( thisCache ) {
1197                                 // Remove the section of cache data
1198                                 delete thisCache[ name ];
1199
1200                                 // If we've removed all the data, remove the element's cache
1201                                 if ( isNode && jQuery.isEmptyObject(thisCache) ) {
1202                                         jQuery.removeData( elem );
1203                                 }
1204                         }
1205
1206                 // Otherwise, we want to remove all of the element's data
1207                 } else {
1208                         if ( isNode && jQuery.support.deleteExpando ) {
1209                                 delete elem[ jQuery.expando ];
1210
1211                         } else if ( elem.removeAttribute ) {
1212                                 elem.removeAttribute( jQuery.expando );
1213
1214                         // Completely remove the data cache
1215                         } else if ( isNode ) {
1216                                 delete cache[ id ];
1217
1218                         // Remove all fields from the object
1219                         } else {
1220                                 for ( var n in elem ) {
1221                                         delete elem[ n ];
1222                                 }
1223                         }
1224                 }
1225         },
1226
1227         // A method for determining if a DOM node can handle the data expando
1228         acceptData: function( elem ) {
1229                 if ( elem.nodeName ) {
1230                         var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1231
1232                         if ( match ) {
1233                                 return !(match === true || elem.getAttribute("classid") !== match);
1234                         }
1235                 }
1236
1237                 return true;
1238         }
1239 });
1240
1241 jQuery.fn.extend({
1242         data: function( key, value ) {
1243                 var data = null;
1244
1245                 if ( typeof key === "undefined" ) {
1246                         if ( this.length ) {
1247                                 var attr = this[0].attributes, name;
1248                                 data = jQuery.data( this[0] );
1249
1250                                 for ( var i = 0, l = attr.length; i < l; i++ ) {
1251                                         name = attr[i].name;
1252
1253                                         if ( name.indexOf( "data-" ) === 0 ) {
1254                                                 name = name.substr( 5 );
1255                                                 dataAttr( this[0], name, data[ name ] );
1256                                         }
1257                                 }
1258                         }
1259
1260                         return data;
1261
1262                 } else if ( typeof key === "object" ) {
1263                         return this.each(function() {
1264                                 jQuery.data( this, key );
1265                         });
1266                 }
1267
1268                 var parts = key.split(".");
1269                 parts[1] = parts[1] ? "." + parts[1] : "";
1270
1271                 if ( value === undefined ) {
1272                         data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1273
1274                         // Try to fetch any internally stored data first
1275                         if ( data === undefined && this.length ) {
1276                                 data = jQuery.data( this[0], key );
1277                                 data = dataAttr( this[0], key, data );
1278                         }
1279
1280                         return data === undefined && parts[1] ?
1281                                 this.data( parts[0] ) :
1282                                 data;
1283
1284                 } else {
1285                         return this.each(function() {
1286                                 var $this = jQuery( this ),
1287                                         args = [ parts[0], value ];
1288
1289                                 $this.triggerHandler( "setData" + parts[1] + "!", args );
1290                                 jQuery.data( this, key, value );
1291                                 $this.triggerHandler( "changeData" + parts[1] + "!", args );
1292                         });
1293                 }
1294         },
1295
1296         removeData: function( key ) {
1297                 return this.each(function() {
1298                         jQuery.removeData( this, key );
1299                 });
1300         }
1301 });
1302
1303 function dataAttr( elem, key, data ) {
1304         // If nothing was found internally, try to fetch any
1305         // data from the HTML5 data-* attribute
1306         if ( data === undefined && elem.nodeType === 1 ) {
1307                 data = elem.getAttribute( "data-" + key );
1308
1309                 if ( typeof data === "string" ) {
1310                         try {
1311                                 data = data === "true" ? true :
1312                                 data === "false" ? false :
1313                                 data === "null" ? null :
1314                                 !jQuery.isNaN( data ) ? parseFloat( data ) :
1315                                         rbrace.test( data ) ? jQuery.parseJSON( data ) :
1316                                         data;
1317                         } catch( e ) {}
1318
1319                         // Make sure we set the data so it isn't changed later
1320                         jQuery.data( elem, key, data );
1321
1322                 } else {
1323                         data = undefined;
1324                 }
1325         }
1326
1327         return data;
1328 }
1329
1330
1331
1332
1333 jQuery.extend({
1334         queue: function( elem, type, data ) {
1335                 if ( !elem ) {
1336                         return;
1337                 }
1338
1339                 type = (type || "fx") + "queue";
1340                 var q = jQuery.data( elem, type );
1341
1342                 // Speed up dequeue by getting out quickly if this is just a lookup
1343                 if ( !data ) {
1344                         return q || [];
1345                 }
1346
1347                 if ( !q || jQuery.isArray(data) ) {
1348                         q = jQuery.data( elem, type, jQuery.makeArray(data) );
1349
1350                 } else {
1351                         q.push( data );
1352                 }
1353
1354                 return q;
1355         },
1356
1357         dequeue: function( elem, type ) {
1358                 type = type || "fx";
1359
1360                 var queue = jQuery.queue( elem, type ),
1361                         fn = queue.shift();
1362
1363                 // If the fx queue is dequeued, always remove the progress sentinel
1364                 if ( fn === "inprogress" ) {
1365                         fn = queue.shift();
1366                 }
1367
1368                 if ( fn ) {
1369                         // Add a progress sentinel to prevent the fx queue from being
1370                         // automatically dequeued
1371                         if ( type === "fx" ) {
1372                                 queue.unshift("inprogress");
1373                         }
1374
1375                         fn.call(elem, function() {
1376                                 jQuery.dequeue(elem, type);
1377                         });
1378                 }
1379         }
1380 });
1381
1382 jQuery.fn.extend({
1383         queue: function( type, data ) {
1384                 if ( typeof type !== "string" ) {
1385                         data = type;
1386                         type = "fx";
1387                 }
1388
1389                 if ( data === undefined ) {
1390                         return jQuery.queue( this[0], type );
1391                 }
1392                 return this.each(function( i ) {
1393                         var queue = jQuery.queue( this, type, data );
1394
1395                         if ( type === "fx" && queue[0] !== "inprogress" ) {
1396                                 jQuery.dequeue( this, type );
1397                         }
1398                 });
1399         },
1400         dequeue: function( type ) {
1401                 return this.each(function() {
1402                         jQuery.dequeue( this, type );
1403                 });
1404         },
1405
1406         // Based off of the plugin by Clint Helfers, with permission.
1407         // http://blindsignals.com/index.php/2009/07/jquery-delay/
1408         delay: function( time, type ) {
1409                 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1410                 type = type || "fx";
1411
1412                 return this.queue( type, function() {
1413                         var elem = this;
1414                         setTimeout(function() {
1415                                 jQuery.dequeue( elem, type );
1416                         }, time );
1417                 });
1418         },
1419
1420         clearQueue: function( type ) {
1421                 return this.queue( type || "fx", [] );
1422         }
1423 });
1424
1425
1426
1427
1428 var rclass = /[\n\t]/g,
1429         rspaces = /\s+/,
1430         rreturn = /\r/g,
1431         rspecialurl = /^(?:href|src|style)$/,
1432         rtype = /^(?:button|input)$/i,
1433         rfocusable = /^(?:button|input|object|select|textarea)$/i,
1434         rclickable = /^a(?:rea)?$/i,
1435         rradiocheck = /^(?:radio|checkbox)$/i;
1436
1437 jQuery.props = {
1438         "for": "htmlFor",
1439         "class": "className",
1440         readonly: "readOnly",
1441         maxlength: "maxLength",
1442         cellspacing: "cellSpacing",
1443         rowspan: "rowSpan",
1444         colspan: "colSpan",
1445         tabindex: "tabIndex",
1446         usemap: "useMap",
1447         frameborder: "frameBorder"
1448 };
1449
1450 jQuery.fn.extend({
1451         attr: function( name, value ) {
1452                 return jQuery.access( this, name, value, true, jQuery.attr );
1453         },
1454
1455         removeAttr: function( name, fn ) {
1456                 return this.each(function(){
1457                         jQuery.attr( this, name, "" );
1458                         if ( this.nodeType === 1 ) {
1459                                 this.removeAttribute( name );
1460                         }
1461                 });
1462         },
1463
1464         addClass: function( value ) {
1465                 if ( jQuery.isFunction(value) ) {
1466                         return this.each(function(i) {
1467                                 var self = jQuery(this);
1468                                 self.addClass( value.call(this, i, self.attr("class")) );
1469                         });
1470                 }
1471
1472                 if ( value && typeof value === "string" ) {
1473                         var classNames = (value || "").split( rspaces );
1474
1475                         for ( var i = 0, l = this.length; i < l; i++ ) {
1476                                 var elem = this[i];
1477
1478                                 if ( elem.nodeType === 1 ) {
1479                                         if ( !elem.className ) {
1480                                                 elem.className = value;
1481
1482                                         } else {
1483                                                 var className = " " + elem.className + " ",
1484                                                         setClass = elem.className;
1485
1486                                                 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1487                                                         if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1488                                                                 setClass += " " + classNames[c];
1489                                                         }
1490                                                 }
1491                                                 elem.className = jQuery.trim( setClass );
1492                                         }
1493                                 }
1494                         }
1495                 }
1496
1497                 return this;
1498         },
1499
1500         removeClass: function( value ) {
1501                 if ( jQuery.isFunction(value) ) {
1502                         return this.each(function(i) {
1503                                 var self = jQuery(this);
1504                                 self.removeClass( value.call(this, i, self.attr("class")) );
1505                         });
1506                 }
1507
1508                 if ( (value && typeof value === "string") || value === undefined ) {
1509                         var classNames = (value || "").split( rspaces );
1510
1511                         for ( var i = 0, l = this.length; i < l; i++ ) {
1512                                 var elem = this[i];
1513
1514                                 if ( elem.nodeType === 1 && elem.className ) {
1515                                         if ( value ) {
1516                                                 var className = (" " + elem.className + " ").replace(rclass, " ");
1517                                                 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1518                                                         className = className.replace(" " + classNames[c] + " ", " ");
1519                                                 }
1520                                                 elem.className = jQuery.trim( className );
1521
1522                                         } else {
1523                                                 elem.className = "";
1524                                         }
1525                                 }
1526                         }
1527                 }
1528
1529                 return this;
1530         },
1531
1532         toggleClass: function( value, stateVal ) {
1533                 var type = typeof value,
1534                         isBool = typeof stateVal === "boolean";
1535
1536                 if ( jQuery.isFunction( value ) ) {
1537                         return this.each(function(i) {
1538                                 var self = jQuery(this);
1539                                 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1540                         });
1541                 }
1542
1543                 return this.each(function() {
1544                         if ( type === "string" ) {
1545                                 // toggle individual class names
1546                                 var className,
1547                                         i = 0,
1548                                         self = jQuery( this ),
1549                                         state = stateVal,
1550                                         classNames = value.split( rspaces );
1551
1552                                 while ( (className = classNames[ i++ ]) ) {
1553                                         // check each className given, space seperated list
1554                                         state = isBool ? state : !self.hasClass( className );
1555                                         self[ state ? "addClass" : "removeClass" ]( className );
1556                                 }
1557
1558                         } else if ( type === "undefined" || type === "boolean" ) {
1559                                 if ( this.className ) {
1560                                         // store className if set
1561                                         jQuery.data( this, "__className__", this.className );
1562                                 }
1563
1564                                 // toggle whole className
1565                                 this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1566                         }
1567                 });
1568         },
1569
1570         hasClass: function( selector ) {
1571                 var className = " " + selector + " ";
1572                 for ( var i = 0, l = this.length; i < l; i++ ) {
1573                         if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1574                                 return true;
1575                         }
1576                 }
1577
1578                 return false;
1579         },
1580
1581         val: function( value ) {
1582                 if ( !arguments.length ) {
1583                         var elem = this[0];
1584
1585                         if ( elem ) {
1586                                 if ( jQuery.nodeName( elem, "option" ) ) {
1587                                         // attributes.value is undefined in Blackberry 4.7 but
1588                                         // uses .value. See #6932
1589                                         var val = elem.attributes.value;
1590                                         return !val || val.specified ? elem.value : elem.text;
1591                                 }
1592
1593                                 // We need to handle select boxes special
1594                                 if ( jQuery.nodeName( elem, "select" ) ) {
1595                                         var index = elem.selectedIndex,
1596                                                 values = [],
1597                                                 options = elem.options,
1598                                                 one = elem.type === "select-one";
1599
1600                                         // Nothing was selected
1601                                         if ( index < 0 ) {
1602                                                 return null;
1603                                         }
1604
1605                                         // Loop through all the selected options
1606                                         for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1607                                                 var option = options[ i ];
1608
1609                                                 // Don't return options that are disabled or in a disabled optgroup
1610                                                 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
1611                                                                 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
1612
1613                                                         // Get the specific value for the option
1614                                                         value = jQuery(option).val();
1615
1616                                                         // We don't need an array for one selects
1617                                                         if ( one ) {
1618                                                                 return value;
1619                                                         }
1620
1621                                                         // Multi-Selects return an array
1622                                                         values.push( value );
1623                                                 }
1624                                         }
1625
1626                                         return values;
1627                                 }
1628
1629                                 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1630                                 if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1631                                         return elem.getAttribute("value") === null ? "on" : elem.value;
1632                                 }
1633
1634
1635                                 // Everything else, we just grab the value
1636                                 return (elem.value || "").replace(rreturn, "");
1637
1638                         }
1639
1640                         return undefined;
1641                 }
1642
1643                 var isFunction = jQuery.isFunction(value);
1644
1645                 return this.each(function(i) {
1646                         var self = jQuery(this), val = value;
1647
1648                         if ( this.nodeType !== 1 ) {
1649                                 return;
1650                         }
1651
1652                         if ( isFunction ) {
1653                                 val = value.call(this, i, self.val());
1654                         }
1655
1656                         // Treat null/undefined as ""; convert numbers to string
1657                         if ( val == null ) {
1658                                 val = "";
1659                         } else if ( typeof val === "number" ) {
1660                                 val += "";
1661                         } else if ( jQuery.isArray(val) ) {
1662                                 val = jQuery.map(val, function (value) {
1663                                         return value == null ? "" : value + "";
1664                                 });
1665                         }
1666
1667                         if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1668                                 this.checked = jQuery.inArray( self.val(), val ) >= 0;
1669
1670                         } else if ( jQuery.nodeName( this, "select" ) ) {
1671                                 var values = jQuery.makeArray(val);
1672
1673                                 jQuery( "option", this ).each(function() {
1674                                         this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1675                                 });
1676
1677                                 if ( !values.length ) {
1678                                         this.selectedIndex = -1;
1679                                 }
1680
1681                         } else {
1682                                 this.value = val;
1683                         }
1684                 });
1685         }
1686 });
1687
1688 jQuery.extend({
1689         attrFn: {
1690                 val: true,
1691                 css: true,
1692                 html: true,
1693                 text: true,
1694                 data: true,
1695                 width: true,
1696                 height: true,
1697                 offset: true
1698         },
1699
1700         attr: function( elem, name, value, pass ) {
1701                 // don't set attributes on text and comment nodes
1702                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1703                         return undefined;
1704                 }
1705
1706                 if ( pass && name in jQuery.attrFn ) {
1707                         return jQuery(elem)[name](value);
1708                 }
1709
1710                 var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1711                         // Whether we are setting (or getting)
1712                         set = value !== undefined;
1713
1714                 // Try to normalize/fix the name
1715                 name = notxml && jQuery.props[ name ] || name;
1716
1717                 // These attributes require special treatment
1718                 var special = rspecialurl.test( name );
1719
1720                 // Safari mis-reports the default selected property of an option
1721                 // Accessing the parent's selectedIndex property fixes it
1722                 if ( name === "selected" && !jQuery.support.optSelected ) {
1723                         var parent = elem.parentNode;
1724                         if ( parent ) {
1725                                 parent.selectedIndex;
1726
1727                                 // Make sure that it also works with optgroups, see #5701
1728                                 if ( parent.parentNode ) {
1729                                         parent.parentNode.selectedIndex;
1730                                 }
1731                         }
1732                 }
1733
1734                 // If applicable, access the attribute via the DOM 0 way
1735                 // 'in' checks fail in Blackberry 4.7 #6931
1736                 if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
1737                         if ( set ) {
1738                                 // We can't allow the type property to be changed (since it causes problems in IE)
1739                                 if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1740                                         jQuery.error( "type property can't be changed" );
1741                                 }
1742
1743                                 if ( value === null ) {
1744                                         if ( elem.nodeType === 1 ) {
1745                                                 elem.removeAttribute( name );
1746                                         }
1747
1748                                 } else {
1749                                         elem[ name ] = value;
1750                                 }
1751                         }
1752
1753                         // browsers index elements by id/name on forms, give priority to attributes.
1754                         if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1755                                 return elem.getAttributeNode( name ).nodeValue;
1756                         }
1757
1758                         // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1759                         // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1760                         if ( name === "tabIndex" ) {
1761                                 var attributeNode = elem.getAttributeNode( "tabIndex" );
1762
1763                                 return attributeNode && attributeNode.specified ?
1764                                         attributeNode.value :
1765                                         rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1766                                                 0 :
1767                                                 undefined;
1768                         }
1769
1770                         return elem[ name ];
1771                 }
1772
1773                 if ( !jQuery.support.style && notxml && name === "style" ) {
1774                         if ( set ) {
1775                                 elem.style.cssText = "" + value;
1776                         }
1777
1778                         return elem.style.cssText;
1779                 }
1780
1781                 if ( set ) {
1782                         // convert the value to a string (all browsers do this but IE) see #1070
1783                         elem.setAttribute( name, "" + value );
1784                 }
1785
1786                 // Ensure that missing attributes return undefined
1787                 // Blackberry 4.7 returns "" from getAttribute #6938
1788                 if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
1789                         return undefined;
1790                 }
1791
1792                 var attr = !jQuery.support.hrefNormalized && notxml && special ?
1793                                 // Some attributes require a special call on IE
1794                                 elem.getAttribute( name, 2 ) :
1795                                 elem.getAttribute( name );
1796
1797                 // Non-existent attributes return null, we normalize to undefined
1798                 return attr === null ? undefined : attr;
1799         }
1800 });
1801
1802
1803
1804
1805 var rnamespaces = /\.(.*)$/,
1806         rformElems = /^(?:textarea|input|select)$/i,
1807         rperiod = /\./g,
1808         rspace = / /g,
1809         rescape = /[^\w\s.|`]/g,
1810         fcleanup = function( nm ) {
1811                 return nm.replace(rescape, "\\$&");
1812         },
1813         focusCounts = { focusin: 0, focusout: 0 };
1814
1815 /*
1816  * A number of helper functions used for managing events.
1817  * Many of the ideas behind this code originated from
1818  * Dean Edwards' addEvent library.
1819  */
1820 jQuery.event = {
1821
1822         // Bind an event to an element
1823         // Original by Dean Edwards
1824         add: function( elem, types, handler, data ) {
1825                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1826                         return;
1827                 }
1828
1829                 // For whatever reason, IE has trouble passing the window object
1830                 // around, causing it to be cloned in the process
1831                 if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
1832                         elem = window;
1833                 }
1834
1835                 if ( handler === false ) {
1836                         handler = returnFalse;
1837                 } else if ( !handler ) {
1838                         // Fixes bug #7229. Fix recommended by jdalton
1839                   return;
1840                 }
1841
1842                 var handleObjIn, handleObj;
1843
1844                 if ( handler.handler ) {
1845                         handleObjIn = handler;
1846                         handler = handleObjIn.handler;
1847                 }
1848
1849                 // Make sure that the function being executed has a unique ID
1850                 if ( !handler.guid ) {
1851                         handler.guid = jQuery.guid++;
1852                 }
1853
1854                 // Init the element's event structure
1855                 var elemData = jQuery.data( elem );
1856
1857                 // If no elemData is found then we must be trying to bind to one of the
1858                 // banned noData elements
1859                 if ( !elemData ) {
1860                         return;
1861                 }
1862
1863                 // Use a key less likely to result in collisions for plain JS objects.
1864                 // Fixes bug #7150.
1865                 var eventKey = elem.nodeType ? "events" : "__events__",
1866                         events = elemData[ eventKey ],
1867                         eventHandle = elemData.handle;
1868
1869                 if ( typeof events === "function" ) {
1870                         // On plain objects events is a fn that holds the the data
1871                         // which prevents this data from being JSON serialized
1872                         // the function does not need to be called, it just contains the data
1873                         eventHandle = events.handle;
1874                         events = events.events;
1875
1876                 } else if ( !events ) {
1877                         if ( !elem.nodeType ) {
1878                                 // On plain objects, create a fn that acts as the holder
1879                                 // of the values to avoid JSON serialization of event data
1880                                 elemData[ eventKey ] = elemData = function(){};
1881                         }
1882
1883                         elemData.events = events = {};
1884                 }
1885
1886                 if ( !eventHandle ) {
1887                         elemData.handle = eventHandle = function() {
1888                                 // Handle the second event of a trigger and when
1889                                 // an event is called after a page has unloaded
1890                                 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1891                                         jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1892                                         undefined;
1893                         };
1894                 }
1895
1896                 // Add elem as a property of the handle function
1897                 // This is to prevent a memory leak with non-native events in IE.
1898                 eventHandle.elem = elem;
1899
1900                 // Handle multiple events separated by a space
1901                 // jQuery(...).bind("mouseover mouseout", fn);
1902                 types = types.split(" ");
1903
1904                 var type, i = 0, namespaces;
1905
1906                 while ( (type = types[ i++ ]) ) {
1907                         handleObj = handleObjIn ?
1908                                 jQuery.extend({}, handleObjIn) :
1909                                 { handler: handler, data: data };
1910
1911                         // Namespaced event handlers
1912                         if ( type.indexOf(".") > -1 ) {
1913                                 namespaces = type.split(".");
1914                                 type = namespaces.shift();
1915                                 handleObj.namespace = namespaces.slice(0).sort().join(".");
1916
1917                         } else {
1918                                 namespaces = [];
1919                                 handleObj.namespace = "";
1920                         }
1921
1922                         handleObj.type = type;
1923                         if ( !handleObj.guid ) {
1924                                 handleObj.guid = handler.guid;
1925                         }
1926
1927                         // Get the current list of functions bound to this event
1928                         var handlers = events[ type ],
1929                                 special = jQuery.event.special[ type ] || {};
1930
1931                         // Init the event handler queue
1932                         if ( !handlers ) {
1933                                 handlers = events[ type ] = [];
1934
1935                                 // Check for a special event handler
1936                                 // Only use addEventListener/attachEvent if the special
1937                                 // events handler returns false
1938                                 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
1939                                         // Bind the global event handler to the element
1940                                         if ( elem.addEventListener ) {
1941                                                 elem.addEventListener( type, eventHandle, false );
1942
1943                                         } else if ( elem.attachEvent ) {
1944                                                 elem.attachEvent( "on" + type, eventHandle );
1945                                         }
1946                                 }
1947                         }
1948
1949                         if ( special.add ) {
1950                                 special.add.call( elem, handleObj );
1951
1952                                 if ( !handleObj.handler.guid ) {
1953                                         handleObj.handler.guid = handler.guid;
1954                                 }
1955                         }
1956
1957                         // Add the function to the element's handler list
1958                         handlers.push( handleObj );
1959
1960                         // Keep track of which events have been used, for global triggering
1961                         jQuery.event.global[ type ] = true;
1962                 }
1963
1964                 // Nullify elem to prevent memory leaks in IE
1965                 elem = null;
1966         },
1967
1968         global: {},
1969
1970         // Detach an event or set of events from an element
1971         remove: function( elem, types, handler, pos ) {
1972                 // don't do events on text and comment nodes
1973                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1974                         return;
1975                 }
1976
1977                 if ( handler === false ) {
1978                         handler = returnFalse;
1979                 }
1980
1981                 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
1982                         eventKey = elem.nodeType ? "events" : "__events__",
1983                         elemData = jQuery.data( elem ),
1984                         events = elemData && elemData[ eventKey ];
1985
1986                 if ( !elemData || !events ) {
1987                         return;
1988                 }
1989
1990                 if ( typeof events === "function" ) {
1991                         elemData = events;
1992                         events = events.events;
1993                 }
1994
1995                 // types is actually an event object here
1996                 if ( types && types.type ) {
1997                         handler = types.handler;
1998                         types = types.type;
1999                 }
2000
2001                 // Unbind all events for the element
2002                 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2003                         types = types || "";
2004
2005                         for ( type in events ) {
2006                                 jQuery.event.remove( elem, type + types );
2007                         }
2008
2009                         return;
2010                 }
2011
2012                 // Handle multiple events separated by a space
2013                 // jQuery(...).unbind("mouseover mouseout", fn);
2014                 types = types.split(" ");
2015
2016                 while ( (type = types[ i++ ]) ) {
2017                         origType = type;
2018                         handleObj = null;
2019                         all = type.indexOf(".") < 0;
2020                         namespaces = [];
2021
2022                         if ( !all ) {
2023                                 // Namespaced event handlers
2024                                 namespaces = type.split(".");
2025                                 type = namespaces.shift();
2026
2027                                 namespace = new RegExp("(^|\\.)" +
2028                                         jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2029                         }
2030
2031                         eventType = events[ type ];
2032
2033                         if ( !eventType ) {
2034                                 continue;
2035                         }
2036
2037                         if ( !handler ) {
2038                                 for ( j = 0; j < eventType.length; j++ ) {
2039                                         handleObj = eventType[ j ];
2040
2041                                         if ( all || namespace.test( handleObj.namespace ) ) {
2042                                                 jQuery.event.remove( elem, origType, handleObj.handler, j );
2043                                                 eventType.splice( j--, 1 );
2044                                         }
2045                                 }
2046
2047                                 continue;
2048                         }
2049
2050                         special = jQuery.event.special[ type ] || {};
2051
2052                         for ( j = pos || 0; j < eventType.length; j++ ) {
2053                                 handleObj = eventType[ j ];
2054
2055                                 if ( handler.guid === handleObj.guid ) {
2056                                         // remove the given handler for the given type
2057                                         if ( all || namespace.test( handleObj.namespace ) ) {
2058                                                 if ( pos == null ) {
2059                                                         eventType.splice( j--, 1 );
2060                                                 }
2061
2062                                                 if ( special.remove ) {
2063                                                         special.remove.call( elem, handleObj );
2064                                                 }
2065                                         }
2066
2067                                         if ( pos != null ) {
2068                                                 break;
2069                                         }
2070                                 }
2071                         }
2072
2073                         // remove generic event handler if no more handlers exist
2074                         if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2075                                 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2076                                         jQuery.removeEvent( elem, type, elemData.handle );
2077                                 }
2078
2079                                 ret = null;
2080                                 delete events[ type ];
2081                         }
2082                 }
2083
2084                 // Remove the expando if it's no longer used
2085                 if ( jQuery.isEmptyObject( events ) ) {
2086                         var handle = elemData.handle;
2087                         if ( handle ) {
2088                                 handle.elem = null;
2089                         }
2090
2091                         delete elemData.events;
2092                         delete elemData.handle;
2093
2094                         if ( typeof elemData === "function" ) {
2095                                 jQuery.removeData( elem, eventKey );
2096
2097                         } else if ( jQuery.isEmptyObject( elemData ) ) {
2098                                 jQuery.removeData( elem );
2099                         }
2100                 }
2101         },
2102
2103         // bubbling is internal
2104         trigger: function( event, data, elem /*, bubbling */ ) {
2105                 // Event object or event type
2106                 var type = event.type || event,
2107                         bubbling = arguments[3];
2108
2109                 if ( !bubbling ) {
2110                         event = typeof event === "object" ?
2111                                 // jQuery.Event object
2112                                 event[ jQuery.expando ] ? event :
2113                                 // Object literal
2114                                 jQuery.extend( jQuery.Event(type), event ) :
2115                                 // Just the event type (string)
2116                                 jQuery.Event(type);
2117
2118                         if ( type.indexOf("!") >= 0 ) {
2119                                 event.type = type = type.slice(0, -1);
2120                                 event.exclusive = true;
2121                         }
2122
2123                         // Handle a global trigger
2124                         if ( !elem ) {
2125                                 // Don't bubble custom events when global (to avoid too much overhead)
2126                                 event.stopPropagation();
2127
2128                                 // Only trigger if we've ever bound an event for it
2129                                 if ( jQuery.event.global[ type ] ) {
2130                                         jQuery.each( jQuery.cache, function() {
2131                                                 if ( this.events && this.events[type] ) {
2132                                                         jQuery.event.trigger( event, data, this.handle.elem );
2133                                                 }
2134                                         });
2135                                 }
2136                         }
2137
2138                         // Handle triggering a single element
2139
2140                         // don't do events on text and comment nodes
2141                         if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
2142                                 return undefined;
2143                         }
2144
2145                         // Clean up in case it is reused
2146                         event.result = undefined;
2147                         event.target = elem;
2148
2149                         // Clone the incoming data, if any
2150                         data = jQuery.makeArray( data );
2151                         data.unshift( event );
2152                 }
2153
2154                 event.currentTarget = elem;
2155
2156                 // Trigger the event, it is assumed that "handle" is a function
2157                 var handle = elem.nodeType ?
2158                         jQuery.data( elem, "handle" ) :
2159                         (jQuery.data( elem, "__events__" ) || {}).handle;
2160
2161                 if ( handle ) {
2162                         handle.apply( elem, data );
2163                 }
2164
2165                 var parent = elem.parentNode || elem.ownerDocument;
2166
2167                 // Trigger an inline bound script
2168                 try {
2169                         if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
2170                                 if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
2171                                         event.result = false;
2172                                         event.preventDefault();
2173                                 }
2174                         }
2175
2176                 // prevent IE from throwing an error for some elements with some event types, see #3533
2177                 } catch (inlineError) {}
2178
2179                 if ( !event.isPropagationStopped() && parent ) {
2180                         jQuery.event.trigger( event, data, parent, true );
2181
2182                 } else if ( !event.isDefaultPrevented() ) {
2183                         var old,
2184                                 target = event.target,
2185                                 targetType = type.replace( rnamespaces, "" ),
2186                                 isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
2187                                 special = jQuery.event.special[ targetType ] || {};
2188
2189                         if ( (!special._default || special._default.call( elem, event ) === false) &&
2190                                 !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
2191
2192                                 try {
2193                                         if ( target[ targetType ] ) {
2194                                                 // Make sure that we don't accidentally re-trigger the onFOO events
2195                                                 old = target[ "on" + targetType ];
2196
2197                                                 if ( old ) {
2198                                                         target[ "on" + targetType ] = null;
2199                                                 }
2200
2201                                                 jQuery.event.triggered = true;
2202                                                 target[ targetType ]();
2203                                         }
2204
2205                                 // prevent IE from throwing an error for some elements with some event types, see #3533
2206                                 } catch (triggerError) {}
2207
2208                                 if ( old ) {
2209                                         target[ "on" + targetType ] = old;
2210                                 }
2211
2212                                 jQuery.event.triggered = false;
2213                         }
2214                 }
2215         },
2216
2217         handle: function( event ) {
2218                 var all, handlers, namespaces, namespace_re, events,
2219                         namespace_sort = [],
2220                         args = jQuery.makeArray( arguments );
2221
2222                 event = args[0] = jQuery.event.fix( event || window.event );
2223                 event.currentTarget = this;
2224
2225                 // Namespaced event handlers
2226                 all = event.type.indexOf(".") < 0 && !event.exclusive;
2227
2228                 if ( !all ) {
2229                         namespaces = event.type.split(".");
2230                         event.type = namespaces.shift();
2231                         namespace_sort = namespaces.slice(0).sort();
2232                         namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
2233                 }
2234
2235                 event.namespace = event.namespace || namespace_sort.join(".");
2236
2237                 events = jQuery.data(this, this.nodeType ? "events" : "__events__");
2238
2239                 if ( typeof events === "function" ) {
2240                         events = events.events;
2241                 }
2242
2243                 handlers = (events || {})[ event.type ];
2244
2245                 if ( events && handlers ) {
2246                         // Clone the handlers to prevent manipulation
2247                         handlers = handlers.slice(0);
2248
2249                         for ( var j = 0, l = handlers.length; j < l; j++ ) {
2250                                 var handleObj = handlers[ j ];
2251
2252                                 // Filter the functions by class
2253                                 if ( all || namespace_re.test( handleObj.namespace ) ) {
2254                                         // Pass in a reference to the handler function itself
2255                                         // So that we can later remove it
2256                                         event.handler = handleObj.handler;
2257                                         event.data = handleObj.data;
2258                                         event.handleObj = handleObj;
2259
2260                                         var ret = handleObj.handler.apply( this, args );
2261
2262                                         if ( ret !== undefined ) {
2263                                                 event.result = ret;
2264                                                 if ( ret === false ) {
2265                                                         event.preventDefault();
2266                                                         event.stopPropagation();
2267                                                 }
2268                                         }
2269
2270                                         if ( event.isImmediatePropagationStopped() ) {
2271                                                 break;
2272                                         }
2273                                 }
2274                         }
2275                 }
2276
2277                 return event.result;
2278         },
2279
2280         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(" "),
2281
2282         fix: function( event ) {
2283                 if ( event[ jQuery.expando ] ) {
2284                         return event;
2285                 }
2286
2287                 // store a copy of the original event object
2288                 // and "clone" to set read-only properties
2289                 var originalEvent = event;
2290                 event = jQuery.Event( originalEvent );
2291
2292                 for ( var i = this.props.length, prop; i; ) {
2293                         prop = this.props[ --i ];
2294                         event[ prop ] = originalEvent[ prop ];
2295                 }
2296
2297                 // Fix target property, if necessary
2298                 if ( !event.target ) {
2299                         // Fixes #1925 where srcElement might not be defined either
2300                         event.target = event.srcElement || document;
2301                 }
2302
2303                 // check if target is a textnode (safari)
2304                 if ( event.target.nodeType === 3 ) {
2305                         event.target = event.target.parentNode;
2306                 }
2307
2308                 // Add relatedTarget, if necessary
2309                 if ( !event.relatedTarget && event.fromElement ) {
2310                         event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2311                 }
2312
2313                 // Calculate pageX/Y if missing and clientX/Y available
2314                 if ( event.pageX == null && event.clientX != null ) {
2315                         var doc = document.documentElement,
2316                                 body = document.body;
2317
2318                         event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2319                         event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
2320                 }
2321
2322                 // Add which for key events
2323                 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2324                         event.which = event.charCode != null ? event.charCode : event.keyCode;
2325                 }
2326
2327                 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2328                 if ( !event.metaKey && event.ctrlKey ) {
2329                         event.metaKey = event.ctrlKey;
2330                 }
2331
2332                 // Add which for click: 1 === left; 2 === middle; 3 === right
2333                 // Note: button is not normalized, so don't use it
2334                 if ( !event.which && event.button !== undefined ) {
2335                         event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2336                 }
2337
2338                 return event;
2339         },
2340
2341         // Deprecated, use jQuery.guid instead
2342         guid: 1E8,
2343
2344         // Deprecated, use jQuery.proxy instead
2345         proxy: jQuery.proxy,
2346
2347         special: {
2348                 ready: {
2349                         // Make sure the ready event is setup
2350                         setup: jQuery.bindReady,
2351                         teardown: jQuery.noop
2352                 },
2353
2354                 live: {
2355                         add: function( handleObj ) {
2356                                 jQuery.event.add( this,
2357                                         liveConvert( handleObj.origType, handleObj.selector ),
2358                                         jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
2359                         },
2360
2361                         remove: function( handleObj ) {
2362                                 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
2363                         }
2364                 },
2365
2366                 beforeunload: {
2367                         setup: function( data, namespaces, eventHandle ) {
2368                                 // We only want to do this special case on windows
2369                                 if ( jQuery.isWindow( this ) ) {
2370                                         this.onbeforeunload = eventHandle;
2371                                 }
2372                         },
2373
2374                         teardown: function( namespaces, eventHandle ) {
2375                                 if ( this.onbeforeunload === eventHandle ) {
2376                                         this.onbeforeunload = null;
2377                                 }
2378                         }
2379                 }
2380         }
2381 };
2382
2383 jQuery.removeEvent = document.removeEventListener ?
2384         function( elem, type, handle ) {
2385                 if ( elem.removeEventListener ) {
2386                         elem.removeEventListener( type, handle, false );
2387                 }
2388         } :
2389         function( elem, type, handle ) {
2390                 if ( elem.detachEvent ) {
2391                         elem.detachEvent( "on" + type, handle );
2392                 }
2393         };
2394
2395 jQuery.Event = function( src ) {
2396         // Allow instantiation without the 'new' keyword
2397         if ( !this.preventDefault ) {
2398                 return new jQuery.Event( src );
2399         }
2400
2401         // Event object
2402         if ( src && src.type ) {
2403                 this.originalEvent = src;
2404                 this.type = src.type;
2405         // Event type
2406         } else {
2407                 this.type = src;
2408         }
2409
2410         // timeStamp is buggy for some events on Firefox(#3843)
2411         // So we won't rely on the native value
2412         this.timeStamp = jQuery.now();
2413
2414         // Mark it as fixed
2415         this[ jQuery.expando ] = true;
2416 };
2417
2418 function returnFalse() {
2419         return false;
2420 }
2421 function returnTrue() {
2422         return true;
2423 }
2424
2425 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2426 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2427 jQuery.Event.prototype = {
2428         preventDefault: function() {
2429                 this.isDefaultPrevented = returnTrue;
2430
2431                 var e = this.originalEvent;
2432                 if ( !e ) {
2433                         return;
2434                 }
2435
2436                 // if preventDefault exists run it on the original event
2437                 if ( e.preventDefault ) {
2438                         e.preventDefault();
2439
2440                 // otherwise set the returnValue property of the original event to false (IE)
2441                 } else {
2442                         e.returnValue = false;
2443                 }
2444         },
2445         stopPropagation: function() {
2446                 this.isPropagationStopped = returnTrue;
2447
2448                 var e = this.originalEvent;
2449                 if ( !e ) {
2450                         return;
2451                 }
2452                 // if stopPropagation exists run it on the original event
2453                 if ( e.stopPropagation ) {
2454                         e.stopPropagation();
2455                 }
2456                 // otherwise set the cancelBubble property of the original event to true (IE)
2457                 e.cancelBubble = true;
2458         },
2459         stopImmediatePropagation: function() {
2460                 this.isImmediatePropagationStopped = returnTrue;
2461                 this.stopPropagation();
2462         },
2463         isDefaultPrevented: returnFalse,
2464         isPropagationStopped: returnFalse,
2465         isImmediatePropagationStopped: returnFalse
2466 };
2467
2468 // Checks if an event happened on an element within another element
2469 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2470 var withinElement = function( event ) {
2471         // Check if mouse(over|out) are still within the same parent element
2472         var parent = event.relatedTarget;
2473
2474         // Firefox sometimes assigns relatedTarget a XUL element
2475         // which we cannot access the parentNode property of
2476         try {
2477                 // Traverse up the tree
2478                 while ( parent && parent !== this ) {
2479                         parent = parent.parentNode;
2480                 }
2481
2482                 if ( parent !== this ) {
2483                         // set the correct event type
2484                         event.type = event.data;
2485
2486                         // handle event if we actually just moused on to a non sub-element
2487                         jQuery.event.handle.apply( this, arguments );
2488                 }
2489
2490         // assuming we've left the element since we most likely mousedover a xul element
2491         } catch(e) { }
2492 },
2493
2494 // In case of event delegation, we only need to rename the event.type,
2495 // liveHandler will take care of the rest.
2496 delegate = function( event ) {
2497         event.type = event.data;
2498         jQuery.event.handle.apply( this, arguments );
2499 };
2500
2501 // Create mouseenter and mouseleave events
2502 jQuery.each({
2503         mouseenter: "mouseover",
2504         mouseleave: "mouseout"
2505 }, function( orig, fix ) {
2506         jQuery.event.special[ orig ] = {
2507                 setup: function( data ) {
2508                         jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2509                 },
2510                 teardown: function( data ) {
2511                         jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2512                 }
2513         };
2514 });
2515
2516 // submit delegation
2517 if ( !jQuery.support.submitBubbles ) {
2518
2519         jQuery.event.special.submit = {
2520                 setup: function( data, namespaces ) {
2521                         if ( this.nodeName.toLowerCase() !== "form" ) {
2522                                 jQuery.event.add(this, "click.specialSubmit", function( e ) {
2523                                         var elem = e.target,
2524                                                 type = elem.type;
2525
2526                                         if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2527                                                 e.liveFired = undefined;
2528                                                 return trigger( "submit", this, arguments );
2529                                         }
2530                                 });
2531
2532                                 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
2533                                         var elem = e.target,
2534                                                 type = elem.type;
2535
2536                                         if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2537                                                 e.liveFired = undefined;
2538                                                 return trigger( "submit", this, arguments );
2539                                         }
2540                                 });
2541
2542                         } else {
2543                                 return false;
2544                         }
2545                 },
2546
2547                 teardown: function( namespaces ) {
2548                         jQuery.event.remove( this, ".specialSubmit" );
2549                 }
2550         };
2551
2552 }
2553
2554 // change delegation, happens here so we have bind.
2555 if ( !jQuery.support.changeBubbles ) {
2556
2557         var changeFilters,
2558
2559         getVal = function( elem ) {
2560                 var type = elem.type, val = elem.value;
2561
2562                 if ( type === "radio" || type === "checkbox" ) {
2563                         val = elem.checked;
2564
2565                 } else if ( type === "select-multiple" ) {
2566                         val = elem.selectedIndex > -1 ?
2567                                 jQuery.map( elem.options, function( elem ) {
2568                                         return elem.selected;
2569                                 }).join("-") :
2570                                 "";
2571
2572                 } else if ( elem.nodeName.toLowerCase() === "select" ) {
2573                         val = elem.selectedIndex;
2574                 }
2575
2576                 return val;
2577         },
2578
2579         testChange = function testChange( e ) {
2580                 var elem = e.target, data, val;
2581
2582                 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
2583                         return;
2584                 }
2585
2586                 data = jQuery.data( elem, "_change_data" );
2587                 val = getVal(elem);
2588
2589                 // the current data will be also retrieved by beforeactivate
2590                 if ( e.type !== "focusout" || elem.type !== "radio" ) {
2591                         jQuery.data( elem, "_change_data", val );
2592                 }
2593
2594                 if ( data === undefined || val === data ) {
2595                         return;
2596                 }
2597
2598                 if ( data != null || val ) {
2599                         e.type = "change";
2600                         e.liveFired = undefined;
2601                         return jQuery.event.trigger( e, arguments[1], elem );
2602                 }
2603         };
2604
2605         jQuery.event.special.change = {
2606                 filters: {
2607                         focusout: testChange,
2608
2609                         beforedeactivate: testChange,
2610
2611                         click: function( e ) {
2612                                 var elem = e.target, type = elem.type;
2613
2614                                 if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2615                                         return testChange.call( this, e );
2616                                 }
2617                         },
2618
2619                         // Change has to be called before submit
2620                         // Keydown will be called before keypress, which is used in submit-event delegation
2621                         keydown: function( e ) {
2622                                 var elem = e.target, type = elem.type;
2623
2624                                 if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2625                                         (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2626                                         type === "select-multiple" ) {
2627                                         return testChange.call( this, e );
2628                                 }
2629                         },
2630
2631                         // Beforeactivate happens also before the previous element is blurred
2632                         // with this event you can't trigger a change event, but you can store
2633                         // information
2634                         beforeactivate: function( e ) {
2635                                 var elem = e.target;
2636                                 jQuery.data( elem, "_change_data", getVal(elem) );
2637                         }
2638                 },
2639
2640                 setup: function( data, namespaces ) {
2641                         if ( this.type === "file" ) {
2642                                 return false;
2643                         }
2644
2645                         for ( var type in changeFilters ) {
2646                                 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
2647                         }
2648
2649                         return rformElems.test( this.nodeName );
2650                 },
2651
2652                 teardown: function( namespaces ) {
2653                         jQuery.event.remove( this, ".specialChange" );
2654
2655                         return rformElems.test( this.nodeName );
2656                 }
2657         };
2658
2659         changeFilters = jQuery.event.special.change.filters;
2660
2661         // Handle when the input is .focus()'d
2662         changeFilters.focus = changeFilters.beforeactivate;
2663 }
2664
2665 function trigger( type, elem, args ) {
2666         args[0].type = type;
2667         return jQuery.event.handle.apply( elem, args );
2668 }
2669
2670 // Create "bubbling" focus and blur events
2671 if ( document.addEventListener ) {
2672         jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2673                 jQuery.event.special[ fix ] = {
2674                         setup: function() {
2675                                 if ( focusCounts[fix]++ === 0 ) {
2676                                         document.addEventListener( orig, handler, true );
2677                                 }
2678                         },
2679                         teardown: function() {
2680                                 if ( --focusCounts[fix] === 0 ) {
2681                                         document.removeEventListener( orig, handler, true );
2682                                 }
2683                         }
2684                 };
2685
2686                 function handler( e ) {
2687                         e = jQuery.event.fix( e );
2688                         e.type = fix;
2689                         return jQuery.event.trigger( e, null, e.target );
2690                 }
2691         });
2692 }
2693
2694 jQuery.each(["bind", "one"], function( i, name ) {
2695         jQuery.fn[ name ] = function( type, data, fn ) {
2696                 // Handle object literals
2697                 if ( typeof type === "object" ) {
2698                         for ( var key in type ) {
2699                                 this[ name ](key, data, type[key], fn);
2700                         }
2701                         return this;
2702                 }
2703
2704                 if ( jQuery.isFunction( data ) || data === false ) {
2705                         fn = data;
2706                         data = undefined;
2707                 }
2708
2709                 var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2710                         jQuery( this ).unbind( event, handler );
2711                         return fn.apply( this, arguments );
2712                 }) : fn;
2713
2714                 if ( type === "unload" && name !== "one" ) {
2715                         this.one( type, data, fn );
2716
2717                 } else {
2718                         for ( var i = 0, l = this.length; i < l; i++ ) {
2719                                 jQuery.event.add( this[i], type, handler, data );
2720                         }
2721                 }
2722
2723                 return this;
2724         };
2725 });
2726
2727 jQuery.fn.extend({
2728         unbind: function( type, fn ) {
2729                 // Handle object literals
2730                 if ( typeof type === "object" && !type.preventDefault ) {
2731                         for ( var key in type ) {
2732                                 this.unbind(key, type[key]);
2733                         }
2734
2735                 } else {
2736                         for ( var i = 0, l = this.length; i < l; i++ ) {
2737                                 jQuery.event.remove( this[i], type, fn );
2738                         }
2739                 }
2740
2741                 return this;
2742         },
2743
2744         delegate: function( selector, types, data, fn ) {
2745                 return this.live( types, data, fn, selector );
2746         },
2747
2748         undelegate: function( selector, types, fn ) {
2749                 if ( arguments.length === 0 ) {
2750                                 return this.unbind( "live" );
2751
2752                 } else {
2753                         return this.die( types, null, fn, selector );
2754                 }
2755         },
2756
2757         trigger: function( type, data ) {
2758                 return this.each(function() {
2759                         jQuery.event.trigger( type, data, this );
2760                 });
2761         },
2762
2763         triggerHandler: function( type, data ) {
2764                 if ( this[0] ) {
2765                         var event = jQuery.Event( type );
2766                         event.preventDefault();
2767                         event.stopPropagation();
2768                         jQuery.event.trigger( event, data, this[0] );
2769                         return event.result;
2770                 }
2771         },
2772
2773         toggle: function( fn ) {
2774                 // Save reference to arguments for access in closure
2775                 var args = arguments,
2776                         i = 1;
2777
2778                 // link all the functions, so any of them can unbind this click handler
2779                 while ( i < args.length ) {
2780                         jQuery.proxy( fn, args[ i++ ] );
2781                 }
2782
2783                 return this.click( jQuery.proxy( fn, function( event ) {
2784                         // Figure out which function to execute
2785                         var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2786                         jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2787
2788                         // Make sure that clicks stop
2789                         event.preventDefault();
2790
2791                         // and execute the function
2792                         return args[ lastToggle ].apply( this, arguments ) || false;
2793                 }));
2794         },
2795
2796         hover: function( fnOver, fnOut ) {
2797                 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2798         }
2799 });
2800
2801 var liveMap = {
2802         focus: "focusin",
2803         blur: "focusout",
2804         mouseenter: "mouseover",
2805         mouseleave: "mouseout"
2806 };
2807
2808 jQuery.each(["live", "die"], function( i, name ) {
2809         jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
2810                 var type, i = 0, match, namespaces, preType,
2811                         selector = origSelector || this.selector,
2812                         context = origSelector ? this : jQuery( this.context );
2813
2814                 if ( typeof types === "object" && !types.preventDefault ) {
2815                         for ( var key in types ) {
2816                                 context[ name ]( key, data, types[key], selector );
2817                         }
2818
2819                         return this;
2820                 }
2821
2822                 if ( jQuery.isFunction( data ) ) {
2823                         fn = data;
2824                         data = undefined;
2825                 }
2826
2827                 types = (types || "").split(" ");
2828
2829                 while ( (type = types[ i++ ]) != null ) {
2830                         match = rnamespaces.exec( type );
2831                         namespaces = "";
2832
2833                         if ( match )  {
2834                                 namespaces = match[0];
2835                                 type = type.replace( rnamespaces, "" );
2836                         }
2837
2838                         if ( type === "hover" ) {
2839                                 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
2840                                 continue;
2841                         }
2842
2843                         preType = type;
2844
2845                         if ( type === "focus" || type === "blur" ) {
2846                                 types.push( liveMap[ type ] + namespaces );
2847                                 type = type + namespaces;
2848
2849                         } else {
2850                                 type = (liveMap[ type ] || type) + namespaces;
2851                         }
2852
2853                         if ( name === "live" ) {
2854                                 // bind live handler
2855                                 for ( var j = 0, l = context.length; j < l; j++ ) {
2856                                         jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
2857                                                 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
2858                                 }
2859
2860                         } else {
2861                                 // unbind live handler
2862                                 context.unbind( "live." + liveConvert( type, selector ), fn );
2863                         }
2864                 }
2865
2866                 return this;
2867         };
2868 });
2869
2870 function liveHandler( event ) {
2871         var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
2872                 elems = [],
2873                 selectors = [],
2874                 events = jQuery.data( this, this.nodeType ? "events" : "__events__" );
2875
2876         if ( typeof events === "function" ) {
2877                 events = events.events;
2878         }
2879
2880         // Make sure we avoid non-left-click bubbling in Firefox (#3861)
2881         if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
2882                 return;
2883         }
2884
2885         if ( event.namespace ) {
2886                 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
2887         }
2888
2889         event.liveFired = this;
2890
2891         var live = events.live.slice(0);
2892
2893         for ( j = 0; j < live.length; j++ ) {
2894                 handleObj = live[j];
2895
2896                 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
2897                         selectors.push( handleObj.selector );
2898
2899                 } else {
2900                         live.splice( j--, 1 );
2901                 }
2902         }
2903
2904         match = jQuery( event.target ).closest( selectors, event.currentTarget );
2905
2906         for ( i = 0, l = match.length; i < l; i++ ) {
2907                 close = match[i];
2908
2909                 for ( j = 0; j < live.length; j++ ) {
2910                         handleObj = live[j];
2911
2912                         if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) {
2913                                 elem = close.elem;
2914                                 related = null;
2915
2916                                 // Those two events require additional checking
2917                                 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
2918                                         event.type = handleObj.preType;
2919                                         related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
2920                                 }
2921
2922                                 if ( !related || related !== elem ) {
2923                                         elems.push({ elem: elem, handleObj: handleObj, level: close.level });
2924                                 }
2925                         }
2926                 }
2927         }
2928
2929         for ( i = 0, l = elems.length; i < l; i++ ) {
2930                 match = elems[i];
2931
2932                 if ( maxLevel && match.level > maxLevel ) {
2933                         break;
2934                 }
2935
2936                 event.currentTarget = match.elem;
2937                 event.data = match.handleObj.data;
2938                 event.handleObj = match.handleObj;
2939
2940                 ret = match.handleObj.origHandler.apply( match.elem, arguments );
2941
2942                 if ( ret === false || event.isPropagationStopped() ) {
2943                         maxLevel = match.level;
2944
2945                         if ( ret === false ) {
2946                                 stop = false;
2947                         }
2948                         if ( event.isImmediatePropagationStopped() ) {
2949                                 break;
2950                         }
2951                 }
2952         }
2953
2954         return stop;
2955 }
2956
2957 function liveConvert( type, selector ) {
2958         return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
2959 }
2960
2961 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2962         "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2963         "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2964
2965         // Handle event binding
2966         jQuery.fn[ name ] = function( data, fn ) {
2967                 if ( fn == null ) {
2968                         fn = data;
2969                         data = null;
2970                 }
2971
2972                 return arguments.length > 0 ?
2973                         this.bind( name, data, fn ) :
2974                         this.trigger( name );
2975         };
2976
2977         if ( jQuery.attrFn ) {
2978                 jQuery.attrFn[ name ] = true;
2979         }
2980 });
2981
2982 // Prevent memory leaks in IE
2983 // Window isn't included so as not to unbind existing unload events
2984 // More info:
2985 //  - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2986 if ( window.attachEvent && !window.addEventListener ) {
2987         jQuery(window).bind("unload", function() {
2988                 for ( var id in jQuery.cache ) {
2989                         if ( jQuery.cache[ id ].handle ) {
2990                                 // Try/Catch is to handle iframes being unloaded, see #4280
2991                                 try {
2992                                         jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2993                                 } catch(e) {}
2994                         }
2995                 }
2996         });
2997 }
2998
2999
3000 /*!
3001  * Sizzle CSS Selector Engine - v1.0
3002  *  Copyright 2009, The Dojo Foundation
3003  *  Released under the MIT, BSD, and GPL Licenses.
3004  *  More information: http://sizzlejs.com/
3005  */
3006 (function(){
3007
3008 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3009         done = 0,
3010         toString = Object.prototype.toString,
3011         hasDuplicate = false,
3012         baseHasDuplicate = true;
3013
3014 // Here we check if the JavaScript engine is using some sort of
3015 // optimization where it does not always call our comparision
3016 // function. If that is the case, discard the hasDuplicate value.
3017 //   Thus far that includes Google Chrome.
3018 [0, 0].sort(function() {
3019         baseHasDuplicate = false;
3020         return 0;
3021 });
3022
3023 var Sizzle = function( selector, context, results, seed ) {
3024         results = results || [];
3025         context = context || document;
3026
3027         var origContext = context;
3028
3029         if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3030                 return [];
3031         }
3032
3033         if ( !selector || typeof selector !== "string" ) {
3034                 return results;
3035         }
3036
3037         var m, set, checkSet, extra, ret, cur, pop, i,
3038                 prune = true,
3039                 contextXML = Sizzle.isXML( context ),
3040                 parts = [],
3041                 soFar = selector;
3042
3043         // Reset the position of the chunker regexp (start from head)
3044         do {
3045                 chunker.exec( "" );
3046                 m = chunker.exec( soFar );
3047
3048                 if ( m ) {
3049                         soFar = m[3];
3050
3051                         parts.push( m[1] );
3052
3053                         if ( m[2] ) {
3054                                 extra = m[3];
3055                                 break;
3056                         }
3057                 }
3058         } while ( m );
3059
3060         if ( parts.length > 1 && origPOS.exec( selector ) ) {
3061
3062                 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3063                         set = posProcess( parts[0] + parts[1], context );
3064
3065                 } else {
3066                         set = Expr.relative[ parts[0] ] ?
3067                                 [ context ] :
3068                                 Sizzle( parts.shift(), context );
3069
3070                         while ( parts.length ) {
3071                                 selector = parts.shift();
3072
3073                                 if ( Expr.relative[ selector ] ) {
3074                                         selector += parts.shift();
3075                                 }
3076
3077                                 set = posProcess( selector, set );
3078                         }
3079                 }
3080
3081         } else {
3082                 // Take a shortcut and set the context if the root selector is an ID
3083                 // (but not if it'll be faster if the inner selector is an ID)
3084                 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3085                                 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3086
3087                         ret = Sizzle.find( parts.shift(), context, contextXML );
3088                         context = ret.expr ?
3089                                 Sizzle.filter( ret.expr, ret.set )[0] :
3090                                 ret.set[0];
3091                 }
3092
3093                 if ( context ) {
3094                         ret = seed ?
3095                                 { expr: parts.pop(), set: makeArray(seed) } :
3096                                 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3097
3098                         set = ret.expr ?
3099                                 Sizzle.filter( ret.expr, ret.set ) :
3100                                 ret.set;
3101
3102                         if ( parts.length > 0 ) {
3103                                 checkSet = makeArray( set );
3104
3105                         } else {
3106                                 prune = false;
3107                         }
3108
3109                         while ( parts.length ) {
3110                                 cur = parts.pop();
3111                                 pop = cur;
3112
3113                                 if ( !Expr.relative[ cur ] ) {
3114                                         cur = "";
3115                                 } else {
3116                                         pop = parts.pop();
3117                                 }
3118
3119                                 if ( pop == null ) {
3120                                         pop = context;
3121                                 }
3122
3123                                 Expr.relative[ cur ]( checkSet, pop, contextXML );
3124                         }
3125
3126                 } else {
3127                         checkSet = parts = [];
3128                 }
3129         }
3130
3131         if ( !checkSet ) {
3132                 checkSet = set;
3133         }
3134
3135         if ( !checkSet ) {
3136                 Sizzle.error( cur || selector );
3137         }
3138
3139         if ( toString.call(checkSet) === "[object Array]" ) {
3140                 if ( !prune ) {
3141                         results.push.apply( results, checkSet );
3142
3143                 } else if ( context && context.nodeType === 1 ) {
3144                         for ( i = 0; checkSet[i] != null; i++ ) {
3145                                 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3146                                         results.push( set[i] );
3147                                 }
3148                         }
3149
3150                 } else {
3151                         for ( i = 0; checkSet[i] != null; i++ ) {
3152                                 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3153                                         results.push( set[i] );
3154                                 }
3155                         }
3156                 }
3157
3158         } else {
3159                 makeArray( checkSet, results );
3160         }
3161
3162         if ( extra ) {
3163                 Sizzle( extra, origContext, results, seed );
3164                 Sizzle.uniqueSort( results );
3165         }
3166
3167         return results;
3168 };
3169
3170 Sizzle.uniqueSort = function( results ) {
3171         if ( sortOrder ) {
3172                 hasDuplicate = baseHasDuplicate;
3173                 results.sort( sortOrder );
3174
3175                 if ( hasDuplicate ) {
3176                         for ( var i = 1; i < results.length; i++ ) {
3177                                 if ( results[i] === results[ i - 1 ] ) {
3178                                         results.splice( i--, 1 );
3179                                 }
3180                         }
3181                 }
3182         }
3183
3184         return results;
3185 };
3186
3187 Sizzle.matches = function( expr, set ) {
3188         return Sizzle( expr, null, null, set );
3189 };
3190
3191 Sizzle.matchesSelector = function( node, expr ) {
3192         return Sizzle( expr, null, null, [node] ).length > 0;
3193 };
3194
3195 Sizzle.find = function( expr, context, isXML ) {
3196         var set;
3197
3198         if ( !expr ) {
3199                 return [];
3200         }
3201
3202         for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3203                 var match,
3204                         type = Expr.order[i];
3205
3206                 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3207                         var left = match[1];
3208                         match.splice( 1, 1 );
3209
3210                         if ( left.substr( left.length - 1 ) !== "\\" ) {
3211                                 match[1] = (match[1] || "").replace(/\\/g, "");
3212                                 set = Expr.find[ type ]( match, context, isXML );
3213
3214                                 if ( set != null ) {
3215                                         expr = expr.replace( Expr.match[ type ], "" );
3216                                         break;
3217                                 }
3218                         }
3219                 }
3220         }
3221
3222         if ( !set ) {
3223                 set = context.getElementsByTagName( "*" );
3224         }
3225
3226         return { set: set, expr: expr };
3227 };
3228
3229 Sizzle.filter = function( expr, set, inplace, not ) {
3230         var match, anyFound,
3231                 old = expr,
3232                 result = [],
3233                 curLoop = set,
3234                 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
3235
3236         while ( expr && set.length ) {
3237                 for ( var type in Expr.filter ) {
3238                         if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3239                                 var found, item,
3240                                         filter = Expr.filter[ type ],
3241                                         left = match[1];
3242
3243                                 anyFound = false;
3244
3245                                 match.splice(1,1);
3246
3247                                 if ( left.substr( left.length - 1 ) === "\\" ) {
3248                                         continue;
3249                                 }
3250
3251                                 if ( curLoop === result ) {
3252                                         result = [];
3253                                 }
3254
3255                                 if ( Expr.preFilter[ type ] ) {
3256                                         match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3257
3258                                         if ( !match ) {
3259                                                 anyFound = found = true;
3260
3261                                         } else if ( match === true ) {
3262                                                 continue;
3263                                         }
3264                                 }
3265
3266                                 if ( match ) {
3267                                         for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
3268                                                 if ( item ) {
3269                                                         found = filter( item, match, i, curLoop );
3270                                                         var pass = not ^ !!found;
3271
3272                                                         if ( inplace && found != null ) {
3273                                                                 if ( pass ) {
3274                                                                         anyFound = true;
3275
3276                                                                 } else {
3277                                                                         curLoop[i] = false;
3278                                                                 }
3279
3280                                                         } else if ( pass ) {
3281                                                                 result.push( item );
3282                                                                 anyFound = true;
3283                                                         }
3284                                                 }
3285                                         }
3286                                 }
3287
3288                                 if ( found !== undefined ) {
3289                                         if ( !inplace ) {
3290                                                 curLoop = result;
3291                                         }
3292
3293                                         expr = expr.replace( Expr.match[ type ], "" );
3294
3295                                         if ( !anyFound ) {
3296                                                 return [];
3297                                         }
3298
3299                                         break;
3300                                 }
3301                         }
3302                 }
3303
3304                 // Improper expression
3305                 if ( expr === old ) {
3306                         if ( anyFound == null ) {
3307                                 Sizzle.error( expr );
3308
3309                         } else {
3310                                 break;
3311                         }
3312                 }
3313
3314                 old = expr;
3315         }
3316
3317         return curLoop;
3318 };
3319
3320 Sizzle.error = function( msg ) {
3321         throw "Syntax error, unrecognized expression: " + msg;
3322 };
3323
3324 var Expr = Sizzle.selectors = {
3325         order: [ "ID", "NAME", "TAG" ],
3326
3327         match: {
3328                 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3329                 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3330                 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
3331                 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
3332                 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
3333                 CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+\-]*)\))?/,
3334                 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
3335                 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
3336         },
3337
3338         leftMatch: {},
3339
3340         attrMap: {
3341                 "class": "className",
3342                 "for": "htmlFor"
3343         },
3344
3345         attrHandle: {
3346                 href: function( elem ) {
3347                         return elem.getAttribute( "href" );
3348                 }
3349         },
3350
3351         relative: {
3352                 "+": function(checkSet, part){
3353                         var isPartStr = typeof part === "string",
3354                                 isTag = isPartStr && !/\W/.test( part ),
3355                                 isPartStrNotTag = isPartStr && !isTag;
3356
3357                         if ( isTag ) {
3358                                 part = part.toLowerCase();
3359                         }
3360
3361                         for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
3362                                 if ( (elem = checkSet[i]) ) {
3363                                         while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
3364
3365                                         checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
3366                                                 elem || false :
3367                                                 elem === part;
3368                                 }
3369                         }
3370
3371                         if ( isPartStrNotTag ) {
3372                                 Sizzle.filter( part, checkSet, true );
3373                         }
3374                 },
3375
3376                 ">": function( checkSet, part ) {
3377                         var elem,
3378                                 isPartStr = typeof part === "string",
3379                                 i = 0,
3380                                 l = checkSet.length;
3381
3382                         if ( isPartStr && !/\W/.test( part ) ) {
3383                                 part = part.toLowerCase();
3384
3385                                 for ( ; i < l; i++ ) {
3386                                         elem = checkSet[i];
3387
3388                                         if ( elem ) {
3389                                                 var parent = elem.parentNode;
3390                                                 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
3391                                         }
3392                                 }
3393
3394                         } else {
3395                                 for ( ; i < l; i++ ) {
3396                                         elem = checkSet[i];
3397
3398                                         if ( elem ) {
3399                                                 checkSet[i] = isPartStr ?
3400                                                         elem.parentNode :
3401                                                         elem.parentNode === part;
3402                                         }
3403                                 }
3404
3405                                 if ( isPartStr ) {
3406                                         Sizzle.filter( part, checkSet, true );
3407                                 }
3408                         }
3409                 },
3410
3411                 "": function(checkSet, part, isXML){
3412                         var nodeCheck,
3413                                 doneName = done++,
3414                                 checkFn = dirCheck;
3415
3416                         if ( typeof part === "string" && !/\W/.test(part) ) {
3417                                 part = part.toLowerCase();
3418                                 nodeCheck = part;
3419                                 checkFn = dirNodeCheck;
3420                         }
3421
3422                         checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
3423                 },
3424
3425                 "~": function( checkSet, part, isXML ) {
3426                         var nodeCheck,
3427                                 doneName = done++,
3428                                 checkFn = dirCheck;
3429
3430                         if ( typeof part === "string" && !/\W/.test( part ) ) {
3431                                 part = part.toLowerCase();
3432                                 nodeCheck = part;
3433                                 checkFn = dirNodeCheck;
3434                         }
3435
3436                         checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
3437                 }
3438         },
3439
3440         find: {
3441                 ID: function( match, context, isXML ) {
3442                         if ( typeof context.getElementById !== "undefined" && !isXML ) {
3443                                 var m = context.getElementById(match[1]);
3444                                 // Check parentNode to catch when Blackberry 4.6 returns
3445                                 // nodes that are no longer in the document #6963
3446                                 return m && m.parentNode ? [m] : [];
3447                         }
3448                 },
3449
3450                 NAME: function( match, context ) {
3451                         if ( typeof context.getElementsByName !== "undefined" ) {
3452                                 var ret = [],
3453                                         results = context.getElementsByName( match[1] );
3454
3455                                 for ( var i = 0, l = results.length; i < l; i++ ) {
3456                                         if ( results[i].getAttribute("name") === match[1] ) {
3457                                                 ret.push( results[i] );
3458                                         }
3459                                 }
3460
3461                                 return ret.length === 0 ? null : ret;
3462                         }
3463                 },
3464
3465                 TAG: function( match, context ) {
3466                         return context.getElementsByTagName( match[1] );
3467                 }
3468         },
3469         preFilter: {
3470                 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
3471                         match = " " + match[1].replace(/\\/g, "") + " ";
3472
3473                         if ( isXML ) {
3474                                 return match;
3475                         }
3476
3477                         for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
3478                                 if ( elem ) {
3479                                         if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
3480                                                 if ( !inplace ) {
3481                                                         result.push( elem );
3482                                                 }
3483
3484                                         } else if ( inplace ) {
3485                                                 curLoop[i] = false;
3486                                         }
3487                                 }
3488                         }
3489
3490                         return false;
3491                 },
3492
3493                 ID: function( match ) {
3494                         return match[1].replace(/\\/g, "");
3495                 },
3496
3497                 TAG: function( match, curLoop ) {
3498                         return match[1].toLowerCase();
3499                 },
3500
3501                 CHILD: function( match ) {
3502                         if ( match[1] === "nth" ) {
3503                                 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3504                                 var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
3505                                         match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
3506                                         !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
3507
3508                                 // calculate the numbers (first)n+(last) including if they are negative
3509                                 match[2] = (test[1] + (test[2] || 1)) - 0;
3510                                 match[3] = test[3] - 0;
3511                         }
3512
3513                         // TODO: Move to normal caching system
3514                         match[0] = done++;
3515
3516                         return match;
3517                 },
3518
3519                 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
3520                         var name = match[1].replace(/\\/g, "");
3521
3522                         if ( !isXML && Expr.attrMap[name] ) {
3523                                 match[1] = Expr.attrMap[name];
3524                         }
3525
3526                         if ( match[2] === "~=" ) {
3527                                 match[4] = " " + match[4] + " ";
3528                         }
3529
3530                         return match;
3531                 },
3532
3533                 PSEUDO: function( match, curLoop, inplace, result, not ) {
3534                         if ( match[1] === "not" ) {
3535                                 // If we're dealing with a complex expression, or a simple one
3536                                 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3537                                         match[3] = Sizzle(match[3], null, null, curLoop);
3538
3539                                 } else {
3540                                         var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3541
3542                                         if ( !inplace ) {
3543                                                 result.push.apply( result, ret );
3544                                         }
3545
3546                                         return false;
3547                                 }
3548
3549                         } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3550                                 return true;
3551                         }
3552
3553                         return match;
3554                 },
3555
3556                 POS: function( match ) {
3557                         match.unshift( true );
3558
3559                         return match;
3560                 }
3561         },
3562
3563         filters: {
3564                 enabled: function( elem ) {
3565                         return elem.disabled === false && elem.type !== "hidden";
3566                 },
3567
3568                 disabled: function( elem ) {
3569                         return elem.disabled === true;
3570                 },
3571
3572                 checked: function( elem ) {
3573                         return elem.checked === true;
3574                 },
3575
3576                 selected: function( elem ) {
3577                         // Accessing this property makes selected-by-default
3578                         // options in Safari work properly
3579                         elem.parentNode.selectedIndex;
3580
3581                         return elem.selected === true;
3582                 },
3583
3584                 parent: function( elem ) {
3585                         return !!elem.firstChild;
3586                 },
3587
3588                 empty: function( elem ) {
3589                         return !elem.firstChild;
3590                 },
3591
3592                 has: function( elem, i, match ) {
3593                         return !!Sizzle( match[3], elem ).length;
3594                 },
3595
3596                 header: function( elem ) {
3597                         return (/h\d/i).test( elem.nodeName );
3598                 },
3599
3600                 text: function( elem ) {
3601                         return "text" === elem.type;
3602                 },
3603                 radio: function( elem ) {
3604                         return "radio" === elem.type;
3605                 },
3606
3607                 checkbox: function( elem ) {
3608                         return "checkbox" === elem.type;
3609                 },
3610
3611                 file: function( elem ) {
3612                         return "file" === elem.type;
3613                 },
3614                 password: function( elem ) {
3615                         return "password" === elem.type;
3616                 },
3617
3618                 submit: function( elem ) {
3619                         return "submit" === elem.type;
3620                 },
3621
3622                 image: function( elem ) {
3623                         return "image" === elem.type;
3624                 },
3625
3626                 reset: function( elem ) {
3627                         return "reset" === elem.type;
3628                 },
3629
3630                 button: function( elem ) {
3631                         return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3632                 },
3633
3634                 input: function( elem ) {
3635                         return (/input|select|textarea|button/i).test( elem.nodeName );
3636                 }
3637         },
3638         setFilters: {
3639                 first: function( elem, i ) {
3640                         return i === 0;
3641                 },
3642
3643                 last: function( elem, i, match, array ) {
3644                         return i === array.length - 1;
3645                 },
3646
3647                 even: function( elem, i ) {
3648                         return i % 2 === 0;
3649                 },
3650
3651                 odd: function( elem, i ) {
3652                         return i % 2 === 1;
3653                 },
3654
3655                 lt: function( elem, i, match ) {
3656                         return i < match[3] - 0;
3657                 },
3658
3659                 gt: function( elem, i, match ) {
3660                         return i > match[3] - 0;
3661                 },
3662
3663                 nth: function( elem, i, match ) {
3664                         return match[3] - 0 === i;
3665                 },
3666
3667                 eq: function( elem, i, match ) {
3668                         return match[3] - 0 === i;
3669                 }
3670         },
3671         filter: {
3672                 PSEUDO: function( elem, match, i, array ) {
3673                         var name = match[1],
3674                                 filter = Expr.filters[ name ];
3675
3676                         if ( filter ) {
3677                                 return filter( elem, i, match, array );
3678
3679                         } else if ( name === "contains" ) {
3680                                 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
3681
3682                         } else if ( name === "not" ) {
3683                                 var not = match[3];
3684
3685                                 for ( var j = 0, l = not.length; j < l; j++ ) {
3686                                         if ( not[j] === elem ) {
3687                                                 return false;
3688                                         }
3689                                 }
3690
3691                                 return true;
3692
3693                         } else {
3694                                 Sizzle.error( "Syntax error, unrecognized expression: " + name );
3695                         }
3696                 },
3697
3698                 CHILD: function( elem, match ) {
3699                         var type = match[1],
3700                                 node = elem;
3701
3702                         switch ( type ) {
3703                                 case "only":
3704                                 case "first":
3705                                         while ( (node = node.previousSibling) )  {
3706                                                 if ( node.nodeType === 1 ) {
3707                                                         return false;
3708                                                 }
3709                                         }
3710
3711                                         if ( type === "first" ) {
3712                                                 return true;
3713                                         }
3714
3715                                         node = elem;
3716
3717                                 case "last":
3718                                         while ( (node = node.nextSibling) )      {
3719                                                 if ( node.nodeType === 1 ) {
3720                                                         return false;
3721                                                 }
3722                                         }
3723
3724                                         return true;
3725
3726                                 case "nth":
3727                                         var first = match[2],
3728                                                 last = match[3];
3729
3730                                         if ( first === 1 && last === 0 ) {
3731                                                 return true;
3732                                         }
3733
3734                                         var doneName = match[0],
3735                                                 parent = elem.parentNode;
3736
3737                                         if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3738                                                 var count = 0;
3739
3740                                                 for ( node = parent.firstChild; node; node = node.nextSibling ) {
3741                                                         if ( node.nodeType === 1 ) {
3742                                                                 node.nodeIndex = ++count;
3743                                                         }
3744                                                 }
3745
3746                                                 parent.sizcache = doneName;
3747                                         }
3748
3749                                         var diff = elem.nodeIndex - last;
3750
3751                                         if ( first === 0 ) {
3752                                                 return diff === 0;
3753
3754                                         } else {
3755                                                 return ( diff % first === 0 && diff / first >= 0 );
3756                                         }
3757                         }
3758                 },
3759
3760                 ID: function( elem, match ) {
3761                         return elem.nodeType === 1 && elem.getAttribute("id") === match;
3762                 },
3763
3764                 TAG: function( elem, match ) {
3765                         return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3766                 },
3767
3768                 CLASS: function( elem, match ) {
3769                         return (" " + (elem.className || elem.getAttribute("class")) + " ")
3770                                 .indexOf( match ) > -1;
3771                 },
3772
3773                 ATTR: function( elem, match ) {
3774                         var name = match[1],
3775                                 result = Expr.attrHandle[ name ] ?
3776                                         Expr.attrHandle[ name ]( elem ) :
3777                                         elem[ name ] != null ?
3778                                                 elem[ name ] :
3779                                                 elem.getAttribute( name ),
3780                                 value = result + "",
3781                                 type = match[2],
3782                                 check = match[4];
3783
3784                         return result == null ?
3785                                 type === "!=" :
3786                                 type === "=" ?
3787                                 value === check :
3788                                 type === "*=" ?
3789                                 value.indexOf(check) >= 0 :
3790                                 type === "~=" ?
3791                                 (" " + value + " ").indexOf(check) >= 0 :
3792                                 !check ?
3793                                 value && result !== false :
3794                                 type === "!=" ?
3795                                 value !== check :
3796                                 type === "^=" ?
3797                                 value.indexOf(check) === 0 :
3798                                 type === "$=" ?
3799                                 value.substr(value.length - check.length) === check :
3800                                 type === "|=" ?
3801                                 value === check || value.substr(0, check.length + 1) === check + "-" :
3802                                 false;
3803                 },
3804
3805                 POS: function( elem, match, i, array ) {
3806                         var name = match[2],
3807                                 filter = Expr.setFilters[ name ];
3808
3809                         if ( filter ) {
3810                                 return filter( elem, i, match, array );
3811                         }
3812                 }
3813         }
3814 };
3815
3816 var origPOS = Expr.match.POS,
3817         fescape = function(all, num){
3818                 return "\\" + (num - 0 + 1);
3819         };
3820
3821 for ( var type in Expr.match ) {
3822         Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
3823         Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
3824 }
3825
3826 var makeArray = function( array, results ) {
3827         array = Array.prototype.slice.call( array, 0 );
3828
3829         if ( results ) {
3830                 results.push.apply( results, array );
3831                 return results;
3832         }
3833
3834         return array;
3835 };
3836
3837 // Perform a simple check to determine if the browser is capable of
3838 // converting a NodeList to an array using builtin methods.
3839 // Also verifies that the returned array holds DOM nodes
3840 // (which is not the case in the Blackberry browser)
3841 try {
3842         Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
3843
3844 // Provide a fallback method if it does not work
3845 } catch( e ) {
3846         makeArray = function( array, results ) {
3847                 var i = 0,
3848                         ret = results || [];
3849
3850                 if ( toString.call(array) === "[object Array]" ) {
3851                         Array.prototype.push.apply( ret, array );
3852
3853                 } else {
3854                         if ( typeof array.length === "number" ) {
3855                                 for ( var l = array.length; i < l; i++ ) {
3856                                         ret.push( array[i] );
3857                                 }
3858
3859                         } else {
3860                                 for ( ; array[i]; i++ ) {
3861                                         ret.push( array[i] );
3862                                 }
3863                         }
3864                 }
3865
3866                 return ret;
3867         };
3868 }
3869
3870 var sortOrder, siblingCheck;
3871
3872 if ( document.documentElement.compareDocumentPosition ) {
3873         sortOrder = function( a, b ) {
3874                 if ( a === b ) {
3875                         hasDuplicate = true;
3876                         return 0;
3877                 }
3878
3879                 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3880                         return a.compareDocumentPosition ? -1 : 1;
3881                 }
3882
3883                 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
3884         };
3885
3886 } else {
3887         sortOrder = function( a, b ) {
3888                 var al, bl,
3889                         ap = [],
3890                         bp = [],
3891                         aup = a.parentNode,
3892                         bup = b.parentNode,
3893                         cur = aup;
3894
3895                 // The nodes are identical, we can exit early
3896                 if ( a === b ) {
3897                         hasDuplicate = true;
3898                         return 0;
3899
3900                 // If the nodes are siblings (or identical) we can do a quick check
3901                 } else if ( aup === bup ) {
3902                         return siblingCheck( a, b );
3903
3904                 // If no parents were found then the nodes are disconnected
3905                 } else if ( !aup ) {
3906                         return -1;
3907
3908                 } else if ( !bup ) {
3909                         return 1;
3910                 }
3911
3912                 // Otherwise they're somewhere else in the tree so we need
3913                 // to build up a full list of the parentNodes for comparison
3914                 while ( cur ) {
3915                         ap.unshift( cur );
3916                         cur = cur.parentNode;
3917                 }
3918
3919                 cur = bup;
3920
3921                 while ( cur ) {
3922                         bp.unshift( cur );
3923                         cur = cur.parentNode;
3924                 }
3925
3926                 al = ap.length;
3927                 bl = bp.length;
3928
3929                 // Start walking down the tree looking for a discrepancy
3930                 for ( var i = 0; i < al && i < bl; i++ ) {
3931                         if ( ap[i] !== bp[i] ) {
3932                                 return siblingCheck( ap[i], bp[i] );
3933                         }
3934                 }
3935
3936                 // We ended someplace up the tree so do a sibling check
3937                 return i === al ?
3938                         siblingCheck( a, bp[i], -1 ) :
3939                         siblingCheck( ap[i], b, 1 );
3940         };
3941
3942         siblingCheck = function( a, b, ret ) {
3943                 if ( a === b ) {
3944                         return ret;
3945                 }
3946
3947                 var cur = a.nextSibling;
3948
3949                 while ( cur ) {
3950                         if ( cur === b ) {
3951                                 return -1;
3952                         }
3953
3954                         cur = cur.nextSibling;
3955                 }
3956
3957                 return 1;
3958         };
3959 }
3960
3961 // Utility function for retreiving the text value of an array of DOM nodes
3962 Sizzle.getText = function( elems ) {
3963         var ret = "", elem;
3964
3965         for ( var i = 0; elems[i]; i++ ) {
3966                 elem = elems[i];
3967
3968                 // Get the text from text nodes and CDATA nodes
3969                 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3970                         ret += elem.nodeValue;
3971
3972                 // Traverse everything else, except comment nodes
3973                 } else if ( elem.nodeType !== 8 ) {
3974                         ret += Sizzle.getText( elem.childNodes );
3975                 }
3976         }
3977
3978         return ret;
3979 };
3980
3981 // Check to see if the browser returns elements by name when
3982 // querying by getElementById (and provide a workaround)
3983 (function(){
3984         // We're going to inject a fake input element with a specified name
3985         var form = document.createElement("div"),
3986                 id = "script" + (new Date()).getTime(),
3987                 root = document.documentElement;
3988
3989         form.innerHTML = "<a name='" + id + "'/>";
3990
3991         // Inject it into the root element, check its status, and remove it quickly
3992         root.insertBefore( form, root.firstChild );
3993
3994         // The workaround has to do additional checks after a getElementById
3995         // Which slows things down for other browsers (hence the branching)
3996         if ( document.getElementById( id ) ) {
3997                 Expr.find.ID = function( match, context, isXML ) {
3998                         if ( typeof context.getElementById !== "undefined" && !isXML ) {
3999                                 var m = context.getElementById(match[1]);
4000
4001                                 return m ?
4002                                         m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4003                                                 [m] :
4004                                                 undefined :
4005                                         [];
4006                         }
4007                 };
4008
4009                 Expr.filter.ID = function( elem, match ) {
4010                         var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4011
4012                         return elem.nodeType === 1 && node && node.nodeValue === match;
4013                 };
4014         }
4015
4016         root.removeChild( form );
4017
4018         // release memory in IE
4019         root = form = null;
4020 })();
4021
4022 (function(){
4023         // Check to see if the browser returns only elements
4024         // when doing getElementsByTagName("*")
4025
4026         // Create a fake element
4027         var div = document.createElement("div");
4028         div.appendChild( document.createComment("") );
4029
4030         // Make sure no comments are found
4031         if ( div.getElementsByTagName("*").length > 0 ) {
4032                 Expr.find.TAG = function( match, context ) {
4033                         var results = context.getElementsByTagName( match[1] );
4034
4035                         // Filter out possible comments
4036                         if ( match[1] === "*" ) {
4037                                 var tmp = [];
4038
4039                                 for ( var i = 0; results[i]; i++ ) {
4040                                         if ( results[i].nodeType === 1 ) {
4041                                                 tmp.push( results[i] );
4042                                         }
4043                                 }
4044
4045                                 results = tmp;
4046                         }
4047
4048                         return results;
4049                 };
4050         }
4051
4052         // Check to see if an attribute returns normalized href attributes
4053         div.innerHTML = "<a href='#'></a>";
4054
4055         if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4056                         div.firstChild.getAttribute("href") !== "#" ) {
4057
4058                 Expr.attrHandle.href = function( elem ) {
4059                         return elem.getAttribute( "href", 2 );
4060                 };
4061         }
4062
4063         // release memory in IE
4064         div = null;
4065 })();
4066
4067 if ( document.querySelectorAll ) {
4068         (function(){
4069                 var oldSizzle = Sizzle,
4070                         div = document.createElement("div"),
4071                         id = "__sizzle__";
4072
4073                 div.innerHTML = "<p class='TEST'></p>";
4074
4075                 // Safari can't handle uppercase or unicode characters when
4076                 // in quirks mode.
4077                 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4078                         return;
4079                 }
4080
4081                 Sizzle = function( query, context, extra, seed ) {
4082                         context = context || document;
4083
4084                         // Make sure that attribute selectors are quoted
4085                         query = query.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4086
4087                         // Only use querySelectorAll on non-XML documents
4088                         // (ID selectors don't work in non-HTML documents)
4089                         if ( !seed && !Sizzle.isXML(context) ) {
4090                                 if ( context.nodeType === 9 ) {
4091                                         try {
4092                                                 return makeArray( context.querySelectorAll(query), extra );
4093                                         } catch(qsaError) {}
4094
4095                                 // qSA works strangely on Element-rooted queries
4096                                 // We can work around this by specifying an extra ID on the root
4097                                 // and working up from there (Thanks to Andrew Dupont for the technique)
4098                                 // IE 8 doesn't work on object elements
4099                                 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4100                                         var old = context.getAttribute( "id" ),
4101                                                 nid = old || id;
4102
4103                                         if ( !old ) {
4104                                                 context.setAttribute( "id", nid );
4105                                         }
4106
4107                                         try {
4108                                                 return makeArray( context.querySelectorAll( "#" + nid + " " + query ), extra );
4109
4110                                         } catch(pseudoError) {
4111                                         } finally {
4112                                                 if ( !old ) {
4113                                                         context.removeAttribute( "id" );
4114                                                 }
4115                                         }
4116                                 }
4117                         }
4118
4119                         return oldSizzle(query, context, extra, seed);
4120                 };
4121
4122                 for ( var prop in oldSizzle ) {
4123                         Sizzle[ prop ] = oldSizzle[ prop ];
4124                 }
4125
4126                 // release memory in IE
4127                 div = null;
4128         })();
4129 }
4130
4131 (function(){
4132         var html = document.documentElement,
4133                 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
4134                 pseudoWorks = false;
4135
4136         try {
4137                 // This should fail with an exception
4138                 // Gecko does not error, returns false instead
4139                 matches.call( document.documentElement, "[test!='']:sizzle" );
4140
4141         } catch( pseudoError ) {
4142                 pseudoWorks = true;
4143         }
4144
4145         if ( matches ) {
4146                 Sizzle.matchesSelector = function( node, expr ) {
4147                         // Make sure that attribute selectors are quoted
4148                         expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4149
4150                         if ( !Sizzle.isXML( node ) ) {
4151                                 try {
4152                                         if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
4153                                                 return matches.call( node, expr );
4154                                         }
4155                                 } catch(e) {}
4156                         }
4157
4158                         return Sizzle(expr, null, null, [node]).length > 0;
4159                 };
4160         }
4161 })();
4162
4163 (function(){
4164         var div = document.createElement("div");
4165
4166         div.innerHTML = "<div class='test e'></div><div class='test'></div>";
4167
4168         // Opera can't find a second classname (in 9.6)
4169         // Also, make sure that getElementsByClassName actually exists
4170         if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
4171                 return;
4172         }
4173
4174         // Safari caches class attributes, doesn't catch changes (in 3.2)
4175         div.lastChild.className = "e";
4176
4177         if ( div.getElementsByClassName("e").length === 1 ) {
4178                 return;
4179         }
4180
4181         Expr.order.splice(1, 0, "CLASS");
4182         Expr.find.CLASS = function( match, context, isXML ) {
4183                 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
4184                         return context.getElementsByClassName(match[1]);
4185                 }
4186         };
4187
4188         // release memory in IE
4189         div = null;
4190 })();
4191
4192 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4193         for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4194                 var elem = checkSet[i];
4195
4196                 if ( elem ) {
4197                         var match = false;
4198
4199                         elem = elem[dir];
4200
4201                         while ( elem ) {
4202                                 if ( elem.sizcache === doneName ) {
4203                                         match = checkSet[elem.sizset];
4204                                         break;
4205                                 }
4206
4207                                 if ( elem.nodeType === 1 && !isXML ){
4208                                         elem.sizcache = doneName;
4209                                         elem.sizset = i;
4210                                 }
4211
4212                                 if ( elem.nodeName.toLowerCase() === cur ) {
4213                                         match = elem;
4214                                         break;
4215                                 }
4216
4217                                 elem = elem[dir];
4218                         }
4219
4220                         checkSet[i] = match;
4221                 }
4222         }
4223 }
4224
4225 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4226         for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4227                 var elem = checkSet[i];
4228
4229                 if ( elem ) {
4230                         var match = false;
4231
4232                         elem = elem[dir];
4233
4234                         while ( elem ) {
4235                                 if ( elem.sizcache === doneName ) {
4236                                         match = checkSet[elem.sizset];
4237                                         break;
4238                                 }
4239
4240                                 if ( elem.nodeType === 1 ) {
4241                                         if ( !isXML ) {
4242                                                 elem.sizcache = doneName;
4243                                                 elem.sizset = i;
4244                                         }
4245
4246                                         if ( typeof cur !== "string" ) {
4247                                                 if ( elem === cur ) {
4248                                                         match = true;
4249                                                         break;
4250                                                 }
4251
4252                                         } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
4253                                                 match = elem;
4254                                                 break;
4255                                         }
4256                                 }
4257
4258                                 elem = elem[dir];
4259                         }
4260
4261                         checkSet[i] = match;
4262                 }
4263         }
4264 }
4265
4266 if ( document.documentElement.contains ) {
4267         Sizzle.contains = function( a, b ) {
4268                 return a !== b && (a.contains ? a.contains(b) : true);
4269         };
4270
4271 } else if ( document.documentElement.compareDocumentPosition ) {
4272         Sizzle.contains = function( a, b ) {
4273                 return !!(a.compareDocumentPosition(b) & 16);
4274         };
4275
4276 } else {
4277         Sizzle.contains = function() {
4278                 return false;
4279         };
4280 }
4281
4282 Sizzle.isXML = function( elem ) {
4283         // documentElement is verified for cases where it doesn't yet exist
4284         // (such as loading iframes in IE - #4833)
4285         var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
4286
4287         return documentElement ? documentElement.nodeName !== "HTML" : false;
4288 };
4289
4290 var posProcess = function( selector, context ) {
4291         var match,
4292                 tmpSet = [],
4293                 later = "",
4294                 root = context.nodeType ? [context] : context;
4295
4296         // Position selectors must be done after the filter
4297         // And so must :not(positional) so we move all PSEUDOs to the end
4298         while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
4299                 later += match[0];
4300                 selector = selector.replace( Expr.match.PSEUDO, "" );
4301         }
4302
4303         selector = Expr.relative[selector] ? selector + "*" : selector;
4304
4305         for ( var i = 0, l = root.length; i < l; i++ ) {
4306                 Sizzle( selector, root[i], tmpSet );
4307         }
4308
4309         return Sizzle.filter( later, tmpSet );
4310 };
4311
4312 // EXPOSE
4313 jQuery.find = Sizzle;
4314 jQuery.expr = Sizzle.selectors;
4315 jQuery.expr[":"] = jQuery.expr.filters;
4316 jQuery.unique = Sizzle.uniqueSort;
4317 jQuery.text = Sizzle.getText;
4318 jQuery.isXMLDoc = Sizzle.isXML;
4319 jQuery.contains = Sizzle.contains;
4320
4321
4322 })();
4323
4324
4325 var runtil = /Until$/,
4326         rparentsprev = /^(?:parents|prevUntil|prevAll)/,
4327         // Note: This RegExp should be improved, or likely pulled from Sizzle
4328         rmultiselector = /,/,
4329         isSimple = /^.[^:#\[\.,]*$/,
4330         slice = Array.prototype.slice,
4331         POS = jQuery.expr.match.POS;
4332
4333 jQuery.fn.extend({
4334         find: function( selector ) {
4335                 var ret = this.pushStack( "", "find", selector ),
4336                         length = 0;
4337
4338                 for ( var i = 0, l = this.length; i < l; i++ ) {
4339                         length = ret.length;
4340                         jQuery.find( selector, this[i], ret );
4341
4342                         if ( i > 0 ) {
4343                                 // Make sure that the results are unique
4344                                 for ( var n = length; n < ret.length; n++ ) {
4345                                         for ( var r = 0; r < length; r++ ) {
4346                                                 if ( ret[r] === ret[n] ) {
4347                                                         ret.splice(n--, 1);
4348                                                         break;
4349                                                 }
4350                                         }
4351                                 }
4352                         }
4353                 }
4354
4355                 return ret;
4356         },
4357
4358         has: function( target ) {
4359                 var targets = jQuery( target );
4360                 return this.filter(function() {
4361                         for ( var i = 0, l = targets.length; i < l; i++ ) {
4362                                 if ( jQuery.contains( this, targets[i] ) ) {
4363                                         return true;
4364                                 }
4365                         }
4366                 });
4367         },
4368
4369         not: function( selector ) {
4370                 return this.pushStack( winnow(this, selector, false), "not", selector);
4371         },
4372
4373         filter: function( selector ) {
4374                 return this.pushStack( winnow(this, selector, true), "filter", selector );
4375         },
4376
4377         is: function( selector ) {
4378                 return !!selector && jQuery.filter( selector, this ).length > 0;
4379         },
4380
4381         closest: function( selectors, context ) {
4382                 var ret = [], i, l, cur = this[0];
4383
4384                 if ( jQuery.isArray( selectors ) ) {
4385                         var match, selector,
4386                                 matches = {},
4387                                 level = 1;
4388
4389                         if ( cur && selectors.length ) {
4390                                 for ( i = 0, l = selectors.length; i < l; i++ ) {
4391                                         selector = selectors[i];
4392
4393                                         if ( !matches[selector] ) {
4394                                                 matches[selector] = jQuery.expr.match.POS.test( selector ) ?
4395                                                         jQuery( selector, context || this.context ) :
4396                                                         selector;
4397                                         }
4398                                 }
4399
4400                                 while ( cur && cur.ownerDocument && cur !== context ) {
4401                                         for ( selector in matches ) {
4402                                                 match = matches[selector];
4403
4404                                                 if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
4405                                                         ret.push({ selector: selector, elem: cur, level: level });
4406                                                 }
4407                                         }
4408
4409                                         cur = cur.parentNode;
4410                                         level++;
4411                                 }
4412                         }
4413
4414                         return ret;
4415                 }
4416
4417                 var pos = POS.test( selectors ) ?
4418                         jQuery( selectors, context || this.context ) : null;
4419
4420                 for ( i = 0, l = this.length; i < l; i++ ) {
4421                         cur = this[i];
4422
4423                         while ( cur ) {
4424                                 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
4425                                         ret.push( cur );
4426                                         break;
4427
4428                                 } else {
4429                                         cur = cur.parentNode;
4430                                         if ( !cur || !cur.ownerDocument || cur === context ) {
4431                                                 break;
4432                                         }
4433                                 }
4434                         }
4435                 }
4436
4437                 ret = ret.length > 1 ? jQuery.unique(ret) : ret;
4438
4439                 return this.pushStack( ret, "closest", selectors );
4440         },
4441
4442         // Determine the position of an element within
4443         // the matched set of elements
4444         index: function( elem ) {
4445                 if ( !elem || typeof elem === "string" ) {
4446                         return jQuery.inArray( this[0],
4447                                 // If it receives a string, the selector is used
4448                                 // If it receives nothing, the siblings are used
4449                                 elem ? jQuery( elem ) : this.parent().children() );
4450                 }
4451                 // Locate the position of the desired element
4452                 return jQuery.inArray(
4453                         // If it receives a jQuery object, the first element is used
4454                         elem.jquery ? elem[0] : elem, this );
4455         },
4456
4457         add: function( selector, context ) {
4458                 var set = typeof selector === "string" ?
4459                                 jQuery( selector, context || this.context ) :
4460                                 jQuery.makeArray( selector ),
4461                         all = jQuery.merge( this.get(), set );
4462
4463                 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
4464                         all :
4465                         jQuery.unique( all ) );
4466         },
4467
4468         andSelf: function() {
4469                 return this.add( this.prevObject );
4470         }
4471 });
4472
4473 // A painfully simple check to see if an element is disconnected
4474 // from a document (should be improved, where feasible).
4475 function isDisconnected( node ) {
4476         return !node || !node.parentNode || node.parentNode.nodeType === 11;
4477 }
4478
4479 jQuery.each({
4480         parent: function( elem ) {
4481                 var parent = elem.parentNode;
4482                 return parent && parent.nodeType !== 11 ? parent : null;
4483         },
4484         parents: function( elem ) {
4485                 return jQuery.dir( elem, "parentNode" );
4486         },
4487         parentsUntil: function( elem, i, until ) {
4488                 return jQuery.dir( elem, "parentNode", until );
4489         },
4490         next: function( elem ) {
4491                 return jQuery.nth( elem, 2, "nextSibling" );
4492         },
4493         prev: function( elem ) {
4494                 return jQuery.nth( elem, 2, "previousSibling" );
4495         },
4496         nextAll: function( elem ) {
4497                 return jQuery.dir( elem, "nextSibling" );
4498         },
4499         prevAll: function( elem ) {
4500                 return jQuery.dir( elem, "previousSibling" );
4501         },
4502         nextUntil: function( elem, i, until ) {
4503                 return jQuery.dir( elem, "nextSibling", until );
4504         },
4505         prevUntil: function( elem, i, until ) {
4506                 return jQuery.dir( elem, "previousSibling", until );
4507         },
4508         siblings: function( elem ) {
4509                 return jQuery.sibling( elem.parentNode.firstChild, elem );
4510         },
4511         children: function( elem ) {
4512                 return jQuery.sibling( elem.firstChild );
4513         },
4514         contents: function( elem ) {
4515                 return jQuery.nodeName( elem, "iframe" ) ?
4516                         elem.contentDocument || elem.contentWindow.document :
4517                         jQuery.makeArray( elem.childNodes );
4518         }
4519 }, function( name, fn ) {
4520         jQuery.fn[ name ] = function( until, selector ) {
4521                 var ret = jQuery.map( this, fn, until );
4522
4523                 if ( !runtil.test( name ) ) {
4524                         selector = until;
4525                 }
4526
4527                 if ( selector && typeof selector === "string" ) {
4528                         ret = jQuery.filter( selector, ret );
4529                 }
4530
4531                 ret = this.length > 1 ? jQuery.unique( ret ) : ret;
4532
4533                 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
4534                         ret = ret.reverse();
4535                 }
4536
4537                 return this.pushStack( ret, name, slice.call(arguments).join(",") );
4538         };
4539 });
4540
4541 jQuery.extend({
4542         filter: function( expr, elems, not ) {
4543                 if ( not ) {
4544                         expr = ":not(" + expr + ")";
4545                 }
4546
4547                 return elems.length === 1 ?
4548                         jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
4549                         jQuery.find.matches(expr, elems);
4550         },
4551
4552         dir: function( elem, dir, until ) {
4553                 var matched = [],
4554                         cur = elem[ dir ];
4555
4556                 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
4557                         if ( cur.nodeType === 1 ) {
4558                                 matched.push( cur );
4559                         }
4560                         cur = cur[dir];
4561                 }
4562                 return matched;
4563         },
4564
4565         nth: function( cur, result, dir, elem ) {
4566                 result = result || 1;
4567                 var num = 0;
4568
4569                 for ( ; cur; cur = cur[dir] ) {
4570                         if ( cur.nodeType === 1 && ++num === result ) {
4571                                 break;
4572                         }
4573                 }
4574
4575                 return cur;
4576         },
4577
4578         sibling: function( n, elem ) {
4579                 var r = [];
4580
4581                 for ( ; n; n = n.nextSibling ) {
4582                         if ( n.nodeType === 1 && n !== elem ) {
4583                                 r.push( n );
4584                         }
4585                 }
4586
4587                 return r;
4588         }
4589 });
4590
4591 // Implement the identical functionality for filter and not
4592 function winnow( elements, qualifier, keep ) {
4593         if ( jQuery.isFunction( qualifier ) ) {
4594                 return jQuery.grep(elements, function( elem, i ) {
4595                         var retVal = !!qualifier.call( elem, i, elem );
4596                         return retVal === keep;
4597                 });
4598
4599         } else if ( qualifier.nodeType ) {
4600                 return jQuery.grep(elements, function( elem, i ) {
4601                         return (elem === qualifier) === keep;
4602                 });
4603
4604         } else if ( typeof qualifier === "string" ) {
4605                 var filtered = jQuery.grep(elements, function( elem ) {
4606                         return elem.nodeType === 1;
4607                 });
4608
4609                 if ( isSimple.test( qualifier ) ) {
4610                         return jQuery.filter(qualifier, filtered, !keep);
4611                 } else {
4612                         qualifier = jQuery.filter( qualifier, filtered );
4613                 }
4614         }
4615
4616         return jQuery.grep(elements, function( elem, i ) {
4617                 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
4618         });
4619 }
4620
4621
4622
4623
4624 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
4625         rleadingWhitespace = /^\s+/,
4626         rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
4627         rtagName = /<([\w:]+)/,
4628         rtbody = /<tbody/i,
4629         rhtml = /<|&#?\w+;/,
4630         rnocache = /<(?:script|object|embed|option|style)/i,
4631         // checked="checked" or checked (html5)
4632         rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
4633         raction = /\=([^="'>\s]+\/)>/g,
4634         wrapMap = {
4635                 option: [ 1, "<select multiple='multiple'>", "</select>" ],
4636                 legend: [ 1, "<fieldset>", "</fieldset>" ],
4637                 thead: [ 1, "<table>", "</table>" ],
4638                 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4639                 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4640                 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
4641                 area: [ 1, "<map>", "</map>" ],
4642                 _default: [ 0, "", "" ]
4643         };
4644
4645 wrapMap.optgroup = wrapMap.option;
4646 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4647 wrapMap.th = wrapMap.td;
4648
4649 // IE can't serialize <link> and <script> tags normally
4650 if ( !jQuery.support.htmlSerialize ) {
4651         wrapMap._default = [ 1, "div<div>", "</div>" ];
4652 }
4653
4654 jQuery.fn.extend({
4655         text: function( text ) {
4656                 if ( jQuery.isFunction(text) ) {
4657                         return this.each(function(i) {
4658                                 var self = jQuery( this );
4659
4660                                 self.text( text.call(this, i, self.text()) );
4661                         });
4662                 }
4663
4664                 if ( typeof text !== "object" && text !== undefined ) {
4665                         return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4666                 }
4667
4668                 return jQuery.text( this );
4669         },
4670
4671         wrapAll: function( html ) {
4672                 if ( jQuery.isFunction( html ) ) {
4673                         return this.each(function(i) {
4674                                 jQuery(this).wrapAll( html.call(this, i) );
4675                         });
4676                 }
4677
4678                 if ( this[0] ) {
4679                         // The elements to wrap the target around
4680                         var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
4681
4682                         if ( this[0].parentNode ) {
4683                                 wrap.insertBefore( this[0] );
4684                         }
4685
4686                         wrap.map(function() {
4687                                 var elem = this;
4688
4689                                 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
4690                                         elem = elem.firstChild;
4691                                 }
4692
4693                                 return elem;
4694                         }).append(this);
4695                 }
4696
4697                 return this;
4698         },
4699
4700         wrapInner: function( html ) {
4701                 if ( jQuery.isFunction( html ) ) {
4702                         return this.each(function(i) {
4703                                 jQuery(this).wrapInner( html.call(this, i) );
4704                         });
4705                 }
4706
4707                 return this.each(function() {
4708                         var self = jQuery( this ),
4709                                 contents = self.contents();
4710
4711                         if ( contents.length ) {
4712                                 contents.wrapAll( html );
4713
4714                         } else {
4715                                 self.append( html );
4716                         }
4717                 });
4718         },
4719
4720         wrap: function( html ) {
4721                 return this.each(function() {
4722                         jQuery( this ).wrapAll( html );
4723                 });
4724         },
4725
4726         unwrap: function() {
4727                 return this.parent().each(function() {
4728                         if ( !jQuery.nodeName( this, "body" ) ) {
4729                                 jQuery( this ).replaceWith( this.childNodes );
4730                         }
4731                 }).end();
4732         },
4733
4734         append: function() {
4735                 return this.domManip(arguments, true, function( elem ) {
4736                         if ( this.nodeType === 1 ) {
4737                                 this.appendChild( elem );
4738                         }
4739                 });
4740         },
4741
4742         prepend: function() {
4743                 return this.domManip(arguments, true, function( elem ) {
4744                         if ( this.nodeType === 1 ) {
4745                                 this.insertBefore( elem, this.firstChild );
4746                         }
4747                 });
4748         },
4749
4750         before: function() {
4751                 if ( this[0] && this[0].parentNode ) {
4752                         return this.domManip(arguments, false, function( elem ) {
4753                                 this.parentNode.insertBefore( elem, this );
4754                         });
4755                 } else if ( arguments.length ) {
4756                         var set = jQuery(arguments[0]);
4757                         set.push.apply( set, this.toArray() );
4758                         return this.pushStack( set, "before", arguments );
4759                 }
4760         },
4761
4762         after: function() {
4763                 if ( this[0] && this[0].parentNode ) {
4764                         return this.domManip(arguments, false, function( elem ) {
4765                                 this.parentNode.insertBefore( elem, this.nextSibling );
4766                         });
4767                 } else if ( arguments.length ) {
4768                         var set = this.pushStack( this, "after", arguments );
4769                         set.push.apply( set, jQuery(arguments[0]).toArray() );
4770                         return set;
4771                 }
4772         },
4773
4774         // keepData is for internal use only--do not document
4775         remove: function( selector, keepData ) {
4776                 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4777                         if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
4778                                 if ( !keepData && elem.nodeType === 1 ) {
4779                                         jQuery.cleanData( elem.getElementsByTagName("*") );
4780                                         jQuery.cleanData( [ elem ] );
4781                                 }
4782
4783                                 if ( elem.parentNode ) {
4784                                          elem.parentNode.removeChild( elem );
4785                                 }
4786                         }
4787                 }
4788
4789                 return this;
4790         },
4791
4792         empty: function() {
4793                 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4794                         // Remove element nodes and prevent memory leaks
4795                         if ( elem.nodeType === 1 ) {
4796                                 jQuery.cleanData( elem.getElementsByTagName("*") );
4797                         }
4798
4799                         // Remove any remaining nodes
4800                         while ( elem.firstChild ) {
4801                                 elem.removeChild( elem.firstChild );
4802                         }
4803                 }
4804
4805                 return this;
4806         },
4807
4808         clone: function( events ) {
4809                 // Do the clone
4810                 var ret = this.map(function() {
4811                         if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
4812                                 // IE copies events bound via attachEvent when
4813                                 // using cloneNode. Calling detachEvent on the
4814                                 // clone will also remove the events from the orignal
4815                                 // In order to get around this, we use innerHTML.
4816                                 // Unfortunately, this means some modifications to
4817                                 // attributes in IE that are actually only stored
4818                                 // as properties will not be copied (such as the
4819                                 // the name attribute on an input).
4820                                 var html = this.outerHTML,
4821                                         ownerDocument = this.ownerDocument;
4822
4823                                 if ( !html ) {
4824                                         var div = ownerDocument.createElement("div");
4825                                         div.appendChild( this.cloneNode(true) );
4826                                         html = div.innerHTML;
4827                                 }
4828
4829                                 return jQuery.clean([html.replace(rinlinejQuery, "")
4830                                         // Handle the case in IE 8 where action=/test/> self-closes a tag
4831                                         .replace(raction, '="$1">')
4832                                         .replace(rleadingWhitespace, "")], ownerDocument)[0];
4833                         } else {
4834                                 return this.cloneNode(true);
4835                         }
4836                 });
4837
4838                 // Copy the events from the original to the clone
4839                 if ( events === true ) {
4840                         cloneCopyEvent( this, ret );
4841                         cloneCopyEvent( this.find("*"), ret.find("*") );
4842                 }
4843
4844                 // Return the cloned set
4845                 return ret;
4846         },
4847
4848         html: function( value ) {
4849                 if ( value === undefined ) {
4850                         return this[0] && this[0].nodeType === 1 ?
4851                                 this[0].innerHTML.replace(rinlinejQuery, "") :
4852                                 null;
4853
4854                 // See if we can take a shortcut and just use innerHTML
4855                 } else if ( typeof value === "string" && !rnocache.test( value ) &&
4856                         (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
4857                         !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
4858
4859                         value = value.replace(rxhtmlTag, "<$1></$2>");
4860
4861                         try {
4862                                 for ( var i = 0, l = this.length; i < l; i++ ) {
4863                                         // Remove element nodes and prevent memory leaks
4864                                         if ( this[i].nodeType === 1 ) {
4865                                                 jQuery.cleanData( this[i].getElementsByTagName("*") );
4866                                                 this[i].innerHTML = value;
4867                                         }
4868                                 }
4869
4870                         // If using innerHTML throws an exception, use the fallback method
4871                         } catch(e) {
4872                                 this.empty().append( value );
4873                         }
4874
4875                 } else if ( jQuery.isFunction( value ) ) {
4876                         this.each(function(i){
4877                                 var self = jQuery( this );
4878
4879                                 self.html( value.call(this, i, self.html()) );
4880                         });
4881
4882                 } else {
4883                         this.empty().append( value );
4884                 }
4885
4886                 return this;
4887         },
4888
4889         replaceWith: function( value ) {
4890                 if ( this[0] && this[0].parentNode ) {
4891                         // Make sure that the elements are removed from the DOM before they are inserted
4892                         // this can help fix replacing a parent with child elements
4893                         if ( jQuery.isFunction( value ) ) {
4894                                 return this.each(function(i) {
4895                                         var self = jQuery(this), old = self.html();
4896                                         self.replaceWith( value.call( this, i, old ) );
4897                                 });
4898                         }
4899
4900                         if ( typeof value !== "string" ) {
4901                                 value = jQuery( value ).detach();
4902                         }
4903
4904                         return this.each(function() {
4905                                 var next = this.nextSibling,
4906                                         parent = this.parentNode;
4907
4908                                 jQuery( this ).remove();
4909
4910                                 if ( next ) {
4911                                         jQuery(next).before( value );
4912                                 } else {
4913                                         jQuery(parent).append( value );
4914                                 }
4915                         });
4916                 } else {
4917                         return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4918                 }
4919         },
4920
4921         detach: function( selector ) {
4922                 return this.remove( selector, true );
4923         },
4924
4925         domManip: function( args, table, callback ) {
4926                 var results, first, fragment, parent,
4927                         value = args[0],
4928                         scripts = [];
4929
4930                 // We can't cloneNode fragments that contain checked, in WebKit
4931                 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4932                         return this.each(function() {
4933                                 jQuery(this).domManip( args, table, callback, true );
4934                         });
4935                 }
4936
4937                 if ( jQuery.isFunction(value) ) {
4938                         return this.each(function(i) {
4939                                 var self = jQuery(this);
4940                                 args[0] = value.call(this, i, table ? self.html() : undefined);
4941                                 self.domManip( args, table, callback );
4942                         });
4943                 }
4944
4945                 if ( this[0] ) {
4946                         parent = value && value.parentNode;
4947
4948                         // If we're in a fragment, just use that instead of building a new one
4949                         if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
4950                                 results = { fragment: parent };
4951
4952                         } else {
4953                                 results = jQuery.buildFragment( args, this, scripts );
4954                         }
4955
4956                         fragment = results.fragment;
4957
4958                         if ( fragment.childNodes.length === 1 ) {
4959                                 first = fragment = fragment.firstChild;
4960                         } else {
4961                                 first = fragment.firstChild;
4962                         }
4963
4964                         if ( first ) {
4965                                 table = table && jQuery.nodeName( first, "tr" );
4966
4967                                 for ( var i = 0, l = this.length; i < l; i++ ) {
4968                                         callback.call(
4969                                                 table ?
4970                                                         root(this[i], first) :
4971                                                         this[i],
4972                                                 i > 0 || results.cacheable || this.length > 1  ?
4973                                                         fragment.cloneNode(true) :
4974                                                         fragment
4975                                         );
4976                                 }
4977                         }
4978
4979                         if ( scripts.length ) {
4980                                 jQuery.each( scripts, evalScript );
4981                         }
4982                 }
4983
4984                 return this;
4985         }
4986 });
4987
4988 function root( elem, cur ) {
4989         return jQuery.nodeName(elem, "table") ?
4990                 (elem.getElementsByTagName("tbody")[0] ||
4991                 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4992                 elem;
4993 }
4994
4995 function cloneCopyEvent(orig, ret) {
4996         var i = 0;
4997
4998         ret.each(function() {
4999                 if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
5000                         return;
5001                 }
5002
5003                 var oldData = jQuery.data( orig[i++] ),
5004                         curData = jQuery.data( this, oldData ),
5005                         events = oldData && oldData.events;
5006
5007                 if ( events ) {
5008                         delete curData.handle;
5009                         curData.events = {};
5010
5011                         for ( var type in events ) {
5012                                 for ( var handler in events[ type ] ) {
5013                                         jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
5014                                 }
5015                         }
5016                 }
5017         });
5018 }
5019
5020 jQuery.buildFragment = function( args, nodes, scripts ) {
5021         var fragment, cacheable, cacheresults,
5022                 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
5023
5024         // Only cache "small" (1/2 KB) strings that are associated with the main document
5025         // Cloning options loses the selected state, so don't cache them
5026         // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5027         // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5028         if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5029                 !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
5030
5031                 cacheable = true;
5032                 cacheresults = jQuery.fragments[ args[0] ];
5033                 if ( cacheresults ) {
5034                         if ( cacheresults !== 1 ) {
5035                                 fragment = cacheresults;
5036                         }
5037                 }
5038         }
5039
5040         if ( !fragment ) {
5041                 fragment = doc.createDocumentFragment();
5042                 jQuery.clean( args, doc, fragment, scripts );
5043         }
5044
5045         if ( cacheable ) {
5046                 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
5047         }
5048
5049         return { fragment: fragment, cacheable: cacheable };
5050 };
5051
5052 jQuery.fragments = {};
5053
5054 jQuery.each({
5055         appendTo: "append",
5056         prependTo: "prepend",
5057         insertBefore: "before",
5058         insertAfter: "after",
5059         replaceAll: "replaceWith"
5060 }, function( name, original ) {
5061         jQuery.fn[ name ] = function( selector ) {
5062                 var ret = [],
5063                         insert = jQuery( selector ),
5064                         parent = this.length === 1 && this[0].parentNode;
5065
5066                 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5067                         insert[ original ]( this[0] );
5068                         return this;
5069
5070                 } else {
5071                         for ( var i = 0, l = insert.length; i < l; i++ ) {
5072                                 var elems = (i > 0 ? this.clone(true) : this).get();
5073                                 jQuery( insert[i] )[ original ]( elems );
5074                                 ret = ret.concat( elems );
5075                         }
5076
5077                         return this.pushStack( ret, name, insert.selector );
5078                 }
5079         };
5080 });
5081
5082 jQuery.extend({
5083         clean: function( elems, context, fragment, scripts ) {
5084                 context = context || document;
5085
5086                 // !context.createElement fails in IE with an error but returns typeof 'object'
5087                 if ( typeof context.createElement === "undefined" ) {
5088                         context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
5089                 }
5090
5091                 var ret = [];
5092
5093                 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
5094                         if ( typeof elem === "number" ) {
5095                                 elem += "";
5096                         }
5097
5098                         if ( !elem ) {
5099                                 continue;
5100                         }
5101
5102                         // Convert html string into DOM nodes
5103                         if ( typeof elem === "string" && !rhtml.test( elem ) ) {
5104                                 elem = context.createTextNode( elem );
5105
5106                         } else if ( typeof elem === "string" ) {
5107                                 // Fix "XHTML"-style tags in all browsers
5108                                 elem = elem.replace(rxhtmlTag, "<$1></$2>");
5109
5110                                 // Trim whitespace, otherwise indexOf won't work as expected
5111                                 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
5112                                         wrap = wrapMap[ tag ] || wrapMap._default,
5113                                         depth = wrap[0],
5114                                         div = context.createElement("div");
5115
5116                                 // Go to html and back, then peel off extra wrappers
5117                                 div.innerHTML = wrap[1] + elem + wrap[2];
5118
5119                                 // Move to the right depth
5120                                 while ( depth-- ) {
5121                                         div = div.lastChild;
5122                                 }
5123
5124                                 // Remove IE's autoinserted <tbody> from table fragments
5125                                 if ( !jQuery.support.tbody ) {
5126
5127                                         // String was a <table>, *may* have spurious <tbody>
5128                                         var hasBody = rtbody.test(elem),
5129                                                 tbody = tag === "table" && !hasBody ?
5130                                                         div.firstChild && div.firstChild.childNodes :
5131
5132                                                         // String was a bare <thead> or <tfoot>
5133                                                         wrap[1] === "<table>" && !hasBody ?
5134                                                                 div.childNodes :
5135                                                                 [];
5136
5137                                         for ( var j = tbody.length - 1; j >= 0 ; --j ) {
5138                                                 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
5139                                                         tbody[ j ].parentNode.removeChild( tbody[ j ] );
5140                                                 }
5141                                         }
5142
5143                                 }
5144
5145                                 // IE completely kills leading whitespace when innerHTML is used
5146                                 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
5147                                         div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
5148                                 }
5149
5150                                 elem = div.childNodes;
5151                         }
5152
5153                         if ( elem.nodeType ) {
5154                                 ret.push( elem );
5155                         } else {
5156                                 ret = jQuery.merge( ret, elem );
5157                         }
5158                 }
5159
5160                 if ( fragment ) {
5161                         for ( i = 0; ret[i]; i++ ) {
5162                                 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
5163                                         scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
5164
5165                                 } else {
5166                                         if ( ret[i].nodeType === 1 ) {
5167                                                 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
5168                                         }
5169                                         fragment.appendChild( ret[i] );
5170                                 }
5171                         }
5172                 }
5173
5174                 return ret;
5175         },
5176
5177         cleanData: function( elems ) {
5178                 var data, id, cache = jQuery.cache,
5179                         special = jQuery.event.special,
5180                         deleteExpando = jQuery.support.deleteExpando;
5181
5182                 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
5183                         if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
5184                                 continue;
5185                         }
5186
5187                         id = elem[ jQuery.expando ];
5188
5189                         if ( id ) {
5190                                 data = cache[ id ];
5191
5192                                 if ( data && data.events ) {
5193                                         for ( var type in data.events ) {
5194                                                 if ( special[ type ] ) {
5195                                                         jQuery.event.remove( elem, type );
5196
5197                                                 } else {
5198                                                         jQuery.removeEvent( elem, type, data.handle );
5199                                                 }
5200                                         }
5201                                 }
5202
5203                                 if ( deleteExpando ) {
5204                                         delete elem[ jQuery.expando ];
5205
5206                                 } else if ( elem.removeAttribute ) {
5207                                         elem.removeAttribute( jQuery.expando );
5208                                 }
5209
5210                                 delete cache[ id ];
5211                         }
5212                 }
5213         }
5214 });
5215
5216 function evalScript( i, elem ) {
5217         if ( elem.src ) {
5218                 jQuery.ajax({
5219                         url: elem.src,
5220                         async: false,
5221                         dataType: "script"
5222                 });
5223         } else {
5224                 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
5225         }
5226
5227         if ( elem.parentNode ) {
5228                 elem.parentNode.removeChild( elem );
5229         }
5230 }
5231
5232
5233
5234
5235 var ralpha = /alpha\([^)]*\)/i,
5236         ropacity = /opacity=([^)]*)/,
5237         rdashAlpha = /-([a-z])/ig,
5238         rupper = /([A-Z])/g,
5239         rnumpx = /^-?\d+(?:px)?$/i,
5240         rnum = /^-?\d/,
5241
5242         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
5243         cssWidth = [ "Left", "Right" ],
5244         cssHeight = [ "Top", "Bottom" ],
5245         curCSS,
5246
5247         getComputedStyle,
5248         currentStyle,
5249
5250         fcamelCase = function( all, letter ) {
5251                 return letter.toUpperCase();
5252         };
5253
5254 jQuery.fn.css = function( name, value ) {
5255         // Setting 'undefined' is a no-op
5256         if ( arguments.length === 2 && value === undefined ) {
5257                 return this;
5258         }
5259
5260         return jQuery.access( this, name, value, true, function( elem, name, value ) {
5261                 return value !== undefined ?
5262                         jQuery.style( elem, name, value ) :
5263                         jQuery.css( elem, name );
5264         });
5265 };
5266
5267 jQuery.extend({
5268         // Add in style property hooks for overriding the default
5269         // behavior of getting and setting a style property
5270         cssHooks: {
5271                 opacity: {
5272                         get: function( elem, computed ) {
5273                                 if ( computed ) {
5274                                         // We should always get a number back from opacity
5275                                         var ret = curCSS( elem, "opacity", "opacity" );
5276                                         return ret === "" ? "1" : ret;
5277
5278                                 } else {
5279                                         return elem.style.opacity;
5280                                 }
5281                         }
5282                 }
5283         },
5284
5285         // Exclude the following css properties to add px
5286         cssNumber: {
5287                 "zIndex": true,
5288                 "fontWeight": true,
5289                 "opacity": true,
5290                 "zoom": true,
5291                 "lineHeight": true
5292         },
5293
5294         // Add in properties whose names you wish to fix before
5295         // setting or getting the value
5296         cssProps: {
5297                 // normalize float css property
5298                 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
5299         },
5300
5301         // Get and set the style property on a DOM Node
5302         style: function( elem, name, value, extra ) {
5303                 // Don't set styles on text and comment nodes
5304                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
5305                         return;
5306                 }
5307
5308                 // Make sure that we're working with the right name
5309                 var ret, origName = jQuery.camelCase( name ),
5310                         style = elem.style, hooks = jQuery.cssHooks[ origName ];
5311
5312                 name = jQuery.cssProps[ origName ] || origName;
5313
5314                 // Check if we're setting a value
5315                 if ( value !== undefined ) {
5316                         // Make sure that NaN and null values aren't set. See: #7116
5317                         if ( typeof value === "number" && isNaN( value ) || value == null ) {
5318                                 return;
5319                         }
5320
5321                         // If a number was passed in, add 'px' to the (except for certain CSS properties)
5322                         if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
5323                                 value += "px";
5324                         }
5325
5326                         // If a hook was provided, use that value, otherwise just set the specified value
5327                         if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
5328                                 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
5329                                 // Fixes bug #5509
5330                                 try {
5331                                         style[ name ] = value;
5332                                 } catch(e) {}
5333                         }
5334
5335                 } else {
5336                         // If a hook was provided get the non-computed value from there
5337                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
5338                                 return ret;
5339                         }
5340
5341                         // Otherwise just get the value from the style object
5342                         return style[ name ];
5343                 }
5344         },
5345
5346         css: function( elem, name, extra ) {
5347                 // Make sure that we're working with the right name
5348                 var ret, origName = jQuery.camelCase( name ),
5349                         hooks = jQuery.cssHooks[ origName ];
5350
5351                 name = jQuery.cssProps[ origName ] || origName;
5352
5353                 // If a hook was provided get the computed value from there
5354                 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
5355                         return ret;
5356
5357                 // Otherwise, if a way to get the computed value exists, use that
5358                 } else if ( curCSS ) {
5359                         return curCSS( elem, name, origName );
5360                 }
5361         },
5362
5363         // A method for quickly swapping in/out CSS properties to get correct calculations
5364         swap: function( elem, options, callback ) {
5365                 var old = {};
5366
5367                 // Remember the old values, and insert the new ones
5368                 for ( var name in options ) {
5369                         old[ name ] = elem.style[ name ];
5370                         elem.style[ name ] = options[ name ];
5371                 }
5372
5373                 callback.call( elem );
5374
5375                 // Revert the old values
5376                 for ( name in options ) {
5377                         elem.style[ name ] = old[ name ];
5378                 }
5379         },
5380
5381         camelCase: function( string ) {
5382                 return string.replace( rdashAlpha, fcamelCase );
5383         }
5384 });
5385
5386 // DEPRECATED, Use jQuery.css() instead
5387 jQuery.curCSS = jQuery.css;
5388
5389 jQuery.each(["height", "width"], function( i, name ) {
5390         jQuery.cssHooks[ name ] = {
5391                 get: function( elem, computed, extra ) {
5392                         var val;
5393
5394                         if ( computed ) {
5395                                 if ( elem.offsetWidth !== 0 ) {
5396                                         val = getWH( elem, name, extra );
5397
5398                                 } else {
5399                                         jQuery.swap( elem, cssShow, function() {
5400                                                 val = getWH( elem, name, extra );
5401                                         });
5402                                 }
5403
5404                                 if ( val <= 0 ) {
5405                                         val = curCSS( elem, name, name );
5406
5407                                         if ( val === "0px" && currentStyle ) {
5408                                                 val = currentStyle( elem, name, name );
5409                                         }
5410
5411                                         if ( val != null ) {
5412                                                 // Should return "auto" instead of 0, use 0 for
5413                                                 // temporary backwards-compat
5414                                                 return val === "" || val === "auto" ? "0px" : val;
5415                                         }
5416                                 }
5417
5418                                 if ( val < 0 || val == null ) {
5419                                         val = elem.style[ name ];
5420
5421                                         // Should return "auto" instead of 0, use 0 for
5422                                         // temporary backwards-compat
5423                                         return val === "" || val === "auto" ? "0px" : val;
5424                                 }
5425
5426                                 return typeof val === "string" ? val : val + "px";
5427                         }
5428                 },
5429
5430                 set: function( elem, value ) {
5431                         if ( rnumpx.test( value ) ) {
5432                                 // ignore negative width and height values #1599
5433                                 value = parseFloat(value);
5434
5435                                 if ( value >= 0 ) {
5436                                         return value + "px";
5437                                 }
5438
5439                         } else {
5440                                 return value;
5441                         }
5442                 }
5443         };
5444 });
5445
5446 if ( !jQuery.support.opacity ) {
5447         jQuery.cssHooks.opacity = {
5448                 get: function( elem, computed ) {
5449                         // IE uses filters for opacity
5450                         return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
5451                                 (parseFloat(RegExp.$1) / 100) + "" :
5452                                 computed ? "1" : "";
5453                 },
5454
5455                 set: function( elem, value ) {
5456                         var style = elem.style;
5457
5458                         // IE has trouble with opacity if it does not have layout
5459                         // Force it by setting the zoom level
5460                         style.zoom = 1;
5461
5462                         // Set the alpha filter to set the opacity
5463                         var opacity = jQuery.isNaN(value) ?
5464                                 "" :
5465                                 "alpha(opacity=" + value * 100 + ")",
5466                                 filter = style.filter || "";
5467
5468                         style.filter = ralpha.test(filter) ?
5469                                 filter.replace(ralpha, opacity) :
5470                                 style.filter + ' ' + opacity;
5471                 }
5472         };
5473 }
5474
5475 if ( document.defaultView && document.defaultView.getComputedStyle ) {
5476         getComputedStyle = function( elem, newName, name ) {
5477                 var ret, defaultView, computedStyle;
5478
5479                 name = name.replace( rupper, "-$1" ).toLowerCase();
5480
5481                 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
5482                         return undefined;
5483                 }
5484
5485                 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
5486                         ret = computedStyle.getPropertyValue( name );
5487                         if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
5488                                 ret = jQuery.style( elem, name );
5489                         }
5490                 }
5491
5492                 return ret;
5493         };
5494 }
5495
5496 if ( document.documentElement.currentStyle ) {
5497         currentStyle = function( elem, name ) {
5498                 var left, rsLeft,
5499                         ret = elem.currentStyle && elem.currentStyle[ name ],
5500                         style = elem.style;
5501
5502                 // From the awesome hack by Dean Edwards
5503                 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
5504
5505                 // If we're not dealing with a regular pixel number
5506                 // but a number that has a weird ending, we need to convert it to pixels
5507                 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
5508                         // Remember the original values
5509                         left = style.left;
5510                         rsLeft = elem.runtimeStyle.left;
5511
5512                         // Put in the new values to get a computed value out
5513                         elem.runtimeStyle.left = elem.currentStyle.left;
5514                         style.left = name === "fontSize" ? "1em" : (ret || 0);
5515                         ret = style.pixelLeft + "px";
5516
5517                         // Revert the changed values
5518                         style.left = left;
5519                         elem.runtimeStyle.left = rsLeft;
5520                 }
5521
5522                 return ret === "" ? "auto" : ret;
5523         };
5524 }
5525
5526 curCSS = getComputedStyle || currentStyle;
5527
5528 function getWH( elem, name, extra ) {
5529         var which = name === "width" ? cssWidth : cssHeight,
5530                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
5531
5532         if ( extra === "border" ) {
5533                 return val;
5534         }
5535
5536         jQuery.each( which, function() {
5537                 if ( !extra ) {
5538                         val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
5539                 }
5540
5541                 if ( extra === "margin" ) {
5542                         val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
5543
5544                 } else {
5545                         val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
5546                 }
5547         });
5548
5549         return val;
5550 }
5551
5552 if ( jQuery.expr && jQuery.expr.filters ) {
5553         jQuery.expr.filters.hidden = function( elem ) {
5554                 var width = elem.offsetWidth,
5555                         height = elem.offsetHeight;
5556
5557                 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
5558         };
5559
5560         jQuery.expr.filters.visible = function( elem ) {
5561                 return !jQuery.expr.filters.hidden( elem );
5562         };
5563 }
5564
5565
5566
5567
5568 var jsc = jQuery.now(),
5569         rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
5570         rselectTextarea = /^(?:select|textarea)/i,
5571         rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
5572         rnoContent = /^(?:GET|HEAD)$/,
5573         rbracket = /\[\]$/,
5574         jsre = /\=\?(&|$)/,
5575         rquery = /\?/,
5576         rts = /([?&])_=[^&]*/,
5577         rurl = /^(\w+:)?\/\/([^\/?#]+)/,
5578         r20 = /%20/g,
5579         rhash = /#.*$/,
5580
5581         // Keep a copy of the old load method
5582         _load = jQuery.fn.load;
5583
5584 jQuery.fn.extend({
5585         load: function( url, params, callback ) {
5586                 if ( typeof url !== "string" && _load ) {
5587                         return _load.apply( this, arguments );
5588
5589                 // Don't do a request if no elements are being requested
5590                 } else if ( !this.length ) {
5591                         return this;
5592                 }
5593
5594                 var off = url.indexOf(" ");
5595                 if ( off >= 0 ) {
5596                         var selector = url.slice(off, url.length);
5597                         url = url.slice(0, off);
5598                 }
5599
5600                 // Default to a GET request
5601                 var type = "GET";
5602
5603                 // If the second parameter was provided
5604                 if ( params ) {
5605                         // If it's a function
5606                         if ( jQuery.isFunction( params ) ) {
5607                                 // We assume that it's the callback
5608                                 callback = params;
5609                                 params = null;
5610
5611                         // Otherwise, build a param string
5612                         } else if ( typeof params === "object" ) {
5613                                 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
5614                                 type = "POST";
5615                         }
5616                 }
5617
5618                 var self = this;
5619
5620                 // Request the remote document
5621                 jQuery.ajax({
5622                         url: url,
5623                         type: type,
5624                         dataType: "html",
5625                         data: params,
5626                         complete: function( res, status ) {
5627                                 // If successful, inject the HTML into all the matched elements
5628                                 if ( status === "success" || status === "notmodified" ) {
5629                                         // See if a selector was specified
5630                                         self.html( selector ?
5631                                                 // Create a dummy div to hold the results
5632                                                 jQuery("<div>")
5633                                                         // inject the contents of the document in, removing the scripts
5634                                                         // to avoid any 'Permission Denied' errors in IE
5635                                                         .append(res.responseText.replace(rscript, ""))
5636
5637                                                         // Locate the specified elements
5638                                                         .find(selector) :
5639
5640                                                 // If not, just inject the full result
5641                                                 res.responseText );
5642                                 }
5643
5644                                 if ( callback ) {
5645                                         self.each( callback, [res.responseText, status, res] );
5646                                 }
5647                         }
5648                 });
5649
5650                 return this;
5651         },
5652
5653         serialize: function() {
5654                 return jQuery.param(this.serializeArray());
5655         },
5656
5657         serializeArray: function() {
5658                 return this.map(function() {
5659                         return this.elements ? jQuery.makeArray(this.elements) : this;
5660                 })
5661                 .filter(function() {
5662                         return this.name && !this.disabled &&
5663                                 (this.checked || rselectTextarea.test(this.nodeName) ||
5664                                         rinput.test(this.type));
5665                 })
5666                 .map(function( i, elem ) {
5667                         var val = jQuery(this).val();
5668
5669                         return val == null ?
5670                                 null :
5671                                 jQuery.isArray(val) ?
5672                                         jQuery.map( val, function( val, i ) {
5673                                                 return { name: elem.name, value: val };
5674                                         }) :
5675                                         { name: elem.name, value: val };
5676                 }).get();
5677         }
5678 });
5679
5680 // Attach a bunch of functions for handling common AJAX events
5681 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
5682         jQuery.fn[o] = function( f ) {
5683                 return this.bind(o, f);
5684         };
5685 });
5686
5687 jQuery.extend({
5688         get: function( url, data, callback, type ) {
5689                 // shift arguments if data argument was omited
5690                 if ( jQuery.isFunction( data ) ) {
5691                         type = type || callback;
5692                         callback = data;
5693                         data = null;
5694                 }
5695
5696                 return jQuery.ajax({
5697                         type: "GET",
5698                         url: url,
5699                         data: data,
5700                         success: callback,
5701                         dataType: type
5702                 });
5703         },
5704
5705         getScript: function( url, callback ) {
5706                 return jQuery.get(url, null, callback, "script");
5707         },
5708
5709         getJSON: function( url, data, callback ) {
5710                 return jQuery.get(url, data, callback, "json");
5711         },
5712
5713         post: function( url, data, callback, type ) {
5714                 // shift arguments if data argument was omited
5715                 if ( jQuery.isFunction( data ) ) {
5716                         type = type || callback;
5717                         callback = data;
5718                         data = {};
5719                 }
5720
5721                 return jQuery.ajax({
5722                         type: "POST",
5723                         url: url,
5724                         data: data,
5725                         success: callback,
5726                         dataType: type
5727                 });
5728         },
5729
5730         ajaxSetup: function( settings ) {
5731                 jQuery.extend( jQuery.ajaxSettings, settings );
5732         },
5733
5734         ajaxSettings: {
5735                 url: location.href,
5736                 global: true,
5737                 type: "GET",
5738                 contentType: "application/x-www-form-urlencoded",
5739                 processData: true,
5740                 async: true,
5741                 /*
5742                 timeout: 0,
5743                 data: null,
5744                 username: null,
5745                 password: null,
5746                 traditional: false,
5747                 */
5748                 // This function can be overriden by calling jQuery.ajaxSetup
5749                 xhr: function() {
5750                         return new window.XMLHttpRequest();
5751                 },
5752                 accepts: {
5753                         xml: "application/xml, text/xml",
5754                         html: "text/html",
5755                         script: "text/javascript, application/javascript",
5756                         json: "application/json, text/javascript",
5757                         text: "text/plain",
5758                         _default: "*/*"
5759                 }
5760         },
5761
5762         ajax: function( origSettings ) {
5763                 var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
5764                         jsonp, status, data, type = s.type.toUpperCase(), noContent = rnoContent.test(type);
5765
5766                 s.url = s.url.replace( rhash, "" );
5767
5768                 // Use original (not extended) context object if it was provided
5769                 s.context = origSettings && origSettings.context != null ? origSettings.context : s;
5770
5771                 // convert data if not already a string
5772                 if ( s.data && s.processData && typeof s.data !== "string" ) {
5773                         s.data = jQuery.param( s.data, s.traditional );
5774                 }
5775
5776                 // Handle JSONP Parameter Callbacks
5777                 if ( s.dataType === "jsonp" ) {
5778                         if ( type === "GET" ) {
5779                                 if ( !jsre.test( s.url ) ) {
5780                                         s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
5781                                 }
5782                         } else if ( !s.data || !jsre.test(s.data) ) {
5783                                 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
5784                         }
5785                         s.dataType = "json";
5786                 }
5787
5788                 // Build temporary JSONP function
5789                 if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
5790                         jsonp = s.jsonpCallback || ("jsonp" + jsc++);
5791
5792                         // Replace the =? sequence both in the query string and the data
5793                         if ( s.data ) {
5794                                 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
5795                         }
5796
5797                         s.url = s.url.replace(jsre, "=" + jsonp + "$1");
5798
5799                         // We need to make sure
5800                         // that a JSONP style response is executed properly
5801                         s.dataType = "script";
5802
5803                         // Handle JSONP-style loading
5804                         var customJsonp = window[ jsonp ];
5805
5806                         window[ jsonp ] = function( tmp ) {
5807                                 if ( jQuery.isFunction( customJsonp ) ) {
5808                                         customJsonp( tmp );
5809
5810                                 } else {
5811                                         // Garbage collect
5812                                         window[ jsonp ] = undefined;
5813
5814                                         try {
5815                                                 delete window[ jsonp ];
5816                                         } catch( jsonpError ) {}
5817                                 }
5818
5819                                 data = tmp;
5820                                 jQuery.handleSuccess( s, xhr, status, data );
5821                                 jQuery.handleComplete( s, xhr, status, data );
5822
5823                                 if ( head ) {
5824                                         head.removeChild( script );
5825                                 }
5826                         };
5827                 }
5828
5829                 if ( s.dataType === "script" && s.cache === null ) {
5830                         s.cache = false;
5831                 }
5832
5833                 if ( s.cache === false && noContent ) {
5834                         var ts = jQuery.now();
5835
5836                         // try replacing _= if it is there
5837                         var ret = s.url.replace(rts, "$1_=" + ts);
5838
5839                         // if nothing was replaced, add timestamp to the end
5840                         s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
5841                 }
5842
5843                 // If data is available, append data to url for GET/HEAD requests
5844                 if ( s.data && noContent ) {
5845                         s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
5846                 }
5847
5848                 // Watch for a new set of requests
5849                 if ( s.global && jQuery.active++ === 0 ) {
5850                         jQuery.event.trigger( "ajaxStart" );
5851                 }
5852
5853                 // Matches an absolute URL, and saves the domain
5854                 var parts = rurl.exec( s.url ),
5855                         remote = parts && (parts[1] && parts[1].toLowerCase() !== location.protocol || parts[2].toLowerCase() !== location.host);
5856
5857                 // If we're requesting a remote document
5858                 // and trying to load JSON or Script with a GET
5859                 if ( s.dataType === "script" && type === "GET" && remote ) {
5860                         var head = document.getElementsByTagName("head")[0] || document.documentElement;
5861                         var script = document.createElement("script");
5862                         if ( s.scriptCharset ) {
5863                                 script.charset = s.scriptCharset;
5864                         }
5865                         script.src = s.url;
5866
5867                         // Handle Script loading
5868                         if ( !jsonp ) {
5869                                 var done = false;
5870
5871                                 // Attach handlers for all browsers
5872                                 script.onload = script.onreadystatechange = function() {
5873                                         if ( !done && (!this.readyState ||
5874                                                         this.readyState === "loaded" || this.readyState === "complete") ) {
5875                                                 done = true;
5876                                                 jQuery.handleSuccess( s, xhr, status, data );
5877                                                 jQuery.handleComplete( s, xhr, status, data );
5878
5879                                                 // Handle memory leak in IE
5880                                                 script.onload = script.onreadystatechange = null;
5881                                                 if ( head && script.parentNode ) {
5882                                                         head.removeChild( script );
5883                                                 }
5884                                         }
5885                                 };
5886                         }
5887
5888                         // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
5889                         // This arises when a base node is used (#2709 and #4378).
5890                         head.insertBefore( script, head.firstChild );
5891
5892                         // We handle everything using the script element injection
5893                         return undefined;
5894                 }
5895
5896                 var requestDone = false;
5897
5898                 // Create the request object
5899                 var xhr = s.xhr();
5900
5901                 if ( !xhr ) {
5902                         return;
5903                 }
5904
5905                 // Open the socket
5906                 // Passing null username, generates a login popup on Opera (#2865)
5907                 if ( s.username ) {
5908                         xhr.open(type, s.url, s.async, s.username, s.password);
5909                 } else {
5910                         xhr.open(type, s.url, s.async);
5911                 }
5912
5913                 // Need an extra try/catch for cross domain requests in Firefox 3
5914                 try {
5915                         // Set content-type if data specified and content-body is valid for this type
5916                         if ( (s.data != null && !noContent) || (origSettings && origSettings.contentType) ) {
5917                                 xhr.setRequestHeader("Content-Type", s.contentType);
5918                         }
5919
5920                         // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
5921                         if ( s.ifModified ) {
5922                                 if ( jQuery.lastModified[s.url] ) {
5923                                         xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
5924                                 }
5925
5926                                 if ( jQuery.etag[s.url] ) {
5927                                         xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
5928                                 }
5929                         }
5930
5931                         // Set header so the called script knows that it's an XMLHttpRequest
5932                         // Only send the header if it's not a remote XHR
5933                         if ( !remote ) {
5934                                 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
5935                         }
5936
5937                         // Set the Accepts header for the server, depending on the dataType
5938                         xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
5939                                 s.accepts[ s.dataType ] + ", */*; q=0.01" :
5940                                 s.accepts._default );
5941                 } catch( headerError ) {}
5942
5943                 // Allow custom headers/mimetypes and early abort
5944                 if ( s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false ) {
5945                         // Handle the global AJAX counter
5946                         if ( s.global && jQuery.active-- === 1 ) {
5947                                 jQuery.event.trigger( "ajaxStop" );
5948                         }
5949
5950                         // close opended socket
5951                         xhr.abort();
5952                         return false;
5953                 }
5954
5955                 if ( s.global ) {
5956                         jQuery.triggerGlobal( s, "ajaxSend", [xhr, s] );
5957                 }
5958
5959                 // Wait for a response to come back
5960                 var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
5961                         // The request was aborted
5962                         if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
5963                                 // Opera doesn't call onreadystatechange before this point
5964                                 // so we simulate the call
5965                                 if ( !requestDone ) {
5966                                         jQuery.handleComplete( s, xhr, status, data );
5967                                 }
5968
5969                                 requestDone = true;
5970                                 if ( xhr ) {
5971                                         xhr.onreadystatechange = jQuery.noop;
5972                                 }
5973
5974                         // The transfer is complete and the data is available, or the request timed out
5975                         } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
5976                                 requestDone = true;
5977                                 xhr.onreadystatechange = jQuery.noop;
5978
5979                                 status = isTimeout === "timeout" ?
5980                                         "timeout" :
5981                                         !jQuery.httpSuccess( xhr ) ?
5982                                                 "error" :
5983                                                 s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
5984                                                         "notmodified" :
5985                                                         "success";
5986
5987                                 var errMsg;
5988
5989                                 if ( status === "success" ) {
5990                                         // Watch for, and catch, XML document parse errors
5991                                         try {
5992                                                 // process the data (runs the xml through httpData regardless of callback)
5993                                                 data = jQuery.httpData( xhr, s.dataType, s );
5994                                         } catch( parserError ) {
5995                                                 status = "parsererror";
5996                                                 errMsg = parserError;
5997                                         }
5998                                 }
5999
6000                                 // Make sure that the request was successful or notmodified
6001                                 if ( status === "success" || status === "notmodified" ) {
6002                                         // JSONP handles its own success callback
6003                                         if ( !jsonp ) {
6004                                                 jQuery.handleSuccess( s, xhr, status, data );
6005                                         }
6006                                 } else {
6007                                         jQuery.handleError( s, xhr, status, errMsg );
6008                                 }
6009
6010                                 // Fire the complete handlers
6011                                 if ( !jsonp ) {
6012                                         jQuery.handleComplete( s, xhr, status, data );
6013                                 }
6014
6015                                 if ( isTimeout === "timeout" ) {
6016                                         xhr.abort();
6017                                 }
6018
6019                                 // Stop memory leaks
6020                                 if ( s.async ) {
6021                                         xhr = null;
6022                                 }
6023                         }
6024                 };
6025
6026                 // Override the abort handler, if we can (IE 6 doesn't allow it, but that's OK)
6027                 // Opera doesn't fire onreadystatechange at all on abort
6028                 try {
6029                         var oldAbort = xhr.abort;
6030                         xhr.abort = function() {
6031                                 if ( xhr ) {
6032                                         // oldAbort has no call property in IE7 so
6033                                         // just do it this way, which works in all
6034                                         // browsers
6035                                         Function.prototype.call.call( oldAbort, xhr );
6036                                 }
6037
6038                                 onreadystatechange( "abort" );
6039                         };
6040                 } catch( abortError ) {}
6041
6042                 // Timeout checker
6043                 if ( s.async && s.timeout > 0 ) {
6044                         setTimeout(function() {
6045                                 // Check to see if the request is still happening
6046                                 if ( xhr && !requestDone ) {
6047                                         onreadystatechange( "timeout" );
6048                                 }
6049                         }, s.timeout);
6050                 }
6051
6052                 // Send the data
6053                 try {
6054                         xhr.send( noContent || s.data == null ? null : s.data );
6055
6056                 } catch( sendError ) {
6057                         jQuery.handleError( s, xhr, null, sendError );
6058
6059                         // Fire the complete handlers
6060                         jQuery.handleComplete( s, xhr, status, data );
6061                 }
6062
6063                 // firefox 1.5 doesn't fire statechange for sync requests
6064                 if ( !s.async ) {
6065                         onreadystatechange();
6066                 }
6067
6068                 // return XMLHttpRequest to allow aborting the request etc.
6069                 return xhr;
6070         },
6071
6072         // Serialize an array of form elements or a set of
6073         // key/values into a query string
6074         param: function( a, traditional ) {
6075                 var s = [],
6076                         add = function( key, value ) {
6077                                 // If value is a function, invoke it and return its value
6078                                 value = jQuery.isFunction(value) ? value() : value;
6079                                 s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
6080                         };
6081
6082                 // Set traditional to true for jQuery <= 1.3.2 behavior.
6083                 if ( traditional === undefined ) {
6084                         traditional = jQuery.ajaxSettings.traditional;
6085                 }
6086
6087                 // If an array was passed in, assume that it is an array of form elements.
6088                 if ( jQuery.isArray(a) || a.jquery ) {
6089                         // Serialize the form elements
6090                         jQuery.each( a, function() {
6091                                 add( this.name, this.value );
6092                         });
6093
6094                 } else {
6095                         // If traditional, encode the "old" way (the way 1.3.2 or older
6096                         // did it), otherwise encode params recursively.
6097                         for ( var prefix in a ) {
6098                                 buildParams( prefix, a[prefix], traditional, add );
6099                         }
6100                 }
6101
6102                 // Return the resulting serialization
6103                 return s.join("&").replace(r20, "+");
6104         }
6105 });
6106
6107 function buildParams( prefix, obj, traditional, add ) {
6108         if ( jQuery.isArray(obj) && obj.length ) {
6109                 // Serialize array item.
6110                 jQuery.each( obj, function( i, v ) {
6111                         if ( traditional || rbracket.test( prefix ) ) {
6112                                 // Treat each array item as a scalar.
6113                                 add( prefix, v );
6114
6115                         } else {
6116                                 // If array item is non-scalar (array or object), encode its
6117                                 // numeric index to resolve deserialization ambiguity issues.
6118                                 // Note that rack (as of 1.0.0) can't currently deserialize
6119                                 // nested arrays properly, and attempting to do so may cause
6120                                 // a server error. Possible fixes are to modify rack's
6121                                 // deserialization algorithm or to provide an option or flag
6122                                 // to force array serialization to be shallow.
6123                                 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
6124                         }
6125                 });
6126
6127         } else if ( !traditional && obj != null && typeof obj === "object" ) {
6128                 if ( jQuery.isEmptyObject( obj ) ) {
6129                         add( prefix, "" );
6130
6131                 // Serialize object item.
6132                 } else {
6133                         jQuery.each( obj, function( k, v ) {
6134                                 buildParams( prefix + "[" + k + "]", v, traditional, add );
6135                         });
6136                 }
6137
6138         } else {
6139                 // Serialize scalar item.
6140                 add( prefix, obj );
6141         }
6142 }
6143
6144 // This is still on the jQuery object... for now
6145 // Want to move this to jQuery.ajax some day
6146 jQuery.extend({
6147
6148         // Counter for holding the number of active queries
6149         active: 0,
6150
6151         // Last-Modified header cache for next request
6152         lastModified: {},
6153         etag: {},
6154
6155         handleError: function( s, xhr, status, e ) {
6156                 // If a local callback was specified, fire it
6157                 if ( s.error ) {
6158                         s.error.call( s.context, xhr, status, e );
6159                 }
6160
6161                 // Fire the global callback
6162                 if ( s.global ) {
6163                         jQuery.triggerGlobal( s, "ajaxError", [xhr, s, e] );
6164                 }
6165         },
6166
6167         handleSuccess: function( s, xhr, status, data ) {
6168                 // If a local callback was specified, fire it and pass it the data
6169                 if ( s.success ) {
6170                         s.success.call( s.context, data, status, xhr );
6171                 }
6172
6173                 // Fire the global callback
6174                 if ( s.global ) {
6175                         jQuery.triggerGlobal( s, "ajaxSuccess", [xhr, s] );
6176                 }
6177         },
6178
6179         handleComplete: function( s, xhr, status ) {
6180                 // Process result
6181                 if ( s.complete ) {
6182                         s.complete.call( s.context, xhr, status );
6183                 }
6184
6185                 // The request was completed
6186                 if ( s.global ) {
6187                         jQuery.triggerGlobal( s, "ajaxComplete", [xhr, s] );
6188                 }
6189
6190                 // Handle the global AJAX counter
6191                 if ( s.global && jQuery.active-- === 1 ) {
6192                         jQuery.event.trigger( "ajaxStop" );
6193                 }
6194         },
6195
6196         triggerGlobal: function( s, type, args ) {
6197                 (s.context && s.context.url == null ? jQuery(s.context) : jQuery.event).trigger(type, args);
6198         },
6199
6200         // Determines if an XMLHttpRequest was successful or not
6201         httpSuccess: function( xhr ) {
6202                 try {
6203                         // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
6204                         return !xhr.status && location.protocol === "file:" ||
6205                                 xhr.status >= 200 && xhr.status < 300 ||
6206                                 xhr.status === 304 || xhr.status === 1223;
6207                 } catch(e) {}
6208
6209                 return false;
6210         },
6211
6212         // Determines if an XMLHttpRequest returns NotModified
6213         httpNotModified: function( xhr, url ) {
6214                 var lastModified = xhr.getResponseHeader("Last-Modified"),
6215                         etag = xhr.getResponseHeader("Etag");
6216
6217                 if ( lastModified ) {
6218                         jQuery.lastModified[url] = lastModified;
6219                 }
6220
6221                 if ( etag ) {
6222                         jQuery.etag[url] = etag;
6223                 }
6224
6225                 return xhr.status === 304;
6226         },
6227
6228         httpData: function( xhr, type, s ) {
6229                 var ct = xhr.getResponseHeader("content-type") || "",
6230                         xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
6231                         data = xml ? xhr.responseXML : xhr.responseText;
6232
6233                 if ( xml && data.documentElement.nodeName === "parsererror" ) {
6234                         jQuery.error( "parsererror" );
6235                 }
6236
6237                 // Allow a pre-filtering function to sanitize the response
6238                 // s is checked to keep backwards compatibility
6239                 if ( s && s.dataFilter ) {
6240                         data = s.dataFilter( data, type );
6241                 }
6242
6243                 // The filter can actually parse the response
6244                 if ( typeof data === "string" ) {
6245                         // Get the JavaScript object, if JSON is used.
6246                         if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
6247                                 data = jQuery.parseJSON( data );
6248
6249                         // If the type is "script", eval it in global context
6250                         } else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
6251                                 jQuery.globalEval( data );
6252                         }
6253                 }
6254
6255                 return data;
6256         }
6257
6258 });
6259
6260 /*
6261  * Create the request object; Microsoft failed to properly
6262  * implement the XMLHttpRequest in IE7 (can't request local files),
6263  * so we use the ActiveXObject when it is available
6264  * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
6265  * we need a fallback.
6266  */
6267 if ( window.ActiveXObject ) {
6268         jQuery.ajaxSettings.xhr = function() {
6269                 if ( window.location.protocol !== "file:" ) {
6270                         try {
6271                                 return new window.XMLHttpRequest();
6272                         } catch(xhrError) {}
6273                 }
6274
6275                 try {
6276                         return new window.ActiveXObject("Microsoft.XMLHTTP");
6277                 } catch(activeError) {}
6278         };
6279 }
6280
6281 // Does this browser support XHR requests?
6282 jQuery.support.ajax = !!jQuery.ajaxSettings.xhr();
6283
6284
6285
6286
6287 var elemdisplay = {},
6288         rfxtypes = /^(?:toggle|show|hide)$/,
6289         rfxnum = /^([+\-]=)?([\d+.\-]+)(.*)$/,
6290         timerId,
6291         fxAttrs = [
6292                 // height animations
6293                 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
6294                 // width animations
6295                 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
6296                 // opacity animations
6297                 [ "opacity" ]
6298         ];
6299
6300 jQuery.fn.extend({
6301         show: function( speed, easing, callback ) {
6302                 var elem, display;
6303
6304                 if ( speed || speed === 0 ) {
6305                         return this.animate( genFx("show", 3), speed, easing, callback);
6306
6307                 } else {
6308                         for ( var i = 0, j = this.length; i < j; i++ ) {
6309                                 elem = this[i];
6310                                 display = elem.style.display;
6311
6312                                 // Reset the inline display of this element to learn if it is
6313                                 // being hidden by cascaded rules or not
6314                                 if ( !jQuery.data(elem, "olddisplay") && display === "none" ) {
6315                                         display = elem.style.display = "";
6316                                 }
6317
6318                                 // Set elements which have been overridden with display: none
6319                                 // in a stylesheet to whatever the default browser style is
6320                                 // for such an element
6321                                 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
6322                                         jQuery.data(elem, "olddisplay", defaultDisplay(elem.nodeName));
6323                                 }
6324                         }
6325
6326                         // Set the display of most of the elements in a second loop
6327                         // to avoid the constant reflow
6328                         for ( i = 0; i < j; i++ ) {
6329                                 elem = this[i];
6330                                 display = elem.style.display;
6331
6332                                 if ( display === "" || display === "none" ) {
6333                                         elem.style.display = jQuery.data(elem, "olddisplay") || "";
6334                                 }
6335                         }
6336
6337                         return this;
6338                 }
6339         },
6340
6341         hide: function( speed, easing, callback ) {
6342                 if ( speed || speed === 0 ) {
6343                         return this.animate( genFx("hide", 3), speed, easing, callback);
6344
6345                 } else {
6346                         for ( var i = 0, j = this.length; i < j; i++ ) {
6347                                 var display = jQuery.css( this[i], "display" );
6348
6349                                 if ( display !== "none" ) {
6350                                         jQuery.data( this[i], "olddisplay", display );
6351                                 }
6352                         }
6353
6354                         // Set the display of the elements in a second loop
6355                         // to avoid the constant reflow
6356                         for ( i = 0; i < j; i++ ) {
6357                                 this[i].style.display = "none";
6358                         }
6359
6360                         return this;
6361                 }
6362         },
6363
6364         // Save the old toggle function
6365         _toggle: jQuery.fn.toggle,
6366
6367         toggle: function( fn, fn2, callback ) {
6368                 var bool = typeof fn === "boolean";
6369
6370                 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
6371                         this._toggle.apply( this, arguments );
6372
6373                 } else if ( fn == null || bool ) {
6374                         this.each(function() {
6375                                 var state = bool ? fn : jQuery(this).is(":hidden");
6376                                 jQuery(this)[ state ? "show" : "hide" ]();
6377                         });
6378
6379                 } else {
6380                         this.animate(genFx("toggle", 3), fn, fn2, callback);
6381                 }
6382
6383                 return this;
6384         },
6385
6386         fadeTo: function( speed, to, easing, callback ) {
6387                 return this.filter(":hidden").css("opacity", 0).show().end()
6388                                         .animate({opacity: to}, speed, easing, callback);
6389         },
6390
6391         animate: function( prop, speed, easing, callback ) {
6392                 var optall = jQuery.speed(speed, easing, callback);
6393
6394                 if ( jQuery.isEmptyObject( prop ) ) {
6395                         return this.each( optall.complete );
6396                 }
6397
6398                 return this[ optall.queue === false ? "each" : "queue" ](function() {
6399                         // XXX 'this' does not always have a nodeName when running the
6400                         // test suite
6401
6402                         var opt = jQuery.extend({}, optall), p,
6403                                 isElement = this.nodeType === 1,
6404                                 hidden = isElement && jQuery(this).is(":hidden"),
6405                                 self = this;
6406
6407                         for ( p in prop ) {
6408                                 var name = jQuery.camelCase( p );
6409
6410                                 if ( p !== name ) {
6411                                         prop[ name ] = prop[ p ];
6412                                         delete prop[ p ];
6413                                         p = name;
6414                                 }
6415
6416                                 if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
6417                                         return opt.complete.call(this);
6418                                 }
6419
6420                                 if ( isElement && ( p === "height" || p === "width" ) ) {
6421                                         // Make sure that nothing sneaks out
6422                                         // Record all 3 overflow attributes because IE does not
6423                                         // change the overflow attribute when overflowX and
6424                                         // overflowY are set to the same value
6425                                         opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
6426
6427                                         // Set display property to inline-block for height/width
6428                                         // animations on inline elements that are having width/height
6429                                         // animated
6430                                         if ( jQuery.css( this, "display" ) === "inline" &&
6431                                                         jQuery.css( this, "float" ) === "none" ) {
6432                                                 if ( !jQuery.support.inlineBlockNeedsLayout ) {
6433                                                         this.style.display = "inline-block";
6434
6435                                                 } else {
6436                                                         var display = defaultDisplay(this.nodeName);
6437
6438                                                         // inline-level elements accept inline-block;
6439                                                         // block-level elements need to be inline with layout
6440                                                         if ( display === "inline" ) {
6441                                                                 this.style.display = "inline-block";
6442
6443                                                         } else {
6444                                                                 this.style.display = "inline";
6445                                                                 this.style.zoom = 1;
6446                                                         }
6447                                                 }
6448                                         }
6449                                 }
6450
6451                                 if ( jQuery.isArray( prop[p] ) ) {
6452                                         // Create (if needed) and add to specialEasing
6453                                         (opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
6454                                         prop[p] = prop[p][0];
6455                                 }
6456                         }
6457
6458                         if ( opt.overflow != null ) {
6459                                 this.style.overflow = "hidden";
6460                         }
6461
6462                         opt.curAnim = jQuery.extend({}, prop);
6463
6464                         jQuery.each( prop, function( name, val ) {
6465                                 var e = new jQuery.fx( self, opt, name );
6466
6467                                 if ( rfxtypes.test(val) ) {
6468                                         e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
6469
6470                                 } else {
6471                                         var parts = rfxnum.exec(val),
6472                                                 start = e.cur() || 0;
6473
6474                                         if ( parts ) {
6475                                                 var end = parseFloat( parts[2] ),
6476                                                         unit = parts[3] || "px";
6477
6478                                                 // We need to compute starting value
6479                                                 if ( unit !== "px" ) {
6480                                                         jQuery.style( self, name, (end || 1) + unit);
6481                                                         start = ((end || 1) / e.cur()) * start;
6482                                                         jQuery.style( self, name, start + unit);
6483                                                 }
6484
6485                                                 // If a +=/-= token was provided, we're doing a relative animation
6486                                                 if ( parts[1] ) {
6487                                                         end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
6488                                                 }
6489
6490                                                 e.custom( start, end, unit );
6491
6492                                         } else {
6493                                                 e.custom( start, val, "" );
6494                                         }
6495                                 }
6496                         });
6497
6498                         // For JS strict compliance
6499                         return true;
6500                 });
6501         },
6502
6503         stop: function( clearQueue, gotoEnd ) {
6504                 var timers = jQuery.timers;
6505
6506                 if ( clearQueue ) {
6507                         this.queue([]);
6508                 }
6509
6510                 this.each(function() {
6511                         // go in reverse order so anything added to the queue during the loop is ignored
6512                         for ( var i = timers.length - 1; i >= 0; i-- ) {
6513                                 if ( timers[i].elem === this ) {
6514                                         if (gotoEnd) {
6515                                                 // force the next step to be the last
6516                                                 timers[i](true);
6517                                         }
6518
6519                                         timers.splice(i, 1);
6520                                 }
6521                         }
6522                 });
6523
6524                 // start the next in the queue if the last step wasn't forced
6525                 if ( !gotoEnd ) {
6526                         this.dequeue();
6527                 }
6528
6529                 return this;
6530         }
6531
6532 });
6533
6534 function genFx( type, num ) {
6535         var obj = {};
6536
6537         jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
6538                 obj[ this ] = type;
6539         });
6540
6541         return obj;
6542 }
6543
6544 // Generate shortcuts for custom animations
6545 jQuery.each({
6546         slideDown: genFx("show", 1),
6547         slideUp: genFx("hide", 1),
6548         slideToggle: genFx("toggle", 1),
6549         fadeIn: { opacity: "show" },
6550         fadeOut: { opacity: "hide" },
6551         fadeToggle: { opacity: "toggle" }
6552 }, function( name, props ) {
6553         jQuery.fn[ name ] = function( speed, easing, callback ) {
6554                 return this.animate( props, speed, easing, callback );
6555         };
6556 });
6557
6558 jQuery.extend({
6559         speed: function( speed, easing, fn ) {
6560                 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
6561                         complete: fn || !fn && easing ||
6562                                 jQuery.isFunction( speed ) && speed,
6563                         duration: speed,
6564                         easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
6565                 };
6566
6567                 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
6568                         opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
6569
6570                 // Queueing
6571                 opt.old = opt.complete;
6572                 opt.complete = function() {
6573                         if ( opt.queue !== false ) {
6574                                 jQuery(this).dequeue();
6575                         }
6576                         if ( jQuery.isFunction( opt.old ) ) {
6577                                 opt.old.call( this );
6578                         }
6579                 };
6580
6581                 return opt;
6582         },
6583
6584         easing: {
6585                 linear: function( p, n, firstNum, diff ) {
6586                         return firstNum + diff * p;
6587                 },
6588                 swing: function( p, n, firstNum, diff ) {
6589                         return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
6590                 }
6591         },
6592
6593         timers: [],
6594
6595         fx: function( elem, options, prop ) {
6596                 this.options = options;
6597                 this.elem = elem;
6598                 this.prop = prop;
6599
6600                 if ( !options.orig ) {
6601                         options.orig = {};
6602                 }
6603         }
6604
6605 });
6606
6607 jQuery.fx.prototype = {
6608         // Simple function for setting a style value
6609         update: function() {
6610                 if ( this.options.step ) {
6611                         this.options.step.call( this.elem, this.now, this );
6612                 }
6613
6614                 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
6615         },
6616
6617         // Get the current size
6618         cur: function() {
6619                 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
6620                         return this.elem[ this.prop ];
6621                 }
6622
6623                 var r = parseFloat( jQuery.css( this.elem, this.prop ) );
6624                 return r && r > -10000 ? r : 0;
6625         },
6626
6627         // Start an animation from one number to another
6628         custom: function( from, to, unit ) {
6629                 var self = this,
6630                         fx = jQuery.fx;
6631
6632                 this.startTime = jQuery.now();
6633                 this.start = from;
6634                 this.end = to;
6635                 this.unit = unit || this.unit || "px";
6636                 this.now = this.start;
6637                 this.pos = this.state = 0;
6638
6639                 function t( gotoEnd ) {
6640                         return self.step(gotoEnd);
6641                 }
6642
6643                 t.elem = this.elem;
6644
6645                 if ( t() && jQuery.timers.push(t) && !timerId ) {
6646                         timerId = setInterval(fx.tick, fx.interval);
6647                 }
6648         },
6649
6650         // Simple 'show' function
6651         show: function() {
6652                 // Remember where we started, so that we can go back to it later
6653                 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
6654                 this.options.show = true;
6655
6656                 // Begin the animation
6657                 // Make sure that we start at a small width/height to avoid any
6658                 // flash of content
6659                 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
6660
6661                 // Start by showing the element
6662                 jQuery( this.elem ).show();
6663         },
6664
6665         // Simple 'hide' function
6666         hide: function() {
6667                 // Remember where we started, so that we can go back to it later
6668                 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
6669                 this.options.hide = true;
6670
6671                 // Begin the animation
6672                 this.custom(this.cur(), 0);
6673         },
6674
6675         // Each step of an animation
6676         step: function( gotoEnd ) {
6677                 var t = jQuery.now(), done = true;
6678
6679                 if ( gotoEnd || t >= this.options.duration + this.startTime ) {
6680                         this.now = this.end;
6681                         this.pos = this.state = 1;
6682                         this.update();
6683
6684                         this.options.curAnim[ this.prop ] = true;
6685
6686                         for ( var i in this.options.curAnim ) {
6687                                 if ( this.options.curAnim[i] !== true ) {
6688                                         done = false;
6689                                 }
6690                         }
6691
6692                         if ( done ) {
6693                                 // Reset the overflow
6694                                 if ( this.options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
6695                                         var elem = this.elem,
6696                                                 options = this.options;
6697
6698                                         jQuery.each( [ "", "X", "Y" ], function (index, value) {
6699                                                 elem.style[ "overflow" + value ] = options.overflow[index];
6700                                         } );
6701                                 }
6702
6703                                 // Hide the element if the "hide" operation was done
6704                                 if ( this.options.hide ) {
6705                                         jQuery(this.elem).hide();
6706                                 }
6707
6708                                 // Reset the properties, if the item has been hidden or shown
6709                                 if ( this.options.hide || this.options.show ) {
6710                                         for ( var p in this.options.curAnim ) {
6711                                                 jQuery.style( this.elem, p, this.options.orig[p] );
6712                                         }
6713                                 }
6714
6715                                 // Execute the complete function
6716                                 this.options.complete.call( this.elem );
6717                         }
6718
6719                         return false;
6720
6721                 } else {
6722                         var n = t - this.startTime;
6723                         this.state = n / this.options.duration;
6724
6725                         // Perform the easing function, defaults to swing
6726                         var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
6727                         var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
6728                         this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
6729                         this.now = this.start + ((this.end - this.start) * this.pos);
6730
6731                         // Perform the next step of the animation
6732                         this.update();
6733                 }
6734
6735                 return true;
6736         }
6737 };
6738
6739 jQuery.extend( jQuery.fx, {
6740         tick: function() {
6741                 var timers = jQuery.timers;
6742
6743                 for ( var i = 0; i < timers.length; i++ ) {
6744                         if ( !timers[i]() ) {
6745                                 timers.splice(i--, 1);
6746                         }
6747                 }
6748
6749                 if ( !timers.length ) {
6750                         jQuery.fx.stop();
6751                 }
6752         },
6753
6754         interval: 13,
6755
6756         stop: function() {
6757                 clearInterval( timerId );
6758                 timerId = null;
6759         },
6760
6761         speeds: {
6762                 slow: 600,
6763                 fast: 200,
6764                 // Default speed
6765                 _default: 400
6766         },
6767
6768         step: {
6769                 opacity: function( fx ) {
6770                         jQuery.style( fx.elem, "opacity", fx.now );
6771                 },
6772
6773                 _default: function( fx ) {
6774                         if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
6775                                 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
6776                         } else {
6777                                 fx.elem[ fx.prop ] = fx.now;
6778                         }
6779                 }
6780         }
6781 });
6782
6783 if ( jQuery.expr && jQuery.expr.filters ) {
6784         jQuery.expr.filters.animated = function( elem ) {
6785                 return jQuery.grep(jQuery.timers, function( fn ) {
6786                         return elem === fn.elem;
6787                 }).length;
6788         };
6789 }
6790
6791 function defaultDisplay( nodeName ) {
6792         if ( !elemdisplay[ nodeName ] ) {
6793                 var elem = jQuery("<" + nodeName + ">").appendTo("body"),
6794                         display = elem.css("display");
6795
6796                 elem.remove();
6797
6798                 if ( display === "none" || display === "" ) {
6799                         display = "block";
6800                 }
6801
6802                 elemdisplay[ nodeName ] = display;
6803         }
6804
6805         return elemdisplay[ nodeName ];
6806 }
6807
6808
6809
6810
6811 var rtable = /^t(?:able|d|h)$/i,
6812         rroot = /^(?:body|html)$/i;
6813
6814 if ( "getBoundingClientRect" in document.documentElement ) {
6815         jQuery.fn.offset = function( options ) {
6816                 var elem = this[0], box;
6817
6818                 if ( options ) {
6819                         return this.each(function( i ) {
6820                                 jQuery.offset.setOffset( this, options, i );
6821                         });
6822                 }
6823
6824                 if ( !elem || !elem.ownerDocument ) {
6825                         return null;
6826                 }
6827
6828                 if ( elem === elem.ownerDocument.body ) {
6829                         return jQuery.offset.bodyOffset( elem );
6830                 }
6831
6832                 try {
6833                         box = elem.getBoundingClientRect();
6834                 } catch(e) {}
6835
6836                 var doc = elem.ownerDocument,
6837                         docElem = doc.documentElement;
6838
6839                 // Make sure we're not dealing with a disconnected DOM node
6840                 if ( !box || !jQuery.contains( docElem, elem ) ) {
6841                         return box || { top: 0, left: 0 };
6842                 }
6843
6844                 var body = doc.body,
6845                         win = getWindow(doc),
6846                         clientTop  = docElem.clientTop  || body.clientTop  || 0,
6847                         clientLeft = docElem.clientLeft || body.clientLeft || 0,
6848                         scrollTop  = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ),
6849                         scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft),
6850                         top  = box.top  + scrollTop  - clientTop,
6851                         left = box.left + scrollLeft - clientLeft;
6852
6853                 return { top: top, left: left };
6854         };
6855
6856 } else {
6857         jQuery.fn.offset = function( options ) {
6858                 var elem = this[0];
6859
6860                 if ( options ) {
6861                         return this.each(function( i ) {
6862                                 jQuery.offset.setOffset( this, options, i );
6863                         });
6864                 }
6865
6866                 if ( !elem || !elem.ownerDocument ) {
6867                         return null;
6868                 }
6869
6870                 if ( elem === elem.ownerDocument.body ) {
6871                         return jQuery.offset.bodyOffset( elem );
6872                 }
6873
6874                 jQuery.offset.initialize();
6875
6876                 var computedStyle,
6877                         offsetParent = elem.offsetParent,
6878                         prevOffsetParent = elem,
6879                         doc = elem.ownerDocument,
6880                         docElem = doc.documentElement,
6881                         body = doc.body,
6882                         defaultView = doc.defaultView,
6883                         prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
6884                         top = elem.offsetTop,
6885                         left = elem.offsetLeft;
6886
6887                 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
6888                         if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
6889                                 break;
6890                         }
6891
6892                         computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
6893                         top  -= elem.scrollTop;
6894                         left -= elem.scrollLeft;
6895
6896                         if ( elem === offsetParent ) {
6897                                 top  += elem.offsetTop;
6898                                 left += elem.offsetLeft;
6899
6900                                 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
6901                                         top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
6902                                         left += parseFloat( computedStyle.borderLeftWidth ) || 0;
6903                                 }
6904
6905                                 prevOffsetParent = offsetParent;
6906                                 offsetParent = elem.offsetParent;
6907                         }
6908
6909                         if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
6910                                 top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
6911                                 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
6912                         }
6913
6914                         prevComputedStyle = computedStyle;
6915                 }
6916
6917                 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
6918                         top  += body.offsetTop;
6919                         left += body.offsetLeft;
6920                 }
6921
6922                 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
6923                         top  += Math.max( docElem.scrollTop, body.scrollTop );
6924                         left += Math.max( docElem.scrollLeft, body.scrollLeft );
6925                 }
6926
6927                 return { top: top, left: left };
6928         };
6929 }
6930
6931 jQuery.offset = {
6932         initialize: function() {
6933                 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
6934                         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>";
6935
6936                 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
6937
6938                 container.innerHTML = html;
6939                 body.insertBefore( container, body.firstChild );
6940                 innerDiv = container.firstChild;
6941                 checkDiv = innerDiv.firstChild;
6942                 td = innerDiv.nextSibling.firstChild.firstChild;
6943
6944                 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
6945                 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
6946
6947                 checkDiv.style.position = "fixed";
6948                 checkDiv.style.top = "20px";
6949
6950                 // safari subtracts parent border width here which is 5px
6951                 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
6952                 checkDiv.style.position = checkDiv.style.top = "";
6953
6954                 innerDiv.style.overflow = "hidden";
6955                 innerDiv.style.position = "relative";
6956
6957                 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
6958
6959                 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
6960
6961                 body.removeChild( container );
6962                 body = container = innerDiv = checkDiv = table = td = null;
6963                 jQuery.offset.initialize = jQuery.noop;
6964         },
6965
6966         bodyOffset: function( body ) {
6967                 var top = body.offsetTop,
6968                         left = body.offsetLeft;
6969
6970                 jQuery.offset.initialize();
6971
6972                 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
6973                         top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
6974                         left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
6975                 }
6976
6977                 return { top: top, left: left };
6978         },
6979
6980         setOffset: function( elem, options, i ) {
6981                 var position = jQuery.css( elem, "position" );
6982
6983                 // set position first, in-case top/left are set even on static elem
6984                 if ( position === "static" ) {
6985                         elem.style.position = "relative";
6986                 }
6987
6988                 var curElem = jQuery( elem ),
6989                         curOffset = curElem.offset(),
6990                         curCSSTop = jQuery.css( elem, "top" ),
6991                         curCSSLeft = jQuery.css( elem, "left" ),
6992                         calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1),
6993                         props = {}, curPosition = {}, curTop, curLeft;
6994
6995                 // need to be able to calculate position if either top or left is auto and position is absolute
6996                 if ( calculatePosition ) {
6997                         curPosition = curElem.position();
6998                 }
6999
7000                 curTop  = calculatePosition ? curPosition.top  : parseInt( curCSSTop,  10 ) || 0;
7001                 curLeft = calculatePosition ? curPosition.left : parseInt( curCSSLeft, 10 ) || 0;
7002
7003                 if ( jQuery.isFunction( options ) ) {
7004                         options = options.call( elem, i, curOffset );
7005                 }
7006
7007                 if (options.top != null) {
7008                         props.top = (options.top - curOffset.top) + curTop;
7009                 }
7010                 if (options.left != null) {
7011                         props.left = (options.left - curOffset.left) + curLeft;
7012                 }
7013
7014                 if ( "using" in options ) {
7015                         options.using.call( elem, props );
7016                 } else {
7017                         curElem.css( props );
7018                 }
7019         }
7020 };
7021
7022
7023 jQuery.fn.extend({
7024         position: function() {
7025                 if ( !this[0] ) {
7026                         return null;
7027                 }
7028
7029                 var elem = this[0],
7030
7031                 // Get *real* offsetParent
7032                 offsetParent = this.offsetParent(),
7033
7034                 // Get correct offsets
7035                 offset       = this.offset(),
7036                 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
7037
7038                 // Subtract element margins
7039                 // note: when an element has margin: auto the offsetLeft and marginLeft
7040                 // are the same in Safari causing offset.left to incorrectly be 0
7041                 offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
7042                 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
7043
7044                 // Add offsetParent borders
7045                 parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
7046                 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
7047
7048                 // Subtract the two offsets
7049                 return {
7050                         top:  offset.top  - parentOffset.top,
7051                         left: offset.left - parentOffset.left
7052                 };
7053         },
7054
7055         offsetParent: function() {
7056                 return this.map(function() {
7057                         var offsetParent = this.offsetParent || document.body;
7058                         while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
7059                                 offsetParent = offsetParent.offsetParent;
7060                         }
7061                         return offsetParent;
7062                 });
7063         }
7064 });
7065
7066
7067 // Create scrollLeft and scrollTop methods
7068 jQuery.each( ["Left", "Top"], function( i, name ) {
7069         var method = "scroll" + name;
7070
7071         jQuery.fn[ method ] = function(val) {
7072                 var elem = this[0], win;
7073
7074                 if ( !elem ) {
7075                         return null;
7076                 }
7077
7078                 if ( val !== undefined ) {
7079                         // Set the scroll offset
7080                         return this.each(function() {
7081                                 win = getWindow( this );
7082
7083                                 if ( win ) {
7084                                         win.scrollTo(
7085                                                 !i ? val : jQuery(win).scrollLeft(),
7086                                                  i ? val : jQuery(win).scrollTop()
7087                                         );
7088
7089                                 } else {
7090                                         this[ method ] = val;
7091                                 }
7092                         });
7093                 } else {
7094                         win = getWindow( elem );
7095
7096                         // Return the scroll offset
7097                         return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
7098                                 jQuery.support.boxModel && win.document.documentElement[ method ] ||
7099                                         win.document.body[ method ] :
7100                                 elem[ method ];
7101                 }
7102         };
7103 });
7104
7105 function getWindow( elem ) {
7106         return jQuery.isWindow( elem ) ?
7107                 elem :
7108                 elem.nodeType === 9 ?
7109                         elem.defaultView || elem.parentWindow :
7110                         false;
7111 }
7112
7113
7114
7115
7116 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
7117 jQuery.each([ "Height", "Width" ], function( i, name ) {
7118
7119         var type = name.toLowerCase();
7120
7121         // innerHeight and innerWidth
7122         jQuery.fn["inner" + name] = function() {
7123                 return this[0] ?
7124                         parseFloat( jQuery.css( this[0], type, "padding" ) ) :
7125                         null;
7126         };
7127
7128         // outerHeight and outerWidth
7129         jQuery.fn["outer" + name] = function( margin ) {
7130                 return this[0] ?
7131                         parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
7132                         null;
7133         };
7134
7135         jQuery.fn[ type ] = function( size ) {
7136                 // Get window width or height
7137                 var elem = this[0];
7138                 if ( !elem ) {
7139                         return size == null ? null : this;
7140                 }
7141
7142                 if ( jQuery.isFunction( size ) ) {
7143                         return this.each(function( i ) {
7144                                 var self = jQuery( this );
7145                                 self[ type ]( size.call( this, i, self[ type ]() ) );
7146                         });
7147                 }
7148
7149                 if ( jQuery.isWindow( elem ) ) {
7150                         // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
7151                         return elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
7152                                 elem.document.body[ "client" + name ];
7153
7154                 // Get document width or height
7155                 } else if ( elem.nodeType === 9 ) {
7156                         // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
7157                         return Math.max(
7158                                 elem.documentElement["client" + name],
7159                                 elem.body["scroll" + name], elem.documentElement["scroll" + name],
7160                                 elem.body["offset" + name], elem.documentElement["offset" + name]
7161                         );
7162
7163                 // Get or set width or height on the element
7164                 } else if ( size === undefined ) {
7165                         var orig = jQuery.css( elem, type ),
7166                                 ret = parseFloat( orig );
7167
7168                         return jQuery.isNaN( ret ) ? orig : ret;
7169
7170                 // Set the width or height on the element (default to pixels if value is unitless)
7171                 } else {
7172                         return this.css( type, typeof size === "string" ? size : size + "px" );
7173                 }
7174         };
7175
7176 });
7177
7178
7179 })(window);