src/main/resources/static/javascript/jquery-1.4.2.js

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