← Back to branch summary

~testplan-team/testplan/source-collection

« back to all changes in this revision

Viewing changes to htmlunit-2.4/src/test/resources/jquery/1.2.6/src/core.js

  • Committer: edA-qa mort-ora-y
  • Date: 2010-04-07 10:54:57 UTC
  • Revision ID: eda-qa@disemia.com-20100407105457-g46bvbsrjqtjujab
updating hmltunit src

Show diffs side-by-side

added added

removed removed

Lines of Context:
htmlunit-2.4/src/test/resources/jquery/1.2.6/src/core.js
1
 
/*
2
 
 * jQuery @VERSION - New Wave Javascript
3
 
 *
4
 
 * Copyright (c) 2008 John Resig (jquery.com)
5
 
 * Dual licensed under the MIT (MIT-LICENSE.txt)
6
 
 * and GPL (GPL-LICENSE.txt) licenses.
7
 
 *
8
 
 * $Date: 2008-05-24 21:09:21 +0300 (Sat, 24 May 2008) $
9
 
 * $Rev: 5683 $
10
 
 */
11
 
 
12
 
// Map over jQuery in case of overwrite
13
 
var _jQuery = window.jQuery,
14
 
// Map over the $ in case of overwrite
15
 
        _$ = window.$;
16
 
 
17
 
var jQuery = window.jQuery = window.$ = function( selector, context ) {
18
 
        // The jQuery object is actually just the init constructor 'enhanced'
19
 
        return new jQuery.fn.init( selector, context );
20
 
};
21
 
 
22
 
// A simple way to check for HTML strings or ID strings
23
 
// (both of which we optimize for)
24
 
var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/,
25
 
 
26
 
// Is it a simple selector
27
 
        isSimple = /^.[^:#\[\.]*$/,
28
 
 
29
 
// Will speed up references to undefined, and allows munging its name.
30
 
        undefined;
31
 
 
32
 
jQuery.fn = jQuery.prototype = {
33
 
        init: function( selector, context ) {
34
 
                // Make sure that a selection was provided
35
 
                selector = selector || document;
36
 
 
37
 
                // Handle $(DOMElement)
38
 
                if ( selector.nodeType ) {
39
 
                        this[0] = selector;
40
 
                        this.length = 1;
41
 
                        return this;
42
 
                }
43
 
                // Handle HTML strings
44
 
                if ( typeof selector == "string" ) {
45
 
                        // Are we dealing with HTML string or an ID?
46
 
                        var match = quickExpr.exec( selector );
47
 
 
48
 
                        // Verify a match, and that no context was specified for #id
49
 
                        if ( match && (match[1] || !context) ) {
50
 
 
51
 
                                // HANDLE: $(html) -> $(array)
52
 
                                if ( match[1] )
53
 
                                        selector = jQuery.clean( [ match[1] ], context );
54
 
 
55
 
                                // HANDLE: $("#id")
56
 
                                else {
57
 
                                        var elem = document.getElementById( match[3] );
58
 
 
59
 
                                        // Make sure an element was located
60
 
                                        if ( elem ){
61
 
                                                // Handle the case where IE and Opera return items
62
 
                                                // by name instead of ID
63
 
                                                if ( elem.id != match[3] )
64
 
                                                        return jQuery().find( selector );
65
 
 
66
 
                                                // Otherwise, we inject the element directly into the jQuery object
67
 
                                                return jQuery( elem );
68
 
                                        }
69
 
                                        selector = [];
70
 
                                }
71
 
 
72
 
                        // HANDLE: $(expr, [context])
73
 
                        // (which is just equivalent to: $(content).find(expr)
74
 
                        } else
75
 
                                return jQuery( context ).find( selector );
76
 
 
77
 
                // HANDLE: $(function)
78
 
                // Shortcut for document ready
79
 
                } else if ( jQuery.isFunction( selector ) )
80
 
                        return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
81
 
 
82
 
                return this.setArray(jQuery.makeArray(selector));
83
 
        },
84
 
 
85
 
        // The current version of jQuery being used
86
 
        jquery: "@VERSION",
87
 
 
88
 
        // The number of elements contained in the matched element set
89
 
        size: function() {
90
 
                return this.length;
91
 
        },
92
 
 
93
 
        // The number of elements contained in the matched element set
94
 
        length: 0,
95
 
 
96
 
        // Get the Nth element in the matched element set OR
97
 
        // Get the whole matched element set as a clean array
98
 
        get: function( num ) {
99
 
                return num == undefined ?
100
 
 
101
 
                        // Return a 'clean' array
102
 
                        jQuery.makeArray( this ) :
103
 
 
104
 
                        // Return just the object
105
 
                        this[ num ];
106
 
        },
107
 
 
108
 
        // Take an array of elements and push it onto the stack
109
 
        // (returning the new matched element set)
110
 
        pushStack: function( elems ) {
111
 
                // Build a new jQuery matched element set
112
 
                var ret = jQuery( elems );
113
 
 
114
 
                // Add the old object onto the stack (as a reference)
115
 
                ret.prevObject = this;
116
 
 
117
 
                // Return the newly-formed element set
118
 
                return ret;
119
 
        },
120
 
 
121
 
        // Force the current matched set of elements to become
122
 
        // the specified array of elements (destroying the stack in the process)
123
 
        // You should use pushStack() in order to do this, but maintain the stack
124
 
        setArray: function( elems ) {
125
 
                // Resetting the length to 0, then using the native Array push
126
 
                // is a super-fast way to populate an object with array-like properties
127
 
                this.length = 0;
128
 
                Array.prototype.push.apply( this, elems );
129
 
 
130
 
                return this;
131
 
        },
132
 
 
133
 
        // Execute a callback for every element in the matched set.
134
 
        // (You can seed the arguments with an array of args, but this is
135
 
        // only used internally.)
136
 
        each: function( callback, args ) {
137
 
                return jQuery.each( this, callback, args );
138
 
        },
139
 
 
140
 
        // Determine the position of an element within
141
 
        // the matched set of elements
142
 
        index: function( elem ) {
143
 
                var ret = -1;
144
 
 
145
 
                // Locate the position of the desired element
146
 
                return jQuery.inArray(
147
 
                        // If it receives a jQuery object, the first element is used
148
 
                        elem && elem.jquery ? elem[0] : elem
149
 
                , this );
150
 
        },
151
 
 
152
 
        attr: function( name, value, type ) {
153
 
                var options = name;
154
 
 
155
 
                // Look for the case where we're accessing a style value
156
 
                if ( name.constructor == String )
157
 
                        if ( value === undefined )
158
 
                                return this[0] && jQuery[ type || "attr" ]( this[0], name );
159
 
 
160
 
                        else {
161
 
                                options = {};
162
 
                                options[ name ] = value;
163
 
                        }
164
 
 
165
 
                // Check to see if we're setting style values
166
 
                return this.each(function(i){
167
 
                        // Set all the styles
168
 
                        for ( name in options )
169
 
                                jQuery.attr(
170
 
                                        type ?
171
 
                                                this.style :
172
 
                                                this,
173
 
                                        name, jQuery.prop( this, options[ name ], type, i, name )
174
 
                                );
175
 
                });
176
 
        },
177
 
 
178
 
        css: function( key, value ) {
179
 
                // ignore negative width and height values
180
 
                if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
181
 
                        value = undefined;
182
 
                return this.attr( key, value, "curCSS" );
183
 
        },
184
 
 
185
 
        text: function( text ) {
186
 
                if ( typeof text != "object" && text != null )
187
 
                        return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
188
 
 
189
 
                var ret = "";
190
 
 
191
 
                jQuery.each( text || this, function(){
192
 
                        jQuery.each( this.childNodes, function(){
193
 
                                if ( this.nodeType != 8 )
194
 
                                        ret += this.nodeType != 1 ?
195
 
                                                this.nodeValue :
196
 
                                                jQuery.fn.text( [ this ] );
197
 
                        });
198
 
                });
199
 
 
200
 
                return ret;
201
 
        },
202
 
 
203
 
        wrapAll: function( html ) {
204
 
                if ( this[0] )
205
 
                        // The elements to wrap the target around
206
 
                        jQuery( html, this[0].ownerDocument )
207
 
                                .clone()
208
 
                                .insertBefore( this[0] )
209
 
                                .map(function(){
210
 
                                        var elem = this;
211
 
 
212
 
                                        while ( elem.firstChild )
213
 
                                                elem = elem.firstChild;
214
 
 
215
 
                                        return elem;
216
 
                                })
217
 
                                .append(this);
218
 
 
219
 
                return this;
220
 
        },
221
 
 
222
 
        wrapInner: function( html ) {
223
 
                return this.each(function(){
224
 
                        jQuery( this ).contents().wrapAll( html );
225
 
                });
226
 
        },
227
 
 
228
 
        wrap: function( html ) {
229
 
                return this.each(function(){
230
 
                        jQuery( this ).wrapAll( html );
231
 
                });
232
 
        },
233
 
 
234
 
        append: function() {
235
 
                return this.domManip(arguments, true, false, function(elem){
236
 
                        if (this.nodeType == 1)
237
 
                                this.appendChild( elem );
238
 
                });
239
 
        },
240
 
 
241
 
        prepend: function() {
242
 
                return this.domManip(arguments, true, true, function(elem){
243
 
                        if (this.nodeType == 1)
244
 
                                this.insertBefore( elem, this.firstChild );
245
 
                });
246
 
        },
247
 
 
248
 
        before: function() {
249
 
                return this.domManip(arguments, false, false, function(elem){
250
 
                        this.parentNode.insertBefore( elem, this );
251
 
                });
252
 
        },
253
 
 
254
 
        after: function() {
255
 
                return this.domManip(arguments, false, true, function(elem){
256
 
                        this.parentNode.insertBefore( elem, this.nextSibling );
257
 
                });
258
 
        },
259
 
 
260
 
        end: function() {
261
 
                return this.prevObject || jQuery( [] );
262
 
        },
263
 
 
264
 
        find: function( selector ) {
265
 
                var elems = jQuery.map(this, function(elem){
266
 
                        return jQuery.find( selector, elem );
267
 
                });
268
 
 
269
 
                return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
270
 
                        jQuery.unique( elems ) :
271
 
                        elems );
272
 
        },
273
 
 
274
 
        clone: function( events ) {
275
 
                // Do the clone
276
 
                var ret = this.map(function(){
277
 
                        if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
278
 
                                // IE copies events bound via attachEvent when
279
 
                                // using cloneNode. Calling detachEvent on the
280
 
                                // clone will also remove the events from the orignal
281
 
                                // In order to get around this, we use innerHTML.
282
 
                                // Unfortunately, this means some modifications to
283
 
                                // attributes in IE that are actually only stored
284
 
                                // as properties will not be copied (such as the
285
 
                                // the name attribute on an input).
286
 
                                var clone = this.cloneNode(true),
287
 
                                        container = document.createElement("div");
288
 
                                container.appendChild(clone);
289
 
                                return jQuery.clean([container.innerHTML])[0];
290
 
                        } else
291
 
                                return this.cloneNode(true);
292
 
                });
293
 
 
294
 
                // Need to set the expando to null on the cloned set if it exists
295
 
                // removeData doesn't work here, IE removes it from the original as well
296
 
                // this is primarily for IE but the data expando shouldn't be copied over in any browser
297
 
                var clone = ret.find("*").andSelf().each(function(){
298
 
                        if ( this[ expando ] != undefined )
299
 
                                this[ expando ] = null;
300
 
                });
301
 
 
302
 
                // Copy the events from the original to the clone
303
 
                if ( events === true )
304
 
                        this.find("*").andSelf().each(function(i){
305
 
                                if (this.nodeType == 3)
306
 
                                        return;
307
 
                                var events = jQuery.data( this, "events" );
308
 
 
309
 
                                for ( var type in events )
310
 
                                        for ( var handler in events[ type ] )
311
 
                                                jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
312
 
                        });
313
 
 
314
 
                // Return the cloned set
315
 
                return ret;
316
 
        },
317
 
 
318
 
        filter: function( selector ) {
319
 
                return this.pushStack(
320
 
                        jQuery.isFunction( selector ) &&
321
 
                        jQuery.grep(this, function(elem, i){
322
 
                                return selector.call( elem, i );
323
 
                        }) ||
324
 
 
325
 
                        jQuery.multiFilter( selector, this ) );
326
 
        },
327
 
 
328
 
        not: function( selector ) {
329
 
                if ( selector.constructor == String )
330
 
                        // test special case where just one selector is passed in
331
 
                        if ( isSimple.test( selector ) )
332
 
                                return this.pushStack( jQuery.multiFilter( selector, this, true ) );
333
 
                        else
334
 
                                selector = jQuery.multiFilter( selector, this );
335
 
 
336
 
                var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
337
 
                return this.filter(function() {
338
 
                        return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
339
 
                });
340
 
        },
341
 
 
342
 
        add: function( selector ) {
343
 
                return this.pushStack( jQuery.unique( jQuery.merge(
344
 
                        this.get(),
345
 
                        typeof selector == 'string' ?
346
 
                                jQuery( selector ) :
347
 
                                jQuery.makeArray( selector )
348
 
                )));
349
 
        },
350
 
 
351
 
        is: function( selector ) {
352
 
                return !!selector && jQuery.multiFilter( selector, this ).length > 0;
353
 
        },
354
 
 
355
 
        hasClass: function( selector ) {
356
 
                return this.is( "." + selector );
357
 
        },
358
 
 
359
 
        val: function( value ) {
360
 
                if ( value == undefined ) {
361
 
 
362
 
                        if ( this.length ) {
363
 
                                var elem = this[0];
364
 
 
365
 
                                // We need to handle select boxes special
366
 
                                if ( jQuery.nodeName( elem, "select" ) ) {
367
 
                                        var index = elem.selectedIndex,
368
 
                                                values = [],
369
 
                                                options = elem.options,
370
 
                                                one = elem.type == "select-one";
371
 
 
372
 
                                        // Nothing was selected
373
 
                                        if ( index < 0 )
374
 
                                                return null;
375
 
 
376
 
                                        // Loop through all the selected options
377
 
                                        for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
378
 
                                                var option = options[ i ];
379
 
 
380
 
                                                if ( option.selected ) {
381
 
                                                        // Get the specifc value for the option
382
 
                                                        value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
383
 
 
384
 
                                                        // We don't need an array for one selects
385
 
                                                        if ( one )
386
 
                                                                return value;
387
 
 
388
 
                                                        // Multi-Selects return an array
389
 
                                                        values.push( value );
390
 
                                                }
391
 
                                        }
392
 
 
393
 
                                        return values;
394
 
 
395
 
                                // Everything else, we just grab the value
396
 
                                } else
397
 
                                        return (this[0].value || "").replace(/\r/g, "");
398
 
 
399
 
                        }
400
 
 
401
 
                        return undefined;
402
 
                }
403
 
 
404
 
                if( value.constructor == Number )
405
 
                        value += '';
406
 
 
407
 
                return this.each(function(){
408
 
                        if ( this.nodeType != 1 )
409
 
                                return;
410
 
 
411
 
                        if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
412
 
                                this.checked = (jQuery.inArray(this.value, value) >= 0 ||
413
 
                                        jQuery.inArray(this.name, value) >= 0);
414
 
 
415
 
                        else if ( jQuery.nodeName( this, "select" ) ) {
416
 
                                var values = jQuery.makeArray(value);
417
 
 
418
 
                                jQuery( "option", this ).each(function(){
419
 
                                        this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
420
 
                                                jQuery.inArray( this.text, values ) >= 0);
421
 
                                });
422
 
 
423
 
                                if ( !values.length )
424
 
                                        this.selectedIndex = -1;
425
 
 
426
 
                        } else
427
 
                                this.value = value;
428
 
                });
429
 
        },
430
 
 
431
 
        html: function( value ) {
432
 
                return value == undefined ?
433
 
                        (this[0] ?
434
 
                                this[0].innerHTML :
435
 
                                null) :
436
 
                        this.empty().append( value );
437
 
        },
438
 
 
439
 
        replaceWith: function( value ) {
440
 
                return this.after( value ).remove();
441
 
        },
442
 
 
443
 
        eq: function( i ) {
444
 
                return this.slice( i, i + 1 );
445
 
        },
446
 
 
447
 
        slice: function() {
448
 
                return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
449
 
        },
450
 
 
451
 
        map: function( callback ) {
452
 
                return this.pushStack( jQuery.map(this, function(elem, i){
453
 
                        return callback.call( elem, i, elem );
454
 
                }));
455
 
        },
456
 
 
457
 
        andSelf: function() {
458
 
                return this.add( this.prevObject );
459
 
        },
460
 
 
461
 
        data: function( key, value ){
462
 
                var parts = key.split(".");
463
 
                parts[1] = parts[1] ? "." + parts[1] : "";
464
 
 
465
 
                if ( value === undefined ) {
466
 
                        var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
467
 
 
468
 
                        if ( data === undefined && this.length )
469
 
                                data = jQuery.data( this[0], key );
470
 
 
471
 
                        return data === undefined && parts[1] ?
472
 
                                this.data( parts[0] ) :
473
 
                                data;
474
 
                } else
475
 
                        return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
476
 
                                jQuery.data( this, key, value );
477
 
                        });
478
 
        },
479
 
 
480
 
        removeData: function( key ){
481
 
                return this.each(function(){
482
 
                        jQuery.removeData( this, key );
483
 
                });
484
 
        },
485
 
 
486
 
        domManip: function( args, table, reverse, callback ) {
487
 
                var clone = this.length > 1, elems;
488
 
 
489
 
                return this.each(function(){
490
 
                        if ( !elems ) {
491
 
                                elems = jQuery.clean( args, this.ownerDocument );
492
 
 
493
 
                                if ( reverse )
494
 
                                        elems.reverse();
495
 
                        }
496
 
 
497
 
                        var obj = this;
498
 
 
499
 
                        if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
500
 
                                obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );
501
 
 
502
 
                        var scripts = jQuery( [] );
503
 
 
504
 
                        jQuery.each(elems, function(){
505
 
                                var elem = clone ?
506
 
                                        jQuery( this ).clone( true )[0] :
507
 
                                        this;
508
 
 
509
 
                                // execute all scripts after the elements have been injected
510
 
                                if ( jQuery.nodeName( elem, "script" ) )
511
 
                                        scripts = scripts.add( elem );
512
 
                                else {
513
 
                                        // Remove any inner scripts for later evaluation
514
 
                                        if ( elem.nodeType == 1 )
515
 
                                                scripts = scripts.add( jQuery( "script", elem ).remove() );
516
 
 
517
 
                                        // Inject the elements into the document
518
 
                                        callback.call( obj, elem );
519
 
                                }
520
 
                        });
521
 
 
522
 
                        scripts.each( evalScript );
523
 
                });
524
 
        }
525
 
};
526
 
 
527
 
// Give the init function the jQuery prototype for later instantiation
528
 
jQuery.fn.init.prototype = jQuery.fn;
529
 
 
530
 
function evalScript( i, elem ) {
531
 
        if ( elem.src )
532
 
                jQuery.ajax({
533
 
                        url: elem.src,
534
 
                        async: false,
535
 
                        dataType: "script"
536
 
                });
537
 
 
538
 
        else
539
 
                jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
540
 
 
541
 
        if ( elem.parentNode )
542
 
                elem.parentNode.removeChild( elem );
543
 
}
544
 
 
545
 
function now(){
546
 
        return +new Date;
547
 
}
548
 
 
549
 
jQuery.extend = jQuery.fn.extend = function() {
550
 
        // copy reference to target object
551
 
        var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
552
 
 
553
 
        // Handle a deep copy situation
554
 
        if ( target.constructor == Boolean ) {
555
 
                deep = target;
556
 
                target = arguments[1] || {};
557
 
                // skip the boolean and the target
558
 
                i = 2;
559
 
        }
560
 
 
561
 
        // Handle case when target is a string or something (possible in deep copy)
562
 
        if ( typeof target != "object" && typeof target != "function" )
563
 
                target = {};
564
 
 
565
 
        // extend jQuery itself if only one argument is passed
566
 
        if ( length == i ) {
567
 
                target = this;
568
 
                --i;
569
 
        }
570
 
 
571
 
        for ( ; i < length; i++ )
572
 
                // Only deal with non-null/undefined values
573
 
                if ( (options = arguments[ i ]) != null )
574
 
                        // Extend the base object
575
 
                        for ( var name in options ) {
576
 
                                var src = target[ name ], copy = options[ name ];
577
 
 
578
 
                                // Prevent never-ending loop
579
 
                                if ( target === copy )
580
 
                                        continue;
581
 
 
582
 
                                // Recurse if we're merging object values
583
 
                                if ( deep && copy && typeof copy == "object" && !copy.nodeType )
584
 
                                        target[ name ] = jQuery.extend( deep, 
585
 
                                                // Never move original objects, clone them
586
 
                                                src || ( copy.length != null ? [ ] : { } )
587
 
                                        , copy );
588
 
 
589
 
                                // Don't bring in undefined values
590
 
                                else if ( copy !== undefined )
591
 
                                        target[ name ] = copy;
592
 
 
593
 
                        }
594
 
 
595
 
        // Return the modified object
596
 
        return target;
597
 
};
598
 
 
599
 
var expando = "jQuery" + now(), uuid = 0, windowData = {},
600
 
        // exclude the following css properties to add px
601
 
        exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
602
 
        // cache defaultView
603
 
        defaultView = document.defaultView || {};
604
 
 
605
 
jQuery.extend({
606
 
        noConflict: function( deep ) {
607
 
                window.$ = _$;
608
 
 
609
 
                if ( deep )
610
 
                        window.jQuery = _jQuery;
611
 
 
612
 
                return jQuery;
613
 
        },
614
 
 
615
 
        // See test/unit/core.js for details concerning this function.
616
 
        isFunction: function( fn ) {
617
 
                return !!fn && typeof fn != "string" && !fn.nodeName &&
618
 
                        fn.constructor != Array && /^[\s[]?function/.test( fn + "" );
619
 
        },
620
 
 
621
 
        // check if an element is in a (or is an) XML document
622
 
        isXMLDoc: function( elem ) {
623
 
                return elem.documentElement && !elem.body ||
624
 
                        elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
625
 
        },
626
 
 
627
 
        // Evalulates a script in a global context
628
 
        globalEval: function( data ) {
629
 
                data = jQuery.trim( data );
630
 
 
631
 
                if ( data ) {
632
 
                        // Inspired by code by Andrea Giammarchi
633
 
                        // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
634
 
                        var head = document.getElementsByTagName("head")[0] || document.documentElement,
635
 
                                script = document.createElement("script");
636
 
 
637
 
                        script.type = "text/javascript";
638
 
                        if ( jQuery.browser.msie )
639
 
                                script.text = data;
640
 
                        else
641
 
                                script.appendChild( document.createTextNode( data ) );
642
 
 
643
 
                        // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
644
 
                        // This arises when a base node is used (#2709).
645
 
                        head.insertBefore( script, head.firstChild );
646
 
                        head.removeChild( script );
647
 
                }
648
 
        },
649
 
 
650
 
        nodeName: function( elem, name ) {
651
 
                return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
652
 
        },
653
 
 
654
 
        cache: {},
655
 
 
656
 
        data: function( elem, name, data ) {
657
 
                elem = elem == window ?
658
 
                        windowData :
659
 
                        elem;
660
 
 
661
 
                var id = elem[ expando ];
662
 
 
663
 
                // Compute a unique ID for the element
664
 
                if ( !id )
665
 
                        id = elem[ expando ] = ++uuid;
666
 
 
667
 
                // Only generate the data cache if we're
668
 
                // trying to access or manipulate it
669
 
                if ( name && !jQuery.cache[ id ] )
670
 
                        jQuery.cache[ id ] = {};
671
 
 
672
 
                // Prevent overriding the named cache with undefined values
673
 
                if ( data !== undefined )
674
 
                        jQuery.cache[ id ][ name ] = data;
675
 
 
676
 
                // Return the named cache data, or the ID for the element
677
 
                return name ?
678
 
                        jQuery.cache[ id ][ name ] :
679
 
                        id;
680
 
        },
681
 
 
682
 
        removeData: function( elem, name ) {
683
 
                elem = elem == window ?
684
 
                        windowData :
685
 
                        elem;
686
 
 
687
 
                var id = elem[ expando ];
688
 
 
689
 
                // If we want to remove a specific section of the element's data
690
 
                if ( name ) {
691
 
                        if ( jQuery.cache[ id ] ) {
692
 
                                // Remove the section of cache data
693
 
                                delete jQuery.cache[ id ][ name ];
694
 
 
695
 
                                // If we've removed all the data, remove the element's cache
696
 
                                name = "";
697
 
 
698
 
                                for ( name in jQuery.cache[ id ] )
699
 
                                        break;
700
 
 
701
 
                                if ( !name )
702
 
                                        jQuery.removeData( elem );
703
 
                        }
704
 
 
705
 
                // Otherwise, we want to remove all of the element's data
706
 
                } else {
707
 
                        // Clean up the element expando
708
 
                        try {
709
 
                                delete elem[ expando ];
710
 
                        } catch(e){
711
 
                                // IE has trouble directly removing the expando
712
 
                                // but it's ok with using removeAttribute
713
 
                                if ( elem.removeAttribute )
714
 
                                        elem.removeAttribute( expando );
715
 
                        }
716
 
 
717
 
                        // Completely remove the data cache
718
 
                        delete jQuery.cache[ id ];
719
 
                }
720
 
        },
721
 
 
722
 
        // args is for internal usage only
723
 
        each: function( object, callback, args ) {
724
 
                var name, i = 0, length = object.length;
725
 
 
726
 
                if ( args ) {
727
 
                        if ( length == undefined ) {
728
 
                                for ( name in object )
729
 
                                        if ( callback.apply( object[ name ], args ) === false )
730
 
                                                break;
731
 
                        } else
732
 
                                for ( ; i < length; )
733
 
                                        if ( callback.apply( object[ i++ ], args ) === false )
734
 
                                                break;
735
 
 
736
 
                // A special, fast, case for the most common use of each
737
 
                } else {
738
 
                        if ( length == undefined ) {
739
 
                                for ( name in object )
740
 
                                        if ( callback.call( object[ name ], name, object[ name ] ) === false )
741
 
                                                break;
742
 
                        } else
743
 
                                for ( var value = object[0];
744
 
                                        i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
745
 
                }
746
 
 
747
 
                return object;
748
 
        },
749
 
 
750
 
        prop: function( elem, value, type, i, name ) {
751
 
                // Handle executable functions
752
 
                if ( jQuery.isFunction( value ) )
753
 
                        value = value.call( elem, i );
754
 
 
755
 
                // Handle passing in a number to a CSS property
756
 
                return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
757
 
                        value + "px" :
758
 
                        value;
759
 
        },
760
 
 
761
 
        className: {
762
 
                // internal only, use addClass("class")
763
 
                add: function( elem, classNames ) {
764
 
                        jQuery.each((classNames || "").split(/\s+/), function(i, className){
765
 
                                if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
766
 
                                        elem.className += (elem.className ? " " : "") + className;
767
 
                        });
768
 
                },
769
 
 
770
 
                // internal only, use removeClass("class")
771
 
                remove: function( elem, classNames ) {
772
 
                        if (elem.nodeType == 1)
773
 
                                elem.className = classNames != undefined ?
774
 
                                        jQuery.grep(elem.className.split(/\s+/), function(className){
775
 
                                                return !jQuery.className.has( classNames, className );
776
 
                                        }).join(" ") :
777
 
                                        "";
778
 
                },
779
 
 
780
 
                // internal only, use hasClass("class")
781
 
                has: function( elem, className ) {
782
 
                        return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
783
 
                }
784
 
        },
785
 
 
786
 
        // A method for quickly swapping in/out CSS properties to get correct calculations
787
 
        swap: function( elem, options, callback ) {
788
 
                var old = {};
789
 
                // Remember the old values, and insert the new ones
790
 
                for ( var name in options ) {
791
 
                        old[ name ] = elem.style[ name ];
792
 
                        elem.style[ name ] = options[ name ];
793
 
                }
794
 
 
795
 
                callback.call( elem );
796
 
 
797
 
                // Revert the old values
798
 
                for ( var name in options )
799
 
                        elem.style[ name ] = old[ name ];
800
 
        },
801
 
 
802
 
        css: function( elem, name, force ) {
803
 
                if ( name == "width" || name == "height" ) {
804
 
                        var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
805
 
 
806
 
                        function getWH() {
807
 
                                val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
808
 
                                var padding = 0, border = 0;
809
 
                                jQuery.each( which, function() {
810
 
                                        padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
811
 
                                        border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
812
 
                                });
813
 
                                val -= Math.round(padding + border);
814
 
                        }
815
 
 
816
 
                        if ( jQuery(elem).is(":visible") )
817
 
                                getWH();
818
 
                        else
819
 
                                jQuery.swap( elem, props, getWH );
820
 
 
821
 
                        return Math.max(0, val);
822
 
                }
823
 
 
824
 
                return jQuery.curCSS( elem, name, force );
825
 
        },
826
 
 
827
 
        curCSS: function( elem, name, force ) {
828
 
                var ret, style = elem.style;
829
 
 
830
 
                // A helper method for determining if an element's values are broken
831
 
                function color( elem ) {
832
 
                        if ( !jQuery.browser.safari )
833
 
                                return false;
834
 
 
835
 
                        // defaultView is cached
836
 
                        var ret = defaultView.getComputedStyle( elem, null );
837
 
                        return !ret || ret.getPropertyValue("color") == "";
838
 
                }
839
 
 
840
 
                // We need to handle opacity special in IE
841
 
                if ( name == "opacity" && jQuery.browser.msie ) {
842
 
                        ret = jQuery.attr( style, "opacity" );
843
 
 
844
 
                        return ret == "" ?
845
 
                                "1" :
846
 
                                ret;
847
 
                }
848
 
                // Opera sometimes will give the wrong display answer, this fixes it, see #2037
849
 
                if ( jQuery.browser.opera && name == "display" ) {
850
 
                        var save = style.outline;
851
 
                        style.outline = "0 solid black";
852
 
                        style.outline = save;
853
 
                }
854
 
 
855
 
                // Make sure we're using the right name for getting the float value
856
 
                if ( name.match( /float/i ) )
857
 
                        name = styleFloat;
858
 
 
859
 
                if ( !force && style && style[ name ] )
860
 
                        ret = style[ name ];
861
 
 
862
 
                else if ( defaultView.getComputedStyle ) {
863
 
 
864
 
                        // Only "float" is needed here
865
 
                        if ( name.match( /float/i ) )
866
 
                                name = "float";
867
 
 
868
 
                        name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
869
 
 
870
 
                        var computedStyle = defaultView.getComputedStyle( elem, null );
871
 
 
872
 
                        if ( computedStyle && !color( elem ) )
873
 
                                ret = computedStyle.getPropertyValue( name );
874
 
 
875
 
                        // If the element isn't reporting its values properly in Safari
876
 
                        // then some display: none elements are involved
877
 
                        else {
878
 
                                var swap = [], stack = [], a = elem, i = 0;
879
 
 
880
 
                                // Locate all of the parent display: none elements
881
 
                                for ( ; a && color(a); a = a.parentNode )
882
 
                                        stack.unshift(a);
883
 
 
884
 
                                // Go through and make them visible, but in reverse
885
 
                                // (It would be better if we knew the exact display type that they had)
886
 
                                for ( ; i < stack.length; i++ )
887
 
                                        if ( color( stack[ i ] ) ) {
888
 
                                                swap[ i ] = stack[ i ].style.display;
889
 
                                                stack[ i ].style.display = "block";
890
 
                                        }
891
 
 
892
 
                                // Since we flip the display style, we have to handle that
893
 
                                // one special, otherwise get the value
894
 
                                ret = name == "display" && swap[ stack.length - 1 ] != null ?
895
 
                                        "none" :
896
 
                                        ( computedStyle && computedStyle.getPropertyValue( name ) ) || "";
897
 
 
898
 
                                // Finally, revert the display styles back
899
 
                                for ( i = 0; i < swap.length; i++ )
900
 
                                        if ( swap[ i ] != null )
901
 
                                                stack[ i ].style.display = swap[ i ];
902
 
                        }
903
 
 
904
 
                        // We should always get a number back from opacity
905
 
                        if ( name == "opacity" && ret == "" )
906
 
                                ret = "1";
907
 
 
908
 
                } else if ( elem.currentStyle ) {
909
 
                        var camelCase = name.replace(/\-(\w)/g, function(all, letter){
910
 
                                return letter.toUpperCase();
911
 
                        });
912
 
 
913
 
                        ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
914
 
 
915
 
                        // From the awesome hack by Dean Edwards
916
 
                        // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
917
 
 
918
 
                        // If we're not dealing with a regular pixel number
919
 
                        // but a number that has a weird ending, we need to convert it to pixels
920
 
                        if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
921
 
                                // Remember the original values
922
 
                                var left = style.left, rsLeft = elem.runtimeStyle.left;
923
 
 
924
 
                                // Put in the new values to get a computed value out
925
 
                                elem.runtimeStyle.left = elem.currentStyle.left;
926
 
                                style.left = ret || 0;
927
 
                                ret = style.pixelLeft + "px";
928
 
 
929
 
                                // Revert the changed values
930
 
                                style.left = left;
931
 
                                elem.runtimeStyle.left = rsLeft;
932
 
                        }
933
 
                }
934
 
 
935
 
                return ret;
936
 
        },
937
 
 
938
 
        clean: function( elems, context ) {
939
 
                var ret = [];
940
 
                context = context || document;
941
 
                // !context.createElement fails in IE with an error but returns typeof 'object'
942
 
                if (typeof context.createElement == 'undefined')
943
 
                        context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
944
 
 
945
 
                jQuery.each(elems, function(i, elem){
946
 
                        if ( !elem )
947
 
                                return;
948
 
 
949
 
                        if ( elem.constructor == Number )
950
 
                                elem += '';
951
 
 
952
 
                        // Convert html string into DOM nodes
953
 
                        if ( typeof elem == "string" ) {
954
 
                                // Fix "XHTML"-style tags in all browsers
955
 
                                elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
956
 
                                        return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
957
 
                                                all :
958
 
                                                front + "></" + tag + ">";
959
 
                                });
960
 
 
961
 
                                // Trim whitespace, otherwise indexOf won't work as expected
962
 
                                var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");
963
 
 
964
 
                                var wrap =
965
 
                                        // option or optgroup
966
 
                                        !tags.indexOf("<opt") &&
967
 
                                        [ 1, "<select multiple='multiple'>", "</select>" ] ||
968
 
 
969
 
                                        !tags.indexOf("<leg") &&
970
 
                                        [ 1, "<fieldset>", "</fieldset>" ] ||
971
 
 
972
 
                                        tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
973
 
                                        [ 1, "<table>", "</table>" ] ||
974
 
 
975
 
                                        !tags.indexOf("<tr") &&
976
 
                                        [ 2, "<table><tbody>", "</tbody></table>" ] ||
977
 
 
978
 
                                        // <thead> matched above
979
 
                                        (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
980
 
                                        [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
981
 
 
982
 
                                        !tags.indexOf("<col") &&
983
 
                                        [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
984
 
 
985
 
                                        // IE can't serialize <link> and <script> tags normally
986
 
                                        jQuery.browser.msie &&
987
 
                                        [ 1, "div<div>", "</div>" ] ||
988
 
 
989
 
                                        [ 0, "", "" ];
990
 
 
991
 
                                // Go to html and back, then peel off extra wrappers
992
 
                                div.innerHTML = wrap[1] + elem + wrap[2];
993
 
 
994
 
                                // Move to the right depth
995
 
                                while ( wrap[0]-- )
996
 
                                        div = div.lastChild;
997
 
 
998
 
                                // Remove IE's autoinserted <tbody> from table fragments
999
 
                                if ( jQuery.browser.msie ) {
1000
 
 
1001
 
                                        // String was a <table>, *may* have spurious <tbody>
1002
 
                                        var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
1003
 
                                                div.firstChild && div.firstChild.childNodes :
1004
 
 
1005
 
                                                // String was a bare <thead> or <tfoot>
1006
 
                                                wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
1007
 
                                                        div.childNodes :
1008
 
                                                        [];
1009
 
 
1010
 
                                        for ( var j = tbody.length - 1; j >= 0 ; --j )
1011
 
                                                if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
1012
 
                                                        tbody[ j ].parentNode.removeChild( tbody[ j ] );
1013
 
 
1014
 
                                        // IE completely kills leading whitespace when innerHTML is used
1015
 
                                        if ( /^\s/.test( elem ) )
1016
 
                                                div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
1017
 
 
1018
 
                                }
1019
 
 
1020
 
                                elem = jQuery.makeArray( div.childNodes );
1021
 
                        }
1022
 
 
1023
 
                        if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
1024
 
                                return;
1025
 
 
1026
 
                        if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
1027
 
                                ret.push( elem );
1028
 
 
1029
 
                        else
1030
 
                                ret = jQuery.merge( ret, elem );
1031
 
 
1032
 
                });
1033
 
 
1034
 
                return ret;
1035
 
        },
1036
 
 
1037
 
        attr: function( elem, name, value ) {
1038
 
                // don't set attributes on text and comment nodes
1039
 
                if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
1040
 
                        return undefined;
1041
 
 
1042
 
                var notxml = !jQuery.isXMLDoc( elem ),
1043
 
                        // Whether we are setting (or getting)
1044
 
                        set = value !== undefined,
1045
 
                        msie = jQuery.browser.msie;
1046
 
 
1047
 
                // Try to normalize/fix the name
1048
 
                name = notxml && jQuery.props[ name ] || name;
1049
 
 
1050
 
                // Only do all the following if this is a node (faster for style)
1051
 
                // IE elem.getAttribute passes even for style
1052
 
                if ( elem.tagName ) {
1053
 
 
1054
 
                        // These attributes require special treatment
1055
 
                        var special = /href|src|style/.test( name );
1056
 
 
1057
 
                        // Safari mis-reports the default selected property of a hidden option
1058
 
                        // Accessing the parent's selectedIndex property fixes it
1059
 
                        if ( name == "selected" && jQuery.browser.safari )
1060
 
                                elem.parentNode.selectedIndex;
1061
 
 
1062
 
                        // If applicable, access the attribute via the DOM 0 way
1063
 
                        if ( name in elem && notxml && !special ) {
1064
 
                                if ( set ){
1065
 
                                        // We can't allow the type property to be changed (since it causes problems in IE)
1066
 
                                        if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
1067
 
                                                throw "type property can't be changed";
1068
 
 
1069
 
                                        elem[ name ] = value;
1070
 
                                }
1071
 
 
1072
 
                                // browsers index elements by id/name on forms, give priority to attributes.
1073
 
                                if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1074
 
                                        return elem.getAttributeNode( name ).nodeValue;
1075
 
 
1076
 
                                return elem[ name ];
1077
 
                        }
1078
 
 
1079
 
                        if ( msie && notxml &&  name == "style" )
1080
 
                                return jQuery.attr( elem.style, "cssText", value );
1081
 
 
1082
 
                        if ( set )
1083
 
                                // convert the value to a string (all browsers do this but IE) see #1070
1084
 
                                elem.setAttribute( name, "" + value );
1085
 
 
1086
 
                        var attr = msie && notxml && special
1087
 
                                        // Some attributes require a special call on IE
1088
 
                                        ? elem.getAttribute( name, 2 )
1089
 
                                        : elem.getAttribute( name );
1090
 
 
1091
 
                        // Non-existent attributes return null, we normalize to undefined
1092
 
                        return attr === null ? undefined : attr;
1093
 
                }
1094
 
 
1095
 
                // elem is actually elem.style ... set the style
1096
 
 
1097
 
                // IE uses filters for opacity
1098
 
                if ( msie && name == "opacity" ) {
1099
 
                        if ( set ) {
1100
 
                                // IE has trouble with opacity if it does not have layout
1101
 
                                // Force it by setting the zoom level
1102
 
                                elem.zoom = 1;
1103
 
 
1104
 
                                // Set the alpha filter to set the opacity
1105
 
                                elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1106
 
                                        (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1107
 
                        }
1108
 
 
1109
 
                        return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1110
 
                                (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1111
 
                                "";
1112
 
                }
1113
 
 
1114
 
                name = name.replace(/-([a-z])/ig, function(all, letter){
1115
 
                        return letter.toUpperCase();
1116
 
                });
1117
 
 
1118
 
                if ( set )
1119
 
                        elem[ name ] = value;
1120
 
 
1121
 
                return elem[ name ];
1122
 
        },
1123
 
 
1124
 
        trim: function( text ) {
1125
 
                return (text || "").replace( /^\s+|\s+$/g, "" );
1126
 
        },
1127
 
 
1128
 
        makeArray: function( array ) {
1129
 
                var ret = [];
1130
 
 
1131
 
                if( array != null ){
1132
 
                        var i = array.length;
1133
 
                        //the window, strings and functions also have 'length'
1134
 
                        if( i == null || array.split || array.setInterval || array.call )
1135
 
                                ret[0] = array;
1136
 
                        else
1137
 
                                while( i )
1138
 
                                        ret[--i] = array[i];
1139
 
                }
1140
 
 
1141
 
                return ret;
1142
 
        },
1143
 
 
1144
 
        inArray: function( elem, array ) {
1145
 
                for ( var i = 0, length = array.length; i < length; i++ )
1146
 
                // Use === because on IE, window == document
1147
 
                        if ( array[ i ] === elem )
1148
 
                                return i;
1149
 
 
1150
 
                return -1;
1151
 
        },
1152
 
 
1153
 
        merge: function( first, second ) {
1154
 
                // We have to loop this way because IE & Opera overwrite the length
1155
 
                // expando of getElementsByTagName
1156
 
                var i = 0, elem, pos = first.length;
1157
 
                // Also, we need to make sure that the correct elements are being returned
1158
 
                // (IE returns comment nodes in a '*' query)
1159
 
                if ( jQuery.browser.msie ) {
1160
 
                        while ( elem = second[ i++ ] )
1161
 
                                if ( elem.nodeType != 8 )
1162
 
                                        first[ pos++ ] = elem;
1163
 
 
1164
 
                } else
1165
 
                        while ( elem = second[ i++ ] )
1166
 
                                first[ pos++ ] = elem;
1167
 
 
1168
 
                return first;
1169
 
        },
1170
 
 
1171
 
        unique: function( array ) {
1172
 
                var ret = [], done = {};
1173
 
 
1174
 
                try {
1175
 
 
1176
 
                        for ( var i = 0, length = array.length; i < length; i++ ) {
1177
 
                                var id = jQuery.data( array[ i ] );
1178
 
 
1179
 
                                if ( !done[ id ] ) {
1180
 
                                        done[ id ] = true;
1181
 
                                        ret.push( array[ i ] );
1182
 
                                }
1183
 
                        }
1184
 
 
1185
 
                } catch( e ) {
1186
 
                        ret = array;
1187
 
                }
1188
 
 
1189
 
                return ret;
1190
 
        },
1191
 
 
1192
 
        grep: function( elems, callback, inv ) {
1193
 
                var ret = [];
1194
 
 
1195
 
                // Go through the array, only saving the items
1196
 
                // that pass the validator function
1197
 
                for ( var i = 0, length = elems.length; i < length; i++ )
1198
 
                        if ( !inv != !callback( elems[ i ], i ) )
1199
 
                                ret.push( elems[ i ] );
1200
 
 
1201
 
                return ret;
1202
 
        },
1203
 
 
1204
 
        map: function( elems, callback ) {
1205
 
                var ret = [];
1206
 
 
1207
 
                // Go through the array, translating each of the items to their
1208
 
                // new value (or values).
1209
 
                for ( var i = 0, length = elems.length; i < length; i++ ) {
1210
 
                        var value = callback( elems[ i ], i );
1211
 
 
1212
 
                        if ( value != null )
1213
 
                                ret[ ret.length ] = value;
1214
 
                }
1215
 
 
1216
 
                return ret.concat.apply( [], ret );
1217
 
        }
1218
 
});
1219
 
 
1220
 
var userAgent = navigator.userAgent.toLowerCase();
1221
 
 
1222
 
// Figure out what browser is being used
1223
 
jQuery.browser = {
1224
 
        version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
1225
 
        safari: /webkit/.test( userAgent ),
1226
 
        opera: /opera/.test( userAgent ),
1227
 
        msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1228
 
        mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1229
 
};
1230
 
 
1231
 
var styleFloat = jQuery.browser.msie ?
1232
 
        "styleFloat" :
1233
 
        "cssFloat";
1234
 
 
1235
 
jQuery.extend({
1236
 
        // Check to see if the W3C box model is being used
1237
 
        boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
1238
 
 
1239
 
        props: {
1240
 
                "for": "htmlFor",
1241
 
                "class": "className",
1242
 
                "float": styleFloat,
1243
 
                cssFloat: styleFloat,
1244
 
                styleFloat: styleFloat,
1245
 
                readonly: "readOnly",
1246
 
                maxlength: "maxLength",
1247
 
                cellspacing: "cellSpacing"
1248
 
        }
1249
 
});
1250
 
 
1251
 
jQuery.each({
1252
 
        parent: function(elem){return elem.parentNode;},
1253
 
        parents: function(elem){return jQuery.dir(elem,"parentNode");},
1254
 
        next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1255
 
        prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1256
 
        nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1257
 
        prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1258
 
        siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1259
 
        children: function(elem){return jQuery.sibling(elem.firstChild);},
1260
 
        contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1261
 
}, function(name, fn){
1262
 
        jQuery.fn[ name ] = function( selector ) {
1263
 
                var ret = jQuery.map( this, fn );
1264
 
 
1265
 
                if ( selector && typeof selector == "string" )
1266
 
                        ret = jQuery.multiFilter( selector, ret );
1267
 
 
1268
 
                return this.pushStack( jQuery.unique( ret ) );
1269
 
        };
1270
 
});
1271
 
 
1272
 
jQuery.each({
1273
 
        appendTo: "append",
1274
 
        prependTo: "prepend",
1275
 
        insertBefore: "before",
1276
 
        insertAfter: "after",
1277
 
        replaceAll: "replaceWith"
1278
 
}, function(name, original){
1279
 
        jQuery.fn[ name ] = function() {
1280
 
                var args = arguments;
1281
 
 
1282
 
                return this.each(function(){
1283
 
                        for ( var i = 0, length = args.length; i < length; i++ )
1284
 
                                jQuery( args[ i ] )[ original ]( this );
1285
 
                });
1286
 
        };
1287
 
});
1288
 
 
1289
 
jQuery.each({
1290
 
        removeAttr: function( name ) {
1291
 
                jQuery.attr( this, name, "" );
1292
 
                if (this.nodeType == 1)
1293
 
                        this.removeAttribute( name );
1294
 
        },
1295
 
 
1296
 
        addClass: function( classNames ) {
1297
 
                jQuery.className.add( this, classNames );
1298
 
        },
1299
 
 
1300
 
        removeClass: function( classNames ) {
1301
 
                jQuery.className.remove( this, classNames );
1302
 
        },
1303
 
 
1304
 
        toggleClass: function( classNames ) {
1305
 
                jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1306
 
        },
1307
 
 
1308
 
        remove: function( selector ) {
1309
 
                if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
1310
 
                        // Prevent memory leaks
1311
 
                        jQuery( "*", this ).add(this).each(function(){
1312
 
                                jQuery.event.remove(this);
1313
 
                                jQuery.removeData(this);
1314
 
                        });
1315
 
                        if (this.parentNode)
1316
 
                                this.parentNode.removeChild( this );
1317
 
                }
1318
 
        },
1319
 
 
1320
 
        empty: function() {
1321
 
                // Remove element nodes and prevent memory leaks
1322
 
                jQuery( ">*", this ).remove();
1323
 
 
1324
 
                // Remove any remaining nodes
1325
 
                while ( this.firstChild )
1326
 
                        this.removeChild( this.firstChild );
1327
 
        }
1328
 
}, function(name, fn){
1329
 
        jQuery.fn[ name ] = function(){
1330
 
                return this.each( fn, arguments );
1331
 
        };
1332
 
});
1333
 
 
1334
 
jQuery.each([ "Height", "Width" ], function(i, name){
1335
 
        var type = name.toLowerCase();
1336
 
 
1337
 
        jQuery.fn[ type ] = function( size ) {
1338
 
                // Get window width or height
1339
 
                return this[0] == window ?
1340
 
                        // Opera reports document.body.client[Width/Height] properly in both quirks and standards
1341
 
                        jQuery.browser.opera && document.body[ "client" + name ] ||
1342
 
 
1343
 
                        // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1344
 
                        jQuery.browser.safari && window[ "inner" + name ] ||
1345
 
 
1346
 
                        // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1347
 
                        document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
1348
 
 
1349
 
                        // Get document width or height
1350
 
                        this[0] == document ?
1351
 
                                // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1352
 
                                Math.max(
1353
 
                                        Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
1354
 
                                        Math.max(document.body["offset" + name], document.documentElement["offset" + name])
1355
 
                                ) :
1356
 
 
1357
 
                                // Get or set width or height on the element
1358
 
                                size == undefined ?
1359
 
                                        // Get width or height on the element
1360
 
                                        (this.length ? jQuery.css( this[0], type ) : null) :
1361
 
 
1362
 
                                        // Set the width or height on the element (default to pixels if value is unitless)
1363
 
                                        this.css( type, size.constructor == String ? size : size + "px" );
1364
 
        };
1365
 
});
1366
 
 
1367
 
// Helper function used by the dimensions and offset modules
1368
 
function num(elem, prop) {
1369
 
        return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1370
 
}
 
 
b'\\ No newline at end of file'