Bug Tracker

Ticket #4158: test2.html

File test2.html, 122.2 KB (added by initjh, 13 years ago)

Test Case 1

Line 
1<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2<html xmlns="http://www.w3.org/1999/xhtml" lang="nl" xml:lang="nl">
3
4<head>
5        <script type="text/javascript">
6    //copy/pasted from Sizzle github test/jquery.js
7    //behaves same as jQuery 1.3.1 stable and jQuery trunk
8   
9/*!
10 * jQuery JavaScript Library v1.3.1
11 * http://jquery.com/
12 *
13 * Copyright (c) 2009 John Resig
14 * Dual licensed under the MIT and GPL licenses.
15 * http://docs.jquery.com/License
16 *
17 * Date: 2009-02-14 13:10:45 -0500 (Sat, 14 Feb 2009)
18 * Revision: 6200
19 */
20(function(){
21
22var 
23        // Will speed up references to window, and allows munging its name.
24        window = this,
25        // Will speed up references to undefined, and allows munging its name.
26        undefined,
27        // Map over jQuery in case of overwrite
28        _jQuery = window.jQuery,
29        // Map over the $ in case of overwrite
30        _$ = window.$,
31
32        jQuery = window.jQuery = window.$ = function( selector, context ) {
33                // The jQuery object is actually just the init constructor 'enhanced'
34                return new jQuery.fn.init( selector, context );
35        },
36
37        // A simple way to check for HTML strings or ID strings
38        // (both of which we optimize for)
39        quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
40        // Is it a simple selector
41        isSimple = /^.[^:#\[\.,]*$/;
42
43jQuery.fn = jQuery.prototype = {
44        init: function( selector, context ) {
45                // Make sure that a selection was provided
46                selector = selector || document;
47
48                // Handle $(DOMElement)
49                if ( selector.nodeType ) {
50                        this[0] = selector;
51                        this.length = 1;
52                        this.context = selector;
53                        return this;
54                }
55                // Handle HTML strings
56                if ( typeof selector === "string" ) {
57                        // Are we dealing with HTML string or an ID?
58                        var match = quickExpr.exec( selector );
59
60                        // Verify a match, and that no context was specified for #id
61                        if ( match && (match[1] || !context) ) {
62
63                                // HANDLE: $(html) -> $(array)
64                                if ( match[1] )
65                                        selector = jQuery.clean( [ match[1] ], context );
66
67                                // HANDLE: $("#id")
68                                else {
69                                        var elem = document.getElementById( match[3] );
70
71                                        // Handle the case where IE and Opera return items
72                                        // by name instead of ID
73                                        if ( elem && elem.id != match[3] )
74                                                return jQuery().find( selector );
75
76                                        // Otherwise, we inject the element directly into the jQuery object
77                                        var ret = jQuery( elem || [] );
78                                        ret.context = document;
79                                        ret.selector = selector;
80                                        return ret;
81                                }
82
83                        // HANDLE: $(expr, [context])
84                        // (which is just equivalent to: $(content).find(expr)
85                        } else
86                                return jQuery( context ).find( selector );
87
88                // HANDLE: $(function)
89                // Shortcut for document ready
90                } else if ( jQuery.isFunction( selector ) )
91                        return jQuery( document ).ready( selector );
92
93                // Make sure that old selector state is passed along
94                if ( selector.selector && selector.context ) {
95                        this.selector = selector.selector;
96                        this.context = selector.context;
97                }
98
99                return this.setArray(jQuery.isArray( selector ) ?
100                        selector :
101                        jQuery.makeArray(selector));
102        },
103
104        // Start with an empty selector
105        selector: "",
106
107        // The current version of jQuery being used
108        jquery: "1.3.1",
109
110        // The number of elements contained in the matched element set
111        size: function() {
112                return this.length;
113        },
114
115        // Get the Nth element in the matched element set OR
116        // Get the whole matched element set as a clean array
117        get: function( num ) {
118                return num === undefined ?
119
120                        // Return a 'clean' array
121                        Array.prototype.slice.call( this ) :
122
123                        // Return just the object
124                        this[ num ];
125        },
126
127        // Take an array of elements and push it onto the stack
128        // (returning the new matched element set)
129        pushStack: function( elems, name, selector ) {
130                // Build a new jQuery matched element set
131                var ret = jQuery( elems );
132
133                // Add the old object onto the stack (as a reference)
134                ret.prevObject = this;
135
136                ret.context = this.context;
137
138                if ( name === "find" )
139                        ret.selector = this.selector + (this.selector ? " " : "") + selector;
140                else if ( name )
141                        ret.selector = this.selector + "." + name + "(" + selector + ")";
142
143                // Return the newly-formed element set
144                return ret;
145        },
146
147        // Force the current matched set of elements to become
148        // the specified array of elements (destroying the stack in the process)
149        // You should use pushStack() in order to do this, but maintain the stack
150        setArray: function( elems ) {
151                // Resetting the length to 0, then using the native Array push
152                // is a super-fast way to populate an object with array-like properties
153                this.length = 0;
154                Array.prototype.push.apply( this, elems );
155
156                return this;
157        },
158
159        // Execute a callback for every element in the matched set.
160        // (You can seed the arguments with an array of args, but this is
161        // only used internally.)
162        each: function( callback, args ) {
163                return jQuery.each( this, callback, args );
164        },
165
166        // Determine the position of an element within
167        // the matched set of elements
168        index: function( elem ) {
169                // Locate the position of the desired element
170                return jQuery.inArray(
171                        // If it receives a jQuery object, the first element is used
172                        elem && elem.jquery ? elem[0] : elem
173                , this );
174        },
175
176        attr: function( name, value, type ) {
177                var options = name;
178
179                // Look for the case where we're accessing a style value
180                if ( typeof name === "string" )
181                        if ( value === undefined )
182                                return this[0] && jQuery[ type || "attr" ]( this[0], name );
183
184                        else {
185                                options = {};
186                                options[ name ] = value;
187                        }
188
189                // Check to see if we're setting style values
190                return this.each(function(i){
191                        // Set all the styles
192                        for ( name in options )
193                                jQuery.attr(
194                                        type ?
195                                                this.style :
196                                                this,
197                                        name, jQuery.prop( this, options[ name ], type, i, name )
198                                );
199                });
200        },
201
202        css: function( key, value ) {
203                // ignore negative width and height values
204                if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
205                        value = undefined;
206                return this.attr( key, value, "curCSS" );
207        },
208
209        text: function( text ) {
210                if ( typeof text !== "object" && text != null )
211                        return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
212
213                var ret = "";
214
215                jQuery.each( text || this, function(){
216                        jQuery.each( this.childNodes, function(){
217                                if ( this.nodeType != 8 )
218                                        ret += this.nodeType != 1 ?
219                                                this.nodeValue :
220                                                jQuery.fn.text( [ this ] );
221                        });
222                });
223
224                return ret;
225        },
226
227        wrapAll: function( html ) {
228                if ( this[0] ) {
229                        // The elements to wrap the target around
230                        var wrap = jQuery( html, this[0].ownerDocument ).clone();
231
232                        if ( this[0].parentNode )
233                                wrap.insertBefore( this[0] );
234
235                        wrap.map(function(){
236                                var elem = this;
237
238                                while ( elem.firstChild )
239                                        elem = elem.firstChild;
240
241                                return elem;
242                        }).append(this);
243                }
244
245                return this;
246        },
247
248        wrapInner: function( html ) {
249                return this.each(function(){
250                        jQuery( this ).contents().wrapAll( html );
251                });
252        },
253
254        wrap: function( html ) {
255                return this.each(function(){
256                        jQuery( this ).wrapAll( html );
257                });
258        },
259
260        append: function() {
261                return this.domManip(arguments, true, function(elem){
262                        if (this.nodeType == 1)
263                                this.appendChild( elem );
264                });
265        },
266
267        prepend: function() {
268                return this.domManip(arguments, true, function(elem){
269                        if (this.nodeType == 1)
270                                this.insertBefore( elem, this.firstChild );
271                });
272        },
273
274        before: function() {
275                return this.domManip(arguments, false, function(elem){
276                        this.parentNode.insertBefore( elem, this );
277                });
278        },
279
280        after: function() {
281                return this.domManip(arguments, false, function(elem){
282                        this.parentNode.insertBefore( elem, this.nextSibling );
283                });
284        },
285
286        end: function() {
287                return this.prevObject || jQuery( [] );
288        },
289
290        // For internal use only.
291        // Behaves like an Array's .push method, not like a jQuery method.
292        push: [].push,
293        sort: [].sort,
294        splice: [].splice,
295
296        find: function( selector ) {
297                if ( this.length === 1 ) {
298                        var ret = this.pushStack( [], "find", selector );
299                        ret.length = 0;
300                        jQuery.find( selector, this[0], ret );
301                        return ret;
302                } else {
303                        return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){
304                                return jQuery.find( selector, elem );
305                        })), "find", selector );
306                }
307        },
308
309        clone: function( events ) {
310                // Do the clone
311                var ret = this.map(function(){
312                        if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
313                                // IE copies events bound via attachEvent when
314                                // using cloneNode. Calling detachEvent on the
315                                // clone will also remove the events from the orignal
316                                // In order to get around this, we use innerHTML.
317                                // Unfortunately, this means some modifications to
318                                // attributes in IE that are actually only stored
319                                // as properties will not be copied (such as the
320                                // the name attribute on an input).
321                                var html = this.outerHTML;
322                                if ( !html ) {
323                                        var div = this.ownerDocument.createElement("div");
324                                        div.appendChild( this.cloneNode(true) );
325                                        html = div.innerHTML;
326                                }
327
328                                return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];
329                        } else
330                                return this.cloneNode(true);
331                });
332
333                // Copy the events from the original to the clone
334                if ( events === true ) {
335                        var orig = this.find("*").andSelf(), i = 0;
336
337                        ret.find("*").andSelf().each(function(){
338                                if ( this.nodeName !== orig[i].nodeName )
339                                        return;
340
341                                var events = jQuery.data( orig[i], "events" );
342
343                                for ( var type in events ) {
344                                        for ( var handler in events[ type ] ) {
345                                                jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
346                                        }
347                                }
348
349                                i++;
350                        });
351                }
352
353                // Return the cloned set
354                return ret;
355        },
356
357        filter: function( selector ) {
358                return this.pushStack(
359                        jQuery.isFunction( selector ) &&
360                        jQuery.grep(this, function(elem, i){
361                                return selector.call( elem, i );
362                        }) ||
363
364                        jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
365                                return elem.nodeType === 1;
366                        }) ), "filter", selector );
367        },
368
369        closest: function( selector ) {
370                var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,
371                        closer = 0;
372
373                return this.map(function(){
374                        var cur = this;
375                        while ( cur && cur.ownerDocument ) {
376                                if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {
377                                        jQuery.data(cur, "closest", closer);
378                                        return cur;
379                                }
380                                cur = cur.parentNode;
381                                closer++;
382                        }
383                });
384        },
385
386        not: function( selector ) {
387                if ( typeof selector === "string" )
388                        // test special case where just one selector is passed in
389                        if ( isSimple.test( selector ) )
390                                return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
391                        else
392                                selector = jQuery.multiFilter( selector, this );
393
394                var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
395                return this.filter(function() {
396                        return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
397                });
398        },
399
400        add: function( selector ) {
401                return this.pushStack( jQuery.unique( jQuery.merge(
402                        this.get(),
403                        typeof selector === "string" ?
404                                jQuery( selector ) :
405                                jQuery.makeArray( selector )
406                )));
407        },
408
409        is: function( selector ) {
410                return !!selector && jQuery.multiFilter( selector, this ).length > 0;
411        },
412
413        hasClass: function( selector ) {
414                return !!selector && this.is( "." + selector );
415        },
416
417        val: function( value ) {
418                if ( value === undefined ) {                   
419                        var elem = this[0];
420
421                        if ( elem ) {
422                                if( jQuery.nodeName( elem, 'option' ) )
423                                        return (elem.attributes.value || {}).specified ? elem.value : elem.text;
424                               
425                                // We need to handle select boxes special
426                                if ( jQuery.nodeName( elem, "select" ) ) {
427                                        var index = elem.selectedIndex,
428                                                values = [],
429                                                options = elem.options,
430                                                one = elem.type == "select-one";
431
432                                        // Nothing was selected
433                                        if ( index < 0 )
434                                                return null;
435
436                                        // Loop through all the selected options
437                                        for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
438                                                var option = options[ i ];
439
440                                                if ( option.selected ) {
441                                                        // Get the specifc value for the option
442                                                        value = jQuery(option).val();
443
444                                                        // We don't need an array for one selects
445                                                        if ( one )
446                                                                return value;
447
448                                                        // Multi-Selects return an array
449                                                        values.push( value );
450                                                }
451                                        }
452
453                                        return values;                         
454                                }
455
456                                // Everything else, we just grab the value
457                                return (elem.value || "").replace(/\r/g, "");
458
459                        }
460
461                        return undefined;
462                }
463
464                if ( typeof value === "number" )
465                        value += '';
466
467                return this.each(function(){
468                        if ( this.nodeType != 1 )
469                                return;
470
471                        if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
472                                this.checked = (jQuery.inArray(this.value, value) >= 0 ||
473                                        jQuery.inArray(this.name, value) >= 0);
474
475                        else if ( jQuery.nodeName( this, "select" ) ) {
476                                var values = jQuery.makeArray(value);
477
478                                jQuery( "option", this ).each(function(){
479                                        this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
480                                                jQuery.inArray( this.text, values ) >= 0);
481                                });
482
483                                if ( !values.length )
484                                        this.selectedIndex = -1;
485
486                        } else
487                                this.value = value;
488                });
489        },
490
491        html: function( value ) {
492                return value === undefined ?
493                        (this[0] ?
494                                this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :
495                                null) :
496                        this.empty().append( value );
497        },
498
499        replaceWith: function( value ) {
500                return this.after( value ).remove();
501        },
502
503        eq: function( i ) {
504                return this.slice( i, +i + 1 );
505        },
506
507        slice: function() {
508                return this.pushStack( Array.prototype.slice.apply( this, arguments ),
509                        "slice", Array.prototype.slice.call(arguments).join(",") );
510        },
511
512        map: function( callback ) {
513                return this.pushStack( jQuery.map(this, function(elem, i){
514                        return callback.call( elem, i, elem );
515                }));
516        },
517
518        andSelf: function() {
519                return this.add( this.prevObject );
520        },
521
522        domManip: function( args, table, callback ) {
523                if ( this[0] ) {
524                        var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
525                                scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
526                                first = fragment.firstChild,
527                                extra = this.length > 1 ? fragment.cloneNode(true) : fragment;
528
529                        if ( first )
530                                for ( var i = 0, l = this.length; i < l; i++ )
531                                        callback.call( root(this[i], first), i > 0 ? extra.cloneNode(true) : fragment );
532                       
533                        if ( scripts )
534                                jQuery.each( scripts, evalScript );
535                }
536
537                return this;
538               
539                function root( elem, cur ) {
540                        return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
541                                (elem.getElementsByTagName("tbody")[0] ||
542                                elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
543                                elem;
544                }
545        }
546};
547
548// Give the init function the jQuery prototype for later instantiation
549jQuery.fn.init.prototype = jQuery.fn;
550
551function evalScript( i, elem ) {
552        if ( elem.src )
553                jQuery.ajax({
554                        url: elem.src,
555                        async: false,
556                        dataType: "script"
557                });
558
559        else
560                jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
561
562        if ( elem.parentNode )
563                elem.parentNode.removeChild( elem );
564}
565
566function now(){
567        return +new Date;
568}
569
570jQuery.extend = jQuery.fn.extend = function() {
571        // copy reference to target object
572        var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
573
574        // Handle a deep copy situation
575        if ( typeof target === "boolean" ) {
576                deep = target;
577                target = arguments[1] || {};
578                // skip the boolean and the target
579                i = 2;
580        }
581
582        // Handle case when target is a string or something (possible in deep copy)
583        if ( typeof target !== "object" && !jQuery.isFunction(target) )
584                target = {};
585
586        // extend jQuery itself if only one argument is passed
587        if ( length == i ) {
588                target = this;
589                --i;
590        }
591
592        for ( ; i < length; i++ )
593                // Only deal with non-null/undefined values
594                if ( (options = arguments[ i ]) != null )
595                        // Extend the base object
596                        for ( var name in options ) {
597                                var src = target[ name ], copy = options[ name ];
598
599                                // Prevent never-ending loop
600                                if ( target === copy )
601                                        continue;
602
603                                // Recurse if we're merging object values
604                                if ( deep && copy && typeof copy === "object" && !copy.nodeType )
605                                        target[ name ] = jQuery.extend( deep, 
606                                                // Never move original objects, clone them
607                                                src || ( copy.length != null ? [ ] : { } )
608                                        , copy );
609
610                                // Don't bring in undefined values
611                                else if ( copy !== undefined )
612                                        target[ name ] = copy;
613
614                        }
615
616        // Return the modified object
617        return target;
618};
619
620// exclude the following css properties to add px
621var     exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
622        // cache defaultView
623        defaultView = document.defaultView || {},
624        toString = Object.prototype.toString;
625
626jQuery.extend({
627        noConflict: function( deep ) {
628                window.$ = _$;
629
630                if ( deep )
631                        window.jQuery = _jQuery;
632
633                return jQuery;
634        },
635
636        // See test/unit/core.js for details concerning isFunction.
637        // Since version 1.3, DOM methods and functions like alert
638        // aren't supported. They return false on IE (#2968).
639        isFunction: function( obj ) {
640                return toString.call(obj) === "[object Function]";
641        },
642
643        isArray: function( obj ) {
644                return toString.call(obj) === "[object Array]";
645        },
646
647        // check if an element is in a (or is an) XML document
648        isXMLDoc: function( elem ) {
649                return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
650                        !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
651        },
652
653        // Evalulates a script in a global context
654        globalEval: function( data ) {
655                if ( data && /\S/.test(data) ) {
656                        // Inspired by code by Andrea Giammarchi
657                        // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
658                        var head = document.getElementsByTagName("head")[0] || document.documentElement,
659                                script = document.createElement("script");
660
661                        script.type = "text/javascript";
662                        if ( jQuery.support.scriptEval )
663                                script.appendChild( document.createTextNode( data ) );
664                        else
665                                script.text = data;
666
667                        // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
668                        // This arises when a base node is used (#2709).
669                        head.insertBefore( script, head.firstChild );
670                        head.removeChild( script );
671                }
672        },
673
674        nodeName: function( elem, name ) {
675                return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
676        },
677
678        // args is for internal usage only
679        each: function( object, callback, args ) {
680                var name, i = 0, length = object.length;
681
682                if ( args ) {
683                        if ( length === undefined ) {
684                                for ( name in object )
685                                        if ( callback.apply( object[ name ], args ) === false )
686                                                break;
687                        } else
688                                for ( ; i < length; )
689                                        if ( callback.apply( object[ i++ ], args ) === false )
690                                                break;
691
692                // A special, fast, case for the most common use of each
693                } else {
694                        if ( length === undefined ) {
695                                for ( name in object )
696                                        if ( callback.call( object[ name ], name, object[ name ] ) === false )
697                                                break;
698                        } else
699                                for ( var value = object[0];
700                                        i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
701                }
702
703                return object;
704        },
705
706        prop: function( elem, value, type, i, name ) {
707                // Handle executable functions
708                if ( jQuery.isFunction( value ) )
709                        value = value.call( elem, i );
710
711                // Handle passing in a number to a CSS property
712                return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
713                        value + "px" :
714                        value;
715        },
716
717        className: {
718                // internal only, use addClass("class")
719                add: function( elem, classNames ) {
720                        jQuery.each((classNames || "").split(/\s+/), function(i, className){
721                                if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
722                                        elem.className += (elem.className ? " " : "") + className;
723                        });
724                },
725
726                // internal only, use removeClass("class")
727                remove: function( elem, classNames ) {
728                        if (elem.nodeType == 1)
729                                elem.className = classNames !== undefined ?
730                                        jQuery.grep(elem.className.split(/\s+/), function(className){
731                                                return !jQuery.className.has( classNames, className );
732                                        }).join(" ") :
733                                        "";
734                },
735
736                // internal only, use hasClass("class")
737                has: function( elem, className ) {
738                        return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
739                }
740        },
741
742        // A method for quickly swapping in/out CSS properties to get correct calculations
743        swap: function( elem, options, callback ) {
744                var old = {};
745                // Remember the old values, and insert the new ones
746                for ( var name in options ) {
747                        old[ name ] = elem.style[ name ];
748                        elem.style[ name ] = options[ name ];
749                }
750
751                callback.call( elem );
752
753                // Revert the old values
754                for ( var name in options )
755                        elem.style[ name ] = old[ name ];
756        },
757
758        css: function( elem, name, force, extra ) {
759                if ( name == "width" || name == "height" ) {
760                        var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
761
762                        function getWH() {
763                                val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
764
765                                if ( extra === "border" )
766                                        return;
767
768                                jQuery.each( which, function() {
769                                        if ( !extra )
770                                                val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
771                                        if ( extra === "margin" )
772                                                val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
773                                        else
774                                                val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
775                                });
776                        }
777
778                        if ( elem.offsetWidth !== 0 )
779                                getWH();
780                        else
781                                jQuery.swap( elem, props, getWH );
782
783                        return Math.max(0, Math.round(val));
784                }
785
786                return jQuery.curCSS( elem, name, force );
787        },
788
789        curCSS: function( elem, name, force ) {
790                var ret, style = elem.style;
791
792                // We need to handle opacity special in IE
793                if ( name == "opacity" && !jQuery.support.opacity ) {
794                        ret = jQuery.attr( style, "opacity" );
795
796                        return ret == "" ?
797                                "1" :
798                                ret;
799                }
800
801                // Make sure we're using the right name for getting the float value
802                if ( name.match( /float/i ) )
803                        name = styleFloat;
804
805                if ( !force && style && style[ name ] )
806                        ret = style[ name ];
807
808                else if ( defaultView.getComputedStyle ) {
809
810                        // Only "float" is needed here
811                        if ( name.match( /float/i ) )
812                                name = "float";
813
814                        name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
815
816                        var computedStyle = defaultView.getComputedStyle( elem, null );
817
818                        if ( computedStyle )
819                                ret = computedStyle.getPropertyValue( name );
820
821                        // We should always get a number back from opacity
822                        if ( name == "opacity" && ret == "" )
823                                ret = "1";
824
825                } else if ( elem.currentStyle ) {
826                        var camelCase = name.replace(/\-(\w)/g, function(all, letter){
827                                return letter.toUpperCase();
828                        });
829
830                        ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
831
832                        // From the awesome hack by Dean Edwards
833                        // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
834
835                        // If we're not dealing with a regular pixel number
836                        // but a number that has a weird ending, we need to convert it to pixels
837                        if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
838                                // Remember the original values
839                                var left = style.left, rsLeft = elem.runtimeStyle.left;
840
841                                // Put in the new values to get a computed value out
842                                elem.runtimeStyle.left = elem.currentStyle.left;
843                                style.left = ret || 0;
844                                ret = style.pixelLeft + "px";
845
846                                // Revert the changed values
847                                style.left = left;
848                                elem.runtimeStyle.left = rsLeft;
849                        }
850                }
851
852                return ret;
853        },
854
855        clean: function( elems, context, fragment ) {
856                context = context || document;
857
858                // !context.createElement fails in IE with an error but returns typeof 'object'
859                if ( typeof context.createElement === "undefined" )
860                        context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
861
862                // If a single string is passed in and it's a single tag
863                // just do a createElement and skip the rest
864                if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
865                        var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
866                        if ( match )
867                                return [ context.createElement( match[1] ) ];
868                }
869
870                var ret = [], scripts = [], div = context.createElement("div");
871
872                jQuery.each(elems, function(i, elem){
873                        if ( typeof elem === "number" )
874                                elem += '';
875
876                        if ( !elem )
877                                return;
878
879                        // Convert html string into DOM nodes
880                        if ( typeof elem === "string" ) {
881                                // Fix "XHTML"-style tags in all browsers
882                                elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
883                                        return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
884                                                all :
885                                                front + "></" + tag + ">";
886                                });
887
888                                // Trim whitespace, otherwise indexOf won't work as expected
889                                var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();
890
891                                var wrap =
892                                        // option or optgroup
893                                        !tags.indexOf("<opt") &&
894                                        [ 1, "<select multiple='multiple'>", "</select>" ] ||
895
896                                        !tags.indexOf("<leg") &&
897                                        [ 1, "<fieldset>", "</fieldset>" ] ||
898
899                                        tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
900                                        [ 1, "<table>", "</table>" ] ||
901
902                                        !tags.indexOf("<tr") &&
903                                        [ 2, "<table><tbody>", "</tbody></table>" ] ||
904
905                                        // <thead> matched above
906                                        (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
907                                        [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
908
909                                        !tags.indexOf("<col") &&
910                                        [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
911
912                                        // IE can't serialize <link> and <script> tags normally
913                                        !jQuery.support.htmlSerialize &&
914                                        [ 1, "div<div>", "</div>" ] ||
915
916                                        [ 0, "", "" ];
917
918                                // Go to html and back, then peel off extra wrappers
919                                div.innerHTML = wrap[1] + elem + wrap[2];
920
921                                // Move to the right depth
922                                while ( wrap[0]-- )
923                                        div = div.lastChild;
924
925                                // Remove IE's autoinserted <tbody> from table fragments
926                                if ( !jQuery.support.tbody ) {
927
928                                        // String was a <table>, *may* have spurious <tbody>
929                                        var hasBody = /<tbody/i.test(elem),
930                                                tbody = !tags.indexOf("<table") && !hasBody ?
931                                                        div.firstChild && div.firstChild.childNodes :
932
933                                                // String was a bare <thead> or <tfoot>
934                                                wrap[1] == "<table>" && !hasBody ?
935                                                        div.childNodes :
936                                                        [];
937
938                                        for ( var j = tbody.length - 1; j >= 0 ; --j )
939                                                if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
940                                                        tbody[ j ].parentNode.removeChild( tbody[ j ] );
941
942                                        }
943
944                                // IE completely kills leading whitespace when innerHTML is used
945                                if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
946                                        div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
947                               
948                                elem = jQuery.makeArray( div.childNodes );
949                        }
950
951                        if ( elem.nodeType )
952                                ret.push( elem );
953                        else
954                                ret = jQuery.merge( ret, elem );
955
956                });
957
958                if ( fragment ) {
959                        for ( var i = 0; ret[i]; i++ ) {
960                                if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
961                                        scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
962                                } else {
963                                        if ( ret[i].nodeType === 1 )
964                                                ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
965                                        fragment.appendChild( ret[i] );
966                                }
967                        }
968                       
969                        return scripts;
970                }
971
972                return ret;
973        },
974
975        attr: function( elem, name, value ) {
976                // don't set attributes on text and comment nodes
977                if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
978                        return undefined;
979
980                var notxml = !jQuery.isXMLDoc( elem ),
981                        // Whether we are setting (or getting)
982                        set = value !== undefined;
983
984                // Try to normalize/fix the name
985                name = notxml && jQuery.props[ name ] || name;
986
987                // Only do all the following if this is a node (faster for style)
988                // IE elem.getAttribute passes even for style
989                if ( elem.tagName ) {
990
991                        // These attributes require special treatment
992                        var special = /href|src|style/.test( name );
993
994                        // Safari mis-reports the default selected property of a hidden option
995                        // Accessing the parent's selectedIndex property fixes it
996                        if ( name == "selected" && elem.parentNode )
997                                elem.parentNode.selectedIndex;
998
999                        // If applicable, access the attribute via the DOM 0 way
1000                        if ( name in elem && notxml && !special ) {
1001                                if ( set ){
1002                                        // We can't allow the type property to be changed (since it causes problems in IE)
1003                                        if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
1004                                                throw "type property can't be changed";
1005
1006                                        elem[ name ] = value;
1007                                }
1008
1009                                // browsers index elements by id/name on forms, give priority to attributes.
1010                                if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1011                                        return elem.getAttributeNode( name ).nodeValue;
1012
1013                                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1014                                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1015                                if ( name == "tabIndex" ) {
1016                                        var attributeNode = elem.getAttributeNode( "tabIndex" );
1017                                        return attributeNode && attributeNode.specified
1018                                                ? attributeNode.value
1019                                                : elem.nodeName.match(/(button|input|object|select|textarea)/i)
1020                                                        ? 0
1021                                                        : elem.nodeName.match(/^(a|area)$/i) && elem.href
1022                                                                ? 0
1023                                                                : undefined;
1024                                }
1025
1026                                return elem[ name ];
1027                        }
1028
1029                        if ( !jQuery.support.style && notxml &&  name == "style" )
1030                                return jQuery.attr( elem.style, "cssText", value );
1031
1032                        if ( set )
1033                                // convert the value to a string (all browsers do this but IE) see #1070
1034                                elem.setAttribute( name, "" + value );
1035
1036                        var attr = !jQuery.support.hrefNormalized && notxml && special
1037                                        // Some attributes require a special call on IE
1038                                        ? elem.getAttribute( name, 2 )
1039                                        : elem.getAttribute( name );
1040
1041                        // Non-existent attributes return null, we normalize to undefined
1042                        return attr === null ? undefined : attr;
1043                }
1044
1045                // elem is actually elem.style ... set the style
1046
1047                // IE uses filters for opacity
1048                if ( !jQuery.support.opacity && name == "opacity" ) {
1049                        if ( set ) {
1050                                // IE has trouble with opacity if it does not have layout
1051                                // Force it by setting the zoom level
1052                                elem.zoom = 1;
1053
1054                                // Set the alpha filter to set the opacity
1055                                elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1056                                        (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1057                        }
1058
1059                        return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1060                                (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1061                                "";
1062                }
1063
1064                name = name.replace(/-([a-z])/ig, function(all, letter){
1065                        return letter.toUpperCase();
1066                });
1067
1068                if ( set )
1069                        elem[ name ] = value;
1070
1071                return elem[ name ];
1072        },
1073
1074        trim: function( text ) {
1075                return (text || "").replace( /^\s+|\s+$/g, "" );
1076        },
1077
1078        makeArray: function( array ) {
1079                var ret = [];
1080
1081                if( array != null ){
1082                        var i = array.length;
1083                        // The window, strings (and functions) also have 'length'
1084                        if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
1085                                ret[0] = array;
1086                        else
1087                                while( i )
1088                                        ret[--i] = array[i];
1089                }
1090
1091                return ret;
1092        },
1093
1094        inArray: function( elem, array ) {
1095                for ( var i = 0, length = array.length; i < length; i++ )
1096                // Use === because on IE, window == document
1097                        if ( array[ i ] === elem )
1098                                return i;
1099
1100                return -1;
1101        },
1102
1103        merge: function( first, second ) {
1104                // We have to loop this way because IE & Opera overwrite the length
1105                // expando of getElementsByTagName
1106                var i = 0, elem, pos = first.length;
1107                // Also, we need to make sure that the correct elements are being returned
1108                // (IE returns comment nodes in a '*' query)
1109                if ( !jQuery.support.getAll ) {
1110                        while ( (elem = second[ i++ ]) != null )
1111                                if ( elem.nodeType != 8 )
1112                                        first[ pos++ ] = elem;
1113
1114                } else
1115                        while ( (elem = second[ i++ ]) != null )
1116                                first[ pos++ ] = elem;
1117
1118                return first;
1119        },
1120
1121        unique: function( array ) {
1122                var ret = [], done = {};
1123
1124                try {
1125
1126                        for ( var i = 0, length = array.length; i < length; i++ ) {
1127                                var id = jQuery.data( array[ i ] );
1128
1129                                if ( !done[ id ] ) {
1130                                        done[ id ] = true;
1131                                        ret.push( array[ i ] );
1132                                }
1133                        }
1134
1135                } catch( e ) {
1136                        ret = array;
1137                }
1138
1139                return ret;
1140        },
1141
1142        grep: function( elems, callback, inv ) {
1143                var ret = [];
1144
1145                // Go through the array, only saving the items
1146                // that pass the validator function
1147                for ( var i = 0, length = elems.length; i < length; i++ )
1148                        if ( !inv != !callback( elems[ i ], i ) )
1149                                ret.push( elems[ i ] );
1150
1151                return ret;
1152        },
1153
1154        map: function( elems, callback ) {
1155                var ret = [];
1156
1157                // Go through the array, translating each of the items to their
1158                // new value (or values).
1159                for ( var i = 0, length = elems.length; i < length; i++ ) {
1160                        var value = callback( elems[ i ], i );
1161
1162                        if ( value != null )
1163                                ret[ ret.length ] = value;
1164                }
1165
1166                return ret.concat.apply( [], ret );
1167        }
1168});
1169
1170// Use of jQuery.browser is deprecated.
1171// It's included for backwards compatibility and plugins,
1172// although they should work to migrate away.
1173
1174var userAgent = navigator.userAgent.toLowerCase();
1175
1176// Figure out what browser is being used
1177jQuery.browser = {
1178        version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
1179        safari: /webkit/.test( userAgent ),
1180        opera: /opera/.test( userAgent ),
1181        msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1182        mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1183};
1184
1185jQuery.each({
1186        parent: function(elem){return elem.parentNode;},
1187        parents: function(elem){return jQuery.dir(elem,"parentNode");},
1188        next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1189        prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1190        nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1191        prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1192        siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1193        children: function(elem){return jQuery.sibling(elem.firstChild);},
1194        contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1195}, function(name, fn){
1196        jQuery.fn[ name ] = function( selector ) {
1197                var ret = jQuery.map( this, fn );
1198
1199                if ( selector && typeof selector == "string" )
1200                        ret = jQuery.multiFilter( selector, ret );
1201
1202                return this.pushStack( jQuery.unique( ret ), name, selector );
1203        };
1204});
1205
1206jQuery.each({
1207        appendTo: "append",
1208        prependTo: "prepend",
1209        insertBefore: "before",
1210        insertAfter: "after",
1211        replaceAll: "replaceWith"
1212}, function(name, original){
1213        jQuery.fn[ name ] = function() {
1214                var args = arguments;
1215
1216                return this.each(function(){
1217                        for ( var i = 0, length = args.length; i < length; i++ )
1218                                jQuery( args[ i ] )[ original ]( this );
1219                });
1220        };
1221});
1222
1223jQuery.each({
1224        removeAttr: function( name ) {
1225                jQuery.attr( this, name, "" );
1226                if (this.nodeType == 1)
1227                        this.removeAttribute( name );
1228        },
1229
1230        addClass: function( classNames ) {
1231                jQuery.className.add( this, classNames );
1232        },
1233
1234        removeClass: function( classNames ) {
1235                jQuery.className.remove( this, classNames );
1236        },
1237
1238        toggleClass: function( classNames, state ) {
1239                if( typeof state !== "boolean" )
1240                        state = !jQuery.className.has( this, classNames );
1241                jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1242        },
1243
1244        remove: function( selector ) {
1245                if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
1246                        // Prevent memory leaks
1247                        jQuery( "*", this ).add([this]).each(function(){
1248                                jQuery.event.remove(this);
1249                                jQuery.removeData(this);
1250                        });
1251                        if (this.parentNode)
1252                                this.parentNode.removeChild( this );
1253                }
1254        },
1255
1256        empty: function() {
1257                // Remove element nodes and prevent memory leaks
1258                jQuery( ">*", this ).remove();
1259
1260                // Remove any remaining nodes
1261                while ( this.firstChild )
1262                        this.removeChild( this.firstChild );
1263        }
1264}, function(name, fn){
1265        jQuery.fn[ name ] = function(){
1266                return this.each( fn, arguments );
1267        };
1268});
1269
1270// Helper function used by the dimensions and offset modules
1271function num(elem, prop) {
1272        return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1273}
1274var expando = "jQuery" + now(), uuid = 0, windowData = {};
1275
1276jQuery.extend({
1277        cache: {},
1278
1279        data: function( elem, name, data ) {
1280                elem = elem == window ?
1281                        windowData :
1282                        elem;
1283
1284                var id = elem[ expando ];
1285
1286                // Compute a unique ID for the element
1287                if ( !id )
1288                        id = elem[ expando ] = ++uuid;
1289
1290                // Only generate the data cache if we're
1291                // trying to access or manipulate it
1292                if ( name && !jQuery.cache[ id ] )
1293                        jQuery.cache[ id ] = {};
1294
1295                // Prevent overriding the named cache with undefined values
1296                if ( data !== undefined )
1297                        jQuery.cache[ id ][ name ] = data;
1298
1299                // Return the named cache data, or the ID for the element
1300                return name ?
1301                        jQuery.cache[ id ][ name ] :
1302                        id;
1303        },
1304
1305        removeData: function( elem, name ) {
1306                elem = elem == window ?
1307                        windowData :
1308                        elem;
1309
1310                var id = elem[ expando ];
1311
1312                // If we want to remove a specific section of the element's data
1313                if ( name ) {
1314                        if ( jQuery.cache[ id ] ) {
1315                                // Remove the section of cache data
1316                                delete jQuery.cache[ id ][ name ];
1317
1318                                // If we've removed all the data, remove the element's cache
1319                                name = "";
1320
1321                                for ( name in jQuery.cache[ id ] )
1322                                        break;
1323
1324                                if ( !name )
1325                                        jQuery.removeData( elem );
1326                        }
1327
1328                // Otherwise, we want to remove all of the element's data
1329                } else {
1330                        // Clean up the element expando
1331                        try {
1332                                delete elem[ expando ];
1333                        } catch(e){
1334                                // IE has trouble directly removing the expando
1335                                // but it's ok with using removeAttribute
1336                                if ( elem.removeAttribute )
1337                                        elem.removeAttribute( expando );
1338                        }
1339
1340                        // Completely remove the data cache
1341                        delete jQuery.cache[ id ];
1342                }
1343        },
1344        queue: function( elem, type, data ) {
1345                if ( elem ){
1346       
1347                        type = (type || "fx") + "queue";
1348       
1349                        var q = jQuery.data( elem, type );
1350       
1351                        if ( !q || jQuery.isArray(data) )
1352                                q = jQuery.data( elem, type, jQuery.makeArray(data) );
1353                        else if( data )
1354                                q.push( data );
1355       
1356                }
1357                return q;
1358        },
1359
1360        dequeue: function( elem, type ){
1361                var queue = jQuery.queue( elem, type ),
1362                        fn = queue.shift();
1363               
1364                if( !type || type === "fx" )
1365                        fn = queue[0];
1366                       
1367                if( fn !== undefined )
1368                        fn.call(elem);
1369        }
1370});
1371
1372jQuery.fn.extend({
1373        data: function( key, value ){
1374                var parts = key.split(".");
1375                parts[1] = parts[1] ? "." + parts[1] : "";
1376
1377                if ( value === undefined ) {
1378                        var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1379
1380                        if ( data === undefined && this.length )
1381                                data = jQuery.data( this[0], key );
1382
1383                        return data === undefined && parts[1] ?
1384                                this.data( parts[0] ) :
1385                                data;
1386                } else
1387                        return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
1388                                jQuery.data( this, key, value );
1389                        });
1390        },
1391
1392        removeData: function( key ){
1393                return this.each(function(){
1394                        jQuery.removeData( this, key );
1395                });
1396        },
1397        queue: function(type, data){
1398                if ( typeof type !== "string" ) {
1399                        data = type;
1400                        type = "fx";
1401                }
1402
1403                if ( data === undefined )
1404                        return jQuery.queue( this[0], type );
1405
1406                return this.each(function(){
1407                        var queue = jQuery.queue( this, type, data );
1408                       
1409                         if( type == "fx" && queue.length == 1 )
1410                                queue[0].call(this);
1411                });
1412        },
1413        dequeue: function(type){
1414                return this.each(function(){
1415                        jQuery.dequeue( this, type );
1416                });
1417        }
1418});/*!
1419 * Sizzle CSS Selector Engine - v0.9.3
1420 *  Copyright 2009, The Dojo Foundation
1421 *  Released under the MIT, BSD, and GPL Licenses.
1422 *  More information: http://sizzlejs.com/
1423 */
1424(function(){
1425
1426var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[]+)+|[>+~])(\s*,\s*)?/g,
1427        done = 0,
1428        toString = Object.prototype.toString;
1429
1430var Sizzle = function(selector, context, results, seed) {
1431        results = results || [];
1432        context = context || document;
1433
1434        if ( context.nodeType !== 1 && context.nodeType !== 9 )
1435                return [];
1436       
1437        if ( !selector || typeof selector !== "string" ) {
1438                return results;
1439        }
1440
1441        var parts = [], m, set, checkSet, check, mode, extra, prune = true;
1442       
1443        // Reset the position of the chunker regexp (start from head)
1444        chunker.lastIndex = 0;
1445       
1446        while ( (m = chunker.exec(selector)) !== null ) {
1447                parts.push( m[1] );
1448               
1449                if ( m[2] ) {
1450                        extra = RegExp.rightContext;
1451                        break;
1452                }
1453        }
1454
1455        if ( parts.length > 1 && origPOS.exec( selector ) ) {
1456                if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
1457                        set = posProcess( parts[0] + parts[1], context );
1458                } else {
1459                        set = Expr.relative[ parts[0] ] ?
1460                                [ context ] :
1461                                Sizzle( parts.shift(), context );
1462
1463                        while ( parts.length ) {
1464                                selector = parts.shift();
1465
1466                                if ( Expr.relative[ selector ] )
1467                                        selector += parts.shift();
1468
1469                                set = posProcess( selector, set );
1470                        }
1471                }
1472        } else {
1473                var ret = seed ?
1474                        { expr: parts.pop(), set: makeArray(seed) } :
1475                        Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
1476                set = Sizzle.filter( ret.expr, ret.set );
1477
1478                if ( parts.length > 0 ) {
1479                        checkSet = makeArray(set);
1480                } else {
1481                        prune = false;
1482                }
1483
1484                while ( parts.length ) {
1485                        var cur = parts.pop(), pop = cur;
1486
1487                        if ( !Expr.relative[ cur ] ) {
1488                                cur = "";
1489                        } else {
1490                                pop = parts.pop();
1491                        }
1492
1493                        if ( pop == null ) {
1494                                pop = context;
1495                        }
1496
1497                        Expr.relative[ cur ]( checkSet, pop, isXML(context) );
1498                }
1499        }
1500
1501        if ( !checkSet ) {
1502                checkSet = set;
1503        }
1504
1505        if ( !checkSet ) {
1506                throw "Syntax error, unrecognized expression: " + (cur || selector);
1507        }
1508
1509        if ( toString.call(checkSet) === "[object Array]" ) {
1510                if ( !prune ) {
1511                        results.push.apply( results, checkSet );
1512                } else if ( context.nodeType === 1 ) {
1513                        for ( var i = 0; checkSet[i] != null; i++ ) {
1514                                if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
1515                                        results.push( set[i] );
1516                                }
1517                        }
1518                } else {
1519                        for ( var i = 0; checkSet[i] != null; i++ ) {
1520                                if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
1521                                        results.push( set[i] );
1522                                }
1523                        }
1524                }
1525        } else {
1526                makeArray( checkSet, results );
1527        }
1528
1529        if ( extra ) {
1530                Sizzle( extra, context, results, seed );
1531
1532                if ( sortOrder ) {
1533                        hasDuplicate = false;
1534                        results.sort(sortOrder);
1535
1536                        if ( hasDuplicate ) {
1537                                for ( var i = 1; i < results.length; i++ ) {
1538                                        if ( results[i] === results[i-1] ) {
1539                                                results.splice(i--, 1);
1540                                        }
1541                                }
1542                        }
1543                }
1544        }
1545
1546        return results;
1547};
1548
1549Sizzle.matches = function(expr, set){
1550        return Sizzle(expr, null, null, set);
1551};
1552
1553Sizzle.find = function(expr, context, isXML){
1554        var set, match;
1555
1556        if ( !expr ) {
1557                return [];
1558        }
1559
1560        for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
1561                var type = Expr.order[i], match;
1562               
1563                if ( (match = Expr.match[ type ].exec( expr )) ) {
1564                        var left = RegExp.leftContext;
1565
1566                        if ( left.substr( left.length - 1 ) !== "\\" ) {
1567                                match[1] = (match[1] || "").replace(/\\/g, "");
1568                                set = Expr.find[ type ]( match, context, isXML );
1569                                if ( set != null ) {
1570                                        expr = expr.replace( Expr.match[ type ], "" );
1571                                        break;
1572                                }
1573                        }
1574                }
1575        }
1576
1577        if ( !set ) {
1578                set = context.getElementsByTagName("*");
1579        }
1580
1581        return {set: set, expr: expr};
1582};
1583
1584Sizzle.filter = function(expr, set, inplace, not){
1585        var old = expr, result = [], curLoop = set, match, anyFound;
1586
1587        while ( expr && set.length ) {
1588                for ( var type in Expr.filter ) {
1589                        if ( (match = Expr.match[ type ].exec( expr )) != null ) {
1590                                var filter = Expr.filter[ type ], found, item;
1591                                anyFound = false;
1592
1593                                if ( curLoop == result ) {
1594                                        result = [];
1595                                }
1596
1597                                if ( Expr.preFilter[ type ] ) {
1598                                        match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not );
1599
1600                                        if ( !match ) {
1601                                                anyFound = found = true;
1602                                        } else if ( match === true ) {
1603                                                continue;
1604                                        }
1605                                }
1606
1607                                if ( match ) {
1608                                        for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
1609                                                if ( item ) {
1610                                                        found = filter( item, match, i, curLoop );
1611                                                        var pass = not ^ !!found;
1612
1613                                                        if ( inplace && found != null ) {
1614                                                                if ( pass ) {
1615                                                                        anyFound = true;
1616                                                                } else {
1617                                                                        curLoop[i] = false;
1618                                                                }
1619                                                        } else if ( pass ) {
1620                                                                result.push( item );
1621                                                                anyFound = true;
1622                                                        }
1623                                                }
1624                                        }
1625                                }
1626
1627                                if ( found !== undefined ) {
1628                                        if ( !inplace ) {
1629                                                curLoop = result;
1630                                        }
1631
1632                                        expr = expr.replace( Expr.match[ type ], "" );
1633
1634                                        if ( !anyFound ) {
1635                                                return [];
1636                                        }
1637
1638                                        break;
1639                                }
1640                        }
1641                }
1642
1643                expr = expr.replace(/\s*,\s*/, "");
1644
1645                // Improper expression
1646                if ( expr == old ) {
1647                        if ( anyFound == null ) {
1648                                throw "Syntax error, unrecognized expression: " + expr;
1649                        } else {
1650                                break;
1651                        }
1652                }
1653
1654                old = expr;
1655        }
1656
1657        return curLoop;
1658};
1659
1660var Expr = Sizzle.selectors = {
1661        order: [ "ID", "NAME", "TAG" ],
1662        match: {
1663                ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1664                CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1665                NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
1666                ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
1667                TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
1668                CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
1669                POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
1670                PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
1671        },
1672        attrMap: {
1673                "class": "className",
1674                "for": "htmlFor"
1675        },
1676        attrHandle: {
1677                href: function(elem){
1678                        return elem.getAttribute("href");
1679                }
1680        },
1681        relative: {
1682                "+": function(checkSet, part, isXML){
1683                        var     isPartStr = typeof part === "string",
1684                                isTag = isPartStr && !/\W/.test(part),
1685                                isPartStrNotTag = isPartStr && !isTag;
1686                        if ( isTag && !isXML ) part = part.toUpperCase();
1687                        for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
1688                                if ( elem = checkSet[i] ) {
1689                                        while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {};
1690                                        checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
1691                                                 elem : elem === part;
1692                                }
1693                        }
1694                        if (isPartStrNotTag) {
1695                                Sizzle.filter( part, checkSet, true );
1696                        }
1697                },
1698                ">": function(checkSet, part, isXML){
1699                        if ( typeof part === "string" && !/\W/.test(part) ) {
1700                                part = isXML ? part : part.toUpperCase();
1701
1702                                for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1703                                        var elem = checkSet[i];
1704                                        if ( elem ) {
1705                                                var parent = elem.parentNode;
1706                                                checkSet[i] = parent.nodeName === part ? parent : false;
1707                                        }
1708                                }
1709                        } else {
1710                                for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1711                                        var elem = checkSet[i];
1712                                        if ( elem ) {
1713                                                checkSet[i] = typeof part === "string" ?
1714                                                        elem.parentNode :
1715                                                        elem.parentNode === part;
1716                                        }
1717                                }
1718
1719                                if ( typeof part === "string" ) {
1720                                        Sizzle.filter( part, checkSet, true );
1721                                }
1722                        }
1723                },
1724                "": function(checkSet, part, isXML){
1725                        var doneName = done++, checkFn = dirCheck;
1726
1727                        if ( !part.match(/\W/) ) {
1728                                var nodeCheck = part = isXML ? part : part.toUpperCase();
1729                                checkFn = dirNodeCheck;
1730                        }
1731
1732                        checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
1733                },
1734                "~": function(checkSet, part, isXML){
1735                        var doneName = done++, checkFn = dirCheck;
1736
1737                        if ( typeof part === "string" && !part.match(/\W/) ) {
1738                                var nodeCheck = part = isXML ? part : part.toUpperCase();
1739                                checkFn = dirNodeCheck;
1740                        }
1741
1742                        checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
1743                }
1744        },
1745        find: {
1746                ID: function(match, context, isXML){
1747                        if ( typeof context.getElementById !== "undefined" && !isXML ) {
1748                                var m = context.getElementById(match[1]);
1749                                return m ? [m] : [];
1750                        }
1751                },
1752                NAME: function(match, context, isXML){
1753                        if ( typeof context.getElementsByName !== "undefined" ) {
1754                                var ret = context.getElementsByName(match[1]);
1755                                return ret.length === 0 ? null : ret;
1756                        }
1757                },
1758                TAG: function(match, context){
1759                        return context.getElementsByTagName(match[1]);
1760                }
1761        },
1762        preFilter: {
1763                CLASS: function(match, curLoop, inplace, result, not){
1764                        match = " " + match[1].replace(/\\/g, "") + " ";
1765
1766                        for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
1767                                if ( elem ) {
1768                                        if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
1769                                                if ( !inplace )
1770                                                        result.push( elem );
1771                                        } else if ( inplace ) {
1772                                                curLoop[i] = false;
1773                                        }
1774                                }
1775                        }
1776
1777                        return false;
1778                },
1779                ID: function(match){
1780                        return match[1].replace(/\\/g, "");
1781                },
1782                TAG: function(match, curLoop){
1783                        for ( var i = 0; curLoop[i] === false; i++ ){}
1784                        return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
1785                },
1786                CHILD: function(match){
1787                        if ( match[1] == "nth" ) {
1788                                // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1789                                var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
1790                                        match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
1791                                        !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
1792
1793                                // calculate the numbers (first)n+(last) including if they are negative
1794                                match[2] = (test[1] + (test[2] || 1)) - 0;
1795                                match[3] = test[3] - 0;
1796                        }
1797
1798                        // TODO: Move to normal caching system
1799                        match[0] = done++;
1800
1801                        return match;
1802                },
1803                ATTR: function(match){
1804                        var name = match[1].replace(/\\/g, "");
1805                       
1806                        if ( Expr.attrMap[name] ) {
1807                                match[1] = Expr.attrMap[name];
1808                        }
1809
1810                        if ( match[2] === "~=" ) {
1811                                match[4] = " " + match[4] + " ";
1812                        }
1813
1814                        return match;
1815                },
1816                PSEUDO: function(match, curLoop, inplace, result, not){
1817                        if ( match[1] === "not" ) {
1818                                // If we're dealing with a complex expression, or a simple one
1819                                if ( match[3].match(chunker).length > 1 ) {
1820                                        match[3] = Sizzle(match[3], null, null, curLoop);
1821                                } else {
1822                                        var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
1823                                        if ( !inplace ) {
1824                                                result.push.apply( result, ret );
1825                                        }
1826                                        return false;
1827                                }
1828                        } else if ( Expr.match.POS.test( match[0] ) ) {
1829                                return true;
1830                        }
1831                       
1832                        return match;
1833                },
1834                POS: function(match){
1835                        match.unshift( true );
1836                        return match;
1837                }
1838        },
1839        filters: {
1840                enabled: function(elem){
1841                        return elem.disabled === false && elem.type !== "hidden";
1842                },
1843                disabled: function(elem){
1844                        return elem.disabled === true;
1845                },
1846                checked: function(elem){
1847                        return elem.checked === true;
1848                },
1849                selected: function(elem){
1850                        // Accessing this property makes selected-by-default
1851                        // options in Safari work properly
1852                        elem.parentNode.selectedIndex;
1853                        return elem.selected === true;
1854                },
1855                parent: function(elem){
1856                        return !!elem.firstChild;
1857                },
1858                empty: function(elem){
1859                        return !elem.firstChild;
1860                },
1861                has: function(elem, i, match){
1862                        return !!Sizzle( match[3], elem ).length;
1863                },
1864                header: function(elem){
1865                        return /h\d/i.test( elem.nodeName );
1866                },
1867                text: function(elem){
1868                        return "text" === elem.type;
1869                },
1870                radio: function(elem){
1871                        return "radio" === elem.type;
1872                },
1873                checkbox: function(elem){
1874                        return "checkbox" === elem.type;
1875                },
1876                file: function(elem){
1877                        return "file" === elem.type;
1878                },
1879                password: function(elem){
1880                        return "password" === elem.type;
1881                },
1882                submit: function(elem){
1883                        return "submit" === elem.type;
1884                },
1885                image: function(elem){
1886                        return "image" === elem.type;
1887                },
1888                reset: function(elem){
1889                        return "reset" === elem.type;
1890                },
1891                button: function(elem){
1892                        return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
1893                },
1894                input: function(elem){
1895                        return /input|select|textarea|button/i.test(elem.nodeName);
1896                }
1897        },
1898        setFilters: {
1899                first: function(elem, i){
1900                        return i === 0;
1901                },
1902                last: function(elem, i, match, array){
1903                        return i === array.length - 1;
1904                },
1905                even: function(elem, i){
1906                        return i % 2 === 0;
1907                },
1908                odd: function(elem, i){
1909                        return i % 2 === 1;
1910                },
1911                lt: function(elem, i, match){
1912                        return i < match[3] - 0;
1913                },
1914                gt: function(elem, i, match){
1915                        return i > match[3] - 0;
1916                },
1917                nth: function(elem, i, match){
1918                        return match[3] - 0 == i;
1919                },
1920                eq: function(elem, i, match){
1921                        return match[3] - 0 == i;
1922                }
1923        },
1924        filter: {
1925                CHILD: function(elem, match){
1926                        var type = match[1], node = elem;
1927                        switch (type) {
1928                                case 'only':
1929                                case 'first':
1930                                        while (node = node.previousSibling)  {
1931                                                if ( node.nodeType === 1 ) return false;
1932                                        }
1933                                        if ( type == 'first') return true;
1934                                        node = elem;
1935                                case 'last':
1936                                        while (node = node.nextSibling)  {
1937                                                if ( node.nodeType === 1 ) return false;
1938                                        }
1939                                        return true;
1940                                case 'nth':
1941                                        var first = match[2], last = match[3];
1942
1943                                        if ( first == 1 && last == 0 ) {
1944                                                return true;
1945                                        }
1946                                       
1947                                        var doneName = match[0],
1948                                                parent = elem.parentNode;
1949       
1950                                        if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
1951                                                var count = 0;
1952                                                for ( node = parent.firstChild; node; node = node.nextSibling ) {
1953                                                        if ( node.nodeType === 1 ) {
1954                                                                node.nodeIndex = ++count;
1955                                                        }
1956                                                } 
1957                                                parent.sizcache = doneName;
1958                                        }
1959                                       
1960                                        var diff = elem.nodeIndex - last;
1961                                        if ( first == 0 ) {
1962                                                return diff == 0;
1963                                        } else {
1964                                                return ( diff % first == 0 && diff / first >= 0 );
1965                                        }
1966                        }
1967                },
1968                PSEUDO: function(elem, match, i, array){
1969                        var name = match[1], filter = Expr.filters[ name ];
1970
1971                        if ( filter ) {
1972                                return filter( elem, i, match, array );
1973                        } else if ( name === "contains" ) {
1974                                return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
1975                        } else if ( name === "not" ) {
1976                                var not = match[3];
1977
1978                                for ( var i = 0, l = not.length; i < l; i++ ) {
1979                                        if ( not[i] === elem ) {
1980                                                return false;
1981                                        }
1982                                }
1983
1984                                return true;
1985                        }
1986                },
1987                ID: function(elem, match){
1988                        return elem.nodeType === 1 && elem.getAttribute("id") === match;
1989                },
1990                TAG: function(elem, match){
1991                        return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
1992                },
1993                CLASS: function(elem, match){
1994                        return match.test( elem.className );
1995                },
1996                ATTR: function(elem, match){
1997                        var name = match[1],
1998                                result = Expr.attrHandle[ name ] ?
1999                                        Expr.attrHandle[ name ]( elem ) :
2000                                        elem[ name ] != null ?
2001                                                elem[ name ] :
2002                                                elem.getAttribute( name ),
2003                                value = result + "",
2004                                type = match[2],
2005                                check = match[4];
2006
2007                        return result == null ?
2008                                type === "!=" :
2009                                type === "=" ?
2010                                value === check :
2011                                type === "*=" ?
2012                                value.indexOf(check) >= 0 :
2013                                type === "~=" ?
2014                                (" " + value + " ").indexOf(check) >= 0 :
2015                                !check ?
2016                                value && result !== false :
2017                                type === "!=" ?
2018                                value != check :
2019                                type === "^=" ?
2020                                value.indexOf(check) === 0 :
2021                                type === "$=" ?
2022                                value.substr(value.length - check.length) === check :
2023                                type === "|=" ?
2024                                value === check || value.substr(0, check.length + 1) === check + "-" :
2025                                false;
2026                },
2027                POS: function(elem, match, i, array){
2028                        var name = match[2], filter = Expr.setFilters[ name ];
2029
2030                        if ( filter ) {
2031                                return filter( elem, i, match, array );
2032                        }
2033                }
2034        }
2035};
2036
2037var origPOS = Expr.match.POS;
2038
2039for ( var type in Expr.match ) {
2040        Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
2041}
2042
2043var makeArray = function(array, results) {
2044        array = Array.prototype.slice.call( array );
2045
2046        if ( results ) {
2047                results.push.apply( results, array );
2048                return results;
2049        }
2050       
2051        return array;
2052};
2053
2054// Perform a simple check to determine if the browser is capable of
2055// converting a NodeList to an array using builtin methods.
2056try {
2057        Array.prototype.slice.call( document.documentElement.childNodes );
2058
2059// Provide a fallback method if it does not work
2060} catch(e){
2061        makeArray = function(array, results) {
2062                var ret = results || [];
2063
2064                if ( toString.call(array) === "[object Array]" ) {
2065                        Array.prototype.push.apply( ret, array );
2066                } else {
2067                        if ( typeof array.length === "number" ) {
2068                                for ( var i = 0, l = array.length; i < l; i++ ) {
2069                                        ret.push( array[i] );
2070                                }
2071                        } else {
2072                                for ( var i = 0; array[i]; i++ ) {
2073                                        ret.push( array[i] );
2074                                }
2075                        }
2076                }
2077
2078                return ret;
2079        };
2080}
2081
2082var sortOrder;
2083
2084if ( Array.prototype.indexOf ) {
2085        var indexOf = Array.prototype.indexOf,
2086                allSort = document.getElementsByTagName("*");
2087
2088        sortOrder = function( a, b ) {
2089                var ret = indexOf.call( allSort, a ) - indexOf.call( allSort, b );
2090                if ( ret === 0 ) {
2091                        hasDuplicate = true;
2092                }
2093                return ret;
2094        };
2095} else if ( document.documentElement.sourceIndex === 1 ) {
2096        sortOrder = function( a, b ) {
2097                var ret = a.sourceIndex - b.sourceIndex;
2098                if ( ret === 0 ) {
2099                        hasDuplicate = true;
2100                }
2101                return ret;
2102        };
2103}
2104
2105// Check to see if the browser returns elements by name when
2106// querying by getElementById (and provide a workaround)
2107(function(){
2108        // We're going to inject a fake input element with a specified name
2109        var form = document.createElement("form"),
2110                id = "script" + (new Date).getTime();
2111        form.innerHTML = "<input name='" + id + "'/>";
2112
2113        // Inject it into the root element, check its status, and remove it quickly
2114        var root = document.documentElement;
2115        root.insertBefore( form, root.firstChild );
2116
2117        // The workaround has to do additional checks after a getElementById
2118        // Which slows things down for other browsers (hence the branching)
2119        if ( !!document.getElementById( id ) ) {
2120                Expr.find.ID = function(match, context, isXML){
2121                        if ( typeof context.getElementById !== "undefined" && !isXML ) {
2122                                var m = context.getElementById(match[1]);
2123                                return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
2124                        }
2125                };
2126
2127                Expr.filter.ID = function(elem, match){
2128                        var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
2129                        return elem.nodeType === 1 && node && node.nodeValue === match;
2130                };
2131        }
2132
2133        root.removeChild( form );
2134})();
2135
2136(function(){
2137        // Check to see if the browser returns only elements
2138        // when doing getElementsByTagName("*")
2139
2140        // Create a fake element
2141        var div = document.createElement("div");
2142        div.appendChild( document.createComment("") );
2143
2144        // Make sure no comments are found
2145        if ( div.getElementsByTagName("*").length > 0 ) {
2146                Expr.find.TAG = function(match, context){
2147                        var results = context.getElementsByTagName(match[1]);
2148
2149                        // Filter out possible comments
2150                        if ( match[1] === "*" ) {
2151                                var tmp = [];
2152
2153                                for ( var i = 0; results[i]; i++ ) {
2154                                        if ( results[i].nodeType === 1 ) {
2155                                                tmp.push( results[i] );
2156                                        }
2157                                }
2158
2159                                results = tmp;
2160                        }
2161
2162                        return results;
2163                };
2164        }
2165
2166        // Check to see if an attribute returns normalized href attributes
2167        div.innerHTML = "<a href='#'></a>";
2168        if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
2169                        div.firstChild.getAttribute("href") !== "#" ) {
2170                Expr.attrHandle.href = function(elem){
2171                        return elem.getAttribute("href", 2);
2172                };
2173        }
2174})();
2175
2176if ( document.querySelectorAll ) (function(){
2177        var oldSizzle = Sizzle, div = document.createElement("div");
2178        div.innerHTML = "<p class='TEST'></p>";
2179
2180        // Safari can't handle uppercase or unicode characters when
2181        // in quirks mode.
2182        if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
2183                return;
2184        }
2185       
2186        Sizzle = function(query, context, extra, seed){
2187                context = context || document;
2188
2189                // Only use querySelectorAll on non-XML documents
2190                // (ID selectors don't work in non-HTML documents)
2191                if ( !seed && context.nodeType === 9 && !isXML(context) ) {
2192                        try {
2193                                return makeArray( context.querySelectorAll(query), extra );
2194                        } catch(e){}
2195                }
2196               
2197                return oldSizzle(query, context, extra, seed);
2198        };
2199
2200        Sizzle.find = oldSizzle.find;
2201        Sizzle.filter = oldSizzle.filter;
2202        Sizzle.selectors = oldSizzle.selectors;
2203        Sizzle.matches = oldSizzle.matches;
2204})();
2205
2206if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2207        var div = document.createElement("div");
2208        div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2209
2210        // Opera can't find a second classname (in 9.6)
2211        if ( div.getElementsByClassName("e").length === 0 )
2212                return;
2213
2214        // Safari caches class attributes, doesn't catch changes (in 3.2)
2215        div.lastChild.className = "e";
2216
2217        if ( div.getElementsByClassName("e").length === 1 )
2218                return;
2219
2220        Expr.order.splice(1, 0, "CLASS");
2221        Expr.find.CLASS = function(match, context) {
2222                return context.getElementsByClassName(match[1]);
2223        };
2224})();
2225
2226function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2227        var sibDir = dir == "previousSibling" && !isXML;
2228        for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2229                var elem = checkSet[i];
2230                if ( elem ) {
2231                        if ( sibDir && elem.nodeType === 1 ){
2232                                elem.sizcache = doneName;
2233                                elem.sizset = i;
2234                        }
2235                        elem = elem[dir];
2236                        var match = false;
2237
2238                        while ( elem ) {
2239                                if ( elem.sizcache === doneName ) {
2240                                        match = checkSet[elem.sizset];
2241                                        break;
2242                                }
2243
2244                                if ( elem.nodeType === 1 && !isXML ){
2245                                        elem.sizcache = doneName;
2246                                        elem.sizset = i;
2247                                }
2248
2249                                if ( elem.nodeName === cur ) {
2250                                        match = elem;
2251                                        break;
2252                                }
2253
2254                                elem = elem[dir];
2255                        }
2256
2257                        checkSet[i] = match;
2258                }
2259        }
2260}
2261
2262function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2263        var sibDir = dir == "previousSibling" && !isXML;
2264        for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2265                var elem = checkSet[i];
2266                if ( elem ) {
2267                        if ( sibDir && elem.nodeType === 1 ) {
2268                                elem.sizcache = doneName;
2269                                elem.sizset = i;
2270                        }
2271                        elem = elem[dir];
2272                        var match = false;
2273
2274                        while ( elem ) {
2275                                if ( elem.sizcache === doneName ) {
2276                                        match = checkSet[elem.sizset];
2277                                        break;
2278                                }
2279
2280                                if ( elem.nodeType === 1 ) {
2281                                        if ( !isXML ) {
2282                                                elem.sizcache = doneName;
2283                                                elem.sizset = i;
2284                                        }
2285                                        if ( typeof cur !== "string" ) {
2286                                                if ( elem === cur ) {
2287                                                        match = true;
2288                                                        break;
2289                                                }
2290
2291                                        } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
2292                                                match = elem;
2293                                                break;
2294                                        }
2295                                }
2296
2297                                elem = elem[dir];
2298                        }
2299
2300                        checkSet[i] = match;
2301                }
2302        }
2303}
2304
2305var contains = document.compareDocumentPosition ?  function(a, b){
2306        return a.compareDocumentPosition(b) & 16;
2307} : function(a, b){
2308        return a !== b && (a.contains ? a.contains(b) : true);
2309};
2310
2311var isXML = function(elem){
2312        return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
2313                !!elem.ownerDocument && isXML( elem.ownerDocument );
2314};
2315
2316var posProcess = function(selector, context){
2317        var tmpSet = [], later = "", match,
2318                root = context.nodeType ? [context] : context;
2319
2320        // Position selectors must be done after the filter
2321        // And so must :not(positional) so we move all PSEUDOs to the end
2322        while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
2323                later += match[0];
2324                selector = selector.replace( Expr.match.PSEUDO, "" );
2325        }
2326
2327        selector = Expr.relative[selector] ? selector + "*" : selector;
2328
2329        for ( var i = 0, l = root.length; i < l; i++ ) {
2330                Sizzle( selector, root[i], tmpSet );
2331        }
2332
2333        return Sizzle.filter( later, tmpSet );
2334};
2335
2336// EXPOSE
2337jQuery.find = Sizzle;
2338jQuery.filter = Sizzle.filter;
2339jQuery.expr = Sizzle.selectors;
2340jQuery.expr[":"] = jQuery.expr.filters;
2341
2342Sizzle.selectors.filters.hidden = function(elem){
2343        return "hidden" === elem.type ||
2344                jQuery.css(elem, "display") === "none" ||
2345                jQuery.css(elem, "visibility") === "hidden";
2346};
2347
2348Sizzle.selectors.filters.visible = function(elem){
2349        return "hidden" !== elem.type &&
2350                jQuery.css(elem, "display") !== "none" &&
2351                jQuery.css(elem, "visibility") !== "hidden";
2352};
2353
2354Sizzle.selectors.filters.animated = function(elem){
2355        return jQuery.grep(jQuery.timers, function(fn){
2356                return elem === fn.elem;
2357        }).length;
2358};
2359
2360jQuery.multiFilter = function( expr, elems, not ) {
2361        if ( not ) {
2362                expr = ":not(" + expr + ")";
2363        }
2364
2365        return Sizzle.matches(expr, elems);
2366};
2367
2368jQuery.dir = function( elem, dir ){
2369        var matched = [], cur = elem[dir];
2370        while ( cur && cur != document ) {
2371                if ( cur.nodeType == 1 )
2372                        matched.push( cur );
2373                cur = cur[dir];
2374        }
2375        return matched;
2376};
2377
2378jQuery.nth = function(cur, result, dir, elem){
2379        result = result || 1;
2380        var num = 0;
2381
2382        for ( ; cur; cur = cur[dir] )
2383                if ( cur.nodeType == 1 && ++num == result )
2384                        break;
2385
2386        return cur;
2387};
2388
2389jQuery.sibling = function(n, elem){
2390        var r = [];
2391
2392        for ( ; n; n = n.nextSibling ) {
2393                if ( n.nodeType == 1 && n != elem )
2394                        r.push( n );
2395        }
2396
2397        return r;
2398};
2399
2400return;
2401
2402window.Sizzle = Sizzle;
2403
2404})();
2405/*
2406 * A number of helper functions used for managing events.
2407 * Many of the ideas behind this code originated from
2408 * Dean Edwards' addEvent library.
2409 */
2410jQuery.event = {
2411
2412        // Bind an event to an element
2413        // Original by Dean Edwards
2414        add: function(elem, types, handler, data) {
2415                if ( elem.nodeType == 3 || elem.nodeType == 8 )
2416                        return;
2417
2418                // For whatever reason, IE has trouble passing the window object
2419                // around, causing it to be cloned in the process
2420                if ( elem.setInterval && elem != window )
2421                        elem = window;
2422
2423                // Make sure that the function being executed has a unique ID
2424                if ( !handler.guid )
2425                        handler.guid = this.guid++;
2426
2427                // if data is passed, bind to handler
2428                if ( data !== undefined ) {
2429                        // Create temporary function pointer to original handler
2430                        var fn = handler;
2431
2432                        // Create unique handler function, wrapped around original handler
2433                        handler = this.proxy( fn );
2434
2435                        // Store data in unique handler
2436                        handler.data = data;
2437                }
2438
2439                // Init the element's event structure
2440                var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
2441                        handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
2442                                // Handle the second event of a trigger and when
2443                                // an event is called after a page has unloaded
2444                                return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
2445                                        jQuery.event.handle.apply(arguments.callee.elem, arguments) :
2446                                        undefined;
2447                        });
2448                // Add elem as a property of the handle function
2449                // This is to prevent a memory leak with non-native
2450                // event in IE.
2451                handle.elem = elem;
2452
2453                // Handle multiple events separated by a space
2454                // jQuery(...).bind("mouseover mouseout", fn);
2455                jQuery.each(types.split(/\s+/), function(index, type) {
2456                        // Namespaced event handlers
2457                        var namespaces = type.split(".");
2458                        type = namespaces.shift();
2459                        handler.type = namespaces.slice().sort().join(".");
2460
2461                        // Get the current list of functions bound to this event
2462                        var handlers = events[type];
2463                       
2464                        if ( jQuery.event.specialAll[type] )
2465                                jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
2466
2467                        // Init the event handler queue
2468                        if (!handlers) {
2469                                handlers = events[type] = {};
2470
2471                                // Check for a special event handler
2472                                // Only use addEventListener/attachEvent if the special
2473                                // events handler returns false
2474                                if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
2475                                        // Bind the global event handler to the element
2476                                        if (elem.addEventListener)
2477                                                elem.addEventListener(type, handle, false);
2478                                        else if (elem.attachEvent)
2479                                                elem.attachEvent("on" + type, handle);
2480                                }
2481                        }
2482
2483                        // Add the function to the element's handler list
2484                        handlers[handler.guid] = handler;
2485
2486                        // Keep track of which events have been used, for global triggering
2487                        jQuery.event.global[type] = true;
2488                });
2489
2490                // Nullify elem to prevent memory leaks in IE
2491                elem = null;
2492        },
2493
2494        guid: 1,
2495        global: {},
2496
2497        // Detach an event or set of events from an element
2498        remove: function(elem, types, handler) {
2499                // don't do events on text and comment nodes
2500                if ( elem.nodeType == 3 || elem.nodeType == 8 )
2501                        return;
2502
2503                var events = jQuery.data(elem, "events"), ret, index;
2504
2505                if ( events ) {
2506                        // Unbind all events for the element
2507                        if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
2508                                for ( var type in events )
2509                                        this.remove( elem, type + (types || "") );
2510                        else {
2511                                // types is actually an event object here
2512                                if ( types.type ) {
2513                                        handler = types.handler;
2514                                        types = types.type;
2515                                }
2516
2517                                // Handle multiple events seperated by a space
2518                                // jQuery(...).unbind("mouseover mouseout", fn);
2519                                jQuery.each(types.split(/\s+/), function(index, type){
2520                                        // Namespaced event handlers
2521                                        var namespaces = type.split(".");
2522                                        type = namespaces.shift();
2523                                        var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
2524
2525                                        if ( events[type] ) {
2526                                                // remove the given handler for the given type
2527                                                if ( handler )
2528                                                        delete events[type][handler.guid];
2529
2530                                                // remove all handlers for the given type
2531                                                else
2532                                                        for ( var handle in events[type] )
2533                                                                // Handle the removal of namespaced events
2534                                                                if ( namespace.test(events[type][handle].type) )
2535                                                                        delete events[type][handle];
2536                                                                       
2537                                                if ( jQuery.event.specialAll[type] )
2538                                                        jQuery.event.specialAll[type].teardown.call(elem, namespaces);
2539
2540                                                // remove generic event handler if no more handlers exist
2541                                                for ( ret in events[type] ) break;
2542                                                if ( !ret ) {
2543                                                        if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
2544                                                                if (elem.removeEventListener)
2545                                                                        elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
2546                                                                else if (elem.detachEvent)
2547                                                                        elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
2548                                                        }
2549                                                        ret = null;
2550                                                        delete events[type];
2551                                                }
2552                                        }
2553                                });
2554                        }
2555
2556                        // Remove the expando if it's no longer used
2557                        for ( ret in events ) break;
2558                        if ( !ret ) {
2559                                var handle = jQuery.data( elem, "handle" );
2560                                if ( handle ) handle.elem = null;
2561                                jQuery.removeData( elem, "events" );
2562                                jQuery.removeData( elem, "handle" );
2563                        }
2564                }
2565        },
2566
2567        // bubbling is internal
2568        trigger: function( event, data, elem, bubbling ) {
2569                // Event object or event type
2570                var type = event.type || event;
2571
2572                if( !bubbling ){
2573                        event = typeof event === "object" ?
2574                                // jQuery.Event object
2575                                event[expando] ? event :
2576                                // Object literal
2577                                jQuery.extend( jQuery.Event(type), event ) :
2578                                // Just the event type (string)
2579                                jQuery.Event(type);
2580
2581                        if ( type.indexOf("!") >= 0 ) {
2582                                event.type = type = type.slice(0, -1);
2583                                event.exclusive = true;
2584                        }
2585
2586                        // Handle a global trigger
2587                        if ( !elem ) {
2588                                // Don't bubble custom events when global (to avoid too much overhead)
2589                                event.stopPropagation();
2590                                // Only trigger if we've ever bound an event for it
2591                                if ( this.global[type] )
2592                                        jQuery.each( jQuery.cache, function(){
2593                                                if ( this.events && this.events[type] )
2594                                                        jQuery.event.trigger( event, data, this.handle.elem );
2595                                        });
2596                        }
2597
2598                        // Handle triggering a single element
2599
2600                        // don't do events on text and comment nodes
2601                        if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 )
2602                                return undefined;
2603                       
2604                        // Clean up in case it is reused
2605                        event.result = undefined;
2606                        event.target = elem;
2607                       
2608                        // Clone the incoming data, if any
2609                        data = jQuery.makeArray(data);
2610                        data.unshift( event );
2611                }
2612
2613                event.currentTarget = elem;
2614
2615                // Trigger the event, it is assumed that "handle" is a function
2616                var handle = jQuery.data(elem, "handle");
2617                if ( handle )
2618                        handle.apply( elem, data );
2619
2620                // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2621                if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2622                        event.result = false;
2623
2624                // Trigger the native events (except for clicks on links)
2625                if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2626                        this.triggered = true;
2627                        try {
2628                                elem[ type ]();
2629                        // prevent IE from throwing an error for some hidden elements
2630                        } catch (e) {}
2631                }
2632
2633                this.triggered = false;
2634
2635                if ( !event.isPropagationStopped() ) {
2636                        var parent = elem.parentNode || elem.ownerDocument;
2637                        if ( parent )
2638                                jQuery.event.trigger(event, data, parent, true);
2639                }
2640        },
2641
2642        handle: function(event) {
2643                // returned undefined or false
2644                var all, handlers;
2645
2646                event = arguments[0] = jQuery.event.fix( event || window.event );
2647
2648                // Namespaced event handlers
2649                var namespaces = event.type.split(".");
2650                event.type = namespaces.shift();
2651
2652                // Cache this now, all = true means, any handler
2653                all = !namespaces.length && !event.exclusive;
2654               
2655                var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
2656
2657                handlers = ( jQuery.data(this, "events") || {} )[event.type];
2658
2659                for ( var j in handlers ) {
2660                        var handler = handlers[j];
2661
2662                        // Filter the functions by class
2663                        if ( all || namespace.test(handler.type) ) {
2664                                // Pass in a reference to the handler function itself
2665                                // So that we can later remove it
2666                                event.handler = handler;
2667                                event.data = handler.data;
2668
2669                                var ret = handler.apply(this, arguments);
2670
2671                                if( ret !== undefined ){
2672                                        event.result = ret;
2673                                        if ( ret === false ) {
2674                                                event.preventDefault();
2675                                                event.stopPropagation();
2676                                        }
2677                                }
2678
2679                                if( event.isImmediatePropagationStopped() )
2680                                        break;
2681
2682                        }
2683                }
2684        },
2685
2686        props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2687
2688        fix: function(event) {
2689                if ( event[expando] )
2690                        return event;
2691
2692                // store a copy of the original event object
2693                // and "clone" to set read-only properties
2694                var originalEvent = event;
2695                event = jQuery.Event( originalEvent );
2696
2697                for ( var i = this.props.length, prop; i; ){
2698                        prop = this.props[ --i ];
2699                        event[ prop ] = originalEvent[ prop ];
2700                }
2701
2702                // Fix target property, if necessary
2703                if ( !event.target )
2704                        event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2705
2706                // check if target is a textnode (safari)
2707                if ( event.target.nodeType == 3 )
2708                        event.target = event.target.parentNode;
2709
2710                // Add relatedTarget, if necessary
2711                if ( !event.relatedTarget && event.fromElement )
2712                        event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2713
2714                // Calculate pageX/Y if missing and clientX/Y available
2715                if ( event.pageX == null && event.clientX != null ) {
2716                        var doc = document.documentElement, body = document.body;
2717                        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2718                        event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2719                }
2720
2721                // Add which for key events
2722                if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2723                        event.which = event.charCode || event.keyCode;
2724
2725                // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2726                if ( !event.metaKey && event.ctrlKey )
2727                        event.metaKey = event.ctrlKey;
2728
2729                // Add which for click: 1 == left; 2 == middle; 3 == right
2730                // Note: button is not normalized, so don't use it
2731                if ( !event.which && event.button )
2732                        event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2733
2734                return event;
2735        },
2736
2737        proxy: function( fn, proxy ){
2738                proxy = proxy || function(){ return fn.apply(this, arguments); };
2739                // Set the guid of unique handler to the same of original handler, so it can be removed
2740                proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
2741                // So proxy can be declared as an argument
2742                return proxy;
2743        },
2744
2745        special: {
2746                ready: {
2747                        // Make sure the ready event is setup
2748                        setup: bindReady,
2749                        teardown: function() {}
2750                }
2751        },
2752       
2753        specialAll: {
2754                live: {
2755                        setup: function( selector, namespaces ){
2756                                jQuery.event.add( this, namespaces[0], liveHandler );
2757                        },
2758                        teardown:  function( namespaces ){
2759                                if ( namespaces.length ) {
2760                                        var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
2761                                       
2762                                        jQuery.each( (jQuery.data(this, "events").live || {}), function(){
2763                                                if ( name.test(this.type) )
2764                                                        remove++;
2765                                        });
2766                                       
2767                                        if ( remove < 1 )
2768                                                jQuery.event.remove( this, namespaces[0], liveHandler );
2769                                }
2770                        }
2771                }
2772        }
2773};
2774
2775jQuery.Event = function( src ){
2776        // Allow instantiation without the 'new' keyword
2777        if( !this.preventDefault )
2778                return new jQuery.Event(src);
2779       
2780        // Event object
2781        if( src && src.type ){
2782                this.originalEvent = src;
2783                this.type = src.type;
2784        // Event type
2785        }else
2786                this.type = src;
2787
2788        // timeStamp is buggy for some events on Firefox(#3843)
2789        // So we won't rely on the native value
2790        this.timeStamp = now();
2791       
2792        // Mark it as fixed
2793        this[expando] = true;
2794};
2795
2796function returnFalse(){
2797        return false;
2798}
2799function returnTrue(){
2800        return true;
2801}
2802
2803// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2804// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2805jQuery.Event.prototype = {
2806        preventDefault: function() {
2807                this.isDefaultPrevented = returnTrue;
2808
2809                var e = this.originalEvent;
2810                if( !e )
2811                        return;
2812                // if preventDefault exists run it on the original event
2813                if (e.preventDefault)
2814                        e.preventDefault();
2815                // otherwise set the returnValue property of the original event to false (IE)
2816                e.returnValue = false;
2817        },
2818        stopPropagation: function() {
2819                this.isPropagationStopped = returnTrue;
2820
2821                var e = this.originalEvent;
2822                if( !e )
2823                        return;
2824                // if stopPropagation exists run it on the original event
2825                if (e.stopPropagation)
2826                        e.stopPropagation();
2827                // otherwise set the cancelBubble property of the original event to true (IE)
2828                e.cancelBubble = true;
2829        },
2830        stopImmediatePropagation:function(){
2831                this.isImmediatePropagationStopped = returnTrue;
2832                this.stopPropagation();
2833        },
2834        isDefaultPrevented: returnFalse,
2835        isPropagationStopped: returnFalse,
2836        isImmediatePropagationStopped: returnFalse
2837};
2838// Checks if an event happened on an element within another element
2839// Used in jQuery.event.special.mouseenter and mouseleave handlers
2840var withinElement = function(event) {
2841        // Check if mouse(over|out) are still within the same parent element
2842        var parent = event.relatedTarget;
2843        // Traverse up the tree
2844        while ( parent && parent != this )
2845                try { parent = parent.parentNode; }
2846                catch(e) { parent = this; }
2847       
2848        if( parent != this ){
2849                // set the correct event type
2850                event.type = event.data;
2851                // handle event if we actually just moused on to a non sub-element
2852                jQuery.event.handle.apply( this, arguments );
2853        }
2854};
2855       
2856jQuery.each({ 
2857        mouseover: 'mouseenter', 
2858        mouseout: 'mouseleave'
2859}, function( orig, fix ){
2860        jQuery.event.special[ fix ] = {
2861                setup: function(){
2862                        jQuery.event.add( this, orig, withinElement, fix );
2863                },
2864                teardown: function(){
2865                        jQuery.event.remove( this, orig, withinElement );
2866                }
2867        };                         
2868});
2869
2870jQuery.fn.extend({
2871        bind: function( type, data, fn ) {
2872                return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2873                        jQuery.event.add( this, type, fn || data, fn && data );
2874                });
2875        },
2876
2877        one: function( type, data, fn ) {
2878                var one = jQuery.event.proxy( fn || data, function(event) {
2879                        jQuery(this).unbind(event, one);
2880                        return (fn || data).apply( this, arguments );
2881                });
2882                return this.each(function(){
2883                        jQuery.event.add( this, type, one, fn && data);
2884                });
2885        },
2886
2887        unbind: function( type, fn ) {
2888                return this.each(function(){
2889                        jQuery.event.remove( this, type, fn );
2890                });
2891        },
2892
2893        trigger: function( type, data ) {
2894                return this.each(function(){
2895                        jQuery.event.trigger( type, data, this );
2896                });
2897        },
2898
2899        triggerHandler: function( type, data ) {
2900                if( this[0] ){
2901                        var event = jQuery.Event(type);
2902                        event.preventDefault();
2903                        event.stopPropagation();
2904                        jQuery.event.trigger( event, data, this[0] );
2905                        return event.result;
2906                }               
2907        },
2908
2909        toggle: function( fn ) {
2910                // Save reference to arguments for access in closure
2911                var args = arguments, i = 1;
2912
2913                // link all the functions, so any of them can unbind this click handler
2914                while( i < args.length )
2915                        jQuery.event.proxy( fn, args[i++] );
2916
2917                return this.click( jQuery.event.proxy( fn, function(event) {
2918                        // Figure out which function to execute
2919                        this.lastToggle = ( this.lastToggle || 0 ) % i;
2920
2921                        // Make sure that clicks stop
2922                        event.preventDefault();
2923
2924                        // and execute the function
2925                        return args[ this.lastToggle++ ].apply( this, arguments ) || false;
2926                }));
2927        },
2928
2929        hover: function(fnOver, fnOut) {
2930                return this.mouseenter(fnOver).mouseleave(fnOut);
2931        },
2932
2933        ready: function(fn) {
2934                // Attach the listeners
2935                bindReady();
2936
2937                // If the DOM is already ready
2938                if ( jQuery.isReady )
2939                        // Execute the function immediately
2940                        fn.call( document, jQuery );
2941
2942                // Otherwise, remember the function for later
2943                else
2944                        // Add the function to the wait list
2945                        jQuery.readyList.push( fn );
2946
2947                return this;
2948        },
2949       
2950        live: function( type, fn ){
2951                var proxy = jQuery.event.proxy( fn );
2952                proxy.guid += this.selector + type;
2953
2954                jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
2955
2956                return this;
2957        },
2958       
2959        die: function( type, fn ){
2960                jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
2961                return this;
2962        }
2963});
2964
2965function liveHandler( event ){
2966        var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"),
2967                stop = true,
2968                elems = [];
2969
2970        jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
2971                if ( check.test(fn.type) ) {
2972                        var elem = jQuery(event.target).closest(fn.data)[0];
2973                        if ( elem )
2974                                elems.push({ elem: elem, fn: fn });
2975                }
2976        });
2977
2978        elems.sort(function(a,b) {
2979                return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "closest");
2980        });
2981       
2982        jQuery.each(elems, function(){
2983                if ( this.fn.call(this.elem, event, this.fn.data) === false )
2984                        return (stop = false);
2985        });
2986
2987        return stop;
2988}
2989
2990function liveConvert(type, selector){
2991        return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].join(".");
2992}
2993
2994jQuery.extend({
2995        isReady: false,
2996        readyList: [],
2997        // Handle when the DOM is ready
2998        ready: function() {
2999                // Make sure that the DOM is not already loaded
3000                if ( !jQuery.isReady ) {
3001                        // Remember that the DOM is ready
3002                        jQuery.isReady = true;
3003
3004                        // If there are functions bound, to execute
3005                        if ( jQuery.readyList ) {
3006                                // Execute all of them
3007                                jQuery.each( jQuery.readyList, function(){
3008                                        this.call( document, jQuery );
3009                                });
3010
3011                                // Reset the list of functions
3012                                jQuery.readyList = null;
3013                        }
3014
3015                        // Trigger any bound ready events
3016                        jQuery(document).triggerHandler("ready");
3017                }
3018        }
3019});
3020
3021var readyBound = false;
3022
3023function bindReady(){
3024        if ( readyBound ) return;
3025        readyBound = true;
3026
3027        // Mozilla, Opera and webkit nightlies currently support this event
3028        if ( document.addEventListener ) {
3029                // Use the handy event callback
3030                document.addEventListener( "DOMContentLoaded", function(){
3031                        document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
3032                        jQuery.ready();
3033                }, false );
3034
3035        // If IE event model is used
3036        } else if ( document.attachEvent ) {
3037                // ensure firing before onload,
3038                // maybe late but safe also for iframes
3039                document.attachEvent("onreadystatechange", function(){
3040                        if ( document.readyState === "complete" ) {
3041                                document.detachEvent( "onreadystatechange", arguments.callee );
3042                                jQuery.ready();
3043                        }
3044                });
3045
3046                // If IE and not an iframe
3047                // continually check to see if the document is ready
3048                if ( document.documentElement.doScroll && window == window.top ) (function(){
3049                        if ( jQuery.isReady ) return;
3050
3051                        try {
3052                                // If IE is used, use the trick by Diego Perini
3053                                // http://javascript.nwbox.com/IEContentLoaded/
3054                                document.documentElement.doScroll("left");
3055                        } catch( error ) {
3056                                setTimeout( arguments.callee, 0 );
3057                                return;
3058                        }
3059
3060                        // and execute any waiting functions
3061                        jQuery.ready();
3062                })();
3063        }
3064
3065        // A fallback to window.onload, that will always work
3066        jQuery.event.add( window, "load", jQuery.ready );
3067}
3068
3069jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
3070        "mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
3071        "change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
3072
3073        // Handle event binding
3074        jQuery.fn[name] = function(fn){
3075                return fn ? this.bind(name, fn) : this.trigger(name);
3076        };
3077});
3078
3079// Prevent memory leaks in IE
3080// And prevent errors on refresh with events like mouseover in other browsers
3081// Window isn't included so as not to unbind existing unload events
3082jQuery( window ).bind( 'unload', function(){ 
3083        for ( var id in jQuery.cache )
3084                // Skip the window
3085                if ( id != 1 && jQuery.cache[ id ].handle )
3086                        jQuery.event.remove( jQuery.cache[ id ].handle.elem );
3087}); 
3088(function(){
3089
3090        jQuery.support = {};
3091
3092        var root = document.documentElement,
3093                script = document.createElement("script"),
3094                div = document.createElement("div"),
3095                id = "script" + (new Date).getTime();
3096
3097        div.style.display = "none";
3098        div.innerHTML = '   <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>';
3099
3100        var all = div.getElementsByTagName("*"),
3101                a = div.getElementsByTagName("a")[0];
3102
3103        // Can't get basic test support
3104        if ( !all || !all.length || !a ) {
3105                return;
3106        }
3107
3108        jQuery.support = {
3109                // IE strips leading whitespace when .innerHTML is used
3110                leadingWhitespace: div.firstChild.nodeType == 3,
3111               
3112                // Make sure that tbody elements aren't automatically inserted
3113                // IE will insert them into empty tables
3114                tbody: !div.getElementsByTagName("tbody").length,
3115               
3116                // Make sure that you can get all elements in an <object> element
3117                // IE 7 always returns no results
3118                objectAll: !!div.getElementsByTagName("object")[0]
3119                        .getElementsByTagName("*").length,
3120               
3121                // Make sure that link elements get serialized correctly by innerHTML
3122                // This requires a wrapper element in IE
3123                htmlSerialize: !!div.getElementsByTagName("link").length,
3124               
3125                // Get the style information from getAttribute
3126                // (IE uses .cssText insted)
3127                style: /red/.test( a.getAttribute("style") ),
3128               
3129                // Make sure that URLs aren't manipulated
3130                // (IE normalizes it by default)
3131                hrefNormalized: a.getAttribute("href") === "/a",
3132               
3133                // Make sure that element opacity exists
3134                // (IE uses filter instead)
3135                opacity: a.style.opacity === "0.5",
3136               
3137                // Verify style float existence
3138                // (IE uses styleFloat instead of cssFloat)
3139                cssFloat: !!a.style.cssFloat,
3140
3141                // Will be defined later
3142                scriptEval: false,
3143                noCloneEvent: true,
3144                boxModel: null
3145        };
3146       
3147        script.type = "text/javascript";
3148        try {
3149                script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
3150        } catch(e){}
3151
3152        root.insertBefore( script, root.firstChild );
3153       
3154        // Make sure that the execution of code works by injecting a script
3155        // tag with appendChild/createTextNode
3156        // (IE doesn't support this, fails, and uses .text instead)
3157        if ( window[ id ] ) {
3158                jQuery.support.scriptEval = true;
3159                delete window[ id ];
3160        }
3161
3162        root.removeChild( script );
3163
3164        if ( div.attachEvent && div.fireEvent ) {
3165                div.attachEvent("onclick", function(){
3166                        // Cloning a node shouldn't copy over any
3167                        // bound event handlers (IE does this)
3168                        jQuery.support.noCloneEvent = false;
3169                        div.detachEvent("onclick", arguments.callee);
3170                });
3171                div.cloneNode(true).fireEvent("onclick");
3172        }
3173
3174        // Figure out if the W3C box model works as expected
3175        // document.body must exist before we can do this
3176        jQuery(function(){
3177                var div = document.createElement("div");
3178                div.style.width = div.style.paddingLeft = "1px";
3179
3180                document.body.appendChild( div );
3181                jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
3182                document.body.removeChild( div ).style.display = 'none';
3183        });
3184})();
3185
3186var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat";
3187
3188jQuery.props = {
3189        "for": "htmlFor",
3190        "class": "className",
3191        "float": styleFloat,
3192        cssFloat: styleFloat,
3193        styleFloat: styleFloat,
3194        readonly: "readOnly",
3195        maxlength: "maxLength",
3196        cellspacing: "cellSpacing",
3197        rowspan: "rowSpan",
3198        tabindex: "tabIndex"
3199};
3200jQuery.fn.extend({
3201        // Keep a copy of the old load
3202        _load: jQuery.fn.load,
3203
3204        load: function( url, params, callback ) {
3205                if ( typeof url !== "string" )
3206                        return this._load( url );
3207
3208                var off = url.indexOf(" ");
3209                if ( off >= 0 ) {
3210                        var selector = url.slice(off, url.length);
3211                        url = url.slice(0, off);
3212                }
3213
3214                // Default to a GET request
3215                var type = "GET";
3216
3217                // If the second parameter was provided
3218                if ( params )
3219                        // If it's a function
3220                        if ( jQuery.isFunction( params ) ) {
3221                                // We assume that it's the callback
3222                                callback = params;
3223                                params = null;
3224
3225                        // Otherwise, build a param string
3226                        } else if( typeof params === "object" ) {
3227                                params = jQuery.param( params );
3228                                type = "POST";
3229                        }
3230
3231                var self = this;
3232
3233                // Request the remote document
3234                jQuery.ajax({
3235                        url: url,
3236                        type: type,
3237                        dataType: "html",
3238                        data: params,
3239                        complete: function(res, status){
3240                                // If successful, inject the HTML into all the matched elements
3241                                if ( status == "success" || status == "notmodified" )
3242                                        // See if a selector was specified
3243                                        self.html( selector ?
3244                                                // Create a dummy div to hold the results
3245                                                jQuery("<div/>")
3246                                                        // inject the contents of the document in, removing the scripts
3247                                                        // to avoid any 'Permission Denied' errors in IE
3248                                                        .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
3249
3250                                                        // Locate the specified elements
3251                                                        .find(selector) :
3252
3253                                                // If not, just inject the full result
3254                                                res.responseText );
3255
3256                                if( callback )
3257                                        self.each( callback, [res.responseText, status, res] );
3258                        }
3259                });
3260                return this;
3261        },
3262
3263        serialize: function() {
3264                return jQuery.param(this.serializeArray());
3265        },
3266        serializeArray: function() {
3267                return this.map(function(){
3268                        return this.elements ? jQuery.makeArray(this.elements) : this;
3269                })
3270                .filter(function(){
3271                        return this.name && !this.disabled &&
3272                                (this.checked || /select|textarea/i.test(this.nodeName) ||
3273                                        /text|hidden|password/i.test(this.type));
3274                })
3275                .map(function(i, elem){
3276                        var val = jQuery(this).val();
3277                        return val == null ? null :
3278                                jQuery.isArray(val) ?
3279                                        jQuery.map( val, function(val, i){
3280                                                return {name: elem.name, value: val};
3281                                        }) :
3282                                        {name: elem.name, value: val};
3283                }).get();
3284        }
3285});
3286
3287// Attach a bunch of functions for handling common AJAX events
3288jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
3289        jQuery.fn[o] = function(f){
3290                return this.bind(o, f);
3291        };
3292});
3293
3294var jsc = now();
3295
3296jQuery.extend({
3297 
3298        get: function( url, data, callback, type ) {
3299                // shift arguments if data argument was ommited
3300                if ( jQuery.isFunction( data ) ) {
3301                        callback = data;
3302                        data = null;
3303                }
3304
3305                return jQuery.ajax({
3306                        type: "GET",
3307                        url: url,
3308                        data: data,
3309                        success: callback,
3310                        dataType: type
3311                });
3312        },
3313
3314        getScript: function( url, callback ) {
3315                return jQuery.get(url, null, callback, "script");
3316        },
3317
3318        getJSON: function( url, data, callback ) {
3319                return jQuery.get(url, data, callback, "json");
3320        },
3321
3322        post: function( url, data, callback, type ) {
3323                if ( jQuery.isFunction( data ) ) {
3324                        callback = data;
3325                        data = {};
3326                }
3327
3328                return jQuery.ajax({
3329                        type: "POST",
3330                        url: url,
3331                        data: data,
3332                        success: callback,
3333                        dataType: type
3334                });
3335        },
3336
3337        ajaxSetup: function( settings ) {
3338                jQuery.extend( jQuery.ajaxSettings, settings );
3339        },
3340
3341        ajaxSettings: {
3342                url: location.href,
3343                global: true,
3344                type: "GET",
3345                contentType: "application/x-www-form-urlencoded",
3346                processData: true,
3347                async: true,
3348                /*
3349                timeout: 0,
3350                data: null,
3351                username: null,
3352                password: null,
3353                */
3354                // Create the request object; Microsoft failed to properly
3355                // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
3356                // This function can be overriden by calling jQuery.ajaxSetup
3357                xhr:function(){
3358                        return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
3359                },
3360                accepts: {
3361                        xml: "application/xml, text/xml",
3362                        html: "text/html",
3363                        script: "text/javascript, application/javascript",
3364                        json: "application/json, text/javascript",
3365                        text: "text/plain",
3366                        _default: "*/*"
3367                }
3368        },
3369
3370        // Last-Modified header cache for next request
3371        lastModified: {},
3372
3373        ajax: function( s ) {
3374                // Extend the settings, but re-extend 's' so that it can be
3375                // checked again later (in the test suite, specifically)
3376                s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
3377
3378                var jsonp, jsre = /=\?(&|$)/g, status, data,
3379                        type = s.type.toUpperCase();
3380
3381                // convert data if not already a string
3382                if ( s.data && s.processData && typeof s.data !== "string" )
3383                        s.data = jQuery.param(s.data);
3384
3385                // Handle JSONP Parameter Callbacks
3386                if ( s.dataType == "jsonp" ) {
3387                        if ( type == "GET" ) {
3388                                if ( !s.url.match(jsre) )
3389                                        s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
3390                        } else if ( !s.data || !s.data.match(jsre) )
3391                                s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
3392                        s.dataType = "json";
3393                }
3394
3395                // Build temporary JSONP function
3396                if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
3397                        jsonp = "jsonp" + jsc++;
3398
3399                        // Replace the =? sequence both in the query string and the data
3400                        if ( s.data )
3401                                s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
3402                        s.url = s.url.replace(jsre, "=" + jsonp + "$1");
3403
3404                        // We need to make sure
3405                        // that a JSONP style response is executed properly
3406                        s.dataType = "script";
3407
3408                        // Handle JSONP-style loading
3409                        window[ jsonp ] = function(tmp){
3410                                data = tmp;
3411                                success();
3412                                complete();
3413                                // Garbage collect
3414                                window[ jsonp ] = undefined;
3415                                try{ delete window[ jsonp ]; } catch(e){}
3416                                if ( head )
3417                                        head.removeChild( script );
3418                        };
3419                }
3420
3421                if ( s.dataType == "script" && s.cache == null )
3422                        s.cache = false;
3423
3424                if ( s.cache === false && type == "GET" ) {
3425                        var ts = now();
3426                        // try replacing _= if it is there
3427                        var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
3428                        // if nothing was replaced, add timestamp to the end
3429                        s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
3430                }
3431
3432                // If data is available, append data to url for get requests
3433                if ( s.data && type == "GET" ) {
3434                        s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
3435
3436                        // IE likes to send both get and post data, prevent this
3437                        s.data = null;
3438                }
3439
3440                // Watch for a new set of requests
3441                if ( s.global && ! jQuery.active++ )
3442                        jQuery.event.trigger( "ajaxStart" );
3443
3444                // Matches an absolute URL, and saves the domain
3445                var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );
3446
3447                // If we're requesting a remote document
3448                // and trying to load JSON or Script with a GET
3449                if ( s.dataType == "script" && type == "GET" && parts
3450                        && ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){
3451
3452                        var head = document.getElementsByTagName("head")[0];
3453                        var script = document.createElement("script");
3454                        script.src = s.url;
3455                        if (s.scriptCharset)
3456                                script.charset = s.scriptCharset;
3457
3458                        // Handle Script loading
3459                        if ( !jsonp ) {
3460                                var done = false;
3461
3462                                // Attach handlers for all browsers
3463                                script.onload = script.onreadystatechange = function(){
3464                                        if ( !done && (!this.readyState ||
3465                                                        this.readyState == "loaded" || this.readyState == "complete") ) {
3466                                                done = true;
3467                                                success();
3468                                                complete();
3469
3470                                                // Handle memory leak in IE
3471                                                script.onload = script.onreadystatechange = null;
3472                                                head.removeChild( script );
3473                                        }
3474                                };
3475                        }
3476
3477                        head.appendChild(script);
3478
3479                        // We handle everything using the script element injection
3480                        return undefined;
3481                }
3482
3483                var requestDone = false;
3484
3485                // Create the request object
3486                var xhr = s.xhr();
3487
3488                // Open the socket
3489                // Passing null username, generates a login popup on Opera (#2865)
3490                if( s.username )
3491                        xhr.open(type, s.url, s.async, s.username, s.password);
3492                else
3493                        xhr.open(type, s.url, s.async);
3494
3495                // Need an extra try/catch for cross domain requests in Firefox 3
3496                try {
3497                        // Set the correct header, if data is being sent
3498                        if ( s.data )
3499                                xhr.setRequestHeader("Content-Type", s.contentType);
3500
3501                        // Set the If-Modified-Since header, if ifModified mode.
3502                        if ( s.ifModified )
3503                                xhr.setRequestHeader("If-Modified-Since",
3504                                        jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
3505
3506                        // Set header so the called script knows that it's an XMLHttpRequest
3507                        xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
3508
3509                        // Set the Accepts header for the server, depending on the dataType
3510                        xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
3511                                s.accepts[ s.dataType ] + ", */*" :
3512                                s.accepts._default );
3513                } catch(e){}
3514
3515                // Allow custom headers/mimetypes and early abort
3516                if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
3517                        // Handle the global AJAX counter
3518                        if ( s.global && ! --jQuery.active )
3519                                jQuery.event.trigger( "ajaxStop" );
3520                        // close opended socket
3521                        xhr.abort();
3522                        return false;
3523                }
3524
3525                if ( s.global )
3526                        jQuery.event.trigger("ajaxSend", [xhr, s]);
3527
3528                // Wait for a response to come back
3529                var onreadystatechange = function(isTimeout){
3530                        // The request was aborted, clear the interval and decrement jQuery.active
3531                        if (xhr.readyState == 0) {
3532                                if (ival) {
3533                                        // clear poll interval
3534                                        clearInterval(ival);
3535                                        ival = null;
3536                                        // Handle the global AJAX counter
3537                                        if ( s.global && ! --jQuery.active )
3538                                                jQuery.event.trigger( "ajaxStop" );
3539                                }
3540                        // The transfer is complete and the data is available, or the request timed out
3541                        } else if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
3542                                requestDone = true;
3543
3544                                // clear poll interval
3545                                if (ival) {
3546                                        clearInterval(ival);
3547                                        ival = null;
3548                                }
3549
3550                                status = isTimeout == "timeout" ? "timeout" :
3551                                        !jQuery.httpSuccess( xhr ) ? "error" :
3552                                        s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
3553                                        "success";
3554
3555                                if ( status == "success" ) {
3556                                        // Watch for, and catch, XML document parse errors
3557                                        try {
3558                                                // process the data (runs the xml through httpData regardless of callback)
3559                                                data = jQuery.httpData( xhr, s.dataType, s );
3560                                        } catch(e) {
3561                                                status = "parsererror";
3562                                        }
3563                                }
3564
3565                                // Make sure that the request was successful or notmodified
3566                                if ( status == "success" ) {
3567                                        // Cache Last-Modified header, if ifModified mode.
3568                                        var modRes;
3569                                        try {
3570                                                modRes = xhr.getResponseHeader("Last-Modified");
3571                                        } catch(e) {} // swallow exception thrown by FF if header is not available
3572
3573                                        if ( s.ifModified && modRes )
3574                                                jQuery.lastModified[s.url] = modRes;
3575
3576                                        // JSONP handles its own success callback
3577                                        if ( !jsonp )
3578                                                success();
3579                                } else
3580                                        jQuery.handleError(s, xhr, status);
3581
3582                                // Fire the complete handlers
3583                                complete();
3584
3585                                if ( isTimeout )
3586                                        xhr.abort();
3587
3588                                // Stop memory leaks
3589                                if ( s.async )
3590                                        xhr = null;
3591                        }
3592                };
3593
3594                if ( s.async ) {
3595                        // don't attach the handler to the request, just poll it instead
3596                        var ival = setInterval(onreadystatechange, 13);
3597
3598                        // Timeout checker
3599                        if ( s.timeout > 0 )
3600                                setTimeout(function(){
3601                                        // Check to see if the request is still happening
3602                                        if ( xhr && !requestDone )
3603                                                onreadystatechange( "timeout" );
3604                                }, s.timeout);
3605                }
3606
3607                // Send the data
3608                try {
3609                        xhr.send(s.data);
3610                } catch(e) {
3611                        jQuery.handleError(s, xhr, null, e);
3612                }
3613
3614                // firefox 1.5 doesn't fire statechange for sync requests
3615                if ( !s.async )
3616                        onreadystatechange();
3617
3618                function success(){
3619                        // If a local callback was specified, fire it and pass it the data
3620                        if ( s.success )
3621                                s.success( data, status );
3622
3623                        // Fire the global callback
3624                        if ( s.global )
3625                                jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
3626                }
3627
3628                function complete(){
3629                        // Process result
3630                        if ( s.complete )
3631                                s.complete(xhr, status);
3632
3633                        // The request was completed
3634                        if ( s.global )
3635                                jQuery.event.trigger( "ajaxComplete", [xhr, s] );
3636
3637                        // Handle the global AJAX counter
3638                        if ( s.global && ! --jQuery.active )
3639                                jQuery.event.trigger( "ajaxStop" );
3640                }
3641
3642                // return XMLHttpRequest to allow aborting the request etc.
3643                return xhr;
3644        },
3645
3646        handleError: function( s, xhr, status, e ) {
3647                // If a local callback was specified, fire it
3648                if ( s.error ) s.error( xhr, status, e );
3649
3650                // Fire the global callback
3651                if ( s.global )
3652                        jQuery.event.trigger( "ajaxError", [xhr, s, e] );
3653        },
3654
3655        // Counter for holding the number of active queries
3656        active: 0,
3657
3658        // Determines if an XMLHttpRequest was successful or not
3659        httpSuccess: function( xhr ) {
3660                try {
3661                        // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
3662                        return !xhr.status && location.protocol == "file:" ||
3663                                ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223;
3664                } catch(e){}
3665                return false;
3666        },
3667
3668        // Determines if an XMLHttpRequest returns NotModified
3669        httpNotModified: function( xhr, url ) {
3670                try {
3671                        var xhrRes = xhr.getResponseHeader("Last-Modified");
3672
3673                        // Firefox always returns 200. check Last-Modified date
3674                        return xhr.status == 304 || xhrRes == jQuery.lastModified[url];
3675                } catch(e){}
3676                return false;
3677        },
3678
3679        httpData: function( xhr, type, s ) {
3680                var ct = xhr.getResponseHeader("content-type"),
3681                        xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
3682                        data = xml ? xhr.responseXML : xhr.responseText;
3683
3684                if ( xml && data.documentElement.tagName == "parsererror" )
3685                        throw "parsererror";
3686                       
3687                // Allow a pre-filtering function to sanitize the response
3688                // s != null is checked to keep backwards compatibility
3689                if( s && s.dataFilter )
3690                        data = s.dataFilter( data, type );
3691
3692                // The filter can actually parse the response
3693                if( typeof data === "string" ){
3694
3695                        // If the type is "script", eval it in global context
3696                        if ( type == "script" )
3697                                jQuery.globalEval( data );
3698
3699                        // Get the JavaScript object, if JSON is used.
3700                        if ( type == "json" )
3701                                data = window["eval"]("(" + data + ")");
3702                }
3703               
3704                return data;
3705        },
3706
3707        // Serialize an array of form elements or a set of
3708        // key/values into a query string
3709        param: function( a ) {
3710                var s = [ ];
3711
3712                function add( key, value ){
3713                        s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
3714                };
3715
3716                // If an array was passed in, assume that it is an array
3717                // of form elements
3718                if ( jQuery.isArray(a) || a.jquery )
3719                        // Serialize the form elements
3720                        jQuery.each( a, function(){
3721                                add( this.name, this.value );
3722                        });
3723
3724                // Otherwise, assume that it's an object of key/value pairs
3725                else
3726                        // Serialize the key/values
3727                        for ( var j in a )
3728                                // If the value is an array then the key names need to be repeated
3729                                if ( jQuery.isArray(a[j]) )
3730                                        jQuery.each( a[j], function(){
3731                                                add( j, this );
3732                                        });
3733                                else
3734                                        add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
3735
3736                // Return the resulting serialization
3737                return s.join("&").replace(/%20/g, "+");
3738        }
3739
3740});
3741var elemdisplay = {},
3742        timerId,
3743        fxAttrs = [
3744                // height animations
3745                [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
3746                // width animations
3747                [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
3748                // opacity animations
3749                [ "opacity" ]
3750        ];
3751
3752function genFx( type, num ){
3753        var obj = {};
3754        jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){
3755                obj[ this ] = type;
3756        });
3757        return obj;
3758}
3759
3760jQuery.fn.extend({
3761        show: function(speed,callback){
3762                if ( speed ) {
3763                        return this.animate( genFx("show", 3), speed, callback);
3764                } else {
3765                        for ( var i = 0, l = this.length; i < l; i++ ){
3766                                var old = jQuery.data(this[i], "olddisplay");
3767                               
3768                                this[i].style.display = old || "";
3769                               
3770                                if ( jQuery.css(this[i], "display") === "none" ) {
3771                                        var tagName = this[i].tagName, display;
3772                                       
3773                                        if ( elemdisplay[ tagName ] ) {
3774                                                display = elemdisplay[ tagName ];
3775                                        } else {
3776                                                var elem = jQuery("<" + tagName + " />").appendTo("body");
3777                                               
3778                                                display = elem.css("display");
3779                                                if ( display === "none" )
3780                                                        display = "block";
3781                                               
3782                                                elem.remove();
3783                                               
3784                                                elemdisplay[ tagName ] = display;
3785                                        }
3786                                       
3787                                        jQuery.data(this[i], "olddisplay", display);
3788                                }
3789
3790                                // Set the display of the elements in a second loop
3791                                // to avoid the constant reflow
3792                                for ( var i = 0, l = this.length; i < l; i++ ){
3793                                        this[i].style.display = jQuery.data(this[i], "olddisplay");
3794                                }
3795                        }
3796                       
3797                        return this;
3798                }
3799        },
3800
3801        hide: function(speed,callback){
3802                if ( speed ) {
3803                        return this.animate( genFx("hide", 3), speed, callback);
3804                } else {
3805                        for ( var i = 0, l = this.length; i < l; i++ ){
3806                                var old = jQuery.data(this[i], "olddisplay");
3807                                if ( !old && old !== "none" )
3808                                        jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
3809                        }
3810
3811                        // Set the display of the elements in a second loop
3812                        // to avoid the constant reflow
3813                        for ( var i = 0, l = this.length; i < l; i++ ){
3814                                this[i].style.display = "none";
3815                        }
3816
3817                        return this;
3818                }
3819        },
3820
3821        // Save the old toggle function
3822        _toggle: jQuery.fn.toggle,
3823
3824        toggle: function( fn, fn2 ){
3825                var bool = typeof fn === "boolean";
3826
3827                return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
3828                        this._toggle.apply( this, arguments ) :
3829                        fn == null || bool ?
3830                                this.each(function(){
3831                                        var state = bool ? fn : jQuery(this).is(":hidden");
3832                                        jQuery(this)[ state ? "show" : "hide" ]();
3833                                }) :
3834                                this.animate(genFx("toggle", 3), fn, fn2);
3835        },
3836
3837        fadeTo: function(speed,to,callback){
3838                return this.animate({opacity: to}, speed, callback);
3839        },
3840
3841        animate: function( prop, speed, easing, callback ) {
3842                var optall = jQuery.speed(speed, easing, callback);
3843
3844                return this[ optall.queue === false ? "each" : "queue" ](function(){
3845               
3846                        var opt = jQuery.extend({}, optall), p,
3847                                hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
3848                                self = this;
3849       
3850                        for ( p in prop ) {
3851                                if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
3852                                        return opt.complete.call(this);
3853
3854                                if ( ( p == "height" || p == "width" ) && this.style ) {
3855                                        // Store display property
3856                                        opt.display = jQuery.css(this, "display");
3857
3858                                        // Make sure that nothing sneaks out
3859                                        opt.overflow = this.style.overflow;
3860                                }
3861                        }
3862
3863                        if ( opt.overflow != null )
3864                                this.style.overflow = "hidden";
3865
3866                        opt.curAnim = jQuery.extend({}, prop);
3867
3868                        jQuery.each( prop, function(name, val){
3869                                var e = new jQuery.fx( self, opt, name );
3870
3871                                if ( /toggle|show|hide/.test(val) )
3872                                        e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3873                                else {
3874                                        var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3875                                                start = e.cur(true) || 0;
3876
3877                                        if ( parts ) {
3878                                                var end = parseFloat(parts[2]),
3879                                                        unit = parts[3] || "px";
3880
3881                                                // We need to compute starting value
3882                                                if ( unit != "px" ) {
3883                                                        self.style[ name ] = (end || 1) + unit;
3884                                                        start = ((end || 1) / e.cur(true)) * start;
3885                                                        self.style[ name ] = start + unit;
3886                                                }
3887
3888                                                // If a +=/-= token was provided, we're doing a relative animation
3889                                                if ( parts[1] )
3890                                                        end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3891
3892                                                e.custom( start, end, unit );
3893                                        } else
3894                                                e.custom( start, val, "" );
3895                                }
3896                        });
3897
3898                        // For JS strict compliance
3899                        return true;
3900                });
3901        },
3902
3903        stop: function(clearQueue, gotoEnd){
3904                var timers = jQuery.timers;
3905
3906                if (clearQueue)
3907                        this.queue([]);
3908
3909                this.each(function(){
3910                        // go in reverse order so anything added to the queue during the loop is ignored
3911                        for ( var i = timers.length - 1; i >= 0; i-- )
3912                                if ( timers[i].elem == this ) {
3913                                        if (gotoEnd)
3914                                                // force the next step to be the last
3915                                                timers[i](true);
3916                                        timers.splice(i, 1);
3917                                }
3918                });
3919
3920                // start the next in the queue if the last step wasn't forced
3921                if (!gotoEnd)
3922                        this.dequeue();
3923
3924                return this;
3925        }
3926
3927});
3928
3929// Generate shortcuts for custom animations
3930jQuery.each({
3931        slideDown: genFx("show", 1),
3932        slideUp: genFx("hide", 1),
3933        slideToggle: genFx("toggle", 1),
3934        fadeIn: { opacity: "show" },
3935        fadeOut: { opacity: "hide" }
3936}, function( name, props ){
3937        jQuery.fn[ name ] = function( speed, callback ){
3938                return this.animate( props, speed, callback );
3939        };
3940});
3941
3942jQuery.extend({
3943
3944        speed: function(speed, easing, fn) {
3945                var opt = typeof speed === "object" ? speed : {
3946                        complete: fn || !fn && easing ||
3947                                jQuery.isFunction( speed ) && speed,
3948                        duration: speed,
3949                        easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
3950                };
3951
3952                opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
3953                        jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
3954
3955                // Queueing
3956                opt.old = opt.complete;
3957                opt.complete = function(){
3958                        if ( opt.queue !== false )
3959                                jQuery(this).dequeue();
3960                        if ( jQuery.isFunction( opt.old ) )
3961                                opt.old.call( this );
3962                };
3963
3964                return opt;
3965        },
3966
3967        easing: {
3968                linear: function( p, n, firstNum, diff ) {
3969                        return firstNum + diff * p;
3970                },
3971                swing: function( p, n, firstNum, diff ) {
3972                        return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
3973                }
3974        },
3975
3976        timers: [],
3977
3978        fx: function( elem, options, prop ){
3979                this.options = options;
3980                this.elem = elem;
3981                this.prop = prop;
3982
3983                if ( !options.orig )
3984                        options.orig = {};
3985        }
3986
3987});
3988
3989jQuery.fx.prototype = {
3990
3991        // Simple function for setting a style value
3992        update: function(){
3993                if ( this.options.step )
3994                        this.options.step.call( this.elem, this.now, this );
3995
3996                (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
3997
3998                // Set display property to block for height/width animations
3999                if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
4000                        this.elem.style.display = "block";
4001        },
4002
4003        // Get the current size
4004        cur: function(force){
4005                if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
4006                        return this.elem[ this.prop ];
4007
4008                var r = parseFloat(jQuery.css(this.elem, this.prop, force));
4009                return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
4010        },
4011
4012        // Start an animation from one number to another
4013        custom: function(from, to, unit){
4014                this.startTime = now();
4015                this.start = from;
4016                this.end = to;
4017                this.unit = unit || this.unit || "px";
4018                this.now = this.start;
4019                this.pos = this.state = 0;
4020
4021                var self = this;
4022                function t(gotoEnd){
4023                        return self.step(gotoEnd);
4024                }
4025
4026                t.elem = this.elem;
4027
4028                if ( t() && jQuery.timers.push(t) && !timerId ) {
4029                        timerId = setInterval(function(){
4030                                var timers = jQuery.timers;
4031
4032                                for ( var i = 0; i < timers.length; i++ )
4033                                        if ( !timers[i]() )
4034                                                timers.splice(i--, 1);
4035
4036                                if ( !timers.length ) {
4037                                        clearInterval( timerId );
4038                                        timerId = undefined;
4039                                }
4040                        }, 13);
4041                }
4042        },
4043
4044        // Simple 'show' function
4045        show: function(){
4046                // Remember where we started, so that we can go back to it later
4047                this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
4048                this.options.show = true;
4049
4050                // Begin the animation
4051                // Make sure that we start at a small width/height to avoid any
4052                // flash of content
4053                this.custom(this.prop == "width" || this.prop == "height" ? 1 : 0, this.cur());
4054
4055                // Start by showing the element
4056                jQuery(this.elem).show();
4057        },
4058
4059        // Simple 'hide' function
4060        hide: function(){
4061                // Remember where we started, so that we can go back to it later
4062                this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
4063                this.options.hide = true;
4064
4065                // Begin the animation
4066                this.custom(this.cur(), 0);
4067        },
4068
4069        // Each step of an animation
4070        step: function(gotoEnd){
4071                var t = now();
4072
4073                if ( gotoEnd || t >= this.options.duration + this.startTime ) {
4074                        this.now = this.end;
4075                        this.pos = this.state = 1;
4076                        this.update();
4077
4078                        this.options.curAnim[ this.prop ] = true;
4079
4080                        var done = true;
4081                        for ( var i in this.options.curAnim )
4082                                if ( this.options.curAnim[i] !== true )
4083                                        done = false;
4084
4085                        if ( done ) {
4086                                if ( this.options.display != null ) {
4087                                        // Reset the overflow
4088                                        this.elem.style.overflow = this.options.overflow;
4089
4090                                        // Reset the display
4091                                        this.elem.style.display = this.options.display;
4092                                        if ( jQuery.css(this.elem, "display") == "none" )
4093                                                this.elem.style.display = "block";
4094                                }
4095
4096                                // Hide the element if the "hide" operation was done
4097                                if ( this.options.hide )
4098                                        jQuery(this.elem).hide();
4099
4100                                // Reset the properties, if the item has been hidden or shown
4101                                if ( this.options.hide || this.options.show )
4102                                        for ( var p in this.options.curAnim )
4103                                                jQuery.attr(this.elem.style, p, this.options.orig[p]);
4104                                       
4105                                // Execute the complete function
4106                                this.options.complete.call( this.elem );
4107                        }
4108
4109                        return false;
4110                } else {
4111                        var n = t - this.startTime;
4112                        this.state = n / this.options.duration;
4113
4114                        // Perform the easing function, defaults to swing
4115                        this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
4116                        this.now = this.start + ((this.end - this.start) * this.pos);
4117
4118                        // Perform the next step of the animation
4119                        this.update();
4120                }
4121
4122                return true;
4123        }
4124
4125};
4126
4127jQuery.extend( jQuery.fx, {
4128        speeds:{
4129                slow: 600,
4130                fast: 200,
4131                // Default speed
4132                _default: 400
4133        },
4134        step: {
4135
4136                opacity: function(fx){
4137                        jQuery.attr(fx.elem.style, "opacity", fx.now);
4138                },
4139
4140                _default: function(fx){
4141                        if ( fx.elem.style && fx.elem.style[ fx.prop ] != null )
4142                                fx.elem.style[ fx.prop ] = fx.now + fx.unit;
4143                        else
4144                                fx.elem[ fx.prop ] = fx.now;
4145                }
4146        }
4147});
4148if ( document.documentElement["getBoundingClientRect"] )
4149        jQuery.fn.offset = function() {
4150                if ( !this[0] ) return { top: 0, left: 0 };
4151                if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4152                var box  = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
4153                        clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
4154                        top  = box.top  + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
4155                        left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
4156                return { top: top, left: left };
4157        };
4158else 
4159        jQuery.fn.offset = function() {
4160                if ( !this[0] ) return { top: 0, left: 0 };
4161                if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4162                jQuery.offset.initialized || jQuery.offset.initialize();
4163
4164                var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
4165                        doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
4166                        body = doc.body, defaultView = doc.defaultView,
4167                        prevComputedStyle = defaultView.getComputedStyle(elem, null),
4168                        top = elem.offsetTop, left = elem.offsetLeft;
4169
4170                while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
4171                        computedStyle = defaultView.getComputedStyle(elem, null);
4172                        top -= elem.scrollTop, left -= elem.scrollLeft;
4173                        if ( elem === offsetParent ) {
4174                                top += elem.offsetTop, left += elem.offsetLeft;
4175                                if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
4176                                        top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
4177                                        left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
4178                                prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
4179                        }
4180                        if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
4181                                top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
4182                                left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
4183                        prevComputedStyle = computedStyle;
4184                }
4185
4186                if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
4187                        top  += body.offsetTop,
4188                        left += body.offsetLeft;
4189
4190                if ( prevComputedStyle.position === "fixed" )
4191                        top  += Math.max(docElem.scrollTop, body.scrollTop),
4192                        left += Math.max(docElem.scrollLeft, body.scrollLeft);
4193
4194                return { top: top, left: left };
4195        };
4196
4197jQuery.offset = {
4198        initialize: function() {
4199                if ( this.initialized ) return;
4200                var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop,
4201                        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>';
4202
4203                rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
4204                for ( prop in rules ) container.style[prop] = rules[prop];
4205
4206                container.innerHTML = html;
4207                body.insertBefore(container, body.firstChild);
4208                innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
4209
4210                this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
4211                this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
4212
4213                innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
4214                this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
4215
4216                body.style.marginTop = '1px';
4217                this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
4218                body.style.marginTop = bodyMarginTop;
4219
4220                body.removeChild(container);
4221                this.initialized = true;
4222        },
4223
4224        bodyOffset: function(body) {
4225                jQuery.offset.initialized || jQuery.offset.initialize();
4226                var top = body.offsetTop, left = body.offsetLeft;
4227                if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
4228                        top  += parseInt( jQuery.curCSS(body, 'marginTop',  true), 10 ) || 0,
4229                        left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0;
4230                return { top: top, left: left };
4231        }
4232};
4233
4234
4235jQuery.fn.extend({
4236        position: function() {
4237                var left = 0, top = 0, results;
4238
4239                if ( this[0] ) {
4240                        // Get *real* offsetParent
4241                        var offsetParent = this.offsetParent(),
4242
4243                        // Get correct offsets
4244                        offset       = this.offset(),
4245                        parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
4246
4247                        // Subtract element margins
4248                        // note: when an element has margin: auto the offsetLeft and marginLeft
4249                        // are the same in Safari causing offset.left to incorrectly be 0
4250                        offset.top  -= num( this, 'marginTop'  );
4251                        offset.left -= num( this, 'marginLeft' );
4252
4253                        // Add offsetParent borders
4254                        parentOffset.top  += num( offsetParent, 'borderTopWidth'  );
4255                        parentOffset.left += num( offsetParent, 'borderLeftWidth' );
4256
4257                        // Subtract the two offsets
4258                        results = {
4259                                top:  offset.top  - parentOffset.top,
4260                                left: offset.left - parentOffset.left
4261                        };
4262                }
4263
4264                return results;
4265        },
4266
4267        offsetParent: function() {
4268                var offsetParent = this[0].offsetParent || document.body;
4269                while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
4270                        offsetParent = offsetParent.offsetParent;
4271                return jQuery(offsetParent);
4272        }
4273});
4274
4275
4276// Create scrollLeft and scrollTop methods
4277jQuery.each( ['Left', 'Top'], function(i, name) {
4278        var method = 'scroll' + name;
4279       
4280        jQuery.fn[ method ] = function(val) {
4281                if (!this[0]) return null;
4282
4283                return val !== undefined ?
4284
4285                        // Set the scroll offset
4286                        this.each(function() {
4287                                this == window || this == document ?
4288                                        window.scrollTo(
4289                                                !i ? val : jQuery(window).scrollLeft(),
4290                                                 i ? val : jQuery(window).scrollTop()
4291                                        ) :
4292                                        this[ method ] = val;
4293                        }) :
4294
4295                        // Return the scroll offset
4296                        this[0] == window || this[0] == document ?
4297                                self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
4298                                        jQuery.boxModel && document.documentElement[ method ] ||
4299                                        document.body[ method ] :
4300                                this[0][ method ];
4301        };
4302});
4303// Create innerHeight, innerWidth, outerHeight and outerWidth methods
4304jQuery.each([ "Height", "Width" ], function(i, name){
4305
4306        var tl = i ? "Left"  : "Top",  // top or left
4307                br = i ? "Right" : "Bottom", // bottom or right
4308                lower = name.toLowerCase();
4309
4310        // innerHeight and innerWidth
4311        jQuery.fn["inner" + name] = function(){
4312                re