N98_jQuery - Version 1.0.0

Version Notes

First stable release.

Release Info

Developer	netz98 new media GmbH
Extension	N98_jQuery
Version	1.0.0
Comparing to
See all releases

Version 1.0.0

Files changed (6) hide show

app/code/community/N98/JQuery/etc/config.xml +48 -0
app/design/frontend/base/default/layout/n98/jquery.xml +10 -0
app/etc/modules/N98_JQuery.xml +44 -0
js/n98/jquery/jquery-1.6.2.js +8981 -0
js/n98/jquery/jquery.no.conflict.js +1 -0
package.xml +18 -0

app/code/community/N98/JQuery/etc/config.xml ADDED Viewed

	@@ -0,0 +1,48 @@


1	+ <?xml version="1.0"?>
2	+ <!--
3	+ /**
4	+ * Copyright © 2011
5	+ * netz98 new media GmbH. All rights reserved.
6	+ *
7	+ * The use and redistribution of this software, either compiled or uncompiled,
8	+ * with or without modifications are permitted provided that the
9	+ * following conditions are met:
10	+ *
11	+ * 1. Redistributions of compiled or uncompiled source must contain the above
12	+ * copyright notice, this list of the conditions and the following disclaimer:
13	+ *
14	+ * 2. All advertising materials mentioning features or use of this software must
15	+ * display the following acknowledgement:
16	+ * "This product includes software developed by the netz98 new media GmbH, Mainz."
17	+ *
18	+ * 3. The name of the netz98 new media GmbH may not be used to endorse or promote
19	+ * products derived from this software without specific prior written permission.
20	+ *
21	+ * 4. License holders of the netz98 new media GmbH are only permitted to
22	+ * redistribute altered software, if this is licensed under conditions that contain
23	+ * a copyleft-clause.
24	+ *
25	+ * This software is provided by the netz98 new media GmbH without any express or
26	+ * implied warranties. netz98 is under no condition liable for the functional
27	+ * capability of this software for a certain purpose or the general usability.
28	+ * netz98 is under no condition liable for any direct or indirect damages resulting
29	+ * from the use of the software.
30	+ * Liability and Claims for damages of any kind are excluded.
31	+ */
32	+ -->
33	+ <config>
34	+ <modules>
35	+ <N98_JQuery>
36	+ <version>1.0.0</version>
37	+ </N98_JQuery>
38	+ </modules>
39	+ <frontend>
40	+ <layout>
41	+ <updates>
42	+ <n98_jquery>
43	+ <file>n98/jquery.xml</file>
44	+ </n98_jquery>
45	+ </updates>
46	+ </layout>
47	+ </frontend>
48	+ </config>

app/design/frontend/base/default/layout/n98/jquery.xml ADDED Viewed

	@@ -0,0 +1,10 @@


1	+ <?xml version="1.0" encoding="UTF-8"?>
2	+ <layoutUpdate>
3	+ <default>
4	+ <reference name="head">
5	+ <action method="addJs"><script>n98/jquery/jquery-1.6.2.js</script></action>
6	+ <action method="addJs"><script>n98/jquery/jquery.no.conflict.js</script></action>
7	+ </reference>
8	+ </default>
9	+ </layoutUpdate>
10	+

app/etc/modules/N98_JQuery.xml ADDED Viewed

	@@ -0,0 +1,44 @@


1	+ <?xml version="1.0"?>
2	+ <!--
3	+ /**
4	+ * Copyright © 2011
5	+ * netz98 new media GmbH. All rights reserved.
6	+ *
7	+ * The use and redistribution of this software, either compiled or uncompiled,
8	+ * with or without modifications are permitted provided that the
9	+ * following conditions are met:
10	+ *
11	+ * 1. Redistributions of compiled or uncompiled source must contain the above
12	+ * copyright notice, this list of the conditions and the following disclaimer:
13	+ *
14	+ * 2. All advertising materials mentioning features or use of this software must
15	+ * display the following acknowledgement:
16	+ * "This product includes software developed by the netz98 new media GmbH, Mainz."
17	+ *
18	+ * 3. The name of the netz98 new media GmbH may not be used to endorse or promote
19	+ * products derived from this software without specific prior written permission.
20	+ *
21	+ * 4. License holders of the netz98 new media GmbH are only permitted to
22	+ * redistribute altered software, if this is licensed under conditions that contain
23	+ * a copyleft-clause.
24	+ *
25	+ * This software is provided by the netz98 new media GmbH without any express or
26	+ * implied warranties. netz98 is under no condition liable for the functional
27	+ * capability of this software for a certain purpose or the general usability.
28	+ * netz98 is under no condition liable for any direct or indirect damages resulting
29	+ * from the use of the software.
30	+ * Liability and Claims for damages of any kind are excluded.
31	+ */
32	+ -->
33	+ <config>
34	+ <modules>
35	+ <N98_JQuery>
36	+ <active>true</active>
37	+ <codePool>community</codePool>
38	+ <depends>
39	+ <Mage_Core />
40	+ </depends>
41	+ </N98_JQuery>
42	+ </modules>
43	+ </config>
44	+

js/n98/jquery/jquery-1.6.2.js ADDED Viewed

	@@ -0,0 +1,8981 @@


1	+ /*!
2	+ * jQuery JavaScript Library v1.6.2
3	+ * http://jquery.com/
4	+ *
5	+ * Copyright 2011, 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 2011, The Dojo Foundation
12	+ * Released under the MIT, BSD, and GPL Licenses.
13	+ *
14	+ * Date: Thu Jun 30 14:16:56 2011 -0400
15	+ */
16	+ (function( window, undefined ) {
17	+
18	+ // Use the correct document accordingly with window argument (sandbox)
19	+ var document = window.document,
20	+ navigator = window.navigator,
21	+ location = window.location;
22	+ var jQuery = (function() {
23	+
24	+ // Define a local copy of jQuery
25	+ var jQuery = function( selector, context ) {
26	+ // The jQuery object is actually just the init constructor 'enhanced'
27	+ return new jQuery.fn.init( selector, context, rootjQuery );
28	+ },
29	+
30	+ // Map over jQuery in case of overwrite
31	+ _jQuery = window.jQuery,
32	+
33	+ // Map over the $ in case of overwrite
34	+ _$ = window.$,
35	+
36	+ // A central reference to the root jQuery(document)
37	+ rootjQuery,
38	+
39	+ // A simple way to check for HTML strings or ID strings
40	+ // (both of which we optimize for)
41	+ quickExpr = /^(?:[^<](<[\w\W]+>)[^>]$\|#([\w\-]*)$)/,
42	+
43	+ // Check if a string has a non-whitespace character in it
44	+ rnotwhite = /\S/,
45	+
46	+ // Used for trimming whitespace
47	+ trimLeft = /^\s+/,
48	+ trimRight = /\s+$/,
49	+
50	+ // Check for digits
51	+ rdigit = /\d/,
52	+
53	+ // Match a standalone tag
54	+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
55	+
56	+ // JSON RegExp
57	+ rvalidchars = /^[\],:{}\s]*$/,
58	+ rvalidescape = /\\(?:["\\\/bfnrt]\|u[0-9a-fA-F]{4})/g,
59	+ rvalidtokens = /"[^"\\\n\r]"\|true\|false\|null\|-?\d+(?:\.\d)?(?:[eE][+\-]?\d+)?/g,
60	+ rvalidbraces = /(?:^\|:\|,)(?:\s*\[)+/g,
61	+
62	+ // Useragent RegExp
63	+ rwebkit = /(webkit)[ \/]([\w.]+)/,
64	+ ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
65	+ rmsie = /(msie) ([\w.]+)/,
66	+ rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
67	+
68	+ // Matches dashed string for camelizing
69	+ rdashAlpha = /-([a-z])/ig,
70	+
71	+ // Used by jQuery.camelCase as callback to replace()
72	+ fcamelCase = function( all, letter ) {
73	+ return letter.toUpperCase();
74	+ },
75	+
76	+ // Keep a UserAgent string for use with jQuery.browser
77	+ userAgent = navigator.userAgent,
78	+
79	+ // For matching the engine and version of the browser
80	+ browserMatch,
81	+
82	+ // The deferred used 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	+ constructor: jQuery,
101	+ init: function( selector, context, rootjQuery ) {
102	+ var match, elem, ret, doc;
103	+
104	+ // Handle $(""), $(null), or $(undefined)
105	+ if ( !selector ) {
106	+ return this;
107	+ }
108	+
109	+ // Handle $(DOMElement)
110	+ if ( selector.nodeType ) {
111	+ this.context = this[0] = selector;
112	+ this.length = 1;
113	+ return this;
114	+ }
115	+
116	+ // The body element only exists once, optimize finding it
117	+ if ( selector === "body" && !context && document.body ) {
118	+ this.context = document;
119	+ this[0] = document.body;
120	+ this.selector = selector;
121	+ this.length = 1;
122	+ return this;
123	+ }
124	+
125	+ // Handle HTML strings
126	+ if ( typeof selector === "string" ) {
127	+ // Are we dealing with HTML string or an ID?
128	+ if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
129	+ // Assume that strings that start and end with <> are HTML and skip the regex check
130	+ match = [ null, selector, null ];
131	+
132	+ } else {
133	+ match = quickExpr.exec( selector );
134	+ }
135	+
136	+ // Verify a match, and that no context was specified for #id
137	+ if ( match && (match[1] \|\| !context) ) {
138	+
139	+ // HANDLE: $(html) -> $(array)
140	+ if ( match[1] ) {
141	+ context = context instanceof jQuery ? context[0] : context;
142	+ doc = (context ? context.ownerDocument \|\| context : document);
143	+
144	+ // If a single string is passed in and it's a single tag
145	+ // just do a createElement and skip the rest
146	+ ret = rsingleTag.exec( selector );
147	+
148	+ if ( ret ) {
149	+ if ( jQuery.isPlainObject( context ) ) {
150	+ selector = [ document.createElement( ret[1] ) ];
151	+ jQuery.fn.attr.call( selector, context, true );
152	+
153	+ } else {
154	+ selector = [ doc.createElement( ret[1] ) ];
155	+ }
156	+
157	+ } else {
158	+ ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
159	+ selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
160	+ }
161	+
162	+ return jQuery.merge( this, selector );
163	+
164	+ // HANDLE: $("#id")
165	+ } else {
166	+ elem = document.getElementById( match[2] );
167	+
168	+ // Check parentNode to catch when Blackberry 4.6 returns
169	+ // nodes that are no longer in the document #6963
170	+ if ( elem && elem.parentNode ) {
171	+ // Handle the case where IE and Opera return items
172	+ // by name instead of ID
173	+ if ( elem.id !== match[2] ) {
174	+ return rootjQuery.find( selector );
175	+ }
176	+
177	+ // Otherwise, we inject the element directly into the jQuery object
178	+ this.length = 1;
179	+ this[0] = elem;
180	+ }
181	+
182	+ this.context = document;
183	+ this.selector = selector;
184	+ return this;
185	+ }
186	+
187	+ // HANDLE: $(expr, $(...))
188	+ } else if ( !context \|\| context.jquery ) {
189	+ return (context \|\| rootjQuery).find( selector );
190	+
191	+ // HANDLE: $(expr, context)
192	+ // (which is just equivalent to: $(context).find(expr)
193	+ } else {
194	+ return this.constructor( context ).find( selector );
195	+ }
196	+
197	+ // HANDLE: $(function)
198	+ // Shortcut for document ready
199	+ } else if ( jQuery.isFunction( selector ) ) {
200	+ return rootjQuery.ready( selector );
201	+ }
202	+
203	+ if (selector.selector !== undefined) {
204	+ this.selector = selector.selector;
205	+ this.context = selector.context;
206	+ }
207	+
208	+ return jQuery.makeArray( selector, this );
209	+ },
210	+
211	+ // Start with an empty selector
212	+ selector: "",
213	+
214	+ // The current version of jQuery being used
215	+ jquery: "1.6.2",
216	+
217	+ // The default length of a jQuery object is 0
218	+ length: 0,
219	+
220	+ // The number of elements contained in the matched element set
221	+ size: function() {
222	+ return this.length;
223	+ },
224	+
225	+ toArray: function() {
226	+ return slice.call( this, 0 );
227	+ },
228	+
229	+ // Get the Nth element in the matched element set OR
230	+ // Get the whole matched element set as a clean array
231	+ get: function( num ) {
232	+ return num == null ?
233	+
234	+ // Return a 'clean' array
235	+ this.toArray() :
236	+
237	+ // Return just the object
238	+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
239	+ },
240	+
241	+ // Take an array of elements and push it onto the stack
242	+ // (returning the new matched element set)
243	+ pushStack: function( elems, name, selector ) {
244	+ // Build a new jQuery matched element set
245	+ var ret = this.constructor();
246	+
247	+ if ( jQuery.isArray( elems ) ) {
248	+ push.apply( ret, elems );
249	+
250	+ } else {
251	+ jQuery.merge( ret, elems );
252	+ }
253	+
254	+ // Add the old object onto the stack (as a reference)
255	+ ret.prevObject = this;
256	+
257	+ ret.context = this.context;
258	+
259	+ if ( name === "find" ) {
260	+ ret.selector = this.selector + (this.selector ? " " : "") + selector;
261	+ } else if ( name ) {
262	+ ret.selector = this.selector + "." + name + "(" + selector + ")";
263	+ }
264	+
265	+ // Return the newly-formed element set
266	+ return ret;
267	+ },
268	+
269	+ // Execute a callback for every element in the matched set.
270	+ // (You can seed the arguments with an array of args, but this is
271	+ // only used internally.)
272	+ each: function( callback, args ) {
273	+ return jQuery.each( this, callback, args );
274	+ },
275	+
276	+ ready: function( fn ) {
277	+ // Attach the listeners
278	+ jQuery.bindReady();
279	+
280	+ // Add the callback
281	+ readyList.done( fn );
282	+
283	+ return this;
284	+ },
285	+
286	+ eq: function( i ) {
287	+ return i === -1 ?
288	+ this.slice( i ) :
289	+ this.slice( i, +i + 1 );
290	+ },
291	+
292	+ first: function() {
293	+ return this.eq( 0 );
294	+ },
295	+
296	+ last: function() {
297	+ return this.eq( -1 );
298	+ },
299	+
300	+ slice: function() {
301	+ return this.pushStack( slice.apply( this, arguments ),
302	+ "slice", slice.call(arguments).join(",") );
303	+ },
304	+
305	+ map: function( callback ) {
306	+ return this.pushStack( jQuery.map(this, function( elem, i ) {
307	+ return callback.call( elem, i, elem );
308	+ }));
309	+ },
310	+
311	+ end: function() {
312	+ return this.prevObject \|\| this.constructor(null);
313	+ },
314	+
315	+ // For internal use only.
316	+ // Behaves like an Array's method, not like a jQuery method.
317	+ push: push,
318	+ sort: [].sort,
319	+ splice: [].splice
320	+ };
321	+
322	+ // Give the init function the jQuery prototype for later instantiation
323	+ jQuery.fn.init.prototype = jQuery.fn;
324	+
325	+ jQuery.extend = jQuery.fn.extend = function() {
326	+ var options, name, src, copy, copyIsArray, clone,
327	+ target = arguments[0] \|\| {},
328	+ i = 1,
329	+ length = arguments.length,
330	+ deep = false;
331	+
332	+ // Handle a deep copy situation
333	+ if ( typeof target === "boolean" ) {
334	+ deep = target;
335	+ target = arguments[1] \|\| {};
336	+ // skip the boolean and the target
337	+ i = 2;
338	+ }
339	+
340	+ // Handle case when target is a string or something (possible in deep copy)
341	+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
342	+ target = {};
343	+ }
344	+
345	+ // extend jQuery itself if only one argument is passed
346	+ if ( length === i ) {
347	+ target = this;
348	+ --i;
349	+ }
350	+
351	+ for ( ; i < length; i++ ) {
352	+ // Only deal with non-null/undefined values
353	+ if ( (options = arguments[ i ]) != null ) {
354	+ // Extend the base object
355	+ for ( name in options ) {
356	+ src = target[ name ];
357	+ copy = options[ name ];
358	+
359	+ // Prevent never-ending loop
360	+ if ( target === copy ) {
361	+ continue;
362	+ }
363	+
364	+ // Recurse if we're merging plain objects or arrays
365	+ if ( deep && copy && ( jQuery.isPlainObject(copy) \|\| (copyIsArray = jQuery.isArray(copy)) ) ) {
366	+ if ( copyIsArray ) {
367	+ copyIsArray = false;
368	+ clone = src && jQuery.isArray(src) ? src : [];
369	+
370	+ } else {
371	+ clone = src && jQuery.isPlainObject(src) ? src : {};
372	+ }
373	+
374	+ // Never move original objects, clone them
375	+ target[ name ] = jQuery.extend( deep, clone, copy );
376	+
377	+ // Don't bring in undefined values
378	+ } else if ( copy !== undefined ) {
379	+ target[ name ] = copy;
380	+ }
381	+ }
382	+ }
383	+ }
384	+
385	+ // Return the modified object
386	+ return target;
387	+ };
388	+
389	+ jQuery.extend({
390	+ noConflict: function( deep ) {
391	+ if ( window.$ === jQuery ) {
392	+ window.$ = _$;
393	+ }
394	+
395	+ if ( deep && window.jQuery === jQuery ) {
396	+ window.jQuery = _jQuery;
397	+ }
398	+
399	+ return jQuery;
400	+ },
401	+
402	+ // Is the DOM ready to be used? Set to true once it occurs.
403	+ isReady: false,
404	+
405	+ // A counter to track how many items to wait for before
406	+ // the ready event fires. See #6781
407	+ readyWait: 1,
408	+
409	+ // Hold (or release) the ready event
410	+ holdReady: function( hold ) {
411	+ if ( hold ) {
412	+ jQuery.readyWait++;
413	+ } else {
414	+ jQuery.ready( true );
415	+ }
416	+ },
417	+
418	+ // Handle when the DOM is ready
419	+ ready: function( wait ) {
420	+ // Either a released hold or an DOMready/load event and not yet ready
421	+ if ( (wait === true && !--jQuery.readyWait) \|\| (wait !== true && !jQuery.isReady) ) {
422	+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
423	+ if ( !document.body ) {
424	+ return setTimeout( jQuery.ready, 1 );
425	+ }
426	+
427	+ // Remember that the DOM is ready
428	+ jQuery.isReady = true;
429	+
430	+ // If a normal DOM Ready event fired, decrement, and wait if need be
431	+ if ( wait !== true && --jQuery.readyWait > 0 ) {
432	+ return;
433	+ }
434	+
435	+ // If there are functions bound, to execute
436	+ readyList.resolveWith( document, [ jQuery ] );
437	+
438	+ // Trigger any bound ready events
439	+ if ( jQuery.fn.trigger ) {
440	+ jQuery( document ).trigger( "ready" ).unbind( "ready" );
441	+ }
442	+ }
443	+ },
444	+
445	+ bindReady: function() {
446	+ if ( readyList ) {
447	+ return;
448	+ }
449	+
450	+ readyList = jQuery._Deferred();
451	+
452	+ // Catch cases where $(document).ready() is called after the
453	+ // browser event has already occurred.
454	+ if ( document.readyState === "complete" ) {
455	+ // Handle it asynchronously to allow scripts the opportunity to delay ready
456	+ return setTimeout( jQuery.ready, 1 );
457	+ }
458	+
459	+ // Mozilla, Opera and webkit nightlies currently support this event
460	+ if ( document.addEventListener ) {
461	+ // Use the handy event callback
462	+ document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
463	+
464	+ // A fallback to window.onload, that will always work
465	+ window.addEventListener( "load", jQuery.ready, false );
466	+
467	+ // If IE event model is used
468	+ } else if ( document.attachEvent ) {
469	+ // ensure firing before onload,
470	+ // maybe late but safe also for iframes
471	+ document.attachEvent( "onreadystatechange", DOMContentLoaded );
472	+
473	+ // A fallback to window.onload, that will always work
474	+ window.attachEvent( "onload", jQuery.ready );
475	+
476	+ // If IE and not a frame
477	+ // continually check to see if the document is ready
478	+ var toplevel = false;
479	+
480	+ try {
481	+ toplevel = window.frameElement == null;
482	+ } catch(e) {}
483	+
484	+ if ( document.documentElement.doScroll && toplevel ) {
485	+ doScrollCheck();
486	+ }
487	+ }
488	+ },
489	+
490	+ // See test/unit/core.js for details concerning isFunction.
491	+ // Since version 1.3, DOM methods and functions like alert
492	+ // aren't supported. They return false on IE (#2968).
493	+ isFunction: function( obj ) {
494	+ return jQuery.type(obj) === "function";
495	+ },
496	+
497	+ isArray: Array.isArray \|\| function( obj ) {
498	+ return jQuery.type(obj) === "array";
499	+ },
500	+
501	+ // A crude way of determining if an object is a window
502	+ isWindow: function( obj ) {
503	+ return obj && typeof obj === "object" && "setInterval" in obj;
504	+ },
505	+
506	+ isNaN: function( obj ) {
507	+ return obj == null \|\| !rdigit.test( obj ) \|\| isNaN( obj );
508	+ },
509	+
510	+ type: function( obj ) {
511	+ return obj == null ?
512	+ String( obj ) :
513	+ class2type[ toString.call(obj) ] \|\| "object";
514	+ },
515	+
516	+ isPlainObject: function( obj ) {
517	+ // Must be an Object.
518	+ // Because of IE, we also have to check the presence of the constructor property.
519	+ // Make sure that DOM nodes and window objects don't pass through, as well
520	+ if ( !obj \|\| jQuery.type(obj) !== "object" \|\| obj.nodeType \|\| jQuery.isWindow( obj ) ) {
521	+ return false;
522	+ }
523	+
524	+ // Not own constructor property must be Object
525	+ if ( obj.constructor &&
526	+ !hasOwn.call(obj, "constructor") &&
527	+ !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
528	+ return false;
529	+ }
530	+
531	+ // Own properties are enumerated firstly, so to speed up,
532	+ // if last one is own, then all properties are own.
533	+
534	+ var key;
535	+ for ( key in obj ) {}
536	+
537	+ return key === undefined \|\| hasOwn.call( obj, key );
538	+ },
539	+
540	+ isEmptyObject: function( obj ) {
541	+ for ( var name in obj ) {
542	+ return false;
543	+ }
544	+ return true;
545	+ },
546	+
547	+ error: function( msg ) {
548	+ throw msg;
549	+ },
550	+
551	+ parseJSON: function( data ) {
552	+ if ( typeof data !== "string" \|\| !data ) {
553	+ return null;
554	+ }
555	+
556	+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
557	+ data = jQuery.trim( data );
558	+
559	+ // Attempt to parse using the native JSON parser first
560	+ if ( window.JSON && window.JSON.parse ) {
561	+ return window.JSON.parse( data );
562	+ }
563	+
564	+ // Make sure the incoming data is actual JSON
565	+ // Logic borrowed from http://json.org/json2.js
566	+ if ( rvalidchars.test( data.replace( rvalidescape, "@" )
567	+ .replace( rvalidtokens, "]" )
568	+ .replace( rvalidbraces, "")) ) {
569	+
570	+ return (new Function( "return " + data ))();
571	+
572	+ }
573	+ jQuery.error( "Invalid JSON: " + data );
574	+ },
575	+
576	+ // Cross-browser xml parsing
577	+ // (xml & tmp used internally)
578	+ parseXML: function( data , xml , tmp ) {
579	+
580	+ if ( window.DOMParser ) { // Standard
581	+ tmp = new DOMParser();
582	+ xml = tmp.parseFromString( data , "text/xml" );
583	+ } else { // IE
584	+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
585	+ xml.async = "false";
586	+ xml.loadXML( data );
587	+ }
588	+
589	+ tmp = xml.documentElement;
590	+
591	+ if ( ! tmp \|\| ! tmp.nodeName \|\| tmp.nodeName === "parsererror" ) {
592	+ jQuery.error( "Invalid XML: " + data );
593	+ }
594	+
595	+ return xml;
596	+ },
597	+
598	+ noop: function() {},
599	+
600	+ // Evaluates a script in a global context
601	+ // Workarounds based on findings by Jim Driscoll
602	+ // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
603	+ globalEval: function( data ) {
604	+ if ( data && rnotwhite.test( data ) ) {
605	+ // We use execScript on Internet Explorer
606	+ // We use an anonymous function so that context is window
607	+ // rather than jQuery in Firefox
608	+ ( window.execScript \|\| function( data ) {
609	+ window[ "eval" ].call( window, data );
610	+ } )( data );
611	+ }
612	+ },
613	+
614	+ // Converts a dashed string to camelCased string;
615	+ // Used by both the css and data modules
616	+ camelCase: function( string ) {
617	+ return string.replace( rdashAlpha, fcamelCase );
618	+ },
619	+
620	+ nodeName: function( elem, name ) {
621	+ return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
622	+ },
623	+
624	+ // args is for internal usage only
625	+ each: function( object, callback, args ) {
626	+ var name, i = 0,
627	+ length = object.length,
628	+ isObj = length === undefined \|\| jQuery.isFunction( object );
629	+
630	+ if ( args ) {
631	+ if ( isObj ) {
632	+ for ( name in object ) {
633	+ if ( callback.apply( object[ name ], args ) === false ) {
634	+ break;
635	+ }
636	+ }
637	+ } else {
638	+ for ( ; i < length; ) {
639	+ if ( callback.apply( object[ i++ ], args ) === false ) {
640	+ break;
641	+ }
642	+ }
643	+ }
644	+
645	+ // A special, fast, case for the most common use of each
646	+ } else {
647	+ if ( isObj ) {
648	+ for ( name in object ) {
649	+ if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
650	+ break;
651	+ }
652	+ }
653	+ } else {
654	+ for ( ; i < length; ) {
655	+ if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
656	+ break;
657	+ }
658	+ }
659	+ }
660	+ }
661	+
662	+ return object;
663	+ },
664	+
665	+ // Use native String.trim function wherever possible
666	+ trim: trim ?
667	+ function( text ) {
668	+ return text == null ?
669	+ "" :
670	+ trim.call( text );
671	+ } :
672	+
673	+ // Otherwise use our own trimming functionality
674	+ function( text ) {
675	+ return text == null ?
676	+ "" :
677	+ text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
678	+ },
679	+
680	+ // results is for internal usage only
681	+ makeArray: function( array, results ) {
682	+ var ret = results \|\| [];
683	+
684	+ if ( array != null ) {
685	+ // The window, strings (and functions) also have 'length'
686	+ // The extra typeof function check is to prevent crashes
687	+ // in Safari 2 (See: #3039)
688	+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
689	+ var type = jQuery.type( array );
690	+
691	+ if ( array.length == null \|\| type === "string" \|\| type === "function" \|\| type === "regexp" \|\| jQuery.isWindow( array ) ) {
692	+ push.call( ret, array );
693	+ } else {
694	+ jQuery.merge( ret, array );
695	+ }
696	+ }
697	+
698	+ return ret;
699	+ },
700	+
701	+ inArray: function( elem, array ) {
702	+
703	+ if ( indexOf ) {
704	+ return indexOf.call( array, elem );
705	+ }
706	+
707	+ for ( var i = 0, length = array.length; i < length; i++ ) {
708	+ if ( array[ i ] === elem ) {
709	+ return i;
710	+ }
711	+ }
712	+
713	+ return -1;
714	+ },
715	+
716	+ merge: function( first, second ) {
717	+ var i = first.length,
718	+ j = 0;
719	+
720	+ if ( typeof second.length === "number" ) {
721	+ for ( var l = second.length; j < l; j++ ) {
722	+ first[ i++ ] = second[ j ];
723	+ }
724	+
725	+ } else {
726	+ while ( second[j] !== undefined ) {
727	+ first[ i++ ] = second[ j++ ];
728	+ }
729	+ }
730	+
731	+ first.length = i;
732	+
733	+ return first;
734	+ },
735	+
736	+ grep: function( elems, callback, inv ) {
737	+ var ret = [], retVal;
738	+ inv = !!inv;
739	+
740	+ // Go through the array, only saving the items
741	+ // that pass the validator function
742	+ for ( var i = 0, length = elems.length; i < length; i++ ) {
743	+ retVal = !!callback( elems[ i ], i );
744	+ if ( inv !== retVal ) {
745	+ ret.push( elems[ i ] );
746	+ }
747	+ }
748	+
749	+ return ret;
750	+ },
751	+
752	+ // arg is for internal usage only
753	+ map: function( elems, callback, arg ) {
754	+ var value, key, ret = [],
755	+ i = 0,
756	+ length = elems.length,
757	+ // jquery objects are treated as arrays
758	+ isArray = elems instanceof jQuery \|\| length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) \|\| length === 0 \|\| jQuery.isArray( elems ) ) ;
759	+
760	+ // Go through the array, translating each of the items to their
761	+ if ( isArray ) {
762	+ for ( ; i < length; i++ ) {
763	+ value = callback( elems[ i ], i, arg );
764	+
765	+ if ( value != null ) {
766	+ ret[ ret.length ] = value;
767	+ }
768	+ }
769	+
770	+ // Go through every key on the object,
771	+ } else {
772	+ for ( key in elems ) {
773	+ value = callback( elems[ key ], key, arg );
774	+
775	+ if ( value != null ) {
776	+ ret[ ret.length ] = value;
777	+ }
778	+ }
779	+ }
780	+
781	+ // Flatten any nested arrays
782	+ return ret.concat.apply( [], ret );
783	+ },
784	+
785	+ // A global GUID counter for objects
786	+ guid: 1,
787	+
788	+ // Bind a function to a context, optionally partially applying any
789	+ // arguments.
790	+ proxy: function( fn, context ) {
791	+ if ( typeof context === "string" ) {
792	+ var tmp = fn[ context ];
793	+ context = fn;
794	+ fn = tmp;
795	+ }
796	+
797	+ // Quick check to determine if target is callable, in the spec
798	+ // this throws a TypeError, but we will just return undefined.
799	+ if ( !jQuery.isFunction( fn ) ) {
800	+ return undefined;
801	+ }
802	+
803	+ // Simulated bind
804	+ var args = slice.call( arguments, 2 ),
805	+ proxy = function() {
806	+ return fn.apply( context, args.concat( slice.call( arguments ) ) );
807	+ };
808	+
809	+ // Set the guid of unique handler to the same of original handler, so it can be removed
810	+ proxy.guid = fn.guid = fn.guid \|\| proxy.guid \|\| jQuery.guid++;
811	+
812	+ return proxy;
813	+ },
814	+
815	+ // Mutifunctional method to get and set values to a collection
816	+ // The value/s can optionally be executed if it's a function
817	+ access: function( elems, key, value, exec, fn, pass ) {
818	+ var length = elems.length;
819	+
820	+ // Setting many attributes
821	+ if ( typeof key === "object" ) {
822	+ for ( var k in key ) {
823	+ jQuery.access( elems, k, key[k], exec, fn, value );
824	+ }
825	+ return elems;
826	+ }
827	+
828	+ // Setting one attribute
829	+ if ( value !== undefined ) {
830	+ // Optionally, function values get executed if exec is true
831	+ exec = !pass && exec && jQuery.isFunction(value);
832	+
833	+ for ( var i = 0; i < length; i++ ) {
834	+ fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
835	+ }
836	+
837	+ return elems;
838	+ }
839	+
840	+ // Getting an attribute
841	+ return length ? fn( elems[0], key ) : undefined;
842	+ },
843	+
844	+ now: function() {
845	+ return (new Date()).getTime();
846	+ },
847	+
848	+ // Use of jQuery.browser is frowned upon.
849	+ // More details: http://docs.jquery.com/Utilities/jQuery.browser
850	+ uaMatch: function( ua ) {
851	+ ua = ua.toLowerCase();
852	+
853	+ var match = rwebkit.exec( ua ) \|\|
854	+ ropera.exec( ua ) \|\|
855	+ rmsie.exec( ua ) \|\|
856	+ ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) \|\|
857	+ [];
858	+
859	+ return { browser: match[1] \|\| "", version: match[2] \|\| "0" };
860	+ },
861	+
862	+ sub: function() {
863	+ function jQuerySub( selector, context ) {
864	+ return new jQuerySub.fn.init( selector, context );
865	+ }
866	+ jQuery.extend( true, jQuerySub, this );
867	+ jQuerySub.superclass = this;
868	+ jQuerySub.fn = jQuerySub.prototype = this();
869	+ jQuerySub.fn.constructor = jQuerySub;
870	+ jQuerySub.sub = this.sub;
871	+ jQuerySub.fn.init = function init( selector, context ) {
872	+ if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
873	+ context = jQuerySub( context );
874	+ }
875	+
876	+ return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
877	+ };
878	+ jQuerySub.fn.init.prototype = jQuerySub.fn;
879	+ var rootjQuerySub = jQuerySub(document);
880	+ return jQuerySub;
881	+ },
882	+
883	+ browser: {}
884	+ });
885	+
886	+ // Populate the class2type map
887	+ jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
888	+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
889	+ });
890	+
891	+ browserMatch = jQuery.uaMatch( userAgent );
892	+ if ( browserMatch.browser ) {
893	+ jQuery.browser[ browserMatch.browser ] = true;
894	+ jQuery.browser.version = browserMatch.version;
895	+ }
896	+
897	+ // Deprecated, use jQuery.browser.webkit instead
898	+ if ( jQuery.browser.webkit ) {
899	+ jQuery.browser.safari = true;
900	+ }
901	+
902	+ // IE doesn't match non-breaking spaces with \s
903	+ if ( rnotwhite.test( "\xA0" ) ) {
904	+ trimLeft = /^[\s\xA0]+/;
905	+ trimRight = /[\s\xA0]+$/;
906	+ }
907	+
908	+ // All jQuery objects should point back to these
909	+ rootjQuery = jQuery(document);
910	+
911	+ // Cleanup functions for the document ready method
912	+ if ( document.addEventListener ) {
913	+ DOMContentLoaded = function() {
914	+ document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
915	+ jQuery.ready();
916	+ };
917	+
918	+ } else if ( document.attachEvent ) {
919	+ DOMContentLoaded = function() {
920	+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
921	+ if ( document.readyState === "complete" ) {
922	+ document.detachEvent( "onreadystatechange", DOMContentLoaded );
923	+ jQuery.ready();
924	+ }
925	+ };
926	+ }
927	+
928	+ // The DOM ready check for Internet Explorer
929	+ function doScrollCheck() {
930	+ if ( jQuery.isReady ) {
931	+ return;
932	+ }
933	+
934	+ try {
935	+ // If IE is used, use the trick by Diego Perini
936	+ // http://javascript.nwbox.com/IEContentLoaded/
937	+ document.documentElement.doScroll("left");
938	+ } catch(e) {
939	+ setTimeout( doScrollCheck, 1 );
940	+ return;
941	+ }
942	+
943	+ // and execute any waiting functions
944	+ jQuery.ready();
945	+ }
946	+
947	+ return jQuery;
948	+
949	+ })();
950	+
951	+
952	+ var // Promise methods
953	+ promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
954	+ // Static reference to slice
955	+ sliceDeferred = [].slice;
956	+
957	+ jQuery.extend({
958	+ // Create a simple deferred (one callbacks list)
959	+ _Deferred: function() {
960	+ var // callbacks list
961	+ callbacks = [],
962	+ // stored [ context , args ]
963	+ fired,
964	+ // to avoid firing when already doing so
965	+ firing,
966	+ // flag to know if the deferred has been cancelled
967	+ cancelled,
968	+ // the deferred itself
969	+ deferred = {
970	+
971	+ // done( f1, f2, ...)
972	+ done: function() {
973	+ if ( !cancelled ) {
974	+ var args = arguments,
975	+ i,
976	+ length,
977	+ elem,
978	+ type,
979	+ _fired;
980	+ if ( fired ) {
981	+ _fired = fired;
982	+ fired = 0;
983	+ }
984	+ for ( i = 0, length = args.length; i < length; i++ ) {
985	+ elem = args[ i ];
986	+ type = jQuery.type( elem );
987	+ if ( type === "array" ) {
988	+ deferred.done.apply( deferred, elem );
989	+ } else if ( type === "function" ) {
990	+ callbacks.push( elem );
991	+ }
992	+ }
993	+ if ( _fired ) {
994	+ deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
995	+ }
996	+ }
997	+ return this;
998	+ },
999	+
1000	+ // resolve with given context and args
1001	+ resolveWith: function( context, args ) {
1002	+ if ( !cancelled && !fired && !firing ) {
1003	+ // make sure args are available (#8421)
1004	+ args = args \|\| [];
1005	+ firing = 1;
1006	+ try {
1007	+ while( callbacks[ 0 ] ) {
1008	+ callbacks.shift().apply( context, args );
1009	+ }
1010	+ }
1011	+ finally {
1012	+ fired = [ context, args ];
1013	+ firing = 0;
1014	+ }
1015	+ }
1016	+ return this;
1017	+ },
1018	+
1019	+ // resolve with this as context and given arguments
1020	+ resolve: function() {
1021	+ deferred.resolveWith( this, arguments );
1022	+ return this;
1023	+ },
1024	+
1025	+ // Has this deferred been resolved?
1026	+ isResolved: function() {
1027	+ return !!( firing \|\| fired );
1028	+ },
1029	+
1030	+ // Cancel
1031	+ cancel: function() {
1032	+ cancelled = 1;
1033	+ callbacks = [];
1034	+ return this;
1035	+ }
1036	+ };
1037	+
1038	+ return deferred;
1039	+ },
1040	+
1041	+ // Full fledged deferred (two callbacks list)
1042	+ Deferred: function( func ) {
1043	+ var deferred = jQuery._Deferred(),
1044	+ failDeferred = jQuery._Deferred(),
1045	+ promise;
1046	+ // Add errorDeferred methods, then and promise
1047	+ jQuery.extend( deferred, {
1048	+ then: function( doneCallbacks, failCallbacks ) {
1049	+ deferred.done( doneCallbacks ).fail( failCallbacks );
1050	+ return this;
1051	+ },
1052	+ always: function() {
1053	+ return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1054	+ },
1055	+ fail: failDeferred.done,
1056	+ rejectWith: failDeferred.resolveWith,
1057	+ reject: failDeferred.resolve,
1058	+ isRejected: failDeferred.isResolved,
1059	+ pipe: function( fnDone, fnFail ) {
1060	+ return jQuery.Deferred(function( newDefer ) {
1061	+ jQuery.each( {
1062	+ done: [ fnDone, "resolve" ],
1063	+ fail: [ fnFail, "reject" ]
1064	+ }, function( handler, data ) {
1065	+ var fn = data[ 0 ],
1066	+ action = data[ 1 ],
1067	+ returned;
1068	+ if ( jQuery.isFunction( fn ) ) {
1069	+ deferred[ handler ](function() {
1070	+ returned = fn.apply( this, arguments );
1071	+ if ( returned && jQuery.isFunction( returned.promise ) ) {
1072	+ returned.promise().then( newDefer.resolve, newDefer.reject );
1073	+ } else {
1074	+ newDefer[ action ]( returned );
1075	+ }
1076	+ });
1077	+ } else {
1078	+ deferred[ handler ]( newDefer[ action ] );
1079	+ }
1080	+ });
1081	+ }).promise();
1082	+ },
1083	+ // Get a promise for this deferred
1084	+ // If obj is provided, the promise aspect is added to the object
1085	+ promise: function( obj ) {
1086	+ if ( obj == null ) {
1087	+ if ( promise ) {
1088	+ return promise;
1089	+ }
1090	+ promise = obj = {};
1091	+ }
1092	+ var i = promiseMethods.length;
1093	+ while( i-- ) {
1094	+ obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1095	+ }
1096	+ return obj;
1097	+ }
1098	+ });
1099	+ // Make sure only one callback list will be used
1100	+ deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1101	+ // Unexpose cancel
1102	+ delete deferred.cancel;
1103	+ // Call given func if any
1104	+ if ( func ) {
1105	+ func.call( deferred, deferred );
1106	+ }
1107	+ return deferred;
1108	+ },
1109	+
1110	+ // Deferred helper
1111	+ when: function( firstParam ) {
1112	+ var args = arguments,
1113	+ i = 0,
1114	+ length = args.length,
1115	+ count = length,
1116	+ deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1117	+ firstParam :
1118	+ jQuery.Deferred();
1119	+ function resolveFunc( i ) {
1120	+ return function( value ) {
1121	+ args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1122	+ if ( !( --count ) ) {
1123	+ // Strange bug in FF4:
1124	+ // Values changed onto the arguments object sometimes end up as undefined values
1125	+ // outside the $.when method. Cloning the object into a fresh array solves the issue
1126	+ deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1127	+ }
1128	+ };
1129	+ }
1130	+ if ( length > 1 ) {
1131	+ for( ; i < length; i++ ) {
1132	+ if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1133	+ args[ i ].promise().then( resolveFunc(i), deferred.reject );
1134	+ } else {
1135	+ --count;
1136	+ }
1137	+ }
1138	+ if ( !count ) {
1139	+ deferred.resolveWith( deferred, args );
1140	+ }
1141	+ } else if ( deferred !== firstParam ) {
1142	+ deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1143	+ }
1144	+ return deferred.promise();
1145	+ }
1146	+ });
1147	+
1148	+
1149	+
1150	+ jQuery.support = (function() {
1151	+
1152	+ var div = document.createElement( "div" ),
1153	+ documentElement = document.documentElement,
1154	+ all,
1155	+ a,
1156	+ select,
1157	+ opt,
1158	+ input,
1159	+ marginDiv,
1160	+ support,
1161	+ fragment,
1162	+ body,
1163	+ testElementParent,
1164	+ testElement,
1165	+ testElementStyle,
1166	+ tds,
1167	+ events,
1168	+ eventName,
1169	+ i,
1170	+ isSupported;
1171	+
1172	+ // Preliminary tests
1173	+ div.setAttribute("className", "t");
1174	+ div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1175	+
1176	+ all = div.getElementsByTagName( "*" );
1177	+ a = div.getElementsByTagName( "a" )[ 0 ];
1178	+
1179	+ // Can't get basic test support
1180	+ if ( !all \|\| !all.length \|\| !a ) {
1181	+ return {};
1182	+ }
1183	+
1184	+ // First batch of supports tests
1185	+ select = document.createElement( "select" );
1186	+ opt = select.appendChild( document.createElement("option") );
1187	+ input = div.getElementsByTagName( "input" )[ 0 ];
1188	+
1189	+ support = {
1190	+ // IE strips leading whitespace when .innerHTML is used
1191	+ leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1192	+
1193	+ // Make sure that tbody elements aren't automatically inserted
1194	+ // IE will insert them into empty tables
1195	+ tbody: !div.getElementsByTagName( "tbody" ).length,
1196	+
1197	+ // Make sure that link elements get serialized correctly by innerHTML
1198	+ // This requires a wrapper element in IE
1199	+ htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1200	+
1201	+ // Get the style information from getAttribute
1202	+ // (IE uses .cssText instead)
1203	+ style: /top/.test( a.getAttribute("style") ),
1204	+
1205	+ // Make sure that URLs aren't manipulated
1206	+ // (IE normalizes it by default)
1207	+ hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1208	+
1209	+ // Make sure that element opacity exists
1210	+ // (IE uses filter instead)
1211	+ // Use a regex to work around a WebKit issue. See #5145
1212	+ opacity: /^0.55$/.test( a.style.opacity ),
1213	+
1214	+ // Verify style float existence
1215	+ // (IE uses styleFloat instead of cssFloat)
1216	+ cssFloat: !!a.style.cssFloat,
1217	+
1218	+ // Make sure that if no value is specified for a checkbox
1219	+ // that it defaults to "on".
1220	+ // (WebKit defaults to "" instead)
1221	+ checkOn: ( input.value === "on" ),
1222	+
1223	+ // Make sure that a selected-by-default option has a working selected property.
1224	+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1225	+ optSelected: opt.selected,
1226	+
1227	+ // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1228	+ getSetAttribute: div.className !== "t",
1229	+
1230	+ // Will be defined later
1231	+ submitBubbles: true,
1232	+ changeBubbles: true,
1233	+ focusinBubbles: false,
1234	+ deleteExpando: true,
1235	+ noCloneEvent: true,
1236	+ inlineBlockNeedsLayout: false,
1237	+ shrinkWrapBlocks: false,
1238	+ reliableMarginRight: true
1239	+ };
1240	+
1241	+ // Make sure checked status is properly cloned
1242	+ input.checked = true;
1243	+ support.noCloneChecked = input.cloneNode( true ).checked;
1244	+
1245	+ // Make sure that the options inside disabled selects aren't marked as disabled
1246	+ // (WebKit marks them as disabled)
1247	+ select.disabled = true;
1248	+ support.optDisabled = !opt.disabled;
1249	+
1250	+ // Test to see if it's possible to delete an expando from an element
1251	+ // Fails in Internet Explorer
1252	+ try {
1253	+ delete div.test;
1254	+ } catch( e ) {
1255	+ support.deleteExpando = false;
1256	+ }
1257	+
1258	+ if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1259	+ div.attachEvent( "onclick", function() {
1260	+ // Cloning a node shouldn't copy over any
1261	+ // bound event handlers (IE does this)
1262	+ support.noCloneEvent = false;
1263	+ });
1264	+ div.cloneNode( true ).fireEvent( "onclick" );
1265	+ }
1266	+
1267	+ // Check if a radio maintains it's value
1268	+ // after being appended to the DOM
1269	+ input = document.createElement("input");
1270	+ input.value = "t";
1271	+ input.setAttribute("type", "radio");
1272	+ support.radioValue = input.value === "t";
1273	+
1274	+ input.setAttribute("checked", "checked");
1275	+ div.appendChild( input );
1276	+ fragment = document.createDocumentFragment();
1277	+ fragment.appendChild( div.firstChild );
1278	+
1279	+ // WebKit doesn't clone checked state correctly in fragments
1280	+ support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1281	+
1282	+ div.innerHTML = "";
1283	+
1284	+ // Figure out if the W3C box model works as expected
1285	+ div.style.width = div.style.paddingLeft = "1px";
1286	+
1287	+ body = document.getElementsByTagName( "body" )[ 0 ];
1288	+ // We use our own, invisible, body unless the body is already present
1289	+ // in which case we use a div (#9239)
1290	+ testElement = document.createElement( body ? "div" : "body" );
1291	+ testElementStyle = {
1292	+ visibility: "hidden",
1293	+ width: 0,
1294	+ height: 0,
1295	+ border: 0,
1296	+ margin: 0
1297	+ };
1298	+ if ( body ) {
1299	+ jQuery.extend( testElementStyle, {
1300	+ position: "absolute",
1301	+ left: -1000,
1302	+ top: -1000
1303	+ });
1304	+ }
1305	+ for ( i in testElementStyle ) {
1306	+ testElement.style[ i ] = testElementStyle[ i ];
1307	+ }
1308	+ testElement.appendChild( div );
1309	+ testElementParent = body \|\| documentElement;
1310	+ testElementParent.insertBefore( testElement, testElementParent.firstChild );
1311	+
1312	+ // Check if a disconnected checkbox will retain its checked
1313	+ // value of true after appended to the DOM (IE6/7)
1314	+ support.appendChecked = input.checked;
1315	+
1316	+ support.boxModel = div.offsetWidth === 2;
1317	+
1318	+ if ( "zoom" in div.style ) {
1319	+ // Check if natively block-level elements act like inline-block
1320	+ // elements when setting their display to 'inline' and giving
1321	+ // them layout
1322	+ // (IE < 8 does this)
1323	+ div.style.display = "inline";
1324	+ div.style.zoom = 1;
1325	+ support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1326	+
1327	+ // Check if elements with layout shrink-wrap their children
1328	+ // (IE 6 does this)
1329	+ div.style.display = "";
1330	+ div.innerHTML = "<div style='width:4px;'></div>";
1331	+ support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1332	+ }
1333	+
1334	+ div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1335	+ tds = div.getElementsByTagName( "td" );
1336	+
1337	+ // Check if table cells still have offsetWidth/Height when they are set
1338	+ // to display:none and there are still other visible table cells in a
1339	+ // table row; if so, offsetWidth/Height are not reliable for use when
1340	+ // determining if an element has been hidden directly using
1341	+ // display:none (it is still safe to use offsets if a parent element is
1342	+ // hidden; don safety goggles and see bug #4512 for more information).
1343	+ // (only IE 8 fails this test)
1344	+ isSupported = ( tds[ 0 ].offsetHeight === 0 );
1345	+
1346	+ tds[ 0 ].style.display = "";
1347	+ tds[ 1 ].style.display = "none";
1348	+
1349	+ // Check if empty table cells still have offsetWidth/Height
1350	+ // (IE < 8 fail this test)
1351	+ support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1352	+ div.innerHTML = "";
1353	+
1354	+ // Check if div with explicit width and no margin-right incorrectly
1355	+ // gets computed margin-right based on width of container. For more
1356	+ // info see bug #3333
1357	+ // Fails in WebKit before Feb 2011 nightlies
1358	+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1359	+ if ( document.defaultView && document.defaultView.getComputedStyle ) {
1360	+ marginDiv = document.createElement( "div" );
1361	+ marginDiv.style.width = "0";
1362	+ marginDiv.style.marginRight = "0";
1363	+ div.appendChild( marginDiv );
1364	+ support.reliableMarginRight =
1365	+ ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) \|\| { marginRight: 0 } ).marginRight, 10 ) \|\| 0 ) === 0;
1366	+ }
1367	+
1368	+ // Remove the body element we added
1369	+ testElement.innerHTML = "";
1370	+ testElementParent.removeChild( testElement );
1371	+
1372	+ // Technique from Juriy Zaytsev
1373	+ // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1374	+ // We only care about the case where non-standard event systems
1375	+ // are used, namely in IE. Short-circuiting here helps us to
1376	+ // avoid an eval call (in setAttribute) which can cause CSP
1377	+ // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1378	+ if ( div.attachEvent ) {
1379	+ for( i in {
1380	+ submit: 1,
1381	+ change: 1,
1382	+ focusin: 1
1383	+ } ) {
1384	+ eventName = "on" + i;
1385	+ isSupported = ( eventName in div );
1386	+ if ( !isSupported ) {
1387	+ div.setAttribute( eventName, "return;" );
1388	+ isSupported = ( typeof div[ eventName ] === "function" );
1389	+ }
1390	+ support[ i + "Bubbles" ] = isSupported;
1391	+ }
1392	+ }
1393	+
1394	+ // Null connected elements to avoid leaks in IE
1395	+ testElement = fragment = select = opt = body = marginDiv = div = input = null;
1396	+
1397	+ return support;
1398	+ })();
1399	+
1400	+ // Keep track of boxModel
1401	+ jQuery.boxModel = jQuery.support.boxModel;
1402	+
1403	+
1404	+
1405	+
1406	+ var rbrace = /^(?:\{.\}\|\[.\])$/,
1407	+ rmultiDash = /([a-z])([A-Z])/g;
1408	+
1409	+ jQuery.extend({
1410	+ cache: {},
1411	+
1412	+ // Please use with caution
1413	+ uuid: 0,
1414	+
1415	+ // Unique for each copy of jQuery on the page
1416	+ // Non-digits removed to match rinlinejQuery
1417	+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1418	+
1419	+ // The following elements throw uncatchable exceptions if you
1420	+ // attempt to add expando properties to them.
1421	+ noData: {
1422	+ "embed": true,
1423	+ // Ban all objects except for Flash (which handle expandos)
1424	+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1425	+ "applet": true
1426	+ },
1427	+
1428	+ hasData: function( elem ) {
1429	+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1430	+
1431	+ return !!elem && !isEmptyDataObject( elem );
1432	+ },
1433	+
1434	+ data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1435	+ if ( !jQuery.acceptData( elem ) ) {
1436	+ return;
1437	+ }
1438	+
1439	+ var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1440	+
1441	+ // We have to handle DOM nodes and JS objects differently because IE6-7
1442	+ // can't GC object references properly across the DOM-JS boundary
1443	+ isNode = elem.nodeType,
1444	+
1445	+ // Only DOM nodes need the global jQuery cache; JS object data is
1446	+ // attached directly to the object so GC can occur automatically
1447	+ cache = isNode ? jQuery.cache : elem,
1448	+
1449	+ // Only defining an ID for JS objects if its cache already exists allows
1450	+ // the code to shortcut on the same path as a DOM node with no cache
1451	+ id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1452	+
1453	+ // Avoid doing any more work than we need to when trying to get data on an
1454	+ // object that has no data at all
1455	+ if ( (!id \|\| (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1456	+ return;
1457	+ }
1458	+
1459	+ if ( !id ) {
1460	+ // Only DOM nodes need a new unique ID for each element since their data
1461	+ // ends up in the global cache
1462	+ if ( isNode ) {
1463	+ elem[ jQuery.expando ] = id = ++jQuery.uuid;
1464	+ } else {
1465	+ id = jQuery.expando;
1466	+ }
1467	+ }
1468	+
1469	+ if ( !cache[ id ] ) {
1470	+ cache[ id ] = {};
1471	+
1472	+ // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1473	+ // metadata on plain JS objects when the object is serialized using
1474	+ // JSON.stringify
1475	+ if ( !isNode ) {
1476	+ cache[ id ].toJSON = jQuery.noop;
1477	+ }
1478	+ }
1479	+
1480	+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
1481	+ // shallow copied over onto the existing cache
1482	+ if ( typeof name === "object" \|\| typeof name === "function" ) {
1483	+ if ( pvt ) {
1484	+ cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1485	+ } else {
1486	+ cache[ id ] = jQuery.extend(cache[ id ], name);
1487	+ }
1488	+ }
1489	+
1490	+ thisCache = cache[ id ];
1491	+
1492	+ // Internal jQuery data is stored in a separate object inside the object's data
1493	+ // cache in order to avoid key collisions between internal data and user-defined
1494	+ // data
1495	+ if ( pvt ) {
1496	+ if ( !thisCache[ internalKey ] ) {
1497	+ thisCache[ internalKey ] = {};
1498	+ }
1499	+
1500	+ thisCache = thisCache[ internalKey ];
1501	+ }
1502	+
1503	+ if ( data !== undefined ) {
1504	+ thisCache[ jQuery.camelCase( name ) ] = data;
1505	+ }
1506	+
1507	+ // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1508	+ // not attempt to inspect the internal events object using jQuery.data, as this
1509	+ // internal data object is undocumented and subject to change.
1510	+ if ( name === "events" && !thisCache[name] ) {
1511	+ return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1512	+ }
1513	+
1514	+ return getByName ?
1515	+ // Check for both converted-to-camel and non-converted data property names
1516	+ thisCache[ jQuery.camelCase( name ) ] \|\| thisCache[ name ] :
1517	+ thisCache;
1518	+ },
1519	+
1520	+ removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1521	+ if ( !jQuery.acceptData( elem ) ) {
1522	+ return;
1523	+ }
1524	+
1525	+ var internalKey = jQuery.expando, isNode = elem.nodeType,
1526	+
1527	+ // See jQuery.data for more information
1528	+ cache = isNode ? jQuery.cache : elem,
1529	+
1530	+ // See jQuery.data for more information
1531	+ id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1532	+
1533	+ // If there is already no cache entry for this object, there is no
1534	+ // purpose in continuing
1535	+ if ( !cache[ id ] ) {
1536	+ return;
1537	+ }
1538	+
1539	+ if ( name ) {
1540	+ var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1541	+
1542	+ if ( thisCache ) {
1543	+ delete thisCache[ name ];
1544	+
1545	+ // If there is no data left in the cache, we want to continue
1546	+ // and let the cache object itself get destroyed
1547	+ if ( !isEmptyDataObject(thisCache) ) {
1548	+ return;
1549	+ }
1550	+ }
1551	+ }
1552	+
1553	+ // See jQuery.data for more information
1554	+ if ( pvt ) {
1555	+ delete cache[ id ][ internalKey ];
1556	+
1557	+ // Don't destroy the parent cache unless the internal data object
1558	+ // had been the only thing left in it
1559	+ if ( !isEmptyDataObject(cache[ id ]) ) {
1560	+ return;
1561	+ }
1562	+ }
1563	+
1564	+ var internalCache = cache[ id ][ internalKey ];
1565	+
1566	+ // Browsers that fail expando deletion also refuse to delete expandos on
1567	+ // the window, but it will allow it on all other JS objects; other browsers
1568	+ // don't care
1569	+ if ( jQuery.support.deleteExpando \|\| cache != window ) {
1570	+ delete cache[ id ];
1571	+ } else {
1572	+ cache[ id ] = null;
1573	+ }
1574	+
1575	+ // We destroyed the entire user cache at once because it's faster than
1576	+ // iterating through each key, but we need to continue to persist internal
1577	+ // data if it existed
1578	+ if ( internalCache ) {
1579	+ cache[ id ] = {};
1580	+ // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1581	+ // metadata on plain JS objects when the object is serialized using
1582	+ // JSON.stringify
1583	+ if ( !isNode ) {
1584	+ cache[ id ].toJSON = jQuery.noop;
1585	+ }
1586	+
1587	+ cache[ id ][ internalKey ] = internalCache;
1588	+
1589	+ // Otherwise, we need to eliminate the expando on the node to avoid
1590	+ // false lookups in the cache for entries that no longer exist
1591	+ } else if ( isNode ) {
1592	+ // IE does not allow us to delete expando properties from nodes,
1593	+ // nor does it have a removeAttribute function on Document nodes;
1594	+ // we must handle all of these cases
1595	+ if ( jQuery.support.deleteExpando ) {
1596	+ delete elem[ jQuery.expando ];
1597	+ } else if ( elem.removeAttribute ) {
1598	+ elem.removeAttribute( jQuery.expando );
1599	+ } else {
1600	+ elem[ jQuery.expando ] = null;
1601	+ }
1602	+ }
1603	+ },
1604	+
1605	+ // For internal use only.
1606	+ _data: function( elem, name, data ) {
1607	+ return jQuery.data( elem, name, data, true );
1608	+ },
1609	+
1610	+ // A method for determining if a DOM node can handle the data expando
1611	+ acceptData: function( elem ) {
1612	+ if ( elem.nodeName ) {
1613	+ var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1614	+
1615	+ if ( match ) {
1616	+ return !(match === true \|\| elem.getAttribute("classid") !== match);
1617	+ }
1618	+ }
1619	+
1620	+ return true;
1621	+ }
1622	+ });
1623	+
1624	+ jQuery.fn.extend({
1625	+ data: function( key, value ) {
1626	+ var data = null;
1627	+
1628	+ if ( typeof key === "undefined" ) {
1629	+ if ( this.length ) {
1630	+ data = jQuery.data( this[0] );
1631	+
1632	+ if ( this[0].nodeType === 1 ) {
1633	+ var attr = this[0].attributes, name;
1634	+ for ( var i = 0, l = attr.length; i < l; i++ ) {
1635	+ name = attr[i].name;
1636	+
1637	+ if ( name.indexOf( "data-" ) === 0 ) {
1638	+ name = jQuery.camelCase( name.substring(5) );
1639	+
1640	+ dataAttr( this[0], name, data[ name ] );
1641	+ }
1642	+ }
1643	+ }
1644	+ }
1645	+
1646	+ return data;
1647	+
1648	+ } else if ( typeof key === "object" ) {
1649	+ return this.each(function() {
1650	+ jQuery.data( this, key );
1651	+ });
1652	+ }
1653	+
1654	+ var parts = key.split(".");
1655	+ parts[1] = parts[1] ? "." + parts[1] : "";
1656	+
1657	+ if ( value === undefined ) {
1658	+ data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1659	+
1660	+ // Try to fetch any internally stored data first
1661	+ if ( data === undefined && this.length ) {
1662	+ data = jQuery.data( this[0], key );
1663	+ data = dataAttr( this[0], key, data );
1664	+ }
1665	+
1666	+ return data === undefined && parts[1] ?
1667	+ this.data( parts[0] ) :
1668	+ data;
1669	+
1670	+ } else {
1671	+ return this.each(function() {
1672	+ var $this = jQuery( this ),
1673	+ args = [ parts[0], value ];
1674	+
1675	+ $this.triggerHandler( "setData" + parts[1] + "!", args );
1676	+ jQuery.data( this, key, value );
1677	+ $this.triggerHandler( "changeData" + parts[1] + "!", args );
1678	+ });
1679	+ }
1680	+ },
1681	+
1682	+ removeData: function( key ) {
1683	+ return this.each(function() {
1684	+ jQuery.removeData( this, key );
1685	+ });
1686	+ }
1687	+ });
1688	+
1689	+ function dataAttr( elem, key, data ) {
1690	+ // If nothing was found internally, try to fetch any
1691	+ // data from the HTML5 data-* attribute
1692	+ if ( data === undefined && elem.nodeType === 1 ) {
1693	+ var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
1694	+
1695	+ data = elem.getAttribute( name );
1696	+
1697	+ if ( typeof data === "string" ) {
1698	+ try {
1699	+ data = data === "true" ? true :
1700	+ data === "false" ? false :
1701	+ data === "null" ? null :
1702	+ !jQuery.isNaN( data ) ? parseFloat( data ) :
1703	+ rbrace.test( data ) ? jQuery.parseJSON( data ) :
1704	+ data;
1705	+ } catch( e ) {}
1706	+
1707	+ // Make sure we set the data so it isn't changed later
1708	+ jQuery.data( elem, key, data );
1709	+
1710	+ } else {
1711	+ data = undefined;
1712	+ }
1713	+ }
1714	+
1715	+ return data;
1716	+ }
1717	+
1718	+ // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1719	+ // property to be considered empty objects; this property always exists in
1720	+ // order to make sure JSON.stringify does not expose internal metadata
1721	+ function isEmptyDataObject( obj ) {
1722	+ for ( var name in obj ) {
1723	+ if ( name !== "toJSON" ) {
1724	+ return false;
1725	+ }
1726	+ }
1727	+
1728	+ return true;
1729	+ }
1730	+
1731	+
1732	+
1733	+
1734	+ function handleQueueMarkDefer( elem, type, src ) {
1735	+ var deferDataKey = type + "defer",
1736	+ queueDataKey = type + "queue",
1737	+ markDataKey = type + "mark",
1738	+ defer = jQuery.data( elem, deferDataKey, undefined, true );
1739	+ if ( defer &&
1740	+ ( src === "queue" \|\| !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1741	+ ( src === "mark" \|\| !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1742	+ // Give room for hard-coded callbacks to fire first
1743	+ // and eventually mark/queue something else on the element
1744	+ setTimeout( function() {
1745	+ if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1746	+ !jQuery.data( elem, markDataKey, undefined, true ) ) {
1747	+ jQuery.removeData( elem, deferDataKey, true );
1748	+ defer.resolve();
1749	+ }
1750	+ }, 0 );
1751	+ }
1752	+ }
1753	+
1754	+ jQuery.extend({
1755	+
1756	+ _mark: function( elem, type ) {
1757	+ if ( elem ) {
1758	+ type = (type \|\| "fx") + "mark";
1759	+ jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) \|\| 0) + 1, true );
1760	+ }
1761	+ },
1762	+
1763	+ _unmark: function( force, elem, type ) {
1764	+ if ( force !== true ) {
1765	+ type = elem;
1766	+ elem = force;
1767	+ force = false;
1768	+ }
1769	+ if ( elem ) {
1770	+ type = type \|\| "fx";
1771	+ var key = type + "mark",
1772	+ count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) \|\| 1 ) - 1 );
1773	+ if ( count ) {
1774	+ jQuery.data( elem, key, count, true );
1775	+ } else {
1776	+ jQuery.removeData( elem, key, true );
1777	+ handleQueueMarkDefer( elem, type, "mark" );
1778	+ }
1779	+ }
1780	+ },
1781	+
1782	+ queue: function( elem, type, data ) {
1783	+ if ( elem ) {
1784	+ type = (type \|\| "fx") + "queue";
1785	+ var q = jQuery.data( elem, type, undefined, true );
1786	+ // Speed up dequeue by getting out quickly if this is just a lookup
1787	+ if ( data ) {
1788	+ if ( !q \|\| jQuery.isArray(data) ) {
1789	+ q = jQuery.data( elem, type, jQuery.makeArray(data), true );
1790	+ } else {
1791	+ q.push( data );
1792	+ }
1793	+ }
1794	+ return q \|\| [];
1795	+ }
1796	+ },
1797	+
1798	+ dequeue: function( elem, type ) {
1799	+ type = type \|\| "fx";
1800	+
1801	+ var queue = jQuery.queue( elem, type ),
1802	+ fn = queue.shift(),
1803	+ defer;
1804	+
1805	+ // If the fx queue is dequeued, always remove the progress sentinel
1806	+ if ( fn === "inprogress" ) {
1807	+ fn = queue.shift();
1808	+ }
1809	+
1810	+ if ( fn ) {
1811	+ // Add a progress sentinel to prevent the fx queue from being
1812	+ // automatically dequeued
1813	+ if ( type === "fx" ) {
1814	+ queue.unshift("inprogress");
1815	+ }
1816	+
1817	+ fn.call(elem, function() {
1818	+ jQuery.dequeue(elem, type);
1819	+ });
1820	+ }
1821	+
1822	+ if ( !queue.length ) {
1823	+ jQuery.removeData( elem, type + "queue", true );
1824	+ handleQueueMarkDefer( elem, type, "queue" );
1825	+ }
1826	+ }
1827	+ });
1828	+
1829	+ jQuery.fn.extend({
1830	+ queue: function( type, data ) {
1831	+ if ( typeof type !== "string" ) {
1832	+ data = type;
1833	+ type = "fx";
1834	+ }
1835	+
1836	+ if ( data === undefined ) {
1837	+ return jQuery.queue( this[0], type );
1838	+ }
1839	+ return this.each(function() {
1840	+ var queue = jQuery.queue( this, type, data );
1841	+
1842	+ if ( type === "fx" && queue[0] !== "inprogress" ) {
1843	+ jQuery.dequeue( this, type );
1844	+ }
1845	+ });
1846	+ },
1847	+ dequeue: function( type ) {
1848	+ return this.each(function() {
1849	+ jQuery.dequeue( this, type );
1850	+ });
1851	+ },
1852	+ // Based off of the plugin by Clint Helfers, with permission.
1853	+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
1854	+ delay: function( time, type ) {
1855	+ time = jQuery.fx ? jQuery.fx.speeds[time] \|\| time : time;
1856	+ type = type \|\| "fx";
1857	+
1858	+ return this.queue( type, function() {
1859	+ var elem = this;
1860	+ setTimeout(function() {
1861	+ jQuery.dequeue( elem, type );
1862	+ }, time );
1863	+ });
1864	+ },
1865	+ clearQueue: function( type ) {
1866	+ return this.queue( type \|\| "fx", [] );
1867	+ },
1868	+ // Get a promise resolved when queues of a certain type
1869	+ // are emptied (fx is the type by default)
1870	+ promise: function( type, object ) {
1871	+ if ( typeof type !== "string" ) {
1872	+ object = type;
1873	+ type = undefined;
1874	+ }
1875	+ type = type \|\| "fx";
1876	+ var defer = jQuery.Deferred(),
1877	+ elements = this,
1878	+ i = elements.length,
1879	+ count = 1,
1880	+ deferDataKey = type + "defer",
1881	+ queueDataKey = type + "queue",
1882	+ markDataKey = type + "mark",
1883	+ tmp;
1884	+ function resolve() {
1885	+ if ( !( --count ) ) {
1886	+ defer.resolveWith( elements, [ elements ] );
1887	+ }
1888	+ }
1889	+ while( i-- ) {
1890	+ if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) \|\|
1891	+ ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) \|\|
1892	+ jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1893	+ jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
1894	+ count++;
1895	+ tmp.done( resolve );
1896	+ }
1897	+ }
1898	+ resolve();
1899	+ return defer.promise();
1900	+ }
1901	+ });
1902	+
1903	+
1904	+
1905	+
1906	+ var rclass = /[\n\t\r]/g,
1907	+ rspace = /\s+/,
1908	+ rreturn = /\r/g,
1909	+ rtype = /^(?:button\|input)$/i,
1910	+ rfocusable = /^(?:button\|input\|object\|select\|textarea)$/i,
1911	+ rclickable = /^a(?:rea)?$/i,
1912	+ rboolean = /^(?:autofocus\|autoplay\|async\|checked\|controls\|defer\|disabled\|hidden\|loop\|multiple\|open\|readonly\|required\|scoped\|selected)$/i,
1913	+ rinvalidChar = /\:\|^on/,
1914	+ formHook, boolHook;
1915	+
1916	+ jQuery.fn.extend({
1917	+ attr: function( name, value ) {
1918	+ return jQuery.access( this, name, value, true, jQuery.attr );
1919	+ },
1920	+
1921	+ removeAttr: function( name ) {
1922	+ return this.each(function() {
1923	+ jQuery.removeAttr( this, name );
1924	+ });
1925	+ },
1926	+
1927	+ prop: function( name, value ) {
1928	+ return jQuery.access( this, name, value, true, jQuery.prop );
1929	+ },
1930	+
1931	+ removeProp: function( name ) {
1932	+ name = jQuery.propFix[ name ] \|\| name;
1933	+ return this.each(function() {
1934	+ // try/catch handles cases where IE balks (such as removing a property on window)
1935	+ try {
1936	+ this[ name ] = undefined;
1937	+ delete this[ name ];
1938	+ } catch( e ) {}
1939	+ });
1940	+ },
1941	+
1942	+ addClass: function( value ) {
1943	+ var classNames, i, l, elem,
1944	+ setClass, c, cl;
1945	+
1946	+ if ( jQuery.isFunction( value ) ) {
1947	+ return this.each(function( j ) {
1948	+ jQuery( this ).addClass( value.call(this, j, this.className) );
1949	+ });
1950	+ }
1951	+
1952	+ if ( value && typeof value === "string" ) {
1953	+ classNames = value.split( rspace );
1954	+
1955	+ for ( i = 0, l = this.length; i < l; i++ ) {
1956	+ elem = this[ i ];
1957	+
1958	+ if ( elem.nodeType === 1 ) {
1959	+ if ( !elem.className && classNames.length === 1 ) {
1960	+ elem.className = value;
1961	+
1962	+ } else {
1963	+ setClass = " " + elem.className + " ";
1964	+
1965	+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
1966	+ if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
1967	+ setClass += classNames[ c ] + " ";
1968	+ }
1969	+ }
1970	+ elem.className = jQuery.trim( setClass );
1971	+ }
1972	+ }
1973	+ }
1974	+ }
1975	+
1976	+ return this;
1977	+ },
1978	+
1979	+ removeClass: function( value ) {
1980	+ var classNames, i, l, elem, className, c, cl;
1981	+
1982	+ if ( jQuery.isFunction( value ) ) {
1983	+ return this.each(function( j ) {
1984	+ jQuery( this ).removeClass( value.call(this, j, this.className) );
1985	+ });
1986	+ }
1987	+
1988	+ if ( (value && typeof value === "string") \|\| value === undefined ) {
1989	+ classNames = (value \|\| "").split( rspace );
1990	+
1991	+ for ( i = 0, l = this.length; i < l; i++ ) {
1992	+ elem = this[ i ];
1993	+
1994	+ if ( elem.nodeType === 1 && elem.className ) {
1995	+ if ( value ) {
1996	+ className = (" " + elem.className + " ").replace( rclass, " " );
1997	+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
1998	+ className = className.replace(" " + classNames[ c ] + " ", " ");
1999	+ }
2000	+ elem.className = jQuery.trim( className );
2001	+
2002	+ } else {
2003	+ elem.className = "";
2004	+ }
2005	+ }
2006	+ }
2007	+ }
2008	+
2009	+ return this;
2010	+ },
2011	+
2012	+ toggleClass: function( value, stateVal ) {
2013	+ var type = typeof value,
2014	+ isBool = typeof stateVal === "boolean";
2015	+
2016	+ if ( jQuery.isFunction( value ) ) {
2017	+ return this.each(function( i ) {
2018	+ jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2019	+ });
2020	+ }
2021	+
2022	+ return this.each(function() {
2023	+ if ( type === "string" ) {
2024	+ // toggle individual class names
2025	+ var className,
2026	+ i = 0,
2027	+ self = jQuery( this ),
2028	+ state = stateVal,
2029	+ classNames = value.split( rspace );
2030	+
2031	+ while ( (className = classNames[ i++ ]) ) {
2032	+ // check each className given, space seperated list
2033	+ state = isBool ? state : !self.hasClass( className );
2034	+ self[ state ? "addClass" : "removeClass" ]( className );
2035	+ }
2036	+
2037	+ } else if ( type === "undefined" \|\| type === "boolean" ) {
2038	+ if ( this.className ) {
2039	+ // store className if set
2040	+ jQuery._data( this, "__className__", this.className );
2041	+ }
2042	+
2043	+ // toggle whole className
2044	+ this.className = this.className \|\| value === false ? "" : jQuery._data( this, "__className__" ) \|\| "";
2045	+ }
2046	+ });
2047	+ },
2048	+
2049	+ hasClass: function( selector ) {
2050	+ var className = " " + selector + " ";
2051	+ for ( var i = 0, l = this.length; i < l; i++ ) {
2052	+ if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2053	+ return true;
2054	+ }
2055	+ }
2056	+
2057	+ return false;
2058	+ },
2059	+
2060	+ val: function( value ) {
2061	+ var hooks, ret,
2062	+ elem = this[0];
2063	+
2064	+ if ( !arguments.length ) {
2065	+ if ( elem ) {
2066	+ hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] \|\| jQuery.valHooks[ elem.type ];
2067	+
2068	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2069	+ return ret;
2070	+ }
2071	+
2072	+ ret = elem.value;
2073	+
2074	+ return typeof ret === "string" ?
2075	+ // handle most common string cases
2076	+ ret.replace(rreturn, "") :
2077	+ // handle cases where value is null/undef or number
2078	+ ret == null ? "" : ret;
2079	+ }
2080	+
2081	+ return undefined;
2082	+ }
2083	+
2084	+ var isFunction = jQuery.isFunction( value );
2085	+
2086	+ return this.each(function( i ) {
2087	+ var self = jQuery(this), val;
2088	+
2089	+ if ( this.nodeType !== 1 ) {
2090	+ return;
2091	+ }
2092	+
2093	+ if ( isFunction ) {
2094	+ val = value.call( this, i, self.val() );
2095	+ } else {
2096	+ val = value;
2097	+ }
2098	+
2099	+ // Treat null/undefined as ""; convert numbers to string
2100	+ if ( val == null ) {
2101	+ val = "";
2102	+ } else if ( typeof val === "number" ) {
2103	+ val += "";
2104	+ } else if ( jQuery.isArray( val ) ) {
2105	+ val = jQuery.map(val, function ( value ) {
2106	+ return value == null ? "" : value + "";
2107	+ });
2108	+ }
2109	+
2110	+ hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] \|\| jQuery.valHooks[ this.type ];
2111	+
2112	+ // If set returns undefined, fall back to normal setting
2113	+ if ( !hooks \|\| !("set" in hooks) \|\| hooks.set( this, val, "value" ) === undefined ) {
2114	+ this.value = val;
2115	+ }
2116	+ });
2117	+ }
2118	+ });
2119	+
2120	+ jQuery.extend({
2121	+ valHooks: {
2122	+ option: {
2123	+ get: function( elem ) {
2124	+ // attributes.value is undefined in Blackberry 4.7 but
2125	+ // uses .value. See #6932
2126	+ var val = elem.attributes.value;
2127	+ return !val \|\| val.specified ? elem.value : elem.text;
2128	+ }
2129	+ },
2130	+ select: {
2131	+ get: function( elem ) {
2132	+ var value,
2133	+ index = elem.selectedIndex,
2134	+ values = [],
2135	+ options = elem.options,
2136	+ one = elem.type === "select-one";
2137	+
2138	+ // Nothing was selected
2139	+ if ( index < 0 ) {
2140	+ return null;
2141	+ }
2142	+
2143	+ // Loop through all the selected options
2144	+ for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2145	+ var option = options[ i ];
2146	+
2147	+ // Don't return options that are disabled or in a disabled optgroup
2148	+ if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2149	+ (!option.parentNode.disabled \|\| !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2150	+
2151	+ // Get the specific value for the option
2152	+ value = jQuery( option ).val();
2153	+
2154	+ // We don't need an array for one selects
2155	+ if ( one ) {
2156	+ return value;
2157	+ }
2158	+
2159	+ // Multi-Selects return an array
2160	+ values.push( value );
2161	+ }
2162	+ }
2163	+
2164	+ // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2165	+ if ( one && !values.length && options.length ) {
2166	+ return jQuery( options[ index ] ).val();
2167	+ }
2168	+
2169	+ return values;
2170	+ },
2171	+
2172	+ set: function( elem, value ) {
2173	+ var values = jQuery.makeArray( value );
2174	+
2175	+ jQuery(elem).find("option").each(function() {
2176	+ this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2177	+ });
2178	+
2179	+ if ( !values.length ) {
2180	+ elem.selectedIndex = -1;
2181	+ }
2182	+ return values;
2183	+ }
2184	+ }
2185	+ },
2186	+
2187	+ attrFn: {
2188	+ val: true,
2189	+ css: true,
2190	+ html: true,
2191	+ text: true,
2192	+ data: true,
2193	+ width: true,
2194	+ height: true,
2195	+ offset: true
2196	+ },
2197	+
2198	+ attrFix: {
2199	+ // Always normalize to ensure hook usage
2200	+ tabindex: "tabIndex"
2201	+ },
2202	+
2203	+ attr: function( elem, name, value, pass ) {
2204	+ var nType = elem.nodeType;
2205	+
2206	+ // don't get/set attributes on text, comment and attribute nodes
2207	+ if ( !elem \|\| nType === 3 \|\| nType === 8 \|\| nType === 2 ) {
2208	+ return undefined;
2209	+ }
2210	+
2211	+ if ( pass && name in jQuery.attrFn ) {
2212	+ return jQuery( elem )[ name ]( value );
2213	+ }
2214	+
2215	+ // Fallback to prop when attributes are not supported
2216	+ if ( !("getAttribute" in elem) ) {
2217	+ return jQuery.prop( elem, name, value );
2218	+ }
2219	+
2220	+ var ret, hooks,
2221	+ notxml = nType !== 1 \|\| !jQuery.isXMLDoc( elem );
2222	+
2223	+ // Normalize the name if needed
2224	+ if ( notxml ) {
2225	+ name = jQuery.attrFix[ name ] \|\| name;
2226	+
2227	+ hooks = jQuery.attrHooks[ name ];
2228	+
2229	+ if ( !hooks ) {
2230	+ // Use boolHook for boolean attributes
2231	+ if ( rboolean.test( name ) ) {
2232	+
2233	+ hooks = boolHook;
2234	+
2235	+ // Use formHook for forms and if the name contains certain characters
2236	+ } else if ( formHook && name !== "className" &&
2237	+ (jQuery.nodeName( elem, "form" ) \|\| rinvalidChar.test( name )) ) {
2238	+
2239	+ hooks = formHook;
2240	+ }
2241	+ }
2242	+ }
2243	+
2244	+ if ( value !== undefined ) {
2245	+
2246	+ if ( value === null ) {
2247	+ jQuery.removeAttr( elem, name );
2248	+ return undefined;
2249	+
2250	+ } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2251	+ return ret;
2252	+
2253	+ } else {
2254	+ elem.setAttribute( name, "" + value );
2255	+ return value;
2256	+ }
2257	+
2258	+ } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2259	+ return ret;
2260	+
2261	+ } else {
2262	+
2263	+ ret = elem.getAttribute( name );
2264	+
2265	+ // Non-existent attributes return null, we normalize to undefined
2266	+ return ret === null ?
2267	+ undefined :
2268	+ ret;
2269	+ }
2270	+ },
2271	+
2272	+ removeAttr: function( elem, name ) {
2273	+ var propName;
2274	+ if ( elem.nodeType === 1 ) {
2275	+ name = jQuery.attrFix[ name ] \|\| name;
2276	+
2277	+ if ( jQuery.support.getSetAttribute ) {
2278	+ // Use removeAttribute in browsers that support it
2279	+ elem.removeAttribute( name );
2280	+ } else {
2281	+ jQuery.attr( elem, name, "" );
2282	+ elem.removeAttributeNode( elem.getAttributeNode( name ) );
2283	+ }
2284	+
2285	+ // Set corresponding property to false for boolean attributes
2286	+ if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] \|\| name) in elem ) {
2287	+ elem[ propName ] = false;
2288	+ }
2289	+ }
2290	+ },
2291	+
2292	+ attrHooks: {
2293	+ type: {
2294	+ set: function( elem, value ) {
2295	+ // We can't allow the type property to be changed (since it causes problems in IE)
2296	+ if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2297	+ jQuery.error( "type property can't be changed" );
2298	+ } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2299	+ // Setting the type on a radio button after the value resets the value in IE6-9
2300	+ // Reset value to it's default in case type is set after value
2301	+ // This is for element creation
2302	+ var val = elem.value;
2303	+ elem.setAttribute( "type", value );
2304	+ if ( val ) {
2305	+ elem.value = val;
2306	+ }
2307	+ return value;
2308	+ }
2309	+ }
2310	+ },
2311	+ tabIndex: {
2312	+ get: function( elem ) {
2313	+ // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2314	+ // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2315	+ var attributeNode = elem.getAttributeNode("tabIndex");
2316	+
2317	+ return attributeNode && attributeNode.specified ?
2318	+ parseInt( attributeNode.value, 10 ) :
2319	+ rfocusable.test( elem.nodeName ) \|\| rclickable.test( elem.nodeName ) && elem.href ?
2320	+ 0 :
2321	+ undefined;
2322	+ }
2323	+ },
2324	+ // Use the value property for back compat
2325	+ // Use the formHook for button elements in IE6/7 (#1954)
2326	+ value: {
2327	+ get: function( elem, name ) {
2328	+ if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2329	+ return formHook.get( elem, name );
2330	+ }
2331	+ return name in elem ?
2332	+ elem.value :
2333	+ null;
2334	+ },
2335	+ set: function( elem, value, name ) {
2336	+ if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2337	+ return formHook.set( elem, value, name );
2338	+ }
2339	+ // Does not return so that setAttribute is also used
2340	+ elem.value = value;
2341	+ }
2342	+ }
2343	+ },
2344	+
2345	+ propFix: {
2346	+ tabindex: "tabIndex",
2347	+ readonly: "readOnly",
2348	+ "for": "htmlFor",
2349	+ "class": "className",
2350	+ maxlength: "maxLength",
2351	+ cellspacing: "cellSpacing",
2352	+ cellpadding: "cellPadding",
2353	+ rowspan: "rowSpan",
2354	+ colspan: "colSpan",
2355	+ usemap: "useMap",
2356	+ frameborder: "frameBorder",
2357	+ contenteditable: "contentEditable"
2358	+ },
2359	+
2360	+ prop: function( elem, name, value ) {
2361	+ var nType = elem.nodeType;
2362	+
2363	+ // don't get/set properties on text, comment and attribute nodes
2364	+ if ( !elem \|\| nType === 3 \|\| nType === 8 \|\| nType === 2 ) {
2365	+ return undefined;
2366	+ }
2367	+
2368	+ var ret, hooks,
2369	+ notxml = nType !== 1 \|\| !jQuery.isXMLDoc( elem );
2370	+
2371	+ if ( notxml ) {
2372	+ // Fix name and attach hooks
2373	+ name = jQuery.propFix[ name ] \|\| name;
2374	+ hooks = jQuery.propHooks[ name ];
2375	+ }
2376	+
2377	+ if ( value !== undefined ) {
2378	+ if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2379	+ return ret;
2380	+
2381	+ } else {
2382	+ return (elem[ name ] = value);
2383	+ }
2384	+
2385	+ } else {
2386	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
2387	+ return ret;
2388	+
2389	+ } else {
2390	+ return elem[ name ];
2391	+ }
2392	+ }
2393	+ },
2394	+
2395	+ propHooks: {}
2396	+ });
2397	+
2398	+ // Hook for boolean attributes
2399	+ boolHook = {
2400	+ get: function( elem, name ) {
2401	+ // Align boolean attributes with corresponding properties
2402	+ return jQuery.prop( elem, name ) ?
2403	+ name.toLowerCase() :
2404	+ undefined;
2405	+ },
2406	+ set: function( elem, value, name ) {
2407	+ var propName;
2408	+ if ( value === false ) {
2409	+ // Remove boolean attributes when set to false
2410	+ jQuery.removeAttr( elem, name );
2411	+ } else {
2412	+ // value is true since we know at this point it's type boolean and not false
2413	+ // Set boolean attributes to the same name and set the DOM property
2414	+ propName = jQuery.propFix[ name ] \|\| name;
2415	+ if ( propName in elem ) {
2416	+ // Only set the IDL specifically if it already exists on the element
2417	+ elem[ propName ] = true;
2418	+ }
2419	+
2420	+ elem.setAttribute( name, name.toLowerCase() );
2421	+ }
2422	+ return name;
2423	+ }
2424	+ };
2425	+
2426	+ // IE6/7 do not support getting/setting some attributes with get/setAttribute
2427	+ if ( !jQuery.support.getSetAttribute ) {
2428	+
2429	+ // propFix is more comprehensive and contains all fixes
2430	+ jQuery.attrFix = jQuery.propFix;
2431	+
2432	+ // Use this for any attribute on a form in IE6/7
2433	+ formHook = jQuery.attrHooks.name = jQuery.attrHooks.title = jQuery.valHooks.button = {
2434	+ get: function( elem, name ) {
2435	+ var ret;
2436	+ ret = elem.getAttributeNode( name );
2437	+ // Return undefined if nodeValue is empty string
2438	+ return ret && ret.nodeValue !== "" ?
2439	+ ret.nodeValue :
2440	+ undefined;
2441	+ },
2442	+ set: function( elem, value, name ) {
2443	+ // Check form objects in IE (multiple bugs related)
2444	+ // Only use nodeValue if the attribute node exists on the form
2445	+ var ret = elem.getAttributeNode( name );
2446	+ if ( ret ) {
2447	+ ret.nodeValue = value;
2448	+ return value;
2449	+ }
2450	+ }
2451	+ };
2452	+
2453	+ // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2454	+ // This is for removals
2455	+ jQuery.each([ "width", "height" ], function( i, name ) {
2456	+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2457	+ set: function( elem, value ) {
2458	+ if ( value === "" ) {
2459	+ elem.setAttribute( name, "auto" );
2460	+ return value;
2461	+ }
2462	+ }
2463	+ });
2464	+ });
2465	+ }
2466	+
2467	+
2468	+ // Some attributes require a special call on IE
2469	+ if ( !jQuery.support.hrefNormalized ) {
2470	+ jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2471	+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2472	+ get: function( elem ) {
2473	+ var ret = elem.getAttribute( name, 2 );
2474	+ return ret === null ? undefined : ret;
2475	+ }
2476	+ });
2477	+ });
2478	+ }
2479	+
2480	+ if ( !jQuery.support.style ) {
2481	+ jQuery.attrHooks.style = {
2482	+ get: function( elem ) {
2483	+ // Return undefined in the case of empty string
2484	+ // Normalize to lowercase since IE uppercases css property names
2485	+ return elem.style.cssText.toLowerCase() \|\| undefined;
2486	+ },
2487	+ set: function( elem, value ) {
2488	+ return (elem.style.cssText = "" + value);
2489	+ }
2490	+ };
2491	+ }
2492	+
2493	+ // Safari mis-reports the default selected property of an option
2494	+ // Accessing the parent's selectedIndex property fixes it
2495	+ if ( !jQuery.support.optSelected ) {
2496	+ jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2497	+ get: function( elem ) {
2498	+ var parent = elem.parentNode;
2499	+
2500	+ if ( parent ) {
2501	+ parent.selectedIndex;
2502	+
2503	+ // Make sure that it also works with optgroups, see #5701
2504	+ if ( parent.parentNode ) {
2505	+ parent.parentNode.selectedIndex;
2506	+ }
2507	+ }
2508	+ }
2509	+ });
2510	+ }
2511	+
2512	+ // Radios and checkboxes getter/setter
2513	+ if ( !jQuery.support.checkOn ) {
2514	+ jQuery.each([ "radio", "checkbox" ], function() {
2515	+ jQuery.valHooks[ this ] = {
2516	+ get: function( elem ) {
2517	+ // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2518	+ return elem.getAttribute("value") === null ? "on" : elem.value;
2519	+ }
2520	+ };
2521	+ });
2522	+ }
2523	+ jQuery.each([ "radio", "checkbox" ], function() {
2524	+ jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2525	+ set: function( elem, value ) {
2526	+ if ( jQuery.isArray( value ) ) {
2527	+ return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2528	+ }
2529	+ }
2530	+ });
2531	+ });
2532	+
2533	+
2534	+
2535	+
2536	+ var rnamespaces = /\.(.*)$/,
2537	+ rformElems = /^(?:textarea\|input\|select)$/i,
2538	+ rperiod = /\./g,
2539	+ rspaces = / /g,
2540	+ rescape = /[^\w\s.\|`]/g,
2541	+ fcleanup = function( nm ) {
2542	+ return nm.replace(rescape, "\\$&");
2543	+ };
2544	+
2545	+ /*
2546	+ * A number of helper functions used for managing events.
2547	+ * Many of the ideas behind this code originated from
2548	+ * Dean Edwards' addEvent library.
2549	+ */
2550	+ jQuery.event = {
2551	+
2552	+ // Bind an event to an element
2553	+ // Original by Dean Edwards
2554	+ add: function( elem, types, handler, data ) {
2555	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 8 ) {
2556	+ return;
2557	+ }
2558	+
2559	+ if ( handler === false ) {
2560	+ handler = returnFalse;
2561	+ } else if ( !handler ) {
2562	+ // Fixes bug #7229. Fix recommended by jdalton
2563	+ return;
2564	+ }
2565	+
2566	+ var handleObjIn, handleObj;
2567	+
2568	+ if ( handler.handler ) {
2569	+ handleObjIn = handler;
2570	+ handler = handleObjIn.handler;
2571	+ }
2572	+
2573	+ // Make sure that the function being executed has a unique ID
2574	+ if ( !handler.guid ) {
2575	+ handler.guid = jQuery.guid++;
2576	+ }
2577	+
2578	+ // Init the element's event structure
2579	+ var elemData = jQuery._data( elem );
2580	+
2581	+ // If no elemData is found then we must be trying to bind to one of the
2582	+ // banned noData elements
2583	+ if ( !elemData ) {
2584	+ return;
2585	+ }
2586	+
2587	+ var events = elemData.events,
2588	+ eventHandle = elemData.handle;
2589	+
2590	+ if ( !events ) {
2591	+ elemData.events = events = {};
2592	+ }
2593	+
2594	+ if ( !eventHandle ) {
2595	+ elemData.handle = eventHandle = function( e ) {
2596	+ // Discard the second event of a jQuery.event.trigger() and
2597	+ // when an event is called after a page has unloaded
2598	+ return typeof jQuery !== "undefined" && (!e \|\| jQuery.event.triggered !== e.type) ?
2599	+ jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2600	+ undefined;
2601	+ };
2602	+ }
2603	+
2604	+ // Add elem as a property of the handle function
2605	+ // This is to prevent a memory leak with non-native events in IE.
2606	+ eventHandle.elem = elem;
2607	+
2608	+ // Handle multiple events separated by a space
2609	+ // jQuery(...).bind("mouseover mouseout", fn);
2610	+ types = types.split(" ");
2611	+
2612	+ var type, i = 0, namespaces;
2613	+
2614	+ while ( (type = types[ i++ ]) ) {
2615	+ handleObj = handleObjIn ?
2616	+ jQuery.extend({}, handleObjIn) :
2617	+ { handler: handler, data: data };
2618	+
2619	+ // Namespaced event handlers
2620	+ if ( type.indexOf(".") > -1 ) {
2621	+ namespaces = type.split(".");
2622	+ type = namespaces.shift();
2623	+ handleObj.namespace = namespaces.slice(0).sort().join(".");
2624	+
2625	+ } else {
2626	+ namespaces = [];
2627	+ handleObj.namespace = "";
2628	+ }
2629	+
2630	+ handleObj.type = type;
2631	+ if ( !handleObj.guid ) {
2632	+ handleObj.guid = handler.guid;
2633	+ }
2634	+
2635	+ // Get the current list of functions bound to this event
2636	+ var handlers = events[ type ],
2637	+ special = jQuery.event.special[ type ] \|\| {};
2638	+
2639	+ // Init the event handler queue
2640	+ if ( !handlers ) {
2641	+ handlers = events[ type ] = [];
2642	+
2643	+ // Check for a special event handler
2644	+ // Only use addEventListener/attachEvent if the special
2645	+ // events handler returns false
2646	+ if ( !special.setup \|\| special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2647	+ // Bind the global event handler to the element
2648	+ if ( elem.addEventListener ) {
2649	+ elem.addEventListener( type, eventHandle, false );
2650	+
2651	+ } else if ( elem.attachEvent ) {
2652	+ elem.attachEvent( "on" + type, eventHandle );
2653	+ }
2654	+ }
2655	+ }
2656	+
2657	+ if ( special.add ) {
2658	+ special.add.call( elem, handleObj );
2659	+
2660	+ if ( !handleObj.handler.guid ) {
2661	+ handleObj.handler.guid = handler.guid;
2662	+ }
2663	+ }
2664	+
2665	+ // Add the function to the element's handler list
2666	+ handlers.push( handleObj );
2667	+
2668	+ // Keep track of which events have been used, for event optimization
2669	+ jQuery.event.global[ type ] = true;
2670	+ }
2671	+
2672	+ // Nullify elem to prevent memory leaks in IE
2673	+ elem = null;
2674	+ },
2675	+
2676	+ global: {},
2677	+
2678	+ // Detach an event or set of events from an element
2679	+ remove: function( elem, types, handler, pos ) {
2680	+ // don't do events on text and comment nodes
2681	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 8 ) {
2682	+ return;
2683	+ }
2684	+
2685	+ if ( handler === false ) {
2686	+ handler = returnFalse;
2687	+ }
2688	+
2689	+ var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2690	+ elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2691	+ events = elemData && elemData.events;
2692	+
2693	+ if ( !elemData \|\| !events ) {
2694	+ return;
2695	+ }
2696	+
2697	+ // types is actually an event object here
2698	+ if ( types && types.type ) {
2699	+ handler = types.handler;
2700	+ types = types.type;
2701	+ }
2702	+
2703	+ // Unbind all events for the element
2704	+ if ( !types \|\| typeof types === "string" && types.charAt(0) === "." ) {
2705	+ types = types \|\| "";
2706	+
2707	+ for ( type in events ) {
2708	+ jQuery.event.remove( elem, type + types );
2709	+ }
2710	+
2711	+ return;
2712	+ }
2713	+
2714	+ // Handle multiple events separated by a space
2715	+ // jQuery(...).unbind("mouseover mouseout", fn);
2716	+ types = types.split(" ");
2717	+
2718	+ while ( (type = types[ i++ ]) ) {
2719	+ origType = type;
2720	+ handleObj = null;
2721	+ all = type.indexOf(".") < 0;
2722	+ namespaces = [];
2723	+
2724	+ if ( !all ) {
2725	+ // Namespaced event handlers
2726	+ namespaces = type.split(".");
2727	+ type = namespaces.shift();
2728	+
2729	+ namespace = new RegExp("(^\|\\.)" +
2730	+ jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.\|$)");
2731	+ }
2732	+
2733	+ eventType = events[ type ];
2734	+
2735	+ if ( !eventType ) {
2736	+ continue;
2737	+ }
2738	+
2739	+ if ( !handler ) {
2740	+ for ( j = 0; j < eventType.length; j++ ) {
2741	+ handleObj = eventType[ j ];
2742	+
2743	+ if ( all \|\| namespace.test( handleObj.namespace ) ) {
2744	+ jQuery.event.remove( elem, origType, handleObj.handler, j );
2745	+ eventType.splice( j--, 1 );
2746	+ }
2747	+ }
2748	+
2749	+ continue;
2750	+ }
2751	+
2752	+ special = jQuery.event.special[ type ] \|\| {};
2753	+
2754	+ for ( j = pos \|\| 0; j < eventType.length; j++ ) {
2755	+ handleObj = eventType[ j ];
2756	+
2757	+ if ( handler.guid === handleObj.guid ) {
2758	+ // remove the given handler for the given type
2759	+ if ( all \|\| namespace.test( handleObj.namespace ) ) {
2760	+ if ( pos == null ) {
2761	+ eventType.splice( j--, 1 );
2762	+ }
2763	+
2764	+ if ( special.remove ) {
2765	+ special.remove.call( elem, handleObj );
2766	+ }
2767	+ }
2768	+
2769	+ if ( pos != null ) {
2770	+ break;
2771	+ }
2772	+ }
2773	+ }
2774	+
2775	+ // remove generic event handler if no more handlers exist
2776	+ if ( eventType.length === 0 \|\| pos != null && eventType.length === 1 ) {
2777	+ if ( !special.teardown \|\| special.teardown.call( elem, namespaces ) === false ) {
2778	+ jQuery.removeEvent( elem, type, elemData.handle );
2779	+ }
2780	+
2781	+ ret = null;
2782	+ delete events[ type ];
2783	+ }
2784	+ }
2785	+
2786	+ // Remove the expando if it's no longer used
2787	+ if ( jQuery.isEmptyObject( events ) ) {
2788	+ var handle = elemData.handle;
2789	+ if ( handle ) {
2790	+ handle.elem = null;
2791	+ }
2792	+
2793	+ delete elemData.events;
2794	+ delete elemData.handle;
2795	+
2796	+ if ( jQuery.isEmptyObject( elemData ) ) {
2797	+ jQuery.removeData( elem, undefined, true );
2798	+ }
2799	+ }
2800	+ },
2801	+
2802	+ // Events that are safe to short-circuit if no handlers are attached.
2803	+ // Native DOM events should not be added, they may have inline handlers.
2804	+ customEvent: {
2805	+ "getData": true,
2806	+ "setData": true,
2807	+ "changeData": true
2808	+ },
2809	+
2810	+ trigger: function( event, data, elem, onlyHandlers ) {
2811	+ // Event object or event type
2812	+ var type = event.type \|\| event,
2813	+ namespaces = [],
2814	+ exclusive;
2815	+
2816	+ if ( type.indexOf("!") >= 0 ) {
2817	+ // Exclusive events trigger only for the exact event (no namespaces)
2818	+ type = type.slice(0, -1);
2819	+ exclusive = true;
2820	+ }
2821	+
2822	+ if ( type.indexOf(".") >= 0 ) {
2823	+ // Namespaced trigger; create a regexp to match event type in handle()
2824	+ namespaces = type.split(".");
2825	+ type = namespaces.shift();
2826	+ namespaces.sort();
2827	+ }
2828	+
2829	+ if ( (!elem \|\| jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2830	+ // No jQuery handlers for this event type, and it can't have inline handlers
2831	+ return;
2832	+ }
2833	+
2834	+ // Caller can pass in an Event, Object, or just an event type string
2835	+ event = typeof event === "object" ?
2836	+ // jQuery.Event object
2837	+ event[ jQuery.expando ] ? event :
2838	+ // Object literal
2839	+ new jQuery.Event( type, event ) :
2840	+ // Just the event type (string)
2841	+ new jQuery.Event( type );
2842	+
2843	+ event.type = type;
2844	+ event.exclusive = exclusive;
2845	+ event.namespace = namespaces.join(".");
2846	+ event.namespace_re = new RegExp("(^\|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.\|$)");
2847	+
2848	+ // triggerHandler() and global events don't bubble or run the default action
2849	+ if ( onlyHandlers \|\| !elem ) {
2850	+ event.preventDefault();
2851	+ event.stopPropagation();
2852	+ }
2853	+
2854	+ // Handle a global trigger
2855	+ if ( !elem ) {
2856	+ // TODO: Stop taunting the data cache; remove global events and always attach to document
2857	+ jQuery.each( jQuery.cache, function() {
2858	+ // internalKey variable is just used to make it easier to find
2859	+ // and potentially change this stuff later; currently it just
2860	+ // points to jQuery.expando
2861	+ var internalKey = jQuery.expando,
2862	+ internalCache = this[ internalKey ];
2863	+ if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2864	+ jQuery.event.trigger( event, data, internalCache.handle.elem );
2865	+ }
2866	+ });
2867	+ return;
2868	+ }
2869	+
2870	+ // Don't do events on text and comment nodes
2871	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 8 ) {
2872	+ return;
2873	+ }
2874	+
2875	+ // Clean up the event in case it is being reused
2876	+ event.result = undefined;
2877	+ event.target = elem;
2878	+
2879	+ // Clone any incoming data and prepend the event, creating the handler arg list
2880	+ data = data != null ? jQuery.makeArray( data ) : [];
2881	+ data.unshift( event );
2882	+
2883	+ var cur = elem,
2884	+ // IE doesn't like method names with a colon (#3533, #8272)
2885	+ ontype = type.indexOf(":") < 0 ? "on" + type : "";
2886	+
2887	+ // Fire event on the current element, then bubble up the DOM tree
2888	+ do {
2889	+ var handle = jQuery._data( cur, "handle" );
2890	+
2891	+ event.currentTarget = cur;
2892	+ if ( handle ) {
2893	+ handle.apply( cur, data );
2894	+ }
2895	+
2896	+ // Trigger an inline bound script
2897	+ if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
2898	+ event.result = false;
2899	+ event.preventDefault();
2900	+ }
2901	+
2902	+ // Bubble up to document, then to window
2903	+ cur = cur.parentNode \|\| cur.ownerDocument \|\| cur === event.target.ownerDocument && window;
2904	+ } while ( cur && !event.isPropagationStopped() );
2905	+
2906	+ // If nobody prevented the default action, do it now
2907	+ if ( !event.isDefaultPrevented() ) {
2908	+ var old,
2909	+ special = jQuery.event.special[ type ] \|\| {};
2910	+
2911	+ if ( (!special._default \|\| special._default.call( elem.ownerDocument, event ) === false) &&
2912	+ !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2913	+
2914	+ // Call a native DOM method on the target with the same name name as the event.
2915	+ // Can't use an .isFunction)() check here because IE6/7 fails that test.
2916	+ // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
2917	+ try {
2918	+ if ( ontype && elem[ type ] ) {
2919	+ // Don't re-trigger an onFOO event when we call its FOO() method
2920	+ old = elem[ ontype ];
2921	+
2922	+ if ( old ) {
2923	+ elem[ ontype ] = null;
2924	+ }
2925	+
2926	+ jQuery.event.triggered = type;
2927	+ elem[ type ]();
2928	+ }
2929	+ } catch ( ieError ) {}
2930	+
2931	+ if ( old ) {
2932	+ elem[ ontype ] = old;
2933	+ }
2934	+
2935	+ jQuery.event.triggered = undefined;
2936	+ }
2937	+ }
2938	+
2939	+ return event.result;
2940	+ },
2941	+
2942	+ handle: function( event ) {
2943	+ event = jQuery.event.fix( event \|\| window.event );
2944	+ // Snapshot the handlers list since a called handler may add/remove events.
2945	+ var handlers = ((jQuery._data( this, "events" ) \|\| {})[ event.type ] \|\| []).slice(0),
2946	+ run_all = !event.exclusive && !event.namespace,
2947	+ args = Array.prototype.slice.call( arguments, 0 );
2948	+
2949	+ // Use the fix-ed Event rather than the (read-only) native event
2950	+ args[0] = event;
2951	+ event.currentTarget = this;
2952	+
2953	+ for ( var j = 0, l = handlers.length; j < l; j++ ) {
2954	+ var handleObj = handlers[ j ];
2955	+
2956	+ // Triggered event must 1) be non-exclusive and have no namespace, or
2957	+ // 2) have namespace(s) a subset or equal to those in the bound event.
2958	+ if ( run_all \|\| event.namespace_re.test( handleObj.namespace ) ) {
2959	+ // Pass in a reference to the handler function itself
2960	+ // So that we can later remove it
2961	+ event.handler = handleObj.handler;
2962	+ event.data = handleObj.data;
2963	+ event.handleObj = handleObj;
2964	+
2965	+ var ret = handleObj.handler.apply( this, args );
2966	+
2967	+ if ( ret !== undefined ) {
2968	+ event.result = ret;
2969	+ if ( ret === false ) {
2970	+ event.preventDefault();
2971	+ event.stopPropagation();
2972	+ }
2973	+ }
2974	+
2975	+ if ( event.isImmediatePropagationStopped() ) {
2976	+ break;
2977	+ }
2978	+ }
2979	+ }
2980	+ return event.result;
2981	+ },
2982	+
2983	+ props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2984	+
2985	+ fix: function( event ) {
2986	+ if ( event[ jQuery.expando ] ) {
2987	+ return event;
2988	+ }
2989	+
2990	+ // store a copy of the original event object
2991	+ // and "clone" to set read-only properties
2992	+ var originalEvent = event;
2993	+ event = jQuery.Event( originalEvent );
2994	+
2995	+ for ( var i = this.props.length, prop; i; ) {
2996	+ prop = this.props[ --i ];
2997	+ event[ prop ] = originalEvent[ prop ];
2998	+ }
2999	+
3000	+ // Fix target property, if necessary
3001	+ if ( !event.target ) {
3002	+ // Fixes #1925 where srcElement might not be defined either
3003	+ event.target = event.srcElement \|\| document;
3004	+ }
3005	+
3006	+ // check if target is a textnode (safari)
3007	+ if ( event.target.nodeType === 3 ) {
3008	+ event.target = event.target.parentNode;
3009	+ }
3010	+
3011	+ // Add relatedTarget, if necessary
3012	+ if ( !event.relatedTarget && event.fromElement ) {
3013	+ event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
3014	+ }
3015	+
3016	+ // Calculate pageX/Y if missing and clientX/Y available
3017	+ if ( event.pageX == null && event.clientX != null ) {
3018	+ var eventDocument = event.target.ownerDocument \|\| document,
3019	+ doc = eventDocument.documentElement,
3020	+ body = eventDocument.body;
3021	+
3022	+ event.pageX = event.clientX + (doc && doc.scrollLeft \|\| body && body.scrollLeft \|\| 0) - (doc && doc.clientLeft \|\| body && body.clientLeft \|\| 0);
3023	+ event.pageY = event.clientY + (doc && doc.scrollTop \|\| body && body.scrollTop \|\| 0) - (doc && doc.clientTop \|\| body && body.clientTop \|\| 0);
3024	+ }
3025	+
3026	+ // Add which for key events
3027	+ if ( event.which == null && (event.charCode != null \|\| event.keyCode != null) ) {
3028	+ event.which = event.charCode != null ? event.charCode : event.keyCode;
3029	+ }
3030	+
3031	+ // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
3032	+ if ( !event.metaKey && event.ctrlKey ) {
3033	+ event.metaKey = event.ctrlKey;
3034	+ }
3035	+
3036	+ // Add which for click: 1 === left; 2 === middle; 3 === right
3037	+ // Note: button is not normalized, so don't use it
3038	+ if ( !event.which && event.button !== undefined ) {
3039	+ event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
3040	+ }
3041	+
3042	+ return event;
3043	+ },
3044	+
3045	+ // Deprecated, use jQuery.guid instead
3046	+ guid: 1E8,
3047	+
3048	+ // Deprecated, use jQuery.proxy instead
3049	+ proxy: jQuery.proxy,
3050	+
3051	+ special: {
3052	+ ready: {
3053	+ // Make sure the ready event is setup
3054	+ setup: jQuery.bindReady,
3055	+ teardown: jQuery.noop
3056	+ },
3057	+
3058	+ live: {
3059	+ add: function( handleObj ) {
3060	+ jQuery.event.add( this,
3061	+ liveConvert( handleObj.origType, handleObj.selector ),
3062	+ jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
3063	+ },
3064	+
3065	+ remove: function( handleObj ) {
3066	+ jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
3067	+ }
3068	+ },
3069	+
3070	+ beforeunload: {
3071	+ setup: function( data, namespaces, eventHandle ) {
3072	+ // We only want to do this special case on windows
3073	+ if ( jQuery.isWindow( this ) ) {
3074	+ this.onbeforeunload = eventHandle;
3075	+ }
3076	+ },
3077	+
3078	+ teardown: function( namespaces, eventHandle ) {
3079	+ if ( this.onbeforeunload === eventHandle ) {
3080	+ this.onbeforeunload = null;
3081	+ }
3082	+ }
3083	+ }
3084	+ }
3085	+ };
3086	+
3087	+ jQuery.removeEvent = document.removeEventListener ?
3088	+ function( elem, type, handle ) {
3089	+ if ( elem.removeEventListener ) {
3090	+ elem.removeEventListener( type, handle, false );
3091	+ }
3092	+ } :
3093	+ function( elem, type, handle ) {
3094	+ if ( elem.detachEvent ) {
3095	+ elem.detachEvent( "on" + type, handle );
3096	+ }
3097	+ };
3098	+
3099	+ jQuery.Event = function( src, props ) {
3100	+ // Allow instantiation without the 'new' keyword
3101	+ if ( !this.preventDefault ) {
3102	+ return new jQuery.Event( src, props );
3103	+ }
3104	+
3105	+ // Event object
3106	+ if ( src && src.type ) {
3107	+ this.originalEvent = src;
3108	+ this.type = src.type;
3109	+
3110	+ // Events bubbling up the document may have been marked as prevented
3111	+ // by a handler lower down the tree; reflect the correct value.
3112	+ this.isDefaultPrevented = (src.defaultPrevented \|\| src.returnValue === false \|\|
3113	+ src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
3114	+
3115	+ // Event type
3116	+ } else {
3117	+ this.type = src;
3118	+ }
3119	+
3120	+ // Put explicitly provided properties onto the event object
3121	+ if ( props ) {
3122	+ jQuery.extend( this, props );
3123	+ }
3124	+
3125	+ // timeStamp is buggy for some events on Firefox(#3843)
3126	+ // So we won't rely on the native value
3127	+ this.timeStamp = jQuery.now();
3128	+
3129	+ // Mark it as fixed
3130	+ this[ jQuery.expando ] = true;
3131	+ };
3132	+
3133	+ function returnFalse() {
3134	+ return false;
3135	+ }
3136	+ function returnTrue() {
3137	+ return true;
3138	+ }
3139	+
3140	+ // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3141	+ // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3142	+ jQuery.Event.prototype = {
3143	+ preventDefault: function() {
3144	+ this.isDefaultPrevented = returnTrue;
3145	+
3146	+ var e = this.originalEvent;
3147	+ if ( !e ) {
3148	+ return;
3149	+ }
3150	+
3151	+ // if preventDefault exists run it on the original event
3152	+ if ( e.preventDefault ) {
3153	+ e.preventDefault();
3154	+
3155	+ // otherwise set the returnValue property of the original event to false (IE)
3156	+ } else {
3157	+ e.returnValue = false;
3158	+ }
3159	+ },
3160	+ stopPropagation: function() {
3161	+ this.isPropagationStopped = returnTrue;
3162	+
3163	+ var e = this.originalEvent;
3164	+ if ( !e ) {
3165	+ return;
3166	+ }
3167	+ // if stopPropagation exists run it on the original event
3168	+ if ( e.stopPropagation ) {
3169	+ e.stopPropagation();
3170	+ }
3171	+ // otherwise set the cancelBubble property of the original event to true (IE)
3172	+ e.cancelBubble = true;
3173	+ },
3174	+ stopImmediatePropagation: function() {
3175	+ this.isImmediatePropagationStopped = returnTrue;
3176	+ this.stopPropagation();
3177	+ },
3178	+ isDefaultPrevented: returnFalse,
3179	+ isPropagationStopped: returnFalse,
3180	+ isImmediatePropagationStopped: returnFalse
3181	+ };
3182	+
3183	+ // Checks if an event happened on an element within another element
3184	+ // Used in jQuery.event.special.mouseenter and mouseleave handlers
3185	+ var withinElement = function( event ) {
3186	+
3187	+ // Check if mouse(over\|out) are still within the same parent element
3188	+ var related = event.relatedTarget,
3189	+ inside = false,
3190	+ eventType = event.type;
3191	+
3192	+ event.type = event.data;
3193	+
3194	+ if ( related !== this ) {
3195	+
3196	+ if ( related ) {
3197	+ inside = jQuery.contains( this, related );
3198	+ }
3199	+
3200	+ if ( !inside ) {
3201	+
3202	+ jQuery.event.handle.apply( this, arguments );
3203	+
3204	+ event.type = eventType;
3205	+ }
3206	+ }
3207	+ },
3208	+
3209	+ // In case of event delegation, we only need to rename the event.type,
3210	+ // liveHandler will take care of the rest.
3211	+ delegate = function( event ) {
3212	+ event.type = event.data;
3213	+ jQuery.event.handle.apply( this, arguments );
3214	+ };
3215	+
3216	+ // Create mouseenter and mouseleave events
3217	+ jQuery.each({
3218	+ mouseenter: "mouseover",
3219	+ mouseleave: "mouseout"
3220	+ }, function( orig, fix ) {
3221	+ jQuery.event.special[ orig ] = {
3222	+ setup: function( data ) {
3223	+ jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
3224	+ },
3225	+ teardown: function( data ) {
3226	+ jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
3227	+ }
3228	+ };
3229	+ });
3230	+
3231	+ // submit delegation
3232	+ if ( !jQuery.support.submitBubbles ) {
3233	+
3234	+ jQuery.event.special.submit = {
3235	+ setup: function( data, namespaces ) {
3236	+ if ( !jQuery.nodeName( this, "form" ) ) {
3237	+ jQuery.event.add(this, "click.specialSubmit", function( e ) {
3238	+ var elem = e.target,
3239	+ type = elem.type;
3240	+
3241	+ if ( (type === "submit" \|\| type === "image") && jQuery( elem ).closest("form").length ) {
3242	+ trigger( "submit", this, arguments );
3243	+ }
3244	+ });
3245	+
3246	+ jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
3247	+ var elem = e.target,
3248	+ type = elem.type;
3249	+
3250	+ if ( (type === "text" \|\| type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
3251	+ trigger( "submit", this, arguments );
3252	+ }
3253	+ });
3254	+
3255	+ } else {
3256	+ return false;
3257	+ }
3258	+ },
3259	+
3260	+ teardown: function( namespaces ) {
3261	+ jQuery.event.remove( this, ".specialSubmit" );
3262	+ }
3263	+ };
3264	+
3265	+ }
3266	+
3267	+ // change delegation, happens here so we have bind.
3268	+ if ( !jQuery.support.changeBubbles ) {
3269	+
3270	+ var changeFilters,
3271	+
3272	+ getVal = function( elem ) {
3273	+ var type = elem.type, val = elem.value;
3274	+
3275	+ if ( type === "radio" \|\| type === "checkbox" ) {
3276	+ val = elem.checked;
3277	+
3278	+ } else if ( type === "select-multiple" ) {
3279	+ val = elem.selectedIndex > -1 ?
3280	+ jQuery.map( elem.options, function( elem ) {
3281	+ return elem.selected;
3282	+ }).join("-") :
3283	+ "";
3284	+
3285	+ } else if ( jQuery.nodeName( elem, "select" ) ) {
3286	+ val = elem.selectedIndex;
3287	+ }
3288	+
3289	+ return val;
3290	+ },
3291	+
3292	+ testChange = function testChange( e ) {
3293	+ var elem = e.target, data, val;
3294	+
3295	+ if ( !rformElems.test( elem.nodeName ) \|\| elem.readOnly ) {
3296	+ return;
3297	+ }
3298	+
3299	+ data = jQuery._data( elem, "_change_data" );
3300	+ val = getVal(elem);
3301	+
3302	+ // the current data will be also retrieved by beforeactivate
3303	+ if ( e.type !== "focusout" \|\| elem.type !== "radio" ) {
3304	+ jQuery._data( elem, "_change_data", val );
3305	+ }
3306	+
3307	+ if ( data === undefined \|\| val === data ) {
3308	+ return;
3309	+ }
3310	+
3311	+ if ( data != null \|\| val ) {
3312	+ e.type = "change";
3313	+ e.liveFired = undefined;
3314	+ jQuery.event.trigger( e, arguments[1], elem );
3315	+ }
3316	+ };
3317	+
3318	+ jQuery.event.special.change = {
3319	+ filters: {
3320	+ focusout: testChange,
3321	+
3322	+ beforedeactivate: testChange,
3323	+
3324	+ click: function( e ) {
3325	+ var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3326	+
3327	+ if ( type === "radio" \|\| type === "checkbox" \|\| jQuery.nodeName( elem, "select" ) ) {
3328	+ testChange.call( this, e );
3329	+ }
3330	+ },
3331	+
3332	+ // Change has to be called before submit
3333	+ // Keydown will be called before keypress, which is used in submit-event delegation
3334	+ keydown: function( e ) {
3335	+ var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3336	+
3337	+ if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) \|\|
3338	+ (e.keyCode === 32 && (type === "checkbox" \|\| type === "radio")) \|\|
3339	+ type === "select-multiple" ) {
3340	+ testChange.call( this, e );
3341	+ }
3342	+ },
3343	+
3344	+ // Beforeactivate happens also before the previous element is blurred
3345	+ // with this event you can't trigger a change event, but you can store
3346	+ // information
3347	+ beforeactivate: function( e ) {
3348	+ var elem = e.target;
3349	+ jQuery._data( elem, "_change_data", getVal(elem) );
3350	+ }
3351	+ },
3352	+
3353	+ setup: function( data, namespaces ) {
3354	+ if ( this.type === "file" ) {
3355	+ return false;
3356	+ }
3357	+
3358	+ for ( var type in changeFilters ) {
3359	+ jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
3360	+ }
3361	+
3362	+ return rformElems.test( this.nodeName );
3363	+ },
3364	+
3365	+ teardown: function( namespaces ) {
3366	+ jQuery.event.remove( this, ".specialChange" );
3367	+
3368	+ return rformElems.test( this.nodeName );
3369	+ }
3370	+ };
3371	+
3372	+ changeFilters = jQuery.event.special.change.filters;
3373	+
3374	+ // Handle when the input is .focus()'d
3375	+ changeFilters.focus = changeFilters.beforeactivate;
3376	+ }
3377	+
3378	+ function trigger( type, elem, args ) {
3379	+ // Piggyback on a donor event to simulate a different one.
3380	+ // Fake originalEvent to avoid donor's stopPropagation, but if the
3381	+ // simulated event prevents default then we do the same on the donor.
3382	+ // Don't pass args or remember liveFired; they apply to the donor event.
3383	+ var event = jQuery.extend( {}, args[ 0 ] );
3384	+ event.type = type;
3385	+ event.originalEvent = {};
3386	+ event.liveFired = undefined;
3387	+ jQuery.event.handle.call( elem, event );
3388	+ if ( event.isDefaultPrevented() ) {
3389	+ args[ 0 ].preventDefault();
3390	+ }
3391	+ }
3392	+
3393	+ // Create "bubbling" focus and blur events
3394	+ if ( !jQuery.support.focusinBubbles ) {
3395	+ jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3396	+
3397	+ // Attach a single capturing handler while someone wants focusin/focusout
3398	+ var attaches = 0;
3399	+
3400	+ jQuery.event.special[ fix ] = {
3401	+ setup: function() {
3402	+ if ( attaches++ === 0 ) {
3403	+ document.addEventListener( orig, handler, true );
3404	+ }
3405	+ },
3406	+ teardown: function() {
3407	+ if ( --attaches === 0 ) {
3408	+ document.removeEventListener( orig, handler, true );
3409	+ }
3410	+ }
3411	+ };
3412	+
3413	+ function handler( donor ) {
3414	+ // Donor event is always a native one; fix it and switch its type.
3415	+ // Let focusin/out handler cancel the donor focus/blur event.
3416	+ var e = jQuery.event.fix( donor );
3417	+ e.type = fix;
3418	+ e.originalEvent = {};
3419	+ jQuery.event.trigger( e, null, e.target );
3420	+ if ( e.isDefaultPrevented() ) {
3421	+ donor.preventDefault();
3422	+ }
3423	+ }
3424	+ });
3425	+ }
3426	+
3427	+ jQuery.each(["bind", "one"], function( i, name ) {
3428	+ jQuery.fn[ name ] = function( type, data, fn ) {
3429	+ var handler;
3430	+
3431	+ // Handle object literals
3432	+ if ( typeof type === "object" ) {
3433	+ for ( var key in type ) {
3434	+ this[ name ](key, data, type[key], fn);
3435	+ }
3436	+ return this;
3437	+ }
3438	+
3439	+ if ( arguments.length === 2 \|\| data === false ) {
3440	+ fn = data;
3441	+ data = undefined;
3442	+ }
3443	+
3444	+ if ( name === "one" ) {
3445	+ handler = function( event ) {
3446	+ jQuery( this ).unbind( event, handler );
3447	+ return fn.apply( this, arguments );
3448	+ };
3449	+ handler.guid = fn.guid \|\| jQuery.guid++;
3450	+ } else {
3451	+ handler = fn;
3452	+ }
3453	+
3454	+ if ( type === "unload" && name !== "one" ) {
3455	+ this.one( type, data, fn );
3456	+
3457	+ } else {
3458	+ for ( var i = 0, l = this.length; i < l; i++ ) {
3459	+ jQuery.event.add( this[i], type, handler, data );
3460	+ }
3461	+ }
3462	+
3463	+ return this;
3464	+ };
3465	+ });
3466	+
3467	+ jQuery.fn.extend({
3468	+ unbind: function( type, fn ) {
3469	+ // Handle object literals
3470	+ if ( typeof type === "object" && !type.preventDefault ) {
3471	+ for ( var key in type ) {
3472	+ this.unbind(key, type[key]);
3473	+ }
3474	+
3475	+ } else {
3476	+ for ( var i = 0, l = this.length; i < l; i++ ) {
3477	+ jQuery.event.remove( this[i], type, fn );
3478	+ }
3479	+ }
3480	+
3481	+ return this;
3482	+ },
3483	+
3484	+ delegate: function( selector, types, data, fn ) {
3485	+ return this.live( types, data, fn, selector );
3486	+ },
3487	+
3488	+ undelegate: function( selector, types, fn ) {
3489	+ if ( arguments.length === 0 ) {
3490	+ return this.unbind( "live" );
3491	+
3492	+ } else {
3493	+ return this.die( types, null, fn, selector );
3494	+ }
3495	+ },
3496	+
3497	+ trigger: function( type, data ) {
3498	+ return this.each(function() {
3499	+ jQuery.event.trigger( type, data, this );
3500	+ });
3501	+ },
3502	+
3503	+ triggerHandler: function( type, data ) {
3504	+ if ( this[0] ) {
3505	+ return jQuery.event.trigger( type, data, this[0], true );
3506	+ }
3507	+ },
3508	+
3509	+ toggle: function( fn ) {
3510	+ // Save reference to arguments for access in closure
3511	+ var args = arguments,
3512	+ guid = fn.guid \|\| jQuery.guid++,
3513	+ i = 0,
3514	+ toggler = function( event ) {
3515	+ // Figure out which function to execute
3516	+ var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) \|\| 0 ) % i;
3517	+ jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3518	+
3519	+ // Make sure that clicks stop
3520	+ event.preventDefault();
3521	+
3522	+ // and execute the function
3523	+ return args[ lastToggle ].apply( this, arguments ) \|\| false;
3524	+ };
3525	+
3526	+ // link all the functions, so any of them can unbind this click handler
3527	+ toggler.guid = guid;
3528	+ while ( i < args.length ) {
3529	+ args[ i++ ].guid = guid;
3530	+ }
3531	+
3532	+ return this.click( toggler );
3533	+ },
3534	+
3535	+ hover: function( fnOver, fnOut ) {
3536	+ return this.mouseenter( fnOver ).mouseleave( fnOut \|\| fnOver );
3537	+ }
3538	+ });
3539	+
3540	+ var liveMap = {
3541	+ focus: "focusin",
3542	+ blur: "focusout",
3543	+ mouseenter: "mouseover",
3544	+ mouseleave: "mouseout"
3545	+ };
3546	+
3547	+ jQuery.each(["live", "die"], function( i, name ) {
3548	+ jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
3549	+ var type, i = 0, match, namespaces, preType,
3550	+ selector = origSelector \|\| this.selector,
3551	+ context = origSelector ? this : jQuery( this.context );
3552	+
3553	+ if ( typeof types === "object" && !types.preventDefault ) {
3554	+ for ( var key in types ) {
3555	+ context[ name ]( key, data, types[key], selector );
3556	+ }
3557	+
3558	+ return this;
3559	+ }
3560	+
3561	+ if ( name === "die" && !types &&
3562	+ origSelector && origSelector.charAt(0) === "." ) {
3563	+
3564	+ context.unbind( origSelector );
3565	+
3566	+ return this;
3567	+ }
3568	+
3569	+ if ( data === false \|\| jQuery.isFunction( data ) ) {
3570	+ fn = data \|\| returnFalse;
3571	+ data = undefined;
3572	+ }
3573	+
3574	+ types = (types \|\| "").split(" ");
3575	+
3576	+ while ( (type = types[ i++ ]) != null ) {
3577	+ match = rnamespaces.exec( type );
3578	+ namespaces = "";
3579	+
3580	+ if ( match ) {
3581	+ namespaces = match[0];
3582	+ type = type.replace( rnamespaces, "" );
3583	+ }
3584	+
3585	+ if ( type === "hover" ) {
3586	+ types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
3587	+ continue;
3588	+ }
3589	+
3590	+ preType = type;
3591	+
3592	+ if ( liveMap[ type ] ) {
3593	+ types.push( liveMap[ type ] + namespaces );
3594	+ type = type + namespaces;
3595	+
3596	+ } else {
3597	+ type = (liveMap[ type ] \|\| type) + namespaces;
3598	+ }
3599	+
3600	+ if ( name === "live" ) {
3601	+ // bind live handler
3602	+ for ( var j = 0, l = context.length; j < l; j++ ) {
3603	+ jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
3604	+ { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
3605	+ }
3606	+
3607	+ } else {
3608	+ // unbind live handler
3609	+ context.unbind( "live." + liveConvert( type, selector ), fn );
3610	+ }
3611	+ }
3612	+
3613	+ return this;
3614	+ };
3615	+ });
3616	+
3617	+ function liveHandler( event ) {
3618	+ var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
3619	+ elems = [],
3620	+ selectors = [],
3621	+ events = jQuery._data( this, "events" );
3622	+
3623	+ // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
3624	+ if ( event.liveFired === this \|\| !events \|\| !events.live \|\| event.target.disabled \|\| event.button && event.type === "click" ) {
3625	+ return;
3626	+ }
3627	+
3628	+ if ( event.namespace ) {
3629	+ namespace = new RegExp("(^\|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.\|$)");
3630	+ }
3631	+
3632	+ event.liveFired = this;
3633	+
3634	+ var live = events.live.slice(0);
3635	+
3636	+ for ( j = 0; j < live.length; j++ ) {
3637	+ handleObj = live[j];
3638	+
3639	+ if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
3640	+ selectors.push( handleObj.selector );
3641	+
3642	+ } else {
3643	+ live.splice( j--, 1 );
3644	+ }
3645	+ }
3646	+
3647	+ match = jQuery( event.target ).closest( selectors, event.currentTarget );
3648	+
3649	+ for ( i = 0, l = match.length; i < l; i++ ) {
3650	+ close = match[i];
3651	+
3652	+ for ( j = 0; j < live.length; j++ ) {
3653	+ handleObj = live[j];
3654	+
3655	+ if ( close.selector === handleObj.selector && (!namespace \|\| namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
3656	+ elem = close.elem;
3657	+ related = null;
3658	+
3659	+ // Those two events require additional checking
3660	+ if ( handleObj.preType === "mouseenter" \|\| handleObj.preType === "mouseleave" ) {
3661	+ event.type = handleObj.preType;
3662	+ related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
3663	+
3664	+ // Make sure not to accidentally match a child element with the same selector
3665	+ if ( related && jQuery.contains( elem, related ) ) {
3666	+ related = elem;
3667	+ }
3668	+ }
3669	+
3670	+ if ( !related \|\| related !== elem ) {
3671	+ elems.push({ elem: elem, handleObj: handleObj, level: close.level });
3672	+ }
3673	+ }
3674	+ }
3675	+ }
3676	+
3677	+ for ( i = 0, l = elems.length; i < l; i++ ) {
3678	+ match = elems[i];
3679	+
3680	+ if ( maxLevel && match.level > maxLevel ) {
3681	+ break;
3682	+ }
3683	+
3684	+ event.currentTarget = match.elem;
3685	+ event.data = match.handleObj.data;
3686	+ event.handleObj = match.handleObj;
3687	+
3688	+ ret = match.handleObj.origHandler.apply( match.elem, arguments );
3689	+
3690	+ if ( ret === false \|\| event.isPropagationStopped() ) {
3691	+ maxLevel = match.level;
3692	+
3693	+ if ( ret === false ) {
3694	+ stop = false;
3695	+ }
3696	+ if ( event.isImmediatePropagationStopped() ) {
3697	+ break;
3698	+ }
3699	+ }
3700	+ }
3701	+
3702	+ return stop;
3703	+ }
3704	+
3705	+ function liveConvert( type, selector ) {
3706	+ return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
3707	+ }
3708	+
3709	+ jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3710	+ "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3711	+ "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
3712	+
3713	+ // Handle event binding
3714	+ jQuery.fn[ name ] = function( data, fn ) {
3715	+ if ( fn == null ) {
3716	+ fn = data;
3717	+ data = null;
3718	+ }
3719	+
3720	+ return arguments.length > 0 ?
3721	+ this.bind( name, data, fn ) :
3722	+ this.trigger( name );
3723	+ };
3724	+
3725	+ if ( jQuery.attrFn ) {
3726	+ jQuery.attrFn[ name ] = true;
3727	+ }
3728	+ });
3729	+
3730	+
3731	+
3732	+ /*!
3733	+ * Sizzle CSS Selector Engine
3734	+ * Copyright 2011, The Dojo Foundation
3735	+ * Released under the MIT, BSD, and GPL Licenses.
3736	+ * More information: http://sizzlejs.com/
3737	+ */
3738	+ (function(){
3739	+
3740	+ var chunker = /((?:$(?:\([^()]+$\|[^()]+)+\)\|\[(?:\[[^\[\]]\]\|['"][^'"]['"]\|[^\[\]'"]+)+\]\|\\.\|[^ >+~,(\[\\]+)+\|[>+~])(\s,\s)?((?:.\|\r\|\n)*)/g,
3741	+ done = 0,
3742	+ toString = Object.prototype.toString,
3743	+ hasDuplicate = false,
3744	+ baseHasDuplicate = true,
3745	+ rBackslash = /\\/g,
3746	+ rNonWord = /\W/;
3747	+
3748	+ // Here we check if the JavaScript engine is using some sort of
3749	+ // optimization where it does not always call our comparision
3750	+ // function. If that is the case, discard the hasDuplicate value.
3751	+ // Thus far that includes Google Chrome.
3752	+ [0, 0].sort(function() {
3753	+ baseHasDuplicate = false;
3754	+ return 0;
3755	+ });
3756	+
3757	+ var Sizzle = function( selector, context, results, seed ) {
3758	+ results = results \|\| [];
3759	+ context = context \|\| document;
3760	+
3761	+ var origContext = context;
3762	+
3763	+ if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3764	+ return [];
3765	+ }
3766	+
3767	+ if ( !selector \|\| typeof selector !== "string" ) {
3768	+ return results;
3769	+ }
3770	+
3771	+ var m, set, checkSet, extra, ret, cur, pop, i,
3772	+ prune = true,
3773	+ contextXML = Sizzle.isXML( context ),
3774	+ parts = [],
3775	+ soFar = selector;
3776	+
3777	+ // Reset the position of the chunker regexp (start from head)
3778	+ do {
3779	+ chunker.exec( "" );
3780	+ m = chunker.exec( soFar );
3781	+
3782	+ if ( m ) {
3783	+ soFar = m[3];
3784	+
3785	+ parts.push( m[1] );
3786	+
3787	+ if ( m[2] ) {
3788	+ extra = m[3];
3789	+ break;
3790	+ }
3791	+ }
3792	+ } while ( m );
3793	+
3794	+ if ( parts.length > 1 && origPOS.exec( selector ) ) {
3795	+
3796	+ if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3797	+ set = posProcess( parts[0] + parts[1], context );
3798	+
3799	+ } else {
3800	+ set = Expr.relative[ parts[0] ] ?
3801	+ [ context ] :
3802	+ Sizzle( parts.shift(), context );
3803	+
3804	+ while ( parts.length ) {
3805	+ selector = parts.shift();
3806	+
3807	+ if ( Expr.relative[ selector ] ) {
3808	+ selector += parts.shift();
3809	+ }
3810	+
3811	+ set = posProcess( selector, set );
3812	+ }
3813	+ }
3814	+
3815	+ } else {
3816	+ // Take a shortcut and set the context if the root selector is an ID
3817	+ // (but not if it'll be faster if the inner selector is an ID)
3818	+ if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3819	+ Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3820	+
3821	+ ret = Sizzle.find( parts.shift(), context, contextXML );
3822	+ context = ret.expr ?
3823	+ Sizzle.filter( ret.expr, ret.set )[0] :
3824	+ ret.set[0];
3825	+ }
3826	+
3827	+ if ( context ) {
3828	+ ret = seed ?
3829	+ { expr: parts.pop(), set: makeArray(seed) } :
3830	+ Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" \|\| parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3831	+
3832	+ set = ret.expr ?
3833	+ Sizzle.filter( ret.expr, ret.set ) :
3834	+ ret.set;
3835	+
3836	+ if ( parts.length > 0 ) {
3837	+ checkSet = makeArray( set );
3838	+
3839	+ } else {
3840	+ prune = false;
3841	+ }
3842	+
3843	+ while ( parts.length ) {
3844	+ cur = parts.pop();
3845	+ pop = cur;
3846	+
3847	+ if ( !Expr.relative[ cur ] ) {
3848	+ cur = "";
3849	+ } else {
3850	+ pop = parts.pop();
3851	+ }
3852	+
3853	+ if ( pop == null ) {
3854	+ pop = context;
3855	+ }
3856	+
3857	+ Expr.relative[ cur ]( checkSet, pop, contextXML );
3858	+ }
3859	+
3860	+ } else {
3861	+ checkSet = parts = [];
3862	+ }
3863	+ }
3864	+
3865	+ if ( !checkSet ) {
3866	+ checkSet = set;
3867	+ }
3868	+
3869	+ if ( !checkSet ) {
3870	+ Sizzle.error( cur \|\| selector );
3871	+ }
3872	+
3873	+ if ( toString.call(checkSet) === "[object Array]" ) {
3874	+ if ( !prune ) {
3875	+ results.push.apply( results, checkSet );
3876	+
3877	+ } else if ( context && context.nodeType === 1 ) {
3878	+ for ( i = 0; checkSet[i] != null; i++ ) {
3879	+ if ( checkSet[i] && (checkSet[i] === true \|\| checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3880	+ results.push( set[i] );
3881	+ }
3882	+ }
3883	+
3884	+ } else {
3885	+ for ( i = 0; checkSet[i] != null; i++ ) {
3886	+ if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3887	+ results.push( set[i] );
3888	+ }
3889	+ }
3890	+ }
3891	+
3892	+ } else {
3893	+ makeArray( checkSet, results );
3894	+ }
3895	+
3896	+ if ( extra ) {
3897	+ Sizzle( extra, origContext, results, seed );
3898	+ Sizzle.uniqueSort( results );
3899	+ }
3900	+
3901	+ return results;
3902	+ };
3903	+
3904	+ Sizzle.uniqueSort = function( results ) {
3905	+ if ( sortOrder ) {
3906	+ hasDuplicate = baseHasDuplicate;
3907	+ results.sort( sortOrder );
3908	+
3909	+ if ( hasDuplicate ) {
3910	+ for ( var i = 1; i < results.length; i++ ) {
3911	+ if ( results[i] === results[ i - 1 ] ) {
3912	+ results.splice( i--, 1 );
3913	+ }
3914	+ }
3915	+ }
3916	+ }
3917	+
3918	+ return results;
3919	+ };
3920	+
3921	+ Sizzle.matches = function( expr, set ) {
3922	+ return Sizzle( expr, null, null, set );
3923	+ };
3924	+
3925	+ Sizzle.matchesSelector = function( node, expr ) {
3926	+ return Sizzle( expr, null, null, [node] ).length > 0;
3927	+ };
3928	+
3929	+ Sizzle.find = function( expr, context, isXML ) {
3930	+ var set;
3931	+
3932	+ if ( !expr ) {
3933	+ return [];
3934	+ }
3935	+
3936	+ for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3937	+ var match,
3938	+ type = Expr.order[i];
3939	+
3940	+ if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3941	+ var left = match[1];
3942	+ match.splice( 1, 1 );
3943	+
3944	+ if ( left.substr( left.length - 1 ) !== "\\" ) {
3945	+ match[1] = (match[1] \|\| "").replace( rBackslash, "" );
3946	+ set = Expr.find[ type ]( match, context, isXML );
3947	+
3948	+ if ( set != null ) {
3949	+ expr = expr.replace( Expr.match[ type ], "" );
3950	+ break;
3951	+ }
3952	+ }
3953	+ }
3954	+ }
3955	+
3956	+ if ( !set ) {
3957	+ set = typeof context.getElementsByTagName !== "undefined" ?
3958	+ context.getElementsByTagName( "*" ) :
3959	+ [];
3960	+ }
3961	+
3962	+ return { set: set, expr: expr };
3963	+ };
3964	+
3965	+ Sizzle.filter = function( expr, set, inplace, not ) {
3966	+ var match, anyFound,
3967	+ old = expr,
3968	+ result = [],
3969	+ curLoop = set,
3970	+ isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
3971	+
3972	+ while ( expr && set.length ) {
3973	+ for ( var type in Expr.filter ) {
3974	+ if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3975	+ var found, item,
3976	+ filter = Expr.filter[ type ],
3977	+ left = match[1];
3978	+
3979	+ anyFound = false;
3980	+
3981	+ match.splice(1,1);
3982	+
3983	+ if ( left.substr( left.length - 1 ) === "\\" ) {
3984	+ continue;
3985	+ }
3986	+
3987	+ if ( curLoop === result ) {
3988	+ result = [];
3989	+ }
3990	+
3991	+ if ( Expr.preFilter[ type ] ) {
3992	+ match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3993	+
3994	+ if ( !match ) {
3995	+ anyFound = found = true;
3996	+
3997	+ } else if ( match === true ) {
3998	+ continue;
3999	+ }
4000	+ }
4001	+
4002	+ if ( match ) {
4003	+ for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
4004	+ if ( item ) {
4005	+ found = filter( item, match, i, curLoop );
4006	+ var pass = not ^ !!found;
4007	+
4008	+ if ( inplace && found != null ) {
4009	+ if ( pass ) {
4010	+ anyFound = true;
4011	+
4012	+ } else {
4013	+ curLoop[i] = false;
4014	+ }
4015	+
4016	+ } else if ( pass ) {
4017	+ result.push( item );
4018	+ anyFound = true;
4019	+ }
4020	+ }
4021	+ }
4022	+ }
4023	+
4024	+ if ( found !== undefined ) {
4025	+ if ( !inplace ) {
4026	+ curLoop = result;
4027	+ }
4028	+
4029	+ expr = expr.replace( Expr.match[ type ], "" );
4030	+
4031	+ if ( !anyFound ) {
4032	+ return [];
4033	+ }
4034	+
4035	+ break;
4036	+ }
4037	+ }
4038	+ }
4039	+
4040	+ // Improper expression
4041	+ if ( expr === old ) {
4042	+ if ( anyFound == null ) {
4043	+ Sizzle.error( expr );
4044	+
4045	+ } else {
4046	+ break;
4047	+ }
4048	+ }
4049	+
4050	+ old = expr;
4051	+ }
4052	+
4053	+ return curLoop;
4054	+ };
4055	+
4056	+ Sizzle.error = function( msg ) {
4057	+ throw "Syntax error, unrecognized expression: " + msg;
4058	+ };
4059	+
4060	+ var Expr = Sizzle.selectors = {
4061	+ order: [ "ID", "NAME", "TAG" ],
4062	+
4063	+ match: {
4064	+ ID: /#((?:[\w\u00c0-\uFFFF\-]\|\\.)+)/,
4065	+ CLASS: /\.((?:[\w\u00c0-\uFFFF\-]\|\\.)+)/,
4066	+ NAME: /\[name=['"]((?:[\w\u00c0-\uFFFF\-]\|\\.)+)['"]\]/,
4067	+ ATTR: /\[\s((?:[\w\u00c0-\uFFFF\-]\|\\.)+)\s(?:(\S?=)\s(?:(['"])(.?)\3\|(#?(?:[\w\u00c0-\uFFFF\-]\|\\.))\|)\|)\s\]/,
4068	+ TAG: /^((?:[\w\u00c0-\uFFFF\*\-]\|\\.)+)/,
4069	+ CHILD: /:(only\|nth\|last\|first)-child(?:$\s(even\|odd\|(?:[+\-]?\d+\|(?:[+\-]?\d)?n\s(?:[+\-]\s\d+)?))\s*$)?/,
4070	+ POS: /:(nth\|eq\|gt\|lt\|first\|last\|even\|odd)(?:$(\d*)$)?(?=[^\-]\|$)/,
4071	+ PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]\|\\.)+)(?:$(['"]?)((?:\([^$]+\)\|[^]*)+)\2\))?/
4072	+ },
4073	+
4074	+ leftMatch: {},
4075	+
4076	+ attrMap: {
4077	+ "class": "className",
4078	+ "for": "htmlFor"
4079	+ },
4080	+
4081	+ attrHandle: {
4082	+ href: function( elem ) {
4083	+ return elem.getAttribute( "href" );
4084	+ },
4085	+ type: function( elem ) {
4086	+ return elem.getAttribute( "type" );
4087	+ }
4088	+ },
4089	+
4090	+ relative: {
4091	+ "+": function(checkSet, part){
4092	+ var isPartStr = typeof part === "string",
4093	+ isTag = isPartStr && !rNonWord.test( part ),
4094	+ isPartStrNotTag = isPartStr && !isTag;
4095	+
4096	+ if ( isTag ) {
4097	+ part = part.toLowerCase();
4098	+ }
4099	+
4100	+ for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4101	+ if ( (elem = checkSet[i]) ) {
4102	+ while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4103	+
4104	+ checkSet[i] = isPartStrNotTag \|\| elem && elem.nodeName.toLowerCase() === part ?
4105	+ elem \|\| false :
4106	+ elem === part;
4107	+ }
4108	+ }
4109	+
4110	+ if ( isPartStrNotTag ) {
4111	+ Sizzle.filter( part, checkSet, true );
4112	+ }
4113	+ },
4114	+
4115	+ ">": function( checkSet, part ) {
4116	+ var elem,
4117	+ isPartStr = typeof part === "string",
4118	+ i = 0,
4119	+ l = checkSet.length;
4120	+
4121	+ if ( isPartStr && !rNonWord.test( part ) ) {
4122	+ part = part.toLowerCase();
4123	+
4124	+ for ( ; i < l; i++ ) {
4125	+ elem = checkSet[i];
4126	+
4127	+ if ( elem ) {
4128	+ var parent = elem.parentNode;
4129	+ checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4130	+ }
4131	+ }
4132	+
4133	+ } else {
4134	+ for ( ; i < l; i++ ) {
4135	+ elem = checkSet[i];
4136	+
4137	+ if ( elem ) {
4138	+ checkSet[i] = isPartStr ?
4139	+ elem.parentNode :
4140	+ elem.parentNode === part;
4141	+ }
4142	+ }
4143	+
4144	+ if ( isPartStr ) {
4145	+ Sizzle.filter( part, checkSet, true );
4146	+ }
4147	+ }
4148	+ },
4149	+
4150	+ "": function(checkSet, part, isXML){
4151	+ var nodeCheck,
4152	+ doneName = done++,
4153	+ checkFn = dirCheck;
4154	+
4155	+ if ( typeof part === "string" && !rNonWord.test( part ) ) {
4156	+ part = part.toLowerCase();
4157	+ nodeCheck = part;
4158	+ checkFn = dirNodeCheck;
4159	+ }
4160	+
4161	+ checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4162	+ },
4163	+
4164	+ "~": function( checkSet, part, isXML ) {
4165	+ var nodeCheck,
4166	+ doneName = done++,
4167	+ checkFn = dirCheck;
4168	+
4169	+ if ( typeof part === "string" && !rNonWord.test( part ) ) {
4170	+ part = part.toLowerCase();
4171	+ nodeCheck = part;
4172	+ checkFn = dirNodeCheck;
4173	+ }
4174	+
4175	+ checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4176	+ }
4177	+ },
4178	+
4179	+ find: {
4180	+ ID: function( match, context, isXML ) {
4181	+ if ( typeof context.getElementById !== "undefined" && !isXML ) {
4182	+ var m = context.getElementById(match[1]);
4183	+ // Check parentNode to catch when Blackberry 4.6 returns
4184	+ // nodes that are no longer in the document #6963
4185	+ return m && m.parentNode ? [m] : [];
4186	+ }
4187	+ },
4188	+
4189	+ NAME: function( match, context ) {
4190	+ if ( typeof context.getElementsByName !== "undefined" ) {
4191	+ var ret = [],
4192	+ results = context.getElementsByName( match[1] );
4193	+
4194	+ for ( var i = 0, l = results.length; i < l; i++ ) {
4195	+ if ( results[i].getAttribute("name") === match[1] ) {
4196	+ ret.push( results[i] );
4197	+ }
4198	+ }
4199	+
4200	+ return ret.length === 0 ? null : ret;
4201	+ }
4202	+ },
4203	+
4204	+ TAG: function( match, context ) {
4205	+ if ( typeof context.getElementsByTagName !== "undefined" ) {
4206	+ return context.getElementsByTagName( match[1] );
4207	+ }
4208	+ }
4209	+ },
4210	+ preFilter: {
4211	+ CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4212	+ match = " " + match[1].replace( rBackslash, "" ) + " ";
4213	+
4214	+ if ( isXML ) {
4215	+ return match;
4216	+ }
4217	+
4218	+ for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4219	+ if ( elem ) {
4220	+ if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4221	+ if ( !inplace ) {
4222	+ result.push( elem );
4223	+ }
4224	+
4225	+ } else if ( inplace ) {
4226	+ curLoop[i] = false;
4227	+ }
4228	+ }
4229	+ }
4230	+
4231	+ return false;
4232	+ },
4233	+
4234	+ ID: function( match ) {
4235	+ return match[1].replace( rBackslash, "" );
4236	+ },
4237	+
4238	+ TAG: function( match, curLoop ) {
4239	+ return match[1].replace( rBackslash, "" ).toLowerCase();
4240	+ },
4241	+
4242	+ CHILD: function( match ) {
4243	+ if ( match[1] === "nth" ) {
4244	+ if ( !match[2] ) {
4245	+ Sizzle.error( match[0] );
4246	+ }
4247	+
4248	+ match[2] = match[2].replace(/^\+\|\s*/g, '');
4249	+
4250	+ // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4251	+ var test = /(-?)(\d)(?:n([+\-]?\d))?/.exec(
4252	+ match[2] === "even" && "2n" \|\| match[2] === "odd" && "2n+1" \|\|
4253	+ !/\D/.test( match[2] ) && "0n+" + match[2] \|\| match[2]);
4254	+
4255	+ // calculate the numbers (first)n+(last) including if they are negative
4256	+ match[2] = (test[1] + (test[2] \|\| 1)) - 0;
4257	+ match[3] = test[3] - 0;
4258	+ }
4259	+ else if ( match[2] ) {
4260	+ Sizzle.error( match[0] );
4261	+ }
4262	+
4263	+ // TODO: Move to normal caching system
4264	+ match[0] = done++;
4265	+
4266	+ return match;
4267	+ },
4268	+
4269	+ ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4270	+ var name = match[1] = match[1].replace( rBackslash, "" );
4271	+
4272	+ if ( !isXML && Expr.attrMap[name] ) {
4273	+ match[1] = Expr.attrMap[name];
4274	+ }
4275	+
4276	+ // Handle if an un-quoted value was used
4277	+ match[4] = ( match[4] \|\| match[5] \|\| "" ).replace( rBackslash, "" );
4278	+
4279	+ if ( match[2] === "~=" ) {
4280	+ match[4] = " " + match[4] + " ";
4281	+ }
4282	+
4283	+ return match;
4284	+ },
4285	+
4286	+ PSEUDO: function( match, curLoop, inplace, result, not ) {
4287	+ if ( match[1] === "not" ) {
4288	+ // If we're dealing with a complex expression, or a simple one
4289	+ if ( ( chunker.exec(match[3]) \|\| "" ).length > 1 \|\| /^\w/.test(match[3]) ) {
4290	+ match[3] = Sizzle(match[3], null, null, curLoop);
4291	+
4292	+ } else {
4293	+ var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4294	+
4295	+ if ( !inplace ) {
4296	+ result.push.apply( result, ret );
4297	+ }
4298	+
4299	+ return false;
4300	+ }
4301	+
4302	+ } else if ( Expr.match.POS.test( match[0] ) \|\| Expr.match.CHILD.test( match[0] ) ) {
4303	+ return true;
4304	+ }
4305	+
4306	+ return match;
4307	+ },
4308	+
4309	+ POS: function( match ) {
4310	+ match.unshift( true );
4311	+
4312	+ return match;
4313	+ }
4314	+ },
4315	+
4316	+ filters: {
4317	+ enabled: function( elem ) {
4318	+ return elem.disabled === false && elem.type !== "hidden";
4319	+ },
4320	+
4321	+ disabled: function( elem ) {
4322	+ return elem.disabled === true;
4323	+ },
4324	+
4325	+ checked: function( elem ) {
4326	+ return elem.checked === true;
4327	+ },
4328	+
4329	+ selected: function( elem ) {
4330	+ // Accessing this property makes selected-by-default
4331	+ // options in Safari work properly
4332	+ if ( elem.parentNode ) {
4333	+ elem.parentNode.selectedIndex;
4334	+ }
4335	+
4336	+ return elem.selected === true;
4337	+ },
4338	+
4339	+ parent: function( elem ) {
4340	+ return !!elem.firstChild;
4341	+ },
4342	+
4343	+ empty: function( elem ) {
4344	+ return !elem.firstChild;
4345	+ },
4346	+
4347	+ has: function( elem, i, match ) {
4348	+ return !!Sizzle( match[3], elem ).length;
4349	+ },
4350	+
4351	+ header: function( elem ) {
4352	+ return (/h\d/i).test( elem.nodeName );
4353	+ },
4354	+
4355	+ text: function( elem ) {
4356	+ var attr = elem.getAttribute( "type" ), type = elem.type;
4357	+ // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4358	+ // use getAttribute instead to test this case
4359	+ return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type \|\| attr === null );
4360	+ },
4361	+
4362	+ radio: function( elem ) {
4363	+ return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4364	+ },
4365	+
4366	+ checkbox: function( elem ) {
4367	+ return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4368	+ },
4369	+
4370	+ file: function( elem ) {
4371	+ return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4372	+ },
4373	+
4374	+ password: function( elem ) {
4375	+ return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4376	+ },
4377	+
4378	+ submit: function( elem ) {
4379	+ var name = elem.nodeName.toLowerCase();
4380	+ return (name === "input" \|\| name === "button") && "submit" === elem.type;
4381	+ },
4382	+
4383	+ image: function( elem ) {
4384	+ return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4385	+ },
4386	+
4387	+ reset: function( elem ) {
4388	+ var name = elem.nodeName.toLowerCase();
4389	+ return (name === "input" \|\| name === "button") && "reset" === elem.type;
4390	+ },
4391	+
4392	+ button: function( elem ) {
4393	+ var name = elem.nodeName.toLowerCase();
4394	+ return name === "input" && "button" === elem.type \|\| name === "button";
4395	+ },
4396	+
4397	+ input: function( elem ) {
4398	+ return (/input\|select\|textarea\|button/i).test( elem.nodeName );
4399	+ },
4400	+
4401	+ focus: function( elem ) {
4402	+ return elem === elem.ownerDocument.activeElement;
4403	+ }
4404	+ },
4405	+ setFilters: {
4406	+ first: function( elem, i ) {
4407	+ return i === 0;
4408	+ },
4409	+
4410	+ last: function( elem, i, match, array ) {
4411	+ return i === array.length - 1;
4412	+ },
4413	+
4414	+ even: function( elem, i ) {
4415	+ return i % 2 === 0;
4416	+ },
4417	+
4418	+ odd: function( elem, i ) {
4419	+ return i % 2 === 1;
4420	+ },
4421	+
4422	+ lt: function( elem, i, match ) {
4423	+ return i < match[3] - 0;
4424	+ },
4425	+
4426	+ gt: function( elem, i, match ) {
4427	+ return i > match[3] - 0;
4428	+ },
4429	+
4430	+ nth: function( elem, i, match ) {
4431	+ return match[3] - 0 === i;
4432	+ },
4433	+
4434	+ eq: function( elem, i, match ) {
4435	+ return match[3] - 0 === i;
4436	+ }
4437	+ },
4438	+ filter: {
4439	+ PSEUDO: function( elem, match, i, array ) {
4440	+ var name = match[1],
4441	+ filter = Expr.filters[ name ];
4442	+
4443	+ if ( filter ) {
4444	+ return filter( elem, i, match, array );
4445	+
4446	+ } else if ( name === "contains" ) {
4447	+ return (elem.textContent \|\| elem.innerText \|\| Sizzle.getText([ elem ]) \|\| "").indexOf(match[3]) >= 0;
4448	+
4449	+ } else if ( name === "not" ) {
4450	+ var not = match[3];
4451	+
4452	+ for ( var j = 0, l = not.length; j < l; j++ ) {
4453	+ if ( not[j] === elem ) {
4454	+ return false;
4455	+ }
4456	+ }
4457	+
4458	+ return true;
4459	+
4460	+ } else {
4461	+ Sizzle.error( name );
4462	+ }
4463	+ },
4464	+
4465	+ CHILD: function( elem, match ) {
4466	+ var type = match[1],
4467	+ node = elem;
4468	+
4469	+ switch ( type ) {
4470	+ case "only":
4471	+ case "first":
4472	+ while ( (node = node.previousSibling) ) {
4473	+ if ( node.nodeType === 1 ) {
4474	+ return false;
4475	+ }
4476	+ }
4477	+
4478	+ if ( type === "first" ) {
4479	+ return true;
4480	+ }
4481	+
4482	+ node = elem;
4483	+
4484	+ case "last":
4485	+ while ( (node = node.nextSibling) ) {
4486	+ if ( node.nodeType === 1 ) {
4487	+ return false;
4488	+ }
4489	+ }
4490	+
4491	+ return true;
4492	+
4493	+ case "nth":
4494	+ var first = match[2],
4495	+ last = match[3];
4496	+
4497	+ if ( first === 1 && last === 0 ) {
4498	+ return true;
4499	+ }
4500	+
4501	+ var doneName = match[0],
4502	+ parent = elem.parentNode;
4503	+
4504	+ if ( parent && (parent.sizcache !== doneName \|\| !elem.nodeIndex) ) {
4505	+ var count = 0;
4506	+
4507	+ for ( node = parent.firstChild; node; node = node.nextSibling ) {
4508	+ if ( node.nodeType === 1 ) {
4509	+ node.nodeIndex = ++count;
4510	+ }
4511	+ }
4512	+
4513	+ parent.sizcache = doneName;
4514	+ }
4515	+
4516	+ var diff = elem.nodeIndex - last;
4517	+
4518	+ if ( first === 0 ) {
4519	+ return diff === 0;
4520	+
4521	+ } else {
4522	+ return ( diff % first === 0 && diff / first >= 0 );
4523	+ }
4524	+ }
4525	+ },
4526	+
4527	+ ID: function( elem, match ) {
4528	+ return elem.nodeType === 1 && elem.getAttribute("id") === match;
4529	+ },
4530	+
4531	+ TAG: function( elem, match ) {
4532	+ return (match === "*" && elem.nodeType === 1) \|\| elem.nodeName.toLowerCase() === match;
4533	+ },
4534	+
4535	+ CLASS: function( elem, match ) {
4536	+ return (" " + (elem.className \|\| elem.getAttribute("class")) + " ")
4537	+ .indexOf( match ) > -1;
4538	+ },
4539	+
4540	+ ATTR: function( elem, match ) {
4541	+ var name = match[1],
4542	+ result = Expr.attrHandle[ name ] ?
4543	+ Expr.attrHandle[ name ]( elem ) :
4544	+ elem[ name ] != null ?
4545	+ elem[ name ] :
4546	+ elem.getAttribute( name ),
4547	+ value = result + "",
4548	+ type = match[2],
4549	+ check = match[4];
4550	+
4551	+ return result == null ?
4552	+ type === "!=" :
4553	+ type === "=" ?
4554	+ value === check :
4555	+ type === "*=" ?
4556	+ value.indexOf(check) >= 0 :
4557	+ type === "~=" ?
4558	+ (" " + value + " ").indexOf(check) >= 0 :
4559	+ !check ?
4560	+ value && result !== false :
4561	+ type === "!=" ?
4562	+ value !== check :
4563	+ type === "^=" ?
4564	+ value.indexOf(check) === 0 :
4565	+ type === "$=" ?
4566	+ value.substr(value.length - check.length) === check :
4567	+ type === "\|=" ?
4568	+ value === check \|\| value.substr(0, check.length + 1) === check + "-" :
4569	+ false;
4570	+ },
4571	+
4572	+ POS: function( elem, match, i, array ) {
4573	+ var name = match[2],
4574	+ filter = Expr.setFilters[ name ];
4575	+
4576	+ if ( filter ) {
4577	+ return filter( elem, i, match, array );
4578	+ }
4579	+ }
4580	+ }
4581	+ };
4582	+
4583	+ var origPOS = Expr.match.POS,
4584	+ fescape = function(all, num){
4585	+ return "\\" + (num - 0 + 1);
4586	+ };
4587	+
4588	+ for ( var type in Expr.match ) {
4589	+ Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]\])(?![^$]$)/.source) );
4590	+ Expr.leftMatch[ type ] = new RegExp( /(^(?:.\|\r\|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4591	+ }
4592	+
4593	+ var makeArray = function( array, results ) {
4594	+ array = Array.prototype.slice.call( array, 0 );
4595	+
4596	+ if ( results ) {
4597	+ results.push.apply( results, array );
4598	+ return results;
4599	+ }
4600	+
4601	+ return array;
4602	+ };
4603	+
4604	+ // Perform a simple check to determine if the browser is capable of
4605	+ // converting a NodeList to an array using builtin methods.
4606	+ // Also verifies that the returned array holds DOM nodes
4607	+ // (which is not the case in the Blackberry browser)
4608	+ try {
4609	+ Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4610	+
4611	+ // Provide a fallback method if it does not work
4612	+ } catch( e ) {
4613	+ makeArray = function( array, results ) {
4614	+ var i = 0,
4615	+ ret = results \|\| [];
4616	+
4617	+ if ( toString.call(array) === "[object Array]" ) {
4618	+ Array.prototype.push.apply( ret, array );
4619	+
4620	+ } else {
4621	+ if ( typeof array.length === "number" ) {
4622	+ for ( var l = array.length; i < l; i++ ) {
4623	+ ret.push( array[i] );
4624	+ }
4625	+
4626	+ } else {
4627	+ for ( ; array[i]; i++ ) {
4628	+ ret.push( array[i] );
4629	+ }
4630	+ }
4631	+ }
4632	+
4633	+ return ret;
4634	+ };
4635	+ }
4636	+
4637	+ var sortOrder, siblingCheck;
4638	+
4639	+ if ( document.documentElement.compareDocumentPosition ) {
4640	+ sortOrder = function( a, b ) {
4641	+ if ( a === b ) {
4642	+ hasDuplicate = true;
4643	+ return 0;
4644	+ }
4645	+
4646	+ if ( !a.compareDocumentPosition \|\| !b.compareDocumentPosition ) {
4647	+ return a.compareDocumentPosition ? -1 : 1;
4648	+ }
4649	+
4650	+ return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4651	+ };
4652	+
4653	+ } else {
4654	+ sortOrder = function( a, b ) {
4655	+ // The nodes are identical, we can exit early
4656	+ if ( a === b ) {
4657	+ hasDuplicate = true;
4658	+ return 0;
4659	+
4660	+ // Fallback to using sourceIndex (in IE) if it's available on both nodes
4661	+ } else if ( a.sourceIndex && b.sourceIndex ) {
4662	+ return a.sourceIndex - b.sourceIndex;
4663	+ }
4664	+
4665	+ var al, bl,
4666	+ ap = [],
4667	+ bp = [],
4668	+ aup = a.parentNode,
4669	+ bup = b.parentNode,
4670	+ cur = aup;
4671	+
4672	+ // If the nodes are siblings (or identical) we can do a quick check
4673	+ if ( aup === bup ) {
4674	+ return siblingCheck( a, b );
4675	+
4676	+ // If no parents were found then the nodes are disconnected
4677	+ } else if ( !aup ) {
4678	+ return -1;
4679	+
4680	+ } else if ( !bup ) {
4681	+ return 1;
4682	+ }
4683	+
4684	+ // Otherwise they're somewhere else in the tree so we need
4685	+ // to build up a full list of the parentNodes for comparison
4686	+ while ( cur ) {
4687	+ ap.unshift( cur );
4688	+ cur = cur.parentNode;
4689	+ }
4690	+
4691	+ cur = bup;
4692	+
4693	+ while ( cur ) {
4694	+ bp.unshift( cur );
4695	+ cur = cur.parentNode;
4696	+ }
4697	+
4698	+ al = ap.length;
4699	+ bl = bp.length;
4700	+
4701	+ // Start walking down the tree looking for a discrepancy
4702	+ for ( var i = 0; i < al && i < bl; i++ ) {
4703	+ if ( ap[i] !== bp[i] ) {
4704	+ return siblingCheck( ap[i], bp[i] );
4705	+ }
4706	+ }
4707	+
4708	+ // We ended someplace up the tree so do a sibling check
4709	+ return i === al ?
4710	+ siblingCheck( a, bp[i], -1 ) :
4711	+ siblingCheck( ap[i], b, 1 );
4712	+ };
4713	+
4714	+ siblingCheck = function( a, b, ret ) {
4715	+ if ( a === b ) {
4716	+ return ret;
4717	+ }
4718	+
4719	+ var cur = a.nextSibling;
4720	+
4721	+ while ( cur ) {
4722	+ if ( cur === b ) {
4723	+ return -1;
4724	+ }
4725	+
4726	+ cur = cur.nextSibling;
4727	+ }
4728	+
4729	+ return 1;
4730	+ };
4731	+ }
4732	+
4733	+ // Utility function for retreiving the text value of an array of DOM nodes
4734	+ Sizzle.getText = function( elems ) {
4735	+ var ret = "", elem;
4736	+
4737	+ for ( var i = 0; elems[i]; i++ ) {
4738	+ elem = elems[i];
4739	+
4740	+ // Get the text from text nodes and CDATA nodes
4741	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 4 ) {
4742	+ ret += elem.nodeValue;
4743	+
4744	+ // Traverse everything else, except comment nodes
4745	+ } else if ( elem.nodeType !== 8 ) {
4746	+ ret += Sizzle.getText( elem.childNodes );
4747	+ }
4748	+ }
4749	+
4750	+ return ret;
4751	+ };
4752	+
4753	+ // Check to see if the browser returns elements by name when
4754	+ // querying by getElementById (and provide a workaround)
4755	+ (function(){
4756	+ // We're going to inject a fake input element with a specified name
4757	+ var form = document.createElement("div"),
4758	+ id = "script" + (new Date()).getTime(),
4759	+ root = document.documentElement;
4760	+
4761	+ form.innerHTML = "<a name='" + id + "'/>";
4762	+
4763	+ // Inject it into the root element, check its status, and remove it quickly
4764	+ root.insertBefore( form, root.firstChild );
4765	+
4766	+ // The workaround has to do additional checks after a getElementById
4767	+ // Which slows things down for other browsers (hence the branching)
4768	+ if ( document.getElementById( id ) ) {
4769	+ Expr.find.ID = function( match, context, isXML ) {
4770	+ if ( typeof context.getElementById !== "undefined" && !isXML ) {
4771	+ var m = context.getElementById(match[1]);
4772	+
4773	+ return m ?
4774	+ m.id === match[1] \|\| typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4775	+ [m] :
4776	+ undefined :
4777	+ [];
4778	+ }
4779	+ };
4780	+
4781	+ Expr.filter.ID = function( elem, match ) {
4782	+ var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4783	+
4784	+ return elem.nodeType === 1 && node && node.nodeValue === match;
4785	+ };
4786	+ }
4787	+
4788	+ root.removeChild( form );
4789	+
4790	+ // release memory in IE
4791	+ root = form = null;
4792	+ })();
4793	+
4794	+ (function(){
4795	+ // Check to see if the browser returns only elements
4796	+ // when doing getElementsByTagName("*")
4797	+
4798	+ // Create a fake element
4799	+ var div = document.createElement("div");
4800	+ div.appendChild( document.createComment("") );
4801	+
4802	+ // Make sure no comments are found
4803	+ if ( div.getElementsByTagName("*").length > 0 ) {
4804	+ Expr.find.TAG = function( match, context ) {
4805	+ var results = context.getElementsByTagName( match[1] );
4806	+
4807	+ // Filter out possible comments
4808	+ if ( match[1] === "*" ) {
4809	+ var tmp = [];
4810	+
4811	+ for ( var i = 0; results[i]; i++ ) {
4812	+ if ( results[i].nodeType === 1 ) {
4813	+ tmp.push( results[i] );
4814	+ }
4815	+ }
4816	+
4817	+ results = tmp;
4818	+ }
4819	+
4820	+ return results;
4821	+ };
4822	+ }
4823	+
4824	+ // Check to see if an attribute returns normalized href attributes
4825	+ div.innerHTML = "<a href='#'></a>";
4826	+
4827	+ if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4828	+ div.firstChild.getAttribute("href") !== "#" ) {
4829	+
4830	+ Expr.attrHandle.href = function( elem ) {
4831	+ return elem.getAttribute( "href", 2 );
4832	+ };
4833	+ }
4834	+
4835	+ // release memory in IE
4836	+ div = null;
4837	+ })();
4838	+
4839	+ if ( document.querySelectorAll ) {
4840	+ (function(){
4841	+ var oldSizzle = Sizzle,
4842	+ div = document.createElement("div"),
4843	+ id = "__sizzle__";
4844	+
4845	+ div.innerHTML = "<p class='TEST'></p>";
4846	+
4847	+ // Safari can't handle uppercase or unicode characters when
4848	+ // in quirks mode.
4849	+ if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4850	+ return;
4851	+ }
4852	+
4853	+ Sizzle = function( query, context, extra, seed ) {
4854	+ context = context \|\| document;
4855	+
4856	+ // Only use querySelectorAll on non-XML documents
4857	+ // (ID selectors don't work in non-HTML documents)
4858	+ if ( !seed && !Sizzle.isXML(context) ) {
4859	+ // See if we find a selector to speed up
4860	+ var match = /^(\w+$)\|^\.([\w\-]+$)\|^#([\w\-]+$)/.exec( query );
4861	+
4862	+ if ( match && (context.nodeType === 1 \|\| context.nodeType === 9) ) {
4863	+ // Speed-up: Sizzle("TAG")
4864	+ if ( match[1] ) {
4865	+ return makeArray( context.getElementsByTagName( query ), extra );
4866	+
4867	+ // Speed-up: Sizzle(".CLASS")
4868	+ } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
4869	+ return makeArray( context.getElementsByClassName( match[2] ), extra );
4870	+ }
4871	+ }
4872	+
4873	+ if ( context.nodeType === 9 ) {
4874	+ // Speed-up: Sizzle("body")
4875	+ // The body element only exists once, optimize finding it
4876	+ if ( query === "body" && context.body ) {
4877	+ return makeArray( [ context.body ], extra );
4878	+
4879	+ // Speed-up: Sizzle("#ID")
4880	+ } else if ( match && match[3] ) {
4881	+ var elem = context.getElementById( match[3] );
4882	+
4883	+ // Check parentNode to catch when Blackberry 4.6 returns
4884	+ // nodes that are no longer in the document #6963
4885	+ if ( elem && elem.parentNode ) {
4886	+ // Handle the case where IE and Opera return items
4887	+ // by name instead of ID
4888	+ if ( elem.id === match[3] ) {
4889	+ return makeArray( [ elem ], extra );
4890	+ }
4891	+
4892	+ } else {
4893	+ return makeArray( [], extra );
4894	+ }
4895	+ }
4896	+
4897	+ try {
4898	+ return makeArray( context.querySelectorAll(query), extra );
4899	+ } catch(qsaError) {}
4900	+
4901	+ // qSA works strangely on Element-rooted queries
4902	+ // We can work around this by specifying an extra ID on the root
4903	+ // and working up from there (Thanks to Andrew Dupont for the technique)
4904	+ // IE 8 doesn't work on object elements
4905	+ } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4906	+ var oldContext = context,
4907	+ old = context.getAttribute( "id" ),
4908	+ nid = old \|\| id,
4909	+ hasParent = context.parentNode,
4910	+ relativeHierarchySelector = /^\s*[+~]/.test( query );
4911	+
4912	+ if ( !old ) {
4913	+ context.setAttribute( "id", nid );
4914	+ } else {
4915	+ nid = nid.replace( /'/g, "\\$&" );
4916	+ }
4917	+ if ( relativeHierarchySelector && hasParent ) {
4918	+ context = context.parentNode;
4919	+ }
4920	+
4921	+ try {
4922	+ if ( !relativeHierarchySelector \|\| hasParent ) {
4923	+ return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
4924	+ }
4925	+
4926	+ } catch(pseudoError) {
4927	+ } finally {
4928	+ if ( !old ) {
4929	+ oldContext.removeAttribute( "id" );
4930	+ }
4931	+ }
4932	+ }
4933	+ }
4934	+
4935	+ return oldSizzle(query, context, extra, seed);
4936	+ };
4937	+
4938	+ for ( var prop in oldSizzle ) {
4939	+ Sizzle[ prop ] = oldSizzle[ prop ];
4940	+ }
4941	+
4942	+ // release memory in IE
4943	+ div = null;
4944	+ })();
4945	+ }
4946	+
4947	+ (function(){
4948	+ var html = document.documentElement,
4949	+ matches = html.matchesSelector \|\| html.mozMatchesSelector \|\| html.webkitMatchesSelector \|\| html.msMatchesSelector;
4950	+
4951	+ if ( matches ) {
4952	+ // Check to see if it's possible to do matchesSelector
4953	+ // on a disconnected node (IE 9 fails this)
4954	+ var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
4955	+ pseudoWorks = false;
4956	+
4957	+ try {
4958	+ // This should fail with an exception
4959	+ // Gecko does not error, returns false instead
4960	+ matches.call( document.documentElement, "[test!='']:sizzle" );
4961	+
4962	+ } catch( pseudoError ) {
4963	+ pseudoWorks = true;
4964	+ }
4965	+
4966	+ Sizzle.matchesSelector = function( node, expr ) {
4967	+ // Make sure that attribute selectors are quoted
4968	+ expr = expr.replace(/\=\s([^'"\]])\s*\]/g, "='$1']");
4969	+
4970	+ if ( !Sizzle.isXML( node ) ) {
4971	+ try {
4972	+ if ( pseudoWorks \|\| !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
4973	+ var ret = matches.call( node, expr );
4974	+
4975	+ // IE 9's matchesSelector returns false on disconnected nodes
4976	+ if ( ret \|\| !disconnectedMatch \|\|
4977	+ // As well, disconnected nodes are said to be in a document
4978	+ // fragment in IE 9, so check for that
4979	+ node.document && node.document.nodeType !== 11 ) {
4980	+ return ret;
4981	+ }
4982	+ }
4983	+ } catch(e) {}
4984	+ }
4985	+
4986	+ return Sizzle(expr, null, null, [node]).length > 0;
4987	+ };
4988	+ }
4989	+ })();
4990	+
4991	+ (function(){
4992	+ var div = document.createElement("div");
4993	+
4994	+ div.innerHTML = "<div class='test e'></div><div class='test'></div>";
4995	+
4996	+ // Opera can't find a second classname (in 9.6)
4997	+ // Also, make sure that getElementsByClassName actually exists
4998	+ if ( !div.getElementsByClassName \|\| div.getElementsByClassName("e").length === 0 ) {
4999	+ return;
5000	+ }
5001	+
5002	+ // Safari caches class attributes, doesn't catch changes (in 3.2)
5003	+ div.lastChild.className = "e";
5004	+
5005	+ if ( div.getElementsByClassName("e").length === 1 ) {
5006	+ return;
5007	+ }
5008	+
5009	+ Expr.order.splice(1, 0, "CLASS");
5010	+ Expr.find.CLASS = function( match, context, isXML ) {
5011	+ if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
5012	+ return context.getElementsByClassName(match[1]);
5013	+ }
5014	+ };
5015	+
5016	+ // release memory in IE
5017	+ div = null;
5018	+ })();
5019	+
5020	+ function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5021	+ for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5022	+ var elem = checkSet[i];
5023	+
5024	+ if ( elem ) {
5025	+ var match = false;
5026	+
5027	+ elem = elem[dir];
5028	+
5029	+ while ( elem ) {
5030	+ if ( elem.sizcache === doneName ) {
5031	+ match = checkSet[elem.sizset];
5032	+ break;
5033	+ }
5034	+
5035	+ if ( elem.nodeType === 1 && !isXML ){
5036	+ elem.sizcache = doneName;
5037	+ elem.sizset = i;
5038	+ }
5039	+
5040	+ if ( elem.nodeName.toLowerCase() === cur ) {
5041	+ match = elem;
5042	+ break;
5043	+ }
5044	+
5045	+ elem = elem[dir];
5046	+ }
5047	+
5048	+ checkSet[i] = match;
5049	+ }
5050	+ }
5051	+ }
5052	+
5053	+ function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5054	+ for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5055	+ var elem = checkSet[i];
5056	+
5057	+ if ( elem ) {
5058	+ var match = false;
5059	+
5060	+ elem = elem[dir];
5061	+
5062	+ while ( elem ) {
5063	+ if ( elem.sizcache === doneName ) {
5064	+ match = checkSet[elem.sizset];
5065	+ break;
5066	+ }
5067	+
5068	+ if ( elem.nodeType === 1 ) {
5069	+ if ( !isXML ) {
5070	+ elem.sizcache = doneName;
5071	+ elem.sizset = i;
5072	+ }
5073	+
5074	+ if ( typeof cur !== "string" ) {
5075	+ if ( elem === cur ) {
5076	+ match = true;
5077	+ break;
5078	+ }
5079	+
5080	+ } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5081	+ match = elem;
5082	+ break;
5083	+ }
5084	+ }
5085	+
5086	+ elem = elem[dir];
5087	+ }
5088	+
5089	+ checkSet[i] = match;
5090	+ }
5091	+ }
5092	+ }
5093	+
5094	+ if ( document.documentElement.contains ) {
5095	+ Sizzle.contains = function( a, b ) {
5096	+ return a !== b && (a.contains ? a.contains(b) : true);
5097	+ };
5098	+
5099	+ } else if ( document.documentElement.compareDocumentPosition ) {
5100	+ Sizzle.contains = function( a, b ) {
5101	+ return !!(a.compareDocumentPosition(b) & 16);
5102	+ };
5103	+
5104	+ } else {
5105	+ Sizzle.contains = function() {
5106	+ return false;
5107	+ };
5108	+ }
5109	+
5110	+ Sizzle.isXML = function( elem ) {
5111	+ // documentElement is verified for cases where it doesn't yet exist
5112	+ // (such as loading iframes in IE - #4833)
5113	+ var documentElement = (elem ? elem.ownerDocument \|\| elem : 0).documentElement;
5114	+
5115	+ return documentElement ? documentElement.nodeName !== "HTML" : false;
5116	+ };
5117	+
5118	+ var posProcess = function( selector, context ) {
5119	+ var match,
5120	+ tmpSet = [],
5121	+ later = "",
5122	+ root = context.nodeType ? [context] : context;
5123	+
5124	+ // Position selectors must be done after the filter
5125	+ // And so must :not(positional) so we move all PSEUDOs to the end
5126	+ while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5127	+ later += match[0];
5128	+ selector = selector.replace( Expr.match.PSEUDO, "" );
5129	+ }
5130	+
5131	+ selector = Expr.relative[selector] ? selector + "*" : selector;
5132	+
5133	+ for ( var i = 0, l = root.length; i < l; i++ ) {
5134	+ Sizzle( selector, root[i], tmpSet );
5135	+ }
5136	+
5137	+ return Sizzle.filter( later, tmpSet );
5138	+ };
5139	+
5140	+ // EXPOSE
5141	+ jQuery.find = Sizzle;
5142	+ jQuery.expr = Sizzle.selectors;
5143	+ jQuery.expr[":"] = jQuery.expr.filters;
5144	+ jQuery.unique = Sizzle.uniqueSort;
5145	+ jQuery.text = Sizzle.getText;
5146	+ jQuery.isXMLDoc = Sizzle.isXML;
5147	+ jQuery.contains = Sizzle.contains;
5148	+
5149	+
5150	+ })();
5151	+
5152	+
5153	+ var runtil = /Until$/,
5154	+ rparentsprev = /^(?:parents\|prevUntil\|prevAll)/,
5155	+ // Note: This RegExp should be improved, or likely pulled from Sizzle
5156	+ rmultiselector = /,/,
5157	+ isSimple = /^.[^:#\[\.,]*$/,
5158	+ slice = Array.prototype.slice,
5159	+ POS = jQuery.expr.match.POS,
5160	+ // methods guaranteed to produce a unique set when starting from a unique set
5161	+ guaranteedUnique = {
5162	+ children: true,
5163	+ contents: true,
5164	+ next: true,
5165	+ prev: true
5166	+ };
5167	+
5168	+ jQuery.fn.extend({
5169	+ find: function( selector ) {
5170	+ var self = this,
5171	+ i, l;
5172	+
5173	+ if ( typeof selector !== "string" ) {
5174	+ return jQuery( selector ).filter(function() {
5175	+ for ( i = 0, l = self.length; i < l; i++ ) {
5176	+ if ( jQuery.contains( self[ i ], this ) ) {
5177	+ return true;
5178	+ }
5179	+ }
5180	+ });
5181	+ }
5182	+
5183	+ var ret = this.pushStack( "", "find", selector ),
5184	+ length, n, r;
5185	+
5186	+ for ( i = 0, l = this.length; i < l; i++ ) {
5187	+ length = ret.length;
5188	+ jQuery.find( selector, this[i], ret );
5189	+
5190	+ if ( i > 0 ) {
5191	+ // Make sure that the results are unique
5192	+ for ( n = length; n < ret.length; n++ ) {
5193	+ for ( r = 0; r < length; r++ ) {
5194	+ if ( ret[r] === ret[n] ) {
5195	+ ret.splice(n--, 1);
5196	+ break;
5197	+ }
5198	+ }
5199	+ }
5200	+ }
5201	+ }
5202	+
5203	+ return ret;
5204	+ },
5205	+
5206	+ has: function( target ) {
5207	+ var targets = jQuery( target );
5208	+ return this.filter(function() {
5209	+ for ( var i = 0, l = targets.length; i < l; i++ ) {
5210	+ if ( jQuery.contains( this, targets[i] ) ) {
5211	+ return true;
5212	+ }
5213	+ }
5214	+ });
5215	+ },
5216	+
5217	+ not: function( selector ) {
5218	+ return this.pushStack( winnow(this, selector, false), "not", selector);
5219	+ },
5220	+
5221	+ filter: function( selector ) {
5222	+ return this.pushStack( winnow(this, selector, true), "filter", selector );
5223	+ },
5224	+
5225	+ is: function( selector ) {
5226	+ return !!selector && ( typeof selector === "string" ?
5227	+ jQuery.filter( selector, this ).length > 0 :
5228	+ this.filter( selector ).length > 0 );
5229	+ },
5230	+
5231	+ closest: function( selectors, context ) {
5232	+ var ret = [], i, l, cur = this[0];
5233	+
5234	+ // Array
5235	+ if ( jQuery.isArray( selectors ) ) {
5236	+ var match, selector,
5237	+ matches = {},
5238	+ level = 1;
5239	+
5240	+ if ( cur && selectors.length ) {
5241	+ for ( i = 0, l = selectors.length; i < l; i++ ) {
5242	+ selector = selectors[i];
5243	+
5244	+ if ( !matches[ selector ] ) {
5245	+ matches[ selector ] = POS.test( selector ) ?
5246	+ jQuery( selector, context \|\| this.context ) :
5247	+ selector;
5248	+ }
5249	+ }
5250	+
5251	+ while ( cur && cur.ownerDocument && cur !== context ) {
5252	+ for ( selector in matches ) {
5253	+ match = matches[ selector ];
5254	+
5255	+ if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
5256	+ ret.push({ selector: selector, elem: cur, level: level });
5257	+ }
5258	+ }
5259	+
5260	+ cur = cur.parentNode;
5261	+ level++;
5262	+ }
5263	+ }
5264	+
5265	+ return ret;
5266	+ }
5267	+
5268	+ // String
5269	+ var pos = POS.test( selectors ) \|\| typeof selectors !== "string" ?
5270	+ jQuery( selectors, context \|\| this.context ) :
5271	+ 0;
5272	+
5273	+ for ( i = 0, l = this.length; i < l; i++ ) {
5274	+ cur = this[i];
5275	+
5276	+ while ( cur ) {
5277	+ if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5278	+ ret.push( cur );
5279	+ break;
5280	+
5281	+ } else {
5282	+ cur = cur.parentNode;
5283	+ if ( !cur \|\| !cur.ownerDocument \|\| cur === context \|\| cur.nodeType === 11 ) {
5284	+ break;
5285	+ }
5286	+ }
5287	+ }
5288	+ }
5289	+
5290	+ ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5291	+
5292	+ return this.pushStack( ret, "closest", selectors );
5293	+ },
5294	+
5295	+ // Determine the position of an element within
5296	+ // the matched set of elements
5297	+ index: function( elem ) {
5298	+ if ( !elem \|\| typeof elem === "string" ) {
5299	+ return jQuery.inArray( this[0],
5300	+ // If it receives a string, the selector is used
5301	+ // If it receives nothing, the siblings are used
5302	+ elem ? jQuery( elem ) : this.parent().children() );
5303	+ }
5304	+ // Locate the position of the desired element
5305	+ return jQuery.inArray(
5306	+ // If it receives a jQuery object, the first element is used
5307	+ elem.jquery ? elem[0] : elem, this );
5308	+ },
5309	+
5310	+ add: function( selector, context ) {
5311	+ var set = typeof selector === "string" ?
5312	+ jQuery( selector, context ) :
5313	+ jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5314	+ all = jQuery.merge( this.get(), set );
5315	+
5316	+ return this.pushStack( isDisconnected( set[0] ) \|\| isDisconnected( all[0] ) ?
5317	+ all :
5318	+ jQuery.unique( all ) );
5319	+ },
5320	+
5321	+ andSelf: function() {
5322	+ return this.add( this.prevObject );
5323	+ }
5324	+ });
5325	+
5326	+ // A painfully simple check to see if an element is disconnected
5327	+ // from a document (should be improved, where feasible).
5328	+ function isDisconnected( node ) {
5329	+ return !node \|\| !node.parentNode \|\| node.parentNode.nodeType === 11;
5330	+ }
5331	+
5332	+ jQuery.each({
5333	+ parent: function( elem ) {
5334	+ var parent = elem.parentNode;
5335	+ return parent && parent.nodeType !== 11 ? parent : null;
5336	+ },
5337	+ parents: function( elem ) {
5338	+ return jQuery.dir( elem, "parentNode" );
5339	+ },
5340	+ parentsUntil: function( elem, i, until ) {
5341	+ return jQuery.dir( elem, "parentNode", until );
5342	+ },
5343	+ next: function( elem ) {
5344	+ return jQuery.nth( elem, 2, "nextSibling" );
5345	+ },
5346	+ prev: function( elem ) {
5347	+ return jQuery.nth( elem, 2, "previousSibling" );
5348	+ },
5349	+ nextAll: function( elem ) {
5350	+ return jQuery.dir( elem, "nextSibling" );
5351	+ },
5352	+ prevAll: function( elem ) {
5353	+ return jQuery.dir( elem, "previousSibling" );
5354	+ },
5355	+ nextUntil: function( elem, i, until ) {
5356	+ return jQuery.dir( elem, "nextSibling", until );
5357	+ },
5358	+ prevUntil: function( elem, i, until ) {
5359	+ return jQuery.dir( elem, "previousSibling", until );
5360	+ },
5361	+ siblings: function( elem ) {
5362	+ return jQuery.sibling( elem.parentNode.firstChild, elem );
5363	+ },
5364	+ children: function( elem ) {
5365	+ return jQuery.sibling( elem.firstChild );
5366	+ },
5367	+ contents: function( elem ) {
5368	+ return jQuery.nodeName( elem, "iframe" ) ?
5369	+ elem.contentDocument \|\| elem.contentWindow.document :
5370	+ jQuery.makeArray( elem.childNodes );
5371	+ }
5372	+ }, function( name, fn ) {
5373	+ jQuery.fn[ name ] = function( until, selector ) {
5374	+ var ret = jQuery.map( this, fn, until ),
5375	+ // The variable 'args' was introduced in
5376	+ // https://github.com/jquery/jquery/commit/52a0238
5377	+ // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
5378	+ // http://code.google.com/p/v8/issues/detail?id=1050
5379	+ args = slice.call(arguments);
5380	+
5381	+ if ( !runtil.test( name ) ) {
5382	+ selector = until;
5383	+ }
5384	+
5385	+ if ( selector && typeof selector === "string" ) {
5386	+ ret = jQuery.filter( selector, ret );
5387	+ }
5388	+
5389	+ ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5390	+
5391	+ if ( (this.length > 1 \|\| rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5392	+ ret = ret.reverse();
5393	+ }
5394	+
5395	+ return this.pushStack( ret, name, args.join(",") );
5396	+ };
5397	+ });
5398	+
5399	+ jQuery.extend({
5400	+ filter: function( expr, elems, not ) {
5401	+ if ( not ) {
5402	+ expr = ":not(" + expr + ")";
5403	+ }
5404	+
5405	+ return elems.length === 1 ?
5406	+ jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5407	+ jQuery.find.matches(expr, elems);
5408	+ },
5409	+
5410	+ dir: function( elem, dir, until ) {
5411	+ var matched = [],
5412	+ cur = elem[ dir ];
5413	+
5414	+ while ( cur && cur.nodeType !== 9 && (until === undefined \|\| cur.nodeType !== 1 \|\| !jQuery( cur ).is( until )) ) {
5415	+ if ( cur.nodeType === 1 ) {
5416	+ matched.push( cur );
5417	+ }
5418	+ cur = cur[dir];
5419	+ }
5420	+ return matched;
5421	+ },
5422	+
5423	+ nth: function( cur, result, dir, elem ) {
5424	+ result = result \|\| 1;
5425	+ var num = 0;
5426	+
5427	+ for ( ; cur; cur = cur[dir] ) {
5428	+ if ( cur.nodeType === 1 && ++num === result ) {
5429	+ break;
5430	+ }
5431	+ }
5432	+
5433	+ return cur;
5434	+ },
5435	+
5436	+ sibling: function( n, elem ) {
5437	+ var r = [];
5438	+
5439	+ for ( ; n; n = n.nextSibling ) {
5440	+ if ( n.nodeType === 1 && n !== elem ) {
5441	+ r.push( n );
5442	+ }
5443	+ }
5444	+
5445	+ return r;
5446	+ }
5447	+ });
5448	+
5449	+ // Implement the identical functionality for filter and not
5450	+ function winnow( elements, qualifier, keep ) {
5451	+
5452	+ // Can't pass null or undefined to indexOf in Firefox 4
5453	+ // Set to 0 to skip string check
5454	+ qualifier = qualifier \|\| 0;
5455	+
5456	+ if ( jQuery.isFunction( qualifier ) ) {
5457	+ return jQuery.grep(elements, function( elem, i ) {
5458	+ var retVal = !!qualifier.call( elem, i, elem );
5459	+ return retVal === keep;
5460	+ });
5461	+
5462	+ } else if ( qualifier.nodeType ) {
5463	+ return jQuery.grep(elements, function( elem, i ) {
5464	+ return (elem === qualifier) === keep;
5465	+ });
5466	+
5467	+ } else if ( typeof qualifier === "string" ) {
5468	+ var filtered = jQuery.grep(elements, function( elem ) {
5469	+ return elem.nodeType === 1;
5470	+ });
5471	+
5472	+ if ( isSimple.test( qualifier ) ) {
5473	+ return jQuery.filter(qualifier, filtered, !keep);
5474	+ } else {
5475	+ qualifier = jQuery.filter( qualifier, filtered );
5476	+ }
5477	+ }
5478	+
5479	+ return jQuery.grep(elements, function( elem, i ) {
5480	+ return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
5481	+ });
5482	+ }
5483	+
5484	+
5485	+
5486	+
5487	+ var rinlinejQuery = / jQuery\d+="(?:\d+\|null)"/g,
5488	+ rleadingWhitespace = /^\s+/,
5489	+ rxhtmlTag = /<(?!area\|br\|col\|embed\|hr\|img\|input\|link\|meta\|param)(([\w:]+)[^>]*)\/>/ig,
5490	+ rtagName = /<([\w:]+)/,
5491	+ rtbody = /<tbody/i,
5492	+ rhtml = /<\|&#?\w+;/,
5493	+ rnocache = /<(?:script\|object\|embed\|option\|style)/i,
5494	+ // checked="checked" or checked
5495	+ rchecked = /checked\s(?:[^=]\|=\s.checked.)/i,
5496	+ rscriptType = /\/(java\|ecma)script/i,
5497	+ rcleanScript = /^\s*<!(?:\[CDATA\[\|\-\-)/,
5498	+ wrapMap = {
5499	+ option: [ 1, "<select multiple='multiple'>", "</select>" ],
5500	+ legend: [ 1, "<fieldset>", "</fieldset>" ],
5501	+ thead: [ 1, "<table>", "</table>" ],
5502	+ tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5503	+ td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5504	+ col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5505	+ area: [ 1, "<map>", "</map>" ],
5506	+ _default: [ 0, "", "" ]
5507	+ };
5508	+
5509	+ wrapMap.optgroup = wrapMap.option;
5510	+ wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5511	+ wrapMap.th = wrapMap.td;
5512	+
5513	+ // IE can't serialize <link> and <script> tags normally
5514	+ if ( !jQuery.support.htmlSerialize ) {
5515	+ wrapMap._default = [ 1, "div<div>", "</div>" ];
5516	+ }
5517	+
5518	+ jQuery.fn.extend({
5519	+ text: function( text ) {
5520	+ if ( jQuery.isFunction(text) ) {
5521	+ return this.each(function(i) {
5522	+ var self = jQuery( this );
5523	+
5524	+ self.text( text.call(this, i, self.text()) );
5525	+ });
5526	+ }
5527	+
5528	+ if ( typeof text !== "object" && text !== undefined ) {
5529	+ return this.empty().append( (this[0] && this[0].ownerDocument \|\| document).createTextNode( text ) );
5530	+ }
5531	+
5532	+ return jQuery.text( this );
5533	+ },
5534	+
5535	+ wrapAll: function( html ) {
5536	+ if ( jQuery.isFunction( html ) ) {
5537	+ return this.each(function(i) {
5538	+ jQuery(this).wrapAll( html.call(this, i) );
5539	+ });
5540	+ }
5541	+
5542	+ if ( this[0] ) {
5543	+ // The elements to wrap the target around
5544	+ var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5545	+
5546	+ if ( this[0].parentNode ) {
5547	+ wrap.insertBefore( this[0] );
5548	+ }
5549	+
5550	+ wrap.map(function() {
5551	+ var elem = this;
5552	+
5553	+ while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5554	+ elem = elem.firstChild;
5555	+ }
5556	+
5557	+ return elem;
5558	+ }).append( this );
5559	+ }
5560	+
5561	+ return this;
5562	+ },
5563	+
5564	+ wrapInner: function( html ) {
5565	+ if ( jQuery.isFunction( html ) ) {
5566	+ return this.each(function(i) {
5567	+ jQuery(this).wrapInner( html.call(this, i) );
5568	+ });
5569	+ }
5570	+
5571	+ return this.each(function() {
5572	+ var self = jQuery( this ),
5573	+ contents = self.contents();
5574	+
5575	+ if ( contents.length ) {
5576	+ contents.wrapAll( html );
5577	+
5578	+ } else {
5579	+ self.append( html );
5580	+ }
5581	+ });
5582	+ },
5583	+
5584	+ wrap: function( html ) {
5585	+ return this.each(function() {
5586	+ jQuery( this ).wrapAll( html );
5587	+ });
5588	+ },
5589	+
5590	+ unwrap: function() {
5591	+ return this.parent().each(function() {
5592	+ if ( !jQuery.nodeName( this, "body" ) ) {
5593	+ jQuery( this ).replaceWith( this.childNodes );
5594	+ }
5595	+ }).end();
5596	+ },
5597	+
5598	+ append: function() {
5599	+ return this.domManip(arguments, true, function( elem ) {
5600	+ if ( this.nodeType === 1 ) {
5601	+ this.appendChild( elem );
5602	+ }
5603	+ });
5604	+ },
5605	+
5606	+ prepend: function() {
5607	+ return this.domManip(arguments, true, function( elem ) {
5608	+ if ( this.nodeType === 1 ) {
5609	+ this.insertBefore( elem, this.firstChild );
5610	+ }
5611	+ });
5612	+ },
5613	+
5614	+ before: function() {
5615	+ if ( this[0] && this[0].parentNode ) {
5616	+ return this.domManip(arguments, false, function( elem ) {
5617	+ this.parentNode.insertBefore( elem, this );
5618	+ });
5619	+ } else if ( arguments.length ) {
5620	+ var set = jQuery(arguments[0]);
5621	+ set.push.apply( set, this.toArray() );
5622	+ return this.pushStack( set, "before", arguments );
5623	+ }
5624	+ },
5625	+
5626	+ after: function() {
5627	+ if ( this[0] && this[0].parentNode ) {
5628	+ return this.domManip(arguments, false, function( elem ) {
5629	+ this.parentNode.insertBefore( elem, this.nextSibling );
5630	+ });
5631	+ } else if ( arguments.length ) {
5632	+ var set = this.pushStack( this, "after", arguments );
5633	+ set.push.apply( set, jQuery(arguments[0]).toArray() );
5634	+ return set;
5635	+ }
5636	+ },
5637	+
5638	+ // keepData is for internal use only--do not document
5639	+ remove: function( selector, keepData ) {
5640	+ for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5641	+ if ( !selector \|\| jQuery.filter( selector, [ elem ] ).length ) {
5642	+ if ( !keepData && elem.nodeType === 1 ) {
5643	+ jQuery.cleanData( elem.getElementsByTagName("*") );
5644	+ jQuery.cleanData( [ elem ] );
5645	+ }
5646	+
5647	+ if ( elem.parentNode ) {
5648	+ elem.parentNode.removeChild( elem );
5649	+ }
5650	+ }
5651	+ }
5652	+
5653	+ return this;
5654	+ },
5655	+
5656	+ empty: function() {
5657	+ for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5658	+ // Remove element nodes and prevent memory leaks
5659	+ if ( elem.nodeType === 1 ) {
5660	+ jQuery.cleanData( elem.getElementsByTagName("*") );
5661	+ }
5662	+
5663	+ // Remove any remaining nodes
5664	+ while ( elem.firstChild ) {
5665	+ elem.removeChild( elem.firstChild );
5666	+ }
5667	+ }
5668	+
5669	+ return this;
5670	+ },
5671	+
5672	+ clone: function( dataAndEvents, deepDataAndEvents ) {
5673	+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5674	+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5675	+
5676	+ return this.map( function () {
5677	+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5678	+ });
5679	+ },
5680	+
5681	+ html: function( value ) {
5682	+ if ( value === undefined ) {
5683	+ return this[0] && this[0].nodeType === 1 ?
5684	+ this[0].innerHTML.replace(rinlinejQuery, "") :
5685	+ null;
5686	+
5687	+ // See if we can take a shortcut and just use innerHTML
5688	+ } else if ( typeof value === "string" && !rnocache.test( value ) &&
5689	+ (jQuery.support.leadingWhitespace \|\| !rleadingWhitespace.test( value )) &&
5690	+ !wrapMap[ (rtagName.exec( value ) \|\| ["", ""])[1].toLowerCase() ] ) {
5691	+
5692	+ value = value.replace(rxhtmlTag, "<$1></$2>");
5693	+
5694	+ try {
5695	+ for ( var i = 0, l = this.length; i < l; i++ ) {
5696	+ // Remove element nodes and prevent memory leaks
5697	+ if ( this[i].nodeType === 1 ) {
5698	+ jQuery.cleanData( this[i].getElementsByTagName("*") );
5699	+ this[i].innerHTML = value;
5700	+ }
5701	+ }
5702	+
5703	+ // If using innerHTML throws an exception, use the fallback method
5704	+ } catch(e) {
5705	+ this.empty().append( value );
5706	+ }
5707	+
5708	+ } else if ( jQuery.isFunction( value ) ) {
5709	+ this.each(function(i){
5710	+ var self = jQuery( this );
5711	+
5712	+ self.html( value.call(this, i, self.html()) );
5713	+ });
5714	+
5715	+ } else {
5716	+ this.empty().append( value );
5717	+ }
5718	+
5719	+ return this;
5720	+ },
5721	+
5722	+ replaceWith: function( value ) {
5723	+ if ( this[0] && this[0].parentNode ) {
5724	+ // Make sure that the elements are removed from the DOM before they are inserted
5725	+ // this can help fix replacing a parent with child elements
5726	+ if ( jQuery.isFunction( value ) ) {
5727	+ return this.each(function(i) {
5728	+ var self = jQuery(this), old = self.html();
5729	+ self.replaceWith( value.call( this, i, old ) );
5730	+ });
5731	+ }
5732	+
5733	+ if ( typeof value !== "string" ) {
5734	+ value = jQuery( value ).detach();
5735	+ }
5736	+
5737	+ return this.each(function() {
5738	+ var next = this.nextSibling,
5739	+ parent = this.parentNode;
5740	+
5741	+ jQuery( this ).remove();
5742	+
5743	+ if ( next ) {
5744	+ jQuery(next).before( value );
5745	+ } else {
5746	+ jQuery(parent).append( value );
5747	+ }
5748	+ });
5749	+ } else {
5750	+ return this.length ?
5751	+ this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5752	+ this;
5753	+ }
5754	+ },
5755	+
5756	+ detach: function( selector ) {
5757	+ return this.remove( selector, true );
5758	+ },
5759	+
5760	+ domManip: function( args, table, callback ) {
5761	+ var results, first, fragment, parent,
5762	+ value = args[0],
5763	+ scripts = [];
5764	+
5765	+ // We can't cloneNode fragments that contain checked, in WebKit
5766	+ if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5767	+ return this.each(function() {
5768	+ jQuery(this).domManip( args, table, callback, true );
5769	+ });
5770	+ }
5771	+
5772	+ if ( jQuery.isFunction(value) ) {
5773	+ return this.each(function(i) {
5774	+ var self = jQuery(this);
5775	+ args[0] = value.call(this, i, table ? self.html() : undefined);
5776	+ self.domManip( args, table, callback );
5777	+ });
5778	+ }
5779	+
5780	+ if ( this[0] ) {
5781	+ parent = value && value.parentNode;
5782	+
5783	+ // If we're in a fragment, just use that instead of building a new one
5784	+ if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5785	+ results = { fragment: parent };
5786	+
5787	+ } else {
5788	+ results = jQuery.buildFragment( args, this, scripts );
5789	+ }
5790	+
5791	+ fragment = results.fragment;
5792	+
5793	+ if ( fragment.childNodes.length === 1 ) {
5794	+ first = fragment = fragment.firstChild;
5795	+ } else {
5796	+ first = fragment.firstChild;
5797	+ }
5798	+
5799	+ if ( first ) {
5800	+ table = table && jQuery.nodeName( first, "tr" );
5801	+
5802	+ for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5803	+ callback.call(
5804	+ table ?
5805	+ root(this[i], first) :
5806	+ this[i],
5807	+ // Make sure that we do not leak memory by inadvertently discarding
5808	+ // the original fragment (which might have attached data) instead of
5809	+ // using it; in addition, use the original fragment object for the last
5810	+ // item instead of first because it can end up being emptied incorrectly
5811	+ // in certain situations (Bug #8070).
5812	+ // Fragments from the fragment cache must always be cloned and never used
5813	+ // in place.
5814	+ results.cacheable \|\| (l > 1 && i < lastIndex) ?
5815	+ jQuery.clone( fragment, true, true ) :
5816	+ fragment
5817	+ );
5818	+ }
5819	+ }
5820	+
5821	+ if ( scripts.length ) {
5822	+ jQuery.each( scripts, evalScript );
5823	+ }
5824	+ }
5825	+
5826	+ return this;
5827	+ }
5828	+ });
5829	+
5830	+ function root( elem, cur ) {
5831	+ return jQuery.nodeName(elem, "table") ?
5832	+ (elem.getElementsByTagName("tbody")[0] \|\|
5833	+ elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5834	+ elem;
5835	+ }
5836	+
5837	+ function cloneCopyEvent( src, dest ) {
5838	+
5839	+ if ( dest.nodeType !== 1 \|\| !jQuery.hasData( src ) ) {
5840	+ return;
5841	+ }
5842	+
5843	+ var internalKey = jQuery.expando,
5844	+ oldData = jQuery.data( src ),
5845	+ curData = jQuery.data( dest, oldData );
5846	+
5847	+ // Switch to use the internal data object, if it exists, for the next
5848	+ // stage of data copying
5849	+ if ( (oldData = oldData[ internalKey ]) ) {
5850	+ var events = oldData.events;
5851	+ curData = curData[ internalKey ] = jQuery.extend({}, oldData);
5852	+
5853	+ if ( events ) {
5854	+ delete curData.handle;
5855	+ curData.events = {};
5856	+
5857	+ for ( var type in events ) {
5858	+ for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
5859	+ jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
5860	+ }
5861	+ }
5862	+ }
5863	+ }
5864	+ }
5865	+
5866	+ function cloneFixAttributes( src, dest ) {
5867	+ var nodeName;
5868	+
5869	+ // We do not need to do anything for non-Elements
5870	+ if ( dest.nodeType !== 1 ) {
5871	+ return;
5872	+ }
5873	+
5874	+ // clearAttributes removes the attributes, which we don't want,
5875	+ // but also removes the attachEvent events, which we do want
5876	+ if ( dest.clearAttributes ) {
5877	+ dest.clearAttributes();
5878	+ }
5879	+
5880	+ // mergeAttributes, in contrast, only merges back on the
5881	+ // original attributes, not the events
5882	+ if ( dest.mergeAttributes ) {
5883	+ dest.mergeAttributes( src );
5884	+ }
5885	+
5886	+ nodeName = dest.nodeName.toLowerCase();
5887	+
5888	+ // IE6-8 fail to clone children inside object elements that use
5889	+ // the proprietary classid attribute value (rather than the type
5890	+ // attribute) to identify the type of content to display
5891	+ if ( nodeName === "object" ) {
5892	+ dest.outerHTML = src.outerHTML;
5893	+
5894	+ } else if ( nodeName === "input" && (src.type === "checkbox" \|\| src.type === "radio") ) {
5895	+ // IE6-8 fails to persist the checked state of a cloned checkbox
5896	+ // or radio button. Worse, IE6-7 fail to give the cloned element
5897	+ // a checked appearance if the defaultChecked value isn't also set
5898	+ if ( src.checked ) {
5899	+ dest.defaultChecked = dest.checked = src.checked;
5900	+ }
5901	+
5902	+ // IE6-7 get confused and end up setting the value of a cloned
5903	+ // checkbox/radio button to an empty string instead of "on"
5904	+ if ( dest.value !== src.value ) {
5905	+ dest.value = src.value;
5906	+ }
5907	+
5908	+ // IE6-8 fails to return the selected option to the default selected
5909	+ // state when cloning options
5910	+ } else if ( nodeName === "option" ) {
5911	+ dest.selected = src.defaultSelected;
5912	+
5913	+ // IE6-8 fails to set the defaultValue to the correct value when
5914	+ // cloning other types of input fields
5915	+ } else if ( nodeName === "input" \|\| nodeName === "textarea" ) {
5916	+ dest.defaultValue = src.defaultValue;
5917	+ }
5918	+
5919	+ // Event data gets referenced instead of copied if the expando
5920	+ // gets copied too
5921	+ dest.removeAttribute( jQuery.expando );
5922	+ }
5923	+
5924	+ jQuery.buildFragment = function( args, nodes, scripts ) {
5925	+ var fragment, cacheable, cacheresults, doc;
5926	+
5927	+ // nodes may contain either an explicit document object,
5928	+ // a jQuery collection or context object.
5929	+ // If nodes[0] contains a valid object to assign to doc
5930	+ if ( nodes && nodes[0] ) {
5931	+ doc = nodes[0].ownerDocument \|\| nodes[0];
5932	+ }
5933	+
5934	+ // Ensure that an attr object doesn't incorrectly stand in as a document object
5935	+ // Chrome and Firefox seem to allow this to occur and will throw exception
5936	+ // Fixes #8950
5937	+ if ( !doc.createDocumentFragment ) {
5938	+ doc = document;
5939	+ }
5940	+
5941	+ // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
5942	+ // Cloning options loses the selected state, so don't cache them
5943	+ // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5944	+ // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5945	+ if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5946	+ args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone \|\| !rchecked.test( args[0] )) ) {
5947	+
5948	+ cacheable = true;
5949	+
5950	+ cacheresults = jQuery.fragments[ args[0] ];
5951	+ if ( cacheresults && cacheresults !== 1 ) {
5952	+ fragment = cacheresults;
5953	+ }
5954	+ }
5955	+
5956	+ if ( !fragment ) {
5957	+ fragment = doc.createDocumentFragment();
5958	+ jQuery.clean( args, doc, fragment, scripts );
5959	+ }
5960	+
5961	+ if ( cacheable ) {
5962	+ jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
5963	+ }
5964	+
5965	+ return { fragment: fragment, cacheable: cacheable };
5966	+ };
5967	+
5968	+ jQuery.fragments = {};
5969	+
5970	+ jQuery.each({
5971	+ appendTo: "append",
5972	+ prependTo: "prepend",
5973	+ insertBefore: "before",
5974	+ insertAfter: "after",
5975	+ replaceAll: "replaceWith"
5976	+ }, function( name, original ) {
5977	+ jQuery.fn[ name ] = function( selector ) {
5978	+ var ret = [],
5979	+ insert = jQuery( selector ),
5980	+ parent = this.length === 1 && this[0].parentNode;
5981	+
5982	+ if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5983	+ insert[ original ]( this[0] );
5984	+ return this;
5985	+
5986	+ } else {
5987	+ for ( var i = 0, l = insert.length; i < l; i++ ) {
5988	+ var elems = (i > 0 ? this.clone(true) : this).get();
5989	+ jQuery( insert[i] )[ original ]( elems );
5990	+ ret = ret.concat( elems );
5991	+ }
5992	+
5993	+ return this.pushStack( ret, name, insert.selector );
5994	+ }
5995	+ };
5996	+ });
5997	+
5998	+ function getAll( elem ) {
5999	+ if ( "getElementsByTagName" in elem ) {
6000	+ return elem.getElementsByTagName( "*" );
6001	+
6002	+ } else if ( "querySelectorAll" in elem ) {
6003	+ return elem.querySelectorAll( "*" );
6004	+
6005	+ } else {
6006	+ return [];
6007	+ }
6008	+ }
6009	+
6010	+ // Used in clean, fixes the defaultChecked property
6011	+ function fixDefaultChecked( elem ) {
6012	+ if ( elem.type === "checkbox" \|\| elem.type === "radio" ) {
6013	+ elem.defaultChecked = elem.checked;
6014	+ }
6015	+ }
6016	+ // Finds all inputs and passes them to fixDefaultChecked
6017	+ function findInputs( elem ) {
6018	+ if ( jQuery.nodeName( elem, "input" ) ) {
6019	+ fixDefaultChecked( elem );
6020	+ } else if ( "getElementsByTagName" in elem ) {
6021	+ jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
6022	+ }
6023	+ }
6024	+
6025	+ jQuery.extend({
6026	+ clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6027	+ var clone = elem.cloneNode(true),
6028	+ srcElements,
6029	+ destElements,
6030	+ i;
6031	+
6032	+ if ( (!jQuery.support.noCloneEvent \|\| !jQuery.support.noCloneChecked) &&
6033	+ (elem.nodeType === 1 \|\| elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6034	+ // IE copies events bound via attachEvent when using cloneNode.
6035	+ // Calling detachEvent on the clone will also remove the events
6036	+ // from the original. In order to get around this, we use some
6037	+ // proprietary methods to clear the events. Thanks to MooTools
6038	+ // guys for this hotness.
6039	+
6040	+ cloneFixAttributes( elem, clone );
6041	+
6042	+ // Using Sizzle here is crazy slow, so we use getElementsByTagName
6043	+ // instead
6044	+ srcElements = getAll( elem );
6045	+ destElements = getAll( clone );
6046	+
6047	+ // Weird iteration because IE will replace the length property
6048	+ // with an element if you are cloning the body and one of the
6049	+ // elements on the page has a name or id of "length"
6050	+ for ( i = 0; srcElements[i]; ++i ) {
6051	+ cloneFixAttributes( srcElements[i], destElements[i] );
6052	+ }
6053	+ }
6054	+
6055	+ // Copy the events from the original to the clone
6056	+ if ( dataAndEvents ) {
6057	+ cloneCopyEvent( elem, clone );
6058	+
6059	+ if ( deepDataAndEvents ) {
6060	+ srcElements = getAll( elem );
6061	+ destElements = getAll( clone );
6062	+
6063	+ for ( i = 0; srcElements[i]; ++i ) {
6064	+ cloneCopyEvent( srcElements[i], destElements[i] );
6065	+ }
6066	+ }
6067	+ }
6068	+
6069	+ srcElements = destElements = null;
6070	+
6071	+ // Return the cloned set
6072	+ return clone;
6073	+ },
6074	+
6075	+ clean: function( elems, context, fragment, scripts ) {
6076	+ var checkScriptType;
6077	+
6078	+ context = context \|\| document;
6079	+
6080	+ // !context.createElement fails in IE with an error but returns typeof 'object'
6081	+ if ( typeof context.createElement === "undefined" ) {
6082	+ context = context.ownerDocument \|\| context[0] && context[0].ownerDocument \|\| document;
6083	+ }
6084	+
6085	+ var ret = [], j;
6086	+
6087	+ for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6088	+ if ( typeof elem === "number" ) {
6089	+ elem += "";
6090	+ }
6091	+
6092	+ if ( !elem ) {
6093	+ continue;
6094	+ }
6095	+
6096	+ // Convert html string into DOM nodes
6097	+ if ( typeof elem === "string" ) {
6098	+ if ( !rhtml.test( elem ) ) {
6099	+ elem = context.createTextNode( elem );
6100	+ } else {
6101	+ // Fix "XHTML"-style tags in all browsers
6102	+ elem = elem.replace(rxhtmlTag, "<$1></$2>");
6103	+
6104	+ // Trim whitespace, otherwise indexOf won't work as expected
6105	+ var tag = (rtagName.exec( elem ) \|\| ["", ""])[1].toLowerCase(),
6106	+ wrap = wrapMap[ tag ] \|\| wrapMap._default,
6107	+ depth = wrap[0],
6108	+ div = context.createElement("div");
6109	+
6110	+ // Go to html and back, then peel off extra wrappers
6111	+ div.innerHTML = wrap[1] + elem + wrap[2];
6112	+
6113	+ // Move to the right depth
6114	+ while ( depth-- ) {
6115	+ div = div.lastChild;
6116	+ }
6117	+
6118	+ // Remove IE's autoinserted <tbody> from table fragments
6119	+ if ( !jQuery.support.tbody ) {
6120	+
6121	+ // String was a <table>, may have spurious <tbody>
6122	+ var hasBody = rtbody.test(elem),
6123	+ tbody = tag === "table" && !hasBody ?
6124	+ div.firstChild && div.firstChild.childNodes :
6125	+
6126	+ // String was a bare <thead> or <tfoot>
6127	+ wrap[1] === "<table>" && !hasBody ?
6128	+ div.childNodes :
6129	+ [];
6130	+
6131	+ for ( j = tbody.length - 1; j >= 0 ; --j ) {
6132	+ if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6133	+ tbody[ j ].parentNode.removeChild( tbody[ j ] );
6134	+ }
6135	+ }
6136	+ }
6137	+
6138	+ // IE completely kills leading whitespace when innerHTML is used
6139	+ if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6140	+ div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6141	+ }
6142	+
6143	+ elem = div.childNodes;
6144	+ }
6145	+ }
6146	+
6147	+ // Resets defaultChecked for any radios and checkboxes
6148	+ // about to be appended to the DOM in IE 6/7 (#8060)
6149	+ var len;
6150	+ if ( !jQuery.support.appendChecked ) {
6151	+ if ( elem[0] && typeof (len = elem.length) === "number" ) {
6152	+ for ( j = 0; j < len; j++ ) {
6153	+ findInputs( elem[j] );
6154	+ }
6155	+ } else {
6156	+ findInputs( elem );
6157	+ }
6158	+ }
6159	+
6160	+ if ( elem.nodeType ) {
6161	+ ret.push( elem );
6162	+ } else {
6163	+ ret = jQuery.merge( ret, elem );
6164	+ }
6165	+ }
6166	+
6167	+ if ( fragment ) {
6168	+ checkScriptType = function( elem ) {
6169	+ return !elem.type \|\| rscriptType.test( elem.type );
6170	+ };
6171	+ for ( i = 0; ret[i]; i++ ) {
6172	+ if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type \|\| ret[i].type.toLowerCase() === "text/javascript") ) {
6173	+ scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6174	+
6175	+ } else {
6176	+ if ( ret[i].nodeType === 1 ) {
6177	+ var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6178	+
6179	+ ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6180	+ }
6181	+ fragment.appendChild( ret[i] );
6182	+ }
6183	+ }
6184	+ }
6185	+
6186	+ return ret;
6187	+ },
6188	+
6189	+ cleanData: function( elems ) {
6190	+ var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
6191	+ deleteExpando = jQuery.support.deleteExpando;
6192	+
6193	+ for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6194	+ if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6195	+ continue;
6196	+ }
6197	+
6198	+ id = elem[ jQuery.expando ];
6199	+
6200	+ if ( id ) {
6201	+ data = cache[ id ] && cache[ id ][ internalKey ];
6202	+
6203	+ if ( data && data.events ) {
6204	+ for ( var type in data.events ) {
6205	+ if ( special[ type ] ) {
6206	+ jQuery.event.remove( elem, type );
6207	+
6208	+ // This is a shortcut to avoid jQuery.event.remove's overhead
6209	+ } else {
6210	+ jQuery.removeEvent( elem, type, data.handle );
6211	+ }
6212	+ }
6213	+
6214	+ // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6215	+ if ( data.handle ) {
6216	+ data.handle.elem = null;
6217	+ }
6218	+ }
6219	+
6220	+ if ( deleteExpando ) {
6221	+ delete elem[ jQuery.expando ];
6222	+
6223	+ } else if ( elem.removeAttribute ) {
6224	+ elem.removeAttribute( jQuery.expando );
6225	+ }
6226	+
6227	+ delete cache[ id ];
6228	+ }
6229	+ }
6230	+ }
6231	+ });
6232	+
6233	+ function evalScript( i, elem ) {
6234	+ if ( elem.src ) {
6235	+ jQuery.ajax({
6236	+ url: elem.src,
6237	+ async: false,
6238	+ dataType: "script"
6239	+ });
6240	+ } else {
6241	+ jQuery.globalEval( ( elem.text \|\| elem.textContent \|\| elem.innerHTML \|\| "" ).replace( rcleanScript, "/$0/" ) );
6242	+ }
6243	+
6244	+ if ( elem.parentNode ) {
6245	+ elem.parentNode.removeChild( elem );
6246	+ }
6247	+ }
6248	+
6249	+
6250	+
6251	+ var ralpha = /alpha$[^)]*$/i,
6252	+ ropacity = /opacity=([^)]*)/,
6253	+ // fixed for IE9, see #8346
6254	+ rupper = /([A-Z]\|^ms)/g,
6255	+ rnumpx = /^-?\d+(?:px)?$/i,
6256	+ rnum = /^-?\d/,
6257	+ rrelNum = /^[+\-]=/,
6258	+ rrelNumFilter = /[^+\-\.\de]+/g,
6259	+
6260	+ cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6261	+ cssWidth = [ "Left", "Right" ],
6262	+ cssHeight = [ "Top", "Bottom" ],
6263	+ curCSS,
6264	+
6265	+ getComputedStyle,
6266	+ currentStyle;
6267	+
6268	+ jQuery.fn.css = function( name, value ) {
6269	+ // Setting 'undefined' is a no-op
6270	+ if ( arguments.length === 2 && value === undefined ) {
6271	+ return this;
6272	+ }
6273	+
6274	+ return jQuery.access( this, name, value, true, function( elem, name, value ) {
6275	+ return value !== undefined ?
6276	+ jQuery.style( elem, name, value ) :
6277	+ jQuery.css( elem, name );
6278	+ });
6279	+ };
6280	+
6281	+ jQuery.extend({
6282	+ // Add in style property hooks for overriding the default
6283	+ // behavior of getting and setting a style property
6284	+ cssHooks: {
6285	+ opacity: {
6286	+ get: function( elem, computed ) {
6287	+ if ( computed ) {
6288	+ // We should always get a number back from opacity
6289	+ var ret = curCSS( elem, "opacity", "opacity" );
6290	+ return ret === "" ? "1" : ret;
6291	+
6292	+ } else {
6293	+ return elem.style.opacity;
6294	+ }
6295	+ }
6296	+ }
6297	+ },
6298	+
6299	+ // Exclude the following css properties to add px
6300	+ cssNumber: {
6301	+ "fillOpacity": true,
6302	+ "fontWeight": true,
6303	+ "lineHeight": true,
6304	+ "opacity": true,
6305	+ "orphans": true,
6306	+ "widows": true,
6307	+ "zIndex": true,
6308	+ "zoom": true
6309	+ },
6310	+
6311	+ // Add in properties whose names you wish to fix before
6312	+ // setting or getting the value
6313	+ cssProps: {
6314	+ // normalize float css property
6315	+ "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6316	+ },
6317	+
6318	+ // Get and set the style property on a DOM Node
6319	+ style: function( elem, name, value, extra ) {
6320	+ // Don't set styles on text and comment nodes
6321	+ if ( !elem \|\| elem.nodeType === 3 \|\| elem.nodeType === 8 \|\| !elem.style ) {
6322	+ return;
6323	+ }
6324	+
6325	+ // Make sure that we're working with the right name
6326	+ var ret, type, origName = jQuery.camelCase( name ),
6327	+ style = elem.style, hooks = jQuery.cssHooks[ origName ];
6328	+
6329	+ name = jQuery.cssProps[ origName ] \|\| origName;
6330	+
6331	+ // Check if we're setting a value
6332	+ if ( value !== undefined ) {
6333	+ type = typeof value;
6334	+
6335	+ // Make sure that NaN and null values aren't set. See: #7116
6336	+ if ( type === "number" && isNaN( value ) \|\| value == null ) {
6337	+ return;
6338	+ }
6339	+
6340	+ // convert relative number strings (+= or -=) to relative numbers. #7345
6341	+ if ( type === "string" && rrelNum.test( value ) ) {
6342	+ value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
6343	+ // Fixes bug #9237
6344	+ type = "number";
6345	+ }
6346	+
6347	+ // If a number was passed in, add 'px' to the (except for certain CSS properties)
6348	+ if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6349	+ value += "px";
6350	+ }
6351	+
6352	+ // If a hook was provided, use that value, otherwise just set the specified value
6353	+ if ( !hooks \|\| !("set" in hooks) \|\| (value = hooks.set( elem, value )) !== undefined ) {
6354	+ // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6355	+ // Fixes bug #5509
6356	+ try {
6357	+ style[ name ] = value;
6358	+ } catch(e) {}
6359	+ }
6360	+
6361	+ } else {
6362	+ // If a hook was provided get the non-computed value from there
6363	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6364	+ return ret;
6365	+ }
6366	+
6367	+ // Otherwise just get the value from the style object
6368	+ return style[ name ];
6369	+ }
6370	+ },
6371	+
6372	+ css: function( elem, name, extra ) {
6373	+ var ret, hooks;
6374	+
6375	+ // Make sure that we're working with the right name
6376	+ name = jQuery.camelCase( name );
6377	+ hooks = jQuery.cssHooks[ name ];
6378	+ name = jQuery.cssProps[ name ] \|\| name;
6379	+
6380	+ // cssFloat needs a special treatment
6381	+ if ( name === "cssFloat" ) {
6382	+ name = "float";
6383	+ }
6384	+
6385	+ // If a hook was provided get the computed value from there
6386	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6387	+ return ret;
6388	+
6389	+ // Otherwise, if a way to get the computed value exists, use that
6390	+ } else if ( curCSS ) {
6391	+ return curCSS( elem, name );
6392	+ }
6393	+ },
6394	+
6395	+ // A method for quickly swapping in/out CSS properties to get correct calculations
6396	+ swap: function( elem, options, callback ) {
6397	+ var old = {};
6398	+
6399	+ // Remember the old values, and insert the new ones
6400	+ for ( var name in options ) {
6401	+ old[ name ] = elem.style[ name ];
6402	+ elem.style[ name ] = options[ name ];
6403	+ }
6404	+
6405	+ callback.call( elem );
6406	+
6407	+ // Revert the old values
6408	+ for ( name in options ) {
6409	+ elem.style[ name ] = old[ name ];
6410	+ }
6411	+ }
6412	+ });
6413	+
6414	+ // DEPRECATED, Use jQuery.css() instead
6415	+ jQuery.curCSS = jQuery.css;
6416	+
6417	+ jQuery.each(["height", "width"], function( i, name ) {
6418	+ jQuery.cssHooks[ name ] = {
6419	+ get: function( elem, computed, extra ) {
6420	+ var val;
6421	+
6422	+ if ( computed ) {
6423	+ if ( elem.offsetWidth !== 0 ) {
6424	+ return getWH( elem, name, extra );
6425	+ } else {
6426	+ jQuery.swap( elem, cssShow, function() {
6427	+ val = getWH( elem, name, extra );
6428	+ });
6429	+ }
6430	+
6431	+ return val;
6432	+ }
6433	+ },
6434	+
6435	+ set: function( elem, value ) {
6436	+ if ( rnumpx.test( value ) ) {
6437	+ // ignore negative width and height values #1599
6438	+ value = parseFloat( value );
6439	+
6440	+ if ( value >= 0 ) {
6441	+ return value + "px";
6442	+ }
6443	+
6444	+ } else {
6445	+ return value;
6446	+ }
6447	+ }
6448	+ };
6449	+ });
6450	+
6451	+ if ( !jQuery.support.opacity ) {
6452	+ jQuery.cssHooks.opacity = {
6453	+ get: function( elem, computed ) {
6454	+ // IE uses filters for opacity
6455	+ return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) \|\| "" ) ?
6456	+ ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6457	+ computed ? "1" : "";
6458	+ },
6459	+
6460	+ set: function( elem, value ) {
6461	+ var style = elem.style,
6462	+ currentStyle = elem.currentStyle;
6463	+
6464	+ // IE has trouble with opacity if it does not have layout
6465	+ // Force it by setting the zoom level
6466	+ style.zoom = 1;
6467	+
6468	+ // Set the alpha filter to set the opacity
6469	+ var opacity = jQuery.isNaN( value ) ?
6470	+ "" :
6471	+ "alpha(opacity=" + value * 100 + ")",
6472	+ filter = currentStyle && currentStyle.filter \|\| style.filter \|\| "";
6473	+
6474	+ style.filter = ralpha.test( filter ) ?
6475	+ filter.replace( ralpha, opacity ) :
6476	+ filter + " " + opacity;
6477	+ }
6478	+ };
6479	+ }
6480	+
6481	+ jQuery(function() {
6482	+ // This hook cannot be added until DOM ready because the support test
6483	+ // for it is not run until after DOM ready
6484	+ if ( !jQuery.support.reliableMarginRight ) {
6485	+ jQuery.cssHooks.marginRight = {
6486	+ get: function( elem, computed ) {
6487	+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6488	+ // Work around by temporarily setting element display to inline-block
6489	+ var ret;
6490	+ jQuery.swap( elem, { "display": "inline-block" }, function() {
6491	+ if ( computed ) {
6492	+ ret = curCSS( elem, "margin-right", "marginRight" );
6493	+ } else {
6494	+ ret = elem.style.marginRight;
6495	+ }
6496	+ });
6497	+ return ret;
6498	+ }
6499	+ };
6500	+ }
6501	+ });
6502	+
6503	+ if ( document.defaultView && document.defaultView.getComputedStyle ) {
6504	+ getComputedStyle = function( elem, name ) {
6505	+ var ret, defaultView, computedStyle;
6506	+
6507	+ name = name.replace( rupper, "-$1" ).toLowerCase();
6508	+
6509	+ if ( !(defaultView = elem.ownerDocument.defaultView) ) {
6510	+ return undefined;
6511	+ }
6512	+
6513	+ if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6514	+ ret = computedStyle.getPropertyValue( name );
6515	+ if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6516	+ ret = jQuery.style( elem, name );
6517	+ }
6518	+ }
6519	+
6520	+ return ret;
6521	+ };
6522	+ }
6523	+
6524	+ if ( document.documentElement.currentStyle ) {
6525	+ currentStyle = function( elem, name ) {
6526	+ var left,
6527	+ ret = elem.currentStyle && elem.currentStyle[ name ],
6528	+ rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
6529	+ style = elem.style;
6530	+
6531	+ // From the awesome hack by Dean Edwards
6532	+ // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6533	+
6534	+ // If we're not dealing with a regular pixel number
6535	+ // but a number that has a weird ending, we need to convert it to pixels
6536	+ if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6537	+ // Remember the original values
6538	+ left = style.left;
6539	+
6540	+ // Put in the new values to get a computed value out
6541	+ if ( rsLeft ) {
6542	+ elem.runtimeStyle.left = elem.currentStyle.left;
6543	+ }
6544	+ style.left = name === "fontSize" ? "1em" : (ret \|\| 0);
6545	+ ret = style.pixelLeft + "px";
6546	+
6547	+ // Revert the changed values
6548	+ style.left = left;
6549	+ if ( rsLeft ) {
6550	+ elem.runtimeStyle.left = rsLeft;
6551	+ }
6552	+ }
6553	+
6554	+ return ret === "" ? "auto" : ret;
6555	+ };
6556	+ }
6557	+
6558	+ curCSS = getComputedStyle \|\| currentStyle;
6559	+
6560	+ function getWH( elem, name, extra ) {
6561	+
6562	+ // Start with offset property
6563	+ var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6564	+ which = name === "width" ? cssWidth : cssHeight;
6565	+
6566	+ if ( val > 0 ) {
6567	+ if ( extra !== "border" ) {
6568	+ jQuery.each( which, function() {
6569	+ if ( !extra ) {
6570	+ val -= parseFloat( jQuery.css( elem, "padding" + this ) ) \|\| 0;
6571	+ }
6572	+ if ( extra === "margin" ) {
6573	+ val += parseFloat( jQuery.css( elem, extra + this ) ) \|\| 0;
6574	+ } else {
6575	+ val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) \|\| 0;
6576	+ }
6577	+ });
6578	+ }
6579	+
6580	+ return val + "px";
6581	+ }
6582	+
6583	+ // Fall back to computed then uncomputed css if necessary
6584	+ val = curCSS( elem, name, name );
6585	+ if ( val < 0 \|\| val == null ) {
6586	+ val = elem.style[ name ] \|\| 0;
6587	+ }
6588	+ // Normalize "", auto, and prepare for extra
6589	+ val = parseFloat( val ) \|\| 0;
6590	+
6591	+ // Add padding, border, margin
6592	+ if ( extra ) {
6593	+ jQuery.each( which, function() {
6594	+ val += parseFloat( jQuery.css( elem, "padding" + this ) ) \|\| 0;
6595	+ if ( extra !== "padding" ) {
6596	+ val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) \|\| 0;
6597	+ }
6598	+ if ( extra === "margin" ) {
6599	+ val += parseFloat( jQuery.css( elem, extra + this ) ) \|\| 0;
6600	+ }
6601	+ });
6602	+ }
6603	+
6604	+ return val + "px";
6605	+ }
6606	+
6607	+ if ( jQuery.expr && jQuery.expr.filters ) {
6608	+ jQuery.expr.filters.hidden = function( elem ) {
6609	+ var width = elem.offsetWidth,
6610	+ height = elem.offsetHeight;
6611	+
6612	+ return (width === 0 && height === 0) \|\| (!jQuery.support.reliableHiddenOffsets && (elem.style.display \|\| jQuery.css( elem, "display" )) === "none");
6613	+ };
6614	+
6615	+ jQuery.expr.filters.visible = function( elem ) {
6616	+ return !jQuery.expr.filters.hidden( elem );
6617	+ };
6618	+ }
6619	+
6620	+
6621	+
6622	+
6623	+ var r20 = /%20/g,
6624	+ rbracket = /\[\]$/,
6625	+ rCRLF = /\r?\n/g,
6626	+ rhash = /#.*$/,
6627	+ rheaders = /^(.?):[ \t]([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6628	+ rinput = /^(?:color\|date\|datetime\|email\|hidden\|month\|number\|password\|range\|search\|tel\|text\|time\|url\|week)$/i,
6629	+ // #7653, #8125, #8152: local protocol detection
6630	+ rlocalProtocol = /^(?:about\|app\|app\-storage\|.+\-extension\|file\|widget):$/,
6631	+ rnoContent = /^(?:GET\|HEAD)$/,
6632	+ rprotocol = /^\/\//,
6633	+ rquery = /\?/,
6634	+ rscript = /<script\b[^<](?:(?!<\/script>)<[^<])*<\/script>/gi,
6635	+ rselectTextarea = /^(?:select\|textarea)/i,
6636	+ rspacesAjax = /\s+/,
6637	+ rts = /([?&])_=[^&]*/,
6638	+ rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6639	+
6640	+ // Keep a copy of the old load method
6641	+ _load = jQuery.fn.load,
6642	+
6643	+ /* Prefilters
6644	+ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6645	+ * 2) These are called:
6646	+ * - BEFORE asking for a transport
6647	+ * - AFTER param serialization (s.data is a string if s.processData is true)
6648	+ * 3) key is the dataType
6649	+ * 4) the catchall symbol "*" can be used
6650	+ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6651	+ */
6652	+ prefilters = {},
6653	+
6654	+ /* Transports bindings
6655	+ * 1) key is the dataType
6656	+ * 2) the catchall symbol "*" can be used
6657	+ * 3) selection will start with transport dataType and THEN go to "*" if needed
6658	+ */
6659	+ transports = {},
6660	+
6661	+ // Document location
6662	+ ajaxLocation,
6663	+
6664	+ // Document location segments
6665	+ ajaxLocParts;
6666	+
6667	+ // #8138, IE may throw an exception when accessing
6668	+ // a field from window.location if document.domain has been set
6669	+ try {
6670	+ ajaxLocation = location.href;
6671	+ } catch( e ) {
6672	+ // Use the href attribute of an A element
6673	+ // since IE will modify it given document.location
6674	+ ajaxLocation = document.createElement( "a" );
6675	+ ajaxLocation.href = "";
6676	+ ajaxLocation = ajaxLocation.href;
6677	+ }
6678	+
6679	+ // Segment location into parts
6680	+ ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) \|\| [];
6681	+
6682	+ // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6683	+ function addToPrefiltersOrTransports( structure ) {
6684	+
6685	+ // dataTypeExpression is optional and defaults to "*"
6686	+ return function( dataTypeExpression, func ) {
6687	+
6688	+ if ( typeof dataTypeExpression !== "string" ) {
6689	+ func = dataTypeExpression;
6690	+ dataTypeExpression = "*";
6691	+ }
6692	+
6693	+ if ( jQuery.isFunction( func ) ) {
6694	+ var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6695	+ i = 0,
6696	+ length = dataTypes.length,
6697	+ dataType,
6698	+ list,
6699	+ placeBefore;
6700	+
6701	+ // For each dataType in the dataTypeExpression
6702	+ for(; i < length; i++ ) {
6703	+ dataType = dataTypes[ i ];
6704	+ // We control if we're asked to add before
6705	+ // any existing element
6706	+ placeBefore = /^\+/.test( dataType );
6707	+ if ( placeBefore ) {
6708	+ dataType = dataType.substr( 1 ) \|\| "*";
6709	+ }
6710	+ list = structure[ dataType ] = structure[ dataType ] \|\| [];
6711	+ // then we add to the structure accordingly
6712	+ list[ placeBefore ? "unshift" : "push" ]( func );
6713	+ }
6714	+ }
6715	+ };
6716	+ }
6717	+
6718	+ // Base inspection function for prefilters and transports
6719	+ function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6720	+ dataType /* internal /, inspected / internal */ ) {
6721	+
6722	+ dataType = dataType \|\| options.dataTypes[ 0 ];
6723	+ inspected = inspected \|\| {};
6724	+
6725	+ inspected[ dataType ] = true;
6726	+
6727	+ var list = structure[ dataType ],
6728	+ i = 0,
6729	+ length = list ? list.length : 0,
6730	+ executeOnly = ( structure === prefilters ),
6731	+ selection;
6732	+
6733	+ for(; i < length && ( executeOnly \|\| !selection ); i++ ) {
6734	+ selection = list[ i ]( options, originalOptions, jqXHR );
6735	+ // If we got redirected to another dataType
6736	+ // we try there if executing only and not done already
6737	+ if ( typeof selection === "string" ) {
6738	+ if ( !executeOnly \|\| inspected[ selection ] ) {
6739	+ selection = undefined;
6740	+ } else {
6741	+ options.dataTypes.unshift( selection );
6742	+ selection = inspectPrefiltersOrTransports(
6743	+ structure, options, originalOptions, jqXHR, selection, inspected );
6744	+ }
6745	+ }
6746	+ }
6747	+ // If we're only executing or nothing was selected
6748	+ // we try the catchall dataType if not done already
6749	+ if ( ( executeOnly \|\| !selection ) && !inspected[ "*" ] ) {
6750	+ selection = inspectPrefiltersOrTransports(
6751	+ structure, options, originalOptions, jqXHR, "*", inspected );
6752	+ }
6753	+ // unnecessary when only executing (prefilters)
6754	+ // but it'll be ignored by the caller in that case
6755	+ return selection;
6756	+ }
6757	+
6758	+ jQuery.fn.extend({
6759	+ load: function( url, params, callback ) {
6760	+ if ( typeof url !== "string" && _load ) {
6761	+ return _load.apply( this, arguments );
6762	+
6763	+ // Don't do a request if no elements are being requested
6764	+ } else if ( !this.length ) {
6765	+ return this;
6766	+ }
6767	+
6768	+ var off = url.indexOf( " " );
6769	+ if ( off >= 0 ) {
6770	+ var selector = url.slice( off, url.length );
6771	+ url = url.slice( 0, off );
6772	+ }
6773	+
6774	+ // Default to a GET request
6775	+ var type = "GET";
6776	+
6777	+ // If the second parameter was provided
6778	+ if ( params ) {
6779	+ // If it's a function
6780	+ if ( jQuery.isFunction( params ) ) {
6781	+ // We assume that it's the callback
6782	+ callback = params;
6783	+ params = undefined;
6784	+
6785	+ // Otherwise, build a param string
6786	+ } else if ( typeof params === "object" ) {
6787	+ params = jQuery.param( params, jQuery.ajaxSettings.traditional );
6788	+ type = "POST";
6789	+ }
6790	+ }
6791	+
6792	+ var self = this;
6793	+
6794	+ // Request the remote document
6795	+ jQuery.ajax({
6796	+ url: url,
6797	+ type: type,
6798	+ dataType: "html",
6799	+ data: params,
6800	+ // Complete callback (responseText is used internally)
6801	+ complete: function( jqXHR, status, responseText ) {
6802	+ // Store the response as specified by the jqXHR object
6803	+ responseText = jqXHR.responseText;
6804	+ // If successful, inject the HTML into all the matched elements
6805	+ if ( jqXHR.isResolved() ) {
6806	+ // #4825: Get the actual response in case
6807	+ // a dataFilter is present in ajaxSettings
6808	+ jqXHR.done(function( r ) {
6809	+ responseText = r;
6810	+ });
6811	+ // See if a selector was specified
6812	+ self.html( selector ?
6813	+ // Create a dummy div to hold the results
6814	+ jQuery("<div>")
6815	+ // inject the contents of the document in, removing the scripts
6816	+ // to avoid any 'Permission Denied' errors in IE
6817	+ .append(responseText.replace(rscript, ""))
6818	+
6819	+ // Locate the specified elements
6820	+ .find(selector) :
6821	+
6822	+ // If not, just inject the full result
6823	+ responseText );
6824	+ }
6825	+
6826	+ if ( callback ) {
6827	+ self.each( callback, [ responseText, status, jqXHR ] );
6828	+ }
6829	+ }
6830	+ });
6831	+
6832	+ return this;
6833	+ },
6834	+
6835	+ serialize: function() {
6836	+ return jQuery.param( this.serializeArray() );
6837	+ },
6838	+
6839	+ serializeArray: function() {
6840	+ return this.map(function(){
6841	+ return this.elements ? jQuery.makeArray( this.elements ) : this;
6842	+ })
6843	+ .filter(function(){
6844	+ return this.name && !this.disabled &&
6845	+ ( this.checked \|\| rselectTextarea.test( this.nodeName ) \|\|
6846	+ rinput.test( this.type ) );
6847	+ })
6848	+ .map(function( i, elem ){
6849	+ var val = jQuery( this ).val();
6850	+
6851	+ return val == null ?
6852	+ null :
6853	+ jQuery.isArray( val ) ?
6854	+ jQuery.map( val, function( val, i ){
6855	+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6856	+ }) :
6857	+ { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6858	+ }).get();
6859	+ }
6860	+ });
6861	+
6862	+ // Attach a bunch of functions for handling common AJAX events
6863	+ jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
6864	+ jQuery.fn[ o ] = function( f ){
6865	+ return this.bind( o, f );
6866	+ };
6867	+ });
6868	+
6869	+ jQuery.each( [ "get", "post" ], function( i, method ) {
6870	+ jQuery[ method ] = function( url, data, callback, type ) {
6871	+ // shift arguments if data argument was omitted
6872	+ if ( jQuery.isFunction( data ) ) {
6873	+ type = type \|\| callback;
6874	+ callback = data;
6875	+ data = undefined;
6876	+ }
6877	+
6878	+ return jQuery.ajax({
6879	+ type: method,
6880	+ url: url,
6881	+ data: data,
6882	+ success: callback,
6883	+ dataType: type
6884	+ });
6885	+ };
6886	+ });
6887	+
6888	+ jQuery.extend({
6889	+
6890	+ getScript: function( url, callback ) {
6891	+ return jQuery.get( url, undefined, callback, "script" );
6892	+ },
6893	+
6894	+ getJSON: function( url, data, callback ) {
6895	+ return jQuery.get( url, data, callback, "json" );
6896	+ },
6897	+
6898	+ // Creates a full fledged settings object into target
6899	+ // with both ajaxSettings and settings fields.
6900	+ // If target is omitted, writes into ajaxSettings.
6901	+ ajaxSetup: function ( target, settings ) {
6902	+ if ( !settings ) {
6903	+ // Only one parameter, we extend ajaxSettings
6904	+ settings = target;
6905	+ target = jQuery.extend( true, jQuery.ajaxSettings, settings );
6906	+ } else {
6907	+ // target was provided, we extend into it
6908	+ jQuery.extend( true, target, jQuery.ajaxSettings, settings );
6909	+ }
6910	+ // Flatten fields we don't want deep extended
6911	+ for( var field in { context: 1, url: 1 } ) {
6912	+ if ( field in settings ) {
6913	+ target[ field ] = settings[ field ];
6914	+ } else if( field in jQuery.ajaxSettings ) {
6915	+ target[ field ] = jQuery.ajaxSettings[ field ];
6916	+ }
6917	+ }
6918	+ return target;
6919	+ },
6920	+
6921	+ ajaxSettings: {
6922	+ url: ajaxLocation,
6923	+ isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
6924	+ global: true,
6925	+ type: "GET",
6926	+ contentType: "application/x-www-form-urlencoded",
6927	+ processData: true,
6928	+ async: true,
6929	+ /*
6930	+ timeout: 0,
6931	+ data: null,
6932	+ dataType: null,
6933	+ username: null,
6934	+ password: null,
6935	+ cache: null,
6936	+ traditional: false,
6937	+ headers: {},
6938	+ */
6939	+
6940	+ accepts: {
6941	+ xml: "application/xml, text/xml",
6942	+ html: "text/html",
6943	+ text: "text/plain",
6944	+ json: "application/json, text/javascript",
6945	+ "": "/*"
6946	+ },
6947	+
6948	+ contents: {
6949	+ xml: /xml/,
6950	+ html: /html/,
6951	+ json: /json/
6952	+ },
6953	+
6954	+ responseFields: {
6955	+ xml: "responseXML",
6956	+ text: "responseText"
6957	+ },
6958	+
6959	+ // List of data converters
6960	+ // 1) key format is "source_type destination_type" (a single space in-between)
6961	+ // 2) the catchall symbol "*" can be used for source_type
6962	+ converters: {
6963	+
6964	+ // Convert anything to text
6965	+ "* text": window.String,
6966	+
6967	+ // Text to html (true = no transformation)
6968	+ "text html": true,
6969	+
6970	+ // Evaluate text as a json expression
6971	+ "text json": jQuery.parseJSON,
6972	+
6973	+ // Parse text as xml
6974	+ "text xml": jQuery.parseXML
6975	+ }
6976	+ },
6977	+
6978	+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
6979	+ ajaxTransport: addToPrefiltersOrTransports( transports ),
6980	+
6981	+ // Main method
6982	+ ajax: function( url, options ) {
6983	+
6984	+ // If url is an object, simulate pre-1.5 signature
6985	+ if ( typeof url === "object" ) {
6986	+ options = url;
6987	+ url = undefined;
6988	+ }
6989	+
6990	+ // Force options to be an object
6991	+ options = options \|\| {};
6992	+
6993	+ var // Create the final options object
6994	+ s = jQuery.ajaxSetup( {}, options ),
6995	+ // Callbacks context
6996	+ callbackContext = s.context \|\| s,
6997	+ // Context for global events
6998	+ // It's the callbackContext if one was provided in the options
6999	+ // and if it's a DOM node or a jQuery collection
7000	+ globalEventContext = callbackContext !== s &&
7001	+ ( callbackContext.nodeType \|\| callbackContext instanceof jQuery ) ?
7002	+ jQuery( callbackContext ) : jQuery.event,
7003	+ // Deferreds
7004	+ deferred = jQuery.Deferred(),
7005	+ completeDeferred = jQuery._Deferred(),
7006	+ // Status-dependent callbacks
7007	+ statusCode = s.statusCode \|\| {},
7008	+ // ifModified key
7009	+ ifModifiedKey,
7010	+ // Headers (they are sent all at once)
7011	+ requestHeaders = {},
7012	+ requestHeadersNames = {},
7013	+ // Response headers
7014	+ responseHeadersString,
7015	+ responseHeaders,
7016	+ // transport
7017	+ transport,
7018	+ // timeout handle
7019	+ timeoutTimer,
7020	+ // Cross-domain detection vars
7021	+ parts,
7022	+ // The jqXHR state
7023	+ state = 0,
7024	+ // To know if global events are to be dispatched
7025	+ fireGlobals,
7026	+ // Loop variable
7027	+ i,
7028	+ // Fake xhr
7029	+ jqXHR = {
7030	+
7031	+ readyState: 0,
7032	+
7033	+ // Caches the header
7034	+ setRequestHeader: function( name, value ) {
7035	+ if ( !state ) {
7036	+ var lname = name.toLowerCase();
7037	+ name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] \|\| name;
7038	+ requestHeaders[ name ] = value;
7039	+ }
7040	+ return this;
7041	+ },
7042	+
7043	+ // Raw string
7044	+ getAllResponseHeaders: function() {
7045	+ return state === 2 ? responseHeadersString : null;
7046	+ },
7047	+
7048	+ // Builds headers hashtable if needed
7049	+ getResponseHeader: function( key ) {
7050	+ var match;
7051	+ if ( state === 2 ) {
7052	+ if ( !responseHeaders ) {
7053	+ responseHeaders = {};
7054	+ while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7055	+ responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7056	+ }
7057	+ }
7058	+ match = responseHeaders[ key.toLowerCase() ];
7059	+ }
7060	+ return match === undefined ? null : match;
7061	+ },
7062	+
7063	+ // Overrides response content-type header
7064	+ overrideMimeType: function( type ) {
7065	+ if ( !state ) {
7066	+ s.mimeType = type;
7067	+ }
7068	+ return this;
7069	+ },
7070	+
7071	+ // Cancel the request
7072	+ abort: function( statusText ) {
7073	+ statusText = statusText \|\| "abort";
7074	+ if ( transport ) {
7075	+ transport.abort( statusText );
7076	+ }
7077	+ done( 0, statusText );
7078	+ return this;
7079	+ }
7080	+ };
7081	+
7082	+ // Callback for when everything is done
7083	+ // It is defined here because jslint complains if it is declared
7084	+ // at the end of the function (which would be more logical and readable)
7085	+ function done( status, statusText, responses, headers ) {
7086	+
7087	+ // Called once
7088	+ if ( state === 2 ) {
7089	+ return;
7090	+ }
7091	+
7092	+ // State is "done" now
7093	+ state = 2;
7094	+
7095	+ // Clear timeout if it exists
7096	+ if ( timeoutTimer ) {
7097	+ clearTimeout( timeoutTimer );
7098	+ }
7099	+
7100	+ // Dereference transport for early garbage collection
7101	+ // (no matter how long the jqXHR object will be used)
7102	+ transport = undefined;
7103	+
7104	+ // Cache response headers
7105	+ responseHeadersString = headers \|\| "";
7106	+
7107	+ // Set readyState
7108	+ jqXHR.readyState = status ? 4 : 0;
7109	+
7110	+ var isSuccess,
7111	+ success,
7112	+ error,
7113	+ response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7114	+ lastModified,
7115	+ etag;
7116	+
7117	+ // If successful, handle type chaining
7118	+ if ( status >= 200 && status < 300 \|\| status === 304 ) {
7119	+
7120	+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7121	+ if ( s.ifModified ) {
7122	+
7123	+ if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7124	+ jQuery.lastModified[ ifModifiedKey ] = lastModified;
7125	+ }
7126	+ if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7127	+ jQuery.etag[ ifModifiedKey ] = etag;
7128	+ }
7129	+ }
7130	+
7131	+ // If not modified
7132	+ if ( status === 304 ) {
7133	+
7134	+ statusText = "notmodified";
7135	+ isSuccess = true;
7136	+
7137	+ // If we have data
7138	+ } else {
7139	+
7140	+ try {
7141	+ success = ajaxConvert( s, response );
7142	+ statusText = "success";
7143	+ isSuccess = true;
7144	+ } catch(e) {
7145	+ // We have a parsererror
7146	+ statusText = "parsererror";
7147	+ error = e;
7148	+ }
7149	+ }
7150	+ } else {
7151	+ // We extract error from statusText
7152	+ // then normalize statusText and status for non-aborts
7153	+ error = statusText;
7154	+ if( !statusText \|\| status ) {
7155	+ statusText = "error";
7156	+ if ( status < 0 ) {
7157	+ status = 0;
7158	+ }
7159	+ }
7160	+ }
7161	+
7162	+ // Set data for the fake xhr object
7163	+ jqXHR.status = status;
7164	+ jqXHR.statusText = statusText;
7165	+
7166	+ // Success/Error
7167	+ if ( isSuccess ) {
7168	+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7169	+ } else {
7170	+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7171	+ }
7172	+
7173	+ // Status-dependent callbacks
7174	+ jqXHR.statusCode( statusCode );
7175	+ statusCode = undefined;
7176	+
7177	+ if ( fireGlobals ) {
7178	+ globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7179	+ [ jqXHR, s, isSuccess ? success : error ] );
7180	+ }
7181	+
7182	+ // Complete
7183	+ completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
7184	+
7185	+ if ( fireGlobals ) {
7186	+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
7187	+ // Handle the global AJAX counter
7188	+ if ( !( --jQuery.active ) ) {
7189	+ jQuery.event.trigger( "ajaxStop" );
7190	+ }
7191	+ }
7192	+ }
7193	+
7194	+ // Attach deferreds
7195	+ deferred.promise( jqXHR );
7196	+ jqXHR.success = jqXHR.done;
7197	+ jqXHR.error = jqXHR.fail;
7198	+ jqXHR.complete = completeDeferred.done;
7199	+
7200	+ // Status-dependent callbacks
7201	+ jqXHR.statusCode = function( map ) {
7202	+ if ( map ) {
7203	+ var tmp;
7204	+ if ( state < 2 ) {
7205	+ for( tmp in map ) {
7206	+ statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7207	+ }
7208	+ } else {
7209	+ tmp = map[ jqXHR.status ];
7210	+ jqXHR.then( tmp, tmp );
7211	+ }
7212	+ }
7213	+ return this;
7214	+ };
7215	+
7216	+ // Remove hash character (#7531: and string promotion)
7217	+ // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7218	+ // We also use the url parameter if available
7219	+ s.url = ( ( url \|\| s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7220	+
7221	+ // Extract dataTypes list
7222	+ s.dataTypes = jQuery.trim( s.dataType \|\| "*" ).toLowerCase().split( rspacesAjax );
7223	+
7224	+ // Determine if a cross-domain request is in order
7225	+ if ( s.crossDomain == null ) {
7226	+ parts = rurl.exec( s.url.toLowerCase() );
7227	+ s.crossDomain = !!( parts &&
7228	+ ( parts[ 1 ] != ajaxLocParts[ 1 ] \|\| parts[ 2 ] != ajaxLocParts[ 2 ] \|\|
7229	+ ( parts[ 3 ] \|\| ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7230	+ ( ajaxLocParts[ 3 ] \|\| ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7231	+ );
7232	+ }
7233	+
7234	+ // Convert data if not already a string
7235	+ if ( s.data && s.processData && typeof s.data !== "string" ) {
7236	+ s.data = jQuery.param( s.data, s.traditional );
7237	+ }
7238	+
7239	+ // Apply prefilters
7240	+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7241	+
7242	+ // If request was aborted inside a prefiler, stop there
7243	+ if ( state === 2 ) {
7244	+ return false;
7245	+ }
7246	+
7247	+ // We can fire global events as of now if asked to
7248	+ fireGlobals = s.global;
7249	+
7250	+ // Uppercase the type
7251	+ s.type = s.type.toUpperCase();
7252	+
7253	+ // Determine if request has content
7254	+ s.hasContent = !rnoContent.test( s.type );
7255	+
7256	+ // Watch for a new set of requests
7257	+ if ( fireGlobals && jQuery.active++ === 0 ) {
7258	+ jQuery.event.trigger( "ajaxStart" );
7259	+ }
7260	+
7261	+ // More options handling for requests with no content
7262	+ if ( !s.hasContent ) {
7263	+
7264	+ // If data is available, append data to url
7265	+ if ( s.data ) {
7266	+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7267	+ }
7268	+
7269	+ // Get ifModifiedKey before adding the anti-cache parameter
7270	+ ifModifiedKey = s.url;
7271	+
7272	+ // Add anti-cache in url if needed
7273	+ if ( s.cache === false ) {
7274	+
7275	+ var ts = jQuery.now(),
7276	+ // try replacing _= if it is there
7277	+ ret = s.url.replace( rts, "$1_=" + ts );
7278	+
7279	+ // if nothing was replaced, add timestamp to the end
7280	+ s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7281	+ }
7282	+ }
7283	+
7284	+ // Set the correct header, if data is being sent
7285	+ if ( s.data && s.hasContent && s.contentType !== false \|\| options.contentType ) {
7286	+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
7287	+ }
7288	+
7289	+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7290	+ if ( s.ifModified ) {
7291	+ ifModifiedKey = ifModifiedKey \|\| s.url;
7292	+ if ( jQuery.lastModified[ ifModifiedKey ] ) {
7293	+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7294	+ }
7295	+ if ( jQuery.etag[ ifModifiedKey ] ) {
7296	+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7297	+ }
7298	+ }
7299	+
7300	+ // Set the Accepts header for the server, depending on the dataType
7301	+ jqXHR.setRequestHeader(
7302	+ "Accept",
7303	+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7304	+ s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "" ? ", /*; q=0.01" : "" ) :
7305	+ s.accepts[ "*" ]
7306	+ );
7307	+
7308	+ // Check for headers option
7309	+ for ( i in s.headers ) {
7310	+ jqXHR.setRequestHeader( i, s.headers[ i ] );
7311	+ }
7312	+
7313	+ // Allow custom headers/mimetypes and early abort
7314	+ if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false \|\| state === 2 ) ) {
7315	+ // Abort if not done already
7316	+ jqXHR.abort();
7317	+ return false;
7318	+
7319	+ }
7320	+
7321	+ // Install callbacks on deferreds
7322	+ for ( i in { success: 1, error: 1, complete: 1 } ) {
7323	+ jqXHR[ i ]( s[ i ] );
7324	+ }
7325	+
7326	+ // Get transport
7327	+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7328	+
7329	+ // If no transport, we auto-abort
7330	+ if ( !transport ) {
7331	+ done( -1, "No Transport" );
7332	+ } else {
7333	+ jqXHR.readyState = 1;
7334	+ // Send global event
7335	+ if ( fireGlobals ) {
7336	+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7337	+ }
7338	+ // Timeout
7339	+ if ( s.async && s.timeout > 0 ) {
7340	+ timeoutTimer = setTimeout( function(){
7341	+ jqXHR.abort( "timeout" );
7342	+ }, s.timeout );
7343	+ }
7344	+
7345	+ try {
7346	+ state = 1;
7347	+ transport.send( requestHeaders, done );
7348	+ } catch (e) {
7349	+ // Propagate exception as error if not done
7350	+ if ( status < 2 ) {
7351	+ done( -1, e );
7352	+ // Simply rethrow otherwise
7353	+ } else {
7354	+ jQuery.error( e );
7355	+ }
7356	+ }
7357	+ }
7358	+
7359	+ return jqXHR;
7360	+ },
7361	+
7362	+ // Serialize an array of form elements or a set of
7363	+ // key/values into a query string
7364	+ param: function( a, traditional ) {
7365	+ var s = [],
7366	+ add = function( key, value ) {
7367	+ // If value is a function, invoke it and return its value
7368	+ value = jQuery.isFunction( value ) ? value() : value;
7369	+ s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7370	+ };
7371	+
7372	+ // Set traditional to true for jQuery <= 1.3.2 behavior.
7373	+ if ( traditional === undefined ) {
7374	+ traditional = jQuery.ajaxSettings.traditional;
7375	+ }
7376	+
7377	+ // If an array was passed in, assume that it is an array of form elements.
7378	+ if ( jQuery.isArray( a ) \|\| ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7379	+ // Serialize the form elements
7380	+ jQuery.each( a, function() {
7381	+ add( this.name, this.value );
7382	+ });
7383	+
7384	+ } else {
7385	+ // If traditional, encode the "old" way (the way 1.3.2 or older
7386	+ // did it), otherwise encode params recursively.
7387	+ for ( var prefix in a ) {
7388	+ buildParams( prefix, a[ prefix ], traditional, add );
7389	+ }
7390	+ }
7391	+
7392	+ // Return the resulting serialization
7393	+ return s.join( "&" ).replace( r20, "+" );
7394	+ }
7395	+ });
7396	+
7397	+ function buildParams( prefix, obj, traditional, add ) {
7398	+ if ( jQuery.isArray( obj ) ) {
7399	+ // Serialize array item.
7400	+ jQuery.each( obj, function( i, v ) {
7401	+ if ( traditional \|\| rbracket.test( prefix ) ) {
7402	+ // Treat each array item as a scalar.
7403	+ add( prefix, v );
7404	+
7405	+ } else {
7406	+ // If array item is non-scalar (array or object), encode its
7407	+ // numeric index to resolve deserialization ambiguity issues.
7408	+ // Note that rack (as of 1.0.0) can't currently deserialize
7409	+ // nested arrays properly, and attempting to do so may cause
7410	+ // a server error. Possible fixes are to modify rack's
7411	+ // deserialization algorithm or to provide an option or flag
7412	+ // to force array serialization to be shallow.
7413	+ buildParams( prefix + "[" + ( typeof v === "object" \|\| jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7414	+ }
7415	+ });
7416	+
7417	+ } else if ( !traditional && obj != null && typeof obj === "object" ) {
7418	+ // Serialize object item.
7419	+ for ( var name in obj ) {
7420	+ buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7421	+ }
7422	+
7423	+ } else {
7424	+ // Serialize scalar item.
7425	+ add( prefix, obj );
7426	+ }
7427	+ }
7428	+
7429	+ // This is still on the jQuery object... for now
7430	+ // Want to move this to jQuery.ajax some day
7431	+ jQuery.extend({
7432	+
7433	+ // Counter for holding the number of active queries
7434	+ active: 0,
7435	+
7436	+ // Last-Modified header cache for next request
7437	+ lastModified: {},
7438	+ etag: {}
7439	+
7440	+ });
7441	+
7442	+ /* Handles responses to an ajax request:
7443	+ * - sets all responseXXX fields accordingly
7444	+ * - finds the right dataType (mediates between content-type and expected dataType)
7445	+ * - returns the corresponding response
7446	+ */
7447	+ function ajaxHandleResponses( s, jqXHR, responses ) {
7448	+
7449	+ var contents = s.contents,
7450	+ dataTypes = s.dataTypes,
7451	+ responseFields = s.responseFields,
7452	+ ct,
7453	+ type,
7454	+ finalDataType,
7455	+ firstDataType;
7456	+
7457	+ // Fill responseXXX fields
7458	+ for( type in responseFields ) {
7459	+ if ( type in responses ) {
7460	+ jqXHR[ responseFields[type] ] = responses[ type ];
7461	+ }
7462	+ }
7463	+
7464	+ // Remove auto dataType and get content-type in the process
7465	+ while( dataTypes[ 0 ] === "*" ) {
7466	+ dataTypes.shift();
7467	+ if ( ct === undefined ) {
7468	+ ct = s.mimeType \|\| jqXHR.getResponseHeader( "content-type" );
7469	+ }
7470	+ }
7471	+
7472	+ // Check if we're dealing with a known content-type
7473	+ if ( ct ) {
7474	+ for ( type in contents ) {
7475	+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
7476	+ dataTypes.unshift( type );
7477	+ break;
7478	+ }
7479	+ }
7480	+ }
7481	+
7482	+ // Check to see if we have a response for the expected dataType
7483	+ if ( dataTypes[ 0 ] in responses ) {
7484	+ finalDataType = dataTypes[ 0 ];
7485	+ } else {
7486	+ // Try convertible dataTypes
7487	+ for ( type in responses ) {
7488	+ if ( !dataTypes[ 0 ] \|\| s.converters[ type + " " + dataTypes[0] ] ) {
7489	+ finalDataType = type;
7490	+ break;
7491	+ }
7492	+ if ( !firstDataType ) {
7493	+ firstDataType = type;
7494	+ }
7495	+ }
7496	+ // Or just use first one
7497	+ finalDataType = finalDataType \|\| firstDataType;
7498	+ }
7499	+
7500	+ // If we found a dataType
7501	+ // We add the dataType to the list if needed
7502	+ // and return the corresponding response
7503	+ if ( finalDataType ) {
7504	+ if ( finalDataType !== dataTypes[ 0 ] ) {
7505	+ dataTypes.unshift( finalDataType );
7506	+ }
7507	+ return responses[ finalDataType ];
7508	+ }
7509	+ }
7510	+
7511	+ // Chain conversions given the request and the original response
7512	+ function ajaxConvert( s, response ) {
7513	+
7514	+ // Apply the dataFilter if provided
7515	+ if ( s.dataFilter ) {
7516	+ response = s.dataFilter( response, s.dataType );
7517	+ }
7518	+
7519	+ var dataTypes = s.dataTypes,
7520	+ converters = {},
7521	+ i,
7522	+ key,
7523	+ length = dataTypes.length,
7524	+ tmp,
7525	+ // Current and previous dataTypes
7526	+ current = dataTypes[ 0 ],
7527	+ prev,
7528	+ // Conversion expression
7529	+ conversion,
7530	+ // Conversion function
7531	+ conv,
7532	+ // Conversion functions (transitive conversion)
7533	+ conv1,
7534	+ conv2;
7535	+
7536	+ // For each dataType in the chain
7537	+ for( i = 1; i < length; i++ ) {
7538	+
7539	+ // Create converters map
7540	+ // with lowercased keys
7541	+ if ( i === 1 ) {
7542	+ for( key in s.converters ) {
7543	+ if( typeof key === "string" ) {
7544	+ converters[ key.toLowerCase() ] = s.converters[ key ];
7545	+ }
7546	+ }
7547	+ }
7548	+
7549	+ // Get the dataTypes
7550	+ prev = current;
7551	+ current = dataTypes[ i ];
7552	+
7553	+ // If current is auto dataType, update it to prev
7554	+ if( current === "*" ) {
7555	+ current = prev;
7556	+ // If no auto and dataTypes are actually different
7557	+ } else if ( prev !== "*" && prev !== current ) {
7558	+
7559	+ // Get the converter
7560	+ conversion = prev + " " + current;
7561	+ conv = converters[ conversion ] \|\| converters[ "* " + current ];
7562	+
7563	+ // If there is no direct converter, search transitively
7564	+ if ( !conv ) {
7565	+ conv2 = undefined;
7566	+ for( conv1 in converters ) {
7567	+ tmp = conv1.split( " " );
7568	+ if ( tmp[ 0 ] === prev \|\| tmp[ 0 ] === "*" ) {
7569	+ conv2 = converters[ tmp[1] + " " + current ];
7570	+ if ( conv2 ) {
7571	+ conv1 = converters[ conv1 ];
7572	+ if ( conv1 === true ) {
7573	+ conv = conv2;
7574	+ } else if ( conv2 === true ) {
7575	+ conv = conv1;
7576	+ }
7577	+ break;
7578	+ }
7579	+ }
7580	+ }
7581	+ }
7582	+ // If we found no converter, dispatch an error
7583	+ if ( !( conv \|\| conv2 ) ) {
7584	+ jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7585	+ }
7586	+ // If found converter is not an equivalence
7587	+ if ( conv !== true ) {
7588	+ // Convert with 1 or 2 converters accordingly
7589	+ response = conv ? conv( response ) : conv2( conv1(response) );
7590	+ }
7591	+ }
7592	+ }
7593	+ return response;
7594	+ }
7595	+
7596	+
7597	+
7598	+
7599	+ var jsc = jQuery.now(),
7600	+ jsre = /(\=)\?(&\|$)\|\?\?/i;
7601	+
7602	+ // Default jsonp settings
7603	+ jQuery.ajaxSetup({
7604	+ jsonp: "callback",
7605	+ jsonpCallback: function() {
7606	+ return jQuery.expando + "_" + ( jsc++ );
7607	+ }
7608	+ });
7609	+
7610	+ // Detect, normalize options and install callbacks for jsonp requests
7611	+ jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7612	+
7613	+ var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7614	+ ( typeof s.data === "string" );
7615	+
7616	+ if ( s.dataTypes[ 0 ] === "jsonp" \|\|
7617	+ s.jsonp !== false && ( jsre.test( s.url ) \|\|
7618	+ inspectData && jsre.test( s.data ) ) ) {
7619	+
7620	+ var responseContainer,
7621	+ jsonpCallback = s.jsonpCallback =
7622	+ jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7623	+ previous = window[ jsonpCallback ],
7624	+ url = s.url,
7625	+ data = s.data,
7626	+ replace = "$1" + jsonpCallback + "$2";
7627	+
7628	+ if ( s.jsonp !== false ) {
7629	+ url = url.replace( jsre, replace );
7630	+ if ( s.url === url ) {
7631	+ if ( inspectData ) {
7632	+ data = data.replace( jsre, replace );
7633	+ }
7634	+ if ( s.data === data ) {
7635	+ // Add callback manually
7636	+ url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7637	+ }
7638	+ }
7639	+ }
7640	+
7641	+ s.url = url;
7642	+ s.data = data;
7643	+
7644	+ // Install callback
7645	+ window[ jsonpCallback ] = function( response ) {
7646	+ responseContainer = [ response ];
7647	+ };
7648	+
7649	+ // Clean-up function
7650	+ jqXHR.always(function() {
7651	+ // Set callback back to previous value
7652	+ window[ jsonpCallback ] = previous;
7653	+ // Call if it was a function and we have a response
7654	+ if ( responseContainer && jQuery.isFunction( previous ) ) {
7655	+ window[ jsonpCallback ]( responseContainer[ 0 ] );
7656	+ }
7657	+ });
7658	+
7659	+ // Use data converter to retrieve json after script execution
7660	+ s.converters["script json"] = function() {
7661	+ if ( !responseContainer ) {
7662	+ jQuery.error( jsonpCallback + " was not called" );
7663	+ }
7664	+ return responseContainer[ 0 ];
7665	+ };
7666	+
7667	+ // force json dataType
7668	+ s.dataTypes[ 0 ] = "json";
7669	+
7670	+ // Delegate to script
7671	+ return "script";
7672	+ }
7673	+ });
7674	+
7675	+
7676	+
7677	+
7678	+ // Install script dataType
7679	+ jQuery.ajaxSetup({
7680	+ accepts: {
7681	+ script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7682	+ },
7683	+ contents: {
7684	+ script: /javascript\|ecmascript/
7685	+ },
7686	+ converters: {
7687	+ "text script": function( text ) {
7688	+ jQuery.globalEval( text );
7689	+ return text;
7690	+ }
7691	+ }
7692	+ });
7693	+
7694	+ // Handle cache's special case and global
7695	+ jQuery.ajaxPrefilter( "script", function( s ) {
7696	+ if ( s.cache === undefined ) {
7697	+ s.cache = false;
7698	+ }
7699	+ if ( s.crossDomain ) {
7700	+ s.type = "GET";
7701	+ s.global = false;
7702	+ }
7703	+ });
7704	+
7705	+ // Bind script tag hack transport
7706	+ jQuery.ajaxTransport( "script", function(s) {
7707	+
7708	+ // This transport only deals with cross domain requests
7709	+ if ( s.crossDomain ) {
7710	+
7711	+ var script,
7712	+ head = document.head \|\| document.getElementsByTagName( "head" )[0] \|\| document.documentElement;
7713	+
7714	+ return {
7715	+
7716	+ send: function( _, callback ) {
7717	+
7718	+ script = document.createElement( "script" );
7719	+
7720	+ script.async = "async";
7721	+
7722	+ if ( s.scriptCharset ) {
7723	+ script.charset = s.scriptCharset;
7724	+ }
7725	+
7726	+ script.src = s.url;
7727	+
7728	+ // Attach handlers for all browsers
7729	+ script.onload = script.onreadystatechange = function( _, isAbort ) {
7730	+
7731	+ if ( isAbort \|\| !script.readyState \|\| /loaded\|complete/.test( script.readyState ) ) {
7732	+
7733	+ // Handle memory leak in IE
7734	+ script.onload = script.onreadystatechange = null;
7735	+
7736	+ // Remove the script
7737	+ if ( head && script.parentNode ) {
7738	+ head.removeChild( script );
7739	+ }
7740	+
7741	+ // Dereference the script
7742	+ script = undefined;
7743	+
7744	+ // Callback if not abort
7745	+ if ( !isAbort ) {
7746	+ callback( 200, "success" );
7747	+ }
7748	+ }
7749	+ };
7750	+ // Use insertBefore instead of appendChild to circumvent an IE6 bug.
7751	+ // This arises when a base node is used (#2709 and #4378).
7752	+ head.insertBefore( script, head.firstChild );
7753	+ },
7754	+
7755	+ abort: function() {
7756	+ if ( script ) {
7757	+ script.onload( 0, 1 );
7758	+ }
7759	+ }
7760	+ };
7761	+ }
7762	+ });
7763	+
7764	+
7765	+
7766	+
7767	+ var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
7768	+ xhrOnUnloadAbort = window.ActiveXObject ? function() {
7769	+ // Abort all pending requests
7770	+ for ( var key in xhrCallbacks ) {
7771	+ xhrCallbacks[ key ]( 0, 1 );
7772	+ }
7773	+ } : false,
7774	+ xhrId = 0,
7775	+ xhrCallbacks;
7776	+
7777	+ // Functions to create xhrs
7778	+ function createStandardXHR() {
7779	+ try {
7780	+ return new window.XMLHttpRequest();
7781	+ } catch( e ) {}
7782	+ }
7783	+
7784	+ function createActiveXHR() {
7785	+ try {
7786	+ return new window.ActiveXObject( "Microsoft.XMLHTTP" );
7787	+ } catch( e ) {}
7788	+ }
7789	+
7790	+ // Create the request object
7791	+ // (This is still attached to ajaxSettings for backward compatibility)
7792	+ jQuery.ajaxSettings.xhr = window.ActiveXObject ?
7793	+ /* Microsoft failed to properly
7794	+ * implement the XMLHttpRequest in IE7 (can't request local files),
7795	+ * so we use the ActiveXObject when it is available
7796	+ * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
7797	+ * we need a fallback.
7798	+ */
7799	+ function() {
7800	+ return !this.isLocal && createStandardXHR() \|\| createActiveXHR();
7801	+ } :
7802	+ // For all other browsers, use the standard XMLHttpRequest object
7803	+ createStandardXHR;
7804	+
7805	+ // Determine support properties
7806	+ (function( xhr ) {
7807	+ jQuery.extend( jQuery.support, {
7808	+ ajax: !!xhr,
7809	+ cors: !!xhr && ( "withCredentials" in xhr )
7810	+ });
7811	+ })( jQuery.ajaxSettings.xhr() );
7812	+
7813	+ // Create transport if the browser can provide an xhr
7814	+ if ( jQuery.support.ajax ) {
7815	+
7816	+ jQuery.ajaxTransport(function( s ) {
7817	+ // Cross domain only allowed if supported through XMLHttpRequest
7818	+ if ( !s.crossDomain \|\| jQuery.support.cors ) {
7819	+
7820	+ var callback;
7821	+
7822	+ return {
7823	+ send: function( headers, complete ) {
7824	+
7825	+ // Get a new xhr
7826	+ var xhr = s.xhr(),
7827	+ handle,
7828	+ i;
7829	+
7830	+ // Open the socket
7831	+ // Passing null username, generates a login popup on Opera (#2865)
7832	+ if ( s.username ) {
7833	+ xhr.open( s.type, s.url, s.async, s.username, s.password );
7834	+ } else {
7835	+ xhr.open( s.type, s.url, s.async );
7836	+ }
7837	+
7838	+ // Apply custom fields if provided
7839	+ if ( s.xhrFields ) {
7840	+ for ( i in s.xhrFields ) {
7841	+ xhr[ i ] = s.xhrFields[ i ];
7842	+ }
7843	+ }
7844	+
7845	+ // Override mime type if needed
7846	+ if ( s.mimeType && xhr.overrideMimeType ) {
7847	+ xhr.overrideMimeType( s.mimeType );
7848	+ }
7849	+
7850	+ // X-Requested-With header
7851	+ // For cross-domain requests, seeing as conditions for a preflight are
7852	+ // akin to a jigsaw puzzle, we simply never set it to be sure.
7853	+ // (it can always be set on a per-request basis or even using ajaxSetup)
7854	+ // For same-domain requests, won't change header if already provided.
7855	+ if ( !s.crossDomain && !headers["X-Requested-With"] ) {
7856	+ headers[ "X-Requested-With" ] = "XMLHttpRequest";
7857	+ }
7858	+
7859	+ // Need an extra try/catch for cross domain requests in Firefox 3
7860	+ try {
7861	+ for ( i in headers ) {
7862	+ xhr.setRequestHeader( i, headers[ i ] );
7863	+ }
7864	+ } catch( _ ) {}
7865	+
7866	+ // Do send the request
7867	+ // This may raise an exception which is actually
7868	+ // handled in jQuery.ajax (so no try/catch here)
7869	+ xhr.send( ( s.hasContent && s.data ) \|\| null );
7870	+
7871	+ // Listener
7872	+ callback = function( _, isAbort ) {
7873	+
7874	+ var status,
7875	+ statusText,
7876	+ responseHeaders,
7877	+ responses,
7878	+ xml;
7879	+
7880	+ // Firefox throws exceptions when accessing properties
7881	+ // of an xhr when a network error occured
7882	+ // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
7883	+ try {
7884	+
7885	+ // Was never called and is aborted or complete
7886	+ if ( callback && ( isAbort \|\| xhr.readyState === 4 ) ) {
7887	+
7888	+ // Only called once
7889	+ callback = undefined;
7890	+
7891	+ // Do not keep as active anymore
7892	+ if ( handle ) {
7893	+ xhr.onreadystatechange = jQuery.noop;
7894	+ if ( xhrOnUnloadAbort ) {
7895	+ delete xhrCallbacks[ handle ];
7896	+ }
7897	+ }
7898	+
7899	+ // If it's an abort
7900	+ if ( isAbort ) {
7901	+ // Abort it manually if needed
7902	+ if ( xhr.readyState !== 4 ) {
7903	+ xhr.abort();
7904	+ }
7905	+ } else {
7906	+ status = xhr.status;
7907	+ responseHeaders = xhr.getAllResponseHeaders();
7908	+ responses = {};
7909	+ xml = xhr.responseXML;
7910	+
7911	+ // Construct response list
7912	+ if ( xml && xml.documentElement /* #4958 */ ) {
7913	+ responses.xml = xml;
7914	+ }
7915	+ responses.text = xhr.responseText;
7916	+
7917	+ // Firefox throws an exception when accessing
7918	+ // statusText for faulty cross-domain requests
7919	+ try {
7920	+ statusText = xhr.statusText;
7921	+ } catch( e ) {
7922	+ // We normalize with Webkit giving an empty statusText
7923	+ statusText = "";
7924	+ }
7925	+
7926	+ // Filter status for non standard behaviors
7927	+
7928	+ // If the request is local and we have data: assume a success
7929	+ // (success with no data won't get notified, that's the best we
7930	+ // can do given current implementations)
7931	+ if ( !status && s.isLocal && !s.crossDomain ) {
7932	+ status = responses.text ? 200 : 404;
7933	+ // IE - #1450: sometimes returns 1223 when it should be 204
7934	+ } else if ( status === 1223 ) {
7935	+ status = 204;
7936	+ }
7937	+ }
7938	+ }
7939	+ } catch( firefoxAccessException ) {
7940	+ if ( !isAbort ) {
7941	+ complete( -1, firefoxAccessException );
7942	+ }
7943	+ }
7944	+
7945	+ // Call complete if needed
7946	+ if ( responses ) {
7947	+ complete( status, statusText, responses, responseHeaders );
7948	+ }
7949	+ };
7950	+
7951	+ // if we're in sync mode or it's in cache
7952	+ // and has been retrieved directly (IE6 & IE7)
7953	+ // we need to manually fire the callback
7954	+ if ( !s.async \|\| xhr.readyState === 4 ) {
7955	+ callback();
7956	+ } else {
7957	+ handle = ++xhrId;
7958	+ if ( xhrOnUnloadAbort ) {
7959	+ // Create the active xhrs callbacks list if needed
7960	+ // and attach the unload handler
7961	+ if ( !xhrCallbacks ) {
7962	+ xhrCallbacks = {};
7963	+ jQuery( window ).unload( xhrOnUnloadAbort );
7964	+ }
7965	+ // Add to list of active xhrs callbacks
7966	+ xhrCallbacks[ handle ] = callback;
7967	+ }
7968	+ xhr.onreadystatechange = callback;
7969	+ }
7970	+ },
7971	+
7972	+ abort: function() {
7973	+ if ( callback ) {
7974	+ callback(0,1);
7975	+ }
7976	+ }
7977	+ };
7978	+ }
7979	+ });
7980	+ }
7981	+
7982	+
7983	+
7984	+
7985	+ var elemdisplay = {},
7986	+ iframe, iframeDoc,
7987	+ rfxtypes = /^(?:toggle\|show\|hide)$/,
7988	+ rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
7989	+ timerId,
7990	+ fxAttrs = [
7991	+ // height animations
7992	+ [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
7993	+ // width animations
7994	+ [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
7995	+ // opacity animations
7996	+ [ "opacity" ]
7997	+ ],
7998	+ fxNow,
7999	+ requestAnimationFrame = window.webkitRequestAnimationFrame \|\|
8000	+ window.mozRequestAnimationFrame \|\|
8001	+ window.oRequestAnimationFrame;
8002	+
8003	+ jQuery.fn.extend({
8004	+ show: function( speed, easing, callback ) {
8005	+ var elem, display;
8006	+
8007	+ if ( speed \|\| speed === 0 ) {
8008	+ return this.animate( genFx("show", 3), speed, easing, callback);
8009	+
8010	+ } else {
8011	+ for ( var i = 0, j = this.length; i < j; i++ ) {
8012	+ elem = this[i];
8013	+
8014	+ if ( elem.style ) {
8015	+ display = elem.style.display;
8016	+
8017	+ // Reset the inline display of this element to learn if it is
8018	+ // being hidden by cascaded rules or not
8019	+ if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
8020	+ display = elem.style.display = "";
8021	+ }
8022	+
8023	+ // Set elements which have been overridden with display: none
8024	+ // in a stylesheet to whatever the default browser style is
8025	+ // for such an element
8026	+ if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
8027	+ jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
8028	+ }
8029	+ }
8030	+ }
8031	+
8032	+ // Set the display of most of the elements in a second loop
8033	+ // to avoid the constant reflow
8034	+ for ( i = 0; i < j; i++ ) {
8035	+ elem = this[i];
8036	+
8037	+ if ( elem.style ) {
8038	+ display = elem.style.display;
8039	+
8040	+ if ( display === "" \|\| display === "none" ) {
8041	+ elem.style.display = jQuery._data(elem, "olddisplay") \|\| "";
8042	+ }
8043	+ }
8044	+ }
8045	+
8046	+ return this;
8047	+ }
8048	+ },
8049	+
8050	+ hide: function( speed, easing, callback ) {
8051	+ if ( speed \|\| speed === 0 ) {
8052	+ return this.animate( genFx("hide", 3), speed, easing, callback);
8053	+
8054	+ } else {
8055	+ for ( var i = 0, j = this.length; i < j; i++ ) {
8056	+ if ( this[i].style ) {
8057	+ var display = jQuery.css( this[i], "display" );
8058	+
8059	+ if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
8060	+ jQuery._data( this[i], "olddisplay", display );
8061	+ }
8062	+ }
8063	+ }
8064	+
8065	+ // Set the display of the elements in a second loop
8066	+ // to avoid the constant reflow
8067	+ for ( i = 0; i < j; i++ ) {
8068	+ if ( this[i].style ) {
8069	+ this[i].style.display = "none";
8070	+ }
8071	+ }
8072	+
8073	+ return this;
8074	+ }
8075	+ },
8076	+
8077	+ // Save the old toggle function
8078	+ _toggle: jQuery.fn.toggle,
8079	+
8080	+ toggle: function( fn, fn2, callback ) {
8081	+ var bool = typeof fn === "boolean";
8082	+
8083	+ if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8084	+ this._toggle.apply( this, arguments );
8085	+
8086	+ } else if ( fn == null \|\| bool ) {
8087	+ this.each(function() {
8088	+ var state = bool ? fn : jQuery(this).is(":hidden");
8089	+ jQuery(this)[ state ? "show" : "hide" ]();
8090	+ });
8091	+
8092	+ } else {
8093	+ this.animate(genFx("toggle", 3), fn, fn2, callback);
8094	+ }
8095	+
8096	+ return this;
8097	+ },
8098	+
8099	+ fadeTo: function( speed, to, easing, callback ) {
8100	+ return this.filter(":hidden").css("opacity", 0).show().end()
8101	+ .animate({opacity: to}, speed, easing, callback);
8102	+ },
8103	+
8104	+ animate: function( prop, speed, easing, callback ) {
8105	+ var optall = jQuery.speed(speed, easing, callback);
8106	+
8107	+ if ( jQuery.isEmptyObject( prop ) ) {
8108	+ return this.each( optall.complete, [ false ] );
8109	+ }
8110	+
8111	+ // Do not change referenced properties as per-property easing will be lost
8112	+ prop = jQuery.extend( {}, prop );
8113	+
8114	+ return this[ optall.queue === false ? "each" : "queue" ](function() {
8115	+ // XXX 'this' does not always have a nodeName when running the
8116	+ // test suite
8117	+
8118	+ if ( optall.queue === false ) {
8119	+ jQuery._mark( this );
8120	+ }
8121	+
8122	+ var opt = jQuery.extend( {}, optall ),
8123	+ isElement = this.nodeType === 1,
8124	+ hidden = isElement && jQuery(this).is(":hidden"),
8125	+ name, val, p,
8126	+ display, e,
8127	+ parts, start, end, unit;
8128	+
8129	+ // will store per property easing and be used to determine when an animation is complete
8130	+ opt.animatedProperties = {};
8131	+
8132	+ for ( p in prop ) {
8133	+
8134	+ // property name normalization
8135	+ name = jQuery.camelCase( p );
8136	+ if ( p !== name ) {
8137	+ prop[ name ] = prop[ p ];
8138	+ delete prop[ p ];
8139	+ }
8140	+
8141	+ val = prop[ name ];
8142	+
8143	+ // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8144	+ if ( jQuery.isArray( val ) ) {
8145	+ opt.animatedProperties[ name ] = val[ 1 ];
8146	+ val = prop[ name ] = val[ 0 ];
8147	+ } else {
8148	+ opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] \|\| opt.easing \|\| 'swing';
8149	+ }
8150	+
8151	+ if ( val === "hide" && hidden \|\| val === "show" && !hidden ) {
8152	+ return opt.complete.call( this );
8153	+ }
8154	+
8155	+ if ( isElement && ( name === "height" \|\| name === "width" ) ) {
8156	+ // Make sure that nothing sneaks out
8157	+ // Record all 3 overflow attributes because IE does not
8158	+ // change the overflow attribute when overflowX and
8159	+ // overflowY are set to the same value
8160	+ opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8161	+
8162	+ // Set display property to inline-block for height/width
8163	+ // animations on inline elements that are having width/height
8164	+ // animated
8165	+ if ( jQuery.css( this, "display" ) === "inline" &&
8166	+ jQuery.css( this, "float" ) === "none" ) {
8167	+ if ( !jQuery.support.inlineBlockNeedsLayout ) {
8168	+ this.style.display = "inline-block";
8169	+
8170	+ } else {
8171	+ display = defaultDisplay( this.nodeName );
8172	+
8173	+ // inline-level elements accept inline-block;
8174	+ // block-level elements need to be inline with layout
8175	+ if ( display === "inline" ) {
8176	+ this.style.display = "inline-block";
8177	+
8178	+ } else {
8179	+ this.style.display = "inline";
8180	+ this.style.zoom = 1;
8181	+ }
8182	+ }
8183	+ }
8184	+ }
8185	+ }
8186	+
8187	+ if ( opt.overflow != null ) {
8188	+ this.style.overflow = "hidden";
8189	+ }
8190	+
8191	+ for ( p in prop ) {
8192	+ e = new jQuery.fx( this, opt, p );
8193	+ val = prop[ p ];
8194	+
8195	+ if ( rfxtypes.test(val) ) {
8196	+ e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
8197	+
8198	+ } else {
8199	+ parts = rfxnum.exec( val );
8200	+ start = e.cur();
8201	+
8202	+ if ( parts ) {
8203	+ end = parseFloat( parts[2] );
8204	+ unit = parts[3] \|\| ( jQuery.cssNumber[ p ] ? "" : "px" );
8205	+
8206	+ // We need to compute starting value
8207	+ if ( unit !== "px" ) {
8208	+ jQuery.style( this, p, (end \|\| 1) + unit);
8209	+ start = ((end \|\| 1) / e.cur()) * start;
8210	+ jQuery.style( this, p, start + unit);
8211	+ }
8212	+
8213	+ // If a +=/-= token was provided, we're doing a relative animation
8214	+ if ( parts[1] ) {
8215	+ end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8216	+ }
8217	+
8218	+ e.custom( start, end, unit );
8219	+
8220	+ } else {
8221	+ e.custom( start, val, "" );
8222	+ }
8223	+ }
8224	+ }
8225	+
8226	+ // For JS strict compliance
8227	+ return true;
8228	+ });
8229	+ },
8230	+
8231	+ stop: function( clearQueue, gotoEnd ) {
8232	+ if ( clearQueue ) {
8233	+ this.queue([]);
8234	+ }
8235	+
8236	+ this.each(function() {
8237	+ var timers = jQuery.timers,
8238	+ i = timers.length;
8239	+ // clear marker counters if we know they won't be
8240	+ if ( !gotoEnd ) {
8241	+ jQuery._unmark( true, this );
8242	+ }
8243	+ while ( i-- ) {
8244	+ if ( timers[i].elem === this ) {
8245	+ if (gotoEnd) {
8246	+ // force the next step to be the last
8247	+ timers[i](true);
8248	+ }
8249	+
8250	+ timers.splice(i, 1);
8251	+ }
8252	+ }
8253	+ });
8254	+
8255	+ // start the next in the queue if the last step wasn't forced
8256	+ if ( !gotoEnd ) {
8257	+ this.dequeue();
8258	+ }
8259	+
8260	+ return this;
8261	+ }
8262	+
8263	+ });
8264	+
8265	+ // Animations created synchronously will run synchronously
8266	+ function createFxNow() {
8267	+ setTimeout( clearFxNow, 0 );
8268	+ return ( fxNow = jQuery.now() );
8269	+ }
8270	+
8271	+ function clearFxNow() {
8272	+ fxNow = undefined;
8273	+ }
8274	+
8275	+ // Generate parameters to create a standard animation
8276	+ function genFx( type, num ) {
8277	+ var obj = {};
8278	+
8279	+ jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
8280	+ obj[ this ] = type;
8281	+ });
8282	+
8283	+ return obj;
8284	+ }
8285	+
8286	+ // Generate shortcuts for custom animations
8287	+ jQuery.each({
8288	+ slideDown: genFx("show", 1),
8289	+ slideUp: genFx("hide", 1),
8290	+ slideToggle: genFx("toggle", 1),
8291	+ fadeIn: { opacity: "show" },
8292	+ fadeOut: { opacity: "hide" },
8293	+ fadeToggle: { opacity: "toggle" }
8294	+ }, function( name, props ) {
8295	+ jQuery.fn[ name ] = function( speed, easing, callback ) {
8296	+ return this.animate( props, speed, easing, callback );
8297	+ };
8298	+ });
8299	+
8300	+ jQuery.extend({
8301	+ speed: function( speed, easing, fn ) {
8302	+ var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
8303	+ complete: fn \|\| !fn && easing \|\|
8304	+ jQuery.isFunction( speed ) && speed,
8305	+ duration: speed,
8306	+ easing: fn && easing \|\| easing && !jQuery.isFunction(easing) && easing
8307	+ };
8308	+
8309	+ opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8310	+ opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
8311	+
8312	+ // Queueing
8313	+ opt.old = opt.complete;
8314	+ opt.complete = function( noUnmark ) {
8315	+ if ( jQuery.isFunction( opt.old ) ) {
8316	+ opt.old.call( this );
8317	+ }
8318	+
8319	+ if ( opt.queue !== false ) {
8320	+ jQuery.dequeue( this );
8321	+ } else if ( noUnmark !== false ) {
8322	+ jQuery._unmark( this );
8323	+ }
8324	+ };
8325	+
8326	+ return opt;
8327	+ },
8328	+
8329	+ easing: {
8330	+ linear: function( p, n, firstNum, diff ) {
8331	+ return firstNum + diff * p;
8332	+ },
8333	+ swing: function( p, n, firstNum, diff ) {
8334	+ return ((-Math.cos(pMath.PI)/2) + 0.5) diff + firstNum;
8335	+ }
8336	+ },
8337	+
8338	+ timers: [],
8339	+
8340	+ fx: function( elem, options, prop ) {
8341	+ this.options = options;
8342	+ this.elem = elem;
8343	+ this.prop = prop;
8344	+
8345	+ options.orig = options.orig \|\| {};
8346	+ }
8347	+
8348	+ });
8349	+
8350	+ jQuery.fx.prototype = {
8351	+ // Simple function for setting a style value
8352	+ update: function() {
8353	+ if ( this.options.step ) {
8354	+ this.options.step.call( this.elem, this.now, this );
8355	+ }
8356	+
8357	+ (jQuery.fx.step[this.prop] \|\| jQuery.fx.step._default)( this );
8358	+ },
8359	+
8360	+ // Get the current size
8361	+ cur: function() {
8362	+ if ( this.elem[this.prop] != null && (!this.elem.style \|\| this.elem.style[this.prop] == null) ) {
8363	+ return this.elem[ this.prop ];
8364	+ }
8365	+
8366	+ var parsed,
8367	+ r = jQuery.css( this.elem, this.prop );
8368	+ // Empty strings, null, undefined and "auto" are converted to 0,
8369	+ // complex values such as "rotate(1rad)" are returned as is,
8370	+ // simple values such as "10px" are parsed to Float.
8371	+ return isNaN( parsed = parseFloat( r ) ) ? !r \|\| r === "auto" ? 0 : r : parsed;
8372	+ },
8373	+
8374	+ // Start an animation from one number to another
8375	+ custom: function( from, to, unit ) {
8376	+ var self = this,
8377	+ fx = jQuery.fx,
8378	+ raf;
8379	+
8380	+ this.startTime = fxNow \|\| createFxNow();
8381	+ this.start = from;
8382	+ this.end = to;
8383	+ this.unit = unit \|\| this.unit \|\| ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8384	+ this.now = this.start;
8385	+ this.pos = this.state = 0;
8386	+
8387	+ function t( gotoEnd ) {
8388	+ return self.step(gotoEnd);
8389	+ }
8390	+
8391	+ t.elem = this.elem;
8392	+
8393	+ if ( t() && jQuery.timers.push(t) && !timerId ) {
8394	+ // Use requestAnimationFrame instead of setInterval if available
8395	+ if ( requestAnimationFrame ) {
8396	+ timerId = true;
8397	+ raf = function() {
8398	+ // When timerId gets set to null at any point, this stops
8399	+ if ( timerId ) {
8400	+ requestAnimationFrame( raf );
8401	+ fx.tick();
8402	+ }
8403	+ };
8404	+ requestAnimationFrame( raf );
8405	+ } else {
8406	+ timerId = setInterval( fx.tick, fx.interval );
8407	+ }
8408	+ }
8409	+ },
8410	+
8411	+ // Simple 'show' function
8412	+ show: function() {
8413	+ // Remember where we started, so that we can go back to it later
8414	+ this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8415	+ this.options.show = true;
8416	+
8417	+ // Begin the animation
8418	+ // Make sure that we start at a small width/height to avoid any
8419	+ // flash of content
8420	+ this.custom(this.prop === "width" \|\| this.prop === "height" ? 1 : 0, this.cur());
8421	+
8422	+ // Start by showing the element
8423	+ jQuery( this.elem ).show();
8424	+ },
8425	+
8426	+ // Simple 'hide' function
8427	+ hide: function() {
8428	+ // Remember where we started, so that we can go back to it later
8429	+ this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8430	+ this.options.hide = true;
8431	+
8432	+ // Begin the animation
8433	+ this.custom(this.cur(), 0);
8434	+ },
8435	+
8436	+ // Each step of an animation
8437	+ step: function( gotoEnd ) {
8438	+ var t = fxNow \|\| createFxNow(),
8439	+ done = true,
8440	+ elem = this.elem,
8441	+ options = this.options,
8442	+ i, n;
8443	+
8444	+ if ( gotoEnd \|\| t >= options.duration + this.startTime ) {
8445	+ this.now = this.end;
8446	+ this.pos = this.state = 1;
8447	+ this.update();
8448	+
8449	+ options.animatedProperties[ this.prop ] = true;
8450	+
8451	+ for ( i in options.animatedProperties ) {
8452	+ if ( options.animatedProperties[i] !== true ) {
8453	+ done = false;
8454	+ }
8455	+ }
8456	+
8457	+ if ( done ) {
8458	+ // Reset the overflow
8459	+ if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8460	+
8461	+ jQuery.each( [ "", "X", "Y" ], function (index, value) {
8462	+ elem.style[ "overflow" + value ] = options.overflow[index];
8463	+ });
8464	+ }
8465	+
8466	+ // Hide the element if the "hide" operation was done
8467	+ if ( options.hide ) {
8468	+ jQuery(elem).hide();
8469	+ }
8470	+
8471	+ // Reset the properties, if the item has been hidden or shown
8472	+ if ( options.hide \|\| options.show ) {
8473	+ for ( var p in options.animatedProperties ) {
8474	+ jQuery.style( elem, p, options.orig[p] );
8475	+ }
8476	+ }
8477	+
8478	+ // Execute the complete function
8479	+ options.complete.call( elem );
8480	+ }
8481	+
8482	+ return false;
8483	+
8484	+ } else {
8485	+ // classical easing cannot be used with an Infinity duration
8486	+ if ( options.duration == Infinity ) {
8487	+ this.now = t;
8488	+ } else {
8489	+ n = t - this.startTime;
8490	+ this.state = n / options.duration;
8491	+
8492	+ // Perform the easing function, defaults to swing
8493	+ this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
8494	+ this.now = this.start + ((this.end - this.start) * this.pos);
8495	+ }
8496	+ // Perform the next step of the animation
8497	+ this.update();
8498	+ }
8499	+
8500	+ return true;
8501	+ }
8502	+ };
8503	+
8504	+ jQuery.extend( jQuery.fx, {
8505	+ tick: function() {
8506	+ for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
8507	+ if ( !timers[i]() ) {
8508	+ timers.splice(i--, 1);
8509	+ }
8510	+ }
8511	+
8512	+ if ( !timers.length ) {
8513	+ jQuery.fx.stop();
8514	+ }
8515	+ },
8516	+
8517	+ interval: 13,
8518	+
8519	+ stop: function() {
8520	+ clearInterval( timerId );
8521	+ timerId = null;
8522	+ },
8523	+
8524	+ speeds: {
8525	+ slow: 600,
8526	+ fast: 200,
8527	+ // Default speed
8528	+ _default: 400
8529	+ },
8530	+
8531	+ step: {
8532	+ opacity: function( fx ) {
8533	+ jQuery.style( fx.elem, "opacity", fx.now );
8534	+ },
8535	+
8536	+ _default: function( fx ) {
8537	+ if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8538	+ fx.elem.style[ fx.prop ] = (fx.prop === "width" \|\| fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
8539	+ } else {
8540	+ fx.elem[ fx.prop ] = fx.now;
8541	+ }
8542	+ }
8543	+ }
8544	+ });
8545	+
8546	+ if ( jQuery.expr && jQuery.expr.filters ) {
8547	+ jQuery.expr.filters.animated = function( elem ) {
8548	+ return jQuery.grep(jQuery.timers, function( fn ) {
8549	+ return elem === fn.elem;
8550	+ }).length;
8551	+ };
8552	+ }
8553	+
8554	+ // Try to restore the default display value of an element
8555	+ function defaultDisplay( nodeName ) {
8556	+
8557	+ if ( !elemdisplay[ nodeName ] ) {
8558	+
8559	+ var body = document.body,
8560	+ elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
8561	+ display = elem.css( "display" );
8562	+
8563	+ elem.remove();
8564	+
8565	+ // If the simple way fails,
8566	+ // get element's real default display by attaching it to a temp iframe
8567	+ if ( display === "none" \|\| display === "" ) {
8568	+ // No iframe to use yet, so create it
8569	+ if ( !iframe ) {
8570	+ iframe = document.createElement( "iframe" );
8571	+ iframe.frameBorder = iframe.width = iframe.height = 0;
8572	+ }
8573	+
8574	+ body.appendChild( iframe );
8575	+
8576	+ // Create a cacheable copy of the iframe document on first call.
8577	+ // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
8578	+ // document to it; WebKit & Firefox won't allow reusing the iframe document.
8579	+ if ( !iframeDoc \|\| !iframe.createElement ) {
8580	+ iframeDoc = ( iframe.contentWindow \|\| iframe.contentDocument ).document;
8581	+ iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
8582	+ iframeDoc.close();
8583	+ }
8584	+
8585	+ elem = iframeDoc.createElement( nodeName );
8586	+
8587	+ iframeDoc.body.appendChild( elem );
8588	+
8589	+ display = jQuery.css( elem, "display" );
8590	+
8591	+ body.removeChild( iframe );
8592	+ }
8593	+
8594	+ // Store the correct default display
8595	+ elemdisplay[ nodeName ] = display;
8596	+ }
8597	+
8598	+ return elemdisplay[ nodeName ];
8599	+ }
8600	+
8601	+
8602	+
8603	+
8604	+ var rtable = /^t(?:able\|d\|h)$/i,
8605	+ rroot = /^(?:body\|html)$/i;
8606	+
8607	+ if ( "getBoundingClientRect" in document.documentElement ) {
8608	+ jQuery.fn.offset = function( options ) {
8609	+ var elem = this[0], box;
8610	+
8611	+ if ( options ) {
8612	+ return this.each(function( i ) {
8613	+ jQuery.offset.setOffset( this, options, i );
8614	+ });
8615	+ }
8616	+
8617	+ if ( !elem \|\| !elem.ownerDocument ) {
8618	+ return null;
8619	+ }
8620	+
8621	+ if ( elem === elem.ownerDocument.body ) {
8622	+ return jQuery.offset.bodyOffset( elem );
8623	+ }
8624	+
8625	+ try {
8626	+ box = elem.getBoundingClientRect();
8627	+ } catch(e) {}
8628	+
8629	+ var doc = elem.ownerDocument,
8630	+ docElem = doc.documentElement;
8631	+
8632	+ // Make sure we're not dealing with a disconnected DOM node
8633	+ if ( !box \|\| !jQuery.contains( docElem, elem ) ) {
8634	+ return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8635	+ }
8636	+
8637	+ var body = doc.body,
8638	+ win = getWindow(doc),
8639	+ clientTop = docElem.clientTop \|\| body.clientTop \|\| 0,
8640	+ clientLeft = docElem.clientLeft \|\| body.clientLeft \|\| 0,
8641	+ scrollTop = win.pageYOffset \|\| jQuery.support.boxModel && docElem.scrollTop \|\| body.scrollTop,
8642	+ scrollLeft = win.pageXOffset \|\| jQuery.support.boxModel && docElem.scrollLeft \|\| body.scrollLeft,
8643	+ top = box.top + scrollTop - clientTop,
8644	+ left = box.left + scrollLeft - clientLeft;
8645	+
8646	+ return { top: top, left: left };
8647	+ };
8648	+
8649	+ } else {
8650	+ jQuery.fn.offset = function( options ) {
8651	+ var elem = this[0];
8652	+
8653	+ if ( options ) {
8654	+ return this.each(function( i ) {
8655	+ jQuery.offset.setOffset( this, options, i );
8656	+ });
8657	+ }
8658	+
8659	+ if ( !elem \|\| !elem.ownerDocument ) {
8660	+ return null;
8661	+ }
8662	+
8663	+ if ( elem === elem.ownerDocument.body ) {
8664	+ return jQuery.offset.bodyOffset( elem );
8665	+ }
8666	+
8667	+ jQuery.offset.initialize();
8668	+
8669	+ var computedStyle,
8670	+ offsetParent = elem.offsetParent,
8671	+ prevOffsetParent = elem,
8672	+ doc = elem.ownerDocument,
8673	+ docElem = doc.documentElement,
8674	+ body = doc.body,
8675	+ defaultView = doc.defaultView,
8676	+ prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8677	+ top = elem.offsetTop,
8678	+ left = elem.offsetLeft;
8679	+
8680	+ while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8681	+ if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8682	+ break;
8683	+ }
8684	+
8685	+ computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8686	+ top -= elem.scrollTop;
8687	+ left -= elem.scrollLeft;
8688	+
8689	+ if ( elem === offsetParent ) {
8690	+ top += elem.offsetTop;
8691	+ left += elem.offsetLeft;
8692	+
8693	+ if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8694	+ top += parseFloat( computedStyle.borderTopWidth ) \|\| 0;
8695	+ left += parseFloat( computedStyle.borderLeftWidth ) \|\| 0;
8696	+ }
8697	+
8698	+ prevOffsetParent = offsetParent;
8699	+ offsetParent = elem.offsetParent;
8700	+ }
8701	+
8702	+ if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8703	+ top += parseFloat( computedStyle.borderTopWidth ) \|\| 0;
8704	+ left += parseFloat( computedStyle.borderLeftWidth ) \|\| 0;
8705	+ }
8706	+
8707	+ prevComputedStyle = computedStyle;
8708	+ }
8709	+
8710	+ if ( prevComputedStyle.position === "relative" \|\| prevComputedStyle.position === "static" ) {
8711	+ top += body.offsetTop;
8712	+ left += body.offsetLeft;
8713	+ }
8714	+
8715	+ if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8716	+ top += Math.max( docElem.scrollTop, body.scrollTop );
8717	+ left += Math.max( docElem.scrollLeft, body.scrollLeft );
8718	+ }
8719	+
8720	+ return { top: top, left: left };
8721	+ };
8722	+ }
8723	+
8724	+ jQuery.offset = {
8725	+ initialize: function() {
8726	+ var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) \|\| 0,
8727	+ 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>";
8728	+
8729	+ jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
8730	+
8731	+ container.innerHTML = html;
8732	+ body.insertBefore( container, body.firstChild );
8733	+ innerDiv = container.firstChild;
8734	+ checkDiv = innerDiv.firstChild;
8735	+ td = innerDiv.nextSibling.firstChild.firstChild;
8736	+
8737	+ this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
8738	+ this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
8739	+
8740	+ checkDiv.style.position = "fixed";
8741	+ checkDiv.style.top = "20px";
8742	+
8743	+ // safari subtracts parent border width here which is 5px
8744	+ this.supportsFixedPosition = (checkDiv.offsetTop === 20 \|\| checkDiv.offsetTop === 15);
8745	+ checkDiv.style.position = checkDiv.style.top = "";
8746	+
8747	+ innerDiv.style.overflow = "hidden";
8748	+ innerDiv.style.position = "relative";
8749	+
8750	+ this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
8751	+
8752	+ this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
8753	+
8754	+ body.removeChild( container );
8755	+ jQuery.offset.initialize = jQuery.noop;
8756	+ },
8757	+
8758	+ bodyOffset: function( body ) {
8759	+ var top = body.offsetTop,
8760	+ left = body.offsetLeft;
8761	+
8762	+ jQuery.offset.initialize();
8763	+
8764	+ if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
8765	+ top += parseFloat( jQuery.css(body, "marginTop") ) \|\| 0;
8766	+ left += parseFloat( jQuery.css(body, "marginLeft") ) \|\| 0;
8767	+ }
8768	+
8769	+ return { top: top, left: left };
8770	+ },
8771	+
8772	+ setOffset: function( elem, options, i ) {
8773	+ var position = jQuery.css( elem, "position" );
8774	+
8775	+ // set position first, in-case top/left are set even on static elem
8776	+ if ( position === "static" ) {
8777	+ elem.style.position = "relative";
8778	+ }
8779	+
8780	+ var curElem = jQuery( elem ),
8781	+ curOffset = curElem.offset(),
8782	+ curCSSTop = jQuery.css( elem, "top" ),
8783	+ curCSSLeft = jQuery.css( elem, "left" ),
8784	+ calculatePosition = (position === "absolute" \|\| position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
8785	+ props = {}, curPosition = {}, curTop, curLeft;
8786	+
8787	+ // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
8788	+ if ( calculatePosition ) {
8789	+ curPosition = curElem.position();
8790	+ curTop = curPosition.top;
8791	+ curLeft = curPosition.left;
8792	+ } else {
8793	+ curTop = parseFloat( curCSSTop ) \|\| 0;
8794	+ curLeft = parseFloat( curCSSLeft ) \|\| 0;
8795	+ }
8796	+
8797	+ if ( jQuery.isFunction( options ) ) {
8798	+ options = options.call( elem, i, curOffset );
8799	+ }
8800	+
8801	+ if (options.top != null) {
8802	+ props.top = (options.top - curOffset.top) + curTop;
8803	+ }
8804	+ if (options.left != null) {
8805	+ props.left = (options.left - curOffset.left) + curLeft;
8806	+ }
8807	+
8808	+ if ( "using" in options ) {
8809	+ options.using.call( elem, props );
8810	+ } else {
8811	+ curElem.css( props );
8812	+ }
8813	+ }
8814	+ };
8815	+
8816	+
8817	+ jQuery.fn.extend({
8818	+ position: function() {
8819	+ if ( !this[0] ) {
8820	+ return null;
8821	+ }
8822	+
8823	+ var elem = this[0],
8824	+
8825	+ // Get real offsetParent
8826	+ offsetParent = this.offsetParent(),
8827	+
8828	+ // Get correct offsets
8829	+ offset = this.offset(),
8830	+ parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
8831	+
8832	+ // Subtract element margins
8833	+ // note: when an element has margin: auto the offsetLeft and marginLeft
8834	+ // are the same in Safari causing offset.left to incorrectly be 0
8835	+ offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) \|\| 0;
8836	+ offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) \|\| 0;
8837	+
8838	+ // Add offsetParent borders
8839	+ parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) \|\| 0;
8840	+ parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) \|\| 0;
8841	+
8842	+ // Subtract the two offsets
8843	+ return {
8844	+ top: offset.top - parentOffset.top,
8845	+ left: offset.left - parentOffset.left
8846	+ };
8847	+ },
8848	+
8849	+ offsetParent: function() {
8850	+ return this.map(function() {
8851	+ var offsetParent = this.offsetParent \|\| document.body;
8852	+ while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
8853	+ offsetParent = offsetParent.offsetParent;
8854	+ }
8855	+ return offsetParent;
8856	+ });
8857	+ }
8858	+ });
8859	+
8860	+
8861	+ // Create scrollLeft and scrollTop methods
8862	+ jQuery.each( ["Left", "Top"], function( i, name ) {
8863	+ var method = "scroll" + name;
8864	+
8865	+ jQuery.fn[ method ] = function( val ) {
8866	+ var elem, win;
8867	+
8868	+ if ( val === undefined ) {
8869	+ elem = this[ 0 ];
8870	+
8871	+ if ( !elem ) {
8872	+ return null;
8873	+ }
8874	+
8875	+ win = getWindow( elem );
8876	+
8877	+ // Return the scroll offset
8878	+ return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
8879	+ jQuery.support.boxModel && win.document.documentElement[ method ] \|\|
8880	+ win.document.body[ method ] :
8881	+ elem[ method ];
8882	+ }
8883	+
8884	+ // Set the scroll offset
8885	+ return this.each(function() {
8886	+ win = getWindow( this );
8887	+
8888	+ if ( win ) {
8889	+ win.scrollTo(
8890	+ !i ? val : jQuery( win ).scrollLeft(),
8891	+ i ? val : jQuery( win ).scrollTop()
8892	+ );
8893	+
8894	+ } else {
8895	+ this[ method ] = val;
8896	+ }
8897	+ });
8898	+ };
8899	+ });
8900	+
8901	+ function getWindow( elem ) {
8902	+ return jQuery.isWindow( elem ) ?
8903	+ elem :
8904	+ elem.nodeType === 9 ?
8905	+ elem.defaultView \|\| elem.parentWindow :
8906	+ false;
8907	+ }
8908	+
8909	+
8910	+
8911	+
8912	+ // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
8913	+ jQuery.each([ "Height", "Width" ], function( i, name ) {
8914	+
8915	+ var type = name.toLowerCase();
8916	+
8917	+ // innerHeight and innerWidth
8918	+ jQuery.fn[ "inner" + name ] = function() {
8919	+ var elem = this[0];
8920	+ return elem && elem.style ?
8921	+ parseFloat( jQuery.css( elem, type, "padding" ) ) :
8922	+ null;
8923	+ };
8924	+
8925	+ // outerHeight and outerWidth
8926	+ jQuery.fn[ "outer" + name ] = function( margin ) {
8927	+ var elem = this[0];
8928	+ return elem && elem.style ?
8929	+ parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
8930	+ null;
8931	+ };
8932	+
8933	+ jQuery.fn[ type ] = function( size ) {
8934	+ // Get window width or height
8935	+ var elem = this[0];
8936	+ if ( !elem ) {
8937	+ return size == null ? null : this;
8938	+ }
8939	+
8940	+ if ( jQuery.isFunction( size ) ) {
8941	+ return this.each(function( i ) {
8942	+ var self = jQuery( this );
8943	+ self[ type ]( size.call( this, i, self[ type ]() ) );
8944	+ });
8945	+ }
8946	+
8947	+ if ( jQuery.isWindow( elem ) ) {
8948	+ // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
8949	+ // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
8950	+ var docElemProp = elem.document.documentElement[ "client" + name ];
8951	+ return elem.document.compatMode === "CSS1Compat" && docElemProp \|\|
8952	+ elem.document.body[ "client" + name ] \|\| docElemProp;
8953	+
8954	+ // Get document width or height
8955	+ } else if ( elem.nodeType === 9 ) {
8956	+ // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
8957	+ return Math.max(
8958	+ elem.documentElement["client" + name],
8959	+ elem.body["scroll" + name], elem.documentElement["scroll" + name],
8960	+ elem.body["offset" + name], elem.documentElement["offset" + name]
8961	+ );
8962	+
8963	+ // Get or set width or height on the element
8964	+ } else if ( size === undefined ) {
8965	+ var orig = jQuery.css( elem, type ),
8966	+ ret = parseFloat( orig );
8967	+
8968	+ return jQuery.isNaN( ret ) ? orig : ret;
8969	+
8970	+ // Set the width or height on the element (default to pixels if value is unitless)
8971	+ } else {
8972	+ return this.css( type, typeof size === "string" ? size : size + "px" );
8973	+ }
8974	+ };
8975	+
8976	+ });
8977	+
8978	+
8979	+ // Expose jQuery to the global object
8980	+ window.jQuery = window.$ = jQuery;
8981	+ })(window);

js/n98/jquery/jquery.no.conflict.js ADDED Viewed

	@@ -0,0 +1 @@


1	+ jQuery.noConflict();

package.xml ADDED Viewed

	@@ -0,0 +1,18 @@


1	+ <?xml version="1.0"?>
2	+ <package>
3	+ <name>N98_jQuery</name>
4	+ <version>1.0.0</version>
5	+ <stability>stable</stability>
6	+ <license uri="http://www.netz98.de/licenses/opensource.html">netz98 open source license</license>
7	+ <channel>community</channel>
8	+ <extends/>
9	+ <summary>Adds jQuery to magento frontend.</summary>
10	+ <description>This package is needed in some magento modules by netz98 new media GmbH.</description>
11	+ <notes>First stable release.</notes>
12	+ <authors><author><name>netz98 new media GmbH</name><user>netz98</user><email>magento@netz98.de</email></author></authors>
13	+ <date>2011-10-11</date>
14	+ <time>16:12:39</time>
15	+ <contents><target name="magecommunity"><dir name="N98"><dir name="JQuery"><dir name="etc"><file name="config.xml" hash="6a33f5c2962628b9eee06bce59c6423f"/></dir></dir></dir></target><target name="mageetc"><dir name="modules"><file name="N98_JQuery.xml" hash="3f84980b671823bf3bb65ba0a635aa8e"/></dir></target><target name="magedesign"><dir name="frontend"><dir name="base"><dir name="default"><dir name="layout"><dir name="n98"><file name="jquery.xml" hash="5309d858f129b6edfcfc6662fe34c0a7"/></dir></dir></dir></dir></dir></target><target name="mageweb"><dir name="js"><dir name="n98"><dir name="jquery"><file name="jquery.no.conflict.js" hash="e2060c4e5e5955c824723b13a212d3ec"/><file name="jquery-1.6.2.js" hash="12840be281cca027968c56e19ebdf6ec"/></dir></dir></dir></target></contents>
16	+ <compatible/>
17	+ <dependencies><required><php><min>5.2.0</min><max>6.0.0</max></php></required></dependencies>
18	+ </package>