@@ -0,0 +1,7179 @@
1+/*!
2+ * jQuery JavaScript Library v1.4.4
3+ * http://jquery.com/
4+ *
5+ * Copyright 2010, John Resig
6+ * Dual licensed under the MIT or GPL Version 2 licenses.
7+ * http://jquery.org/license
8+ *
9+ * Includes Sizzle.js
10+ * http://sizzlejs.com/
11+ * Copyright 2010, The Dojo Foundation
12+ * Released under the MIT, BSD, and GPL Licenses.
13+ *
14+ * Date: Thu Nov 11 19:04:53 2010 -0500
15+ */
16+(function( window, undefined ) {
17+
18+// Use the correct document accordingly with window argument (sandbox)
19+var document = window.document;
20+var jQuery = (function() {
21+
22+// Define a local copy of jQuery
23+var jQuery = function( selector, context ) {
24+ // The jQuery object is actually just the init constructor 'enhanced'
25+ return new jQuery.fn.init( selector, context );
26+ },
27+
28+ // Map over jQuery in case of overwrite
29+ _jQuery = window.jQuery,
30+
31+ // Map over the $ in case of overwrite
32+ _$ = window.$,
33+
34+ // A central reference to the root jQuery(document)
35+ rootjQuery,
36+
37+ // A simple way to check for HTML strings or ID strings
38+ // (both of which we optimize for)
39+ quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
40+
41+ // Is it a simple selector
42+ isSimple = /^.[^:#\[\.,]*$/,
43+
44+ // Check if a string has a non-whitespace character in it
45+ rnotwhite = /\S/,
46+ rwhite = /\s/,
47+
48+ // Used for trimming whitespace
49+ trimLeft = /^\s+/,
50+ trimRight = /\s+$/,
51+
52+ // Check for non-word characters
53+ rnonword = /\W/,
54+
55+ // Check for digits
56+ rdigit = /\d/,
57+
58+ // Match a standalone tag
59+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
60+
61+ // JSON RegExp
62+ rvalidchars = /^[\],:{}\s]*$/,
63+ rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
64+ rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
65+ rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
66+
67+ // Useragent RegExp
68+ rwebkit = /(webkit)[ \/]([\w.]+)/,
69+ ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
70+ rmsie = /(msie) ([\w.]+)/,
71+ rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
72+
73+ // Keep a UserAgent string for use with jQuery.browser
74+ userAgent = navigator.userAgent,
75+
76+ // For matching the engine and version of the browser
77+ browserMatch,
78+
79+ // Has the ready events already been bound?
80+ readyBound = false,
81+
82+ // The functions to execute on DOM ready
83+ readyList = [],
84+
85+ // The ready event handler
86+ DOMContentLoaded,
87+
88+ // Save a reference to some core methods
89+ toString = Object.prototype.toString,
90+ hasOwn = Object.prototype.hasOwnProperty,
91+ push = Array.prototype.push,
92+ slice = Array.prototype.slice,
93+ trim = String.prototype.trim,
94+ indexOf = Array.prototype.indexOf,
95+
96+ // [[Class]] -> type pairs
97+ class2type = {};
98+
99+jQuery.fn = jQuery.prototype = {
100+ init: function( selector, context ) {
101+ var match, elem, ret, doc;
102+
103+ // Handle $(""), $(null), or $(undefined)
104+ if ( !selector ) {
105+ return this;
106+ }
107+
108+ // Handle $(DOMElement)
109+ if ( selector.nodeType ) {
110+ this.context = this[0] = selector;
111+ this.length = 1;
112+ return this;
113+ }
114+
115+ // The body element only exists once, optimize finding it
116+ if ( selector === "body" && !context && document.body ) {
117+ this.context = document;
118+ this[0] = document.body;
119+ this.selector = "body";
120+ this.length = 1;
121+ return this;
122+ }
123+
124+ // Handle HTML strings
125+ if ( typeof selector === "string" ) {
126+ // Are we dealing with HTML string or an ID?
127+ match = quickExpr.exec( selector );
128+
129+ // Verify a match, and that no context was specified for #id
130+ if ( match && (match[1] || !context) ) {
131+
132+ // HANDLE: $(html) -> $(array)
133+ if ( match[1] ) {
134+ doc = (context ? context.ownerDocument || context : document);
135+
136+ // If a single string is passed in and it's a single tag
137+ // just do a createElement and skip the rest
138+ ret = rsingleTag.exec( selector );
139+
140+ if ( ret ) {
141+ if ( jQuery.isPlainObject( context ) ) {
142+ selector = [ document.createElement( ret[1] ) ];
143+ jQuery.fn.attr.call( selector, context, true );
144+
145+ } else {
146+ selector = [ doc.createElement( ret[1] ) ];
147+ }
148+
149+ } else {
150+ ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
151+ selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
152+ }
153+
154+ return jQuery.merge( this, selector );
155+
156+ // HANDLE: $("#id")
157+ } else {
158+ elem = document.getElementById( match[2] );
159+
160+ // Check parentNode to catch when Blackberry 4.6 returns
161+ // nodes that are no longer in the document #6963
162+ if ( elem && elem.parentNode ) {
163+ // Handle the case where IE and Opera return items
164+ // by name instead of ID
165+ if ( elem.id !== match[2] ) {
166+ return rootjQuery.find( selector );
167+ }
168+
169+ // Otherwise, we inject the element directly into the jQuery object
170+ this.length = 1;
171+ this[0] = elem;
172+ }
173+
174+ this.context = document;
175+ this.selector = selector;
176+ return this;
177+ }
178+
179+ // HANDLE: $("TAG")
180+ } else if ( !context && !rnonword.test( selector ) ) {
181+ this.selector = selector;
182+ this.context = document;
183+ selector = document.getElementsByTagName( selector );
184+ return jQuery.merge( this, selector );
185+
186+ // HANDLE: $(expr, $(...))
187+ } else if ( !context || context.jquery ) {
188+ return (context || rootjQuery).find( selector );
189+
190+ // HANDLE: $(expr, context)
191+ // (which is just equivalent to: $(context).find(expr)
192+ } else {
193+ return jQuery( context ).find( selector );
194+ }
195+
196+ // HANDLE: $(function)
197+ // Shortcut for document ready
198+ } else if ( jQuery.isFunction( selector ) ) {
199+ return rootjQuery.ready( selector );
200+ }
201+
202+ if (selector.selector !== undefined) {
203+ this.selector = selector.selector;
204+ this.context = selector.context;
205+ }
206+
207+ return jQuery.makeArray( selector, this );
208+ },
209+
210+ // Start with an empty selector
211+ selector: "",
212+
213+ // The current version of jQuery being used
214+ jquery: "1.4.4",
215+
216+ // The default length of a jQuery object is 0
217+ length: 0,
218+
219+ // The number of elements contained in the matched element set
220+ size: function() {
221+ return this.length;
222+ },
223+
224+ toArray: function() {
225+ return slice.call( this, 0 );
226+ },
227+
228+ // Get the Nth element in the matched element set OR
229+ // Get the whole matched element set as a clean array
230+ get: function( num ) {
231+ return num == null ?
232+
233+ // Return a 'clean' array
234+ this.toArray() :
235+
236+ // Return just the object
237+ ( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
238+ },
239+
240+ // Take an array of elements and push it onto the stack
241+ // (returning the new matched element set)
242+ pushStack: function( elems, name, selector ) {
243+ // Build a new jQuery matched element set
244+ var ret = jQuery();
245+
246+ if ( jQuery.isArray( elems ) ) {
247+ push.apply( ret, elems );
248+
249+ } else {
250+ jQuery.merge( ret, elems );
251+ }
252+
253+ // Add the old object onto the stack (as a reference)
254+ ret.prevObject = this;
255+
256+ ret.context = this.context;
257+
258+ if ( name === "find" ) {
259+ ret.selector = this.selector + (this.selector ? " " : "") + selector;
260+ } else if ( name ) {
261+ ret.selector = this.selector + "." + name + "(" + selector + ")";
262+ }
263+
264+ // Return the newly-formed element set
265+ return ret;
266+ },
267+
268+ // Execute a callback for every element in the matched set.
269+ // (You can seed the arguments with an array of args, but this is
270+ // only used internally.)
271+ each: function( callback, args ) {
272+ return jQuery.each( this, callback, args );
273+ },
274+
275+ ready: function( fn ) {
276+ // Attach the listeners
277+ jQuery.bindReady();
278+
279+ // If the DOM is already ready
280+ if ( jQuery.isReady ) {
281+ // Execute the function immediately
282+ fn.call( document, jQuery );
283+
284+ // Otherwise, remember the function for later
285+ } else if ( readyList ) {
286+ // Add the function to the wait list
287+ readyList.push( fn );
288+ }
289+
290+ return this;
291+ },
292+
293+ eq: function( i ) {
294+ return i === -1 ?
295+ this.slice( i ) :
296+ this.slice( i, +i + 1 );
297+ },
298+
299+ first: function() {
300+ return this.eq( 0 );
301+ },
302+
303+ last: function() {
304+ return this.eq( -1 );
305+ },
306+
307+ slice: function() {
308+ return this.pushStack( slice.apply( this, arguments ),
309+ "slice", slice.call(arguments).join(",") );
310+ },
311+
312+ map: function( callback ) {
313+ return this.pushStack( jQuery.map(this, function( elem, i ) {
314+ return callback.call( elem, i, elem );
315+ }));
316+ },
317+
318+ end: function() {
319+ return this.prevObject || jQuery(null);
320+ },
321+
322+ // For internal use only.
323+ // Behaves like an Array's method, not like a jQuery method.
324+ push: push,
325+ sort: [].sort,
326+ splice: [].splice
327+};
328+
329+// Give the init function the jQuery prototype for later instantiation
330+jQuery.fn.init.prototype = jQuery.fn;
331+
332+jQuery.extend = jQuery.fn.extend = function() {
333+ var options, name, src, copy, copyIsArray, clone,
334+ target = arguments[0] || {},
335+ i = 1,
336+ length = arguments.length,
337+ deep = false;
338+
339+ // Handle a deep copy situation
340+ if ( typeof target === "boolean" ) {
341+ deep = target;
342+ target = arguments[1] || {};
343+ // skip the boolean and the target
344+ i = 2;
345+ }
346+
347+ // Handle case when target is a string or something (possible in deep copy)
348+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
349+ target = {};
350+ }
351+
352+ // extend jQuery itself if only one argument is passed
353+ if ( length === i ) {
354+ target = this;
355+ --i;
356+ }
357+
358+ for ( ; i < length; i++ ) {
359+ // Only deal with non-null/undefined values
360+ if ( (options = arguments[ i ]) != null ) {
361+ // Extend the base object
362+ for ( name in options ) {
363+ src = target[ name ];
364+ copy = options[ name ];
365+
366+ // Prevent never-ending loop
367+ if ( target === copy ) {
368+ continue;
369+ }
370+
371+ // Recurse if we're merging plain objects or arrays
372+ if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
373+ if ( copyIsArray ) {
374+ copyIsArray = false;
375+ clone = src && jQuery.isArray(src) ? src : [];
376+
377+ } else {
378+ clone = src && jQuery.isPlainObject(src) ? src : {};
379+ }
380+
381+ // Never move original objects, clone them
382+ target[ name ] = jQuery.extend( deep, clone, copy );
383+
384+ // Don't bring in undefined values
385+ } else if ( copy !== undefined ) {
386+ target[ name ] = copy;
387+ }
388+ }
389+ }
390+ }
391+
392+ // Return the modified object
393+ return target;
394+};
395+
396+jQuery.extend({
397+ noConflict: function( deep ) {
398+ window.$ = _$;
399+
400+ if ( deep ) {
401+ window.jQuery = _jQuery;
402+ }
403+
404+ return jQuery;
405+ },
406+
407+ // Is the DOM ready to be used? Set to true once it occurs.
408+ isReady: false,
409+
410+ // A counter to track how many items to wait for before
411+ // the ready event fires. See #6781
412+ readyWait: 1,
413+
414+ // Handle when the DOM is ready
415+ ready: function( wait ) {
416+ // A third-party is pushing the ready event forwards
417+ if ( wait === true ) {
418+ jQuery.readyWait--;
419+ }
420+
421+ // Make sure that the DOM is not already loaded
422+ if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
423+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
424+ if ( !document.body ) {
425+ return setTimeout( jQuery.ready, 1 );
426+ }
427+
428+ // Remember that the DOM is ready
429+ jQuery.isReady = true;
430+
431+ // If a normal DOM Ready event fired, decrement, and wait if need be
432+ if ( wait !== true && --jQuery.readyWait > 0 ) {
433+ return;
434+ }
435+
436+ // If there are functions bound, to execute
437+ if ( readyList ) {
438+ // Execute all of them
439+ var fn,
440+ i = 0,
441+ ready = readyList;
442+
443+ // Reset the list of functions
444+ readyList = null;
445+
446+ while ( (fn = ready[ i++ ]) ) {
447+ fn.call( document, jQuery );
448+ }
449+
450+ // Trigger any bound ready events
451+ if ( jQuery.fn.trigger ) {
452+ jQuery( document ).trigger( "ready" ).unbind( "ready" );
453+ }
454+ }
455+ }
456+ },
457+
458+ bindReady: function() {
459+ if ( readyBound ) {
460+ return;
461+ }
462+
463+ readyBound = true;
464+
465+ // Catch cases where $(document).ready() is called after the
466+ // browser event has already occurred.
467+ if ( document.readyState === "complete" ) {
468+ // Handle it asynchronously to allow scripts the opportunity to delay ready
469+ return setTimeout( jQuery.ready, 1 );
470+ }
471+
472+ // Mozilla, Opera and webkit nightlies currently support this event
473+ if ( document.addEventListener ) {
474+ // Use the handy event callback
475+ document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
476+
477+ // A fallback to window.onload, that will always work
478+ window.addEventListener( "load", jQuery.ready, false );
479+
480+ // If IE event model is used
481+ } else if ( document.attachEvent ) {
482+ // ensure firing before onload,
483+ // maybe late but safe also for iframes
484+ document.attachEvent("onreadystatechange", DOMContentLoaded);
485+
486+ // A fallback to window.onload, that will always work
487+ window.attachEvent( "onload", jQuery.ready );
488+
489+ // If IE and not a frame
490+ // continually check to see if the document is ready
491+ var toplevel = false;
492+
493+ try {
494+ toplevel = window.frameElement == null;
495+ } catch(e) {}
496+
497+ if ( document.documentElement.doScroll && toplevel ) {
498+ doScrollCheck();
499+ }
500+ }
501+ },
502+
503+ // See test/unit/core.js for details concerning isFunction.
504+ // Since version 1.3, DOM methods and functions like alert
505+ // aren't supported. They return false on IE (#2968).
506+ isFunction: function( obj ) {
507+ return jQuery.type(obj) === "function";
508+ },
509+
510+ isArray: Array.isArray || function( obj ) {
511+ return jQuery.type(obj) === "array";
512+ },
513+
514+ // A crude way of determining if an object is a window
515+ isWindow: function( obj ) {
516+ return obj && typeof obj === "object" && "setInterval" in obj;
517+ },
518+
519+ isNaN: function( obj ) {
520+ return obj == null || !rdigit.test( obj ) || isNaN( obj );
521+ },
522+
523+ type: function( obj ) {
524+ return obj == null ?
525+ String( obj ) :
526+ class2type[ toString.call(obj) ] || "object";
527+ },
528+
529+ isPlainObject: function( obj ) {
530+ // Must be an Object.
531+ // Because of IE, we also have to check the presence of the constructor property.
532+ // Make sure that DOM nodes and window objects don't pass through, as well
533+ if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
534+ return false;
535+ }
536+
537+ // Not own constructor property must be Object
538+ if ( obj.constructor &&
539+ !hasOwn.call(obj, "constructor") &&
540+ !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
541+ return false;
542+ }
543+
544+ // Own properties are enumerated firstly, so to speed up,
545+ // if last one is own, then all properties are own.
546+
547+ var key;
548+ for ( key in obj ) {}
549+
550+ return key === undefined || hasOwn.call( obj, key );
551+ },
552+
553+ isEmptyObject: function( obj ) {
554+ for ( var name in obj ) {
555+ return false;
556+ }
557+ return true;
558+ },
559+
560+ error: function( msg ) {
561+ throw msg;
562+ },
563+
564+ parseJSON: function( data ) {
565+ if ( typeof data !== "string" || !data ) {
566+ return null;
567+ }
568+
569+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
570+ data = jQuery.trim( data );
571+
572+ // Make sure the incoming data is actual JSON
573+ // Logic borrowed from http://json.org/json2.js
574+ if ( rvalidchars.test(data.replace(rvalidescape, "@")
575+ .replace(rvalidtokens, "]")
576+ .replace(rvalidbraces, "")) ) {
577+
578+ // Try to use the native JSON parser first
579+ return window.JSON && window.JSON.parse ?
580+ window.JSON.parse( data ) :
581+ (new Function("return " + data))();
582+
583+ } else {
584+ jQuery.error( "Invalid JSON: " + data );
585+ }
586+ },
587+
588+ noop: function() {},
589+
590+ // Evalulates a script in a global context
591+ globalEval: function( data ) {
592+ if ( data && rnotwhite.test(data) ) {
593+ // Inspired by code by Andrea Giammarchi
594+ // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
595+ var head = document.getElementsByTagName("head")[0] || document.documentElement,
596+ script = document.createElement("script");
597+
598+ script.type = "text/javascript";
599+
600+ if ( jQuery.support.scriptEval ) {
601+ script.appendChild( document.createTextNode( data ) );
602+ } else {
603+ script.text = data;
604+ }
605+
606+ // Use insertBefore instead of appendChild to circumvent an IE6 bug.
607+ // This arises when a base node is used (#2709).
608+ head.insertBefore( script, head.firstChild );
609+ head.removeChild( script );
610+ }
611+ },
612+
613+ nodeName: function( elem, name ) {
614+ return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
615+ },
616+
617+ // args is for internal usage only
618+ each: function( object, callback, args ) {
619+ var name, i = 0,
620+ length = object.length,
621+ isObj = length === undefined || jQuery.isFunction(object);
622+
623+ if ( args ) {
624+ if ( isObj ) {
625+ for ( name in object ) {
626+ if ( callback.apply( object[ name ], args ) === false ) {
627+ break;
628+ }
629+ }
630+ } else {
631+ for ( ; i < length; ) {
632+ if ( callback.apply( object[ i++ ], args ) === false ) {
633+ break;
634+ }
635+ }
636+ }
637+
638+ // A special, fast, case for the most common use of each
639+ } else {
640+ if ( isObj ) {
641+ for ( name in object ) {
642+ if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
643+ break;
644+ }
645+ }
646+ } else {
647+ for ( var value = object[0];
648+ i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
649+ }
650+ }
651+
652+ return object;
653+ },
654+
655+ // Use native String.trim function wherever possible
656+ trim: trim ?
657+ function( text ) {
658+ return text == null ?
659+ "" :
660+ trim.call( text );
661+ } :
662+
663+ // Otherwise use our own trimming functionality
664+ function( text ) {
665+ return text == null ?
666+ "" :
667+ text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
668+ },
669+
670+ // results is for internal usage only
671+ makeArray: function( array, results ) {
672+ var ret = results || [];
673+
674+ if ( array != null ) {
675+ // The window, strings (and functions) also have 'length'
676+ // The extra typeof function check is to prevent crashes
677+ // in Safari 2 (See: #3039)
678+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
679+ var type = jQuery.type(array);
680+
Cut short: this commit's diff is over 1000 lines.