wx/viewers/flexpaper/js/jquery.js

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