WordPress源代码——jquery（jquery-1.7.1.js）

1  /*!
2   * jQuery JavaScript Library v1.7.1
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: Mon Nov 21 21:11:03 2011 -0500
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          // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
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          // Match a standalone tag
51          rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
52  
53          // JSON RegExp
54          rvalidchars = /^[\],:{}\s]*$/,
55          rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
56          rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
57          rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
58  
59          // Useragent RegExp
60          rwebkit = /(webkit)[ \/]([\w.]+)/,
61          ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
62          rmsie = /(msie) ([\w.]+)/,
63          rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
64  
65          // Matches dashed string for camelizing
66          rdashAlpha = /-([a-z]|[0-9])/ig,
67          rmsPrefix = /^-ms-/,
68  
69          // Used by jQuery.camelCase as callback to replace()
70          fcamelCase = function( all, letter ) {
71                  return ( letter + "" ).toUpperCase();
72          },
73  
74          // Keep a UserAgent string for use with jQuery.browser
75          userAgent = navigator.userAgent,
76  
77          // For matching the engine and version of the browser
78          browserMatch,
79  
80          // The deferred used on DOM ready
81          readyList,
82  
83          // The ready event handler
84          DOMContentLoaded,
85  
86          // Save a reference to some core methods
87          toString = Object.prototype.toString,
88          hasOwn = Object.prototype.hasOwnProperty,
89          push = Array.prototype.push,
90          slice = Array.prototype.slice,
91          trim = String.prototype.trim,
92          indexOf = Array.prototype.indexOf,
93  
94          // [[Class]] -> type pairs
95          class2type = {};
96  
97  jQuery.fn = jQuery.prototype = {
98          constructor: jQuery,
99          init: function( selector, context, rootjQuery ) {
100                  var match, elem, ret, doc;
101  
102                  // Handle $(""), $(null), or $(undefined)
103                  if ( !selector ) {
104                          return this;
105                  }
106  
107                  // Handle $(DOMElement)
108                  if ( selector.nodeType ) {
109                          this.context = this[0] = selector;
110                          this.length = 1;
111                          return this;
112                  }
113  
114                  // The body element only exists once, optimize finding it
115                  if ( selector === "body" && !context && document.body ) {
116                          this.context = document;
117                          this[0] = document.body;
118                          this.selector = selector;
119                          this.length = 1;
120                          return this;
121                  }
122  
123                  // Handle HTML strings
124                  if ( typeof selector === "string" ) {
125                          // Are we dealing with HTML string or an ID?
126                          if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
127                                  // Assume that strings that start and end with <> are HTML and skip the regex check
128                                  match = [ null, selector, null ];
129  
130                          } else {
131                                  match = quickExpr.exec( selector );
132                          }
133  
134                          // Verify a match, and that no context was specified for #id
135                          if ( match && (match[1] || !context) ) {
136  
137                                  // HANDLE: $(html) -> $(array)
138                                  if ( match[1] ) {
139                                          context = context instanceof jQuery ? context[0] : context;
140                                          doc = ( context ? context.ownerDocument || context : document );
141  
142                                          // If a single string is passed in and it's a single tag
143                                          // just do a createElement and skip the rest
144                                          ret = rsingleTag.exec( selector );
145  
146                                          if ( ret ) {
147                                                  if ( jQuery.isPlainObject( context ) ) {
148                                                          selector = [ document.createElement( ret[1] ) ];
149                                                          jQuery.fn.attr.call( selector, context, true );
150  
151                                                  } else {
152                                                          selector = [ doc.createElement( ret[1] ) ];
153                                                  }
154  
155                                          } else {
156                                                  ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
157                                                  selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
158                                          }
159  
160                                          return jQuery.merge( this, selector );
161  
162                                  // HANDLE: $("#id")
163                                  } else {
164                                          elem = document.getElementById( match[2] );
165  
166                                          // Check parentNode to catch when Blackberry 4.6 returns
167                                          // nodes that are no longer in the document #6963
168                                          if ( elem && elem.parentNode ) {
169                                                  // Handle the case where IE and Opera return items
170                                                  // by name instead of ID
171                                                  if ( elem.id !== match[2] ) {
172                                                          return rootjQuery.find( selector );
173                                                  }
174  
175                                                  // Otherwise, we inject the element directly into the jQuery object
176                                                  this.length = 1;
177                                                  this[0] = elem;
178                                          }
179  
180                                          this.context = document;
181                                          this.selector = selector;
182                                          return this;
183                                  }
184  
185                          // HANDLE: $(expr, $(...))
186                          } else if ( !context || context.jquery ) {
187                                  return ( context || rootjQuery ).find( selector );
188  
189                          // HANDLE: $(expr, context)
190                          // (which is just equivalent to: $(context).find(expr)
191                          } else {
192                                  return this.constructor( context ).find( selector );
193                          }
194  
195                  // HANDLE: $(function)
196                  // Shortcut for document ready
197                  } else if ( jQuery.isFunction( selector ) ) {
198                          return rootjQuery.ready( selector );
199                  }
200  
201                  if ( selector.selector !== undefined ) {
202                          this.selector = selector.selector;
203                          this.context = selector.context;
204                  }
205  
206                  return jQuery.makeArray( selector, this );
207          },
208  
209          // Start with an empty selector
210          selector: "",
211  
212          // The current version of jQuery being used
213          jquery: "1.7.1",
214  
215          // The default length of a jQuery object is 0
216          length: 0,
217  
218          // The number of elements contained in the matched element set
219          size: function() {
220                  return this.length;
221          },
222  
223          toArray: function() {
224                  return slice.call( this, 0 );
225          },
226  
227          // Get the Nth element in the matched element set OR
228          // Get the whole matched element set as a clean array
229          get: function( num ) {
230                  return num == null ?
231  
232                          // Return a 'clean' array
233                          this.toArray() :
234  
235                          // Return just the object
236                          ( num < 0 ? this[ this.length + num ] : this[ num ] );
237          },
238  
239          // Take an array of elements and push it onto the stack
240          // (returning the new matched element set)
241          pushStack: function( elems, name, selector ) {
242                  // Build a new jQuery matched element set
243                  var ret = this.constructor();
244  
245                  if ( jQuery.isArray( elems ) ) {
246                          push.apply( ret, elems );
247  
248                  } else {
249                          jQuery.merge( ret, elems );
250                  }
251  
252                  // Add the old object onto the stack (as a reference)
253                  ret.prevObject = this;
254  
255                  ret.context = this.context;
256  
257                  if ( name === "find" ) {
258                          ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
259                  } else if ( name ) {
260                          ret.selector = this.selector + "." + name + "(" + selector + ")";
261                  }
262  
263                  // Return the newly-formed element set
264                  return ret;
265          },
266  
267          // Execute a callback for every element in the matched set.
268          // (You can seed the arguments with an array of args, but this is
269          // only used internally.)
270          each: function( callback, args ) {
271                  return jQuery.each( this, callback, args );
272          },
273  
274          ready: function( fn ) {
275                  // Attach the listeners
276                  jQuery.bindReady();
277  
278                  // Add the callback
279                  readyList.add( fn );
280  
281                  return this;
282          },
283  
284          eq: function( i ) {
285                  i = +i;
286                  return i === -1 ?
287                          this.slice( i ) :
288                          this.slice( i, i + 1 );
289          },
290  
291          first: function() {
292                  return this.eq( 0 );
293          },
294  
295          last: function() {
296                  return this.eq( -1 );
297          },
298  
299          slice: function() {
300                  return this.pushStack( slice.apply( this, arguments ),
301                          "slice", slice.call(arguments).join(",") );
302          },
303  
304          map: function( callback ) {
305                  return this.pushStack( jQuery.map(this, function( elem, i ) {
306                          return callback.call( elem, i, elem );
307                  }));
308          },
309  
310          end: function() {
311                  return this.prevObject || this.constructor(null);
312          },
313  
314          // For internal use only.
315          // Behaves like an Array's method, not like a jQuery method.
316          push: push,
317          sort: [].sort,
318          splice: [].splice
319  };
320  
321  // Give the init function the jQuery prototype for later instantiation
322  jQuery.fn.init.prototype = jQuery.fn;
323  
324  jQuery.extend = jQuery.fn.extend = function() {
325          var options, name, src, copy, copyIsArray, clone,
326                  target = arguments[0] || {},
327                  i = 1,
328                  length = arguments.length,
329                  deep = false;
330  
331          // Handle a deep copy situation
332          if ( typeof target === "boolean" ) {
333                  deep = target;
334                  target = arguments[1] || {};
335                  // skip the boolean and the target
336                  i = 2;
337          }
338  
339          // Handle case when target is a string or something (possible in deep copy)
340          if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
341                  target = {};
342          }
343  
344          // extend jQuery itself if only one argument is passed
345          if ( length === i ) {
346                  target = this;
347                  --i;
348          }
349  
350          for ( ; i < length; i++ ) {
351                  // Only deal with non-null/undefined values
352                  if ( (options = arguments[ i ]) != null ) {
353                          // Extend the base object
354                          for ( name in options ) {
355                                  src = target[ name ];
356                                  copy = options[ name ];
357  
358                                  // Prevent never-ending loop
359                                  if ( target === copy ) {
360                                          continue;
361                                  }
362  
363                                  // Recurse if we're merging plain objects or arrays
364                                  if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
365                                          if ( copyIsArray ) {
366                                                  copyIsArray = false;
367                                                  clone = src && jQuery.isArray(src) ? src : [];
368  
369                                          } else {
370                                                  clone = src && jQuery.isPlainObject(src) ? src : {};
371                                          }
372  
373                                          // Never move original objects, clone them
374                                          target[ name ] = jQuery.extend( deep, clone, copy );
375  
376                                  // Don't bring in undefined values
377                                  } else if ( copy !== undefined ) {
378                                          target[ name ] = copy;
379                                  }
380                          }
381                  }
382          }
383  
384          // Return the modified object
385          return target;
386  };
387  
388  jQuery.extend({
389          noConflict: function( deep ) {
390                  if ( window.$ === jQuery ) {
391                          window.$ = _$;
392                  }
393  
394                  if ( deep && window.jQuery === jQuery ) {
395                          window.jQuery = _jQuery;
396                  }
397  
398                  return jQuery;
399          },
400  
401          // Is the DOM ready to be used? Set to true once it occurs.
402          isReady: false,
403  
404          // A counter to track how many items to wait for before
405          // the ready event fires. See #6781
406          readyWait: 1,
407  
408          // Hold (or release) the ready event
409          holdReady: function( hold ) {
410                  if ( hold ) {
411                          jQuery.readyWait++;
412                  } else {
413                          jQuery.ready( true );
414                  }
415          },
416  
417          // Handle when the DOM is ready
418          ready: function( wait ) {
419                  // Either a released hold or an DOMready/load event and not yet ready
420                  if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
421                          // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
422                          if ( !document.body ) {
423                                  return setTimeout( jQuery.ready, 1 );
424                          }
425  
426                          // Remember that the DOM is ready
427                          jQuery.isReady = true;
428  
429                          // If a normal DOM Ready event fired, decrement, and wait if need be
430                          if ( wait !== true && --jQuery.readyWait > 0 ) {
431                                  return;
432                          }
433  
434                          // If there are functions bound, to execute
435                          readyList.fireWith( document, [ jQuery ] );
436  
437                          // Trigger any bound ready events
438                          if ( jQuery.fn.trigger ) {
439                                  jQuery( document ).trigger( "ready" ).off( "ready" );
440                          }
441                  }
442          },
443  
444          bindReady: function() {
445                  if ( readyList ) {
446                          return;
447                  }
448  
449                  readyList = jQuery.Callbacks( "once memory" );
450  
451                  // Catch cases where $(document).ready() is called after the
452                  // browser event has already occurred.
453                  if ( document.readyState === "complete" ) {
454                          // Handle it asynchronously to allow scripts the opportunity to delay ready
455                          return setTimeout( jQuery.ready, 1 );
456                  }
457  
458                  // Mozilla, Opera and webkit nightlies currently support this event
459                  if ( document.addEventListener ) {
460                          // Use the handy event callback
461                          document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
462  
463                          // A fallback to window.onload, that will always work
464                          window.addEventListener( "load", jQuery.ready, false );
465  
466                  // If IE event model is used
467                  } else if ( document.attachEvent ) {
468                          // ensure firing before onload,
469                          // maybe late but safe also for iframes
470                          document.attachEvent( "onreadystatechange", DOMContentLoaded );
471  
472                          // A fallback to window.onload, that will always work
473                          window.attachEvent( "onload", jQuery.ready );
474  
475                          // If IE and not a frame
476                          // continually check to see if the document is ready
477                          var toplevel = false;
478  
479                          try {
480                                  toplevel = window.frameElement == null;
481                          } catch(e) {}
482  
483                          if ( document.documentElement.doScroll && toplevel ) {
484                                  doScrollCheck();
485                          }
486                  }
487          },
488  
489          // See test/unit/core.js for details concerning isFunction.
490          // Since version 1.3, DOM methods and functions like alert
491          // aren't supported. They return false on IE (#2968).
492          isFunction: function( obj ) {
493                  return jQuery.type(obj) === "function";
494          },
495  
496          isArray: Array.isArray || function( obj ) {
497                  return jQuery.type(obj) === "array";
498          },
499  
500          // A crude way of determining if an object is a window
501          isWindow: function( obj ) {
502                  return obj && typeof obj === "object" && "setInterval" in obj;
503          },
504  
505          isNumeric: function( obj ) {
506                  return !isNaN( parseFloat(obj) ) && isFinite( obj );
507          },
508  
509          type: function( obj ) {
510                  return obj == null ?
511                          String( obj ) :
512                          class2type[ toString.call(obj) ] || "object";
513          },
514  
515          isPlainObject: function( obj ) {
516                  // Must be an Object.
517                  // Because of IE, we also have to check the presence of the constructor property.
518                  // Make sure that DOM nodes and window objects don't pass through, as well
519                  if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
520                          return false;
521                  }
522  
523                  try {
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                  } catch ( e ) {
531                          // IE8,9 Will throw exceptions on certain host objects #9897
532                          return false;
533                  }
534  
535                  // Own properties are enumerated firstly, so to speed up,
536                  // if last one is own, then all properties are own.
537  
538                  var key;
539                  for ( key in obj ) {}
540  
541                  return key === undefined || hasOwn.call( obj, key );
542          },
543  
544          isEmptyObject: function( obj ) {
545                  for ( var name in obj ) {
546                          return false;
547                  }
548                  return true;
549          },
550  
551          error: function( msg ) {
552                  throw new Error( msg );
553          },
554  
555          parseJSON: function( data ) {
556                  if ( typeof data !== "string" || !data ) {
557                          return null;
558                  }
559  
560                  // Make sure leading/trailing whitespace is removed (IE can't handle it)
561                  data = jQuery.trim( data );
562  
563                  // Attempt to parse using the native JSON parser first
564                  if ( window.JSON && window.JSON.parse ) {
565                          return window.JSON.parse( data );
566                  }
567  
568                  // Make sure the incoming data is actual JSON
569                  // Logic borrowed from http://json.org/json2.js
570                  if ( rvalidchars.test( data.replace( rvalidescape, "@" )
571                          .replace( rvalidtokens, "]" )
572                          .replace( rvalidbraces, "")) ) {
573  
574                          return ( new Function( "return " + data ) )();
575  
576                  }
577                  jQuery.error( "Invalid JSON: " + data );
578          },
579  
580          // Cross-browser xml parsing
581          parseXML: function( data ) {
582                  var xml, tmp;
583                  try {
584                          if ( window.DOMParser ) { // Standard
585                                  tmp = new DOMParser();
586                                  xml = tmp.parseFromString( data , "text/xml" );
587                          } else { // IE
588                                  xml = new ActiveXObject( "Microsoft.XMLDOM" );
589                                  xml.async = "false";
590                                  xml.loadXML( data );
591                          }
592                  } catch( e ) {
593                          xml = undefined;
594                  }
595                  if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
596                          jQuery.error( "Invalid XML: " + data );
597                  }
598                  return xml;
599          },
600  
601          noop: function() {},
602  
603          // Evaluates a script in a global context
604          // Workarounds based on findings by Jim Driscoll
605          // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
606          globalEval: function( data ) {
607                  if ( data && rnotwhite.test( data ) ) {
608                          // We use execScript on Internet Explorer
609                          // We use an anonymous function so that context is window
610                          // rather than jQuery in Firefox
611                          ( window.execScript || function( data ) {
612                                  window[ "eval" ].call( window, data );
613                          } )( data );
614                  }
615          },
616  
617          // Convert dashed to camelCase; used by the css and data modules
618          // Microsoft forgot to hump their vendor prefix (#9572)
619          camelCase: function( string ) {
620                  return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
621          },
622  
623          nodeName: function( elem, name ) {
624                  return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
625          },
626  
627          // args is for internal usage only
628          each: function( object, callback, args ) {
629                  var name, i = 0,
630                          length = object.length,
631                          isObj = length === undefined || jQuery.isFunction( object );
632  
633                  if ( args ) {
634                          if ( isObj ) {
635                                  for ( name in object ) {
636                                          if ( callback.apply( object[ name ], args ) === false ) {
637                                                  break;
638                                          }
639                                  }
640                          } else {
641                                  for ( ; i < length; ) {
642                                          if ( callback.apply( object[ i++ ], args ) === false ) {
643                                                  break;
644                                          }
645                                  }
646                          }
647  
648                  // A special, fast, case for the most common use of each
649                  } else {
650                          if ( isObj ) {
651                                  for ( name in object ) {
652                                          if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
653                                                  break;
654                                          }
655                                  }
656                          } else {
657                                  for ( ; i < length; ) {
658                                          if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
659                                                  break;
660                                          }
661                                  }
662                          }
663                  }
664  
665                  return object;
666          },
667  
668          // Use native String.trim function wherever possible
669          trim: trim ?
670                  function( text ) {
671                          return text == null ?
672                                  "" :
673                                  trim.call( text );
674                  } :
675  
676                  // Otherwise use our own trimming functionality
677                  function( text ) {
678                          return text == null ?
679                                  "" :
680                                  text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
681                  },
682  
683          // results is for internal usage only
684          makeArray: function( array, results ) {
685                  var ret = results || [];
686  
687                  if ( array != null ) {
688                          // The window, strings (and functions) also have 'length'
689                          // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
690                          var type = jQuery.type( array );
691  
692                          if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
693                                  push.call( ret, array );
694                          } else {
695                                  jQuery.merge( ret, array );
696                          }
697                  }
698  
699                  return ret;
700          },
701  
702          inArray: function( elem, array, i ) {
703                  var len;
704  
705                  if ( array ) {
706                          if ( indexOf ) {
707                                  return indexOf.call( array, elem, i );
708                          }
709  
710                          len = array.length;
711                          i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
712  
713                          for ( ; i < len; i++ ) {
714                                  // Skip accessing in sparse arrays
715                                  if ( i in array && array[ i ] === elem ) {
716                                          return i;
717                                  }
718                          }
719                  }
720  
721                  return -1;
722          },
723  
724          merge: function( first, second ) {
725                  var i = first.length,
726                          j = 0;
727  
728                  if ( typeof second.length === "number" ) {
729                          for ( var l = second.length; j < l; j++ ) {
730                                  first[ i++ ] = second[ j ];
731                          }
732  
733                  } else {
734                          while ( second[j] !== undefined ) {
735                                  first[ i++ ] = second[ j++ ];
736                          }
737                  }
738  
739                  first.length = i;
740  
741                  return first;
742          },
743  
744          grep: function( elems, callback, inv ) {
745                  var ret = [], retVal;
746                  inv = !!inv;
747  
748                  // Go through the array, only saving the items
749                  // that pass the validator function
750                  for ( var i = 0, length = elems.length; i < length; i++ ) {
751                          retVal = !!callback( elems[ i ], i );
752                          if ( inv !== retVal ) {
753                                  ret.push( elems[ i ] );
754                          }
755                  }
756  
757                  return ret;
758          },
759  
760          // arg is for internal usage only
761          map: function( elems, callback, arg ) {
762                  var value, key, ret = [],
763                          i = 0,
764                          length = elems.length,
765                          // jquery objects are treated as arrays
766                          isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
767  
768                  // Go through the array, translating each of the items to their
769                  if ( isArray ) {
770                          for ( ; i < length; i++ ) {
771                                  value = callback( elems[ i ], i, arg );
772  
773                                  if ( value != null ) {
774                                          ret[ ret.length ] = value;
775                                  }
776                          }
777  
778                  // Go through every key on the object,
779                  } else {
780                          for ( key in elems ) {
781                                  value = callback( elems[ key ], key, arg );
782  
783                                  if ( value != null ) {
784                                          ret[ ret.length ] = value;
785                                  }
786                          }
787                  }
788  
789                  // Flatten any nested arrays
790                  return ret.concat.apply( [], ret );
791          },
792  
793          // A global GUID counter for objects
794          guid: 1,
795  
796          // Bind a function to a context, optionally partially applying any
797          // arguments.
798          proxy: function( fn, context ) {
799                  if ( typeof context === "string" ) {
800                          var tmp = fn[ context ];
801                          context = fn;
802                          fn = tmp;
803                  }
804  
805                  // Quick check to determine if target is callable, in the spec
806                  // this throws a TypeError, but we will just return undefined.
807                  if ( !jQuery.isFunction( fn ) ) {
808                          return undefined;
809                  }
810  
811                  // Simulated bind
812                  var args = slice.call( arguments, 2 ),
813                          proxy = function() {
814                                  return fn.apply( context, args.concat( slice.call( arguments ) ) );
815                          };
816  
817                  // Set the guid of unique handler to the same of original handler, so it can be removed
818                  proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
819  
820                  return proxy;
821          },
822  
823          // Mutifunctional method to get and set values to a collection
824          // The value/s can optionally be executed if it's a function
825          access: function( elems, key, value, exec, fn, pass ) {
826                  var length = elems.length;
827  
828                  // Setting many attributes
829                  if ( typeof key === "object" ) {
830                          for ( var k in key ) {
831                                  jQuery.access( elems, k, key[k], exec, fn, value );
832                          }
833                          return elems;
834                  }
835  
836                  // Setting one attribute
837                  if ( value !== undefined ) {
838                          // Optionally, function values get executed if exec is true
839                          exec = !pass && exec && jQuery.isFunction(value);
840  
841                          for ( var i = 0; i < length; i++ ) {
842                                  fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
843                          }
844  
845                          return elems;
846                  }
847  
848                  // Getting an attribute
849                  return length ? fn( elems[0], key ) : undefined;
850          },
851  
852          now: function() {
853                  return ( new Date() ).getTime();
854          },
855  
856          // Use of jQuery.browser is frowned upon.
857          // More details: http://docs.jquery.com/Utilities/jQuery.browser
858          uaMatch: function( ua ) {
859                  ua = ua.toLowerCase();
860  
861                  var match = rwebkit.exec( ua ) ||
862                          ropera.exec( ua ) ||
863                          rmsie.exec( ua ) ||
864                          ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
865                          [];
866  
867                  return { browser: match[1] || "", version: match[2] || "0" };
868          },
869  
870          sub: function() {
871                  function jQuerySub( selector, context ) {
872                          return new jQuerySub.fn.init( selector, context );
873                  }
874                  jQuery.extend( true, jQuerySub, this );
875                  jQuerySub.superclass = this;
876                  jQuerySub.fn = jQuerySub.prototype = this();
877                  jQuerySub.fn.constructor = jQuerySub;
878                  jQuerySub.sub = this.sub;
879                  jQuerySub.fn.init = function init( selector, context ) {
880                          if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
881                                  context = jQuerySub( context );
882                          }
883  
884                          return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
885                  };
886                  jQuerySub.fn.init.prototype = jQuerySub.fn;
887                  var rootjQuerySub = jQuerySub(document);
888                  return jQuerySub;
889          },
890  
891          browser: {}
892  });
893  
894  // Populate the class2type map
895  jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
896          class2type[ "[object " + name + "]" ] = name.toLowerCase();
897  });
898  
899  browserMatch = jQuery.uaMatch( userAgent );
900  if ( browserMatch.browser ) {
901          jQuery.browser[ browserMatch.browser ] = true;
902          jQuery.browser.version = browserMatch.version;
903  }
904  
905  // Deprecated, use jQuery.browser.webkit instead
906  if ( jQuery.browser.webkit ) {
907          jQuery.browser.safari = true;
908  }
909  
910  // IE doesn't match non-breaking spaces with \s
911  if ( rnotwhite.test( "\xA0" ) ) {
912          trimLeft = /^[\s\xA0]+/;
913          trimRight = /[\s\xA0]+$/;
914  }
915  
916  // All jQuery objects should point back to these
917  rootjQuery = jQuery(document);
918  
919  // Cleanup functions for the document ready method
920  if ( document.addEventListener ) {
921          DOMContentLoaded = function() {
922                  document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
923                  jQuery.ready();
924          };
925  
926  } else if ( document.attachEvent ) {
927          DOMContentLoaded = function() {
928                  // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
929                  if ( document.readyState === "complete" ) {
930                          document.detachEvent( "onreadystatechange", DOMContentLoaded );
931                          jQuery.ready();
932                  }
933          };
934  }
935  
936  // The DOM ready check for Internet Explorer
937  function doScrollCheck() {
938          if ( jQuery.isReady ) {
939                  return;
940          }
941  
942          try {
943                  // If IE is used, use the trick by Diego Perini
944                  // http://javascript.nwbox.com/IEContentLoaded/
945                  document.documentElement.doScroll("left");
946          } catch(e) {
947                  setTimeout( doScrollCheck, 1 );
948                  return;
949          }
950  
951          // and execute any waiting functions
952          jQuery.ready();
953  }
954  
955  return jQuery;
956  
957  })();
958  
959  
960  // String to Object flags format cache
961  var flagsCache = {};
962  
963  // Convert String-formatted flags into Object-formatted ones and store in cache
964  function createFlags( flags ) {
965          var object = flagsCache[ flags ] = {},
966                  i, length;
967          flags = flags.split( /\s+/ );
968          for ( i = 0, length = flags.length; i < length; i++ ) {
969                  object[ flags[i] ] = true;
970          }
971          return object;
972  }
973  
974  /*
975   * Create a callback list using the following parameters:
976   *
977   *      flags:  an optional list of space-separated flags that will change how
978   *                      the callback list behaves
979   *
980   * By default a callback list will act like an event callback list and can be
981   * "fired" multiple times.
982   *
983   * Possible flags:
984   *
985   *      once:                   will ensure the callback list can only be fired once (like a Deferred)
986   *
987   *      memory:                 will keep track of previous values and will call any callback added
988   *                                      after the list has been fired right away with the latest "memorized"
989   *                                      values (like a Deferred)
990   *
991   *      unique:                 will ensure a callback can only be added once (no duplicate in the list)
992   *
993   *      stopOnFalse:    interrupt callings when a callback returns false
994   *
995   */
996  jQuery.Callbacks = function( flags ) {
997  
998          // Convert flags from String-formatted to Object-formatted
999          // (we check in cache first)
1000          flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1001  
1002          var // Actual callback list
1003                  list = [],
1004                  // Stack of fire calls for repeatable lists
1005                  stack = [],
1006                  // Last fire value (for non-forgettable lists)
1007                  memory,
1008                  // Flag to know if list is currently firing
1009                  firing,
1010                  // First callback to fire (used internally by add and fireWith)
1011                  firingStart,
1012                  // End of the loop when firing
1013                  firingLength,
1014                  // Index of currently firing callback (modified by remove if needed)
1015                  firingIndex,
1016                  // Add one or several callbacks to the list
1017                  add = function( args ) {
1018                          var i,
1019                                  length,
1020                                  elem,
1021                                  type,
1022                                  actual;
1023                          for ( i = 0, length = args.length; i < length; i++ ) {
1024                                  elem = args[ i ];
1025                                  type = jQuery.type( elem );
1026                                  if ( type === "array" ) {
1027                                          // Inspect recursively
1028                                          add( elem );
1029                                  } else if ( type === "function" ) {
1030                                          // Add if not in unique mode and callback is not in
1031                                          if ( !flags.unique || !self.has( elem ) ) {
1032                                                  list.push( elem );
1033                                          }
1034                                  }
1035                          }
1036                  },
1037                  // Fire callbacks
1038                  fire = function( context, args ) {
1039                          args = args || [];
1040                          memory = !flags.memory || [ context, args ];
1041                          firing = true;
1042                          firingIndex = firingStart || 0;
1043                          firingStart = 0;
1044                          firingLength = list.length;
1045                          for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1046                                  if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1047                                          memory = true; // Mark as halted
1048                                          break;
1049                                  }
1050                          }
1051                          firing = false;
1052                          if ( list ) {
1053                                  if ( !flags.once ) {
1054                                          if ( stack && stack.length ) {
1055                                                  memory = stack.shift();
1056                                                  self.fireWith( memory[ 0 ], memory[ 1 ] );
1057                                          }
1058                                  } else if ( memory === true ) {
1059                                          self.disable();
1060                                  } else {
1061                                          list = [];
1062                                  }
1063                          }
1064                  },
1065                  // Actual Callbacks object
1066                  self = {
1067                          // Add a callback or a collection of callbacks to the list
1068                          add: function() {
1069                                  if ( list ) {
1070                                          var length = list.length;
1071                                          add( arguments );
1072                                          // Do we need to add the callbacks to the
1073                                          // current firing batch?
1074                                          if ( firing ) {
1075                                                  firingLength = list.length;
1076                                          // With memory, if we're not firing then
1077                                          // we should call right away, unless previous
1078                                          // firing was halted (stopOnFalse)
1079                                          } else if ( memory && memory !== true ) {
1080                                                  firingStart = length;
1081                                                  fire( memory[ 0 ], memory[ 1 ] );
1082                                          }
1083                                  }
1084                                  return this;
1085                          },
1086                          // Remove a callback from the list
1087                          remove: function() {
1088                                  if ( list ) {
1089                                          var args = arguments,
1090                                                  argIndex = 0,
1091                                                  argLength = args.length;
1092                                          for ( ; argIndex < argLength ; argIndex++ ) {
1093                                                  for ( var i = 0; i < list.length; i++ ) {
1094                                                          if ( args[ argIndex ] === list[ i ] ) {
1095                                                                  // Handle firingIndex and firingLength
1096                                                                  if ( firing ) {
1097                                                                          if ( i <= firingLength ) {
1098                                                                                  firingLength--;
1099                                                                                  if ( i <= firingIndex ) {
1100                                                                                          firingIndex--;
1101                                                                                  }
1102                                                                          }
1103                                                                  }
1104                                                                  // Remove the element
1105                                                                  list.splice( i--, 1 );
1106                                                                  // If we have some unicity property then
1107                                                                  // we only need to do this once
1108                                                                  if ( flags.unique ) {
1109                                                                          break;
1110                                                                  }
1111                                                          }
1112                                                  }
1113                                          }
1114                                  }
1115                                  return this;
1116                          },
1117                          // Control if a given callback is in the list
1118                          has: function( fn ) {
1119                                  if ( list ) {
1120                                          var i = 0,
1121                                                  length = list.length;
1122                                          for ( ; i < length; i++ ) {
1123                                                  if ( fn === list[ i ] ) {
1124                                                          return true;
1125                                                  }
1126                                          }
1127                                  }
1128                                  return false;
1129                          },
1130                          // Remove all callbacks from the list
1131                          empty: function() {
1132                                  list = [];
1133                                  return this;
1134                          },
1135                          // Have the list do nothing anymore
1136                          disable: function() {
1137                                  list = stack = memory = undefined;
1138                                  return this;
1139                          },
1140                          // Is it disabled?
1141                          disabled: function() {
1142                                  return !list;
1143                          },
1144                          // Lock the list in its current state
1145                          lock: function() {
1146                                  stack = undefined;
1147                                  if ( !memory || memory === true ) {
1148                                          self.disable();
1149                                  }
1150                                  return this;
1151                          },
1152                          // Is it locked?
1153                          locked: function() {
1154                                  return !stack;
1155                          },
1156                          // Call all callbacks with the given context and arguments
1157                          fireWith: function( context, args ) {
1158                                  if ( stack ) {
1159                                          if ( firing ) {
1160                                                  if ( !flags.once ) {
1161                                                          stack.push( [ context, args ] );
1162                                                  }
1163                                          } else if ( !( flags.once && memory ) ) {
1164                                                  fire( context, args );
1165                                          }
1166                                  }
1167                                  return this;
1168                          },
1169                          // Call all the callbacks with the given arguments
1170                          fire: function() {
1171                                  self.fireWith( this, arguments );
1172                                  return this;
1173                          },
1174                          // To know if the callbacks have already been called at least once
1175                          fired: function() {
1176                                  return !!memory;
1177                          }
1178                  };
1179  
1180          return self;
1181  };
1182  
1183  
1184  
1185  
1186  var // Static reference to slice
1187          sliceDeferred = [].slice;
1188  
1189  jQuery.extend({
1190  
1191          Deferred: function( func ) {
1192                  var doneList = jQuery.Callbacks( "once memory" ),
1193                          failList = jQuery.Callbacks( "once memory" ),
1194                          progressList = jQuery.Callbacks( "memory" ),
1195                          state = "pending",
1196                          lists = {
1197                                  resolve: doneList,
1198                                  reject: failList,
1199                                  notify: progressList
1200                          },
1201                          promise = {
1202                                  done: doneList.add,
1203                                  fail: failList.add,
1204                                  progress: progressList.add,
1205  
1206                                  state: function() {
1207                                          return state;
1208                                  },
1209  
1210                                  // Deprecated
1211                                  isResolved: doneList.fired,
1212                                  isRejected: failList.fired,
1213  
1214                                  then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1215                                          deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1216                                          return this;
1217                                  },
1218                                  always: function() {
1219                                          deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1220                                          return this;
1221                                  },
1222                                  pipe: function( fnDone, fnFail, fnProgress ) {
1223                                          return jQuery.Deferred(function( newDefer ) {
1224                                                  jQuery.each( {
1225                                                          done: [ fnDone, "resolve" ],
1226                                                          fail: [ fnFail, "reject" ],
1227                                                          progress: [ fnProgress, "notify" ]
1228                                                  }, function( handler, data ) {
1229                                                          var fn = data[ 0 ],
1230                                                                  action = data[ 1 ],
1231                                                                  returned;
1232                                                          if ( jQuery.isFunction( fn ) ) {
1233                                                                  deferred[ handler ](function() {
1234                                                                          returned = fn.apply( this, arguments );
1235                                                                          if ( returned && jQuery.isFunction( returned.promise ) ) {
1236                                                                                  returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1237                                                                          } else {
1238                                                                                  newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1239                                                                          }
1240                                                                  });
1241                                                          } else {
1242                                                                  deferred[ handler ]( newDefer[ action ] );
1243                                                          }
1244                                                  });
1245                                          }).promise();
1246                                  },
1247                                  // Get a promise for this deferred
1248                                  // If obj is provided, the promise aspect is added to the object
1249                                  promise: function( obj ) {
1250                                          if ( obj == null ) {
1251                                                  obj = promise;
1252                                          } else {
1253                                                  for ( var key in promise ) {
1254                                                          obj[ key ] = promise[ key ];
1255                                                  }
1256                                          }
1257                                          return obj;
1258                                  }
1259                          },
1260                          deferred = promise.promise({}),
1261                          key;
1262  
1263                  for ( key in lists ) {
1264                          deferred[ key ] = lists[ key ].fire;
1265                          deferred[ key + "With" ] = lists[ key ].fireWith;
1266                  }
1267  
1268                  // Handle state
1269                  deferred.done( function() {
1270                          state = "resolved";
1271                  }, failList.disable, progressList.lock ).fail( function() {
1272                          state = "rejected";
1273                  }, doneList.disable, progressList.lock );
1274  
1275                  // Call given func if any
1276                  if ( func ) {
1277                          func.call( deferred, deferred );
1278                  }
1279  
1280                  // All done!
1281                  return deferred;
1282          },
1283  
1284          // Deferred helper
1285          when: function( firstParam ) {
1286                  var args = sliceDeferred.call( arguments, 0 ),
1287                          i = 0,
1288                          length = args.length,
1289                          pValues = new Array( length ),
1290                          count = length,
1291                          pCount = length,
1292                          deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1293                                  firstParam :
1294                                  jQuery.Deferred(),
1295                          promise = deferred.promise();
1296                  function resolveFunc( i ) {
1297                          return function( value ) {
1298                                  args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1299                                  if ( !( --count ) ) {
1300                                          deferred.resolveWith( deferred, args );
1301                                  }
1302                          };
1303                  }
1304                  function progressFunc( i ) {
1305                          return function( value ) {
1306                                  pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1307                                  deferred.notifyWith( promise, pValues );
1308                          };
1309                  }
1310                  if ( length > 1 ) {
1311                          for ( ; i < length; i++ ) {
1312                                  if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1313                                          args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1314                                  } else {
1315                                          --count;
1316                                  }
1317                          }
1318                          if ( !count ) {
1319                                  deferred.resolveWith( deferred, args );
1320                          }
1321                  } else if ( deferred !== firstParam ) {
1322                          deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1323                  }
1324                  return promise;
1325          }
1326  });
1327  
1328  
1329  
1330  
1331  jQuery.support = (function() {
1332  
1333          var support,
1334                  all,
1335                  a,
1336                  select,
1337                  opt,
1338                  input,
1339                  marginDiv,
1340                  fragment,
1341                  tds,
1342                  events,
1343                  eventName,
1344                  i,
1345                  isSupported,
1346                  div = document.createElement( "div" ),
1347                  documentElement = document.documentElement;
1348  
1349          // Preliminary tests
1350          div.setAttribute("className", "t");
1351          div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1352  
1353          all = div.getElementsByTagName( "*" );
1354          a = div.getElementsByTagName( "a" )[ 0 ];
1355  
1356          // Can't get basic test support
1357          if ( !all || !all.length || !a ) {
1358                  return {};
1359          }
1360  
1361          // First batch of supports tests
1362          select = document.createElement( "select" );
1363          opt = select.appendChild( document.createElement("option") );
1364          input = div.getElementsByTagName( "input" )[ 0 ];
1365  
1366          support = {
1367                  // IE strips leading whitespace when .innerHTML is used
1368                  leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1369  
1370                  // Make sure that tbody elements aren't automatically inserted
1371                  // IE will insert them into empty tables
1372                  tbody: !div.getElementsByTagName("tbody").length,
1373  
1374                  // Make sure that link elements get serialized correctly by innerHTML
1375                  // This requires a wrapper element in IE
1376                  htmlSerialize: !!div.getElementsByTagName("link").length,
1377  
1378                  // Get the style information from getAttribute
1379                  // (IE uses .cssText instead)
1380                  style: /top/.test( a.getAttribute("style") ),
1381  
1382                  // Make sure that URLs aren't manipulated
1383                  // (IE normalizes it by default)
1384                  hrefNormalized: ( a.getAttribute("href") === "/a" ),
1385  
1386                  // Make sure that element opacity exists
1387                  // (IE uses filter instead)
1388                  // Use a regex to work around a WebKit issue. See #5145
1389                  opacity: /^0.55/.test( a.style.opacity ),
1390  
1391                  // Verify style float existence
1392                  // (IE uses styleFloat instead of cssFloat)
1393                  cssFloat: !!a.style.cssFloat,
1394  
1395                  // Make sure that if no value is specified for a checkbox
1396                  // that it defaults to "on".
1397                  // (WebKit defaults to "" instead)
1398                  checkOn: ( input.value === "on" ),
1399  
1400                  // Make sure that a selected-by-default option has a working selected property.
1401                  // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1402                  optSelected: opt.selected,
1403  
1404                  // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1405                  getSetAttribute: div.className !== "t",
1406  
1407                  // Tests for enctype support on a form(#6743)
1408                  enctype: !!document.createElement("form").enctype,
1409  
1410                  // Makes sure cloning an html5 element does not cause problems
1411                  // Where outerHTML is undefined, this still works
1412                  html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1413  
1414                  // Will be defined later
1415                  submitBubbles: true,
1416                  changeBubbles: true,
1417                  focusinBubbles: false,
1418                  deleteExpando: true,
1419                  noCloneEvent: true,
1420                  inlineBlockNeedsLayout: false,
1421                  shrinkWrapBlocks: false,
1422                  reliableMarginRight: true
1423          };
1424  
1425          // Make sure checked status is properly cloned
1426          input.checked = true;
1427          support.noCloneChecked = input.cloneNode( true ).checked;
1428  
1429          // Make sure that the options inside disabled selects aren't marked as disabled
1430          // (WebKit marks them as disabled)
1431          select.disabled = true;
1432          support.optDisabled = !opt.disabled;
1433  
1434          // Test to see if it's possible to delete an expando from an element
1435          // Fails in Internet Explorer
1436          try {
1437                  delete div.test;
1438          } catch( e ) {
1439                  support.deleteExpando = false;
1440          }
1441  
1442          if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1443                  div.attachEvent( "onclick", function() {
1444                          // Cloning a node shouldn't copy over any
1445                          // bound event handlers (IE does this)
1446                          support.noCloneEvent = false;
1447                  });
1448                  div.cloneNode( true ).fireEvent( "onclick" );
1449          }
1450  
1451          // Check if a radio maintains its value
1452          // after being appended to the DOM
1453          input = document.createElement("input");
1454          input.value = "t";
1455          input.setAttribute("type", "radio");
1456          support.radioValue = input.value === "t";
1457  
1458          input.setAttribute("checked", "checked");
1459          div.appendChild( input );
1460          fragment = document.createDocumentFragment();
1461          fragment.appendChild( div.lastChild );
1462  
1463          // WebKit doesn't clone checked state correctly in fragments
1464          support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1465  
1466          // Check if a disconnected checkbox will retain its checked
1467          // value of true after appended to the DOM (IE6/7)
1468          support.appendChecked = input.checked;
1469  
1470          fragment.removeChild( input );
1471          fragment.appendChild( div );
1472  
1473          div.innerHTML = "";
1474  
1475          // Check if div with explicit width and no margin-right incorrectly
1476          // gets computed margin-right based on width of container. For more
1477          // info see bug #3333
1478          // Fails in WebKit before Feb 2011 nightlies
1479          // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1480          if ( window.getComputedStyle ) {
1481                  marginDiv = document.createElement( "div" );
1482                  marginDiv.style.width = "0";
1483                  marginDiv.style.marginRight = "0";
1484                  div.style.width = "2px";
1485                  div.appendChild( marginDiv );
1486                  support.reliableMarginRight =
1487                          ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1488          }
1489  
1490          // Technique from Juriy Zaytsev
1491          // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1492          // We only care about the case where non-standard event systems
1493          // are used, namely in IE. Short-circuiting here helps us to
1494          // avoid an eval call (in setAttribute) which can cause CSP
1495          // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1496          if ( div.attachEvent ) {
1497                  for( i in {
1498                          submit: 1,
1499                          change: 1,
1500                          focusin: 1
1501                  }) {
1502                          eventName = "on" + i;
1503                          isSupported = ( eventName in div );
1504                          if ( !isSupported ) {
1505                                  div.setAttribute( eventName, "return;" );
1506                                  isSupported = ( typeof div[ eventName ] === "function" );
1507                          }
1508                          support[ i + "Bubbles" ] = isSupported;
1509                  }
1510          }
1511  
1512          fragment.removeChild( div );
1513  
1514          // Null elements to avoid leaks in IE
1515          fragment = select = opt = marginDiv = div = input = null;
1516  
1517          // Run tests that need a body at doc ready
1518          jQuery(function() {
1519                  var container, outer, inner, table, td, offsetSupport,
1520                          conMarginTop, ptlm, vb, style, html,
1521                          body = document.getElementsByTagName("body")[0];
1522  
1523                  if ( !body ) {
1524                          // Return for frameset docs that don't have a body
1525                          return;
1526                  }
1527  
1528                  conMarginTop = 1;
1529                  ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";
1530                  vb = "visibility:hidden;border:0;";
1531                  style = "style='" + ptlm + "border:5px solid #000;padding:0;'";
1532                  html = "<div " + style + "><div></div></div>" +
1533                          "<table " + style + " cellpadding='0' cellspacing='0'>" +
1534                          "<tr><td></td></tr></table>";
1535  
1536                  container = document.createElement("div");
1537                  container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
1538                  body.insertBefore( container, body.firstChild );
1539  
1540                  // Construct the test element
1541                  div = document.createElement("div");
1542                  container.appendChild( div );
1543  
1544                  // Check if table cells still have offsetWidth/Height when they are set
1545                  // to display:none and there are still other visible table cells in a
1546                  // table row; if so, offsetWidth/Height are not reliable for use when
1547                  // determining if an element has been hidden directly using
1548                  // display:none (it is still safe to use offsets if a parent element is
1549                  // hidden; don safety goggles and see bug #4512 for more information).
1550                  // (only IE 8 fails this test)
1551                  div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1552                  tds = div.getElementsByTagName( "td" );
1553                  isSupported = ( tds[ 0 ].offsetHeight === 0 );
1554  
1555                  tds[ 0 ].style.display = "";
1556                  tds[ 1 ].style.display = "none";
1557  
1558                  // Check if empty table cells still have offsetWidth/Height
1559                  // (IE <= 8 fail this test)
1560                  support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1561  
1562                  // Figure out if the W3C box model works as expected
1563                  div.innerHTML = "";
1564                  div.style.width = div.style.paddingLeft = "1px";
1565                  jQuery.boxModel = support.boxModel = div.offsetWidth === 2;
1566  
1567                  if ( typeof div.style.zoom !== "undefined" ) {
1568                          // Check if natively block-level elements act like inline-block
1569                          // elements when setting their display to 'inline' and giving
1570                          // them layout
1571                          // (IE < 8 does this)
1572                          div.style.display = "inline";
1573                          div.style.zoom = 1;
1574                          support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1575  
1576                          // Check if elements with layout shrink-wrap their children
1577                          // (IE 6 does this)
1578                          div.style.display = "";
1579                          div.innerHTML = "<div style='width:4px;'></div>";
1580                          support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1581                  }
1582  
1583                  div.style.cssText = ptlm + vb;
1584                  div.innerHTML = html;
1585  
1586                  outer = div.firstChild;
1587                  inner = outer.firstChild;
1588                  td = outer.nextSibling.firstChild.firstChild;
1589  
1590                  offsetSupport = {
1591                          doesNotAddBorder: ( inner.offsetTop !== 5 ),
1592                          doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
1593                  };
1594  
1595                  inner.style.position = "fixed";
1596                  inner.style.top = "20px";
1597  
1598                  // safari subtracts parent border width here which is 5px
1599                  offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
1600                  inner.style.position = inner.style.top = "";
1601  
1602                  outer.style.overflow = "hidden";
1603                  outer.style.position = "relative";
1604  
1605                  offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
1606                  offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
1607  
1608                  body.removeChild( container );
1609                  div  = container = null;
1610  
1611                  jQuery.extend( support, offsetSupport );
1612          });
1613  
1614          return support;
1615  })();
1616  
1617  
1618  
1619  
1620  var rbrace = /^(?:\{.*\}|\[.*\])$/,
1621          rmultiDash = /([A-Z])/g;
1622  
1623  jQuery.extend({
1624          cache: {},
1625  
1626          // Please use with caution
1627          uuid: 0,
1628  
1629          // Unique for each copy of jQuery on the page
1630          // Non-digits removed to match rinlinejQuery
1631          expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1632  
1633          // The following elements throw uncatchable exceptions if you
1634          // attempt to add expando properties to them.
1635          noData: {
1636                  "embed": true,
1637                  // Ban all objects except for Flash (which handle expandos)
1638                  "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1639                  "applet": true
1640          },
1641  
1642          hasData: function( elem ) {
1643                  elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1644                  return !!elem && !isEmptyDataObject( elem );
1645          },
1646  
1647          data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1648                  if ( !jQuery.acceptData( elem ) ) {
1649                          return;
1650                  }
1651  
1652                  var privateCache, thisCache, ret,
1653                          internalKey = jQuery.expando,
1654                          getByName = typeof name === "string",
1655  
1656                          // We have to handle DOM nodes and JS objects differently because IE6-7
1657                          // can't GC object references properly across the DOM-JS boundary
1658                          isNode = elem.nodeType,
1659  
1660                          // Only DOM nodes need the global jQuery cache; JS object data is
1661                          // attached directly to the object so GC can occur automatically
1662                          cache = isNode ? jQuery.cache : elem,
1663  
1664                          // Only defining an ID for JS objects if its cache already exists allows
1665                          // the code to shortcut on the same path as a DOM node with no cache
1666                          id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
1667                          isEvents = name === "events";
1668  
1669                  // Avoid doing any more work than we need to when trying to get data on an
1670                  // object that has no data at all
1671                  if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
1672                          return;
1673                  }
1674  
1675                  if ( !id ) {
1676                          // Only DOM nodes need a new unique ID for each element since their data
1677                          // ends up in the global cache
1678                          if ( isNode ) {
1679                                  elem[ internalKey ] = id = ++jQuery.uuid;
1680                          } else {
1681                                  id = internalKey;
1682                          }
1683                  }
1684  
1685                  if ( !cache[ id ] ) {
1686                          cache[ id ] = {};
1687  
1688                          // Avoids exposing jQuery metadata on plain JS objects when the object
1689                          // is serialized using JSON.stringify
1690                          if ( !isNode ) {
1691                                  cache[ id ].toJSON = jQuery.noop;
1692                          }
1693                  }
1694  
1695                  // An object can be passed to jQuery.data instead of a key/value pair; this gets
1696                  // shallow copied over onto the existing cache
1697                  if ( typeof name === "object" || typeof name === "function" ) {
1698                          if ( pvt ) {
1699                                  cache[ id ] = jQuery.extend( cache[ id ], name );
1700                          } else {
1701                                  cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1702                          }
1703                  }
1704  
1705                  privateCache = thisCache = cache[ id ];
1706  
1707                  // jQuery data() is stored in a separate object inside the object's internal data
1708                  // cache in order to avoid key collisions between internal data and user-defined
1709                  // data.
1710                  if ( !pvt ) {
1711                          if ( !thisCache.data ) {
1712                                  thisCache.data = {};
1713                          }
1714  
1715                          thisCache = thisCache.data;
1716                  }
1717  
1718                  if ( data !== undefined ) {
1719                          thisCache[ jQuery.camelCase( name ) ] = data;
1720                  }
1721  
1722                  // Users should not attempt to inspect the internal events object using jQuery.data,
1723                  // it is undocumented and subject to change. But does anyone listen? No.
1724                  if ( isEvents && !thisCache[ name ] ) {
1725                          return privateCache.events;
1726                  }
1727  
1728                  // Check for both converted-to-camel and non-converted data property names
1729                  // If a data property was specified
1730                  if ( getByName ) {
1731  
1732                          // First Try to find as-is property data
1733                          ret = thisCache[ name ];
1734  
1735                          // Test for null|undefined property data
1736                          if ( ret == null ) {
1737  
1738                                  // Try to find the camelCased property
1739                                  ret = thisCache[ jQuery.camelCase( name ) ];
1740                          }
1741                  } else {
1742                          ret = thisCache;
1743                  }
1744  
1745                  return ret;
1746          },
1747  
1748          removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1749                  if ( !jQuery.acceptData( elem ) ) {
1750                          return;
1751                  }
1752  
1753                  var thisCache, i, l,
1754  
1755                          // Reference to internal data cache key
1756                          internalKey = jQuery.expando,
1757  
1758                          isNode = elem.nodeType,
1759  
1760                          // See jQuery.data for more information
1761                          cache = isNode ? jQuery.cache : elem,
1762  
1763                          // See jQuery.data for more information
1764                          id = isNode ? elem[ internalKey ] : internalKey;
1765  
1766                  // If there is already no cache entry for this object, there is no
1767                  // purpose in continuing
1768                  if ( !cache[ id ] ) {
1769                          return;
1770                  }
1771  
1772                  if ( name ) {
1773  
1774                          thisCache = pvt ? cache[ id ] : cache[ id ].data;
1775  
1776                          if ( thisCache ) {
1777  
1778                                  // Support array or space separated string names for data keys
1779                                  if ( !jQuery.isArray( name ) ) {
1780  
1781                                          // try the string as a key before any manipulation
1782                                          if ( name in thisCache ) {
1783                                                  name = [ name ];
1784                                          } else {
1785  
1786                                                  // split the camel cased version by spaces unless a key with the spaces exists
1787                                                  name = jQuery.camelCase( name );
1788                                                  if ( name in thisCache ) {
1789                                                          name = [ name ];
1790                                                  } else {
1791                                                          name = name.split( " " );
1792                                                  }
1793                                          }
1794                                  }
1795  
1796                                  for ( i = 0, l = name.length; i < l; i++ ) {
1797                                          delete thisCache[ name[i] ];
1798                                  }
1799  
1800                                  // If there is no data left in the cache, we want to continue
1801                                  // and let the cache object itself get destroyed
1802                                  if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1803                                          return;
1804                                  }
1805                          }
1806                  }
1807  
1808                  // See jQuery.data for more information
1809                  if ( !pvt ) {
1810                          delete cache[ id ].data;
1811  
1812                          // Don't destroy the parent cache unless the internal data object
1813                          // had been the only thing left in it
1814                          if ( !isEmptyDataObject(cache[ id ]) ) {
1815                                  return;
1816                          }
1817                  }
1818  
1819                  // Browsers that fail expando deletion also refuse to delete expandos on
1820                  // the window, but it will allow it on all other JS objects; other browsers
1821                  // don't care
1822                  // Ensure that `cache` is not a window object #10080
1823                  if ( jQuery.support.deleteExpando || !cache.setInterval ) {
1824                          delete cache[ id ];
1825                  } else {
1826                          cache[ id ] = null;
1827                  }
1828  
1829                  // We destroyed the cache and need to eliminate the expando on the node to avoid
1830                  // false lookups in the cache for entries that no longer exist
1831                  if ( isNode ) {
1832                          // IE does not allow us to delete expando properties from nodes,
1833                          // nor does it have a removeAttribute function on Document nodes;
1834                          // we must handle all of these cases
1835                          if ( jQuery.support.deleteExpando ) {
1836                                  delete elem[ internalKey ];
1837                          } else if ( elem.removeAttribute ) {
1838                                  elem.removeAttribute( internalKey );
1839                          } else {
1840                                  elem[ internalKey ] = null;
1841                          }
1842                  }
1843          },
1844  
1845          // For internal use only.
1846          _data: function( elem, name, data ) {
1847                  return jQuery.data( elem, name, data, true );
1848          },
1849  
1850          // A method for determining if a DOM node can handle the data expando
1851          acceptData: function( elem ) {
1852                  if ( elem.nodeName ) {
1853                          var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1854  
1855                          if ( match ) {
1856                                  return !(match === true || elem.getAttribute("classid") !== match);
1857                          }
1858                  }
1859  
1860                  return true;
1861          }
1862  });
1863  
1864  jQuery.fn.extend({
1865          data: function( key, value ) {
1866                  var parts, attr, name,
1867                          data = null;
1868  
1869                  if ( typeof key === "undefined" ) {
1870                          if ( this.length ) {
1871                                  data = jQuery.data( this[0] );
1872  
1873                                  if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) {
1874                                          attr = this[0].attributes;
1875                                          for ( var i = 0, l = attr.length; i < l; i++ ) {
1876                                                  name = attr[i].name;
1877  
1878                                                  if ( name.indexOf( "data-" ) === 0 ) {
1879                                                          name = jQuery.camelCase( name.substring(5) );
1880  
1881                                                          dataAttr( this[0], name, data[ name ] );
1882                                                  }
1883                                          }
1884                                          jQuery._data( this[0], "parsedAttrs", true );
1885                                  }
1886                          }
1887  
1888                          return data;
1889  
1890                  } else if ( typeof key === "object" ) {
1891                          return this.each(function() {
1892                                  jQuery.data( this, key );
1893                          });
1894                  }
1895  
1896                  parts = key.split(".");
1897                  parts[1] = parts[1] ? "." + parts[1] : "";
1898  
1899                  if ( value === undefined ) {
1900                          data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1901  
1902                          // Try to fetch any internally stored data first
1903                          if ( data === undefined && this.length ) {
1904                                  data = jQuery.data( this[0], key );
1905                                  data = dataAttr( this[0], key, data );
1906                          }
1907  
1908                          return data === undefined && parts[1] ?
1909                                  this.data( parts[0] ) :
1910                                  data;
1911  
1912                  } else {
1913                          return this.each(function() {
1914                                  var self = jQuery( this ),
1915                                          args = [ parts[0], value ];
1916  
1917                                  self.triggerHandler( "setData" + parts[1] + "!", args );
1918                                  jQuery.data( this, key, value );
1919                                  self.triggerHandler( "changeData" + parts[1] + "!", args );
1920                          });
1921                  }
1922          },
1923  
1924          removeData: function( key ) {
1925                  return this.each(function() {
1926                          jQuery.removeData( this, key );
1927                  });
1928          }
1929  });
1930  
1931  function dataAttr( elem, key, data ) {
1932          // If nothing was found internally, try to fetch any
1933          // data from the HTML5 data-* attribute
1934          if ( data === undefined && elem.nodeType === 1 ) {
1935  
1936                  var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1937  
1938                  data = elem.getAttribute( name );
1939  
1940                  if ( typeof data === "string" ) {
1941                          try {
1942                                  data = data === "true" ? true :
1943                                  data === "false" ? false :
1944                                  data === "null" ? null :
1945                                  jQuery.isNumeric( data ) ? parseFloat( data ) :
1946                                          rbrace.test( data ) ? jQuery.parseJSON( data ) :
1947                                          data;
1948                          } catch( e ) {}
1949  
1950                          // Make sure we set the data so it isn't changed later
1951                          jQuery.data( elem, key, data );
1952  
1953                  } else {
1954                          data = undefined;
1955                  }
1956          }
1957  
1958          return data;
1959  }
1960  
1961  // checks a cache object for emptiness
1962  function isEmptyDataObject( obj ) {
1963          for ( var name in obj ) {
1964  
1965                  // if the public data object is empty, the private is still empty
1966                  if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1967                          continue;
1968                  }
1969                  if ( name !== "toJSON" ) {
1970                          return false;
1971                  }
1972          }
1973  
1974          return true;
1975  }
1976  
1977  
1978  
1979  
1980  function handleQueueMarkDefer( elem, type, src ) {
1981          var deferDataKey = type + "defer",
1982                  queueDataKey = type + "queue",
1983                  markDataKey = type + "mark",
1984                  defer = jQuery._data( elem, deferDataKey );
1985          if ( defer &&
1986                  ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
1987                  ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
1988                  // Give room for hard-coded callbacks to fire first
1989                  // and eventually mark/queue something else on the element
1990                  setTimeout( function() {
1991                          if ( !jQuery._data( elem, queueDataKey ) &&
1992                                  !jQuery._data( elem, markDataKey ) ) {
1993                                  jQuery.removeData( elem, deferDataKey, true );
1994                                  defer.fire();
1995                          }
1996                  }, 0 );
1997          }
1998  }
1999  
2000  jQuery.extend({
2001  
2002          _mark: function( elem, type ) {
2003                  if ( elem ) {
2004                          type = ( type || "fx" ) + "mark";
2005                          jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
2006                  }
2007          },
2008  
2009          _unmark: function( force, elem, type ) {
2010                  if ( force !== true ) {
2011                          type = elem;
2012                          elem = force;
2013                          force = false;
2014                  }
2015                  if ( elem ) {
2016                          type = type || "fx";
2017                          var key = type + "mark",
2018                                  count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
2019                          if ( count ) {
2020                                  jQuery._data( elem, key, count );
2021                          } else {
2022                                  jQuery.removeData( elem, key, true );
2023                                  handleQueueMarkDefer( elem, type, "mark" );
2024                          }
2025                  }
2026          },
2027  
2028          queue: function( elem, type, data ) {
2029                  var q;
2030                  if ( elem ) {
2031                          type = ( type || "fx" ) + "queue";
2032                          q = jQuery._data( elem, type );
2033  
2034                          // Speed up dequeue by getting out quickly if this is just a lookup
2035                          if ( data ) {
2036                                  if ( !q || jQuery.isArray(data) ) {
2037                                          q = jQuery._data( elem, type, jQuery.makeArray(data) );
2038                                  } else {
2039                                          q.push( data );
2040                                  }
2041                          }
2042                          return q || [];
2043                  }
2044          },
2045  
2046          dequeue: function( elem, type ) {
2047                  type = type || "fx";
2048  
2049                  var queue = jQuery.queue( elem, type ),
2050                          fn = queue.shift(),
2051                          hooks = {};
2052  
2053                  // If the fx queue is dequeued, always remove the progress sentinel
2054                  if ( fn === "inprogress" ) {
2055                          fn = queue.shift();
2056                  }
2057  
2058                  if ( fn ) {
2059                          // Add a progress sentinel to prevent the fx queue from being
2060                          // automatically dequeued
2061                          if ( type === "fx" ) {
2062                                  queue.unshift( "inprogress" );
2063                          }
2064  
2065                          jQuery._data( elem, type + ".run", hooks );
2066                          fn.call( elem, function() {
2067                                  jQuery.dequeue( elem, type );
2068                          }, hooks );
2069                  }
2070  
2071                  if ( !queue.length ) {
2072                          jQuery.removeData( elem, type + "queue " + type + ".run", true );
2073                          handleQueueMarkDefer( elem, type, "queue" );
2074                  }
2075          }
2076  });
2077  
2078  jQuery.fn.extend({
2079          queue: function( type, data ) {
2080                  if ( typeof type !== "string" ) {
2081                          data = type;
2082                          type = "fx";
2083                  }
2084  
2085                  if ( data === undefined ) {
2086                          return jQuery.queue( this[0], type );
2087                  }
2088                  return this.each(function() {
2089                          var queue = jQuery.queue( this, type, data );
2090  
2091                          if ( type === "fx" && queue[0] !== "inprogress" ) {
2092                                  jQuery.dequeue( this, type );
2093                          }
2094                  });
2095          },
2096          dequeue: function( type ) {
2097                  return this.each(function() {
2098                          jQuery.dequeue( this, type );
2099                  });
2100          },
2101          // Based off of the plugin by Clint Helfers, with permission.
2102          // http://blindsignals.com/index.php/2009/07/jquery-delay/
2103          delay: function( time, type ) {
2104                  time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2105                  type = type || "fx";
2106  
2107                  return this.queue( type, function( next, hooks ) {
2108                          var timeout = setTimeout( next, time );
2109                          hooks.stop = function() {
2110                                  clearTimeout( timeout );
2111                          };
2112                  });
2113          },
2114          clearQueue: function( type ) {
2115                  return this.queue( type || "fx", [] );
2116          },
2117          // Get a promise resolved when queues of a certain type
2118          // are emptied (fx is the type by default)
2119          promise: function( type, object ) {
2120                  if ( typeof type !== "string" ) {
2121                          object = type;
2122                          type = undefined;
2123                  }
2124                  type = type || "fx";
2125                  var defer = jQuery.Deferred(),
2126                          elements = this,
2127                          i = elements.length,
2128                          count = 1,
2129                          deferDataKey = type + "defer",
2130                          queueDataKey = type + "queue",
2131                          markDataKey = type + "mark",
2132                          tmp;
2133                  function resolve() {
2134                          if ( !( --count ) ) {
2135                                  defer.resolveWith( elements, [ elements ] );
2136                          }
2137                  }
2138                  while( i-- ) {
2139                          if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2140                                          ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2141                                                  jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2142                                          jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2143                                  count++;
2144                                  tmp.add( resolve );
2145                          }
2146                  }
2147                  resolve();
2148                  return defer.promise();
2149          }
2150  });
2151  
2152  
2153  
2154  
2155  var rclass = /[\n\t\r]/g,
2156          rspace = /\s+/,
2157          rreturn = /\r/g,
2158          rtype = /^(?:button|input)$/i,
2159          rfocusable = /^(?:button|input|object|select|textarea)$/i,
2160          rclickable = /^a(?:rea)?$/i,
2161          rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2162          getSetAttribute = jQuery.support.getSetAttribute,
2163          nodeHook, boolHook, fixSpecified;
2164  
2165  jQuery.fn.extend({
2166          attr: function( name, value ) {
2167                  return jQuery.access( this, name, value, true, jQuery.attr );
2168          },
2169  
2170          removeAttr: function( name ) {
2171                  return this.each(function() {
2172                          jQuery.removeAttr( this, name );
2173                  });
2174          },
2175  
2176          prop: function( name, value ) {
2177                  return jQuery.access( this, name, value, true, jQuery.prop );
2178          },
2179  
2180          removeProp: function( name ) {
2181                  name = jQuery.propFix[ name ] || name;
2182                  return this.each(function() {
2183                          // try/catch handles cases where IE balks (such as removing a property on window)
2184                          try {
2185                                  this[ name ] = undefined;
2186                                  delete this[ name ];
2187                          } catch( e ) {}
2188                  });
2189          },
2190  
2191          addClass: function( value ) {
2192                  var classNames, i, l, elem,
2193                          setClass, c, cl;
2194  
2195                  if ( jQuery.isFunction( value ) ) {
2196                          return this.each(function( j ) {
2197                                  jQuery( this ).addClass( value.call(this, j, this.className) );
2198                          });
2199                  }
2200  
2201                  if ( value && typeof value === "string" ) {
2202                          classNames = value.split( rspace );
2203  
2204                          for ( i = 0, l = this.length; i < l; i++ ) {
2205                                  elem = this[ i ];
2206  
2207                                  if ( elem.nodeType === 1 ) {
2208                                          if ( !elem.className && classNames.length === 1 ) {
2209                                                  elem.className = value;
2210  
2211                                          } else {
2212                                                  setClass = " " + elem.className + " ";
2213  
2214                                                  for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2215                                                          if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2216                                                                  setClass += classNames[ c ] + " ";
2217                                                          }
2218                                                  }
2219                                                  elem.className = jQuery.trim( setClass );
2220                                          }
2221                                  }
2222                          }
2223                  }
2224  
2225                  return this;
2226          },
2227  
2228          removeClass: function( value ) {
2229                  var classNames, i, l, elem, className, c, cl;
2230  
2231                  if ( jQuery.isFunction( value ) ) {
2232                          return this.each(function( j ) {
2233                                  jQuery( this ).removeClass( value.call(this, j, this.className) );
2234                          });
2235                  }
2236  
2237                  if ( (value && typeof value === "string") || value === undefined ) {
2238                          classNames = ( value || "" ).split( rspace );
2239  
2240                          for ( i = 0, l = this.length; i < l; i++ ) {
2241                                  elem = this[ i ];
2242  
2243                                  if ( elem.nodeType === 1 && elem.className ) {
2244                                          if ( value ) {
2245                                                  className = (" " + elem.className + " ").replace( rclass, " " );
2246                                                  for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2247                                                          className = className.replace(" " + classNames[ c ] + " ", " ");
2248                                                  }
2249                                                  elem.className = jQuery.trim( className );
2250  
2251                                          } else {
2252                                                  elem.className = "";
2253                                          }
2254                                  }
2255                          }
2256                  }
2257  
2258                  return this;
2259          },
2260  
2261          toggleClass: function( value, stateVal ) {
2262                  var type = typeof value,
2263                          isBool = typeof stateVal === "boolean";
2264  
2265                  if ( jQuery.isFunction( value ) ) {
2266                          return this.each(function( i ) {
2267                                  jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2268                          });
2269                  }
2270  
2271                  return this.each(function() {
2272                          if ( type === "string" ) {
2273                                  // toggle individual class names
2274                                  var className,
2275                                          i = 0,
2276                                          self = jQuery( this ),
2277                                          state = stateVal,
2278                                          classNames = value.split( rspace );
2279  
2280                                  while ( (className = classNames[ i++ ]) ) {
2281                                          // check each className given, space seperated list
2282                                          state = isBool ? state : !self.hasClass( className );
2283                                          self[ state ? "addClass" : "removeClass" ]( className );
2284                                  }
2285  
2286                          } else if ( type === "undefined" || type === "boolean" ) {
2287                                  if ( this.className ) {
2288                                          // store className if set
2289                                          jQuery._data( this, "__className__", this.className );
2290                                  }
2291  
2292                                  // toggle whole className
2293                                  this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2294                          }
2295                  });
2296          },
2297  
2298          hasClass: function( selector ) {
2299                  var className = " " + selector + " ",
2300                          i = 0,
2301                          l = this.length;
2302                  for ( ; i < l; i++ ) {
2303                          if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2304                                  return true;
2305                          }
2306                  }
2307  
2308                  return false;
2309          },
2310  
2311          val: function( value ) {
2312                  var hooks, ret, isFunction,
2313                          elem = this[0];
2314  
2315                  if ( !arguments.length ) {
2316                          if ( elem ) {
2317                                  hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2318  
2319                                  if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2320                                          return ret;
2321                                  }
2322  
2323                                  ret = elem.value;
2324  
2325                                  return typeof ret === "string" ?
2326                                          // handle most common string cases
2327                                          ret.replace(rreturn, "") :
2328                                          // handle cases where value is null/undef or number
2329                                          ret == null ? "" : ret;
2330                          }
2331  
2332                          return;
2333                  }
2334  
2335                  isFunction = jQuery.isFunction( value );
2336  
2337                  return this.each(function( i ) {
2338                          var self = jQuery(this), val;
2339  
2340                          if ( this.nodeType !== 1 ) {
2341                                  return;
2342                          }
2343  
2344                          if ( isFunction ) {
2345                                  val = value.call( this, i, self.val() );
2346                          } else {
2347                                  val = value;
2348                          }
2349  
2350                          // Treat null/undefined as ""; convert numbers to string
2351                          if ( val == null ) {
2352                                  val = "";
2353                          } else if ( typeof val === "number" ) {
2354                                  val += "";
2355                          } else if ( jQuery.isArray( val ) ) {
2356                                  val = jQuery.map(val, function ( value ) {
2357                                          return value == null ? "" : value + "";
2358                                  });
2359                          }
2360  
2361                          hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2362  
2363                          // If set returns undefined, fall back to normal setting
2364                          if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2365                                  this.value = val;
2366                          }
2367                  });
2368          }
2369  });
2370  
2371  jQuery.extend({
2372          valHooks: {
2373                  option: {
2374                          get: function( elem ) {
2375                                  // attributes.value is undefined in Blackberry 4.7 but
2376                                  // uses .value. See #6932
2377                                  var val = elem.attributes.value;
2378                                  return !val || val.specified ? elem.value : elem.text;
2379                          }
2380                  },
2381                  select: {
2382                          get: function( elem ) {
2383                                  var value, i, max, option,
2384                                          index = elem.selectedIndex,
2385                                          values = [],
2386                                          options = elem.options,
2387                                          one = elem.type === "select-one";
2388  
2389                                  // Nothing was selected
2390                                  if ( index < 0 ) {
2391                                          return null;
2392                                  }
2393  
2394                                  // Loop through all the selected options
2395                                  i = one ? index : 0;
2396                                  max = one ? index + 1 : options.length;
2397                                  for ( ; i < max; i++ ) {
2398                                          option = options[ i ];
2399  
2400                                          // Don't return options that are disabled or in a disabled optgroup
2401                                          if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2402                                                          (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2403  
2404                                                  // Get the specific value for the option
2405                                                  value = jQuery( option ).val();
2406  
2407                                                  // We don't need an array for one selects
2408                                                  if ( one ) {
2409                                                          return value;
2410                                                  }
2411  
2412                                                  // Multi-Selects return an array
2413                                                  values.push( value );
2414                                          }
2415                                  }
2416  
2417                                  // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2418                                  if ( one && !values.length && options.length ) {
2419                                          return jQuery( options[ index ] ).val();
2420                                  }
2421  
2422                                  return values;
2423                          },
2424  
2425                          set: function( elem, value ) {
2426                                  var values = jQuery.makeArray( value );
2427  
2428                                  jQuery(elem).find("option").each(function() {
2429                                          this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2430                                  });
2431  
2432                                  if ( !values.length ) {
2433                                          elem.selectedIndex = -1;
2434                                  }
2435                                  return values;
2436                          }
2437                  }
2438          },
2439  
2440          attrFn: {
2441                  val: true,
2442                  css: true,
2443                  html: true,
2444                  text: true,
2445                  data: true,
2446                  width: true,
2447                  height: true,
2448                  offset: true
2449          },
2450  
2451          attr: function( elem, name, value, pass ) {
2452                  var ret, hooks, notxml,
2453                          nType = elem.nodeType;
2454  
2455                  // don't get/set attributes on text, comment and attribute nodes
2456                  if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2457                          return;
2458                  }
2459  
2460                  if ( pass && name in jQuery.attrFn ) {
2461                          return jQuery( elem )[ name ]( value );
2462                  }
2463  
2464                  // Fallback to prop when attributes are not supported
2465                  if ( typeof elem.getAttribute === "undefined" ) {
2466                          return jQuery.prop( elem, name, value );
2467                  }
2468  
2469                  notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2470  
2471                  // All attributes are lowercase
2472                  // Grab necessary hook if one is defined
2473                  if ( notxml ) {
2474                          name = name.toLowerCase();
2475                          hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2476                  }
2477  
2478                  if ( value !== undefined ) {
2479  
2480                          if ( value === null ) {
2481                                  jQuery.removeAttr( elem, name );
2482                                  return;
2483  
2484                          } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2485                                  return ret;
2486  
2487                          } else {
2488                                  elem.setAttribute( name, "" + value );
2489                                  return value;
2490                          }
2491  
2492                  } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2493                          return ret;
2494  
2495                  } else {
2496  
2497                          ret = elem.getAttribute( name );
2498  
2499                          // Non-existent attributes return null, we normalize to undefined
2500                          return ret === null ?
2501                                  undefined :
2502                                  ret;
2503                  }
2504          },
2505  
2506          removeAttr: function( elem, value ) {
2507                  var propName, attrNames, name, l,
2508                          i = 0;
2509  
2510                  if ( value && elem.nodeType === 1 ) {
2511                          attrNames = value.toLowerCase().split( rspace );
2512                          l = attrNames.length;
2513  
2514                          for ( ; i < l; i++ ) {
2515                                  name = attrNames[ i ];
2516  
2517                                  if ( name ) {
2518                                          propName = jQuery.propFix[ name ] || name;
2519  
2520                                          // See #9699 for explanation of this approach (setting first, then removal)
2521                                          jQuery.attr( elem, name, "" );
2522                                          elem.removeAttribute( getSetAttribute ? name : propName );
2523  
2524                                          // Set corresponding property to false for boolean attributes
2525                                          if ( rboolean.test( name ) && propName in elem ) {
2526                                                  elem[ propName ] = false;
2527                                          }
2528                                  }
2529                          }
2530                  }
2531          },
2532  
2533          attrHooks: {
2534                  type: {
2535                          set: function( elem, value ) {
2536                                  // We can't allow the type property to be changed (since it causes problems in IE)
2537                                  if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2538                                          jQuery.error( "type property can't be changed" );
2539                                  } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2540                                          // Setting the type on a radio button after the value resets the value in IE6-9
2541                                          // Reset value to it's default in case type is set after value
2542                                          // This is for element creation
2543                                          var val = elem.value;
2544                                          elem.setAttribute( "type", value );
2545                                          if ( val ) {
2546                                                  elem.value = val;
2547                                          }
2548                                          return value;
2549                                  }
2550                          }
2551                  },
2552                  // Use the value property for back compat
2553                  // Use the nodeHook for button elements in IE6/7 (#1954)
2554                  value: {
2555                          get: function( elem, name ) {
2556                                  if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2557                                          return nodeHook.get( elem, name );
2558                                  }
2559                                  return name in elem ?
2560                                          elem.value :
2561                                          null;
2562                          },
2563                          set: function( elem, value, name ) {
2564                                  if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2565                                          return nodeHook.set( elem, value, name );
2566                                  }
2567                                  // Does not return so that setAttribute is also used
2568                                  elem.value = value;
2569                          }
2570                  }
2571          },
2572  
2573          propFix: {
2574                  tabindex: "tabIndex",
2575                  readonly: "readOnly",
2576                  "for": "htmlFor",
2577                  "class": "className",
2578                  maxlength: "maxLength",
2579                  cellspacing: "cellSpacing",
2580                  cellpadding: "cellPadding",
2581                  rowspan: "rowSpan",
2582                  colspan: "colSpan",
2583                  usemap: "useMap",
2584                  frameborder: "frameBorder",
2585                  contenteditable: "contentEditable"
2586          },
2587  
2588          prop: function( elem, name, value ) {
2589                  var ret, hooks, notxml,
2590                          nType = elem.nodeType;
2591  
2592                  // don't get/set properties on text, comment and attribute nodes
2593                  if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2594                          return;
2595                  }
2596  
2597                  notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2598  
2599                  if ( notxml ) {
2600                          // Fix name and attach hooks
2601                          name = jQuery.propFix[ name ] || name;
2602                          hooks = jQuery.propHooks[ name ];
2603                  }
2604  
2605                  if ( value !== undefined ) {
2606                          if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2607                                  return ret;
2608  
2609                          } else {
2610                                  return ( elem[ name ] = value );
2611                          }
2612  
2613                  } else {
2614                          if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2615                                  return ret;
2616  
2617                          } else {
2618                                  return elem[ name ];
2619                          }
2620                  }
2621          },
2622  
2623          propHooks: {
2624                  tabIndex: {
2625                          get: function( elem ) {
2626                                  // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2627                                  // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2628                                  var attributeNode = elem.getAttributeNode("tabindex");
2629  
2630                                  return attributeNode && attributeNode.specified ?
2631                                          parseInt( attributeNode.value, 10 ) :
2632                                          rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2633                                                  0 :
2634                                                  undefined;
2635                          }
2636                  }
2637          }
2638  });
2639  
2640  // Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2641  jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2642  
2643  // Hook for boolean attributes
2644  boolHook = {
2645          get: function( elem, name ) {
2646                  // Align boolean attributes with corresponding properties
2647                  // Fall back to attribute presence where some booleans are not supported
2648                  var attrNode,
2649                          property = jQuery.prop( elem, name );
2650                  return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2651                          name.toLowerCase() :
2652                          undefined;
2653          },
2654          set: function( elem, value, name ) {
2655                  var propName;
2656                  if ( value === false ) {
2657                          // Remove boolean attributes when set to false
2658                          jQuery.removeAttr( elem, name );
2659                  } else {
2660                          // value is true since we know at this point it's type boolean and not false
2661                          // Set boolean attributes to the same name and set the DOM property
2662                          propName = jQuery.propFix[ name ] || name;
2663                          if ( propName in elem ) {
2664                                  // Only set the IDL specifically if it already exists on the element
2665                                  elem[ propName ] = true;
2666                          }
2667  
2668                          elem.setAttribute( name, name.toLowerCase() );
2669                  }
2670                  return name;
2671          }
2672  };
2673  
2674  // IE6/7 do not support getting/setting some attributes with get/setAttribute
2675  if ( !getSetAttribute ) {
2676  
2677          fixSpecified = {
2678                  name: true,
2679                  id: true
2680          };
2681  
2682          // Use this for any attribute in IE6/7
2683          // This fixes almost every IE6/7 issue
2684          nodeHook = jQuery.valHooks.button = {
2685                  get: function( elem, name ) {
2686                          var ret;
2687                          ret = elem.getAttributeNode( name );
2688                          return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2689                                  ret.nodeValue :
2690                                  undefined;
2691                  },
2692                  set: function( elem, value, name ) {
2693                          // Set the existing or create a new attribute node
2694                          var ret = elem.getAttributeNode( name );
2695                          if ( !ret ) {
2696                                  ret = document.createAttribute( name );
2697                                  elem.setAttributeNode( ret );
2698                          }
2699                          return ( ret.nodeValue = value + "" );
2700                  }
2701          };
2702  
2703          // Apply the nodeHook to tabindex
2704          jQuery.attrHooks.tabindex.set = nodeHook.set;
2705  
2706          // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2707          // This is for removals
2708          jQuery.each([ "width", "height" ], function( i, name ) {
2709                  jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2710                          set: function( elem, value ) {
2711                                  if ( value === "" ) {
2712                                          elem.setAttribute( name, "auto" );
2713                                          return value;
2714                                  }
2715                          }
2716                  });
2717          });
2718  
2719          // Set contenteditable to false on removals(#10429)
2720          // Setting to empty string throws an error as an invalid value
2721          jQuery.attrHooks.contenteditable = {
2722                  get: nodeHook.get,
2723                  set: function( elem, value, name ) {
2724                          if ( value === "" ) {
2725                                  value = "false";
2726                          }
2727                          nodeHook.set( elem, value, name );
2728                  }
2729          };
2730  }
2731  
2732  
2733  // Some attributes require a special call on IE
2734  if ( !jQuery.support.hrefNormalized ) {
2735          jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2736                  jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2737                          get: function( elem ) {
2738                                  var ret = elem.getAttribute( name, 2 );
2739                                  return ret === null ? undefined : ret;
2740                          }
2741                  });
2742          });
2743  }
2744  
2745  if ( !jQuery.support.style ) {
2746          jQuery.attrHooks.style = {
2747                  get: function( elem ) {
2748                          // Return undefined in the case of empty string
2749                          // Normalize to lowercase since IE uppercases css property names
2750                          return elem.style.cssText.toLowerCase() || undefined;
2751                  },
2752                  set: function( elem, value ) {
2753                          return ( elem.style.cssText = "" + value );
2754                  }
2755          };
2756  }
2757  
2758  // Safari mis-reports the default selected property of an option
2759  // Accessing the parent's selectedIndex property fixes it
2760  if ( !jQuery.support.optSelected ) {
2761          jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2762                  get: function( elem ) {
2763                          var parent = elem.parentNode;
2764  
2765                          if ( parent ) {
2766                                  parent.selectedIndex;
2767  
2768                                  // Make sure that it also works with optgroups, see #5701
2769                                  if ( parent.parentNode ) {
2770                                          parent.parentNode.selectedIndex;
2771                                  }
2772                          }
2773                          return null;
2774                  }
2775          });
2776  }
2777  
2778  // IE6/7 call enctype encoding
2779  if ( !jQuery.support.enctype ) {
2780          jQuery.propFix.enctype = "encoding";
2781  }
2782  
2783  // Radios and checkboxes getter/setter
2784  if ( !jQuery.support.checkOn ) {
2785          jQuery.each([ "radio", "checkbox" ], function() {
2786                  jQuery.valHooks[ this ] = {
2787                          get: function( elem ) {
2788                                  // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2789                                  return elem.getAttribute("value") === null ? "on" : elem.value;
2790                          }
2791                  };
2792          });
2793  }
2794  jQuery.each([ "radio", "checkbox" ], function() {
2795          jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2796                  set: function( elem, value ) {
2797                          if ( jQuery.isArray( value ) ) {
2798                                  return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2799                          }
2800                  }
2801          });
2802  });
2803  
2804  
2805  
2806  
2807  var rformElems = /^(?:textarea|input|select)$/i,
2808          rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
2809          rhoverHack = /\bhover(\.\S+)?\b/,
2810          rkeyEvent = /^key/,
2811          rmouseEvent = /^(?:mouse|contextmenu)|click/,
2812          rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2813          rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
2814          quickParse = function( selector ) {
2815                  var quick = rquickIs.exec( selector );
2816                  if ( quick ) {
2817                          //   0  1    2   3
2818                          // [ _, tag, id, class ]
2819                          quick[1] = ( quick[1] || "" ).toLowerCase();
2820                          quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
2821                  }
2822                  return quick;
2823          },
2824          quickIs = function( elem, m ) {
2825                  var attrs = elem.attributes || {};
2826                  return (
2827                          (!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
2828                          (!m[2] || (attrs.id || {}).value === m[2]) &&
2829                          (!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
2830                  );
2831          },
2832          hoverHack = function( events ) {
2833                  return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2834          };
2835  
2836  /*
2837   * Helper functions for managing events -- not part of the public interface.
2838   * Props to Dean Edwards' addEvent library for many of the ideas.
2839   */
2840  jQuery.event = {
2841  
2842          add: function( elem, types, handler, data, selector ) {
2843  
2844                  var elemData, eventHandle, events,
2845                          t, tns, type, namespaces, handleObj,
2846                          handleObjIn, quick, handlers, special;
2847  
2848                  // Don't attach events to noData or text/comment nodes (allow plain objects tho)
2849                  if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2850                          return;
2851                  }
2852  
2853                  // Caller can pass in an object of custom data in lieu of the handler
2854                  if ( handler.handler ) {
2855                          handleObjIn = handler;
2856                          handler = handleObjIn.handler;
2857                  }
2858  
2859                  // Make sure that the handler has a unique ID, used to find/remove it later
2860                  if ( !handler.guid ) {
2861                          handler.guid = jQuery.guid++;
2862                  }
2863  
2864                  // Init the element's event structure and main handler, if this is the first
2865                  events = elemData.events;
2866                  if ( !events ) {
2867                          elemData.events = events = {};
2868                  }
2869                  eventHandle = elemData.handle;
2870                  if ( !eventHandle ) {
2871                          elemData.handle = eventHandle = function( e ) {
2872                                  // Discard the second event of a jQuery.event.trigger() and
2873                                  // when an event is called after a page has unloaded
2874                                  return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2875                                          jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2876                                          undefined;
2877                          };
2878                          // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2879                          eventHandle.elem = elem;
2880                  }
2881  
2882                  // Handle multiple events separated by a space
2883                  // jQuery(...).bind("mouseover mouseout", fn);
2884                  types = jQuery.trim( hoverHack(types) ).split( " " );
2885                  for ( t = 0; t < types.length; t++ ) {
2886  
2887                          tns = rtypenamespace.exec( types[t] ) || [];
2888                          type = tns[1];
2889                          namespaces = ( tns[2] || "" ).split( "." ).sort();
2890  
2891                          // If event changes its type, use the special event handlers for the changed type
2892                          special = jQuery.event.special[ type ] || {};
2893  
2894                          // If selector defined, determine special event api type, otherwise given type
2895                          type = ( selector ? special.delegateType : special.bindType ) || type;
2896  
2897                          // Update special based on newly reset type
2898                          special = jQuery.event.special[ type ] || {};
2899  
2900                          // handleObj is passed to all event handlers
2901                          handleObj = jQuery.extend({
2902                                  type: type,
2903                                  origType: tns[1],
2904                                  data: data,
2905                                  handler: handler,
2906                                  guid: handler.guid,
2907                                  selector: selector,
2908                                  quick: quickParse( selector ),
2909                                  namespace: namespaces.join(".")
2910                          }, handleObjIn );
2911  
2912                          // Init the event handler queue if we're the first
2913                          handlers = events[ type ];
2914                          if ( !handlers ) {
2915                                  handlers = events[ type ] = [];
2916                                  handlers.delegateCount = 0;
2917  
2918                                  // Only use addEventListener/attachEvent if the special events handler returns false
2919                                  if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2920                                          // Bind the global event handler to the element
2921                                          if ( elem.addEventListener ) {
2922                                                  elem.addEventListener( type, eventHandle, false );
2923  
2924                                          } else if ( elem.attachEvent ) {
2925                                                  elem.attachEvent( "on" + type, eventHandle );
2926                                          }
2927                                  }
2928                          }
2929  
2930                          if ( special.add ) {
2931                                  special.add.call( elem, handleObj );
2932  
2933                                  if ( !handleObj.handler.guid ) {
2934                                          handleObj.handler.guid = handler.guid;
2935                                  }
2936                          }
2937  
2938                          // Add to the element's handler list, delegates in front
2939                          if ( selector ) {
2940                                  handlers.splice( handlers.delegateCount++, 0, handleObj );
2941                          } else {
2942                                  handlers.push( handleObj );
2943                          }
2944  
2945                          // Keep track of which events have ever been used, for event optimization
2946                          jQuery.event.global[ type ] = true;
2947                  }
2948  
2949                  // Nullify elem to prevent memory leaks in IE
2950                  elem = null;
2951          },
2952  
2953          global: {},
2954  
2955          // Detach an event or set of events from an element
2956          remove: function( elem, types, handler, selector, mappedTypes ) {
2957  
2958                  var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2959                          t, tns, type, origType, namespaces, origCount,
2960                          j, events, special, handle, eventType, handleObj;
2961  
2962                  if ( !elemData || !(events = elemData.events) ) {
2963                          return;
2964                  }
2965  
2966                  // Once for each type.namespace in types; type may be omitted
2967                  types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
2968                  for ( t = 0; t < types.length; t++ ) {
2969                          tns = rtypenamespace.exec( types[t] ) || [];
2970                          type = origType = tns[1];
2971                          namespaces = tns[2];
2972  
2973                          // Unbind all events (on this namespace, if provided) for the element
2974                          if ( !type ) {
2975                                  for ( type in events ) {
2976                                          jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2977                                  }
2978                                  continue;
2979                          }
2980  
2981                          special = jQuery.event.special[ type ] || {};
2982                          type = ( selector? special.delegateType : special.bindType ) || type;
2983                          eventType = events[ type ] || [];
2984                          origCount = eventType.length;
2985                          namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
2986  
2987                          // Remove matching events
2988                          for ( j = 0; j < eventType.length; j++ ) {
2989                                  handleObj = eventType[ j ];
2990  
2991                                  if ( ( mappedTypes || origType === handleObj.origType ) &&
2992                                           ( !handler || handler.guid === handleObj.guid ) &&
2993                                           ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
2994                                           ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2995                                          eventType.splice( j--, 1 );
2996  
2997                                          if ( handleObj.selector ) {
2998                                                  eventType.delegateCount--;
2999                                          }
3000                                          if ( special.remove ) {
3001                                                  special.remove.call( elem, handleObj );
3002                                          }
3003                                  }
3004                          }
3005  
3006                          // Remove generic event handler if we removed something and no more handlers exist
3007                          // (avoids potential for endless recursion during removal of special event handlers)
3008                          if ( eventType.length === 0 && origCount !== eventType.length ) {
3009                                  if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
3010                                          jQuery.removeEvent( elem, type, elemData.handle );
3011                                  }
3012  
3013                                  delete events[ type ];
3014                          }
3015                  }
3016  
3017                  // Remove the expando if it's no longer used
3018                  if ( jQuery.isEmptyObject( events ) ) {
3019                          handle = elemData.handle;
3020                          if ( handle ) {
3021                                  handle.elem = null;
3022                          }
3023  
3024                          // removeData also checks for emptiness and clears the expando if empty
3025                          // so use it instead of delete
3026                          jQuery.removeData( elem, [ "events", "handle" ], true );
3027                  }
3028          },
3029  
3030          // Events that are safe to short-circuit if no handlers are attached.
3031          // Native DOM events should not be added, they may have inline handlers.
3032          customEvent: {
3033                  "getData": true,
3034                  "setData": true,
3035                  "changeData": true
3036          },
3037  
3038          trigger: function( event, data, elem, onlyHandlers ) {
3039                  // Don't do events on text and comment nodes
3040                  if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
3041                          return;
3042                  }
3043  
3044                  // Event object or event type
3045                  var type = event.type || event,
3046                          namespaces = [],
3047                          cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
3048  
3049                  // focus/blur morphs to focusin/out; ensure we're not firing them right now
3050                  if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
3051                          return;
3052                  }
3053  
3054                  if ( type.indexOf( "!" ) >= 0 ) {
3055                          // Exclusive events trigger only for the exact event (no namespaces)
3056                          type = type.slice(0, -1);
3057                          exclusive = true;
3058                  }
3059  
3060                  if ( type.indexOf( "." ) >= 0 ) {
3061                          // Namespaced trigger; create a regexp to match event type in handle()
3062                          namespaces = type.split(".");
3063                          type = namespaces.shift();
3064                          namespaces.sort();
3065                  }
3066  
3067                  if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
3068                          // No jQuery handlers for this event type, and it can't have inline handlers
3069                          return;
3070                  }
3071  
3072                  // Caller can pass in an Event, Object, or just an event type string
3073                  event = typeof event === "object" ?
3074                          // jQuery.Event object
3075                          event[ jQuery.expando ] ? event :
3076                          // Object literal
3077                          new jQuery.Event( type, event ) :
3078                          // Just the event type (string)
3079                          new jQuery.Event( type );
3080  
3081                  event.type = type;
3082                  event.isTrigger = true;
3083                  event.exclusive = exclusive;
3084                  event.namespace = namespaces.join( "." );
3085                  event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3086                  ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
3087  
3088                  // Handle a global trigger
3089                  if ( !elem ) {
3090  
3091                          // TODO: Stop taunting the data cache; remove global events and always attach to document
3092                          cache = jQuery.cache;
3093                          for ( i in cache ) {
3094                                  if ( cache[ i ].events && cache[ i ].events[ type ] ) {
3095                                          jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
3096                                  }
3097                          }
3098                          return;
3099                  }
3100  
3101                  // Clean up the event in case it is being reused
3102                  event.result = undefined;
3103                  if ( !event.target ) {
3104                          event.target = elem;
3105                  }
3106  
3107                  // Clone any incoming data and prepend the event, creating the handler arg list
3108                  data = data != null ? jQuery.makeArray( data ) : [];
3109                  data.unshift( event );
3110  
3111                  // Allow special events to draw outside the lines
3112                  special = jQuery.event.special[ type ] || {};
3113                  if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
3114                          return;
3115                  }
3116  
3117                  // Determine event propagation path in advance, per W3C events spec (#9951)
3118                  // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
3119                  eventPath = [[ elem, special.bindType || type ]];
3120                  if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
3121  
3122                          bubbleType = special.delegateType || type;
3123                          cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
3124                          old = null;
3125                          for ( ; cur; cur = cur.parentNode ) {
3126                                  eventPath.push([ cur, bubbleType ]);
3127                                  old = cur;
3128                          }
3129  
3130                          // Only add window if we got to document (e.g., not plain obj or detached DOM)
3131                          if ( old && old === elem.ownerDocument ) {
3132                                  eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
3133                          }
3134                  }
3135  
3136                  // Fire handlers on the event path
3137                  for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
3138  
3139                          cur = eventPath[i][0];
3140                          event.type = eventPath[i][1];
3141  
3142                          handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
3143                          if ( handle ) {
3144                                  handle.apply( cur, data );
3145                          }
3146                          // Note that this is a bare JS function and not a jQuery handler
3147                          handle = ontype && cur[ ontype ];
3148                          if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
3149                                  event.preventDefault();
3150                          }
3151                  }
3152                  event.type = type;
3153  
3154                  // If nobody prevented the default action, do it now
3155                  if ( !onlyHandlers && !event.isDefaultPrevented() ) {
3156  
3157                          if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
3158                                  !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
3159  
3160                                  // Call a native DOM method on the target with the same name name as the event.
3161                                  // Can't use an .isFunction() check here because IE6/7 fails that test.
3162                                  // Don't do default actions on window, that's where global variables be (#6170)
3163                                  // IE<9 dies on focus/blur to hidden element (#1486)
3164                                  if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
3165  
3166                                          // Don't re-trigger an onFOO event when we call its FOO() method
3167                                          old = elem[ ontype ];
3168  
3169                                          if ( old ) {
3170                                                  elem[ ontype ] = null;
3171                                          }
3172  
3173                                          // Prevent re-triggering of the same event, since we already bubbled it above
3174                                          jQuery.event.triggered = type;
3175                                          elem[ type ]();
3176                                          jQuery.event.triggered = undefined;
3177  
3178                                          if ( old ) {
3179                                                  elem[ ontype ] = old;
3180                                          }
3181                                  }
3182                          }
3183                  }
3184  
3185                  return event.result;
3186          },
3187  
3188          dispatch: function( event ) {
3189  
3190                  // Make a writable jQuery.Event from the native event object
3191                  event = jQuery.event.fix( event || window.event );
3192  
3193                  var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
3194                          delegateCount = handlers.delegateCount,
3195                          args = [].slice.call( arguments, 0 ),
3196                          run_all = !event.exclusive && !event.namespace,
3197                          handlerQueue = [],
3198                          i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
3199  
3200                  // Use the fix-ed jQuery.Event rather than the (read-only) native event
3201                  args[0] = event;
3202                  event.delegateTarget = this;
3203  
3204                  // Determine handlers that should run if there are delegated events
3205                  // Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861)
3206                  if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) {
3207  
3208                          // Pregenerate a single jQuery object for reuse with .is()
3209                          jqcur = jQuery(this);
3210                          jqcur.context = this.ownerDocument || this;
3211  
3212                          for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3213                                  selMatch = {};
3214                                  matches = [];
3215                                  jqcur[0] = cur;
3216                                  for ( i = 0; i < delegateCount; i++ ) {
3217                                          handleObj = handlers[ i ];
3218                                          sel = handleObj.selector;
3219  
3220                                          if ( selMatch[ sel ] === undefined ) {
3221                                                  selMatch[ sel ] = (
3222                                                          handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
3223                                                  );
3224                                          }
3225                                          if ( selMatch[ sel ] ) {
3226                                                  matches.push( handleObj );
3227                                          }
3228                                  }
3229                                  if ( matches.length ) {
3230                                          handlerQueue.push({ elem: cur, matches: matches });
3231                                  }
3232                          }
3233                  }
3234  
3235                  // Add the remaining (directly-bound) handlers
3236                  if ( handlers.length > delegateCount ) {
3237                          handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3238                  }
3239  
3240                  // Run delegates first; they may want to stop propagation beneath us
3241                  for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3242                          matched = handlerQueue[ i ];
3243                          event.currentTarget = matched.elem;
3244  
3245                          for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3246                                  handleObj = matched.matches[ j ];
3247  
3248                                  // Triggered event must either 1) be non-exclusive and have no namespace, or
3249                                  // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3250                                  if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3251  
3252                                          event.data = handleObj.data;
3253                                          event.handleObj = handleObj;
3254  
3255                                          ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3256                                                          .apply( matched.elem, args );
3257  
3258                                          if ( ret !== undefined ) {
3259                                                  event.result = ret;
3260                                                  if ( ret === false ) {
3261                                                          event.preventDefault();
3262                                                          event.stopPropagation();
3263                                                  }
3264                                          }
3265                                  }
3266                          }
3267                  }
3268  
3269                  return event.result;
3270          },
3271  
3272          // Includes some event props shared by KeyEvent and MouseEvent
3273          // *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3274          props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3275  
3276          fixHooks: {},
3277  
3278          keyHooks: {
3279                  props: "char charCode key keyCode".split(" "),
3280                  filter: function( event, original ) {
3281  
3282                          // Add which for key events
3283                          if ( event.which == null ) {
3284                                  event.which = original.charCode != null ? original.charCode : original.keyCode;
3285                          }
3286  
3287                          return event;
3288                  }
3289          },
3290  
3291          mouseHooks: {
3292                  props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3293                  filter: function( event, original ) {
3294                          var eventDoc, doc, body,
3295                                  button = original.button,
3296                                  fromElement = original.fromElement;
3297  
3298                          // Calculate pageX/Y if missing and clientX/Y available
3299                          if ( event.pageX == null && original.clientX != null ) {
3300                                  eventDoc = event.target.ownerDocument || document;
3301                                  doc = eventDoc.documentElement;
3302                                  body = eventDoc.body;
3303  
3304                                  event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3305                                  event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3306                          }
3307  
3308                          // Add relatedTarget, if necessary
3309                          if ( !event.relatedTarget && fromElement ) {
3310                                  event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3311                          }
3312  
3313                          // Add which for click: 1 === left; 2 === middle; 3 === right
3314                          // Note: button is not normalized, so don't use it
3315                          if ( !event.which && button !== undefined ) {
3316                                  event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3317                          }
3318  
3319                          return event;
3320                  }
3321          },
3322  
3323          fix: function( event ) {
3324                  if ( event[ jQuery.expando ] ) {
3325                          return event;
3326                  }
3327  
3328                  // Create a writable copy of the event object and normalize some properties
3329                  var i, prop,
3330                          originalEvent = event,
3331                          fixHook = jQuery.event.fixHooks[ event.type ] || {},
3332                          copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3333  
3334                  event = jQuery.Event( originalEvent );
3335  
3336                  for ( i = copy.length; i; ) {
3337                          prop = copy[ --i ];
3338                          event[ prop ] = originalEvent[ prop ];
3339                  }
3340  
3341                  // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3342                  if ( !event.target ) {
3343                          event.target = originalEvent.srcElement || document;
3344                  }
3345  
3346                  // Target should not be a text node (#504, Safari)
3347                  if ( event.target.nodeType === 3 ) {
3348                          event.target = event.target.parentNode;
3349                  }
3350  
3351                  // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
3352                  if ( event.metaKey === undefined ) {
3353                          event.metaKey = event.ctrlKey;
3354                  }
3355  
3356                  return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3357          },
3358  
3359          special: {
3360                  ready: {
3361                          // Make sure the ready event is setup
3362                          setup: jQuery.bindReady
3363                  },
3364  
3365                  load: {
3366                          // Prevent triggered image.load events from bubbling to window.load
3367                          noBubble: true
3368                  },
3369  
3370                  focus: {
3371                          delegateType: "focusin"
3372                  },
3373                  blur: {
3374                          delegateType: "focusout"
3375                  },
3376  
3377                  beforeunload: {
3378                          setup: function( data, namespaces, eventHandle ) {
3379                                  // We only want to do this special case on windows
3380                                  if ( jQuery.isWindow( this ) ) {
3381                                          this.onbeforeunload = eventHandle;
3382                                  }
3383                          },
3384  
3385                          teardown: function( namespaces, eventHandle ) {
3386                                  if ( this.onbeforeunload === eventHandle ) {
3387                                          this.onbeforeunload = null;
3388                                  }
3389                          }
3390                  }
3391          },
3392  
3393          simulate: function( type, elem, event, bubble ) {
3394                  // Piggyback on a donor event to simulate a different one.
3395                  // Fake originalEvent to avoid donor's stopPropagation, but if the
3396                  // simulated event prevents default then we do the same on the donor.
3397                  var e = jQuery.extend(
3398                          new jQuery.Event(),
3399                          event,
3400                          { type: type,
3401                                  isSimulated: true,
3402                                  originalEvent: {}
3403                          }
3404                  );
3405                  if ( bubble ) {
3406                          jQuery.event.trigger( e, null, elem );
3407                  } else {
3408                          jQuery.event.dispatch.call( elem, e );
3409                  }
3410                  if ( e.isDefaultPrevented() ) {
3411                          event.preventDefault();
3412                  }
3413          }
3414  };
3415  
3416  // Some plugins are using, but it's undocumented/deprecated and will be removed.
3417  // The 1.7 special event interface should provide all the hooks needed now.
3418  jQuery.event.handle = jQuery.event.dispatch;
3419  
3420  jQuery.removeEvent = document.removeEventListener ?
3421          function( elem, type, handle ) {
3422                  if ( elem.removeEventListener ) {
3423                          elem.removeEventListener( type, handle, false );
3424                  }
3425          } :
3426          function( elem, type, handle ) {
3427                  if ( elem.detachEvent ) {
3428                          elem.detachEvent( "on" + type, handle );
3429                  }
3430          };
3431  
3432  jQuery.Event = function( src, props ) {
3433          // Allow instantiation without the 'new' keyword
3434          if ( !(this instanceof jQuery.Event) ) {
3435                  return new jQuery.Event( src, props );
3436          }
3437  
3438          // Event object
3439          if ( src && src.type ) {
3440                  this.originalEvent = src;
3441                  this.type = src.type;
3442  
3443                  // Events bubbling up the document may have been marked as prevented
3444                  // by a handler lower down the tree; reflect the correct value.
3445                  this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3446                          src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3447  
3448          // Event type
3449          } else {
3450                  this.type = src;
3451          }
3452  
3453          // Put explicitly provided properties onto the event object
3454          if ( props ) {
3455                  jQuery.extend( this, props );
3456          }
3457  
3458          // Create a timestamp if incoming event doesn't have one
3459          this.timeStamp = src && src.timeStamp || jQuery.now();
3460  
3461          // Mark it as fixed
3462          this[ jQuery.expando ] = true;
3463  };
3464  
3465  function returnFalse() {
3466          return false;
3467  }
3468  function returnTrue() {
3469          return true;
3470  }
3471  
3472  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3473  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3474  jQuery.Event.prototype = {
3475          preventDefault: function() {
3476                  this.isDefaultPrevented = returnTrue;
3477  
3478                  var e = this.originalEvent;
3479                  if ( !e ) {
3480                          return;
3481                  }
3482  
3483                  // if preventDefault exists run it on the original event
3484                  if ( e.preventDefault ) {
3485                          e.preventDefault();
3486  
3487                  // otherwise set the returnValue property of the original event to false (IE)
3488                  } else {
3489                          e.returnValue = false;
3490                  }
3491          },
3492          stopPropagation: function() {
3493                  this.isPropagationStopped = returnTrue;
3494  
3495                  var e = this.originalEvent;
3496                  if ( !e ) {
3497                          return;
3498                  }
3499                  // if stopPropagation exists run it on the original event
3500                  if ( e.stopPropagation ) {
3501                          e.stopPropagation();
3502                  }
3503                  // otherwise set the cancelBubble property of the original event to true (IE)
3504                  e.cancelBubble = true;
3505          },
3506          stopImmediatePropagation: function() {
3507                  this.isImmediatePropagationStopped = returnTrue;
3508                  this.stopPropagation();
3509          },
3510          isDefaultPrevented: returnFalse,
3511          isPropagationStopped: returnFalse,
3512          isImmediatePropagationStopped: returnFalse
3513  };
3514  
3515  // Create mouseenter/leave events using mouseover/out and event-time checks
3516  jQuery.each({
3517          mouseenter: "mouseover",
3518          mouseleave: "mouseout"
3519  }, function( orig, fix ) {
3520          jQuery.event.special[ orig ] = {
3521                  delegateType: fix,
3522                  bindType: fix,
3523  
3524                  handle: function( event ) {
3525                          var target = this,
3526                                  related = event.relatedTarget,
3527                                  handleObj = event.handleObj,
3528                                  selector = handleObj.selector,
3529                                  ret;
3530  
3531                          // For mousenter/leave call the handler if related is outside the target.
3532                          // NB: No relatedTarget if the mouse left/entered the browser window
3533                          if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3534                                  event.type = handleObj.origType;
3535                                  ret = handleObj.handler.apply( this, arguments );
3536                                  event.type = fix;
3537                          }
3538                          return ret;
3539                  }
3540          };
3541  });
3542  
3543  // IE submit delegation
3544  if ( !jQuery.support.submitBubbles ) {
3545  
3546          jQuery.event.special.submit = {
3547                  setup: function() {
3548                          // Only need this for delegated form submit events
3549                          if ( jQuery.nodeName( this, "form" ) ) {
3550                                  return false;
3551                          }
3552  
3553                          // Lazy-add a submit handler when a descendant form may potentially be submitted
3554                          jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
3555                                  // Node name check avoids a VML-related crash in IE (#9807)
3556                                  var elem = e.target,
3557                                          form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3558                                  if ( form && !form._submit_attached ) {
3559                                          jQuery.event.add( form, "submit._submit", function( event ) {
3560                                                  // If form was submitted by the user, bubble the event up the tree
3561                                                  if ( this.parentNode && !event.isTrigger ) {
3562                                                          jQuery.event.simulate( "submit", this.parentNode, event, true );
3563                                                  }
3564                                          });
3565                                          form._submit_attached = true;
3566                                  }
3567                          });
3568                          // return undefined since we don't need an event listener
3569                  },
3570  
3571                  teardown: function() {
3572                          // Only need this for delegated form submit events
3573                          if ( jQuery.nodeName( this, "form" ) ) {
3574                                  return false;
3575                          }
3576  
3577                          // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3578                          jQuery.event.remove( this, "._submit" );
3579                  }
3580          };
3581  }
3582  
3583  // IE change delegation and checkbox/radio fix
3584  if ( !jQuery.support.changeBubbles ) {
3585  
3586          jQuery.event.special.change = {
3587  
3588                  setup: function() {
3589  
3590                          if ( rformElems.test( this.nodeName ) ) {
3591                                  // IE doesn't fire change on a check/radio until blur; trigger it on click
3592                                  // after a propertychange. Eat the blur-change in special.change.handle.
3593                                  // This still fires onchange a second time for check/radio after blur.
3594                                  if ( this.type === "checkbox" || this.type === "radio" ) {
3595                                          jQuery.event.add( this, "propertychange._change", function( event ) {
3596                                                  if ( event.originalEvent.propertyName === "checked" ) {
3597                                                          this._just_changed = true;
3598                                                  }
3599                                          });
3600                                          jQuery.event.add( this, "click._change", function( event ) {
3601                                                  if ( this._just_changed && !event.isTrigger ) {
3602                                                          this._just_changed = false;
3603                                                          jQuery.event.simulate( "change", this, event, true );
3604                                                  }
3605                                          });
3606                                  }
3607                                  return false;
3608                          }
3609                          // Delegated event; lazy-add a change handler on descendant inputs
3610                          jQuery.event.add( this, "beforeactivate._change", function( e ) {
3611                                  var elem = e.target;
3612  
3613                                  if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
3614                                          jQuery.event.add( elem, "change._change", function( event ) {
3615                                                  if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
3616                                                          jQuery.event.simulate( "change", this.parentNode, event, true );
3617                                                  }
3618                                          });
3619                                          elem._change_attached = true;
3620                                  }
3621                          });
3622                  },
3623  
3624                  handle: function( event ) {
3625                          var elem = event.target;
3626  
3627                          // Swallow native change events from checkbox/radio, we already triggered them above
3628                          if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3629                                  return event.handleObj.handler.apply( this, arguments );
3630                          }
3631                  },
3632  
3633                  teardown: function() {
3634                          jQuery.event.remove( this, "._change" );
3635  
3636                          return rformElems.test( this.nodeName );
3637                  }
3638          };
3639  }
3640  
3641  // Create "bubbling" focus and blur events
3642  if ( !jQuery.support.focusinBubbles ) {
3643          jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3644  
3645                  // Attach a single capturing handler while someone wants focusin/focusout
3646                  var attaches = 0,
3647                          handler = function( event ) {
3648                                  jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
3649                          };
3650  
3651                  jQuery.event.special[ fix ] = {
3652                          setup: function() {
3653                                  if ( attaches++ === 0 ) {
3654                                          document.addEventListener( orig, handler, true );
3655                                  }
3656                          },
3657                          teardown: function() {
3658                                  if ( --attaches === 0 ) {
3659                                          document.removeEventListener( orig, handler, true );
3660                                  }
3661                          }
3662                  };
3663          });
3664  }
3665  
3666  jQuery.fn.extend({
3667  
3668          on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
3669                  var origFn, type;
3670  
3671                  // Types can be a map of types/handlers
3672                  if ( typeof types === "object" ) {
3673                          // ( types-Object, selector, data )
3674                          if ( typeof selector !== "string" ) {
3675                                  // ( types-Object, data )
3676                                  data = selector;
3677                                  selector = undefined;
3678                          }
3679                          for ( type in types ) {
3680                                  this.on( type, selector, data, types[ type ], one );
3681                          }
3682                          return this;
3683                  }
3684  
3685                  if ( data == null && fn == null ) {
3686                          // ( types, fn )
3687                          fn = selector;
3688                          data = selector = undefined;
3689                  } else if ( fn == null ) {
3690                          if ( typeof selector === "string" ) {
3691                                  // ( types, selector, fn )
3692                                  fn = data;
3693                                  data = undefined;
3694                          } else {
3695                                  // ( types, data, fn )
3696                                  fn = data;
3697                                  data = selector;
3698                                  selector = undefined;
3699                          }
3700                  }
3701                  if ( fn === false ) {
3702                          fn = returnFalse;
3703                  } else if ( !fn ) {
3704                          return this;
3705                  }
3706  
3707                  if ( one === 1 ) {
3708                          origFn = fn;
3709                          fn = function( event ) {
3710                                  // Can use an empty set, since event contains the info
3711                                  jQuery().off( event );
3712                                  return origFn.apply( this, arguments );
3713                          };
3714                          // Use same guid so caller can remove using origFn
3715                          fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
3716                  }
3717                  return this.each( function() {
3718                          jQuery.event.add( this, types, fn, data, selector );
3719                  });
3720          },
3721          one: function( types, selector, data, fn ) {
3722                  return this.on.call( this, types, selector, data, fn, 1 );
3723          },
3724          off: function( types, selector, fn ) {
3725                  if ( types && types.preventDefault && types.handleObj ) {
3726                          // ( event )  dispatched jQuery.Event
3727                          var handleObj = types.handleObj;
3728                          jQuery( types.delegateTarget ).off(
3729                                  handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type,
3730                                  handleObj.selector,
3731                                  handleObj.handler
3732                          );
3733                          return this;
3734                  }
3735                  if ( typeof types === "object" ) {
3736                          // ( types-object [, selector] )
3737                          for ( var type in types ) {
3738                                  this.off( type, selector, types[ type ] );
3739                          }
3740                          return this;
3741                  }
3742                  if ( selector === false || typeof selector === "function" ) {
3743                          // ( types [, fn] )
3744                          fn = selector;
3745                          selector = undefined;
3746                  }
3747                  if ( fn === false ) {
3748                          fn = returnFalse;
3749                  }
3750                  return this.each(function() {
3751                          jQuery.event.remove( this, types, fn, selector );
3752                  });
3753          },
3754  
3755          bind: function( types, data, fn ) {
3756                  return this.on( types, null, data, fn );
3757          },
3758          unbind: function( types, fn ) {
3759                  return this.off( types, null, fn );
3760          },
3761  
3762          live: function( types, data, fn ) {
3763                  jQuery( this.context ).on( types, this.selector, data, fn );
3764                  return this;
3765          },
3766          die: function( types, fn ) {
3767                  jQuery( this.context ).off( types, this.selector || "**", fn );
3768                  return this;
3769          },
3770  
3771          delegate: function( selector, types, data, fn ) {
3772                  return this.on( types, selector, data, fn );
3773          },
3774          undelegate: function( selector, types, fn ) {
3775                  // ( namespace ) or ( selector, types [, fn] )
3776                  return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
3777          },
3778  
3779          trigger: function( type, data ) {
3780                  return this.each(function() {
3781                          jQuery.event.trigger( type, data, this );
3782                  });
3783          },
3784          triggerHandler: function( type, data ) {
3785                  if ( this[0] ) {
3786                          return jQuery.event.trigger( type, data, this[0], true );
3787                  }
3788          },
3789  
3790          toggle: function( fn ) {
3791                  // Save reference to arguments for access in closure
3792                  var args = arguments,
3793                          guid = fn.guid || jQuery.guid++,
3794                          i = 0,
3795                          toggler = function( event ) {
3796                                  // Figure out which function to execute
3797                                  var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3798                                  jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3799  
3800                                  // Make sure that clicks stop
3801                                  event.preventDefault();
3802  
3803                                  // and execute the function
3804                                  return args[ lastToggle ].apply( this, arguments ) || false;
3805                          };
3806  
3807                  // link all the functions, so any of them can unbind this click handler
3808                  toggler.guid = guid;
3809                  while ( i < args.length ) {
3810                          args[ i++ ].guid = guid;
3811                  }
3812  
3813                  return this.click( toggler );
3814          },
3815  
3816          hover: function( fnOver, fnOut ) {
3817                  return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3818          }
3819  });
3820  
3821  jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3822          "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3823          "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3824  
3825          // Handle event binding
3826          jQuery.fn[ name ] = function( data, fn ) {
3827                  if ( fn == null ) {
3828                          fn = data;
3829                          data = null;
3830                  }
3831  
3832                  return arguments.length > 0 ?
3833                          this.on( name, null, data, fn ) :
3834                          this.trigger( name );
3835          };
3836  
3837          if ( jQuery.attrFn ) {
3838                  jQuery.attrFn[ name ] = true;
3839          }
3840  
3841          if ( rkeyEvent.test( name ) ) {
3842                  jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
3843          }
3844  
3845          if ( rmouseEvent.test( name ) ) {
3846                  jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
3847          }
3848  });
3849  
3850  
3851  
3852  /*!
3853   * Sizzle CSS Selector Engine
3854   *  Copyright 2011, The Dojo Foundation
3855   *  Released under the MIT, BSD, and GPL Licenses.
3856   *  More information: http://sizzlejs.com/
3857   */
3858  (function(){
3859  
3860  var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3861          expando = "sizcache" + (Math.random() + '').replace('.', ''),
3862          done = 0,
3863          toString = Object.prototype.toString,
3864          hasDuplicate = false,
3865          baseHasDuplicate = true,
3866          rBackslash = /\\/g,
3867          rReturn = /\r\n/g,
3868          rNonWord = /\W/;
3869  
3870  // Here we check if the JavaScript engine is using some sort of
3871  // optimization where it does not always call our comparision
3872  // function. If that is the case, discard the hasDuplicate value.
3873  //   Thus far that includes Google Chrome.
3874  [0, 0].sort(function() {
3875          baseHasDuplicate = false;
3876          return 0;
3877  });
3878  
3879  var Sizzle = function( selector, context, results, seed ) {
3880          results = results || [];
3881          context = context || document;
3882  
3883          var origContext = context;
3884  
3885          if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3886                  return [];
3887          }
3888         
3889          if ( !selector || typeof selector !== "string" ) {
3890                  return results;
3891          }
3892  
3893          var m, set, checkSet, extra, ret, cur, pop, i,
3894                  prune = true,
3895                  contextXML = Sizzle.isXML( context ),
3896                  parts = [],
3897                  soFar = selector;
3898         
3899          // Reset the position of the chunker regexp (start from head)
3900          do {
3901                  chunker.exec( "" );
3902                  m = chunker.exec( soFar );
3903  
3904                  if ( m ) {
3905                          soFar = m[3];
3906                 
3907                          parts.push( m[1] );
3908                 
3909                          if ( m[2] ) {
3910                                  extra = m[3];
3911                                  break;
3912                          }
3913                  }
3914          } while ( m );
3915  
3916          if ( parts.length > 1 && origPOS.exec( selector ) ) {
3917  
3918                  if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3919                          set = posProcess( parts[0] + parts[1], context, seed );
3920  
3921                  } else {
3922                          set = Expr.relative[ parts[0] ] ?
3923                                  [ context ] :
3924                                  Sizzle( parts.shift(), context );
3925  
3926                          while ( parts.length ) {
3927                                  selector = parts.shift();
3928  
3929                                  if ( Expr.relative[ selector ] ) {
3930                                          selector += parts.shift();
3931                                  }
3932                                 
3933                                  set = posProcess( selector, set, seed );
3934                          }
3935                  }
3936  
3937          } else {
3938                  // Take a shortcut and set the context if the root selector is an ID
3939                  // (but not if it'll be faster if the inner selector is an ID)
3940                  if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3941                                  Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3942  
3943                          ret = Sizzle.find( parts.shift(), context, contextXML );
3944                          context = ret.expr ?
3945                                  Sizzle.filter( ret.expr, ret.set )[0] :
3946                                  ret.set[0];
3947                  }
3948  
3949                  if ( context ) {
3950                          ret = seed ?
3951                                  { expr: parts.pop(), set: makeArray(seed) } :
3952                                  Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3953  
3954                          set = ret.expr ?
3955                                  Sizzle.filter( ret.expr, ret.set ) :
3956                                  ret.set;
3957  
3958                          if ( parts.length > 0 ) {
3959                                  checkSet = makeArray( set );
3960  
3961                          } else {
3962                                  prune = false;
3963                          }
3964  
3965                          while ( parts.length ) {
3966                                  cur = parts.pop();
3967                                  pop = cur;
3968  
3969                                  if ( !Expr.relative[ cur ] ) {
3970                                          cur = "";
3971                                  } else {
3972                                          pop = parts.pop();
3973                                  }
3974  
3975                                  if ( pop == null ) {
3976                                          pop = context;
3977                                  }
3978  
3979                                  Expr.relative[ cur ]( checkSet, pop, contextXML );
3980                          }
3981  
3982                  } else {
3983                          checkSet = parts = [];
3984                  }
3985          }
3986  
3987          if ( !checkSet ) {
3988                  checkSet = set;
3989          }
3990  
3991          if ( !checkSet ) {
3992                  Sizzle.error( cur || selector );
3993          }
3994  
3995          if ( toString.call(checkSet) === "[object Array]" ) {
3996                  if ( !prune ) {
3997                          results.push.apply( results, checkSet );
3998  
3999                  } else if ( context && context.nodeType === 1 ) {
4000                          for ( i = 0; checkSet[i] != null; i++ ) {
4001                                  if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
4002                                          results.push( set[i] );
4003                                  }
4004                          }
4005  
4006                  } else {
4007                          for ( i = 0; checkSet[i] != null; i++ ) {
4008                                  if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
4009                                          results.push( set[i] );
4010                                  }
4011                          }
4012                  }
4013  
4014          } else {
4015                  makeArray( checkSet, results );
4016          }
4017  
4018          if ( extra ) {
4019                  Sizzle( extra, origContext, results, seed );
4020                  Sizzle.uniqueSort( results );
4021          }
4022  
4023          return results;
4024  };
4025  
4026  Sizzle.uniqueSort = function( results ) {
4027          if ( sortOrder ) {
4028                  hasDuplicate = baseHasDuplicate;
4029                  results.sort( sortOrder );
4030  
4031                  if ( hasDuplicate ) {
4032                          for ( var i = 1; i < results.length; i++ ) {
4033                                  if ( results[i] === results[ i - 1 ] ) {
4034                                          results.splice( i--, 1 );
4035                                  }
4036                          }
4037                  }
4038          }
4039  
4040          return results;
4041  };
4042  
4043  Sizzle.matches = function( expr, set ) {
4044          return Sizzle( expr, null, null, set );
4045  };
4046  
4047  Sizzle.matchesSelector = function( node, expr ) {
4048          return Sizzle( expr, null, null, [node] ).length > 0;
4049  };
4050  
4051  Sizzle.find = function( expr, context, isXML ) {
4052          var set, i, len, match, type, left;
4053  
4054          if ( !expr ) {
4055                  return [];
4056          }
4057  
4058          for ( i = 0, len = Expr.order.length; i < len; i++ ) {
4059                  type = Expr.order[i];
4060                 
4061                  if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
4062                          left = match[1];
4063                          match.splice( 1, 1 );
4064  
4065                          if ( left.substr( left.length - 1 ) !== "\\" ) {
4066                                  match[1] = (match[1] || "").replace( rBackslash, "" );
4067                                  set = Expr.find[ type ]( match, context, isXML );
4068  
4069                                  if ( set != null ) {
4070                                          expr = expr.replace( Expr.match[ type ], "" );
4071                                          break;
4072                                  }
4073                          }
4074                  }
4075          }
4076  
4077          if ( !set ) {
4078                  set = typeof context.getElementsByTagName !== "undefined" ?
4079                          context.getElementsByTagName( "*" ) :
4080                          [];
4081          }
4082  
4083          return { set: set, expr: expr };
4084  };
4085  
4086  Sizzle.filter = function( expr, set, inplace, not ) {
4087          var match, anyFound,
4088                  type, found, item, filter, left,
4089                  i, pass,
4090                  old = expr,
4091                  result = [],
4092                  curLoop = set,
4093                  isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
4094  
4095          while ( expr && set.length ) {
4096                  for ( type in Expr.filter ) {
4097                          if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
4098                                  filter = Expr.filter[ type ];
4099                                  left = match[1];
4100  
4101                                  anyFound = false;
4102  
4103                                  match.splice(1,1);
4104  
4105                                  if ( left.substr( left.length - 1 ) === "\\" ) {
4106                                          continue;
4107                                  }
4108  
4109                                  if ( curLoop === result ) {
4110                                          result = [];
4111                                  }
4112  
4113                                  if ( Expr.preFilter[ type ] ) {
4114                                          match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
4115  
4116                                          if ( !match ) {
4117                                                  anyFound = found = true;
4118  
4119                                          } else if ( match === true ) {
4120                                                  continue;
4121                                          }
4122                                  }
4123  
4124                                  if ( match ) {
4125                                          for ( i = 0; (item = curLoop[i]) != null; i++ ) {
4126                                                  if ( item ) {
4127                                                          found = filter( item, match, i, curLoop );
4128                                                          pass = not ^ found;
4129  
4130                                                          if ( inplace && found != null ) {
4131                                                                  if ( pass ) {
4132                                                                          anyFound = true;
4133  
4134                                                                  } else {
4135                                                                          curLoop[i] = false;
4136                                                                  }
4137  
4138                                                          } else if ( pass ) {
4139                                                                  result.push( item );
4140                                                                  anyFound = true;
4141                                                          }
4142                                                  }
4143                                          }
4144                                  }
4145  
4146                                  if ( found !== undefined ) {
4147                                          if ( !inplace ) {
4148                                                  curLoop = result;
4149                                          }
4150  
4151                                          expr = expr.replace( Expr.match[ type ], "" );
4152  
4153                                          if ( !anyFound ) {
4154                                                  return [];
4155                                          }
4156  
4157                                          break;
4158                                  }
4159                          }
4160                  }
4161  
4162                  // Improper expression
4163                  if ( expr === old ) {
4164                          if ( anyFound == null ) {
4165                                  Sizzle.error( expr );
4166  
4167                          } else {
4168                                  break;
4169                          }
4170                  }
4171  
4172                  old = expr;
4173          }
4174  
4175          return curLoop;
4176  };
4177  
4178  Sizzle.error = function( msg ) {
4179          throw new Error( "Syntax error, unrecognized expression: " + msg );
4180  };
4181  
4182  /**
4183   * Utility function for retreiving the text value of an array of DOM nodes
4184   * @param {Array|Element} elem
4185   */
4186  var getText = Sizzle.getText = function( elem ) {
4187      var i, node,
4188                  nodeType = elem.nodeType,
4189                  ret = "";
4190  
4191          if ( nodeType ) {
4192                  if ( nodeType === 1 || nodeType === 9 ) {
4193                          // Use textContent || innerText for elements
4194                          if ( typeof elem.textContent === 'string' ) {
4195                                  return elem.textContent;
4196                          } else if ( typeof elem.innerText === 'string' ) {
4197                                  // Replace IE's carriage returns
4198                                  return elem.innerText.replace( rReturn, '' );
4199                          } else {
4200                                  // Traverse it's children
4201                                  for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
4202                                          ret += getText( elem );
4203                                  }
4204                          }
4205                  } else if ( nodeType === 3 || nodeType === 4 ) {
4206                          return elem.nodeValue;
4207                  }
4208          } else {
4209  
4210                  // If no nodeType, this is expected to be an array
4211                  for ( i = 0; (node = elem[i]); i++ ) {
4212                          // Do not traverse comment nodes
4213                          if ( node.nodeType !== 8 ) {
4214                                  ret += getText( node );
4215                          }
4216                  }
4217          }
4218          return ret;
4219  };
4220  
4221  var Expr = Sizzle.selectors = {
4222          order: [ "ID", "NAME", "TAG" ],
4223  
4224          match: {
4225                  ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4226                  CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4227                  NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
4228                  ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
4229                  TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
4230                  CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
4231                  POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
4232                  PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
4233          },
4234  
4235          leftMatch: {},
4236  
4237          attrMap: {
4238                  "class": "className",
4239                  "for": "htmlFor"
4240          },
4241  
4242          attrHandle: {
4243                  href: function( elem ) {
4244                          return elem.getAttribute( "href" );
4245                  },
4246                  type: function( elem ) {
4247                          return elem.getAttribute( "type" );
4248                  }
4249          },
4250  
4251          relative: {
4252                  "+": function(checkSet, part){
4253                          var isPartStr = typeof part === "string",
4254                                  isTag = isPartStr && !rNonWord.test( part ),
4255                                  isPartStrNotTag = isPartStr && !isTag;
4256  
4257                          if ( isTag ) {
4258                                  part = part.toLowerCase();
4259                          }
4260  
4261                          for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4262                                  if ( (elem = checkSet[i]) ) {
4263                                          while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4264  
4265                                          checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
4266                                                  elem || false :
4267                                                  elem === part;
4268                                  }
4269                          }
4270  
4271                          if ( isPartStrNotTag ) {
4272                                  Sizzle.filter( part, checkSet, true );
4273                          }
4274                  },
4275  
4276                  ">": function( checkSet, part ) {
4277                          var elem,
4278                                  isPartStr = typeof part === "string",
4279                                  i = 0,
4280                                  l = checkSet.length;
4281  
4282                          if ( isPartStr && !rNonWord.test( part ) ) {
4283                                  part = part.toLowerCase();
4284  
4285                                  for ( ; i < l; i++ ) {
4286                                          elem = checkSet[i];
4287  
4288                                          if ( elem ) {
4289                                                  var parent = elem.parentNode;
4290                                                  checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4291                                          }
4292                                  }
4293  
4294                          } else {
4295                                  for ( ; i < l; i++ ) {
4296                                          elem = checkSet[i];
4297  
4298                                          if ( elem ) {
4299                                                  checkSet[i] = isPartStr ?
4300                                                          elem.parentNode :
4301                                                          elem.parentNode === part;
4302                                          }
4303                                  }
4304  
4305                                  if ( isPartStr ) {
4306                                          Sizzle.filter( part, checkSet, true );
4307                                  }
4308                          }
4309                  },
4310  
4311                  "": function(checkSet, part, isXML){
4312                          var nodeCheck,
4313                                  doneName = done++,
4314                                  checkFn = dirCheck;
4315  
4316                          if ( typeof part === "string" && !rNonWord.test( part ) ) {
4317                                  part = part.toLowerCase();
4318                                  nodeCheck = part;
4319                                  checkFn = dirNodeCheck;
4320                          }
4321  
4322                          checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4323                  },
4324  
4325                  "~": function( checkSet, part, isXML ) {
4326                          var nodeCheck,
4327                                  doneName = done++,
4328                                  checkFn = dirCheck;
4329  
4330                          if ( typeof part === "string" && !rNonWord.test( part ) ) {
4331                                  part = part.toLowerCase();
4332                                  nodeCheck = part;
4333                                  checkFn = dirNodeCheck;
4334                          }
4335  
4336                          checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4337                  }
4338          },
4339  
4340          find: {
4341                  ID: function( match, context, isXML ) {
4342                          if ( typeof context.getElementById !== "undefined" && !isXML ) {
4343                                  var m = context.getElementById(match[1]);
4344                                  // Check parentNode to catch when Blackberry 4.6 returns
4345                                  // nodes that are no longer in the document #6963
4346                                  return m && m.parentNode ? [m] : [];
4347                          }
4348                  },
4349  
4350                  NAME: function( match, context ) {
4351                          if ( typeof context.getElementsByName !== "undefined" ) {
4352                                  var ret = [],
4353                                          results = context.getElementsByName( match[1] );
4354  
4355                                  for ( var i = 0, l = results.length; i < l; i++ ) {
4356                                          if ( results[i].getAttribute("name") === match[1] ) {
4357                                                  ret.push( results[i] );
4358                                          }
4359                                  }
4360  
4361                                  return ret.length === 0 ? null : ret;
4362                          }
4363                  },
4364  
4365                  TAG: function( match, context ) {
4366                          if ( typeof context.getElementsByTagName !== "undefined" ) {
4367                                  return context.getElementsByTagName( match[1] );
4368                          }
4369                  }
4370          },
4371          preFilter: {
4372                  CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4373                          match = " " + match[1].replace( rBackslash, "" ) + " ";
4374  
4375                          if ( isXML ) {
4376                                  return match;
4377                          }
4378  
4379                          for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4380                                  if ( elem ) {
4381                                          if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4382                                                  if ( !inplace ) {
4383                                                          result.push( elem );
4384                                                  }
4385  
4386                                          } else if ( inplace ) {
4387                                                  curLoop[i] = false;
4388                                          }
4389                                  }
4390                          }
4391  
4392                          return false;
4393                  },
4394  
4395                  ID: function( match ) {
4396                          return match[1].replace( rBackslash, "" );
4397                  },
4398  
4399                  TAG: function( match, curLoop ) {
4400                          return match[1].replace( rBackslash, "" ).toLowerCase();
4401                  },
4402  
4403                  CHILD: function( match ) {
4404                          if ( match[1] === "nth" ) {
4405                                  if ( !match[2] ) {
4406                                          Sizzle.error( match[0] );
4407                                  }
4408  
4409                                  match[2] = match[2].replace(/^\+|\s*/g, '');
4410  
4411                                  // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4412                                  var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
4413                                          match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
4414                                          !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
4415  
4416                                  // calculate the numbers (first)n+(last) including if they are negative
4417                                  match[2] = (test[1] + (test[2] || 1)) - 0;
4418                                  match[3] = test[3] - 0;
4419                          }
4420                          else if ( match[2] ) {
4421                                  Sizzle.error( match[0] );
4422                          }
4423  
4424                          // TODO: Move to normal caching system
4425                          match[0] = done++;
4426  
4427                          return match;
4428                  },
4429  
4430                  ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4431                          var name = match[1] = match[1].replace( rBackslash, "" );
4432                         
4433                          if ( !isXML && Expr.attrMap[name] ) {
4434                                  match[1] = Expr.attrMap[name];
4435                          }
4436  
4437                          // Handle if an un-quoted value was used
4438                          match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
4439  
4440                          if ( match[2] === "~=" ) {
4441                                  match[4] = " " + match[4] + " ";
4442                          }
4443  
4444                          return match;
4445                  },
4446  
4447                  PSEUDO: function( match, curLoop, inplace, result, not ) {
4448                          if ( match[1] === "not" ) {
4449                                  // If we're dealing with a complex expression, or a simple one
4450                                  if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
4451                                          match[3] = Sizzle(match[3], null, null, curLoop);
4452  
4453                                  } else {
4454                                          var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4455  
4456                                          if ( !inplace ) {
4457                                                  result.push.apply( result, ret );
4458                                          }
4459  
4460                                          return false;
4461                                  }
4462  
4463                          } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
4464                                  return true;
4465                          }
4466                         
4467                          return match;
4468                  },
4469  
4470                  POS: function( match ) {
4471                          match.unshift( true );
4472  
4473                          return match;
4474                  }
4475          },
4476         
4477          filters: {
4478                  enabled: function( elem ) {
4479                          return elem.disabled === false && elem.type !== "hidden";
4480                  },
4481  
4482                  disabled: function( elem ) {
4483                          return elem.disabled === true;
4484                  },
4485  
4486                  checked: function( elem ) {
4487                          return elem.checked === true;
4488                  },
4489                 
4490                  selected: function( elem ) {
4491                          // Accessing this property makes selected-by-default
4492                          // options in Safari work properly
4493                          if ( elem.parentNode ) {
4494                                  elem.parentNode.selectedIndex;
4495                          }
4496                         
4497                          return elem.selected === true;
4498                  },
4499  
4500                  parent: function( elem ) {
4501                          return !!elem.firstChild;
4502                  },
4503  
4504                  empty: function( elem ) {
4505                          return !elem.firstChild;
4506                  },
4507  
4508                  has: function( elem, i, match ) {
4509                          return !!Sizzle( match[3], elem ).length;
4510                  },
4511  
4512                  header: function( elem ) {
4513                          return (/h\d/i).test( elem.nodeName );
4514                  },
4515  
4516                  text: function( elem ) {
4517                          var attr = elem.getAttribute( "type" ), type = elem.type;
4518                          // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4519                          // use getAttribute instead to test this case
4520                          return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
4521                  },
4522  
4523                  radio: function( elem ) {
4524                          return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4525                  },
4526  
4527                  checkbox: function( elem ) {
4528                          return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4529                  },
4530  
4531                  file: function( elem ) {
4532                          return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4533                  },
4534  
4535                  password: function( elem ) {
4536                          return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4537                  },
4538  
4539                  submit: function( elem ) {
4540                          var name = elem.nodeName.toLowerCase();
4541                          return (name === "input" || name === "button") && "submit" === elem.type;
4542                  },
4543  
4544                  image: function( elem ) {
4545                          return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4546                  },
4547  
4548                  reset: function( elem ) {
4549                          var name = elem.nodeName.toLowerCase();
4550                          return (name === "input" || name === "button") && "reset" === elem.type;
4551                  },
4552  
4553                  button: function( elem ) {
4554                          var name = elem.nodeName.toLowerCase();
4555                          return name === "input" && "button" === elem.type || name === "button";
4556                  },
4557  
4558                  input: function( elem ) {
4559                          return (/input|select|textarea|button/i).test( elem.nodeName );
4560                  },
4561  
4562                  focus: function( elem ) {
4563                          return elem === elem.ownerDocument.activeElement;
4564                  }
4565          },
4566          setFilters: {
4567                  first: function( elem, i ) {
4568                          return i === 0;
4569                  },
4570  
4571                  last: function( elem, i, match, array ) {
4572                          return i === array.length - 1;
4573                  },
4574  
4575                  even: function( elem, i ) {
4576                          return i % 2 === 0;
4577                  },
4578  
4579                  odd: function( elem, i ) {
4580                          return i % 2 === 1;
4581                  },
4582  
4583                  lt: function( elem, i, match ) {
4584                          return i < match[3] - 0;
4585                  },
4586  
4587                  gt: function( elem, i, match ) {
4588                          return i > match[3] - 0;
4589                  },
4590  
4591                  nth: function( elem, i, match ) {
4592                          return match[3] - 0 === i;
4593                  },
4594  
4595                  eq: function( elem, i, match ) {
4596                          return match[3] - 0 === i;
4597                  }
4598          },
4599          filter: {
4600                  PSEUDO: function( elem, match, i, array ) {
4601                          var name = match[1],
4602                                  filter = Expr.filters[ name ];
4603  
4604                          if ( filter ) {
4605                                  return filter( elem, i, match, array );
4606  
4607                          } else if ( name === "contains" ) {
4608                                  return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
4609  
4610                          } else if ( name === "not" ) {
4611                                  var not = match[3];
4612  
4613                                  for ( var j = 0, l = not.length; j < l; j++ ) {
4614                                          if ( not[j] === elem ) {
4615                                                  return false;
4616                                          }
4617                                  }
4618  
4619                                  return true;
4620  
4621                          } else {
4622                                  Sizzle.error( name );
4623                          }
4624                  },
4625  
4626                  CHILD: function( elem, match ) {
4627                          var first, last,
4628                                  doneName, parent, cache,
4629                                  count, diff,
4630                                  type = match[1],
4631                                  node = elem;
4632  
4633                          switch ( type ) {
4634                                  case "only":
4635                                  case "first":
4636                                          while ( (node = node.previousSibling) )  {
4637                                                  if ( node.nodeType === 1 ) { 
4638                                                          return false; 
4639                                                  }
4640                                          }
4641  
4642                                          if ( type === "first" ) { 
4643                                                  return true; 
4644                                          }
4645  
4646                                          node = elem;
4647  
4648                                  case "last":
4649                                          while ( (node = node.nextSibling) )      {
4650                                                  if ( node.nodeType === 1 ) { 
4651                                                          return false; 
4652                                                  }
4653                                          }
4654  
4655                                          return true;
4656  
4657                                  case "nth":
4658                                          first = match[2];
4659                                          last = match[3];
4660  
4661                                          if ( first === 1 && last === 0 ) {
4662                                                  return true;
4663                                          }
4664                                         
4665                                          doneName = match[0];
4666                                          parent = elem.parentNode;
4667         
4668                                          if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
4669                                                  count = 0;
4670                                                 
4671                                                  for ( node = parent.firstChild; node; node = node.nextSibling ) {
4672                                                          if ( node.nodeType === 1 ) {
4673                                                                  node.nodeIndex = ++count;
4674                                                          }
4675                                                  } 
4676  
4677                                                  parent[ expando ] = doneName;
4678                                          }
4679                                         
4680                                          diff = elem.nodeIndex - last;
4681  
4682                                          if ( first === 0 ) {
4683                                                  return diff === 0;
4684  
4685                                          } else {
4686                                                  return ( diff % first === 0 && diff / first >= 0 );
4687                                          }
4688                          }
4689                  },
4690  
4691                  ID: function( elem, match ) {
4692                          return elem.nodeType === 1 && elem.getAttribute("id") === match;
4693                  },
4694  
4695                  TAG: function( elem, match ) {
4696                          return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
4697                  },
4698                 
4699                  CLASS: function( elem, match ) {
4700                          return (" " + (elem.className || elem.getAttribute("class")) + " ")
4701                                  .indexOf( match ) > -1;
4702                  },
4703  
4704                  ATTR: function( elem, match ) {
4705                          var name = match[1],
4706                                  result = Sizzle.attr ?
4707                                          Sizzle.attr( elem, name ) :
4708                                          Expr.attrHandle[ name ] ?
4709                                          Expr.attrHandle[ name ]( elem ) :
4710                                          elem[ name ] != null ?
4711                                                  elem[ name ] :
4712                                                  elem.getAttribute( name ),
4713                                  value = result + "",
4714                                  type = match[2],
4715                                  check = match[4];
4716  
4717                          return result == null ?
4718                                  type === "!=" :
4719                                  !type && Sizzle.attr ?
4720                                  result != null :
4721                                  type === "=" ?
4722                                  value === check :
4723                                  type === "*=" ?
4724                                  value.indexOf(check) >= 0 :
4725                                  type === "~=" ?
4726                                  (" " + value + " ").indexOf(check) >= 0 :
4727                                  !check ?
4728                                  value && result !== false :
4729                                  type === "!=" ?
4730                                  value !== check :
4731                                  type === "^=" ?
4732                                  value.indexOf(check) === 0 :
4733                                  type === "$=" ?
4734                                  value.substr(value.length - check.length) === check :
4735                                  type === "|=" ?
4736                                  value === check || value.substr(0, check.length + 1) === check + "-" :
4737                                  false;
4738                  },
4739  
4740                  POS: function( elem, match, i, array ) {
4741                          var name = match[2],
4742                                  filter = Expr.setFilters[ name ];
4743  
4744                          if ( filter ) {
4745                                  return filter( elem, i, match, array );
4746                          }
4747                  }
4748          }
4749  };
4750  
4751  var origPOS = Expr.match.POS,
4752          fescape = function(all, num){
4753                  return "\\" + (num - 0 + 1);
4754          };
4755  
4756  for ( var type in Expr.match ) {
4757          Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
4758          Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4759  }
4760  
4761  var makeArray = function( array, results ) {
4762          array = Array.prototype.slice.call( array, 0 );
4763  
4764          if ( results ) {
4765                  results.push.apply( results, array );
4766                  return results;
4767          }
4768         
4769          return array;
4770  };
4771  
4772  // Perform a simple check to determine if the browser is capable of
4773  // converting a NodeList to an array using builtin methods.
4774  // Also verifies that the returned array holds DOM nodes
4775  // (which is not the case in the Blackberry browser)
4776  try {
4777          Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4778  
4779  // Provide a fallback method if it does not work
4780  } catch( e ) {
4781          makeArray = function( array, results ) {
4782                  var i = 0,
4783                          ret = results || [];
4784  
4785                  if ( toString.call(array) === "[object Array]" ) {
4786                          Array.prototype.push.apply( ret, array );
4787  
4788                  } else {
4789                          if ( typeof array.length === "number" ) {
4790                                  for ( var l = array.length; i < l; i++ ) {
4791                                          ret.push( array[i] );
4792                                  }
4793  
4794                          } else {
4795                                  for ( ; array[i]; i++ ) {
4796                                          ret.push( array[i] );
4797                                  }
4798                          }
4799                  }
4800  
4801                  return ret;
4802          };
4803  }
4804  
4805  var sortOrder, siblingCheck;
4806  
4807  if ( document.documentElement.compareDocumentPosition ) {
4808          sortOrder = function( a, b ) {
4809                  if ( a === b ) {
4810                          hasDuplicate = true;
4811                          return 0;
4812                  }
4813  
4814                  if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
4815                          return a.compareDocumentPosition ? -1 : 1;
4816                  }
4817  
4818                  return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4819          };
4820  
4821  } else {
4822          sortOrder = function( a, b ) {
4823                  // The nodes are identical, we can exit early
4824                  if ( a === b ) {
4825                          hasDuplicate = true;
4826                          return 0;
4827  
4828                  // Fallback to using sourceIndex (in IE) if it's available on both nodes
4829                  } else if ( a.sourceIndex && b.sourceIndex ) {
4830                          return a.sourceIndex - b.sourceIndex;
4831                  }
4832  
4833                  var al, bl,
4834                          ap = [],
4835                          bp = [],
4836                          aup = a.parentNode,
4837                          bup = b.parentNode,
4838                          cur = aup;
4839  
4840                  // If the nodes are siblings (or identical) we can do a quick check
4841                  if ( aup === bup ) {
4842                          return siblingCheck( a, b );
4843  
4844                  // If no parents were found then the nodes are disconnected
4845                  } else if ( !aup ) {
4846                          return -1;
4847  
4848                  } else if ( !bup ) {
4849                          return 1;
4850                  }
4851  
4852                  // Otherwise they're somewhere else in the tree so we need
4853                  // to build up a full list of the parentNodes for comparison
4854                  while ( cur ) {
4855                          ap.unshift( cur );
4856                          cur = cur.parentNode;
4857                  }
4858  
4859                  cur = bup;
4860  
4861                  while ( cur ) {
4862                          bp.unshift( cur );
4863                          cur = cur.parentNode;
4864                  }
4865  
4866                  al = ap.length;
4867                  bl = bp.length;
4868  
4869                  // Start walking down the tree looking for a discrepancy
4870                  for ( var i = 0; i < al && i < bl; i++ ) {
4871                          if ( ap[i] !== bp[i] ) {
4872                                  return siblingCheck( ap[i], bp[i] );
4873                          }
4874                  }
4875  
4876                  // We ended someplace up the tree so do a sibling check
4877                  return i === al ?
4878                          siblingCheck( a, bp[i], -1 ) :
4879                          siblingCheck( ap[i], b, 1 );
4880          };
4881  
4882          siblingCheck = function( a, b, ret ) {
4883                  if ( a === b ) {
4884                          return ret;
4885                  }
4886  
4887                  var cur = a.nextSibling;
4888  
4889                  while ( cur ) {
4890                          if ( cur === b ) {
4891                                  return -1;
4892                          }
4893  
4894                          cur = cur.nextSibling;
4895                  }
4896  
4897                  return 1;
4898          };
4899  }
4900  
4901  // Check to see if the browser returns elements by name when
4902  // querying by getElementById (and provide a workaround)
4903  (function(){
4904          // We're going to inject a fake input element with a specified name
4905          var form = document.createElement("div"),
4906                  id = "script" + (new Date()).getTime(),
4907                  root = document.documentElement;
4908  
4909          form.innerHTML = "<a name='" + id + "'/>";
4910  
4911          // Inject it into the root element, check its status, and remove it quickly
4912          root.insertBefore( form, root.firstChild );
4913  
4914          // The workaround has to do additional checks after a getElementById
4915          // Which slows things down for other browsers (hence the branching)
4916          if ( document.getElementById( id ) ) {
4917                  Expr.find.ID = function( match, context, isXML ) {
4918                          if ( typeof context.getElementById !== "undefined" && !isXML ) {
4919                                  var m = context.getElementById(match[1]);
4920  
4921                                  return m ?
4922                                          m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4923                                                  [m] :
4924                                                  undefined :
4925                                          [];
4926                          }
4927                  };
4928  
4929                  Expr.filter.ID = function( elem, match ) {
4930                          var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4931  
4932                          return elem.nodeType === 1 && node && node.nodeValue === match;
4933                  };
4934          }
4935  
4936          root.removeChild( form );
4937  
4938          // release memory in IE
4939          root = form = null;
4940  })();
4941  
4942  (function(){
4943          // Check to see if the browser returns only elements
4944          // when doing getElementsByTagName("*")
4945  
4946          // Create a fake element
4947          var div = document.createElement("div");
4948          div.appendChild( document.createComment("") );
4949  
4950          // Make sure no comments are found
4951          if ( div.getElementsByTagName("*").length > 0 ) {
4952                  Expr.find.TAG = function( match, context ) {
4953                          var results = context.getElementsByTagName( match[1] );
4954  
4955                          // Filter out possible comments
4956                          if ( match[1] === "*" ) {
4957                                  var tmp = [];
4958  
4959                                  for ( var i = 0; results[i]; i++ ) {
4960                                          if ( results[i].nodeType === 1 ) {
4961                                                  tmp.push( results[i] );
4962                                          }
4963                                  }
4964  
4965                                  results = tmp;
4966                          }
4967  
4968                          return results;
4969                  };
4970          }
4971  
4972          // Check to see if an attribute returns normalized href attributes
4973          div.innerHTML = "<a href='#'></a>";
4974  
4975          if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4976                          div.firstChild.getAttribute("href") !== "#" ) {
4977  
4978                  Expr.attrHandle.href = function( elem ) {
4979                          return elem.getAttribute( "href", 2 );
4980                  };
4981          }
4982  
4983          // release memory in IE
4984          div = null;
4985  })();
4986  
4987  if ( document.querySelectorAll ) {
4988          (function(){
4989                  var oldSizzle = Sizzle,
4990                          div = document.createElement("div"),
4991                          id = "__sizzle__";
4992  
4993                  div.innerHTML = "<p class='TEST'></p>";
4994  
4995                  // Safari can't handle uppercase or unicode characters when
4996                  // in quirks mode.
4997                  if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4998                          return;
4999                  }
5000         
5001                  Sizzle = function( query, context, extra, seed ) {
5002                          context = context || document;
5003  
5004                          // Only use querySelectorAll on non-XML documents
5005                          // (ID selectors don't work in non-HTML documents)
5006                          if ( !seed && !Sizzle.isXML(context) ) {
5007                                  // See if we find a selector to speed up
5008                                  var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
5009                                 
5010                                  if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
5011                                          // Speed-up: Sizzle("TAG")
5012                                          if ( match[1] ) {
5013                                                  return makeArray( context.getElementsByTagName( query ), extra );
5014                                         
5015                                          // Speed-up: Sizzle(".CLASS")
5016                                          } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
5017                                                  return makeArray( context.getElementsByClassName( match[2] ), extra );
5018                                          }
5019                                  }
5020                                 
5021                                  if ( context.nodeType === 9 ) {
5022                                          // Speed-up: Sizzle("body")
5023                                          // The body element only exists once, optimize finding it
5024                                          if ( query === "body" && context.body ) {
5025                                                  return makeArray( [ context.body ], extra );
5026                                                 
5027                                          // Speed-up: Sizzle("#ID")
5028                                          } else if ( match && match[3] ) {
5029                                                  var elem = context.getElementById( match[3] );
5030  
5031                                                  // Check parentNode to catch when Blackberry 4.6 returns
5032                                                  // nodes that are no longer in the document #6963
5033                                                  if ( elem && elem.parentNode ) {
5034                                                          // Handle the case where IE and Opera return items
5035                                                          // by name instead of ID
5036                                                          if ( elem.id === match[3] ) {
5037                                                                  return makeArray( [ elem ], extra );
5038                                                          }
5039                                                         
5040                                                  } else {
5041                                                          return makeArray( [], extra );
5042                                                  }
5043                                          }
5044                                         
5045                                          try {
5046                                                  return makeArray( context.querySelectorAll(query), extra );
5047                                          } catch(qsaError) {}
5048  
5049                                  // qSA works strangely on Element-rooted queries
5050                                  // We can work around this by specifying an extra ID on the root
5051                                  // and working up from there (Thanks to Andrew Dupont for the technique)
5052                                  // IE 8 doesn't work on object elements
5053                                  } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
5054                                          var oldContext = context,
5055                                                  old = context.getAttribute( "id" ),
5056                                                  nid = old || id,
5057                                                  hasParent = context.parentNode,
5058                                                  relativeHierarchySelector = /^\s*[+~]/.test( query );
5059  
5060                                          if ( !old ) {
5061                                                  context.setAttribute( "id", nid );
5062                                          } else {
5063                                                  nid = nid.replace( /'/g, "\\$&" );
5064                                          }
5065                                          if ( relativeHierarchySelector && hasParent ) {
5066                                                  context = context.parentNode;
5067                                          }
5068  
5069                                          try {
5070                                                  if ( !relativeHierarchySelector || hasParent ) {
5071                                                          return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
5072                                                  }
5073  
5074                                          } catch(pseudoError) {
5075                                          } finally {
5076                                                  if ( !old ) {
5077                                                          oldContext.removeAttribute( "id" );
5078                                                  }
5079                                          }
5080                                  }
5081                          }
5082                 
5083                          return oldSizzle(query, context, extra, seed);
5084                  };
5085  
5086                  for ( var prop in oldSizzle ) {
5087                          Sizzle[ prop ] = oldSizzle[ prop ];
5088                  }
5089  
5090                  // release memory in IE
5091                  div = null;
5092          })();
5093  }
5094  
5095  (function(){
5096          var html = document.documentElement,
5097                  matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
5098  
5099          if ( matches ) {
5100                  // Check to see if it's possible to do matchesSelector
5101                  // on a disconnected node (IE 9 fails this)
5102                  var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
5103                          pseudoWorks = false;
5104  
5105                  try {
5106                          // This should fail with an exception
5107                          // Gecko does not error, returns false instead
5108                          matches.call( document.documentElement, "[test!='']:sizzle" );
5109         
5110                  } catch( pseudoError ) {
5111                          pseudoWorks = true;
5112                  }
5113  
5114                  Sizzle.matchesSelector = function( node, expr ) {
5115                          // Make sure that attribute selectors are quoted
5116                          expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
5117  
5118                          if ( !Sizzle.isXML( node ) ) {
5119                                  try { 
5120                                          if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
5121                                                  var ret = matches.call( node, expr );
5122  
5123                                                  // IE 9's matchesSelector returns false on disconnected nodes
5124                                                  if ( ret || !disconnectedMatch ||
5125                                                                  // As well, disconnected nodes are said to be in a document
5126                                                                  // fragment in IE 9, so check for that
5127                                                                  node.document && node.document.nodeType !== 11 ) {
5128                                                          return ret;
5129                                                  }
5130                                          }
5131                                  } catch(e) {}
5132                          }
5133  
5134                          return Sizzle(expr, null, null, [node]).length > 0;
5135                  };
5136          }
5137  })();
5138  
5139  (function(){
5140          var div = document.createElement("div");
5141  
5142          div.innerHTML = "<div class='test e'></div><div class='test'></div>";
5143  
5144          // Opera can't find a second classname (in 9.6)
5145          // Also, make sure that getElementsByClassName actually exists
5146          if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
5147                  return;
5148          }
5149  
5150          // Safari caches class attributes, doesn't catch changes (in 3.2)
5151          div.lastChild.className = "e";
5152  
5153          if ( div.getElementsByClassName("e").length === 1 ) {
5154                  return;
5155          }
5156         
5157          Expr.order.splice(1, 0, "CLASS");
5158          Expr.find.CLASS = function( match, context, isXML ) {
5159                  if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
5160                          return context.getElementsByClassName(match[1]);
5161                  }
5162          };
5163  
5164          // release memory in IE
5165          div = null;
5166  })();
5167  
5168  function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5169          for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5170                  var elem = checkSet[i];
5171  
5172                  if ( elem ) {
5173                          var match = false;
5174  
5175                          elem = elem[dir];
5176  
5177                          while ( elem ) {
5178                                  if ( elem[ expando ] === doneName ) {
5179                                          match = checkSet[elem.sizset];
5180                                          break;
5181                                  }
5182  
5183                                  if ( elem.nodeType === 1 && !isXML ){
5184                                          elem[ expando ] = doneName;
5185                                          elem.sizset = i;
5186                                  }
5187  
5188                                  if ( elem.nodeName.toLowerCase() === cur ) {
5189                                          match = elem;
5190                                          break;
5191                                  }
5192  
5193                                  elem = elem[dir];
5194                          }
5195  
5196                          checkSet[i] = match;
5197                  }
5198          }
5199  }
5200  
5201  function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5202          for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5203                  var elem = checkSet[i];
5204  
5205                  if ( elem ) {
5206                          var match = false;
5207                         
5208                          elem = elem[dir];
5209  
5210                          while ( elem ) {
5211                                  if ( elem[ expando ] === doneName ) {
5212                                          match = checkSet[elem.sizset];
5213                                          break;
5214                                  }
5215  
5216                                  if ( elem.nodeType === 1 ) {
5217                                          if ( !isXML ) {
5218                                                  elem[ expando ] = doneName;
5219                                                  elem.sizset = i;
5220                                          }
5221  
5222                                          if ( typeof cur !== "string" ) {
5223                                                  if ( elem === cur ) {
5224                                                          match = true;
5225                                                          break;
5226                                                  }
5227  
5228                                          } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5229                                                  match = elem;
5230                                                  break;
5231                                          }
5232                                  }
5233  
5234                                  elem = elem[dir];
5235                          }
5236  
5237                          checkSet[i] = match;
5238                  }
5239          }
5240  }
5241  
5242  if ( document.documentElement.contains ) {
5243          Sizzle.contains = function( a, b ) {
5244                  return a !== b && (a.contains ? a.contains(b) : true);
5245          };
5246  
5247  } else if ( document.documentElement.compareDocumentPosition ) {
5248          Sizzle.contains = function( a, b ) {
5249                  return !!(a.compareDocumentPosition(b) & 16);
5250          };
5251  
5252  } else {
5253          Sizzle.contains = function() {
5254                  return false;
5255          };
5256  }
5257  
5258  Sizzle.isXML = function( elem ) {
5259          // documentElement is verified for cases where it doesn't yet exist
5260          // (such as loading iframes in IE - #4833)
5261          var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
5262  
5263          return documentElement ? documentElement.nodeName !== "HTML" : false;
5264  };
5265  
5266  var posProcess = function( selector, context, seed ) {
5267          var match,
5268                  tmpSet = [],
5269                  later = "",
5270                  root = context.nodeType ? [context] : context;
5271  
5272          // Position selectors must be done after the filter
5273          // And so must :not(positional) so we move all PSEUDOs to the end
5274          while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5275                  later += match[0];
5276                  selector = selector.replace( Expr.match.PSEUDO, "" );
5277          }
5278  
5279          selector = Expr.relative[selector] ? selector + "*" : selector;
5280  
5281          for ( var i = 0, l = root.length; i < l; i++ ) {
5282                  Sizzle( selector, root[i], tmpSet, seed );
5283          }
5284  
5285          return Sizzle.filter( later, tmpSet );
5286  };
5287  
5288  // EXPOSE
5289  // Override sizzle attribute retrieval
5290  Sizzle.attr = jQuery.attr;
5291  Sizzle.selectors.attrMap = {};
5292  jQuery.find = Sizzle;
5293  jQuery.expr = Sizzle.selectors;
5294  jQuery.expr[":"] = jQuery.expr.filters;
5295  jQuery.unique = Sizzle.uniqueSort;
5296  jQuery.text = Sizzle.getText;
5297  jQuery.isXMLDoc = Sizzle.isXML;
5298  jQuery.contains = Sizzle.contains;
5299  
5300  
5301  })();
5302  
5303  
5304  var runtil = /Until$/,
5305          rparentsprev = /^(?:parents|prevUntil|prevAll)/,
5306          // Note: This RegExp should be improved, or likely pulled from Sizzle
5307          rmultiselector = /,/,
5308          isSimple = /^.[^:#\[\.,]*$/,
5309          slice = Array.prototype.slice,
5310          POS = jQuery.expr.match.POS,
5311          // methods guaranteed to produce a unique set when starting from a unique set
5312          guaranteedUnique = {
5313                  children: true,
5314                  contents: true,
5315                  next: true,
5316                  prev: true
5317          };
5318  
5319  jQuery.fn.extend({
5320          find: function( selector ) {
5321                  var self = this,
5322                          i, l;
5323  
5324                  if ( typeof selector !== "string" ) {
5325                          return jQuery( selector ).filter(function() {
5326                                  for ( i = 0, l = self.length; i < l; i++ ) {
5327                                          if ( jQuery.contains( self[ i ], this ) ) {
5328                                                  return true;
5329                                          }
5330                                  }
5331                          });
5332                  }
5333  
5334                  var ret = this.pushStack( "", "find", selector ),
5335                          length, n, r;
5336  
5337                  for ( i = 0, l = this.length; i < l; i++ ) {
5338                          length = ret.length;
5339                          jQuery.find( selector, this[i], ret );
5340  
5341                          if ( i > 0 ) {
5342                                  // Make sure that the results are unique
5343                                  for ( n = length; n < ret.length; n++ ) {
5344                                          for ( r = 0; r < length; r++ ) {
5345                                                  if ( ret[r] === ret[n] ) {
5346                                                          ret.splice(n--, 1);
5347                                                          break;
5348                                                  }
5349                                          }
5350                                  }
5351                          }
5352                  }
5353  
5354                  return ret;
5355          },
5356  
5357          has: function( target ) {
5358                  var targets = jQuery( target );
5359                  return this.filter(function() {
5360                          for ( var i = 0, l = targets.length; i < l; i++ ) {
5361                                  if ( jQuery.contains( this, targets[i] ) ) {
5362                                          return true;
5363                                  }
5364                          }
5365                  });
5366          },
5367  
5368          not: function( selector ) {
5369                  return this.pushStack( winnow(this, selector, false), "not", selector);
5370          },
5371  
5372          filter: function( selector ) {
5373                  return this.pushStack( winnow(this, selector, true), "filter", selector );
5374          },
5375  
5376          is: function( selector ) {
5377                  return !!selector && ( 
5378                          typeof selector === "string" ?
5379                                  // If this is a positional selector, check membership in the returned set
5380                                  // so $("p:first").is("p:last") won't return true for a doc with two "p".
5381                                  POS.test( selector ) ? 
5382                                          jQuery( selector, this.context ).index( this[0] ) >= 0 :
5383                                          jQuery.filter( selector, this ).length > 0 :
5384                                  this.filter( selector ).length > 0 );
5385          },
5386  
5387          closest: function( selectors, context ) {
5388                  var ret = [], i, l, cur = this[0];
5389                 
5390                  // Array (deprecated as of jQuery 1.7)
5391                  if ( jQuery.isArray( selectors ) ) {
5392                          var level = 1;
5393  
5394                          while ( cur && cur.ownerDocument && cur !== context ) {
5395                                  for ( i = 0; i < selectors.length; i++ ) {
5396  
5397                                          if ( jQuery( cur ).is( selectors[ i ] ) ) {
5398                                                  ret.push({ selector: selectors[ i ], elem: cur, level: level });
5399                                          }
5400                                  }
5401  
5402                                  cur = cur.parentNode;
5403                                  level++;
5404                          }
5405  
5406                          return ret;
5407                  }
5408  
5409                  // String
5410                  var pos = POS.test( selectors ) || typeof selectors !== "string" ?
5411                                  jQuery( selectors, context || this.context ) :
5412                                  0;
5413  
5414                  for ( i = 0, l = this.length; i < l; i++ ) {
5415                          cur = this[i];
5416  
5417                          while ( cur ) {
5418                                  if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5419                                          ret.push( cur );
5420                                          break;
5421  
5422                                  } else {
5423                                          cur = cur.parentNode;
5424                                          if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
5425                                                  break;
5426                                          }
5427                                  }
5428                          }
5429                  }
5430  
5431                  ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5432  
5433                  return this.pushStack( ret, "closest", selectors );
5434          },
5435  
5436          // Determine the position of an element within
5437          // the matched set of elements
5438          index: function( elem ) {
5439  
5440                  // No argument, return index in parent
5441                  if ( !elem ) {
5442                          return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
5443                  }
5444  
5445                  // index in selector
5446                  if ( typeof elem === "string" ) {
5447                          return jQuery.inArray( this[0], jQuery( elem ) );
5448                  }
5449  
5450                  // Locate the position of the desired element
5451                  return jQuery.inArray(
5452                          // If it receives a jQuery object, the first element is used
5453                          elem.jquery ? elem[0] : elem, this );
5454          },
5455  
5456          add: function( selector, context ) {
5457                  var set = typeof selector === "string" ?
5458                                  jQuery( selector, context ) :
5459                                  jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5460                          all = jQuery.merge( this.get(), set );
5461  
5462                  return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
5463                          all :
5464                          jQuery.unique( all ) );
5465          },
5466  
5467          andSelf: function() {
5468                  return this.add( this.prevObject );
5469          }
5470  });
5471  
5472  // A painfully simple check to see if an element is disconnected
5473  // from a document (should be improved, where feasible).
5474  function isDisconnected( node ) {
5475          return !node || !node.parentNode || node.parentNode.nodeType === 11;
5476  }
5477  
5478  jQuery.each({
5479          parent: function( elem ) {
5480                  var parent = elem.parentNode;
5481                  return parent && parent.nodeType !== 11 ? parent : null;
5482          },
5483          parents: function( elem ) {
5484                  return jQuery.dir( elem, "parentNode" );
5485          },
5486          parentsUntil: function( elem, i, until ) {
5487                  return jQuery.dir( elem, "parentNode", until );
5488          },
5489          next: function( elem ) {
5490                  return jQuery.nth( elem, 2, "nextSibling" );
5491          },
5492          prev: function( elem ) {
5493                  return jQuery.nth( elem, 2, "previousSibling" );
5494          },
5495          nextAll: function( elem ) {
5496                  return jQuery.dir( elem, "nextSibling" );
5497          },
5498          prevAll: function( elem ) {
5499                  return jQuery.dir( elem, "previousSibling" );
5500          },
5501          nextUntil: function( elem, i, until ) {
5502                  return jQuery.dir( elem, "nextSibling", until );
5503          },
5504          prevUntil: function( elem, i, until ) {
5505                  return jQuery.dir( elem, "previousSibling", until );
5506          },
5507          siblings: function( elem ) {
5508                  return jQuery.sibling( elem.parentNode.firstChild, elem );
5509          },
5510          children: function( elem ) {
5511                  return jQuery.sibling( elem.firstChild );
5512          },
5513          contents: function( elem ) {
5514                  return jQuery.nodeName( elem, "iframe" ) ?
5515                          elem.contentDocument || elem.contentWindow.document :
5516                          jQuery.makeArray( elem.childNodes );
5517          }
5518  }, function( name, fn ) {
5519          jQuery.fn[ name ] = function( until, selector ) {
5520                  var ret = jQuery.map( this, fn, until );
5521  
5522                  if ( !runtil.test( name ) ) {
5523                          selector = until;
5524                  }
5525  
5526                  if ( selector && typeof selector === "string" ) {
5527                          ret = jQuery.filter( selector, ret );
5528                  }
5529  
5530                  ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5531  
5532                  if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5533                          ret = ret.reverse();
5534                  }
5535  
5536                  return this.pushStack( ret, name, slice.call( arguments ).join(",") );
5537          };
5538  });
5539  
5540  jQuery.extend({
5541          filter: function( expr, elems, not ) {
5542                  if ( not ) {
5543                          expr = ":not(" + expr + ")";
5544                  }
5545  
5546                  return elems.length === 1 ?
5547                          jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5548                          jQuery.find.matches(expr, elems);
5549          },
5550  
5551          dir: function( elem, dir, until ) {
5552                  var matched = [],
5553                          cur = elem[ dir ];
5554  
5555                  while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
5556                          if ( cur.nodeType === 1 ) {
5557                                  matched.push( cur );
5558                          }
5559                          cur = cur[dir];
5560                  }
5561                  return matched;
5562          },
5563  
5564          nth: function( cur, result, dir, elem ) {
5565                  result = result || 1;
5566                  var num = 0;
5567  
5568                  for ( ; cur; cur = cur[dir] ) {
5569                          if ( cur.nodeType === 1 && ++num === result ) {
5570                                  break;
5571                          }
5572                  }
5573  
5574                  return cur;
5575          },
5576  
5577          sibling: function( n, elem ) {
5578                  var r = [];
5579  
5580                  for ( ; n; n = n.nextSibling ) {
5581                          if ( n.nodeType === 1 && n !== elem ) {
5582                                  r.push( n );
5583                          }
5584                  }
5585  
5586                  return r;
5587          }
5588  });
5589  
5590  // Implement the identical functionality for filter and not
5591  function winnow( elements, qualifier, keep ) {
5592  
5593          // Can't pass null or undefined to indexOf in Firefox 4
5594          // Set to 0 to skip string check
5595          qualifier = qualifier || 0;
5596  
5597          if ( jQuery.isFunction( qualifier ) ) {
5598                  return jQuery.grep(elements, function( elem, i ) {
5599                          var retVal = !!qualifier.call( elem, i, elem );
5600                          return retVal === keep;
5601                  });
5602  
5603          } else if ( qualifier.nodeType ) {
5604                  return jQuery.grep(elements, function( elem, i ) {
5605                          return ( elem === qualifier ) === keep;
5606                  });
5607  
5608          } else if ( typeof qualifier === "string" ) {
5609                  var filtered = jQuery.grep(elements, function( elem ) {
5610                          return elem.nodeType === 1;
5611                  });
5612  
5613                  if ( isSimple.test( qualifier ) ) {
5614                          return jQuery.filter(qualifier, filtered, !keep);
5615                  } else {
5616                          qualifier = jQuery.filter( qualifier, filtered );
5617                  }
5618          }
5619  
5620          return jQuery.grep(elements, function( elem, i ) {
5621                  return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
5622          });
5623  }
5624  
5625  
5626  
5627  
5628  function createSafeFragment( document ) {
5629          var list = nodeNames.split( "|" ),
5630          safeFrag = document.createDocumentFragment();
5631  
5632          if ( safeFrag.createElement ) {
5633                  while ( list.length ) {
5634                          safeFrag.createElement(
5635                                  list.pop()
5636                          );
5637                  }
5638          }
5639          return safeFrag;
5640  }
5641  
5642  var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" +
5643                  "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
5644          rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5645          rleadingWhitespace = /^\s+/,
5646          rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
5647          rtagName = /<([\w:]+)/,
5648          rtbody = /<tbody/i,
5649          rhtml = /<|&#?\w+;/,
5650          rnoInnerhtml = /<(?:script|style)/i,
5651          rnocache = /<(?:script|object|embed|option|style)/i,
5652          rnoshimcache = new RegExp("<(?:" + nodeNames + ")", "i"),
5653          // checked="checked" or checked
5654          rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5655          rscriptType = /\/(java|ecma)script/i,
5656          rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
5657          wrapMap = {
5658                  option: [ 1, "<select multiple='multiple'>", "</select>" ],
5659                  legend: [ 1, "<fieldset>", "</fieldset>" ],
5660                  thead: [ 1, "<table>", "</table>" ],
5661                  tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5662                  td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5663                  col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5664                  area: [ 1, "<map>", "</map>" ],
5665                  _default: [ 0, "", "" ]
5666          },
5667          safeFragment = createSafeFragment( document );
5668  
5669  wrapMap.optgroup = wrapMap.option;
5670  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5671  wrapMap.th = wrapMap.td;
5672  
5673  // IE can't serialize <link> and <script> tags normally
5674  if ( !jQuery.support.htmlSerialize ) {
5675          wrapMap._default = [ 1, "div<div>", "</div>" ];
5676  }
5677  
5678  jQuery.fn.extend({
5679          text: function( text ) {
5680                  if ( jQuery.isFunction(text) ) {
5681                          return this.each(function(i) {
5682                                  var self = jQuery( this );
5683  
5684                                  self.text( text.call(this, i, self.text()) );
5685                          });
5686                  }
5687  
5688                  if ( typeof text !== "object" && text !== undefined ) {
5689                          return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
5690                  }
5691  
5692                  return jQuery.text( this );
5693          },
5694  
5695          wrapAll: function( html ) {
5696                  if ( jQuery.isFunction( html ) ) {
5697                          return this.each(function(i) {
5698                                  jQuery(this).wrapAll( html.call(this, i) );
5699                          });
5700                  }
5701  
5702                  if ( this[0] ) {
5703                          // The elements to wrap the target around
5704                          var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5705  
5706                          if ( this[0].parentNode ) {
5707                                  wrap.insertBefore( this[0] );
5708                          }
5709  
5710                          wrap.map(function() {
5711                                  var elem = this;
5712  
5713                                  while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5714                                          elem = elem.firstChild;
5715                                  }
5716  
5717                                  return elem;
5718                          }).append( this );
5719                  }
5720  
5721                  return this;
5722          },
5723  
5724          wrapInner: function( html ) {
5725                  if ( jQuery.isFunction( html ) ) {
5726                          return this.each(function(i) {
5727                                  jQuery(this).wrapInner( html.call(this, i) );
5728                          });
5729                  }
5730  
5731                  return this.each(function() {
5732                          var self = jQuery( this ),
5733                                  contents = self.contents();
5734  
5735                          if ( contents.length ) {
5736                                  contents.wrapAll( html );
5737  
5738                          } else {
5739                                  self.append( html );
5740                          }
5741                  });
5742          },
5743  
5744          wrap: function( html ) {
5745                  var isFunction = jQuery.isFunction( html );
5746  
5747                  return this.each(function(i) {
5748                          jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
5749                  });
5750          },
5751  
5752          unwrap: function() {
5753                  return this.parent().each(function() {
5754                          if ( !jQuery.nodeName( this, "body" ) ) {
5755                                  jQuery( this ).replaceWith( this.childNodes );
5756                          }
5757                  }).end();
5758          },
5759  
5760          append: function() {
5761                  return this.domManip(arguments, true, function( elem ) {
5762                          if ( this.nodeType === 1 ) {
5763                                  this.appendChild( elem );
5764                          }
5765                  });
5766          },
5767  
5768          prepend: function() {
5769                  return this.domManip(arguments, true, function( elem ) {
5770                          if ( this.nodeType === 1 ) {
5771                                  this.insertBefore( elem, this.firstChild );
5772                          }
5773                  });
5774          },
5775  
5776          before: function() {
5777                  if ( this[0] && this[0].parentNode ) {
5778                          return this.domManip(arguments, false, function( elem ) {
5779                                  this.parentNode.insertBefore( elem, this );
5780                          });
5781                  } else if ( arguments.length ) {
5782                          var set = jQuery.clean( arguments );
5783                          set.push.apply( set, this.toArray() );
5784                          return this.pushStack( set, "before", arguments );
5785                  }
5786          },
5787  
5788          after: function() {
5789                  if ( this[0] && this[0].parentNode ) {
5790                          return this.domManip(arguments, false, function( elem ) {
5791                                  this.parentNode.insertBefore( elem, this.nextSibling );
5792                          });
5793                  } else if ( arguments.length ) {
5794                          var set = this.pushStack( this, "after", arguments );
5795                          set.push.apply( set, jQuery.clean(arguments) );
5796                          return set;
5797                  }
5798          },
5799  
5800          // keepData is for internal use only--do not document
5801          remove: function( selector, keepData ) {
5802                  for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5803                          if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5804                                  if ( !keepData && elem.nodeType === 1 ) {
5805                                          jQuery.cleanData( elem.getElementsByTagName("*") );
5806                                          jQuery.cleanData( [ elem ] );
5807                                  }
5808  
5809                                  if ( elem.parentNode ) {
5810                                          elem.parentNode.removeChild( elem );
5811                                  }
5812                          }
5813                  }
5814  
5815                  return this;
5816          },
5817  
5818          empty: function() {
5819                  for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5820                          // Remove element nodes and prevent memory leaks
5821                          if ( elem.nodeType === 1 ) {
5822                                  jQuery.cleanData( elem.getElementsByTagName("*") );
5823                          }
5824  
5825                          // Remove any remaining nodes
5826                          while ( elem.firstChild ) {
5827                                  elem.removeChild( elem.firstChild );
5828                          }
5829                  }
5830  
5831                  return this;
5832          },
5833  
5834          clone: function( dataAndEvents, deepDataAndEvents ) {
5835                  dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5836                  deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5837  
5838                  return this.map( function () {
5839                          return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5840                  });
5841          },
5842  
5843          html: function( value ) {
5844                  if ( value === undefined ) {
5845                          return this[0] && this[0].nodeType === 1 ?
5846                                  this[0].innerHTML.replace(rinlinejQuery, "") :
5847                                  null;
5848  
5849                  // See if we can take a shortcut and just use innerHTML
5850                  } else if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5851                          (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5852                          !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5853  
5854                          value = value.replace(rxhtmlTag, "<$1></$2>");
5855  
5856                          try {
5857                                  for ( var i = 0, l = this.length; i < l; i++ ) {
5858                                          // Remove element nodes and prevent memory leaks
5859                                          if ( this[i].nodeType === 1 ) {
5860                                                  jQuery.cleanData( this[i].getElementsByTagName("*") );
5861                                                  this[i].innerHTML = value;
5862                                          }
5863                                  }
5864  
5865                          // If using innerHTML throws an exception, use the fallback method
5866                          } catch(e) {
5867                                  this.empty().append( value );
5868                          }
5869  
5870                  } else if ( jQuery.isFunction( value ) ) {
5871                          this.each(function(i){
5872                                  var self = jQuery( this );
5873  
5874                                  self.html( value.call(this, i, self.html()) );
5875                          });
5876  
5877                  } else {
5878                          this.empty().append( value );
5879                  }
5880  
5881                  return this;
5882          },
5883  
5884          replaceWith: function( value ) {
5885                  if ( this[0] && this[0].parentNode ) {
5886                          // Make sure that the elements are removed from the DOM before they are inserted
5887                          // this can help fix replacing a parent with child elements
5888                          if ( jQuery.isFunction( value ) ) {
5889                                  return this.each(function(i) {
5890                                          var self = jQuery(this), old = self.html();
5891                                          self.replaceWith( value.call( this, i, old ) );
5892                                  });
5893                          }
5894  
5895                          if ( typeof value !== "string" ) {
5896                                  value = jQuery( value ).detach();
5897                          }
5898  
5899                          return this.each(function() {
5900                                  var next = this.nextSibling,
5901                                          parent = this.parentNode;
5902  
5903                                  jQuery( this ).remove();
5904  
5905                                  if ( next ) {
5906                                          jQuery(next).before( value );
5907                                  } else {
5908                                          jQuery(parent).append( value );
5909                                  }
5910                          });
5911                  } else {
5912                          return this.length ?
5913                                  this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5914                                  this;
5915                  }
5916          },
5917  
5918          detach: function( selector ) {
5919                  return this.remove( selector, true );
5920          },
5921  
5922          domManip: function( args, table, callback ) {
5923                  var results, first, fragment, parent,
5924                          value = args[0],
5925                          scripts = [];
5926  
5927                  // We can't cloneNode fragments that contain checked, in WebKit
5928                  if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5929                          return this.each(function() {
5930                                  jQuery(this).domManip( args, table, callback, true );
5931                          });
5932                  }
5933  
5934                  if ( jQuery.isFunction(value) ) {
5935                          return this.each(function(i) {
5936                                  var self = jQuery(this);
5937                                  args[0] = value.call(this, i, table ? self.html() : undefined);
5938                                  self.domManip( args, table, callback );
5939                          });
5940                  }
5941  
5942                  if ( this[0] ) {
5943                          parent = value && value.parentNode;
5944  
5945                          // If we're in a fragment, just use that instead of building a new one
5946                          if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5947                                  results = { fragment: parent };
5948  
5949                          } else {
5950                                  results = jQuery.buildFragment( args, this, scripts );
5951                          }
5952  
5953                          fragment = results.fragment;
5954  
5955                          if ( fragment.childNodes.length === 1 ) {
5956                                  first = fragment = fragment.firstChild;
5957                          } else {
5958                                  first = fragment.firstChild;
5959                          }
5960  
5961                          if ( first ) {
5962                                  table = table && jQuery.nodeName( first, "tr" );
5963  
5964                                  for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5965                                          callback.call(
5966                                                  table ?
5967                                                          root(this[i], first) :
5968                                                          this[i],
5969                                                  // Make sure that we do not leak memory by inadvertently discarding
5970                                                  // the original fragment (which might have attached data) instead of
5971                                                  // using it; in addition, use the original fragment object for the last
5972                                                  // item instead of first because it can end up being emptied incorrectly
5973                                                  // in certain situations (Bug #8070).
5974                                                  // Fragments from the fragment cache must always be cloned and never used
5975                                                  // in place.
5976                                                  results.cacheable || ( l > 1 && i < lastIndex ) ?
5977                                                          jQuery.clone( fragment, true, true ) :
5978                                                          fragment
5979                                          );
5980                                  }
5981                          }
5982  
5983                          if ( scripts.length ) {
5984                                  jQuery.each( scripts, evalScript );
5985                          }
5986                  }
5987  
5988                  return this;
5989          }
5990  });
5991  
5992  function root( elem, cur ) {
5993          return jQuery.nodeName(elem, "table") ?
5994                  (elem.getElementsByTagName("tbody")[0] ||
5995                  elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5996                  elem;
5997  }
5998  
5999  function cloneCopyEvent( src, dest ) {
6000  
6001          if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
6002                  return;
6003          }
6004  
6005          var type, i, l,
6006                  oldData = jQuery._data( src ),
6007                  curData = jQuery._data( dest, oldData ),
6008                  events = oldData.events;
6009  
6010          if ( events ) {
6011                  delete curData.handle;
6012                  curData.events = {};
6013  
6014                  for ( type in events ) {
6015                          for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6016                                  jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
6017                          }
6018                  }
6019          }
6020  
6021          // make the cloned public data object a copy from the original
6022          if ( curData.data ) {
6023                  curData.data = jQuery.extend( {}, curData.data );
6024          }
6025  }
6026  
6027  function cloneFixAttributes( src, dest ) {
6028          var nodeName;
6029  
6030          // We do not need to do anything for non-Elements
6031          if ( dest.nodeType !== 1 ) {
6032                  return;
6033          }
6034  
6035          // clearAttributes removes the attributes, which we don't want,
6036          // but also removes the attachEvent events, which we *do* want
6037          if ( dest.clearAttributes ) {
6038                  dest.clearAttributes();
6039          }
6040  
6041          // mergeAttributes, in contrast, only merges back on the
6042          // original attributes, not the events
6043          if ( dest.mergeAttributes ) {
6044                  dest.mergeAttributes( src );
6045          }
6046  
6047          nodeName = dest.nodeName.toLowerCase();
6048  
6049          // IE6-8 fail to clone children inside object elements that use
6050          // the proprietary classid attribute value (rather than the type
6051          // attribute) to identify the type of content to display
6052          if ( nodeName === "object" ) {
6053                  dest.outerHTML = src.outerHTML;
6054  
6055          } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
6056                  // IE6-8 fails to persist the checked state of a cloned checkbox
6057                  // or radio button. Worse, IE6-7 fail to give the cloned element
6058                  // a checked appearance if the defaultChecked value isn't also set
6059                  if ( src.checked ) {
6060                          dest.defaultChecked = dest.checked = src.checked;
6061                  }
6062  
6063                  // IE6-7 get confused and end up setting the value of a cloned
6064                  // checkbox/radio button to an empty string instead of "on"
6065                  if ( dest.value !== src.value ) {
6066                          dest.value = src.value;
6067                  }
6068  
6069          // IE6-8 fails to return the selected option to the default selected
6070          // state when cloning options
6071          } else if ( nodeName === "option" ) {
6072                  dest.selected = src.defaultSelected;
6073  
6074          // IE6-8 fails to set the defaultValue to the correct value when
6075          // cloning other types of input fields
6076          } else if ( nodeName === "input" || nodeName === "textarea" ) {
6077                  dest.defaultValue = src.defaultValue;
6078          }
6079  
6080          // Event data gets referenced instead of copied if the expando
6081          // gets copied too
6082          dest.removeAttribute( jQuery.expando );
6083  }
6084  
6085  jQuery.buildFragment = function( args, nodes, scripts ) {
6086          var fragment, cacheable, cacheresults, doc,
6087          first = args[ 0 ];
6088  
6089          // nodes may contain either an explicit document object,
6090          // a jQuery collection or context object.
6091          // If nodes[0] contains a valid object to assign to doc
6092          if ( nodes && nodes[0] ) {
6093                  doc = nodes[0].ownerDocument || nodes[0];
6094          }
6095  
6096          // Ensure that an attr object doesn't incorrectly stand in as a document object
6097          // Chrome and Firefox seem to allow this to occur and will throw exception
6098          // Fixes #8950
6099          if ( !doc.createDocumentFragment ) {
6100                  doc = document;
6101          }
6102  
6103          // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
6104          // Cloning options loses the selected state, so don't cache them
6105          // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
6106          // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
6107          // Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
6108          if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
6109                  first.charAt(0) === "<" && !rnocache.test( first ) &&
6110                  (jQuery.support.checkClone || !rchecked.test( first )) &&
6111                  (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
6112  
6113                  cacheable = true;
6114  
6115                  cacheresults = jQuery.fragments[ first ];
6116                  if ( cacheresults && cacheresults !== 1 ) {
6117                          fragment = cacheresults;
6118                  }
6119          }
6120  
6121          if ( !fragment ) {
6122                  fragment = doc.createDocumentFragment();
6123                  jQuery.clean( args, doc, fragment, scripts );
6124          }
6125  
6126          if ( cacheable ) {
6127                  jQuery.fragments[ first ] = cacheresults ? fragment : 1;
6128          }
6129  
6130          return { fragment: fragment, cacheable: cacheable };
6131  };
6132  
6133  jQuery.fragments = {};
6134  
6135  jQuery.each({
6136          appendTo: "append",
6137          prependTo: "prepend",
6138          insertBefore: "before",
6139          insertAfter: "after",
6140          replaceAll: "replaceWith"
6141  }, function( name, original ) {
6142          jQuery.fn[ name ] = function( selector ) {
6143                  var ret = [],
6144                          insert = jQuery( selector ),
6145                          parent = this.length === 1 && this[0].parentNode;
6146  
6147                  if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
6148                          insert[ original ]( this[0] );
6149                          return this;
6150  
6151                  } else {
6152                          for ( var i = 0, l = insert.length; i < l; i++ ) {
6153                                  var elems = ( i > 0 ? this.clone(true) : this ).get();
6154                                  jQuery( insert[i] )[ original ]( elems );
6155                                  ret = ret.concat( elems );
6156                          }
6157  
6158                          return this.pushStack( ret, name, insert.selector );
6159                  }
6160          };
6161  });
6162  
6163  function getAll( elem ) {
6164          if ( typeof elem.getElementsByTagName !== "undefined" ) {
6165                  return elem.getElementsByTagName( "*" );
6166  
6167          } else if ( typeof elem.querySelectorAll !== "undefined" ) {
6168                  return elem.querySelectorAll( "*" );
6169  
6170          } else {
6171                  return [];
6172          }
6173  }
6174  
6175  // Used in clean, fixes the defaultChecked property
6176  function fixDefaultChecked( elem ) {
6177          if ( elem.type === "checkbox" || elem.type === "radio" ) {
6178                  elem.defaultChecked = elem.checked;
6179          }
6180  }
6181  // Finds all inputs and passes them to fixDefaultChecked
6182  function findInputs( elem ) {
6183          var nodeName = ( elem.nodeName || "" ).toLowerCase();
6184          if ( nodeName === "input" ) {
6185                  fixDefaultChecked( elem );
6186          // Skip scripts, get other children
6187          } else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) {
6188                  jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
6189          }
6190  }
6191  
6192  // Derived From: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js
6193  function shimCloneNode( elem ) {
6194          var div = document.createElement( "div" );
6195          safeFragment.appendChild( div );
6196  
6197          div.innerHTML = elem.outerHTML;
6198          return div.firstChild;
6199  }
6200  
6201  jQuery.extend({
6202          clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6203                  var srcElements,
6204                          destElements,
6205                          i,
6206                          // IE<=8 does not properly clone detached, unknown element nodes
6207                          clone = jQuery.support.html5Clone || !rnoshimcache.test( "<" + elem.nodeName ) ?
6208                                  elem.cloneNode( true ) :
6209                                  shimCloneNode( elem );
6210  
6211                  if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
6212                                  (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6213                          // IE copies events bound via attachEvent when using cloneNode.
6214                          // Calling detachEvent on the clone will also remove the events
6215                          // from the original. In order to get around this, we use some
6216                          // proprietary methods to clear the events. Thanks to MooTools
6217                          // guys for this hotness.
6218  
6219                          cloneFixAttributes( elem, clone );
6220  
6221                          // Using Sizzle here is crazy slow, so we use getElementsByTagName instead
6222                          srcElements = getAll( elem );
6223                          destElements = getAll( clone );
6224  
6225                          // Weird iteration because IE will replace the length property
6226                          // with an element if you are cloning the body and one of the
6227                          // elements on the page has a name or id of "length"
6228                          for ( i = 0; srcElements[i]; ++i ) {
6229                                  // Ensure that the destination node is not null; Fixes #9587
6230                                  if ( destElements[i] ) {
6231                                          cloneFixAttributes( srcElements[i], destElements[i] );
6232                                  }
6233                          }
6234                  }
6235  
6236                  // Copy the events from the original to the clone
6237                  if ( dataAndEvents ) {
6238                          cloneCopyEvent( elem, clone );
6239  
6240                          if ( deepDataAndEvents ) {
6241                                  srcElements = getAll( elem );
6242                                  destElements = getAll( clone );
6243  
6244                                  for ( i = 0; srcElements[i]; ++i ) {
6245                                          cloneCopyEvent( srcElements[i], destElements[i] );
6246                                  }
6247                          }
6248                  }
6249  
6250                  srcElements = destElements = null;
6251  
6252                  // Return the cloned set
6253                  return clone;
6254          },
6255  
6256          clean: function( elems, context, fragment, scripts ) {
6257                  var checkScriptType;
6258  
6259                  context = context || document;
6260  
6261                  // !context.createElement fails in IE with an error but returns typeof 'object'
6262                  if ( typeof context.createElement === "undefined" ) {
6263                          context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
6264                  }
6265  
6266                  var ret = [], j;
6267  
6268                  for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6269                          if ( typeof elem === "number" ) {
6270                                  elem += "";
6271                          }
6272  
6273                          if ( !elem ) {
6274                                  continue;
6275                          }
6276  
6277                          // Convert html string into DOM nodes
6278                          if ( typeof elem === "string" ) {
6279                                  if ( !rhtml.test( elem ) ) {
6280                                          elem = context.createTextNode( elem );
6281                                  } else {
6282                                          // Fix "XHTML"-style tags in all browsers
6283                                          elem = elem.replace(rxhtmlTag, "<$1></$2>");
6284  
6285                                          // Trim whitespace, otherwise indexOf won't work as expected
6286                                          var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),
6287                                                  wrap = wrapMap[ tag ] || wrapMap._default,
6288                                                  depth = wrap[0],
6289                                                  div = context.createElement("div");
6290  
6291                                          // Append wrapper element to unknown element safe doc fragment
6292                                          if ( context === document ) {
6293                                                  // Use the fragment we've already created for this document
6294                                                  safeFragment.appendChild( div );
6295                                          } else {
6296                                                  // Use a fragment created with the owner document
6297                                                  createSafeFragment( context ).appendChild( div );
6298                                          }
6299  
6300                                          // Go to html and back, then peel off extra wrappers
6301                                          div.innerHTML = wrap[1] + elem + wrap[2];
6302  
6303                                          // Move to the right depth
6304                                          while ( depth-- ) {
6305                                                  div = div.lastChild;
6306                                          }
6307  
6308                                          // Remove IE's autoinserted <tbody> from table fragments
6309                                          if ( !jQuery.support.tbody ) {
6310  
6311                                                  // String was a <table>, *may* have spurious <tbody>
6312                                                  var hasBody = rtbody.test(elem),
6313                                                          tbody = tag === "table" && !hasBody ?
6314                                                                  div.firstChild && div.firstChild.childNodes :
6315  
6316                                                                  // String was a bare <thead> or <tfoot>
6317                                                                  wrap[1] === "<table>" && !hasBody ?
6318                                                                          div.childNodes :
6319                                                                          [];
6320  
6321                                                  for ( j = tbody.length - 1; j >= 0 ; --j ) {
6322                                                          if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6323                                                                  tbody[ j ].parentNode.removeChild( tbody[ j ] );
6324                                                          }
6325                                                  }
6326                                          }
6327  
6328                                          // IE completely kills leading whitespace when innerHTML is used
6329                                          if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6330                                                  div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6331                                          }
6332  
6333                                          elem = div.childNodes;
6334                                  }
6335                          }
6336  
6337                          // Resets defaultChecked for any radios and checkboxes
6338                          // about to be appended to the DOM in IE 6/7 (#8060)
6339                          var len;
6340                          if ( !jQuery.support.appendChecked ) {
6341                                  if ( elem[0] && typeof (len = elem.length) === "number" ) {
6342                                          for ( j = 0; j < len; j++ ) {
6343                                                  findInputs( elem[j] );
6344                                          }
6345                                  } else {
6346                                          findInputs( elem );
6347                                  }
6348                          }
6349  
6350                          if ( elem.nodeType ) {
6351                                  ret.push( elem );
6352                          } else {
6353                                  ret = jQuery.merge( ret, elem );
6354                          }
6355                  }
6356  
6357                  if ( fragment ) {
6358                          checkScriptType = function( elem ) {
6359                                  return !elem.type || rscriptType.test( elem.type );
6360                          };
6361                          for ( i = 0; ret[i]; i++ ) {
6362                                  if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
6363                                          scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6364  
6365                                  } else {
6366                                          if ( ret[i].nodeType === 1 ) {
6367                                                  var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6368  
6369                                                  ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6370                                          }
6371                                          fragment.appendChild( ret[i] );
6372                                  }
6373                          }
6374                  }
6375  
6376                  return ret;
6377          },
6378  
6379          cleanData: function( elems ) {
6380                  var data, id,
6381                          cache = jQuery.cache,
6382                          special = jQuery.event.special,
6383                          deleteExpando = jQuery.support.deleteExpando;
6384  
6385                  for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6386                          if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6387                                  continue;
6388                          }
6389  
6390                          id = elem[ jQuery.expando ];
6391  
6392                          if ( id ) {
6393                                  data = cache[ id ];
6394  
6395                                  if ( data && data.events ) {
6396                                          for ( var type in data.events ) {
6397                                                  if ( special[ type ] ) {
6398                                                          jQuery.event.remove( elem, type );
6399  
6400                                                  // This is a shortcut to avoid jQuery.event.remove's overhead
6401                                                  } else {
6402                                                          jQuery.removeEvent( elem, type, data.handle );
6403                                                  }
6404                                          }
6405  
6406                                          // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6407                                          if ( data.handle ) {
6408                                                  data.handle.elem = null;
6409                                          }
6410                                  }
6411  
6412                                  if ( deleteExpando ) {
6413                                          delete elem[ jQuery.expando ];
6414  
6415                                  } else if ( elem.removeAttribute ) {
6416                                          elem.removeAttribute( jQuery.expando );
6417                                  }
6418  
6419                                  delete cache[ id ];
6420                          }
6421                  }
6422          }
6423  });
6424  
6425  function evalScript( i, elem ) {
6426          if ( elem.src ) {
6427                  jQuery.ajax({
6428                          url: elem.src,
6429                          async: false,
6430                          dataType: "script"
6431                  });
6432          } else {
6433                  jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
6434          }
6435  
6436          if ( elem.parentNode ) {
6437                  elem.parentNode.removeChild( elem );
6438          }
6439  }
6440  
6441  
6442  
6443  
6444  var ralpha = /alpha\([^)]*\)/i,
6445          ropacity = /opacity=([^)]*)/,
6446          // fixed for IE9, see #8346
6447          rupper = /([A-Z]|^ms)/g,
6448          rnumpx = /^-?\d+(?:px)?$/i,
6449          rnum = /^-?\d/,
6450          rrelNum = /^([\-+])=([\-+.\de]+)/,
6451  
6452          cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6453          cssWidth = [ "Left", "Right" ],
6454          cssHeight = [ "Top", "Bottom" ],
6455          curCSS,
6456  
6457          getComputedStyle,
6458          currentStyle;
6459  
6460  jQuery.fn.css = function( name, value ) {
6461          // Setting 'undefined' is a no-op
6462          if ( arguments.length === 2 && value === undefined ) {
6463                  return this;
6464          }
6465  
6466          return jQuery.access( this, name, value, true, function( elem, name, value ) {
6467                  return value !== undefined ?
6468                          jQuery.style( elem, name, value ) :
6469                          jQuery.css( elem, name );
6470          });
6471  };
6472  
6473  jQuery.extend({
6474          // Add in style property hooks for overriding the default
6475          // behavior of getting and setting a style property
6476          cssHooks: {
6477                  opacity: {
6478                          get: function( elem, computed ) {
6479                                  if ( computed ) {
6480                                          // We should always get a number back from opacity
6481                                          var ret = curCSS( elem, "opacity", "opacity" );
6482                                          return ret === "" ? "1" : ret;
6483  
6484                                  } else {
6485                                          return elem.style.opacity;
6486                                  }
6487                          }
6488                  }
6489          },
6490  
6491          // Exclude the following css properties to add px
6492          cssNumber: {
6493                  "fillOpacity": true,
6494                  "fontWeight": true,
6495                  "lineHeight": true,
6496                  "opacity": true,
6497                  "orphans": true,
6498                  "widows": true,
6499                  "zIndex": true,
6500                  "zoom": true
6501          },
6502  
6503          // Add in properties whose names you wish to fix before
6504          // setting or getting the value
6505          cssProps: {
6506                  // normalize float css property
6507                  "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6508          },
6509  
6510          // Get and set the style property on a DOM Node
6511          style: function( elem, name, value, extra ) {
6512                  // Don't set styles on text and comment nodes
6513                  if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6514                          return;
6515                  }
6516  
6517                  // Make sure that we're working with the right name
6518                  var ret, type, origName = jQuery.camelCase( name ),
6519                          style = elem.style, hooks = jQuery.cssHooks[ origName ];
6520  
6521                  name = jQuery.cssProps[ origName ] || origName;
6522  
6523                  // Check if we're setting a value
6524                  if ( value !== undefined ) {
6525                          type = typeof value;
6526  
6527                          // convert relative number strings (+= or -=) to relative numbers. #7345
6528                          if ( type === "string" && (ret = rrelNum.exec( value )) ) {
6529                                  value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
6530                                  // Fixes bug #9237
6531                                  type = "number";
6532                          }
6533  
6534                          // Make sure that NaN and null values aren't set. See: #7116
6535                          if ( value == null || type === "number" && isNaN( value ) ) {
6536                                  return;
6537                          }
6538  
6539                          // If a number was passed in, add 'px' to the (except for certain CSS properties)
6540                          if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6541                                  value += "px";
6542                          }
6543  
6544                          // If a hook was provided, use that value, otherwise just set the specified value
6545                          if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
6546                                  // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6547                                  // Fixes bug #5509
6548                                  try {
6549                                          style[ name ] = value;
6550                                  } catch(e) {}
6551                          }
6552  
6553                  } else {
6554                          // If a hook was provided get the non-computed value from there
6555                          if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6556                                  return ret;
6557                          }
6558  
6559                          // Otherwise just get the value from the style object
6560                          return style[ name ];
6561                  }
6562          },
6563  
6564          css: function( elem, name, extra ) {
6565                  var ret, hooks;
6566  
6567                  // Make sure that we're working with the right name
6568                  name = jQuery.camelCase( name );
6569                  hooks = jQuery.cssHooks[ name ];
6570                  name = jQuery.cssProps[ name ] || name;
6571  
6572                  // cssFloat needs a special treatment
6573                  if ( name === "cssFloat" ) {
6574                          name = "float";
6575                  }
6576  
6577                  // If a hook was provided get the computed value from there
6578                  if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6579                          return ret;
6580  
6581                  // Otherwise, if a way to get the computed value exists, use that
6582                  } else if ( curCSS ) {
6583                          return curCSS( elem, name );
6584                  }
6585          },
6586  
6587          // A method for quickly swapping in/out CSS properties to get correct calculations
6588          swap: function( elem, options, callback ) {
6589                  var old = {};
6590  
6591                  // Remember the old values, and insert the new ones
6592                  for ( var name in options ) {
6593                          old[ name ] = elem.style[ name ];
6594                          elem.style[ name ] = options[ name ];
6595                  }
6596  
6597                  callback.call( elem );
6598  
6599                  // Revert the old values
6600                  for ( name in options ) {
6601                          elem.style[ name ] = old[ name ];
6602                  }
6603          }
6604  });
6605  
6606  // DEPRECATED, Use jQuery.css() instead
6607  jQuery.curCSS = jQuery.css;
6608  
6609  jQuery.each(["height", "width"], function( i, name ) {
6610          jQuery.cssHooks[ name ] = {
6611                  get: function( elem, computed, extra ) {
6612                          var val;
6613  
6614                          if ( computed ) {
6615                                  if ( elem.offsetWidth !== 0 ) {
6616                                          return getWH( elem, name, extra );
6617                                  } else {
6618                                          jQuery.swap( elem, cssShow, function() {
6619                                                  val = getWH( elem, name, extra );
6620                                          });
6621                                  }
6622  
6623                                  return val;
6624                          }
6625                  },
6626  
6627                  set: function( elem, value ) {
6628                          if ( rnumpx.test( value ) ) {
6629                                  // ignore negative width and height values #1599
6630                                  value = parseFloat( value );
6631  
6632                                  if ( value >= 0 ) {
6633                                          return value + "px";
6634                                  }
6635  
6636                          } else {
6637                                  return value;
6638                          }
6639                  }
6640          };
6641  });
6642  
6643  if ( !jQuery.support.opacity ) {
6644          jQuery.cssHooks.opacity = {
6645                  get: function( elem, computed ) {
6646                          // IE uses filters for opacity
6647                          return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
6648                                  ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6649                                  computed ? "1" : "";
6650                  },
6651  
6652                  set: function( elem, value ) {
6653                          var style = elem.style,
6654                                  currentStyle = elem.currentStyle,
6655                                  opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
6656                                  filter = currentStyle && currentStyle.filter || style.filter || "";
6657  
6658                          // IE has trouble with opacity if it does not have layout
6659                          // Force it by setting the zoom level
6660                          style.zoom = 1;
6661  
6662                          // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
6663                          if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
6664  
6665                                  // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
6666                                  // if "filter:" is present at all, clearType is disabled, we want to avoid this
6667                                  // style.removeAttribute is IE Only, but so apparently is this code path...
6668                                  style.removeAttribute( "filter" );
6669  
6670                                  // if there there is no filter style applied in a css rule, we are done
6671                                  if ( currentStyle && !currentStyle.filter ) {
6672                                          return;
6673                                  }
6674                          }
6675  
6676                          // otherwise, set new filter values
6677                          style.filter = ralpha.test( filter ) ?
6678                                  filter.replace( ralpha, opacity ) :
6679                                  filter + " " + opacity;
6680                  }
6681          };
6682  }
6683  
6684  jQuery(function() {
6685          // This hook cannot be added until DOM ready because the support test
6686          // for it is not run until after DOM ready
6687          if ( !jQuery.support.reliableMarginRight ) {
6688                  jQuery.cssHooks.marginRight = {
6689                          get: function( elem, computed ) {
6690                                  // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6691                                  // Work around by temporarily setting element display to inline-block
6692                                  var ret;
6693                                  jQuery.swap( elem, { "display": "inline-block" }, function() {
6694                                          if ( computed ) {
6695                                                  ret = curCSS( elem, "margin-right", "marginRight" );
6696                                          } else {
6697                                                  ret = elem.style.marginRight;
6698                                          }
6699                                  });
6700                                  return ret;
6701                          }
6702                  };
6703          }
6704  });
6705  
6706  if ( document.defaultView && document.defaultView.getComputedStyle ) {
6707          getComputedStyle = function( elem, name ) {
6708                  var ret, defaultView, computedStyle;
6709  
6710                  name = name.replace( rupper, "-$1" ).toLowerCase();
6711  
6712                  if ( (defaultView = elem.ownerDocument.defaultView) &&
6713                                  (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6714                          ret = computedStyle.getPropertyValue( name );
6715                          if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6716                                  ret = jQuery.style( elem, name );
6717                          }
6718                  }
6719  
6720                  return ret;
6721          };
6722  }
6723  
6724  if ( document.documentElement.currentStyle ) {
6725          currentStyle = function( elem, name ) {
6726                  var left, rsLeft, uncomputed,
6727                          ret = elem.currentStyle && elem.currentStyle[ name ],
6728                          style = elem.style;
6729  
6730                  // Avoid setting ret to empty string here
6731                  // so we don't default to auto
6732                  if ( ret === null && style && (uncomputed = style[ name ]) ) {
6733                          ret = uncomputed;
6734                  }
6735  
6736                  // From the awesome hack by Dean Edwards
6737                  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6738  
6739                  // If we're not dealing with a regular pixel number
6740                  // but a number that has a weird ending, we need to convert it to pixels
6741                  if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6742  
6743                          // Remember the original values
6744                          left = style.left;
6745                          rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
6746  
6747                          // Put in the new values to get a computed value out
6748                          if ( rsLeft ) {
6749                                  elem.runtimeStyle.left = elem.currentStyle.left;
6750                          }
6751                          style.left = name === "fontSize" ? "1em" : ( ret || 0 );
6752                          ret = style.pixelLeft + "px";
6753  
6754                          // Revert the changed values
6755                          style.left = left;
6756                          if ( rsLeft ) {
6757                                  elem.runtimeStyle.left = rsLeft;
6758                          }
6759                  }
6760  
6761                  return ret === "" ? "auto" : ret;
6762          };
6763  }
6764  
6765  curCSS = getComputedStyle || currentStyle;
6766  
6767  function getWH( elem, name, extra ) {
6768  
6769          // Start with offset property
6770          var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6771                  which = name === "width" ? cssWidth : cssHeight,
6772                  i = 0,
6773                  len = which.length;
6774  
6775          if ( val > 0 ) {
6776                  if ( extra !== "border" ) {
6777                          for ( ; i < len; i++ ) {
6778                                  if ( !extra ) {
6779                                          val -= parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6780                                  }
6781                                  if ( extra === "margin" ) {
6782                                          val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6783                                  } else {
6784                                          val -= parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6785                                  }
6786                          }
6787                  }
6788  
6789                  return val + "px";
6790          }
6791  
6792          // Fall back to computed then uncomputed css if necessary
6793          val = curCSS( elem, name, name );
6794          if ( val < 0 || val == null ) {
6795                  val = elem.style[ name ] || 0;
6796          }
6797          // Normalize "", auto, and prepare for extra
6798          val = parseFloat( val ) || 0;
6799  
6800          // Add padding, border, margin
6801          if ( extra ) {
6802                  for ( ; i < len; i++ ) {
6803                          val += parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6804                          if ( extra !== "padding" ) {
6805                                  val += parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6806                          }
6807                          if ( extra === "margin" ) {
6808                                  val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6809                          }
6810                  }
6811          }
6812  
6813          return val + "px";
6814  }
6815  
6816  if ( jQuery.expr && jQuery.expr.filters ) {
6817          jQuery.expr.filters.hidden = function( elem ) {
6818                  var width = elem.offsetWidth,
6819                          height = elem.offsetHeight;
6820  
6821                  return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
6822          };
6823  
6824          jQuery.expr.filters.visible = function( elem ) {
6825                  return !jQuery.expr.filters.hidden( elem );
6826          };
6827  }
6828  
6829  
6830  
6831  
6832  var r20 = /%20/g,
6833          rbracket = /\[\]$/,
6834          rCRLF = /\r?\n/g,
6835          rhash = /#.*$/,
6836          rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6837          rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
6838          // #7653, #8125, #8152: local protocol detection
6839          rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
6840          rnoContent = /^(?:GET|HEAD)$/,
6841          rprotocol = /^\/\//,
6842          rquery = /\?/,
6843          rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
6844          rselectTextarea = /^(?:select|textarea)/i,
6845          rspacesAjax = /\s+/,
6846          rts = /([?&])_=[^&]*/,
6847          rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6848  
6849          // Keep a copy of the old load method
6850          _load = jQuery.fn.load,
6851  
6852          /* Prefilters
6853           * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6854           * 2) These are called:
6855           *    - BEFORE asking for a transport
6856           *    - AFTER param serialization (s.data is a string if s.processData is true)
6857           * 3) key is the dataType
6858           * 4) the catchall symbol "*" can be used
6859           * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6860           */
6861          prefilters = {},
6862  
6863          /* Transports bindings
6864           * 1) key is the dataType
6865           * 2) the catchall symbol "*" can be used
6866           * 3) selection will start with transport dataType and THEN go to "*" if needed
6867           */
6868          transports = {},
6869  
6870          // Document location
6871          ajaxLocation,
6872  
6873          // Document location segments
6874          ajaxLocParts,
6875  
6876          // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
6877          allTypes = ["*/"] + ["*"];
6878  
6879  // #8138, IE may throw an exception when accessing
6880  // a field from window.location if document.domain has been set
6881  try {
6882          ajaxLocation = location.href;
6883  } catch( e ) {
6884          // Use the href attribute of an A element
6885          // since IE will modify it given document.location
6886          ajaxLocation = document.createElement( "a" );
6887          ajaxLocation.href = "";
6888          ajaxLocation = ajaxLocation.href;
6889  }
6890  
6891  // Segment location into parts
6892  ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
6893  
6894  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6895  function addToPrefiltersOrTransports( structure ) {
6896  
6897          // dataTypeExpression is optional and defaults to "*"
6898          return function( dataTypeExpression, func ) {
6899  
6900                  if ( typeof dataTypeExpression !== "string" ) {
6901                          func = dataTypeExpression;
6902                          dataTypeExpression = "*";
6903                  }
6904  
6905                  if ( jQuery.isFunction( func ) ) {
6906                          var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6907                                  i = 0,
6908                                  length = dataTypes.length,
6909                                  dataType,
6910                                  list,
6911                                  placeBefore;
6912  
6913                          // For each dataType in the dataTypeExpression
6914                          for ( ; i < length; i++ ) {
6915                                  dataType = dataTypes[ i ];
6916                                  // We control if we're asked to add before
6917                                  // any existing element
6918                                  placeBefore = /^\+/.test( dataType );
6919                                  if ( placeBefore ) {
6920                                          dataType = dataType.substr( 1 ) || "*";
6921                                  }
6922                                  list = structure[ dataType ] = structure[ dataType ] || [];
6923                                  // then we add to the structure accordingly
6924                                  list[ placeBefore ? "unshift" : "push" ]( func );
6925                          }
6926                  }
6927          };
6928  }
6929  
6930  // Base inspection function for prefilters and transports
6931  function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6932                  dataType /* internal */, inspected /* internal */ ) {
6933  
6934          dataType = dataType || options.dataTypes[ 0 ];
6935          inspected = inspected || {};
6936  
6937          inspected[ dataType ] = true;
6938  
6939          var list = structure[ dataType ],
6940                  i = 0,
6941                  length = list ? list.length : 0,
6942                  executeOnly = ( structure === prefilters ),
6943                  selection;
6944  
6945          for ( ; i < length && ( executeOnly || !selection ); i++ ) {
6946                  selection = list[ i ]( options, originalOptions, jqXHR );
6947                  // If we got redirected to another dataType
6948                  // we try there if executing only and not done already
6949                  if ( typeof selection === "string" ) {
6950                          if ( !executeOnly || inspected[ selection ] ) {
6951                                  selection = undefined;
6952                          } else {
6953                                  options.dataTypes.unshift( selection );
6954                                  selection = inspectPrefiltersOrTransports(
6955                                                  structure, options, originalOptions, jqXHR, selection, inspected );
6956                          }
6957                  }
6958          }
6959          // If we're only executing or nothing was selected
6960          // we try the catchall dataType if not done already
6961          if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
6962                  selection = inspectPrefiltersOrTransports(
6963                                  structure, options, originalOptions, jqXHR, "*", inspected );
6964          }
6965          // unnecessary when only executing (prefilters)
6966          // but it'll be ignored by the caller in that case
6967          return selection;
6968  }
6969  
6970  // A special extend for ajax options
6971  // that takes "flat" options (not to be deep extended)
6972  // Fixes #9887
6973  function ajaxExtend( target, src ) {
6974          var key, deep,
6975                  flatOptions = jQuery.ajaxSettings.flatOptions || {};
6976          for ( key in src ) {
6977                  if ( src[ key ] !== undefined ) {
6978                          ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
6979                  }
6980          }
6981          if ( deep ) {
6982                  jQuery.extend( true, target, deep );
6983          }
6984  }
6985  
6986  jQuery.fn.extend({
6987          load: function( url, params, callback ) {
6988                  if ( typeof url !== "string" && _load ) {
6989                          return _load.apply( this, arguments );
6990  
6991                  // Don't do a request if no elements are being requested
6992                  } else if ( !this.length ) {
6993                          return this;
6994                  }
6995  
6996                  var off = url.indexOf( " " );
6997                  if ( off >= 0 ) {
6998                          var selector = url.slice( off, url.length );
6999                          url = url.slice( 0, off );
7000                  }
7001  
7002                  // Default to a GET request
7003                  var type = "GET";
7004  
7005                  // If the second parameter was provided
7006                  if ( params ) {
7007                          // If it's a function
7008                          if ( jQuery.isFunction( params ) ) {
7009                                  // We assume that it's the callback
7010                                  callback = params;
7011                                  params = undefined;
7012  
7013                          // Otherwise, build a param string
7014                          } else if ( typeof params === "object" ) {
7015                                  params = jQuery.param( params, jQuery.ajaxSettings.traditional );
7016                                  type = "POST";
7017                          }
7018                  }
7019  
7020                  var self = this;
7021  
7022                  // Request the remote document
7023                  jQuery.ajax({
7024                          url: url,
7025                          type: type,
7026                          dataType: "html",
7027                          data: params,
7028                          // Complete callback (responseText is used internally)
7029                          complete: function( jqXHR, status, responseText ) {
7030                                  // Store the response as specified by the jqXHR object
7031                                  responseText = jqXHR.responseText;
7032                                  // If successful, inject the HTML into all the matched elements
7033                                  if ( jqXHR.isResolved() ) {
7034                                          // #4825: Get the actual response in case
7035                                          // a dataFilter is present in ajaxSettings
7036                                          jqXHR.done(function( r ) {
7037                                                  responseText = r;
7038                                          });
7039                                          // See if a selector was specified
7040                                          self.html( selector ?
7041                                                  // Create a dummy div to hold the results
7042                                                  jQuery("<div>")
7043                                                          // inject the contents of the document in, removing the scripts
7044                                                          // to avoid any 'Permission Denied' errors in IE
7045                                                          .append(responseText.replace(rscript, ""))
7046  
7047                                                          // Locate the specified elements
7048                                                          .find(selector) :
7049  
7050                                                  // If not, just inject the full result
7051                                                  responseText );
7052                                  }
7053  
7054                                  if ( callback ) {
7055                                          self.each( callback, [ responseText, status, jqXHR ] );
7056                                  }
7057                          }
7058                  });
7059  
7060                  return this;
7061          },
7062  
7063          serialize: function() {
7064                  return jQuery.param( this.serializeArray() );
7065          },
7066  
7067          serializeArray: function() {
7068                  return this.map(function(){
7069                          return this.elements ? jQuery.makeArray( this.elements ) : this;
7070                  })
7071                  .filter(function(){
7072                          return this.name && !this.disabled &&
7073                                  ( this.checked || rselectTextarea.test( this.nodeName ) ||
7074                                          rinput.test( this.type ) );
7075                  })
7076                  .map(function( i, elem ){
7077                          var val = jQuery( this ).val();
7078  
7079                          return val == null ?
7080                                  null :
7081                                  jQuery.isArray( val ) ?
7082                                          jQuery.map( val, function( val, i ){
7083                                                  return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
7084                                          }) :
7085                                          { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
7086                  }).get();
7087          }
7088  });
7089  
7090  // Attach a bunch of functions for handling common AJAX events
7091  jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
7092          jQuery.fn[ o ] = function( f ){
7093                  return this.on( o, f );
7094          };
7095  });
7096  
7097  jQuery.each( [ "get", "post" ], function( i, method ) {
7098          jQuery[ method ] = function( url, data, callback, type ) {
7099                  // shift arguments if data argument was omitted
7100                  if ( jQuery.isFunction( data ) ) {
7101                          type = type || callback;
7102                          callback = data;
7103                          data = undefined;
7104                  }
7105  
7106                  return jQuery.ajax({
7107                          type: method,
7108                          url: url,
7109                          data: data,
7110                          success: callback,
7111                          dataType: type
7112                  });
7113          };
7114  });
7115  
7116  jQuery.extend({
7117  
7118          getScript: function( url, callback ) {
7119                  return jQuery.get( url, undefined, callback, "script" );
7120          },
7121  
7122          getJSON: function( url, data, callback ) {
7123                  return jQuery.get( url, data, callback, "json" );
7124          },
7125  
7126          // Creates a full fledged settings object into target
7127          // with both ajaxSettings and settings fields.
7128          // If target is omitted, writes into ajaxSettings.
7129          ajaxSetup: function( target, settings ) {
7130                  if ( settings ) {
7131                          // Building a settings object
7132                          ajaxExtend( target, jQuery.ajaxSettings );
7133                  } else {
7134                          // Extending ajaxSettings
7135                          settings = target;
7136                          target = jQuery.ajaxSettings;
7137                  }
7138                  ajaxExtend( target, settings );
7139                  return target;
7140          },
7141  
7142          ajaxSettings: {
7143                  url: ajaxLocation,
7144                  isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
7145                  global: true,
7146                  type: "GET",
7147                  contentType: "application/x-www-form-urlencoded",
7148                  processData: true,
7149                  async: true,
7150                  /*
7151                  timeout: 0,
7152                  data: null,
7153                  dataType: null,
7154                  username: null,
7155                  password: null,
7156                  cache: null,
7157                  traditional: false,
7158                  headers: {},
7159                  */
7160  
7161                  accepts: {
7162                          xml: "application/xml, text/xml",
7163                          html: "text/html",
7164                          text: "text/plain",
7165                          json: "application/json, text/javascript",
7166                          "*": allTypes
7167                  },
7168  
7169                  contents: {
7170                          xml: /xml/,
7171                          html: /html/,
7172                          json: /json/
7173                  },
7174  
7175                  responseFields: {
7176                          xml: "responseXML",
7177                          text: "responseText"
7178                  },
7179  
7180                  // List of data converters
7181                  // 1) key format is "source_type destination_type" (a single space in-between)
7182                  // 2) the catchall symbol "*" can be used for source_type
7183                  converters: {
7184  
7185                          // Convert anything to text
7186                          "* text": window.String,
7187  
7188                          // Text to html (true = no transformation)
7189                          "text html": true,
7190  
7191                          // Evaluate text as a json expression
7192                          "text json": jQuery.parseJSON,
7193  
7194                          // Parse text as xml
7195                          "text xml": jQuery.parseXML
7196                  },
7197  
7198                  // For options that shouldn't be deep extended:
7199                  // you can add your own custom options here if
7200                  // and when you create one that shouldn't be
7201                  // deep extended (see ajaxExtend)
7202                  flatOptions: {
7203                          context: true,
7204                          url: true
7205                  }
7206          },
7207  
7208          ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
7209          ajaxTransport: addToPrefiltersOrTransports( transports ),
7210  
7211          // Main method
7212          ajax: function( url, options ) {
7213  
7214                  // If url is an object, simulate pre-1.5 signature
7215                  if ( typeof url === "object" ) {
7216                          options = url;
7217                          url = undefined;
7218                  }
7219  
7220                  // Force options to be an object
7221                  options = options || {};
7222  
7223                  var // Create the final options object
7224                          s = jQuery.ajaxSetup( {}, options ),
7225                          // Callbacks context
7226                          callbackContext = s.context || s,
7227                          // Context for global events
7228                          // It's the callbackContext if one was provided in the options
7229                          // and if it's a DOM node or a jQuery collection
7230                          globalEventContext = callbackContext !== s &&
7231                                  ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
7232                                                  jQuery( callbackContext ) : jQuery.event,
7233                          // Deferreds
7234                          deferred = jQuery.Deferred(),
7235                          completeDeferred = jQuery.Callbacks( "once memory" ),
7236                          // Status-dependent callbacks
7237                          statusCode = s.statusCode || {},
7238                          // ifModified key
7239                          ifModifiedKey,
7240                          // Headers (they are sent all at once)
7241                          requestHeaders = {},
7242                          requestHeadersNames = {},
7243                          // Response headers
7244                          responseHeadersString,
7245                          responseHeaders,
7246                          // transport
7247                          transport,
7248                          // timeout handle
7249                          timeoutTimer,
7250                          // Cross-domain detection vars
7251                          parts,
7252                          // The jqXHR state
7253                          state = 0,
7254                          // To know if global events are to be dispatched
7255                          fireGlobals,
7256                          // Loop variable
7257                          i,
7258                          // Fake xhr
7259                          jqXHR = {
7260  
7261                                  readyState: 0,
7262  
7263                                  // Caches the header
7264                                  setRequestHeader: function( name, value ) {
7265                                          if ( !state ) {
7266                                                  var lname = name.toLowerCase();
7267                                                  name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
7268                                                  requestHeaders[ name ] = value;
7269                                          }
7270                                          return this;
7271                                  },
7272  
7273                                  // Raw string
7274                                  getAllResponseHeaders: function() {
7275                                          return state === 2 ? responseHeadersString : null;
7276                                  },
7277  
7278                                  // Builds headers hashtable if needed
7279                                  getResponseHeader: function( key ) {
7280                                          var match;
7281                                          if ( state === 2 ) {
7282                                                  if ( !responseHeaders ) {
7283                                                          responseHeaders = {};
7284                                                          while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7285                                                                  responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7286                                                          }
7287                                                  }
7288                                                  match = responseHeaders[ key.toLowerCase() ];
7289                                          }
7290                                          return match === undefined ? null : match;
7291                                  },
7292  
7293                                  // Overrides response content-type header
7294                                  overrideMimeType: function( type ) {
7295                                          if ( !state ) {
7296                                                  s.mimeType = type;
7297                                          }
7298                                          return this;
7299                                  },
7300  
7301                                  // Cancel the request
7302                                  abort: function( statusText ) {
7303                                          statusText = statusText || "abort";
7304                                          if ( transport ) {
7305                                                  transport.abort( statusText );
7306                                          }
7307                                          done( 0, statusText );
7308                                          return this;
7309                                  }
7310                          };
7311  
7312                  // Callback for when everything is done
7313                  // It is defined here because jslint complains if it is declared
7314                  // at the end of the function (which would be more logical and readable)
7315                  function done( status, nativeStatusText, responses, headers ) {
7316  
7317                          // Called once
7318                          if ( state === 2 ) {
7319                                  return;
7320                          }
7321  
7322                          // State is "done" now
7323                          state = 2;
7324  
7325                          // Clear timeout if it exists
7326                          if ( timeoutTimer ) {
7327                                  clearTimeout( timeoutTimer );
7328                          }
7329  
7330                          // Dereference transport for early garbage collection
7331                          // (no matter how long the jqXHR object will be used)
7332                          transport = undefined;
7333  
7334                          // Cache response headers
7335                          responseHeadersString = headers || "";
7336  
7337                          // Set readyState
7338                          jqXHR.readyState = status > 0 ? 4 : 0;
7339  
7340                          var isSuccess,
7341                                  success,
7342                                  error,
7343                                  statusText = nativeStatusText,
7344                                  response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7345                                  lastModified,
7346                                  etag;
7347  
7348                          // If successful, handle type chaining
7349                          if ( status >= 200 && status < 300 || status === 304 ) {
7350  
7351                                  // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7352                                  if ( s.ifModified ) {
7353  
7354                                          if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7355                                                  jQuery.lastModified[ ifModifiedKey ] = lastModified;
7356                                          }
7357                                          if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7358                                                  jQuery.etag[ ifModifiedKey ] = etag;
7359                                          }
7360                                  }
7361  
7362                                  // If not modified
7363                                  if ( status === 304 ) {
7364  
7365                                          statusText = "notmodified";
7366                                          isSuccess = true;
7367  
7368                                  // If we have data
7369                                  } else {
7370  
7371                                          try {
7372                                                  success = ajaxConvert( s, response );
7373                                                  statusText = "success";
7374                                                  isSuccess = true;
7375                                          } catch(e) {
7376                                                  // We have a parsererror
7377                                                  statusText = "parsererror";
7378                                                  error = e;
7379                                          }
7380                                  }
7381                          } else {
7382                                  // We extract error from statusText
7383                                  // then normalize statusText and status for non-aborts
7384                                  error = statusText;
7385                                  if ( !statusText || status ) {
7386                                          statusText = "error";
7387                                          if ( status < 0 ) {
7388                                                  status = 0;
7389                                          }
7390                                  }
7391                          }
7392  
7393                          // Set data for the fake xhr object
7394                          jqXHR.status = status;
7395                          jqXHR.statusText = "" + ( nativeStatusText || statusText );
7396  
7397                          // Success/Error
7398                          if ( isSuccess ) {
7399                                  deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7400                          } else {
7401                                  deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7402                          }
7403  
7404                          // Status-dependent callbacks
7405                          jqXHR.statusCode( statusCode );
7406                          statusCode = undefined;
7407  
7408                          if ( fireGlobals ) {
7409                                  globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7410                                                  [ jqXHR, s, isSuccess ? success : error ] );
7411                          }
7412  
7413                          // Complete
7414                          completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
7415  
7416                          if ( fireGlobals ) {
7417                                  globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
7418                                  // Handle the global AJAX counter
7419                                  if ( !( --jQuery.active ) ) {
7420                                          jQuery.event.trigger( "ajaxStop" );
7421                                  }
7422                          }
7423                  }
7424  
7425                  // Attach deferreds
7426                  deferred.promise( jqXHR );
7427                  jqXHR.success = jqXHR.done;
7428                  jqXHR.error = jqXHR.fail;
7429                  jqXHR.complete = completeDeferred.add;
7430  
7431                  // Status-dependent callbacks
7432                  jqXHR.statusCode = function( map ) {
7433                          if ( map ) {
7434                                  var tmp;
7435                                  if ( state < 2 ) {
7436                                          for ( tmp in map ) {
7437                                                  statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7438                                          }
7439                                  } else {
7440                                          tmp = map[ jqXHR.status ];
7441                                          jqXHR.then( tmp, tmp );
7442                                  }
7443                          }
7444                          return this;
7445                  };
7446  
7447                  // Remove hash character (#7531: and string promotion)
7448                  // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7449                  // We also use the url parameter if available
7450                  s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7451  
7452                  // Extract dataTypes list
7453                  s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
7454  
7455                  // Determine if a cross-domain request is in order
7456                  if ( s.crossDomain == null ) {
7457                          parts = rurl.exec( s.url.toLowerCase() );
7458                          s.crossDomain = !!( parts &&
7459                                  ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
7460                                          ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7461                                                  ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7462                          );
7463                  }
7464  
7465                  // Convert data if not already a string
7466                  if ( s.data && s.processData && typeof s.data !== "string" ) {
7467                          s.data = jQuery.param( s.data, s.traditional );
7468                  }
7469  
7470                  // Apply prefilters
7471                  inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7472  
7473                  // If request was aborted inside a prefiler, stop there
7474                  if ( state === 2 ) {
7475                          return false;
7476                  }
7477  
7478                  // We can fire global events as of now if asked to
7479                  fireGlobals = s.global;
7480  
7481                  // Uppercase the type
7482                  s.type = s.type.toUpperCase();
7483  
7484                  // Determine if request has content
7485                  s.hasContent = !rnoContent.test( s.type );
7486  
7487                  // Watch for a new set of requests
7488                  if ( fireGlobals && jQuery.active++ === 0 ) {
7489                          jQuery.event.trigger( "ajaxStart" );
7490                  }
7491  
7492                  // More options handling for requests with no content
7493                  if ( !s.hasContent ) {
7494  
7495                          // If data is available, append data to url
7496                          if ( s.data ) {
7497                                  s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7498                                  // #9682: remove data so that it's not used in an eventual retry
7499                                  delete s.data;
7500                          }
7501  
7502                          // Get ifModifiedKey before adding the anti-cache parameter
7503                          ifModifiedKey = s.url;
7504  
7505                          // Add anti-cache in url if needed
7506                          if ( s.cache === false ) {
7507  
7508                                  var ts = jQuery.now(),
7509                                          // try replacing _= if it is there
7510                                          ret = s.url.replace( rts, "$1_=" + ts );
7511  
7512                                  // if nothing was replaced, add timestamp to the end
7513                                  s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7514                          }
7515                  }
7516  
7517                  // Set the correct header, if data is being sent
7518                  if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
7519                          jqXHR.setRequestHeader( "Content-Type", s.contentType );
7520                  }
7521  
7522                  // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7523                  if ( s.ifModified ) {
7524                          ifModifiedKey = ifModifiedKey || s.url;
7525                          if ( jQuery.lastModified[ ifModifiedKey ] ) {
7526                                  jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7527                          }
7528                          if ( jQuery.etag[ ifModifiedKey ] ) {
7529                                  jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7530                          }
7531                  }
7532  
7533                  // Set the Accepts header for the server, depending on the dataType
7534                  jqXHR.setRequestHeader(
7535                          "Accept",
7536                          s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7537                                  s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
7538                                  s.accepts[ "*" ]
7539                  );
7540  
7541                  // Check for headers option
7542                  for ( i in s.headers ) {
7543                          jqXHR.setRequestHeader( i, s.headers[ i ] );
7544                  }
7545  
7546                  // Allow custom headers/mimetypes and early abort
7547                  if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
7548                                  // Abort if not done already
7549                                  jqXHR.abort();
7550                                  return false;
7551  
7552                  }
7553  
7554                  // Install callbacks on deferreds
7555                  for ( i in { success: 1, error: 1, complete: 1 } ) {
7556                          jqXHR[ i ]( s[ i ] );
7557                  }
7558  
7559                  // Get transport
7560                  transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7561  
7562                  // If no transport, we auto-abort
7563                  if ( !transport ) {
7564                          done( -1, "No Transport" );
7565                  } else {
7566                          jqXHR.readyState = 1;
7567                          // Send global event
7568                          if ( fireGlobals ) {
7569                                  globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7570                          }
7571                          // Timeout
7572                          if ( s.async && s.timeout > 0 ) {
7573                                  timeoutTimer = setTimeout( function(){
7574                                          jqXHR.abort( "timeout" );
7575                                  }, s.timeout );
7576                          }
7577  
7578                          try {
7579                                  state = 1;
7580                                  transport.send( requestHeaders, done );
7581                          } catch (e) {
7582                                  // Propagate exception as error if not done
7583                                  if ( state < 2 ) {
7584                                          done( -1, e );
7585                                  // Simply rethrow otherwise
7586                                  } else {
7587                                          throw e;
7588                                  }
7589                          }
7590                  }
7591  
7592                  return jqXHR;
7593          },
7594  
7595          // Serialize an array of form elements or a set of
7596          // key/values into a query string
7597          param: function( a, traditional ) {
7598                  var s = [],
7599                          add = function( key, value ) {
7600                                  // If value is a function, invoke it and return its value
7601                                  value = jQuery.isFunction( value ) ? value() : value;
7602                                  s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7603                          };
7604  
7605                  // Set traditional to true for jQuery <= 1.3.2 behavior.
7606                  if ( traditional === undefined ) {
7607                          traditional = jQuery.ajaxSettings.traditional;
7608                  }
7609  
7610                  // If an array was passed in, assume that it is an array of form elements.
7611                  if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7612                          // Serialize the form elements
7613                          jQuery.each( a, function() {
7614                                  add( this.name, this.value );
7615                          });
7616  
7617                  } else {
7618                          // If traditional, encode the "old" way (the way 1.3.2 or older
7619                          // did it), otherwise encode params recursively.
7620                          for ( var prefix in a ) {
7621                                  buildParams( prefix, a[ prefix ], traditional, add );
7622                          }
7623                  }
7624  
7625                  // Return the resulting serialization
7626                  return s.join( "&" ).replace( r20, "+" );
7627          }
7628  });
7629  
7630  function buildParams( prefix, obj, traditional, add ) {
7631          if ( jQuery.isArray( obj ) ) {
7632                  // Serialize array item.
7633                  jQuery.each( obj, function( i, v ) {
7634                          if ( traditional || rbracket.test( prefix ) ) {
7635                                  // Treat each array item as a scalar.
7636                                  add( prefix, v );
7637  
7638                          } else {
7639                                  // If array item is non-scalar (array or object), encode its
7640                                  // numeric index to resolve deserialization ambiguity issues.
7641                                  // Note that rack (as of 1.0.0) can't currently deserialize
7642                                  // nested arrays properly, and attempting to do so may cause
7643                                  // a server error. Possible fixes are to modify rack's
7644                                  // deserialization algorithm or to provide an option or flag
7645                                  // to force array serialization to be shallow.
7646                                  buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7647                          }
7648                  });
7649  
7650          } else if ( !traditional && obj != null && typeof obj === "object" ) {
7651                  // Serialize object item.
7652                  for ( var name in obj ) {
7653                          buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7654                  }
7655  
7656          } else {
7657                  // Serialize scalar item.
7658                  add( prefix, obj );
7659          }
7660  }
7661  
7662  // This is still on the jQuery object... for now
7663  // Want to move this to jQuery.ajax some day
7664  jQuery.extend({
7665  
7666          // Counter for holding the number of active queries
7667          active: 0,
7668  
7669          // Last-Modified header cache for next request
7670          lastModified: {},
7671          etag: {}
7672  
7673  });
7674  
7675  /* Handles responses to an ajax request:
7676   * - sets all responseXXX fields accordingly
7677   * - finds the right dataType (mediates between content-type and expected dataType)
7678   * - returns the corresponding response
7679   */
7680  function ajaxHandleResponses( s, jqXHR, responses ) {
7681  
7682          var contents = s.contents,
7683                  dataTypes = s.dataTypes,
7684                  responseFields = s.responseFields,
7685                  ct,
7686                  type,
7687                  finalDataType,
7688                  firstDataType;
7689  
7690          // Fill responseXXX fields
7691          for ( type in responseFields ) {
7692                  if ( type in responses ) {
7693                          jqXHR[ responseFields[type] ] = responses[ type ];
7694                  }
7695          }
7696  
7697          // Remove auto dataType and get content-type in the process
7698          while( dataTypes[ 0 ] === "*" ) {
7699                  dataTypes.shift();
7700                  if ( ct === undefined ) {
7701                          ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
7702                  }
7703          }
7704  
7705          // Check if we're dealing with a known content-type
7706          if ( ct ) {
7707                  for ( type in contents ) {
7708                          if ( contents[ type ] && contents[ type ].test( ct ) ) {
7709                                  dataTypes.unshift( type );
7710                                  break;
7711                          }
7712                  }
7713          }
7714  
7715          // Check to see if we have a response for the expected dataType
7716          if ( dataTypes[ 0 ] in responses ) {
7717                  finalDataType = dataTypes[ 0 ];
7718          } else {
7719                  // Try convertible dataTypes
7720                  for ( type in responses ) {
7721                          if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
7722                                  finalDataType = type;
7723                                  break;
7724                          }
7725                          if ( !firstDataType ) {
7726                                  firstDataType = type;
7727                          }
7728                  }
7729                  // Or just use first one
7730                  finalDataType = finalDataType || firstDataType;
7731          }
7732  
7733          // If we found a dataType
7734          // We add the dataType to the list if needed
7735          // and return the corresponding response
7736          if ( finalDataType ) {
7737                  if ( finalDataType !== dataTypes[ 0 ] ) {
7738                          dataTypes.unshift( finalDataType );
7739                  }
7740                  return responses[ finalDataType ];
7741          }
7742  }
7743  
7744  // Chain conversions given the request and the original response
7745  function ajaxConvert( s, response ) {
7746  
7747          // Apply the dataFilter if provided
7748          if ( s.dataFilter ) {
7749                  response = s.dataFilter( response, s.dataType );
7750          }
7751  
7752          var dataTypes = s.dataTypes,
7753                  converters = {},
7754                  i,
7755                  key,
7756                  length = dataTypes.length,
7757                  tmp,
7758                  // Current and previous dataTypes
7759                  current = dataTypes[ 0 ],
7760                  prev,
7761                  // Conversion expression
7762                  conversion,
7763                  // Conversion function
7764                  conv,
7765                  // Conversion functions (transitive conversion)
7766                  conv1,
7767                  conv2;
7768  
7769          // For each dataType in the chain
7770          for ( i = 1; i < length; i++ ) {
7771  
7772                  // Create converters map
7773                  // with lowercased keys
7774                  if ( i === 1 ) {
7775                          for ( key in s.converters ) {
7776                                  if ( typeof key === "string" ) {
7777                                          converters[ key.toLowerCase() ] = s.converters[ key ];
7778                                  }
7779                          }
7780                  }
7781  
7782                  // Get the dataTypes
7783                  prev = current;
7784                  current = dataTypes[ i ];
7785  
7786                  // If current is auto dataType, update it to prev
7787                  if ( current === "*" ) {
7788                          current = prev;
7789                  // If no auto and dataTypes are actually different
7790                  } else if ( prev !== "*" && prev !== current ) {
7791  
7792                          // Get the converter
7793                          conversion = prev + " " + current;
7794                          conv = converters[ conversion ] || converters[ "* " + current ];
7795  
7796                          // If there is no direct converter, search transitively
7797                          if ( !conv ) {
7798                                  conv2 = undefined;
7799                                  for ( conv1 in converters ) {
7800                                          tmp = conv1.split( " " );
7801                                          if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
7802                                                  conv2 = converters[ tmp[1] + " " + current ];
7803                                                  if ( conv2 ) {
7804                                                          conv1 = converters[ conv1 ];
7805                                                          if ( conv1 === true ) {
7806                                                                  conv = conv2;
7807                                                          } else if ( conv2 === true ) {
7808                                                                  conv = conv1;
7809                                                          }
7810                                                          break;
7811                                                  }
7812                                          }
7813                                  }
7814                          }
7815                          // If we found no converter, dispatch an error
7816                          if ( !( conv || conv2 ) ) {
7817                                  jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7818                          }
7819                          // If found converter is not an equivalence
7820                          if ( conv !== true ) {
7821                                  // Convert with 1 or 2 converters accordingly
7822                                  response = conv ? conv( response ) : conv2( conv1(response) );
7823                          }
7824                  }
7825          }
7826          return response;
7827  }
7828  
7829  
7830  
7831  
7832  var jsc = jQuery.now(),
7833          jsre = /(\=)\?(&|$)|\?\?/i;
7834  
7835  // Default jsonp settings
7836  jQuery.ajaxSetup({
7837          jsonp: "callback",
7838          jsonpCallback: function() {
7839                  return jQuery.expando + "_" + ( jsc++ );
7840          }
7841  });
7842  
7843  // Detect, normalize options and install callbacks for jsonp requests
7844  jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7845  
7846          var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7847                  ( typeof s.data === "string" );
7848  
7849          if ( s.dataTypes[ 0 ] === "jsonp" ||
7850                  s.jsonp !== false && ( jsre.test( s.url ) ||
7851                                  inspectData && jsre.test( s.data ) ) ) {
7852  
7853                  var responseContainer,
7854                          jsonpCallback = s.jsonpCallback =
7855                                  jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7856                          previous = window[ jsonpCallback ],
7857                          url = s.url,
7858                          data = s.data,
7859                          replace = "$1" + jsonpCallback + "$2";
7860  
7861                  if ( s.jsonp !== false ) {
7862                          url = url.replace( jsre, replace );
7863                          if ( s.url === url ) {
7864                                  if ( inspectData ) {
7865                                          data = data.replace( jsre, replace );
7866                                  }
7867                                  if ( s.data === data ) {
7868                                          // Add callback manually
7869                                          url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7870                                  }
7871                          }
7872                  }
7873  
7874                  s.url = url;
7875                  s.data = data;
7876  
7877                  // Install callback
7878                  window[ jsonpCallback ] = function( response ) {
7879                          responseContainer = [ response ];
7880                  };
7881  
7882                  // Clean-up function
7883                  jqXHR.always(function() {
7884                          // Set callback back to previous value
7885                          window[ jsonpCallback ] = previous;
7886                          // Call if it was a function and we have a response
7887                          if ( responseContainer && jQuery.isFunction( previous ) ) {
7888                                  window[ jsonpCallback ]( responseContainer[ 0 ] );
7889                          }
7890                  });
7891  
7892                  // Use data converter to retrieve json after script execution
7893                  s.converters["script json"] = function() {
7894                          if ( !responseContainer ) {
7895                                  jQuery.error( jsonpCallback + " was not called" );
7896                          }
7897                          return responseContainer[ 0 ];
7898                  };
7899  
7900                  // force json dataType
7901                  s.dataTypes[ 0 ] = "json";
7902  
7903                  // Delegate to script
7904                  return "script";
7905          }
7906  });
7907  
7908  
7909  
7910  
7911  // Install script dataType
7912  jQuery.ajaxSetup({
7913          accepts: {
7914                  script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7915          },
7916          contents: {
7917                  script: /javascript|ecmascript/
7918          },
7919          converters: {
7920                  "text script": function( text ) {
7921                          jQuery.globalEval( text );
7922                          return text;
7923                  }
7924          }
7925  });
7926  
7927  // Handle cache's special case and global
7928  jQuery.ajaxPrefilter( "script", function( s ) {
7929          if ( s.cache === undefined ) {
7930                  s.cache = false;
7931          }
7932          if ( s.crossDomain ) {
7933                  s.type = "GET";
7934                  s.global = false;
7935          }
7936  });
7937  
7938  // Bind script tag hack transport
7939  jQuery.ajaxTransport( "script", function(s) {
7940  
7941          // This transport only deals with cross domain requests
7942          if ( s.crossDomain ) {
7943  
7944                  var script,
7945                          head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
7946  
7947                  return {
7948  
7949                          send: function( _, callback ) {
7950  
7951                                  script = document.createElement( "script" );
7952  
7953                                  script.async = "async";
7954  
7955                                  if ( s.scriptCharset ) {
7956                                          script.charset = s.scriptCharset;
7957                                  }
7958  
7959                                  script.src = s.url;
7960  
7961                                  // Attach handlers for all browsers
7962                                  script.onload = script.onreadystatechange = function( _, isAbort ) {
7963  
7964                                          if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
7965  
7966                                                  // Handle memory leak in IE
7967                                                  script.onload = script.onreadystatechange = null;
7968  
7969                                                  // Remove the script
7970                                                  if ( head && script.parentNode ) {
7971                                                          head.removeChild( script );
7972                                                  }
7973  
7974                                                  // Dereference the script
7975                                                  script = undefined;
7976  
7977                                                  // Callback if not abort
7978                                                  if ( !isAbort ) {
7979                                                          callback( 200, "success" );
7980                                                  }
7981                                          }
7982                                  };
7983                                  // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
7984                                  // This arises when a base node is used (#2709 and #4378).
7985                                  head.insertBefore( script, head.firstChild );
7986                          },
7987  
7988                          abort: function() {
7989                                  if ( script ) {
7990                                          script.onload( 0, 1 );
7991                                  }
7992                          }
7993                  };
7994          }
7995  });
7996  
7997  
7998  
7999  
8000  var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
8001          xhrOnUnloadAbort = window.ActiveXObject ? function() {
8002                  // Abort all pending requests
8003                  for ( var key in xhrCallbacks ) {
8004                          xhrCallbacks[ key ]( 0, 1 );
8005                  }
8006          } : false,
8007          xhrId = 0,
8008          xhrCallbacks;
8009  
8010  // Functions to create xhrs
8011  function createStandardXHR() {
8012          try {
8013                  return new window.XMLHttpRequest();
8014          } catch( e ) {}
8015  }
8016  
8017  function createActiveXHR() {
8018          try {
8019                  return new window.ActiveXObject( "Microsoft.XMLHTTP" );
8020          } catch( e ) {}
8021  }
8022  
8023  // Create the request object
8024  // (This is still attached to ajaxSettings for backward compatibility)
8025  jQuery.ajaxSettings.xhr = window.ActiveXObject ?
8026          /* Microsoft failed to properly
8027           * implement the XMLHttpRequest in IE7 (can't request local files),
8028           * so we use the ActiveXObject when it is available
8029           * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
8030           * we need a fallback.
8031           */
8032          function() {
8033                  return !this.isLocal && createStandardXHR() || createActiveXHR();
8034          } :
8035          // For all other browsers, use the standard XMLHttpRequest object
8036          createStandardXHR;
8037  
8038  // Determine support properties
8039  (function( xhr ) {
8040          jQuery.extend( jQuery.support, {
8041                  ajax: !!xhr,
8042                  cors: !!xhr && ( "withCredentials" in xhr )
8043          });
8044  })( jQuery.ajaxSettings.xhr() );
8045  
8046  // Create transport if the browser can provide an xhr
8047  if ( jQuery.support.ajax ) {
8048  
8049          jQuery.ajaxTransport(function( s ) {
8050                  // Cross domain only allowed if supported through XMLHttpRequest
8051                  if ( !s.crossDomain || jQuery.support.cors ) {
8052  
8053                          var callback;
8054  
8055                          return {
8056                                  send: function( headers, complete ) {
8057  
8058                                          // Get a new xhr
8059                                          var xhr = s.xhr(),
8060                                                  handle,
8061                                                  i;
8062  
8063                                          // Open the socket
8064                                          // Passing null username, generates a login popup on Opera (#2865)
8065                                          if ( s.username ) {
8066                                                  xhr.open( s.type, s.url, s.async, s.username, s.password );
8067                                          } else {
8068                                                  xhr.open( s.type, s.url, s.async );
8069                                          }
8070  
8071                                          // Apply custom fields if provided
8072                                          if ( s.xhrFields ) {
8073                                                  for ( i in s.xhrFields ) {
8074                                                          xhr[ i ] = s.xhrFields[ i ];
8075                                                  }
8076                                          }
8077  
8078                                          // Override mime type if needed
8079                                          if ( s.mimeType && xhr.overrideMimeType ) {
8080                                                  xhr.overrideMimeType( s.mimeType );
8081                                          }
8082  
8083                                          // X-Requested-With header
8084                                          // For cross-domain requests, seeing as conditions for a preflight are
8085                                          // akin to a jigsaw puzzle, we simply never set it to be sure.
8086                                          // (it can always be set on a per-request basis or even using ajaxSetup)
8087                                          // For same-domain requests, won't change header if already provided.
8088                                          if ( !s.crossDomain && !headers["X-Requested-With"] ) {
8089                                                  headers[ "X-Requested-With" ] = "XMLHttpRequest";
8090                                          }
8091  
8092                                          // Need an extra try/catch for cross domain requests in Firefox 3
8093                                          try {
8094                                                  for ( i in headers ) {
8095                                                          xhr.setRequestHeader( i, headers[ i ] );
8096                                                  }
8097                                          } catch( _ ) {}
8098  
8099                                          // Do send the request
8100                                          // This may raise an exception which is actually
8101                                          // handled in jQuery.ajax (so no try/catch here)
8102                                          xhr.send( ( s.hasContent && s.data ) || null );
8103  
8104                                          // Listener
8105                                          callback = function( _, isAbort ) {
8106  
8107                                                  var status,
8108                                                          statusText,
8109                                                          responseHeaders,
8110                                                          responses,
8111                                                          xml;
8112  
8113                                                  // Firefox throws exceptions when accessing properties
8114                                                  // of an xhr when a network error occured
8115                                                  // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
8116                                                  try {
8117  
8118                                                          // Was never called and is aborted or complete
8119                                                          if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
8120  
8121                                                                  // Only called once
8122                                                                  callback = undefined;
8123  
8124                                                                  // Do not keep as active anymore
8125                                                                  if ( handle ) {
8126                                                                          xhr.onreadystatechange = jQuery.noop;
8127                                                                          if ( xhrOnUnloadAbort ) {
8128                                                                                  delete xhrCallbacks[ handle ];
8129                                                                          }
8130                                                                  }
8131  
8132                                                                  // If it's an abort
8133                                                                  if ( isAbort ) {
8134                                                                          // Abort it manually if needed
8135                                                                          if ( xhr.readyState !== 4 ) {
8136                                                                                  xhr.abort();
8137                                                                          }
8138                                                                  } else {
8139                                                                          status = xhr.status;
8140                                                                          responseHeaders = xhr.getAllResponseHeaders();
8141                                                                          responses = {};
8142                                                                          xml = xhr.responseXML;
8143  
8144                                                                          // Construct response list
8145                                                                          if ( xml && xml.documentElement /* #4958 */ ) {
8146                                                                                  responses.xml = xml;
8147                                                                          }
8148                                                                          responses.text = xhr.responseText;
8149  
8150                                                                          // Firefox throws an exception when accessing
8151                                                                          // statusText for faulty cross-domain requests
8152                                                                          try {
8153                                                                                  statusText = xhr.statusText;
8154                                                                          } catch( e ) {
8155                                                                                  // We normalize with Webkit giving an empty statusText
8156                                                                                  statusText = "";
8157                                                                          }
8158  
8159                                                                          // Filter status for non standard behaviors
8160  
8161                                                                          // If the request is local and we have data: assume a success
8162                                                                          // (success with no data won't get notified, that's the best we
8163                                                                          // can do given current implementations)
8164                                                                          if ( !status && s.isLocal && !s.crossDomain ) {
8165                                                                                  status = responses.text ? 200 : 404;
8166                                                                          // IE - #1450: sometimes returns 1223 when it should be 204
8167                                                                          } else if ( status === 1223 ) {
8168                                                                                  status = 204;
8169                                                                          }
8170                                                                  }
8171                                                          }
8172                                                  } catch( firefoxAccessException ) {
8173                                                          if ( !isAbort ) {
8174                                                                  complete( -1, firefoxAccessException );
8175                                                          }
8176                                                  }
8177  
8178                                                  // Call complete if needed
8179                                                  if ( responses ) {
8180                                                          complete( status, statusText, responses, responseHeaders );
8181                                                  }
8182                                          };
8183  
8184                                          // if we're in sync mode or it's in cache
8185                                          // and has been retrieved directly (IE6 & IE7)
8186                                          // we need to manually fire the callback
8187                                          if ( !s.async || xhr.readyState === 4 ) {
8188                                                  callback();
8189                                          } else {
8190                                                  handle = ++xhrId;
8191                                                  if ( xhrOnUnloadAbort ) {
8192                                                          // Create the active xhrs callbacks list if needed
8193                                                          // and attach the unload handler
8194                                                          if ( !xhrCallbacks ) {
8195                                                                  xhrCallbacks = {};
8196                                                                  jQuery( window ).unload( xhrOnUnloadAbort );
8197                                                          }
8198                                                          // Add to list of active xhrs callbacks
8199                                                          xhrCallbacks[ handle ] = callback;
8200                                                  }
8201                                                  xhr.onreadystatechange = callback;
8202                                          }
8203                                  },
8204  
8205                                  abort: function() {
8206                                          if ( callback ) {
8207                                                  callback(0,1);
8208                                          }
8209                                  }
8210                          };
8211                  }
8212          });
8213  }
8214  
8215  
8216  
8217  
8218  var elemdisplay = {},
8219          iframe, iframeDoc,
8220          rfxtypes = /^(?:toggle|show|hide)$/,
8221          rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
8222          timerId,
8223          fxAttrs = [
8224                  // height animations
8225                  [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
8226                  // width animations
8227                  [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
8228                  // opacity animations
8229                  [ "opacity" ]
8230          ],
8231          fxNow;
8232  
8233  jQuery.fn.extend({
8234          show: function( speed, easing, callback ) {
8235                  var elem, display;
8236  
8237                  if ( speed || speed === 0 ) {
8238                          return this.animate( genFx("show", 3), speed, easing, callback );
8239  
8240                  } else {
8241                          for ( var i = 0, j = this.length; i < j; i++ ) {
8242                                  elem = this[ i ];
8243  
8244                                  if ( elem.style ) {
8245                                          display = elem.style.display;
8246  
8247                                          // Reset the inline display of this element to learn if it is
8248                                          // being hidden by cascaded rules or not
8249                                          if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
8250                                                  display = elem.style.display = "";
8251                                          }
8252  
8253                                          // Set elements which have been overridden with display: none
8254                                          // in a stylesheet to whatever the default browser style is
8255                                          // for such an element
8256                                          if ( display === "" && jQuery.css(elem, "display") === "none" ) {
8257                                                  jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
8258                                          }
8259                                  }
8260                          }
8261  
8262                          // Set the display of most of the elements in a second loop
8263                          // to avoid the constant reflow
8264                          for ( i = 0; i < j; i++ ) {
8265                                  elem = this[ i ];
8266  
8267                                  if ( elem.style ) {
8268                                          display = elem.style.display;
8269  
8270                                          if ( display === "" || display === "none" ) {
8271                                                  elem.style.display = jQuery._data( elem, "olddisplay" ) || "";
8272                                          }
8273                                  }
8274                          }
8275  
8276                          return this;
8277                  }
8278          },
8279  
8280          hide: function( speed, easing, callback ) {
8281                  if ( speed || speed === 0 ) {
8282                          return this.animate( genFx("hide", 3), speed, easing, callback);
8283  
8284                  } else {
8285                          var elem, display,
8286                                  i = 0,
8287                                  j = this.length;
8288  
8289                          for ( ; i < j; i++ ) {
8290                                  elem = this[i];
8291                                  if ( elem.style ) {
8292                                          display = jQuery.css( elem, "display" );
8293  
8294                                          if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) {
8295                                                  jQuery._data( elem, "olddisplay", display );
8296                                          }
8297                                  }
8298                          }
8299  
8300                          // Set the display of the elements in a second loop
8301                          // to avoid the constant reflow
8302                          for ( i = 0; i < j; i++ ) {
8303                                  if ( this[i].style ) {
8304                                          this[i].style.display = "none";
8305                                  }
8306                          }
8307  
8308                          return this;
8309                  }
8310          },
8311  
8312          // Save the old toggle function
8313          _toggle: jQuery.fn.toggle,
8314  
8315          toggle: function( fn, fn2, callback ) {
8316                  var bool = typeof fn === "boolean";
8317  
8318                  if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8319                          this._toggle.apply( this, arguments );
8320  
8321                  } else if ( fn == null || bool ) {
8322                          this.each(function() {
8323                                  var state = bool ? fn : jQuery(this).is(":hidden");
8324                                  jQuery(this)[ state ? "show" : "hide" ]();
8325                          });
8326  
8327                  } else {
8328                          this.animate(genFx("toggle", 3), fn, fn2, callback);
8329                  }
8330  
8331                  return this;
8332          },
8333  
8334          fadeTo: function( speed, to, easing, callback ) {
8335                  return this.filter(":hidden").css("opacity", 0).show().end()
8336                                          .animate({opacity: to}, speed, easing, callback);
8337          },
8338  
8339          animate: function( prop, speed, easing, callback ) {
8340                  var optall = jQuery.speed( speed, easing, callback );
8341  
8342                  if ( jQuery.isEmptyObject( prop ) ) {
8343                          return this.each( optall.complete, [ false ] );
8344                  }
8345  
8346                  // Do not change referenced properties as per-property easing will be lost
8347                  prop = jQuery.extend( {}, prop );
8348  
8349                  function doAnimation() {
8350                          // XXX 'this' does not always have a nodeName when running the
8351                          // test suite
8352  
8353                          if ( optall.queue === false ) {
8354                                  jQuery._mark( this );
8355                          }
8356  
8357                          var opt = jQuery.extend( {}, optall ),
8358                                  isElement = this.nodeType === 1,
8359                                  hidden = isElement && jQuery(this).is(":hidden"),
8360                                  name, val, p, e,
8361                                  parts, start, end, unit,
8362                                  method;
8363  
8364                          // will store per property easing and be used to determine when an animation is complete
8365                          opt.animatedProperties = {};
8366  
8367                          for ( p in prop ) {
8368  
8369                                  // property name normalization
8370                                  name = jQuery.camelCase( p );
8371                                  if ( p !== name ) {
8372                                          prop[ name ] = prop[ p ];
8373                                          delete prop[ p ];
8374                                  }
8375  
8376                                  val = prop[ name ];
8377  
8378                                  // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8379                                  if ( jQuery.isArray( val ) ) {
8380                                          opt.animatedProperties[ name ] = val[ 1 ];
8381                                          val = prop[ name ] = val[ 0 ];
8382                                  } else {
8383                                          opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
8384                                  }
8385  
8386                                  if ( val === "hide" && hidden || val === "show" && !hidden ) {
8387                                          return opt.complete.call( this );
8388                                  }
8389  
8390                                  if ( isElement && ( name === "height" || name === "width" ) ) {
8391                                          // Make sure that nothing sneaks out
8392                                          // Record all 3 overflow attributes because IE does not
8393                                          // change the overflow attribute when overflowX and
8394                                          // overflowY are set to the same value
8395                                          opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8396  
8397                                          // Set display property to inline-block for height/width
8398                                          // animations on inline elements that are having width/height animated
8399                                          if ( jQuery.css( this, "display" ) === "inline" &&
8400                                                          jQuery.css( this, "float" ) === "none" ) {
8401  
8402                                                  // inline-level elements accept inline-block;
8403                                                  // block-level elements need to be inline with layout
8404                                                  if ( !jQuery.support.inlineBlockNeedsLayout || defaultDisplay( this.nodeName ) === "inline" ) {
8405                                                          this.style.display = "inline-block";
8406  
8407                                                  } else {
8408                                                          this.style.zoom = 1;
8409                                                  }
8410                                          }
8411                                  }
8412                          }
8413  
8414                          if ( opt.overflow != null ) {
8415                                  this.style.overflow = "hidden";
8416                          }
8417  
8418                          for ( p in prop ) {
8419                                  e = new jQuery.fx( this, opt, p );
8420                                  val = prop[ p ];
8421  
8422                                  if ( rfxtypes.test( val ) ) {
8423  
8424                                          // Tracks whether to show or hide based on private
8425                                          // data attached to the element
8426                                          method = jQuery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
8427                                          if ( method ) {
8428                                                  jQuery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
8429                                                  e[ method ]();
8430                                          } else {
8431                                                  e[ val ]();
8432                                          }
8433  
8434                                  } else {
8435                                          parts = rfxnum.exec( val );
8436                                          start = e.cur();
8437  
8438                                          if ( parts ) {
8439                                                  end = parseFloat( parts[2] );
8440                                                  unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
8441  
8442                                                  // We need to compute starting value
8443                                                  if ( unit !== "px" ) {
8444                                                          jQuery.style( this, p, (end || 1) + unit);
8445                                                          start = ( (end || 1) / e.cur() ) * start;
8446                                                          jQuery.style( this, p, start + unit);
8447                                                  }
8448  
8449                                                  // If a +=/-= token was provided, we're doing a relative animation
8450                                                  if ( parts[1] ) {
8451                                                          end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8452                                                  }
8453  
8454                                                  e.custom( start, end, unit );
8455  
8456                                          } else {
8457                                                  e.custom( start, val, "" );
8458                                          }
8459                                  }
8460                          }
8461  
8462                          // For JS strict compliance
8463                          return true;
8464                  }
8465  
8466                  return optall.queue === false ?
8467                          this.each( doAnimation ) :
8468                          this.queue( optall.queue, doAnimation );
8469          },
8470  
8471          stop: function( type, clearQueue, gotoEnd ) {
8472                  if ( typeof type !== "string" ) {
8473                          gotoEnd = clearQueue;
8474                          clearQueue = type;
8475                          type = undefined;
8476                  }
8477                  if ( clearQueue && type !== false ) {
8478                          this.queue( type || "fx", [] );
8479                  }
8480  
8481                  return this.each(function() {
8482                          var index,
8483                                  hadTimers = false,
8484                                  timers = jQuery.timers,
8485                                  data = jQuery._data( this );
8486  
8487                          // clear marker counters if we know they won't be
8488                          if ( !gotoEnd ) {
8489                                  jQuery._unmark( true, this );
8490                          }
8491  
8492                          function stopQueue( elem, data, index ) {
8493                                  var hooks = data[ index ];
8494                                  jQuery.removeData( elem, index, true );
8495                                  hooks.stop( gotoEnd );
8496                          }
8497  
8498                          if ( type == null ) {
8499                                  for ( index in data ) {
8500                                          if ( data[ index ] && data[ index ].stop && index.indexOf(".run") === index.length - 4 ) {
8501                                                  stopQueue( this, data, index );
8502                                          }
8503                                  }
8504                          } else if ( data[ index = type + ".run" ] && data[ index ].stop ){
8505                                  stopQueue( this, data, index );
8506                          }
8507  
8508                          for ( index = timers.length; index--; ) {
8509                                  if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
8510                                          if ( gotoEnd ) {
8511  
8512                                                  // force the next step to be the last
8513                                                  timers[ index ]( true );
8514                                          } else {
8515                                                  timers[ index ].saveState();
8516                                          }
8517                                          hadTimers = true;
8518                                          timers.splice( index, 1 );
8519                                  }
8520                          }
8521  
8522                          // start the next in the queue if the last step wasn't forced
8523                          // timers currently will call their complete callbacks, which will dequeue
8524                          // but only if they were gotoEnd
8525                          if ( !( gotoEnd && hadTimers ) ) {
8526                                  jQuery.dequeue( this, type );
8527                          }
8528                  });
8529          }
8530  
8531  });
8532  
8533  // Animations created synchronously will run synchronously
8534  function createFxNow() {
8535          setTimeout( clearFxNow, 0 );
8536          return ( fxNow = jQuery.now() );
8537  }
8538  
8539  function clearFxNow() {
8540          fxNow = undefined;
8541  }
8542  
8543  // Generate parameters to create a standard animation
8544  function genFx( type, num ) {
8545          var obj = {};
8546  
8547          jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice( 0, num )), function() {
8548                  obj[ this ] = type;
8549          });
8550  
8551          return obj;
8552  }
8553  
8554  // Generate shortcuts for custom animations
8555  jQuery.each({
8556          slideDown: genFx( "show", 1 ),
8557          slideUp: genFx( "hide", 1 ),
8558          slideToggle: genFx( "toggle", 1 ),
8559          fadeIn: { opacity: "show" },
8560          fadeOut: { opacity: "hide" },
8561          fadeToggle: { opacity: "toggle" }
8562  }, function( name, props ) {
8563          jQuery.fn[ name ] = function( speed, easing, callback ) {
8564                  return this.animate( props, speed, easing, callback );
8565          };
8566  });
8567  
8568  jQuery.extend({
8569          speed: function( speed, easing, fn ) {
8570                  var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
8571                          complete: fn || !fn && easing ||
8572                                  jQuery.isFunction( speed ) && speed,
8573                          duration: speed,
8574                          easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
8575                  };
8576  
8577                  opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8578                          opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
8579  
8580                  // normalize opt.queue - true/undefined/null -> "fx"
8581                  if ( opt.queue == null || opt.queue === true ) {
8582                          opt.queue = "fx";
8583                  }
8584  
8585                  // Queueing
8586                  opt.old = opt.complete;
8587  
8588                  opt.complete = function( noUnmark ) {
8589                          if ( jQuery.isFunction( opt.old ) ) {
8590                                  opt.old.call( this );
8591                          }
8592  
8593                          if ( opt.queue ) {
8594                                  jQuery.dequeue( this, opt.queue );
8595                          } else if ( noUnmark !== false ) {
8596                                  jQuery._unmark( this );
8597                          }
8598                  };
8599  
8600                  return opt;
8601          },
8602  
8603          easing: {
8604                  linear: function( p, n, firstNum, diff ) {
8605                          return firstNum + diff * p;
8606                  },
8607                  swing: function( p, n, firstNum, diff ) {
8608                          return ( ( -Math.cos( p*Math.PI ) / 2 ) + 0.5 ) * diff + firstNum;
8609                  }
8610          },
8611  
8612          timers: [],
8613  
8614          fx: function( elem, options, prop ) {
8615                  this.options = options;
8616                  this.elem = elem;
8617                  this.prop = prop;
8618  
8619                  options.orig = options.orig || {};
8620          }
8621  
8622  });
8623  
8624  jQuery.fx.prototype = {
8625          // Simple function for setting a style value
8626          update: function() {
8627                  if ( this.options.step ) {
8628                          this.options.step.call( this.elem, this.now, this );
8629                  }
8630  
8631                  ( jQuery.fx.step[ this.prop ] || jQuery.fx.step._default )( this );
8632          },
8633  
8634          // Get the current size
8635          cur: function() {
8636                  if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
8637                          return this.elem[ this.prop ];
8638                  }
8639  
8640                  var parsed,
8641                          r = jQuery.css( this.elem, this.prop );
8642                  // Empty strings, null, undefined and "auto" are converted to 0,
8643                  // complex values such as "rotate(1rad)" are returned as is,
8644                  // simple values such as "10px" are parsed to Float.
8645                  return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
8646          },
8647  
8648          // Start an animation from one number to another
8649          custom: function( from, to, unit ) {
8650                  var self = this,
8651                          fx = jQuery.fx;
8652  
8653                  this.startTime = fxNow || createFxNow();
8654                  this.end = to;
8655                  this.now = this.start = from;
8656                  this.pos = this.state = 0;
8657                  this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8658  
8659                  function t( gotoEnd ) {
8660                          return self.step( gotoEnd );
8661                  }
8662  
8663                  t.queue = this.options.queue;
8664                  t.elem = this.elem;
8665                  t.saveState = function() {
8666                          if ( self.options.hide && jQuery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
8667                                  jQuery._data( self.elem, "fxshow" + self.prop, self.start );
8668                          }
8669                  };
8670  
8671                  if ( t() && jQuery.timers.push(t) && !timerId ) {
8672                          timerId = setInterval( fx.tick, fx.interval );
8673                  }
8674          },
8675  
8676          // Simple 'show' function
8677          show: function() {
8678                  var dataShow = jQuery._data( this.elem, "fxshow" + this.prop );
8679  
8680                  // Remember where we started, so that we can go back to it later
8681                  this.options.orig[ this.prop ] = dataShow || jQuery.style( this.elem, this.prop );
8682                  this.options.show = true;
8683  
8684                  // Begin the animation
8685                  // Make sure that we start at a small width/height to avoid any flash of content
8686                  if ( dataShow !== undefined ) {
8687                          // This show is picking up where a previous hide or show left off
8688                          this.custom( this.cur(), dataShow );
8689                  } else {
8690                          this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
8691                  }
8692  
8693                  // Start by showing the element
8694                  jQuery( this.elem ).show();
8695          },
8696  
8697          // Simple 'hide' function
8698          hide: function() {
8699                  // Remember where we started, so that we can go back to it later
8700                  this.options.orig[ this.prop ] = jQuery._data( this.elem, "fxshow" + this.prop ) || jQuery.style( this.elem, this.prop );
8701                  this.options.hide = true;
8702  
8703                  // Begin the animation
8704                  this.custom( this.cur(), 0 );
8705          },
8706  
8707          // Each step of an animation
8708          step: function( gotoEnd ) {
8709                  var p, n, complete,
8710                          t = fxNow || createFxNow(),
8711                          done = true,
8712                          elem = this.elem,
8713                          options = this.options;
8714  
8715                  if ( gotoEnd || t >= options.duration + this.startTime ) {
8716                          this.now = this.end;
8717                          this.pos = this.state = 1;
8718                          this.update();
8719  
8720                          options.animatedProperties[ this.prop ] = true;
8721  
8722                          for ( p in options.animatedProperties ) {
8723                                  if ( options.animatedProperties[ p ] !== true ) {
8724                                          done = false;
8725                                  }
8726                          }
8727  
8728                          if ( done ) {
8729                                  // Reset the overflow
8730                                  if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8731  
8732                                          jQuery.each( [ "", "X", "Y" ], function( index, value ) {
8733                                                  elem.style[ "overflow" + value ] = options.overflow[ index ];
8734                                          });
8735                                  }
8736  
8737                                  // Hide the element if the "hide" operation was done
8738                                  if ( options.hide ) {
8739                                          jQuery( elem ).hide();
8740                                  }
8741  
8742                                  // Reset the properties, if the item has been hidden or shown
8743                                  if ( options.hide || options.show ) {
8744                                          for ( p in options.animatedProperties ) {
8745                                                  jQuery.style( elem, p, options.orig[ p ] );
8746                                                  jQuery.removeData( elem, "fxshow" + p, true );
8747                                                  // Toggle data is no longer needed
8748                                                  jQuery.removeData( elem, "toggle" + p, true );
8749                                          }
8750                                  }
8751  
8752                                  // Execute the complete function
8753                                  // in the event that the complete function throws an exception
8754                                  // we must ensure it won't be called twice. #5684
8755  
8756                                  complete = options.complete;
8757                                  if ( complete ) {
8758  
8759                                          options.complete = false;
8760                                          complete.call( elem );
8761                                  }
8762                          }
8763  
8764                          return false;
8765  
8766                  } else {
8767                          // classical easing cannot be used with an Infinity duration
8768                          if ( options.duration == Infinity ) {
8769                                  this.now = t;
8770                          } else {
8771                                  n = t - this.startTime;
8772                                  this.state = n / options.duration;
8773  
8774                                  // Perform the easing function, defaults to swing
8775                                  this.pos = jQuery.easing[ options.animatedProperties[this.prop] ]( this.state, n, 0, 1, options.duration );
8776                                  this.now = this.start + ( (this.end - this.start) * this.pos );
8777                          }
8778                          // Perform the next step of the animation
8779                          this.update();
8780                  }
8781  
8782                  return true;
8783          }
8784  };
8785  
8786  jQuery.extend( jQuery.fx, {
8787          tick: function() {
8788                  var timer,
8789                          timers = jQuery.timers,
8790                          i = 0;
8791  
8792                  for ( ; i < timers.length; i++ ) {
8793                          timer = timers[ i ];
8794                          // Checks the timer has not already been removed
8795                          if ( !timer() && timers[ i ] === timer ) {
8796                                  timers.splice( i--, 1 );
8797                          }
8798                  }
8799  
8800                  if ( !timers.length ) {
8801                          jQuery.fx.stop();
8802                  }
8803          },
8804  
8805          interval: 13,
8806  
8807          stop: function() {
8808                  clearInterval( timerId );
8809                  timerId = null;
8810          },
8811  
8812          speeds: {
8813                  slow: 600,
8814                  fast: 200,
8815                  // Default speed
8816                  _default: 400
8817          },
8818  
8819          step: {
8820                  opacity: function( fx ) {
8821                          jQuery.style( fx.elem, "opacity", fx.now );
8822                  },
8823  
8824                  _default: function( fx ) {
8825                          if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8826                                  fx.elem.style[ fx.prop ] = fx.now + fx.unit;
8827                          } else {
8828                                  fx.elem[ fx.prop ] = fx.now;
8829                          }
8830                  }
8831          }
8832  });
8833  
8834  // Adds width/height step functions
8835  // Do not set anything below 0
8836  jQuery.each([ "width", "height" ], function( i, prop ) {
8837          jQuery.fx.step[ prop ] = function( fx ) {
8838                  jQuery.style( fx.elem, prop, Math.max(0, fx.now) + fx.unit );
8839          };
8840  });
8841  
8842  if ( jQuery.expr && jQuery.expr.filters ) {
8843          jQuery.expr.filters.animated = function( elem ) {
8844                  return jQuery.grep(jQuery.timers, function( fn ) {
8845                          return elem === fn.elem;
8846                  }).length;
8847          };
8848  }
8849  
8850  // Try to restore the default display value of an element
8851  function defaultDisplay( nodeName ) {
8852  
8853          if ( !elemdisplay[ nodeName ] ) {
8854  
8855                  var body = document.body,
8856                          elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
8857                          display = elem.css( "display" );
8858                  elem.remove();
8859  
8860                  // If the simple way fails,
8861                  // get element's real default display by attaching it to a temp iframe
8862                  if ( display === "none" || display === "" ) {
8863                          // No iframe to use yet, so create it
8864                          if ( !iframe ) {
8865                                  iframe = document.createElement( "iframe" );
8866                                  iframe.frameBorder = iframe.width = iframe.height = 0;
8867                          }
8868  
8869                          body.appendChild( iframe );
8870  
8871                          // Create a cacheable copy of the iframe document on first call.
8872                          // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
8873                          // document to it; WebKit & Firefox won't allow reusing the iframe document.
8874                          if ( !iframeDoc || !iframe.createElement ) {
8875                                  iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
8876                                  iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
8877                                  iframeDoc.close();
8878                          }
8879  
8880                          elem = iframeDoc.createElement( nodeName );
8881  
8882                          iframeDoc.body.appendChild( elem );
8883  
8884                          display = jQuery.css( elem, "display" );
8885                          body.removeChild( iframe );
8886                  }
8887  
8888                  // Store the correct default display
8889                  elemdisplay[ nodeName ] = display;
8890          }
8891  
8892          return elemdisplay[ nodeName ];
8893  }
8894  
8895  
8896  
8897  
8898  var rtable = /^t(?:able|d|h)$/i,
8899          rroot = /^(?:body|html)$/i;
8900  
8901  if ( "getBoundingClientRect" in document.documentElement ) {
8902          jQuery.fn.offset = function( options ) {
8903                  var elem = this[0], box;
8904  
8905                  if ( options ) {
8906                          return this.each(function( i ) {
8907                                  jQuery.offset.setOffset( this, options, i );
8908                          });
8909                  }
8910  
8911                  if ( !elem || !elem.ownerDocument ) {
8912                          return null;
8913                  }
8914  
8915                  if ( elem === elem.ownerDocument.body ) {
8916                          return jQuery.offset.bodyOffset( elem );
8917                  }
8918  
8919                  try {
8920                          box = elem.getBoundingClientRect();
8921                  } catch(e) {}
8922  
8923                  var doc = elem.ownerDocument,
8924                          docElem = doc.documentElement;
8925  
8926                  // Make sure we're not dealing with a disconnected DOM node
8927                  if ( !box || !jQuery.contains( docElem, elem ) ) {
8928                          return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8929                  }
8930  
8931                  var body = doc.body,
8932                          win = getWindow(doc),
8933                          clientTop  = docElem.clientTop  || body.clientTop  || 0,
8934                          clientLeft = docElem.clientLeft || body.clientLeft || 0,
8935                          scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
8936                          scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
8937                          top  = box.top  + scrollTop  - clientTop,
8938                          left = box.left + scrollLeft - clientLeft;
8939  
8940                  return { top: top, left: left };
8941          };
8942  
8943  } else {
8944          jQuery.fn.offset = function( options ) {
8945                  var elem = this[0];
8946  
8947                  if ( options ) {
8948                          return this.each(function( i ) {
8949                                  jQuery.offset.setOffset( this, options, i );
8950                          });
8951                  }
8952  
8953                  if ( !elem || !elem.ownerDocument ) {
8954                          return null;
8955                  }
8956  
8957                  if ( elem === elem.ownerDocument.body ) {
8958                          return jQuery.offset.bodyOffset( elem );
8959                  }
8960  
8961                  var computedStyle,
8962                          offsetParent = elem.offsetParent,
8963                          prevOffsetParent = elem,
8964                          doc = elem.ownerDocument,
8965                          docElem = doc.documentElement,
8966                          body = doc.body,
8967                          defaultView = doc.defaultView,
8968                          prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8969                          top = elem.offsetTop,
8970                          left = elem.offsetLeft;
8971  
8972                  while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8973                          if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
8974                                  break;
8975                          }
8976  
8977                          computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8978                          top  -= elem.scrollTop;
8979                          left -= elem.scrollLeft;
8980  
8981                          if ( elem === offsetParent ) {
8982                                  top  += elem.offsetTop;
8983                                  left += elem.offsetLeft;
8984  
8985                                  if ( jQuery.support.doesNotAddBorder && !(jQuery.support.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8986                                          top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8987                                          left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8988                                  }
8989  
8990                                  prevOffsetParent = offsetParent;
8991                                  offsetParent = elem.offsetParent;
8992                          }
8993  
8994                          if ( jQuery.support.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8995                                  top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8996                                  left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8997                          }
8998  
8999                          prevComputedStyle = computedStyle;
9000                  }
9001  
9002                  if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
9003                          top  += body.offsetTop;
9004                          left += body.offsetLeft;
9005                  }
9006  
9007                  if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
9008                          top  += Math.max( docElem.scrollTop, body.scrollTop );
9009                          left += Math.max( docElem.scrollLeft, body.scrollLeft );
9010                  }
9011  
9012                  return { top: top, left: left };
9013          };
9014  }
9015  
9016  jQuery.offset = {
9017  
9018          bodyOffset: function( body ) {
9019                  var top = body.offsetTop,
9020                          left = body.offsetLeft;
9021  
9022                  if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
9023                          top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
9024                          left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
9025                  }
9026  
9027                  return { top: top, left: left };
9028          },
9029  
9030          setOffset: function( elem, options, i ) {
9031                  var position = jQuery.css( elem, "position" );
9032  
9033                  // set position first, in-case top/left are set even on static elem
9034                  if ( position === "static" ) {
9035                          elem.style.position = "relative";
9036                  }
9037  
9038                  var curElem = jQuery( elem ),
9039                          curOffset = curElem.offset(),
9040                          curCSSTop = jQuery.css( elem, "top" ),
9041                          curCSSLeft = jQuery.css( elem, "left" ),
9042                          calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
9043                          props = {}, curPosition = {}, curTop, curLeft;
9044  
9045                  // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
9046                  if ( calculatePosition ) {
9047                          curPosition = curElem.position();
9048                          curTop = curPosition.top;
9049                          curLeft = curPosition.left;
9050                  } else {
9051                          curTop = parseFloat( curCSSTop ) || 0;
9052                          curLeft = parseFloat( curCSSLeft ) || 0;
9053                  }
9054  
9055                  if ( jQuery.isFunction( options ) ) {
9056                          options = options.call( elem, i, curOffset );
9057                  }
9058  
9059                  if ( options.top != null ) {
9060                          props.top = ( options.top - curOffset.top ) + curTop;
9061                  }
9062                  if ( options.left != null ) {
9063                          props.left = ( options.left - curOffset.left ) + curLeft;
9064                  }
9065  
9066                  if ( "using" in options ) {
9067                          options.using.call( elem, props );
9068                  } else {
9069                          curElem.css( props );
9070                  }
9071          }
9072  };
9073  
9074  
9075  jQuery.fn.extend({
9076  
9077          position: function() {
9078                  if ( !this[0] ) {
9079                          return null;
9080                  }
9081  
9082                  var elem = this[0],
9083  
9084                  // Get *real* offsetParent
9085                  offsetParent = this.offsetParent(),
9086  
9087                  // Get correct offsets
9088                  offset       = this.offset(),
9089                  parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
9090  
9091                  // Subtract element margins
9092                  // note: when an element has margin: auto the offsetLeft and marginLeft
9093                  // are the same in Safari causing offset.left to incorrectly be 0
9094                  offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
9095                  offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
9096  
9097                  // Add offsetParent borders
9098                  parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
9099                  parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
9100  
9101                  // Subtract the two offsets
9102                  return {
9103                          top:  offset.top  - parentOffset.top,
9104                          left: offset.left - parentOffset.left
9105                  };
9106          },
9107  
9108          offsetParent: function() {
9109                  return this.map(function() {
9110                          var offsetParent = this.offsetParent || document.body;
9111                          while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
9112                                  offsetParent = offsetParent.offsetParent;
9113                          }
9114                          return offsetParent;
9115                  });
9116          }
9117  });
9118  
9119  
9120  // Create scrollLeft and scrollTop methods
9121  jQuery.each( ["Left", "Top"], function( i, name ) {
9122          var method = "scroll" + name;
9123  
9124          jQuery.fn[ method ] = function( val ) {
9125                  var elem, win;
9126  
9127                  if ( val === undefined ) {
9128                          elem = this[ 0 ];
9129  
9130                          if ( !elem ) {
9131                                  return null;
9132                          }
9133  
9134                          win = getWindow( elem );
9135  
9136                          // Return the scroll offset
9137                          return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
9138                                  jQuery.support.boxModel && win.document.documentElement[ method ] ||
9139                                          win.document.body[ method ] :
9140                                  elem[ method ];
9141                  }
9142  
9143                  // Set the scroll offset
9144                  return this.each(function() {
9145                          win = getWindow( this );
9146  
9147                          if ( win ) {
9148                                  win.scrollTo(
9149                                          !i ? val : jQuery( win ).scrollLeft(),
9150                                           i ? val : jQuery( win ).scrollTop()
9151                                  );
9152  
9153                          } else {
9154                                  this[ method ] = val;
9155                          }
9156                  });
9157          };
9158  });
9159  
9160  function getWindow( elem ) {
9161          return jQuery.isWindow( elem ) ?
9162                  elem :
9163                  elem.nodeType === 9 ?
9164                          elem.defaultView || elem.parentWindow :
9165                          false;
9166  }
9167  
9168  
9169  
9170  
9171  // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
9172  jQuery.each([ "Height", "Width" ], function( i, name ) {
9173  
9174          var type = name.toLowerCase();
9175  
9176          // innerHeight and innerWidth
9177          jQuery.fn[ "inner" + name ] = function() {
9178                  var elem = this[0];
9179                  return elem ?
9180                          elem.style ?
9181                          parseFloat( jQuery.css( elem, type, "padding" ) ) :
9182                          this[ type ]() :
9183                          null;
9184          };
9185  
9186          // outerHeight and outerWidth
9187          jQuery.fn[ "outer" + name ] = function( margin ) {
9188                  var elem = this[0];
9189                  return elem ?
9190                          elem.style ?
9191                          parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
9192                          this[ type ]() :
9193                          null;
9194          };
9195  
9196          jQuery.fn[ type ] = function( size ) {
9197                  // Get window width or height
9198                  var elem = this[0];
9199                  if ( !elem ) {
9200                          return size == null ? null : this;
9201                  }
9202  
9203                  if ( jQuery.isFunction( size ) ) {
9204                          return this.each(function( i ) {
9205                                  var self = jQuery( this );
9206                                  self[ type ]( size.call( this, i, self[ type ]() ) );
9207                          });
9208                  }
9209  
9210                  if ( jQuery.isWindow( elem ) ) {
9211                          // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
9212                          // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
9213                          var docElemProp = elem.document.documentElement[ "client" + name ],
9214                                  body = elem.document.body;
9215                          return elem.document.compatMode === "CSS1Compat" && docElemProp ||
9216                                  body && body[ "client" + name ] || docElemProp;
9217  
9218                  // Get document width or height
9219                  } else if ( elem.nodeType === 9 ) {
9220                          // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
9221                          return Math.max(
9222                                  elem.documentElement["client" + name],
9223                                  elem.body["scroll" + name], elem.documentElement["scroll" + name],
9224                                  elem.body["offset" + name], elem.documentElement["offset" + name]
9225                          );
9226  
9227                  // Get or set width or height on the element
9228                  } else if ( size === undefined ) {
9229                          var orig = jQuery.css( elem, type ),
9230                                  ret = parseFloat( orig );
9231  
9232                          return jQuery.isNumeric( ret ) ? ret : orig;
9233  
9234                  // Set the width or height on the element (default to pixels if value is unitless)
9235                  } else {
9236                          return this.css( type, typeof size === "string" ? size : size + "px" );
9237                  }
9238          };
9239  
9240  });
9241  
9242  
9243  
9244  
9245  // Expose jQuery to the global object
9246  window.jQuery = window.$ = jQuery;
9247  
9248  // Expose jQuery as an AMD module, but only for AMD loaders that
9249  // understand the issues with loading multiple versions of jQuery
9250  // in a page that all might call define(). The loader will indicate
9251  // they have special allowances for multiple jQuery versions by
9252  // specifying define.amd.jQuery = true. Register as a named module,
9253  // since jQuery can be concatenated with other files that may use define,
9254  // but not use a proper concatenation script that understands anonymous
9255  // AMD modules. A named AMD is safest and most robust way to register.
9256  // Lowercase jquery is used because AMD module names are derived from
9257  // file names, and jQuery is normally delivered in a lowercase file name.
9258  // Do this after creating the global so that if an AMD module wants to call
9259  // noConflict to hide this version of jQuery, it will work.
9260  if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
9261          define( "jquery", [], function () { return jQuery; } );
9262  }
9263  
9264  
9265  
9266  })( window );
1  /*!
2   * jQuery JavaScript Library v1.7.1
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: Mon Nov 21 21:11:03 2011 -0500
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          // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
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          // Match a standalone tag
51          rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
52  
53          // JSON RegExp
54          rvalidchars = /^[\],:{}\s]*$/,
55          rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
56          rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
57          rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
58  
59          // Useragent RegExp
60          rwebkit = /(webkit)[ \/]([\w.]+)/,
61          ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
62          rmsie = /(msie) ([\w.]+)/,
63          rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
64  
65          // Matches dashed string for camelizing
66          rdashAlpha = /-([a-z]|[0-9])/ig,
67          rmsPrefix = /^-ms-/,
68  
69          // Used by jQuery.camelCase as callback to replace()
70          fcamelCase = function( all, letter ) {
71                  return ( letter + "" ).toUpperCase();
72          },
73  
74          // Keep a UserAgent string for use with jQuery.browser
75          userAgent = navigator.userAgent,
76  
77          // For matching the engine and version of the browser
78          browserMatch,
79  
80          // The deferred used on DOM ready
81          readyList,
82  
83          // The ready event handler
84          DOMContentLoaded,
85  
86          // Save a reference to some core methods
87          toString = Object.prototype.toString,
88          hasOwn = Object.prototype.hasOwnProperty,
89          push = Array.prototype.push,
90          slice = Array.prototype.slice,
91          trim = String.prototype.trim,
92          indexOf = Array.prototype.indexOf,
93  
94          // [[Class]] -> type pairs
95          class2type = {};
96  
97  jQuery.fn = jQuery.prototype = {
98          constructor: jQuery,
99          init: function( selector, context, rootjQuery ) {
100                  var match, elem, ret, doc;
101  
102                  // Handle $(""), $(null), or $(undefined)
103                  if ( !selector ) {
104                          return this;
105                  }
106  
107                  // Handle $(DOMElement)
108                  if ( selector.nodeType ) {
109                          this.context = this[0] = selector;
110                          this.length = 1;
111                          return this;
112                  }
113  
114                  // The body element only exists once, optimize finding it
115                  if ( selector === "body" && !context && document.body ) {
116                          this.context = document;
117                          this[0] = document.body;
118                          this.selector = selector;
119                          this.length = 1;
120                          return this;
121                  }
122  
123                  // Handle HTML strings
124                  if ( typeof selector === "string" ) {
125                          // Are we dealing with HTML string or an ID?
126                          if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
127                                  // Assume that strings that start and end with <> are HTML and skip the regex check
128                                  match = [ null, selector, null ];
129  
130                          } else {
131                                  match = quickExpr.exec( selector );
132                          }
133  
134                          // Verify a match, and that no context was specified for #id
135                          if ( match && (match[1] || !context) ) {
136  
137                                  // HANDLE: $(html) -> $(array)
138                                  if ( match[1] ) {
139                                          context = context instanceof jQuery ? context[0] : context;
140                                          doc = ( context ? context.ownerDocument || context : document );
141  
142                                          // If a single string is passed in and it's a single tag
143                                          // just do a createElement and skip the rest
144                                          ret = rsingleTag.exec( selector );
145  
146                                          if ( ret ) {
147                                                  if ( jQuery.isPlainObject( context ) ) {
148                                                          selector = [ document.createElement( ret[1] ) ];
149                                                          jQuery.fn.attr.call( selector, context, true );
150  
151                                                  } else {
152                                                          selector = [ doc.createElement( ret[1] ) ];
153                                                  }
154  
155                                          } else {
156                                                  ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
157                                                  selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
158                                          }
159  
160                                          return jQuery.merge( this, selector );
161  
162                                  // HANDLE: $("#id")
163                                  } else {
164                                          elem = document.getElementById( match[2] );
165  
166                                          // Check parentNode to catch when Blackberry 4.6 returns
167                                          // nodes that are no longer in the document #6963
168                                          if ( elem && elem.parentNode ) {
169                                                  // Handle the case where IE and Opera return items
170                                                  // by name instead of ID
171                                                  if ( elem.id !== match[2] ) {
172                                                          return rootjQuery.find( selector );
173                                                  }
174  
175                                                  // Otherwise, we inject the element directly into the jQuery object
176                                                  this.length = 1;
177                                                  this[0] = elem;
178                                          }
179  
180                                          this.context = document;
181                                          this.selector = selector;
182                                          return this;
183                                  }
184  
185                          // HANDLE: $(expr, $(...))
186                          } else if ( !context || context.jquery ) {
187                                  return ( context || rootjQuery ).find( selector );
188  
189                          // HANDLE: $(expr, context)
190                          // (which is just equivalent to: $(context).find(expr)
191                          } else {
192                                  return this.constructor( context ).find( selector );
193                          }
194  
195                  // HANDLE: $(function)
196                  // Shortcut for document ready
197                  } else if ( jQuery.isFunction( selector ) ) {
198                          return rootjQuery.ready( selector );
199                  }
200  
201                  if ( selector.selector !== undefined ) {
202                          this.selector = selector.selector;
203                          this.context = selector.context;
204                  }
205  
206                  return jQuery.makeArray( selector, this );
207          },
208  
209          // Start with an empty selector
210          selector: "",
211  
212          // The current version of jQuery being used
213          jquery: "1.7.1",
214  
215          // The default length of a jQuery object is 0
216          length: 0,
217  
218          // The number of elements contained in the matched element set
219          size: function() {
220                  return this.length;
221          },
222  
223          toArray: function() {
224                  return slice.call( this, 0 );
225          },
226  
227          // Get the Nth element in the matched element set OR
228          // Get the whole matched element set as a clean array
229          get: function( num ) {
230                  return num == null ?
231  
232                          // Return a 'clean' array
233                          this.toArray() :
234  
235                          // Return just the object
236                          ( num < 0 ? this[ this.length + num ] : this[ num ] );
237          },
238  
239          // Take an array of elements and push it onto the stack
240          // (returning the new matched element set)
241          pushStack: function( elems, name, selector ) {
242                  // Build a new jQuery matched element set
243                  var ret = this.constructor();
244  
245                  if ( jQuery.isArray( elems ) ) {
246                          push.apply( ret, elems );
247  
248                  } else {
249                          jQuery.merge( ret, elems );
250                  }
251  
252                  // Add the old object onto the stack (as a reference)
253                  ret.prevObject = this;
254  
255                  ret.context = this.context;
256  
257                  if ( name === "find" ) {
258                          ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
259                  } else if ( name ) {
260                          ret.selector = this.selector + "." + name + "(" + selector + ")";
261                  }
262  
263                  // Return the newly-formed element set
264                  return ret;
265          },
266  
267          // Execute a callback for every element in the matched set.
268          // (You can seed the arguments with an array of args, but this is
269          // only used internally.)
270          each: function( callback, args ) {
271                  return jQuery.each( this, callback, args );
272          },
273  
274          ready: function( fn ) {
275                  // Attach the listeners
276                  jQuery.bindReady();
277  
278                  // Add the callback
279                  readyList.add( fn );
280  
281                  return this;
282          },
283  
284          eq: function( i ) {
285                  i = +i;
286                  return i === -1 ?
287                          this.slice( i ) :
288                          this.slice( i, i + 1 );
289          },
290  
291          first: function() {
292                  return this.eq( 0 );
293          },
294  
295          last: function() {
296                  return this.eq( -1 );
297          },
298  
299          slice: function() {
300                  return this.pushStack( slice.apply( this, arguments ),
301                          "slice", slice.call(arguments).join(",") );
302          },
303  
304          map: function( callback ) {
305                  return this.pushStack( jQuery.map(this, function( elem, i ) {
306                          return callback.call( elem, i, elem );
307                  }));
308          },
309  
310          end: function() {
311                  return this.prevObject || this.constructor(null);
312          },
313  
314          // For internal use only.
315          // Behaves like an Array's method, not like a jQuery method.
316          push: push,
317          sort: [].sort,
318          splice: [].splice
319  };
320  
321  // Give the init function the jQuery prototype for later instantiation
322  jQuery.fn.init.prototype = jQuery.fn;
323  
324  jQuery.extend = jQuery.fn.extend = function() {
325          var options, name, src, copy, copyIsArray, clone,
326                  target = arguments[0] || {},
327                  i = 1,
328                  length = arguments.length,
329                  deep = false;
330  
331          // Handle a deep copy situation
332          if ( typeof target === "boolean" ) {
333                  deep = target;
334                  target = arguments[1] || {};
335                  // skip the boolean and the target
336                  i = 2;
337          }
338  
339          // Handle case when target is a string or something (possible in deep copy)
340          if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
341                  target = {};
342          }
343  
344          // extend jQuery itself if only one argument is passed
345          if ( length === i ) {
346                  target = this;
347                  --i;
348          }
349  
350          for ( ; i < length; i++ ) {
351                  // Only deal with non-null/undefined values
352                  if ( (options = arguments[ i ]) != null ) {
353                          // Extend the base object
354                          for ( name in options ) {
355                                  src = target[ name ];
356                                  copy = options[ name ];
357  
358                                  // Prevent never-ending loop
359                                  if ( target === copy ) {
360                                          continue;
361                                  }
362  
363                                  // Recurse if we're merging plain objects or arrays
364                                  if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
365                                          if ( copyIsArray ) {
366                                                  copyIsArray = false;
367                                                  clone = src && jQuery.isArray(src) ? src : [];
368  
369                                          } else {
370                                                  clone = src && jQuery.isPlainObject(src) ? src : {};
371                                          }
372  
373                                          // Never move original objects, clone them
374                                          target[ name ] = jQuery.extend( deep, clone, copy );
375  
376                                  // Don't bring in undefined values
377                                  } else if ( copy !== undefined ) {
378                                          target[ name ] = copy;
379                                  }
380                          }
381                  }
382          }
383  
384          // Return the modified object
385          return target;
386  };
387  
388  jQuery.extend({
389          noConflict: function( deep ) {
390                  if ( window.$ === jQuery ) {
391                          window.$ = _$;
392                  }
393  
394                  if ( deep && window.jQuery === jQuery ) {
395                          window.jQuery = _jQuery;
396                  }
397  
398                  return jQuery;
399          },
400  
401          // Is the DOM ready to be used? Set to true once it occurs.
402          isReady: false,
403  
404          // A counter to track how many items to wait for before
405          // the ready event fires. See #6781
406          readyWait: 1,
407  
408          // Hold (or release) the ready event
409          holdReady: function( hold ) {
410                  if ( hold ) {
411                          jQuery.readyWait++;
412                  } else {
413                          jQuery.ready( true );
414                  }
415          },
416  
417          // Handle when the DOM is ready
418          ready: function( wait ) {
419                  // Either a released hold or an DOMready/load event and not yet ready
420                  if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
421                          // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
422                          if ( !document.body ) {
423                                  return setTimeout( jQuery.ready, 1 );
424                          }
425  
426                          // Remember that the DOM is ready
427                          jQuery.isReady = true;
428  
429                          // If a normal DOM Ready event fired, decrement, and wait if need be
430                          if ( wait !== true && --jQuery.readyWait > 0 ) {
431                                  return;
432                          }
433  
434                          // If there are functions bound, to execute
435                          readyList.fireWith( document, [ jQuery ] );
436  
437                          // Trigger any bound ready events
438                          if ( jQuery.fn.trigger ) {
439                                  jQuery( document ).trigger( "ready" ).off( "ready" );
440                          }
441                  }
442          },
443  
444          bindReady: function() {
445                  if ( readyList ) {
446                          return;
447                  }
448  
449                  readyList = jQuery.Callbacks( "once memory" );
450  
451                  // Catch cases where $(document).ready() is called after the
452                  // browser event has already occurred.
453                  if ( document.readyState === "complete" ) {
454                          // Handle it asynchronously to allow scripts the opportunity to delay ready
455                          return setTimeout( jQuery.ready, 1 );
456                  }
457  
458                  // Mozilla, Opera and webkit nightlies currently support this event
459                  if ( document.addEventListener ) {
460                          // Use the handy event callback
461                          document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
462  
463                          // A fallback to window.onload, that will always work
464                          window.addEventListener( "load", jQuery.ready, false );
465  
466                  // If IE event model is used
467                  } else if ( document.attachEvent ) {
468                          // ensure firing before onload,
469                          // maybe late but safe also for iframes
470                          document.attachEvent( "onreadystatechange", DOMContentLoaded );
471  
472                          // A fallback to window.onload, that will always work
473                          window.attachEvent( "onload", jQuery.ready );
474  
475                          // If IE and not a frame
476                          // continually check to see if the document is ready
477                          var toplevel = false;
478  
479                          try {
480                                  toplevel = window.frameElement == null;
481                          } catch(e) {}
482  
483                          if ( document.documentElement.doScroll && toplevel ) {
484                                  doScrollCheck();
485                          }
486                  }
487          },
488  
489          // See test/unit/core.js for details concerning isFunction.
490          // Since version 1.3, DOM methods and functions like alert
491          // aren't supported. They return false on IE (#2968).
492          isFunction: function( obj ) {
493                  return jQuery.type(obj) === "function";
494          },
495  
496          isArray: Array.isArray || function( obj ) {
497                  return jQuery.type(obj) === "array";
498          },
499  
500          // A crude way of determining if an object is a window
501          isWindow: function( obj ) {
502                  return obj && typeof obj === "object" && "setInterval" in obj;
503          },
504  
505          isNumeric: function( obj ) {
506                  return !isNaN( parseFloat(obj) ) && isFinite( obj );
507          },
508  
509          type: function( obj ) {
510                  return obj == null ?
511                          String( obj ) :
512                          class2type[ toString.call(obj) ] || "object";
513          },
514  
515          isPlainObject: function( obj ) {
516                  // Must be an Object.
517                  // Because of IE, we also have to check the presence of the constructor property.
518                  // Make sure that DOM nodes and window objects don't pass through, as well
519                  if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
520                          return false;
521                  }
522  
523                  try {
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                  } catch ( e ) {
531                          // IE8,9 Will throw exceptions on certain host objects #9897
532                          return false;
533                  }
534  
535                  // Own properties are enumerated firstly, so to speed up,
536                  // if last one is own, then all properties are own.
537  
538                  var key;
539                  for ( key in obj ) {}
540  
541                  return key === undefined || hasOwn.call( obj, key );
542          },
543  
544          isEmptyObject: function( obj ) {
545                  for ( var name in obj ) {
546                          return false;
547                  }
548                  return true;
549          },
550  
551          error: function( msg ) {
552                  throw new Error( msg );
553          },
554  
555          parseJSON: function( data ) {
556                  if ( typeof data !== "string" || !data ) {
557                          return null;
558                  }
559  
560                  // Make sure leading/trailing whitespace is removed (IE can't handle it)
561                  data = jQuery.trim( data );
562  
563                  // Attempt to parse using the native JSON parser first
564                  if ( window.JSON && window.JSON.parse ) {
565                          return window.JSON.parse( data );
566                  }
567  
568                  // Make sure the incoming data is actual JSON
569                  // Logic borrowed from http://json.org/json2.js
570                  if ( rvalidchars.test( data.replace( rvalidescape, "@" )
571                          .replace( rvalidtokens, "]" )
572                          .replace( rvalidbraces, "")) ) {
573  
574                          return ( new Function( "return " + data ) )();
575  
576                  }
577                  jQuery.error( "Invalid JSON: " + data );
578          },
579  
580          // Cross-browser xml parsing
581          parseXML: function( data ) {
582                  var xml, tmp;
583                  try {
584                          if ( window.DOMParser ) { // Standard
585                                  tmp = new DOMParser();
586                                  xml = tmp.parseFromString( data , "text/xml" );
587                          } else { // IE
588                                  xml = new ActiveXObject( "Microsoft.XMLDOM" );
589                                  xml.async = "false";
590                                  xml.loadXML( data );
591                          }
592                  } catch( e ) {
593                          xml = undefined;
594                  }
595                  if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
596                          jQuery.error( "Invalid XML: " + data );
597                  }
598                  return xml;
599          },
600  
601          noop: function() {},
602  
603          // Evaluates a script in a global context
604          // Workarounds based on findings by Jim Driscoll
605          // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
606          globalEval: function( data ) {
607                  if ( data && rnotwhite.test( data ) ) {
608                          // We use execScript on Internet Explorer
609                          // We use an anonymous function so that context is window
610                          // rather than jQuery in Firefox
611                          ( window.execScript || function( data ) {
612                                  window[ "eval" ].call( window, data );
613                          } )( data );
614                  }
615          },
616  
617          // Convert dashed to camelCase; used by the css and data modules
618          // Microsoft forgot to hump their vendor prefix (#9572)
619          camelCase: function( string ) {
620                  return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
621          },
622  
623          nodeName: function( elem, name ) {
624                  return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
625          },
626  
627          // args is for internal usage only
628          each: function( object, callback, args ) {
629                  var name, i = 0,
630                          length = object.length,
631                          isObj = length === undefined || jQuery.isFunction( object );
632  
633                  if ( args ) {
634                          if ( isObj ) {
635                                  for ( name in object ) {
636                                          if ( callback.apply( object[ name ], args ) === false ) {
637                                                  break;
638                                          }
639                                  }
640                          } else {
641                                  for ( ; i < length; ) {
642                                          if ( callback.apply( object[ i++ ], args ) === false ) {
643                                                  break;
644                                          }
645                                  }
646                          }
647  
648                  // A special, fast, case for the most common use of each
649                  } else {
650                          if ( isObj ) {
651                                  for ( name in object ) {
652                                          if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
653                                                  break;
654                                          }
655                                  }
656                          } else {
657                                  for ( ; i < length; ) {
658                                          if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
659                                                  break;
660                                          }
661                                  }
662                          }
663                  }
664  
665                  return object;
666          },
667  
668          // Use native String.trim function wherever possible
669          trim: trim ?
670                  function( text ) {
671                          return text == null ?
672                                  "" :
673                                  trim.call( text );
674                  } :
675  
676                  // Otherwise use our own trimming functionality
677                  function( text ) {
678                          return text == null ?
679                                  "" :
680                                  text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
681                  },
682  
683          // results is for internal usage only
684          makeArray: function( array, results ) {
685                  var ret = results || [];
686  
687                  if ( array != null ) {
688                          // The window, strings (and functions) also have 'length'
689                          // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
690                          var type = jQuery.type( array );
691  
692                          if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
693                                  push.call( ret, array );
694                          } else {
695                                  jQuery.merge( ret, array );
696                          }
697                  }
698  
699                  return ret;
700          },
701  
702          inArray: function( elem, array, i ) {
703                  var len;
704  
705                  if ( array ) {
706                          if ( indexOf ) {
707                                  return indexOf.call( array, elem, i );
708                          }
709  
710                          len = array.length;
711                          i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
712  
713                          for ( ; i < len; i++ ) {
714                                  // Skip accessing in sparse arrays
715                                  if ( i in array && array[ i ] === elem ) {
716                                          return i;
717                                  }
718                          }
719                  }
720  
721                  return -1;
722          },
723  
724          merge: function( first, second ) {
725                  var i = first.length,
726                          j = 0;
727  
728                  if ( typeof second.length === "number" ) {
729                          for ( var l = second.length; j < l; j++ ) {
730                                  first[ i++ ] = second[ j ];
731                          }
732  
733                  } else {
734                          while ( second[j] !== undefined ) {
735                                  first[ i++ ] = second[ j++ ];
736                          }
737                  }
738  
739                  first.length = i;
740  
741                  return first;
742          },
743  
744          grep: function( elems, callback, inv ) {
745                  var ret = [], retVal;
746                  inv = !!inv;
747  
748                  // Go through the array, only saving the items
749                  // that pass the validator function
750                  for ( var i = 0, length = elems.length; i < length; i++ ) {
751                          retVal = !!callback( elems[ i ], i );
752                          if ( inv !== retVal ) {
753                                  ret.push( elems[ i ] );
754                          }
755                  }
756  
757                  return ret;
758          },
759  
760          // arg is for internal usage only
761          map: function( elems, callback, arg ) {
762                  var value, key, ret = [],
763                          i = 0,
764                          length = elems.length,
765                          // jquery objects are treated as arrays
766                          isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
767  
768                  // Go through the array, translating each of the items to their
769                  if ( isArray ) {
770                          for ( ; i < length; i++ ) {
771                                  value = callback( elems[ i ], i, arg );
772  
773                                  if ( value != null ) {
774                                          ret[ ret.length ] = value;
775                                  }
776                          }
777  
778                  // Go through every key on the object,
779                  } else {
780                          for ( key in elems ) {
781                                  value = callback( elems[ key ], key, arg );
782  
783                                  if ( value != null ) {
784                                          ret[ ret.length ] = value;
785                                  }
786                          }
787                  }
788  
789                  // Flatten any nested arrays
790                  return ret.concat.apply( [], ret );
791          },
792  
793          // A global GUID counter for objects
794          guid: 1,
795  
796          // Bind a function to a context, optionally partially applying any
797          // arguments.
798          proxy: function( fn, context ) {
799                  if ( typeof context === "string" ) {
800                          var tmp = fn[ context ];
801                          context = fn;
802                          fn = tmp;
803                  }
804  
805                  // Quick check to determine if target is callable, in the spec
806                  // this throws a TypeError, but we will just return undefined.
807                  if ( !jQuery.isFunction( fn ) ) {
808                          return undefined;
809                  }
810  
811                  // Simulated bind
812                  var args = slice.call( arguments, 2 ),
813                          proxy = function() {
814                                  return fn.apply( context, args.concat( slice.call( arguments ) ) );
815                          };
816  
817                  // Set the guid of unique handler to the same of original handler, so it can be removed
818                  proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
819  
820                  return proxy;
821          },
822  
823          // Mutifunctional method to get and set values to a collection
824          // The value/s can optionally be executed if it's a function
825          access: function( elems, key, value, exec, fn, pass ) {
826                  var length = elems.length;
827  
828                  // Setting many attributes
829                  if ( typeof key === "object" ) {
830                          for ( var k in key ) {
831                                  jQuery.access( elems, k, key[k], exec, fn, value );
832                          }
833                          return elems;
834                  }
835  
836                  // Setting one attribute
837                  if ( value !== undefined ) {
838                          // Optionally, function values get executed if exec is true
839                          exec = !pass && exec && jQuery.isFunction(value);
840  
841                          for ( var i = 0; i < length; i++ ) {
842                                  fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
843                          }
844  
845                          return elems;
846                  }
847  
848                  // Getting an attribute
849                  return length ? fn( elems[0], key ) : undefined;
850          },
851  
852          now: function() {
853                  return ( new Date() ).getTime();
854          },
855  
856          // Use of jQuery.browser is frowned upon.
857          // More details: http://docs.jquery.com/Utilities/jQuery.browser
858          uaMatch: function( ua ) {
859                  ua = ua.toLowerCase();
860  
861                  var match = rwebkit.exec( ua ) ||
862                          ropera.exec( ua ) ||
863                          rmsie.exec( ua ) ||
864                          ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
865                          [];
866  
867                  return { browser: match[1] || "", version: match[2] || "0" };
868          },
869  
870          sub: function() {
871                  function jQuerySub( selector, context ) {
872                          return new jQuerySub.fn.init( selector, context );
873                  }
874                  jQuery.extend( true, jQuerySub, this );
875                  jQuerySub.superclass = this;
876                  jQuerySub.fn = jQuerySub.prototype = this();
877                  jQuerySub.fn.constructor = jQuerySub;
878                  jQuerySub.sub = this.sub;
879                  jQuerySub.fn.init = function init( selector, context ) {
880                          if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
881                                  context = jQuerySub( context );
882                          }
883  
884                          return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
885                  };
886                  jQuerySub.fn.init.prototype = jQuerySub.fn;
887                  var rootjQuerySub = jQuerySub(document);
888                  return jQuerySub;
889          },
890  
891          browser: {}
892  });
893  
894  // Populate the class2type map
895  jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
896          class2type[ "[object " + name + "]" ] = name.toLowerCase();
897  });
898  
899  browserMatch = jQuery.uaMatch( userAgent );
900  if ( browserMatch.browser ) {
901          jQuery.browser[ browserMatch.browser ] = true;
902          jQuery.browser.version = browserMatch.version;
903  }
904  
905  // Deprecated, use jQuery.browser.webkit instead
906  if ( jQuery.browser.webkit ) {
907          jQuery.browser.safari = true;
908  }
909  
910  // IE doesn't match non-breaking spaces with \s
911  if ( rnotwhite.test( "\xA0" ) ) {
912          trimLeft = /^[\s\xA0]+/;
913          trimRight = /[\s\xA0]+$/;
914  }
915  
916  // All jQuery objects should point back to these
917  rootjQuery = jQuery(document);
918  
919  // Cleanup functions for the document ready method
920  if ( document.addEventListener ) {
921          DOMContentLoaded = function() {
922                  document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
923                  jQuery.ready();
924          };
925  
926  } else if ( document.attachEvent ) {
927          DOMContentLoaded = function() {
928                  // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
929                  if ( document.readyState === "complete" ) {
930                          document.detachEvent( "onreadystatechange", DOMContentLoaded );
931                          jQuery.ready();
932                  }
933          };
934  }
935  
936  // The DOM ready check for Internet Explorer
937  function doScrollCheck() {
938          if ( jQuery.isReady ) {
939                  return;
940          }
941  
942          try {
943                  // If IE is used, use the trick by Diego Perini
944                  // http://javascript.nwbox.com/IEContentLoaded/
945                  document.documentElement.doScroll("left");
946          } catch(e) {
947                  setTimeout( doScrollCheck, 1 );
948                  return;
949          }
950  
951          // and execute any waiting functions
952          jQuery.ready();
953  }
954  
955  return jQuery;
956  
957  })();
958  
959  
960  // String to Object flags format cache
961  var flagsCache = {};
962  
963  // Convert String-formatted flags into Object-formatted ones and store in cache
964  function createFlags( flags ) {
965          var object = flagsCache[ flags ] = {},
966                  i, length;
967          flags = flags.split( /\s+/ );
968          for ( i = 0, length = flags.length; i < length; i++ ) {
969                  object[ flags[i] ] = true;
970          }
971          return object;
972  }
973  
974  /*
975   * Create a callback list using the following parameters:
976   *
977   *      flags:  an optional list of space-separated flags that will change how
978   *                      the callback list behaves
979   *
980   * By default a callback list will act like an event callback list and can be
981   * "fired" multiple times.
982   *
983   * Possible flags:
984   *
985   *      once:                   will ensure the callback list can only be fired once (like a Deferred)
986   *
987   *      memory:                 will keep track of previous values and will call any callback added
988   *                                      after the list has been fired right away with the latest "memorized"
989   *                                      values (like a Deferred)
990   *
991   *      unique:                 will ensure a callback can only be added once (no duplicate in the list)
992   *
993   *      stopOnFalse:    interrupt callings when a callback returns false
994   *
995   */
996  jQuery.Callbacks = function( flags ) {
997  
998          // Convert flags from String-formatted to Object-formatted
999          // (we check in cache first)
1000          flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1001  
1002          var // Actual callback list
1003                  list = [],
1004                  // Stack of fire calls for repeatable lists
1005                  stack = [],
1006                  // Last fire value (for non-forgettable lists)
1007                  memory,
1008                  // Flag to know if list is currently firing
1009                  firing,
1010                  // First callback to fire (used internally by add and fireWith)
1011                  firingStart,
1012                  // End of the loop when firing
1013                  firingLength,
1014                  // Index of currently firing callback (modified by remove if needed)
1015                  firingIndex,
1016                  // Add one or several callbacks to the list
1017                  add = function( args ) {
1018                          var i,
1019                                  length,
1020                                  elem,
1021                                  type,
1022                                  actual;
1023                          for ( i = 0, length = args.length; i < length; i++ ) {
1024                                  elem = args[ i ];
1025                                  type = jQuery.type( elem );
1026                                  if ( type === "array" ) {
1027                                          // Inspect recursively
1028                                          add( elem );
1029                                  } else if ( type === "function" ) {
1030                                          // Add if not in unique mode and callback is not in
1031                                          if ( !flags.unique || !self.has( elem ) ) {
1032                                                  list.push( elem );
1033                                          }
1034                                  }
1035                          }
1036                  },
1037                  // Fire callbacks
1038                  fire = function( context, args ) {
1039                          args = args || [];
1040                          memory = !flags.memory || [ context, args ];
1041                          firing = true;
1042                          firingIndex = firingStart || 0;
1043                          firingStart = 0;
1044                          firingLength = list.length;
1045                          for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1046                                  if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1047                                          memory = true; // Mark as halted
1048                                          break;
1049                                  }
1050                          }
1051                          firing = false;
1052                          if ( list ) {
1053                                  if ( !flags.once ) {
1054                                          if ( stack && stack.length ) {
1055                                                  memory = stack.shift();
1056                                                  self.fireWith( memory[ 0 ], memory[ 1 ] );
1057                                          }
1058                                  } else if ( memory === true ) {
1059                                          self.disable();
1060                                  } else {
1061                                          list = [];
1062                                  }
1063                          }
1064                  },
1065                  // Actual Callbacks object
1066                  self = {
1067                          // Add a callback or a collection of callbacks to the list
1068                          add: function() {
1069                                  if ( list ) {
1070                                          var length = list.length;
1071                                          add( arguments );
1072                                          // Do we need to add the callbacks to the
1073                                          // current firing batch?
1074                                          if ( firing ) {
1075                                                  firingLength = list.length;
1076                                          // With memory, if we're not firing then
1077                                          // we should call right away, unless previous
1078                                          // firing was halted (stopOnFalse)
1079                                          } else if ( memory && memory !== true ) {
1080                                                  firingStart = length;
1081                                                  fire( memory[ 0 ], memory[ 1 ] );
1082                                          }
1083                                  }
1084                                  return this;
1085                          },
1086                          // Remove a callback from the list
1087                          remove: function() {
1088                                  if ( list ) {
1089                                          var args = arguments,
1090                                                  argIndex = 0,
1091                                                  argLength = args.length;
1092                                          for ( ; argIndex < argLength ; argIndex++ ) {
1093                                                  for ( var i = 0; i < list.length; i++ ) {
1094                                                          if ( args[ argIndex ] === list[ i ] ) {
1095                                                                  // Handle firingIndex and firingLength
1096                                                                  if ( firing ) {
1097                                                                          if ( i <= firingLength ) {
1098                                                                                  firingLength--;
1099                                                                                  if ( i <= firingIndex ) {
1100                                                                                          firingIndex--;
1101                                                                                  }
1102                                                                          }
1103                                                                  }
1104                                                                  // Remove the element
1105                                                                  list.splice( i--, 1 );
1106                                                                  // If we have some unicity property then
1107                                                                  // we only need to do this once
1108                                                                  if ( flags.unique ) {
1109                                                                          break;
1110                                                                  }
1111                                                          }
1112                                                  }
1113                                          }
1114                                  }
1115                                  return this;
1116                          },
1117                          // Control if a given callback is in the list
1118                          has: function( fn ) {
1119                                  if ( list ) {
1120                                          var i = 0,
1121                                                  length = list.length;
1122                                          for ( ; i < length; i++ ) {
1123                                                  if ( fn === list[ i ] ) {
1124                                                          return true;
1125                                                  }
1126                                          }
1127                                  }
1128                                  return false;
1129                          },
1130                          // Remove all callbacks from the list
1131                          empty: function() {
1132                                  list = [];
1133                                  return this;
1134                          },
1135                          // Have the list do nothing anymore
1136                          disable: function() {
1137                                  list = stack = memory = undefined;
1138                                  return this;
1139                          },
1140                          // Is it disabled?
1141                          disabled: function() {
1142                                  return !list;
1143                          },
1144                          // Lock the list in its current state
1145                          lock: function() {
1146                                  stack = undefined;
1147                                  if ( !memory || memory === true ) {
1148                                          self.disable();
1149                                  }
1150                                  return this;
1151                          },
1152                          // Is it locked?
1153                          locked: function() {
1154                                  return !stack;
1155                          },
1156                          // Call all callbacks with the given context and arguments
1157                          fireWith: function( context, args ) {
1158                                  if ( stack ) {
1159                                          if ( firing ) {
1160                                                  if ( !flags.once ) {
1161                                                          stack.push( [ context, args ] );
1162                                                  }
1163                                          } else if ( !( flags.once && memory ) ) {
1164                                                  fire( context, args );
1165                                          }
1166                                  }
1167                                  return this;
1168                          },
1169                          // Call all the callbacks with the given arguments
1170                          fire: function() {
1171                                  self.fireWith( this, arguments );
1172                                  return this;
1173                          },
1174                          // To know if the callbacks have already been called at least once
1175                          fired: function() {
1176                                  return !!memory;
1177                          }
1178                  };
1179  
1180          return self;
1181  };
1182  
1183  
1184  
1185  
1186  var // Static reference to slice
1187          sliceDeferred = [].slice;
1188  
1189  jQuery.extend({
1190  
1191          Deferred: function( func ) {
1192                  var doneList = jQuery.Callbacks( "once memory" ),
1193                          failList = jQuery.Callbacks( "once memory" ),
1194                          progressList = jQuery.Callbacks( "memory" ),
1195                          state = "pending",
1196                          lists = {
1197                                  resolve: doneList,
1198                                  reject: failList,
1199                                  notify: progressList
1200                          },
1201                          promise = {
1202                                  done: doneList.add,
1203                                  fail: failList.add,
1204                                  progress: progressList.add,
1205  
1206                                  state: function() {
1207                                          return state;
1208                                  },
1209  
1210                                  // Deprecated
1211                                  isResolved: doneList.fired,
1212                                  isRejected: failList.fired,
1213  
1214                                  then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1215                                          deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1216                                          return this;
1217                                  },
1218                                  always: function() {
1219                                          deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1220                                          return this;
1221                                  },
1222                                  pipe: function( fnDone, fnFail, fnProgress ) {
1223                                          return jQuery.Deferred(function( newDefer ) {
1224                                                  jQuery.each( {
1225                                                          done: [ fnDone, "resolve" ],
1226                                                          fail: [ fnFail, "reject" ],
1227                                                          progress: [ fnProgress, "notify" ]
1228                                                  }, function( handler, data ) {
1229                                                          var fn = data[ 0 ],
1230                                                                  action = data[ 1 ],
1231                                                                  returned;
1232                                                          if ( jQuery.isFunction( fn ) ) {
1233                                                                  deferred[ handler ](function() {
1234                                                                          returned = fn.apply( this, arguments );
1235                                                                          if ( returned && jQuery.isFunction( returned.promise ) ) {
1236                                                                                  returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1237                                                                          } else {
1238                                                                                  newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1239                                                                          }
1240                                                                  });
1241                                                          } else {
1242                                                                  deferred[ handler ]( newDefer[ action ] );
1243                                                          }
1244                                                  });
1245                                          }).promise();
1246                                  },
1247                                  // Get a promise for this deferred
1248                                  // If obj is provided, the promise aspect is added to the object
1249                                  promise: function( obj ) {
1250                                          if ( obj == null ) {
1251                                                  obj = promise;
1252                                          } else {
1253                                                  for ( var key in promise ) {
1254                                                          obj[ key ] = promise[ key ];
1255                                                  }
1256                                          }
1257                                          return obj;
1258                                  }
1259                          },
1260                          deferred = promise.promise({}),
1261                          key;
1262  
1263                  for ( key in lists ) {
1264                          deferred[ key ] = lists[ key ].fire;
1265                          deferred[ key + "With" ] = lists[ key ].fireWith;
1266                  }
1267  
1268                  // Handle state
1269                  deferred.done( function() {
1270                          state = "resolved";
1271                  }, failList.disable, progressList.lock ).fail( function() {
1272                          state = "rejected";
1273                  }, doneList.disable, progressList.lock );
1274  
1275                  // Call given func if any
1276                  if ( func ) {
1277                          func.call( deferred, deferred );
1278                  }
1279  
1280                  // All done!
1281                  return deferred;
1282          },
1283  
1284          // Deferred helper
1285          when: function( firstParam ) {
1286                  var args = sliceDeferred.call( arguments, 0 ),
1287                          i = 0,
1288                          length = args.length,
1289                          pValues = new Array( length ),
1290                          count = length,
1291                          pCount = length,
1292                          deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1293                                  firstParam :
1294                                  jQuery.Deferred(),
1295                          promise = deferred.promise();
1296                  function resolveFunc( i ) {
1297                          return function( value ) {
1298                                  args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1299                                  if ( !( --count ) ) {
1300                                          deferred.resolveWith( deferred, args );
1301                                  }
1302                          };
1303                  }
1304                  function progressFunc( i ) {
1305                          return function( value ) {
1306                                  pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1307                                  deferred.notifyWith( promise, pValues );
1308                          };
1309                  }
1310                  if ( length > 1 ) {
1311                          for ( ; i < length; i++ ) {
1312                                  if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1313                                          args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1314                                  } else {
1315                                          --count;
1316                                  }
1317                          }
1318                          if ( !count ) {
1319                                  deferred.resolveWith( deferred, args );
1320                          }
1321                  } else if ( deferred !== firstParam ) {
1322                          deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1323                  }
1324                  return promise;
1325          }
1326  });
1327  
1328  
1329  
1330  
1331  jQuery.support = (function() {
1332  
1333          var support,
1334                  all,
1335                  a,
1336                  select,
1337                  opt,
1338                  input,
1339                  marginDiv,
1340                  fragment,
1341                  tds,
1342                  events,
1343                  eventName,
1344                  i,
1345                  isSupported,
1346                  div = document.createElement( "div" ),
1347                  documentElement = document.documentElement;
1348  
1349          // Preliminary tests
1350          div.setAttribute("className", "t");
1351          div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1352  
1353          all = div.getElementsByTagName( "*" );
1354          a = div.getElementsByTagName( "a" )[ 0 ];
1355  
1356          // Can't get basic test support
1357          if ( !all || !all.length || !a ) {
1358                  return {};
1359          }
1360  
1361          // First batch of supports tests
1362          select = document.createElement( "select" );
1363          opt = select.appendChild( document.createElement("option") );
1364          input = div.getElementsByTagName( "input" )[ 0 ];
1365  
1366          support = {
1367                  // IE strips leading whitespace when .innerHTML is used
1368                  leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1369  
1370                  // Make sure that tbody elements aren't automatically inserted
1371                  // IE will insert them into empty tables
1372                  tbody: !div.getElementsByTagName("tbody").length,
1373  
1374                  // Make sure that link elements get serialized correctly by innerHTML
1375                  // This requires a wrapper element in IE
1376                  htmlSerialize: !!div.getElementsByTagName("link").length,
1377  
1378                  // Get the style information from getAttribute
1379                  // (IE uses .cssText instead)
1380                  style: /top/.test( a.getAttribute("style") ),
1381  
1382                  // Make sure that URLs aren't manipulated
1383                  // (IE normalizes it by default)
1384                  hrefNormalized: ( a.getAttribute("href") === "/a" ),
1385  
1386                  // Make sure that element opacity exists
1387                  // (IE uses filter instead)
1388                  // Use a regex to work around a WebKit issue. See #5145
1389                  opacity: /^0.55/.test( a.style.opacity ),
1390  
1391                  // Verify style float existence
1392                  // (IE uses styleFloat instead of cssFloat)
1393                  cssFloat: !!a.style.cssFloat,
1394  
1395                  // Make sure that if no value is specified for a checkbox
1396                  // that it defaults to "on".
1397                  // (WebKit defaults to "" instead)
1398                  checkOn: ( input.value === "on" ),
1399  
1400                  // Make sure that a selected-by-default option has a working selected property.
1401                  // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1402                  optSelected: opt.selected,
1403  
1404                  // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1405                  getSetAttribute: div.className !== "t",
1406  
1407                  // Tests for enctype support on a form(#6743)
1408                  enctype: !!document.createElement("form").enctype,
1409  
1410                  // Makes sure cloning an html5 element does not cause problems
1411                  // Where outerHTML is undefined, this still works
1412                  html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1413  
1414                  // Will be defined later
1415                  submitBubbles: true,
1416                  changeBubbles: true,
1417                  focusinBubbles: false,
1418                  deleteExpando: true,
1419                  noCloneEvent: true,
1420                  inlineBlockNeedsLayout: false,
1421                  shrinkWrapBlocks: false,
1422                  reliableMarginRight: true
1423          };
1424  
1425          // Make sure checked status is properly cloned
1426          input.checked = true;
1427          support.noCloneChecked = input.cloneNode( true ).checked;
1428  
1429          // Make sure that the options inside disabled selects aren't marked as disabled
1430          // (WebKit marks them as disabled)
1431          select.disabled = true;
1432          support.optDisabled = !opt.disabled;
1433  
1434          // Test to see if it's possible to delete an expando from an element
1435          // Fails in Internet Explorer
1436          try {
1437                  delete div.test;
1438          } catch( e ) {
1439                  support.deleteExpando = false;
1440          }
1441  
1442          if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1443                  div.attachEvent( "onclick", function() {
1444                          // Cloning a node shouldn't copy over any
1445                          // bound event handlers (IE does this)
1446                          support.noCloneEvent = false;
1447                  });
1448                  div.cloneNode( true ).fireEvent( "onclick" );
1449          }
1450  
1451          // Check if a radio maintains its value
1452          // after being appended to the DOM
1453          input = document.createElement("input");
1454          input.value = "t";
1455          input.setAttribute("type", "radio");
1456          support.radioValue = input.value === "t";
1457  
1458          input.setAttribute("checked", "checked");
1459          div.appendChild( input );
1460          fragment = document.createDocumentFragment();
1461          fragment.appendChild( div.lastChild );
1462  
1463          // WebKit doesn't clone checked state correctly in fragments
1464          support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1465  
1466          // Check if a disconnected checkbox will retain its checked
1467          // value of true after appended to the DOM (IE6/7)
1468          support.appendChecked = input.checked;
1469  
1470          fragment.removeChild( input );
1471          fragment.appendChild( div );
1472  
1473          div.innerHTML = "";
1474  
1475          // Check if div with explicit width and no margin-right incorrectly
1476          // gets computed margin-right based on width of container. For more
1477          // info see bug #3333
1478          // Fails in WebKit before Feb 2011 nightlies
1479          // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1480          if ( window.getComputedStyle ) {
1481                  marginDiv = document.createElement( "div" );
1482                  marginDiv.style.width = "0";
1483                  marginDiv.style.marginRight = "0";
1484                  div.style.width = "2px";
1485                  div.appendChild( marginDiv );
1486                  support.reliableMarginRight =
1487                          ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1488          }
1489  
1490          // Technique from Juriy Zaytsev
1491          // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1492          // We only care about the case where non-standard event systems
1493          // are used, namely in IE. Short-circuiting here helps us to
1494          // avoid an eval call (in setAttribute) which can cause CSP
1495          // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1496          if ( div.attachEvent ) {
1497                  for( i in {
1498                          submit: 1,
1499                          change: 1,
1500                          focusin: 1
1501                  }) {
1502                          eventName = "on" + i;
1503                          isSupported = ( eventName in div );
1504                          if ( !isSupported ) {
1505                                  div.setAttribute( eventName, "return;" );
1506                                  isSupported = ( typeof div[ eventName ] === "function" );
1507                          }
1508                          support[ i + "Bubbles" ] = isSupported;
1509                  }
1510          }
1511  
1512          fragment.removeChild( div );
1513  
1514          // Null elements to avoid leaks in IE
1515          fragment = select = opt = marginDiv = div = input = null;
1516  
1517          // Run tests that need a body at doc ready
1518          jQuery(function() {
1519                  var container, outer, inner, table, td, offsetSupport,
1520                          conMarginTop, ptlm, vb, style, html,
1521                          body = document.getElementsByTagName("body")[0];
1522  
1523                  if ( !body ) {
1524                          // Return for frameset docs that don't have a body
1525                          return;
1526                  }
1527  
1528                  conMarginTop = 1;
1529                  ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";
1530                  vb = "visibility:hidden;border:0;";
1531                  style = "style='" + ptlm + "border:5px solid #000;padding:0;'";
1532                  html = "<div " + style + "><div></div></div>" +
1533                          "<table " + style + " cellpadding='0' cellspacing='0'>" +
1534                          "<tr><td></td></tr></table>";
1535  
1536                  container = document.createElement("div");
1537                  container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
1538                  body.insertBefore( container, body.firstChild );
1539  
1540                  // Construct the test element
1541                  div = document.createElement("div");
1542                  container.appendChild( div );
1543  
1544                  // Check if table cells still have offsetWidth/Height when they are set
1545                  // to display:none and there are still other visible table cells in a
1546                  // table row; if so, offsetWidth/Height are not reliable for use when
1547                  // determining if an element has been hidden directly using
1548                  // display:none (it is still safe to use offsets if a parent element is
1549                  // hidden; don safety goggles and see bug #4512 for more information).
1550                  // (only IE 8 fails this test)
1551                  div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1552                  tds = div.getElementsByTagName( "td" );
1553                  isSupported = ( tds[ 0 ].offsetHeight === 0 );
1554  
1555                  tds[ 0 ].style.display = "";
1556                  tds[ 1 ].style.display = "none";
1557  
1558                  // Check if empty table cells still have offsetWidth/Height
1559                  // (IE <= 8 fail this test)
1560                  support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1561  
1562                  // Figure out if the W3C box model works as expected
1563                  div.innerHTML = "";
1564                  div.style.width = div.style.paddingLeft = "1px";
1565                  jQuery.boxModel = support.boxModel = div.offsetWidth === 2;
1566  
1567                  if ( typeof div.style.zoom !== "undefined" ) {
1568                          // Check if natively block-level elements act like inline-block
1569                          // elements when setting their display to 'inline' and giving
1570                          // them layout
1571                          // (IE < 8 does this)
1572                          div.style.display = "inline";
1573                          div.style.zoom = 1;
1574                          support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1575  
1576                          // Check if elements with layout shrink-wrap their children
1577                          // (IE 6 does this)
1578                          div.style.display = "";
1579                          div.innerHTML = "<div style='width:4px;'></div>";
1580                          support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1581                  }
1582  
1583                  div.style.cssText = ptlm + vb;
1584                  div.innerHTML = html;
1585  
1586                  outer = div.firstChild;
1587                  inner = outer.firstChild;
1588                  td = outer.nextSibling.firstChild.firstChild;
1589  
1590                  offsetSupport = {
1591                          doesNotAddBorder: ( inner.offsetTop !== 5 ),
1592                          doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
1593                  };
1594  
1595                  inner.style.position = "fixed";
1596                  inner.style.top = "20px";
1597  
1598                  // safari subtracts parent border width here which is 5px
1599                  offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
1600                  inner.style.position = inner.style.top = "";
1601  
1602                  outer.style.overflow = "hidden";
1603                  outer.style.position = "relative";
1604  
1605                  offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
1606                  offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
1607  
1608                  body.removeChild( container );
1609                  div  = container = null;
1610  
1611                  jQuery.extend( support, offsetSupport );
1612          });
1613  
1614          return support;
1615  })();
1616  
1617  
1618  
1619  
1620  var rbrace = /^(?:\{.*\}|\[.*\])$/,
1621          rmultiDash = /([A-Z])/g;
1622  
1623  jQuery.extend({
1624          cache: {},
1625  
1626          // Please use with caution
1627          uuid: 0,
1628  
1629          // Unique for each copy of jQuery on the page
1630          // Non-digits removed to match rinlinejQuery
1631          expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1632  
1633          // The following elements throw uncatchable exceptions if you
1634          // attempt to add expando properties to them.
1635          noData: {
1636                  "embed": true,
1637                  // Ban all objects except for Flash (which handle expandos)
1638                  "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1639                  "applet": true
1640          },
1641  
1642          hasData: function( elem ) {
1643                  elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1644                  return !!elem && !isEmptyDataObject( elem );
1645          },
1646  
1647          data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1648                  if ( !jQuery.acceptData( elem ) ) {
1649                          return;
1650                  }
1651  
1652                  var privateCache, thisCache, ret,
1653                          internalKey = jQuery.expando,
1654                          getByName = typeof name === "string",
1655  
1656                          // We have to handle DOM nodes and JS objects differently because IE6-7
1657                          // can't GC object references properly across the DOM-JS boundary
1658                          isNode = elem.nodeType,
1659  
1660                          // Only DOM nodes need the global jQuery cache; JS object data is
1661                          // attached directly to the object so GC can occur automatically
1662                          cache = isNode ? jQuery.cache : elem,
1663  
1664                          // Only defining an ID for JS objects if its cache already exists allows
1665                          // the code to shortcut on the same path as a DOM node with no cache
1666                          id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
1667                          isEvents = name === "events";
1668  
1669                  // Avoid doing any more work than we need to when trying to get data on an
1670                  // object that has no data at all
1671                  if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
1672                          return;
1673                  }
1674  
1675                  if ( !id ) {
1676                          // Only DOM nodes need a new unique ID for each element since their data
1677                          // ends up in the global cache
1678                          if ( isNode ) {
1679                                  elem[ internalKey ] = id = ++jQuery.uuid;
1680                          } else {
1681                                  id = internalKey;
1682                          }
1683                  }
1684  
1685                  if ( !cache[ id ] ) {
1686                          cache[ id ] = {};
1687  
1688                          // Avoids exposing jQuery metadata on plain JS objects when the object
1689                          // is serialized using JSON.stringify
1690                          if ( !isNode ) {
1691                                  cache[ id ].toJSON = jQuery.noop;
1692                          }
1693                  }
1694  
1695                  // An object can be passed to jQuery.data instead of a key/value pair; this gets
1696                  // shallow copied over onto the existing cache
1697                  if ( typeof name === "object" || typeof name === "function" ) {
1698                          if ( pvt ) {
1699                                  cache[ id ] = jQuery.extend( cache[ id ], name );
1700                          } else {
1701                                  cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1702                          }
1703                  }
1704  
1705                  privateCache = thisCache = cache[ id ];
1706  
1707                  // jQuery data() is stored in a separate object inside the object's internal data
1708                  // cache in order to avoid key collisions between internal data and user-defined
1709                  // data.
1710                  if ( !pvt ) {
1711                          if ( !thisCache.data ) {
1712                                  thisCache.data = {};
1713                          }
1714  
1715                          thisCache = thisCache.data;
1716                  }
1717  
1718                  if ( data !== undefined ) {
1719                          thisCache[ jQuery.camelCase( name ) ] = data;
1720                  }
1721  
1722                  // Users should not attempt to inspect the internal events object using jQuery.data,
1723                  // it is undocumented and subject to change. But does anyone listen? No.
1724                  if ( isEvents && !thisCache[ name ] ) {
1725                          return privateCache.events;
1726                  }
1727  
1728                  // Check for both converted-to-camel and non-converted data property names
1729                  // If a data property was specified
1730                  if ( getByName ) {
1731  
1732                          // First Try to find as-is property data
1733                          ret = thisCache[ name ];
1734  
1735                          // Test for null|undefined property data
1736                          if ( ret == null ) {
1737  
1738                                  // Try to find the camelCased property
1739                                  ret = thisCache[ jQuery.camelCase( name ) ];
1740                          }
1741                  } else {
1742                          ret = thisCache;
1743                  }
1744  
1745                  return ret;
1746          },
1747  
1748          removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1749                  if ( !jQuery.acceptData( elem ) ) {
1750                          return;
1751                  }
1752  
1753                  var thisCache, i, l,
1754  
1755                          // Reference to internal data cache key
1756                          internalKey = jQuery.expando,
1757  
1758                          isNode = elem.nodeType,
1759  
1760                          // See jQuery.data for more information
1761                          cache = isNode ? jQuery.cache : elem,
1762  
1763                          // See jQuery.data for more information
1764                          id = isNode ? elem[ internalKey ] : internalKey;
1765  
1766                  // If there is already no cache entry for this object, there is no
1767                  // purpose in continuing
1768                  if ( !cache[ id ] ) {
1769                          return;
1770                  }
1771  
1772                  if ( name ) {
1773  
1774                          thisCache = pvt ? cache[ id ] : cache[ id ].data;
1775  
1776                          if ( thisCache ) {
1777  
1778                                  // Support array or space separated string names for data keys
1779                                  if ( !jQuery.isArray( name ) ) {
1780  
1781                                          // try the string as a key before any manipulation
1782                                          if ( name in thisCache ) {
1783                                                  name = [ name ];
1784                                          } else {
1785  
1786                                                  // split the camel cased version by spaces unless a key with the spaces exists
1787                                                  name = jQuery.camelCase( name );
1788                                                  if ( name in thisCache ) {
1789                                                          name = [ name ];
1790                                                  } else {
1791                                                          name = name.split( " " );
1792                                                  }
1793                                          }
1794                                  }
1795  
1796                                  for ( i = 0, l = name.length; i < l; i++ ) {
1797                                          delete thisCache[ name[i] ];
1798                                  }
1799  
1800                                  // If there is no data left in the cache, we want to continue
1801                                  // and let the cache object itself get destroyed
1802                                  if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1803                                          return;
1804                                  }
1805                          }
1806                  }
1807  
1808                  // See jQuery.data for more information
1809                  if ( !pvt ) {
1810                          delete cache[ id ].data;
1811  
1812                          // Don't destroy the parent cache unless the internal data object
1813                          // had been the only thing left in it
1814                          if ( !isEmptyDataObject(cache[ id ]) ) {
1815                                  return;
1816                          }
1817                  }
1818  
1819                  // Browsers that fail expando deletion also refuse to delete expandos on
1820                  // the window, but it will allow it on all other JS objects; other browsers
1821                  // don't care
1822                  // Ensure that `cache` is not a window object #10080
1823                  if ( jQuery.support.deleteExpando || !cache.setInterval ) {
1824                          delete cache[ id ];
1825                  } else {
1826                          cache[ id ] = null;
1827                  }
1828  
1829                  // We destroyed the cache and need to eliminate the expando on the node to avoid
1830                  // false lookups in the cache for entries that no longer exist
1831                  if ( isNode ) {
1832                          // IE does not allow us to delete expando properties from nodes,
1833                          // nor does it have a removeAttribute function on Document nodes;
1834                          // we must handle all of these cases
1835                          if ( jQuery.support.deleteExpando ) {
1836                                  delete elem[ internalKey ];
1837                          } else if ( elem.removeAttribute ) {
1838                                  elem.removeAttribute( internalKey );
1839                          } else {
1840                                  elem[ internalKey ] = null;
1841                          }
1842                  }
1843          },
1844  
1845          // For internal use only.
1846          _data: function( elem, name, data ) {
1847                  return jQuery.data( elem, name, data, true );
1848          },
1849  
1850          // A method for determining if a DOM node can handle the data expando
1851          acceptData: function( elem ) {
1852                  if ( elem.nodeName ) {
1853                          var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1854  
1855                          if ( match ) {
1856                                  return !(match === true || elem.getAttribute("classid") !== match);
1857                          }
1858                  }
1859  
1860                  return true;
1861          }
1862  });
1863  
1864  jQuery.fn.extend({
1865          data: function( key, value ) {
1866                  var parts, attr, name,
1867                          data = null;
1868  
1869                  if ( typeof key === "undefined" ) {
1870                          if ( this.length ) {
1871                                  data = jQuery.data( this[0] );
1872  
1873                                  if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) {
1874                                          attr = this[0].attributes;
1875                                          for ( var i = 0, l = attr.length; i < l; i++ ) {
1876                                                  name = attr[i].name;
1877  
1878                                                  if ( name.indexOf( "data-" ) === 0 ) {
1879                                                          name = jQuery.camelCase( name.substring(5) );
1880  
1881                                                          dataAttr( this[0], name, data[ name ] );
1882                                                  }
1883                                          }
1884                                          jQuery._data( this[0], "parsedAttrs", true );
1885                                  }
1886                          }
1887  
1888                          return data;
1889  
1890                  } else if ( typeof key === "object" ) {
1891                          return this.each(function() {
1892                                  jQuery.data( this, key );
1893                          });
1894                  }
1895  
1896                  parts = key.split(".");
1897                  parts[1] = parts[1] ? "." + parts[1] : "";
1898  
1899                  if ( value === undefined ) {
1900                          data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1901  
1902                          // Try to fetch any internally stored data first
1903                          if ( data === undefined && this.length ) {
1904                                  data = jQuery.data( this[0], key );
1905                                  data = dataAttr( this[0], key, data );
1906                          }
1907  
1908                          return data === undefined && parts[1] ?
1909                                  this.data( parts[0] ) :
1910                                  data;
1911  
1912                  } else {
1913                          return this.each(function() {
1914                                  var self = jQuery( this ),
1915                                          args = [ parts[0], value ];
1916  
1917                                  self.triggerHandler( "setData" + parts[1] + "!", args );
1918                                  jQuery.data( this, key, value );
1919                                  self.triggerHandler( "changeData" + parts[1] + "!", args );
1920                          });
1921                  }
1922          },
1923  
1924          removeData: function( key ) {
1925                  return this.each(function() {
1926                          jQuery.removeData( this, key );
1927                  });
1928          }
1929  });
1930  
1931  function dataAttr( elem, key, data ) {
1932          // If nothing was found internally, try to fetch any
1933          // data from the HTML5 data-* attribute
1934          if ( data === undefined && elem.nodeType === 1 ) {
1935  
1936                  var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1937  
1938                  data = elem.getAttribute( name );
1939  
1940                  if ( typeof data === "string" ) {
1941                          try {
1942                                  data = data === "true" ? true :
1943                                  data === "false" ? false :
1944                                  data === "null" ? null :
1945                                  jQuery.isNumeric( data ) ? parseFloat( data ) :
1946                                          rbrace.test( data ) ? jQuery.parseJSON( data ) :
1947                                          data;
1948                          } catch( e ) {}
1949  
1950                          // Make sure we set the data so it isn't changed later
1951                          jQuery.data( elem, key, data );
1952  
1953                  } else {
1954                          data = undefined;
1955                  }
1956          }
1957  
1958          return data;
1959  }
1960  
1961  // checks a cache object for emptiness
1962  function isEmptyDataObject( obj ) {
1963          for ( var name in obj ) {
1964  
1965                  // if the public data object is empty, the private is still empty
1966                  if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1967                          continue;
1968                  }
1969                  if ( name !== "toJSON" ) {
1970                          return false;
1971                  }
1972          }
1973  
1974          return true;
1975  }
1976  
1977  
1978  
1979  
1980  function handleQueueMarkDefer( elem, type, src ) {
1981          var deferDataKey = type + "defer",
1982                  queueDataKey = type + "queue",
1983                  markDataKey = type + "mark",
1984                  defer = jQuery._data( elem, deferDataKey );
1985          if ( defer &&
1986                  ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
1987                  ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
1988                  // Give room for hard-coded callbacks to fire first
1989                  // and eventually mark/queue something else on the element
1990                  setTimeout( function() {
1991                          if ( !jQuery._data( elem, queueDataKey ) &&
1992                                  !jQuery._data( elem, markDataKey ) ) {
1993                                  jQuery.removeData( elem, deferDataKey, true );
1994                                  defer.fire();
1995                          }
1996                  }, 0 );
1997          }
1998  }
1999  
2000  jQuery.extend({
2001  
2002          _mark: function( elem, type ) {
2003                  if ( elem ) {
2004                          type = ( type || "fx" ) + "mark";
2005                          jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
2006                  }
2007          },
2008  
2009          _unmark: function( force, elem, type ) {
2010                  if ( force !== true ) {
2011                          type = elem;
2012                          elem = force;
2013                          force = false;
2014                  }
2015                  if ( elem ) {
2016                          type = type || "fx";
2017                          var key = type + "mark",
2018                                  count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
2019                          if ( count ) {
2020                                  jQuery._data( elem, key, count );
2021                          } else {
2022                                  jQuery.removeData( elem, key, true );
2023                                  handleQueueMarkDefer( elem, type, "mark" );
2024                          }
2025                  }
2026          },
2027  
2028          queue: function( elem, type, data ) {
2029                  var q;
2030                  if ( elem ) {
2031                          type = ( type || "fx" ) + "queue";
2032                          q = jQuery._data( elem, type );
2033  
2034                          // Speed up dequeue by getting out quickly if this is just a lookup
2035                          if ( data ) {
2036                                  if ( !q || jQuery.isArray(data) ) {
2037                                          q = jQuery._data( elem, type, jQuery.makeArray(data) );
2038                                  } else {
2039                                          q.push( data );
2040                                  }
2041                          }
2042                          return q || [];
2043                  }
2044          },
2045  
2046          dequeue: function( elem, type ) {
2047                  type = type || "fx";
2048  
2049                  var queue = jQuery.queue( elem, type ),
2050                          fn = queue.shift(),
2051                          hooks = {};
2052  
2053                  // If the fx queue is dequeued, always remove the progress sentinel
2054                  if ( fn === "inprogress" ) {
2055                          fn = queue.shift();
2056                  }
2057  
2058                  if ( fn ) {
2059                          // Add a progress sentinel to prevent the fx queue from being
2060                          // automatically dequeued
2061                          if ( type === "fx" ) {
2062                                  queue.unshift( "inprogress" );
2063                          }
2064  
2065                          jQuery._data( elem, type + ".run", hooks );
2066                          fn.call( elem, function() {
2067                                  jQuery.dequeue( elem, type );
2068                          }, hooks );
2069                  }
2070  
2071                  if ( !queue.length ) {
2072                          jQuery.removeData( elem, type + "queue " + type + ".run", true );
2073                          handleQueueMarkDefer( elem, type, "queue" );
2074                  }
2075          }
2076  });
2077  
2078  jQuery.fn.extend({
2079          queue: function( type, data ) {
2080                  if ( typeof type !== "string" ) {
2081                          data = type;
2082                          type = "fx";
2083                  }
2084  
2085                  if ( data === undefined ) {
2086                          return jQuery.queue( this[0], type );
2087                  }
2088                  return this.each(function() {
2089                          var queue = jQuery.queue( this, type, data );
2090  
2091                          if ( type === "fx" && queue[0] !== "inprogress" ) {
2092                                  jQuery.dequeue( this, type );
2093                          }
2094                  });
2095          },
2096          dequeue: function( type ) {
2097                  return this.each(function() {
2098                          jQuery.dequeue( this, type );
2099                  });
2100          },
2101          // Based off of the plugin by Clint Helfers, with permission.
2102          // http://blindsignals.com/index.php/2009/07/jquery-delay/
2103          delay: function( time, type ) {
2104                  time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2105                  type = type || "fx";
2106  
2107                  return this.queue( type, function( next, hooks ) {
2108                          var timeout = setTimeout( next, time );
2109                          hooks.stop = function() {
2110                                  clearTimeout( timeout );
2111                          };
2112                  });
2113          },
2114          clearQueue: function( type ) {
2115                  return this.queue( type || "fx", [] );
2116          },
2117          // Get a promise resolved when queues of a certain type
2118          // are emptied (fx is the type by default)
2119          promise: function( type, object ) {
2120                  if ( typeof type !== "string" ) {
2121                          object = type;
2122                          type = undefined;
2123                  }
2124                  type = type || "fx";
2125                  var defer = jQuery.Deferred(),
2126                          elements = this,
2127                          i = elements.length,
2128                          count = 1,
2129                          deferDataKey = type + "defer",
2130                          queueDataKey = type + "queue",
2131                          markDataKey = type + "mark",
2132                          tmp;
2133                  function resolve() {
2134                          if ( !( --count ) ) {
2135                                  defer.resolveWith( elements, [ elements ] );
2136                          }
2137                  }
2138                  while( i-- ) {
2139                          if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2140                                          ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2141                                                  jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2142                                          jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2143                                  count++;
2144                                  tmp.add( resolve );
2145                          }
2146                  }
2147                  resolve();
2148                  return defer.promise();
2149          }
2150  });
2151  
2152  
2153  
2154  
2155  var rclass = /[\n\t\r]/g,
2156          rspace = /\s+/,
2157          rreturn = /\r/g,
2158          rtype = /^(?:button|input)$/i,
2159          rfocusable = /^(?:button|input|object|select|textarea)$/i,
2160          rclickable = /^a(?:rea)?$/i,
2161          rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2162          getSetAttribute = jQuery.support.getSetAttribute,
2163          nodeHook, boolHook, fixSpecified;
2164  
2165  jQuery.fn.extend({
2166          attr: function( name, value ) {
2167                  return jQuery.access( this, name, value, true, jQuery.attr );
2168          },
2169  
2170          removeAttr: function( name ) {
2171                  return this.each(function() {
2172                          jQuery.removeAttr( this, name );
2173                  });
2174          },
2175  
2176          prop: function( name, value ) {
2177                  return jQuery.access( this, name, value, true, jQuery.prop );
2178          },
2179  
2180          removeProp: function( name ) {
2181                  name = jQuery.propFix[ name ] || name;
2182                  return this.each(function() {
2183                          // try/catch handles cases where IE balks (such as removing a property on window)
2184                          try {
2185                                  this[ name ] = undefined;
2186                                  delete this[ name ];
2187                          } catch( e ) {}
2188                  });
2189          },
2190  
2191          addClass: function( value ) {
2192                  var classNames, i, l, elem,
2193                          setClass, c, cl;
2194  
2195                  if ( jQuery.isFunction( value ) ) {
2196                          return this.each(function( j ) {
2197                                  jQuery( this ).addClass( value.call(this, j, this.className) );
2198                          });
2199                  }
2200  
2201                  if ( value && typeof value === "string" ) {
2202                          classNames = value.split( rspace );
2203  
2204                          for ( i = 0, l = this.length; i < l; i++ ) {
2205                                  elem = this[ i ];
2206  
2207                                  if ( elem.nodeType === 1 ) {
2208                                          if ( !elem.className && classNames.length === 1 ) {
2209                                                  elem.className = value;
2210  
2211                                          } else {
2212                                                  setClass = " " + elem.className + " ";
2213  
2214                                                  for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2215                                                          if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2216                                                                  setClass += classNames[ c ] + " ";
2217                                                          }
2218                                                  }
2219                                                  elem.className = jQuery.trim( setClass );
2220                                          }
2221                                  }
2222                          }
2223                  }
2224  
2225                  return this;
2226          },
2227  
2228          removeClass: function( value ) {
2229                  var classNames, i, l, elem, className, c, cl;
2230  
2231                  if ( jQuery.isFunction( value ) ) {
2232                          return this.each(function( j ) {
2233                                  jQuery( this ).removeClass( value.call(this, j, this.className) );
2234                          });
2235                  }
2236  
2237                  if ( (value && typeof value === "string") || value === undefined ) {
2238                          classNames = ( value || "" ).split( rspace );
2239  
2240                          for ( i = 0, l = this.length; i < l; i++ ) {
2241                                  elem = this[ i ];
2242  
2243                                  if ( elem.nodeType === 1 && elem.className ) {
2244                                          if ( value ) {
2245                                                  className = (" " + elem.className + " ").replace( rclass, " " );
2246                                                  for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2247                                                          className = className.replace(" " + classNames[ c ] + " ", " ");
2248                                                  }
2249                                                  elem.className = jQuery.trim( className );
2250  
2251                                          } else {
2252                                                  elem.className = "";
2253                                          }
2254                                  }
2255                          }
2256                  }
2257  
2258                  return this;
2259          },
2260  
2261          toggleClass: function( value, stateVal ) {
2262                  var type = typeof value,
2263                          isBool = typeof stateVal === "boolean";
2264  
2265                  if ( jQuery.isFunction( value ) ) {
2266                          return this.each(function( i ) {
2267                                  jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2268                          });
2269                  }
2270  
2271                  return this.each(function() {
2272                          if ( type === "string" ) {
2273                                  // toggle individual class names
2274                                  var className,
2275                                          i = 0,
2276                                          self = jQuery( this ),
2277                                          state = stateVal,
2278                                          classNames = value.split( rspace );
2279  
2280                                  while ( (className = classNames[ i++ ]) ) {
2281                                          // check each className given, space seperated list
2282                                          state = isBool ? state : !self.hasClass( className );
2283                                          self[ state ? "addClass" : "removeClass" ]( className );
2284                                  }
2285  
2286                          } else if ( type === "undefined" || type === "boolean" ) {
2287                                  if ( this.className ) {
2288                                          // store className if set
2289                                          jQuery._data( this, "__className__", this.className );
2290                                  }
2291  
2292                                  // toggle whole className
2293                                  this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2294                          }
2295                  });
2296          },
2297  
2298          hasClass: function( selector ) {
2299                  var className = " " + selector + " ",
2300                          i = 0,
2301                          l = this.length;
2302                  for ( ; i < l; i++ ) {
2303                          if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2304                                  return true;
2305                          }
2306                  }
2307  
2308                  return false;
2309          },
2310  
2311          val: function( value ) {
2312                  var hooks, ret, isFunction,
2313                          elem = this[0];
2314  
2315                  if ( !arguments.length ) {
2316                          if ( elem ) {
2317                                  hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2318  
2319                                  if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2320                                          return ret;
2321                                  }
2322  
2323                                  ret = elem.value;
2324  
2325                                  return typeof ret === "string" ?
2326                                          // handle most common string cases
2327                                          ret.replace(rreturn, "") :
2328                                          // handle cases where value is null/undef or number
2329                                          ret == null ? "" : ret;
2330                          }
2331  
2332                          return;
2333                  }
2334  
2335                  isFunction = jQuery.isFunction( value );
2336  
2337                  return this.each(function( i ) {
2338                          var self = jQuery(this), val;
2339  
2340                          if ( this.nodeType !== 1 ) {
2341                                  return;
2342                          }
2343  
2344                          if ( isFunction ) {
2345                                  val = value.call( this, i, self.val() );
2346                          } else {
2347                                  val = value;
2348                          }
2349  
2350                          // Treat null/undefined as ""; convert numbers to string
2351                          if ( val == null ) {
2352                                  val = "";
2353                          } else if ( typeof val === "number" ) {
2354                                  val += "";
2355                          } else if ( jQuery.isArray( val ) ) {
2356                                  val = jQuery.map(val, function ( value ) {
2357                                          return value == null ? "" : value + "";
2358                                  });
2359                          }
2360  
2361                          hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2362  
2363                          // If set returns undefined, fall back to normal setting
2364                          if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2365                                  this.value = val;
2366                          }
2367                  });
2368          }
2369  });
2370  
2371  jQuery.extend({
2372          valHooks: {
2373                  option: {
2374                          get: function( elem ) {
2375                                  // attributes.value is undefined in Blackberry 4.7 but
2376                                  // uses .value. See #6932
2377                                  var val = elem.attributes.value;
2378                                  return !val || val.specified ? elem.value : elem.text;
2379                          }
2380                  },
2381                  select: {
2382                          get: function( elem ) {
2383                                  var value, i, max, option,
2384                                          index = elem.selectedIndex,
2385                                          values = [],
2386                                          options = elem.options,
2387                                          one = elem.type === "select-one";
2388  
2389                                  // Nothing was selected
2390                                  if ( index < 0 ) {
2391                                          return null;
2392                                  }
2393  
2394                                  // Loop through all the selected options
2395                                  i = one ? index : 0;
2396                                  max = one ? index + 1 : options.length;
2397                                  for ( ; i < max; i++ ) {
2398                                          option = options[ i ];
2399  
2400                                          // Don't return options that are disabled or in a disabled optgroup
2401                                          if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2402                                                          (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2403  
2404                                                  // Get the specific value for the option
2405                                                  value = jQuery( option ).val();
2406  
2407                                                  // We don't need an array for one selects
2408                                                  if ( one ) {
2409                                                          return value;
2410                                                  }
2411  
2412                                                  // Multi-Selects return an array
2413                                                  values.push( value );
2414                                          }
2415                                  }
2416  
2417                                  // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2418                                  if ( one && !values.length && options.length ) {
2419                                          return jQuery( options[ index ] ).val();
2420                                  }
2421  
2422                                  return values;
2423                          },
2424  
2425                          set: function( elem, value ) {
2426                                  var values = jQuery.makeArray( value );
2427  
2428                                  jQuery(elem).find("option").each(function() {
2429                                          this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2430                                  });
2431  
2432                                  if ( !values.length ) {
2433                                          elem.selectedIndex = -1;
2434                                  }
2435                                  return values;
2436                          }
2437                  }
2438          },
2439  
2440          attrFn: {
2441                  val: true,
2442                  css: true,
2443                  html: true,
2444                  text: true,
2445                  data: true,
2446                  width: true,
2447                  height: true,
2448                  offset: true
2449          },
2450  
2451          attr: function( elem, name, value, pass ) {
2452                  var ret, hooks, notxml,
2453                          nType = elem.nodeType;
2454  
2455                  // don't get/set attributes on text, comment and attribute nodes
2456                  if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2457                          return;
2458                  }
2459  
2460                  if ( pass && name in jQuery.attrFn ) {
2461                          return jQuery( elem )[ name ]( value );
2462                  }
2463  
2464                  // Fallback to prop when attributes are not supported
2465                  if ( typeof elem.getAttribute === "undefined" ) {
2466                          return jQuery.prop( elem, name, value );
2467                  }
2468  
2469                  notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2470  
2471                  // All attributes are lowercase
2472                  // Grab necessary hook if one is defined
2473                  if ( notxml ) {
2474                          name = name.toLowerCase();
2475                          hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2476                  }
2477  
2478                  if ( value !== undefined ) {
2479  
2480                          if ( value === null ) {
2481                                  jQuery.removeAttr( elem, name );
2482                                  return;
2483  
2484                          } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2485                                  return ret;
2486  
2487                          } else {
2488                                  elem.setAttribute( name, "" + value );
2489                                  return value;
2490                          }
2491  
2492                  } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2493                          return ret;
2494  
2495                  } else {
2496  
2497                          ret = elem.getAttribute( name );
2498  
2499                          // Non-existent attributes return null, we normalize to undefined
2500                          return ret === null ?
2501                                  undefined :
2502                                  ret;
2503                  }
2504          },
2505  
2506          removeAttr: function( elem, value ) {
2507                  var propName, attrNames, name, l,
2508                          i = 0;
2509  
2510                  if ( value && elem.nodeType === 1 ) {
2511                          attrNames = value.toLowerCase().split( rspace );
2512                          l = attrNames.length;
2513  
2514                          for ( ; i < l; i++ ) {
2515                                  name = attrNames[ i ];
2516  
2517                                  if ( name ) {
2518                                          propName = jQuery.propFix[ name ] || name;
2519  
2520                                          // See #9699 for explanation of this approach (setting first, then removal)
2521                                          jQuery.attr( elem, name, "" );
2522                                          elem.removeAttribute( getSetAttribute ? name : propName );
2523  
2524                                          // Set corresponding property to false for boolean attributes
2525                                          if ( rboolean.test( name ) && propName in elem ) {
2526                                                  elem[ propName ] = false;
2527                                          }
2528                                  }
2529                          }
2530                  }
2531          },
2532  
2533          attrHooks: {
2534                  type: {
2535                          set: function( elem, value ) {
2536                                  // We can't allow the type property to be changed (since it causes problems in IE)
2537                                  if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2538                                          jQuery.error( "type property can't be changed" );
2539                                  } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2540                                          // Setting the type on a radio button after the value resets the value in IE6-9
2541                                          // Reset value to it's default in case type is set after value
2542                                          // This is for element creation
2543                                          var val = elem.value;
2544                                          elem.setAttribute( "type", value );
2545                                          if ( val ) {
2546                                                  elem.value = val;
2547                                          }
2548                                          return value;
2549                                  }
2550                          }
2551                  },
2552                  // Use the value property for back compat
2553                  // Use the nodeHook for button elements in IE6/7 (#1954)
2554                  value: {
2555                          get: function( elem, name ) {
2556                                  if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2557                                          return nodeHook.get( elem, name );
2558                                  }
2559                                  return name in elem ?
2560                                          elem.value :
2561                                          null;
2562                          },
2563                          set: function( elem, value, name ) {
2564                                  if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2565                                          return nodeHook.set( elem, value, name );
2566                                  }
2567                                  // Does not return so that setAttribute is also used
2568                                  elem.value = value;
2569                          }
2570                  }
2571          },
2572  
2573          propFix: {
2574                  tabindex: "tabIndex",
2575                  readonly: "readOnly",
2576                  "for": "htmlFor",
2577                  "class": "className",
2578                  maxlength: "maxLength",
2579                  cellspacing: "cellSpacing",
2580                  cellpadding: "cellPadding",
2581                  rowspan: "rowSpan",
2582                  colspan: "colSpan",
2583                  usemap: "useMap",
2584                  frameborder: "frameBorder",
2585                  contenteditable: "contentEditable"
2586          },
2587  
2588          prop: function( elem, name, value ) {
2589                  var ret, hooks, notxml,
2590                          nType = elem.nodeType;
2591  
2592                  // don't get/set properties on text, comment and attribute nodes
2593                  if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2594                          return;
2595                  }
2596  
2597                  notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2598  
2599                  if ( notxml ) {
2600                          // Fix name and attach hooks
2601                          name = jQuery.propFix[ name ] || name;
2602                          hooks = jQuery.propHooks[ name ];
2603                  }
2604  
2605                  if ( value !== undefined ) {
2606                          if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2607                                  return ret;
2608  
2609                          } else {
2610                                  return ( elem[ name ] = value );
2611                          }
2612  
2613                  } else {
2614                          if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2615                                  return ret;
2616  
2617                          } else {
2618                                  return elem[ name ];
2619                          }
2620                  }
2621          },
2622  
2623          propHooks: {
2624                  tabIndex: {
2625                          get: function( elem ) {
2626                                  // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2627                                  // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2628                                  var attributeNode = elem.getAttributeNode("tabindex");
2629  
2630                                  return attributeNode && attributeNode.specified ?
2631                                          parseInt( attributeNode.value, 10 ) :
2632                                          rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2633                                                  0 :
2634                                                  undefined;
2635                          }
2636                  }
2637          }
2638  });
2639  
2640  // Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2641  jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2642  
2643  // Hook for boolean attributes
2644  boolHook = {
2645          get: function( elem, name ) {
2646                  // Align boolean attributes with corresponding properties
2647                  // Fall back to attribute presence where some booleans are not supported
2648                  var attrNode,
2649                          property = jQuery.prop( elem, name );
2650                  return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2651                          name.toLowerCase() :
2652                          undefined;
2653          },
2654          set: function( elem, value, name ) {
2655                  var propName;
2656                  if ( value === false ) {
2657                          // Remove boolean attributes when set to false
2658                          jQuery.removeAttr( elem, name );
2659                  } else {
2660                          // value is true since we know at this point it's type boolean and not false
2661                          // Set boolean attributes to the same name and set the DOM property
2662                          propName = jQuery.propFix[ name ] || name;
2663                          if ( propName in elem ) {
2664                                  // Only set the IDL specifically if it already exists on the element
2665                                  elem[ propName ] = true;
2666                          }
2667  
2668                          elem.setAttribute( name, name.toLowerCase() );
2669                  }
2670                  return name;
2671          }
2672  };
2673  
2674  // IE6/7 do not support getting/setting some attributes with get/setAttribute
2675  if ( !getSetAttribute ) {
2676  
2677          fixSpecified = {
2678                  name: true,
2679                  id: true
2680          };
2681  
2682          // Use this for any attribute in IE6/7
2683          // This fixes almost every IE6/7 issue
2684          nodeHook = jQuery.valHooks.button = {
2685                  get: function( elem, name ) {
2686                          var ret;
2687                          ret = elem.getAttributeNode( name );
2688                          return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2689                                  ret.nodeValue :
2690                                  undefined;
2691                  },
2692                  set: function( elem, value, name ) {
2693                          // Set the existing or create a new attribute node
2694                          var ret = elem.getAttributeNode( name );
2695                          if ( !ret ) {
2696                                  ret = document.createAttribute( name );
2697                                  elem.setAttributeNode( ret );
2698                          }
2699                          return ( ret.nodeValue = value + "" );
2700                  }
2701          };
2702  
2703          // Apply the nodeHook to tabindex
2704          jQuery.attrHooks.tabindex.set = nodeHook.set;
2705  
2706          // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2707          // This is for removals
2708          jQuery.each([ "width", "height" ], function( i, name ) {
2709                  jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2710                          set: function( elem, value ) {
2711                                  if ( value === "" ) {
2712                                          elem.setAttribute( name, "auto" );
2713                                          return value;
2714                                  }
2715                          }
2716                  });
2717          });
2718  
2719          // Set contenteditable to false on removals(#10429)
2720          // Setting to empty string throws an error as an invalid value
2721          jQuery.attrHooks.contenteditable = {
2722                  get: nodeHook.get,
2723                  set: function( elem, value, name ) {
2724                          if ( value === "" ) {
2725                                  value = "false";
2726                          }
2727                          nodeHook.set( elem, value, name );
2728                  }
2729          };
2730  }
2731  
2732  
2733  // Some attributes require a special call on IE
2734  if ( !jQuery.support.hrefNormalized ) {
2735          jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2736                  jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2737                          get: function( elem ) {
2738                                  var ret = elem.getAttribute( name, 2 );
2739                                  return ret === null ? undefined : ret;
2740                          }
2741                  });
2742          });
2743  }
2744  
2745  if ( !jQuery.support.style ) {
2746          jQuery.attrHooks.style = {
2747                  get: function( elem ) {
2748                          // Return undefined in the case of empty string
2749                          // Normalize to lowercase since IE uppercases css property names
2750                          return elem.style.cssText.toLowerCase() || undefined;
2751                  },
2752                  set: function( elem, value ) {
2753                          return ( elem.style.cssText = "" + value );
2754                  }
2755          };
2756  }
2757  
2758  // Safari mis-reports the default selected property of an option
2759  // Accessing the parent's selectedIndex property fixes it
2760  if ( !jQuery.support.optSelected ) {
2761          jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2762                  get: function( elem ) {
2763                          var parent = elem.parentNode;
2764  
2765                          if ( parent ) {
2766                                  parent.selectedIndex;
2767  
2768                                  // Make sure that it also works with optgroups, see #5701
2769                                  if ( parent.parentNode ) {
2770                                          parent.parentNode.selectedIndex;
2771                                  }
2772                          }
2773                          return null;
2774                  }
2775          });
2776  }
2777  
2778  // IE6/7 call enctype encoding
2779  if ( !jQuery.support.enctype ) {
2780          jQuery.propFix.enctype = "encoding";
2781  }
2782  
2783  // Radios and checkboxes getter/setter
2784  if ( !jQuery.support.checkOn ) {
2785          jQuery.each([ "radio", "checkbox" ], function() {
2786                  jQuery.valHooks[ this ] = {
2787                          get: function( elem ) {
2788                                  // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2789                                  return elem.getAttribute("value") === null ? "on" : elem.value;
2790                          }
2791                  };
2792          });
2793  }
2794  jQuery.each([ "radio", "checkbox" ], function() {
2795          jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2796                  set: function( elem, value ) {
2797                          if ( jQuery.isArray( value ) ) {
2798                                  return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2799                          }
2800                  }
2801          });
2802  });
2803  
2804  
2805  
2806  
2807  var rformElems = /^(?:textarea|input|select)$/i,
2808          rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
2809          rhoverHack = /\bhover(\.\S+)?\b/,
2810          rkeyEvent = /^key/,
2811          rmouseEvent = /^(?:mouse|contextmenu)|click/,
2812          rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2813          rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
2814          quickParse = function( selector ) {
2815                  var quick = rquickIs.exec( selector );
2816                  if ( quick ) {
2817                          //   0  1    2   3
2818                          // [ _, tag, id, class ]
2819                          quick[1] = ( quick[1] || "" ).toLowerCase();
2820                          quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
2821                  }
2822                  return quick;
2823          },
2824          quickIs = function( elem, m ) {
2825                  var attrs = elem.attributes || {};
2826                  return (
2827                          (!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
2828                          (!m[2] || (attrs.id || {}).value === m[2]) &&
2829                          (!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
2830                  );
2831          },
2832          hoverHack = function( events ) {
2833                  return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2834          };
2835  
2836  /*
2837   * Helper functions for managing events -- not part of the public interface.
2838   * Props to Dean Edwards' addEvent library for many of the ideas.
2839   */
2840  jQuery.event = {
2841  
2842          add: function( elem, types, handler, data, selector ) {
2843  
2844                  var elemData, eventHandle, events,
2845                          t, tns, type, namespaces, handleObj,
2846                          handleObjIn, quick, handlers, special;
2847  
2848                  // Don't attach events to noData or text/comment nodes (allow plain objects tho)
2849                  if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2850                          return;
2851                  }
2852  
2853                  // Caller can pass in an object of custom data in lieu of the handler
2854                  if ( handler.handler ) {
2855                          handleObjIn = handler;
2856                          handler = handleObjIn.handler;
2857                  }
2858  
2859                  // Make sure that the handler has a unique ID, used to find/remove it later
2860                  if ( !handler.guid ) {
2861                          handler.guid = jQuery.guid++;
2862                  }
2863  
2864                  // Init the element's event structure and main handler, if this is the first
2865                  events = elemData.events;
2866                  if ( !events ) {
2867                          elemData.events = events = {};
2868                  }
2869                  eventHandle = elemData.handle;
2870                  if ( !eventHandle ) {
2871                          elemData.handle = eventHandle = function( e ) {
2872                                  // Discard the second event of a jQuery.event.trigger() and
2873                                  // when an event is called after a page has unloaded
2874                                  return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2875                                          jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2876                                          undefined;
2877                          };
2878                          // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2879                          eventHandle.elem = elem;
2880                  }
2881  
2882                  // Handle multiple events separated by a space
2883                  // jQuery(...).bind("mouseover mouseout", fn);
2884                  types = jQuery.trim( hoverHack(types) ).split( " " );
2885                  for ( t = 0; t < types.length; t++ ) {
2886  
2887                          tns = rtypenamespace.exec( types[t] ) || [];
2888                          type = tns[1];
2889                          namespaces = ( tns[2] || "" ).split( "." ).sort();
2890  
2891                          // If event changes its type, use the special event handlers for the changed type
2892                          special = jQuery.event.special[ type ] || {};
2893  
2894                          // If selector defined, determine special event api type, otherwise given type
2895                          type = ( selector ? special.delegateType : special.bindType ) || type;
2896  
2897                          // Update special based on newly reset type
2898                          special = jQuery.event.special[ type ] || {};
2899  
2900                          // handleObj is passed to all event handlers
2901                          handleObj = jQuery.extend({
2902                                  type: type,
2903                                  origType: tns[1],
2904                                  data: data,
2905                                  handler: handler,
2906                                  guid: handler.guid,
2907                                  selector: selector,
2908                                  quick: quickParse( selector ),
2909                                  namespace: namespaces.join(".")
2910                          }, handleObjIn );
2911  
2912                          // Init the event handler queue if we're the first
2913                          handlers = events[ type ];
2914                          if ( !handlers ) {
2915                                  handlers = events[ type ] = [];
2916                                  handlers.delegateCount = 0;
2917  
2918                                  // Only use addEventListener/attachEvent if the special events handler returns false
2919                                  if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2920                                          // Bind the global event handler to the element
2921                                          if ( elem.addEventListener ) {
2922                                                  elem.addEventListener( type, eventHandle, false );
2923  
2924                                          } else if ( elem.attachEvent ) {
2925                                                  elem.attachEvent( "on" + type, eventHandle );
2926                                          }
2927                                  }
2928                          }
2929  
2930                          if ( special.add ) {
2931                                  special.add.call( elem, handleObj );
2932  
2933                                  if ( !handleObj.handler.guid ) {
2934                                          handleObj.handler.guid = handler.guid;
2935                                  }
2936                          }
2937  
2938                          // Add to the element's handler list, delegates in front
2939                          if ( selector ) {
2940                                  handlers.splice( handlers.delegateCount++, 0, handleObj );
2941                          } else {
2942                                  handlers.push( handleObj );
2943                          }
2944  
2945                          // Keep track of which events have ever been used, for event optimization
2946                          jQuery.event.global[ type ] = true;
2947                  }
2948  
2949                  // Nullify elem to prevent memory leaks in IE
2950                  elem = null;
2951          },
2952  
2953          global: {},
2954  
2955          // Detach an event or set of events from an element
2956          remove: function( elem, types, handler, selector, mappedTypes ) {
2957  
2958                  var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2959                          t, tns, type, origType, namespaces, origCount,
2960                          j, events, special, handle, eventType, handleObj;
2961  
2962                  if ( !elemData || !(events = elemData.events) ) {
2963                          return;
2964                  }
2965  
2966                  // Once for each type.namespace in types; type may be omitted
2967                  types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
2968                  for ( t = 0; t < types.length; t++ ) {
2969                          tns = rtypenamespace.exec( types[t] ) || [];
2970                          type = origType = tns[1];
2971                          namespaces = tns[2];
2972  
2973                          // Unbind all events (on this namespace, if provided) for the element
2974                          if ( !type ) {
2975                                  for ( type in events ) {
2976                                          jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2977                                  }
2978                                  continue;
2979                          }
2980  
2981                          special = jQuery.event.special[ type ] || {};
2982                          type = ( selector? special.delegateType : special.bindType ) || type;
2983                          eventType = events[ type ] || [];
2984                          origCount = eventType.length;
2985                          namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
2986  
2987                          // Remove matching events
2988                          for ( j = 0; j < eventType.length; j++ ) {
2989                                  handleObj = eventType[ j ];
2990  
2991                                  if ( ( mappedTypes || origType === handleObj.origType ) &&
2992                                           ( !handler || handler.guid === handleObj.guid ) &&
2993                                           ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
2994                                           ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2995                                          eventType.splice( j--, 1 );
2996  
2997                                          if ( handleObj.selector ) {
2998                                                  eventType.delegateCount--;
2999                                          }
3000                                          if ( special.remove ) {
3001                                                  special.remove.call( elem, handleObj );
3002                                          }
3003                                  }
3004                          }
3005  
3006                          // Remove generic event handler if we removed something and no more handlers exist
3007                          // (avoids potential for endless recursion during removal of special event handlers)
3008                          if ( eventType.length === 0 && origCount !== eventType.length ) {
3009                                  if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
3010                                          jQuery.removeEvent( elem, type, elemData.handle );
3011                                  }
3012  
3013                                  delete events[ type ];
3014                          }
3015                  }
3016  
3017                  // Remove the expando if it's no longer used
3018                  if ( jQuery.isEmptyObject( events ) ) {
3019                          handle = elemData.handle;
3020                          if ( handle ) {
3021                                  handle.elem = null;
3022                          }
3023  
3024                          // removeData also checks for emptiness and clears the expando if empty
3025                          // so use it instead of delete
3026                          jQuery.removeData( elem, [ "events", "handle" ], true );
3027                  }
3028          },
3029  
3030          // Events that are safe to short-circuit if no handlers are attached.
3031          // Native DOM events should not be added, they may have inline handlers.
3032          customEvent: {
3033                  "getData": true,
3034                  "setData": true,
3035                  "changeData": true
3036          },
3037  
3038          trigger: function( event, data, elem, onlyHandlers ) {
3039                  // Don't do events on text and comment nodes
3040                  if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
3041                          return;
3042                  }
3043  
3044                  // Event object or event type
3045                  var type = event.type || event,
3046                          namespaces = [],
3047                          cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
3048  
3049                  // focus/blur morphs to focusin/out; ensure we're not firing them right now
3050                  if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
3051                          return;
3052                  }
3053  
3054                  if ( type.indexOf( "!" ) >= 0 ) {
3055                          // Exclusive events trigger only for the exact event (no namespaces)
3056                          type = type.slice(0, -1);
3057                          exclusive = true;
3058                  }
3059  
3060                  if ( type.indexOf( "." ) >= 0 ) {
3061                          // Namespaced trigger; create a regexp to match event type in handle()
3062                          namespaces = type.split(".");
3063                          type = namespaces.shift();
3064                          namespaces.sort();
3065                  }
3066  
3067                  if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
3068                          // No jQuery handlers for this event type, and it can't have inline handlers
3069                          return;
3070                  }
3071  
3072                  // Caller can pass in an Event, Object, or just an event type string
3073                  event = typeof event === "object" ?
3074                          // jQuery.Event object
3075                          event[ jQuery.expando ] ? event :
3076                          // Object literal
3077                          new jQuery.Event( type, event ) :
3078                          // Just the event type (string)
3079                          new jQuery.Event( type );
3080  
3081                  event.type = type;
3082                  event.isTrigger = true;
3083                  event.exclusive = exclusive;
3084                  event.namespace = namespaces.join( "." );
3085                  event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3086                  ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
3087  
3088                  // Handle a global trigger
3089                  if ( !elem ) {
3090  
3091                          // TODO: Stop taunting the data cache; remove global events and always attach to document
3092                          cache = jQuery.cache;
3093                          for ( i in cache ) {
3094                                  if ( cache[ i ].events && cache[ i ].events[ type ] ) {
3095                                          jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
3096                                  }
3097                          }
3098                          return;
3099                  }
3100  
3101                  // Clean up the event in case it is being reused
3102                  event.result = undefined;
3103                  if ( !event.target ) {
3104                          event.target = elem;
3105                  }
3106  
3107                  // Clone any incoming data and prepend the event, creating the handler arg list
3108                  data = data != null ? jQuery.makeArray( data ) : [];
3109                  data.unshift( event );
3110  
3111                  // Allow special events to draw outside the lines
3112                  special = jQuery.event.special[ type ] || {};
3113                  if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
3114                          return;
3115                  }
3116  
3117                  // Determine event propagation path in advance, per W3C events spec (#9951)
3118                  // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
3119                  eventPath = [[ elem, special.bindType || type ]];
3120                  if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
3121  
3122                          bubbleType = special.delegateType || type;
3123                          cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
3124                          old = null;
3125                          for ( ; cur; cur = cur.parentNode ) {
3126                                  eventPath.push([ cur, bubbleType ]);
3127                                  old = cur;
3128                          }
3129  
3130                          // Only add window if we got to document (e.g., not plain obj or detached DOM)
3131                          if ( old && old === elem.ownerDocument ) {
3132                                  eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
3133                          }
3134                  }
3135  
3136                  // Fire handlers on the event path
3137                  for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
3138  
3139                          cur = eventPath[i][0];
3140                          event.type = eventPath[i][1];
3141  
3142                          handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
3143                          if ( handle ) {
3144                                  handle.apply( cur, data );
3145                          }
3146                          // Note that this is a bare JS function and not a jQuery handler
3147                          handle = ontype && cur[ ontype ];
3148                          if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
3149                                  event.preventDefault();
3150                          }
3151                  }
3152                  event.type = type;
3153  
3154                  // If nobody prevented the default action, do it now
3155                  if ( !onlyHandlers && !event.isDefaultPrevented() ) {
3156  
3157                          if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
3158                                  !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
3159  
3160                                  // Call a native DOM method on the target with the same name name as the event.
3161                                  // Can't use an .isFunction() check here because IE6/7 fails that test.
3162                                  // Don't do default actions on window, that's where global variables be (#6170)
3163                                  // IE<9 dies on focus/blur to hidden element (#1486)
3164                                  if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
3165  
3166                                          // Don't re-trigger an onFOO event when we call its FOO() method
3167                                          old = elem[ ontype ];
3168  
3169                                          if ( old ) {
3170                                                  elem[ ontype ] = null;
3171                                          }
3172  
3173                                          // Prevent re-triggering of the same event, since we already bubbled it above
3174                                          jQuery.event.triggered = type;
3175                                          elem[ type ]();
3176                                          jQuery.event.triggered = undefined;
3177  
3178                                          if ( old ) {
3179                                                  elem[ ontype ] = old;
3180                                          }
3181                                  }
3182                          }
3183                  }
3184  
3185                  return event.result;
3186          },
3187  
3188          dispatch: function( event ) {
3189  
3190                  // Make a writable jQuery.Event from the native event object
3191                  event = jQuery.event.fix( event || window.event );
3192  
3193                  var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
3194                          delegateCount = handlers.delegateCount,
3195                          args = [].slice.call( arguments, 0 ),
3196                          run_all = !event.exclusive && !event.namespace,
3197                          handlerQueue = [],
3198                          i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
3199  
3200                  // Use the fix-ed jQuery.Event rather than the (read-only) native event
3201                  args[0] = event;
3202                  event.delegateTarget = this;
3203  
3204                  // Determine handlers that should run if there are delegated events
3205                  // Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861)
3206                  if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) {
3207  
3208                          // Pregenerate a single jQuery object for reuse with .is()
3209                          jqcur = jQuery(this);
3210                          jqcur.context = this.ownerDocument || this;
3211  
3212                          for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3213                                  selMatch = {};
3214                                  matches = [];
3215                                  jqcur[0] = cur;
3216                                  for ( i = 0; i < delegateCount; i++ ) {
3217                                          handleObj = handlers[ i ];
3218                                          sel = handleObj.selector;
3219  
3220                                          if ( selMatch[ sel ] === undefined ) {
3221                                                  selMatch[ sel ] = (
3222                                                          handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
3223                                                  );
3224                                          }
3225                                          if ( selMatch[ sel ] ) {
3226                                                  matches.push( handleObj );
3227                                          }
3228                                  }
3229                                  if ( matches.length ) {
3230                                          handlerQueue.push({ elem: cur, matches: matches });
3231                                  }
3232                          }
3233                  }
3234  
3235                  // Add the remaining (directly-bound) handlers
3236                  if ( handlers.length > delegateCount ) {
3237                          handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3238                  }
3239  
3240                  // Run delegates first; they may want to stop propagation beneath us
3241                  for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3242                          matched = handlerQueue[ i ];
3243                          event.currentTarget = matched.elem;
3244  
3245                          for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3246                                  handleObj = matched.matches[ j ];
3247  
3248                                  // Triggered event must either 1) be non-exclusive and have no namespace, or
3249                                  // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3250                                  if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3251  
3252                                          event.data = handleObj.data;
3253                                          event.handleObj = handleObj;
3254  
3255                                          ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3256                                                          .apply( matched.elem, args );
3257  
3258                                          if ( ret !== undefined ) {
3259                                                  event.result = ret;
3260                                                  if ( ret === false ) {
3261                                                          event.preventDefault();
3262                                                          event.stopPropagation();
3263                                                  }
3264                                          }
3265                                  }
3266                          }
3267                  }
3268  
3269                  return event.result;
3270          },
3271  
3272          // Includes some event props shared by KeyEvent and MouseEvent
3273          // *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3274          props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3275  
3276          fixHooks: {},
3277  
3278          keyHooks: {
3279                  props: "char charCode key keyCode".split(" "),
3280                  filter: function( event, original ) {
3281  
3282                          // Add which for key events
3283                          if ( event.which == null ) {
3284                                  event.which = original.charCode != null ? original.charCode : original.keyCode;
3285                          }
3286  
3287                          return event;
3288                  }
3289          },
3290  
3291          mouseHooks: {
3292                  props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3293                  filter: function( event, original ) {
3294                          var eventDoc, doc, body,
3295                                  button = original.button,
3296                                  fromElement = original.fromElement;
3297  
3298                          // Calculate pageX/Y if missing and clientX/Y available
3299                          if ( event.pageX == null && original.clientX != null ) {
3300                                  eventDoc = event.target.ownerDocument || document;
3301                                  doc = eventDoc.documentElement;
3302                                  body = eventDoc.body;
3303  
3304                                  event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3305                                  event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3306                          }
3307  
3308                          // Add relatedTarget, if necessary
3309                          if ( !event.relatedTarget && fromElement ) {
3310                                  event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3311                          }
3312  
3313                          // Add which for click: 1 === left; 2 === middle; 3 === right
3314                          // Note: button is not normalized, so don't use it
3315                          if ( !event.which && button !== undefined ) {
3316                                  event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3317                          }
3318  
3319                          return event;
3320                  }
3321          },
3322  
3323          fix: function( event ) {
3324                  if ( event[ jQuery.expando ] ) {
3325                          return event;
3326                  }
3327  
3328                  // Create a writable copy of the event object and normalize some properties
3329                  var i, prop,
3330                          originalEvent = event,
3331                          fixHook = jQuery.event.fixHooks[ event.type ] || {},
3332                          copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3333  
3334                  event = jQuery.Event( originalEvent );
3335  
3336                  for ( i = copy.length; i; ) {
3337                          prop = copy[ --i ];
3338                          event[ prop ] = originalEvent[ prop ];
3339                  }
3340  
3341                  // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3342                  if ( !event.target ) {
3343                          event.target = originalEvent.srcElement || document;
3344                  }
3345  
3346                  // Target should not be a text node (#504, Safari)
3347                  if ( event.target.nodeType === 3 ) {
3348                          event.target = event.target.parentNode;
3349                  }
3350  
3351                  // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
3352                  if ( event.metaKey === undefined ) {
3353                          event.metaKey = event.ctrlKey;
3354                  }
3355  
3356                  return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3357          },
3358  
3359          special: {
3360                  ready: {
3361                          // Make sure the ready event is setup
3362                          setup: jQuery.bindReady
3363                  },
3364  
3365                  load: {
3366                          // Prevent triggered image.load events from bubbling to window.load
3367                          noBubble: true
3368                  },
3369  
3370                  focus: {
3371                          delegateType: "focusin"
3372                  },
3373                  blur: {
3374                          delegateType: "focusout"
3375                  },
3376  
3377                  beforeunload: {
3378                          setup: function( data, namespaces, eventHandle ) {
3379                                  // We only want to do this special case on windows
3380                                  if ( jQuery.isWindow( this ) ) {
3381                                          this.onbeforeunload = eventHandle;
3382                                  }
3383                          },
3384  
3385                          teardown: function( namespaces, eventHandle ) {
3386                                  if ( this.onbeforeunload === eventHandle ) {
3387                                          this.onbeforeunload = null;
3388                                  }
3389                          }
3390                  }
3391          },
3392  
3393          simulate: function( type, elem, event, bubble ) {
3394                  // Piggyback on a donor event to simulate a different one.
3395                  // Fake originalEvent to avoid donor's stopPropagation, but if the
3396                  // simulated event prevents default then we do the same on the donor.
3397                  var e = jQuery.extend(
3398                          new jQuery.Event(),
3399                          event,
3400                          { type: type,
3401                                  isSimulated: true,
3402                                  originalEvent: {}
3403                          }
3404                  );
3405                  if ( bubble ) {
3406                          jQuery.event.trigger( e, null, elem );
3407                  } else {
3408                          jQuery.event.dispatch.call( elem, e );
3409                  }
3410                  if ( e.isDefaultPrevented() ) {
3411                          event.preventDefault();
3412                  }
3413          }
3414  };
3415  
3416  // Some plugins are using, but it's undocumented/deprecated and will be removed.
3417  // The 1.7 special event interface should provide all the hooks needed now.
3418  jQuery.event.handle = jQuery.event.dispatch;
3419  
3420  jQuery.removeEvent = document.removeEventListener ?
3421          function( elem, type, handle ) {
3422                  if ( elem.removeEventListener ) {
3423                          elem.removeEventListener( type, handle, false );
3424                  }
3425          } :
3426          function( elem, type, handle ) {
3427                  if ( elem.detachEvent ) {
3428                          elem.detachEvent( "on" + type, handle );
3429                  }
3430          };
3431  
3432  jQuery.Event = function( src, props ) {
3433          // Allow instantiation without the 'new' keyword
3434          if ( !(this instanceof jQuery.Event) ) {
3435                  return new jQuery.Event( src, props );
3436          }
3437  
3438          // Event object
3439          if ( src && src.type ) {
3440                  this.originalEvent = src;
3441                  this.type = src.type;
3442  
3443                  // Events bubbling up the document may have been marked as prevented
3444                  // by a handler lower down the tree; reflect the correct value.
3445                  this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3446                          src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3447  
3448          // Event type
3449          } else {
3450                  this.type = src;
3451          }
3452  
3453          // Put explicitly provided properties onto the event object
3454          if ( props ) {
3455                  jQuery.extend( this, props );
3456          }
3457  
3458          // Create a timestamp if incoming event doesn't have one
3459          this.timeStamp = src && src.timeStamp || jQuery.now();
3460  
3461          // Mark it as fixed
3462          this[ jQuery.expando ] = true;
3463  };
3464  
3465  function returnFalse() {
3466          return false;
3467  }
3468  function returnTrue() {
3469          return true;
3470  }
3471  
3472  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3473  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3474  jQuery.Event.prototype = {
3475          preventDefault: function() {
3476                  this.isDefaultPrevented = returnTrue;
3477  
3478                  var e = this.originalEvent;
3479                  if ( !e ) {
3480                          return;
3481                  }
3482  
3483                  // if preventDefault exists run it on the original event
3484                  if ( e.preventDefault ) {
3485                          e.preventDefault();
3486  
3487                  // otherwise set the returnValue property of the original event to false (IE)
3488                  } else {
3489                          e.returnValue = false;
3490                  }
3491          },
3492          stopPropagation: function() {
3493                  this.isPropagationStopped = returnTrue;
3494  
3495                  var e = this.originalEvent;
3496                  if ( !e ) {
3497                          return;
3498                  }
3499                  // if stopPropagation exists run it on the original event
3500                  if ( e.stopPropagation ) {
3501                          e.stopPropagation();
3502                  }
3503                  // otherwise set the cancelBubble property of the original event to true (IE)
3504                  e.cancelBubble = true;
3505          },
3506          stopImmediatePropagation: function() {
3507                  this.isImmediatePropagationStopped = returnTrue;
3508                  this.stopPropagation();
3509          },
3510          isDefaultPrevented: returnFalse,
3511          isPropagationStopped: returnFalse,
3512          isImmediatePropagationStopped: returnFalse
3513  };
3514  
3515  // Create mouseenter/leave events using mouseover/out and event-time checks
3516  jQuery.each({
3517          mouseenter: "mouseover",
3518          mouseleave: "mouseout"
3519  }, function( orig, fix ) {
3520          jQuery.event.special[ orig ] = {
3521                  delegateType: fix,
3522                  bindType: fix,
3523  
3524                  handle: function( event ) {
3525                          var target = this,
3526                                  related = event.relatedTarget,
3527                                  handleObj = event.handleObj,
3528                                  selector = handleObj.selector,
3529                                  ret;
3530  
3531                          // For mousenter/leave call the handler if related is outside the target.
3532                          // NB: No relatedTarget if the mouse left/entered the browser window
3533                          if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3534                                  event.type = handleObj.origType;
3535                                  ret = handleObj.handler.apply( this, arguments );
3536                                  event.type = fix;
3537                          }
3538                          return ret;
3539                  }
3540          };
3541  });
3542  
3543  // IE submit delegation
3544  if ( !jQuery.support.submitBubbles ) {
3545  
3546          jQuery.event.special.submit = {
3547                  setup: function() {
3548                          // Only need this for delegated form submit events
3549                          if ( jQuery.nodeName( this, "form" ) ) {
3550                                  return false;
3551                          }
3552  
3553                          // Lazy-add a submit handler when a descendant form may potentially be submitted
3554                          jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
3555                                  // Node name check avoids a VML-related crash in IE (#9807)
3556                                  var elem = e.target,
3557                                          form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3558                                  if ( form && !form._submit_attached ) {
3559                                          jQuery.event.add( form, "submit._submit", function( event ) {
3560                                                  // If form was submitted by the user, bubble the event up the tree
3561                                                  if ( this.parentNode && !event.isTrigger ) {
3562                                                          jQuery.event.simulate( "submit", this.parentNode, event, true );
3563                                                  }
3564                                          });
3565                                          form._submit_attached = true;
3566                                  }
3567                          });
3568                          // return undefined since we don't need an event listener
3569                  },
3570  
3571                  teardown: function() {
3572                          // Only need this for delegated form submit events
3573                          if ( jQuery.nodeName( this, "form" ) ) {
3574                                  return false;
3575                          }
3576  
3577                          // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3578                          jQuery.event.remove( this, "._submit" );
3579                  }
3580          };
3581  }
3582  
3583  // IE change delegation and checkbox/radio fix
3584  if ( !jQuery.support.changeBubbles ) {
3585  
3586          jQuery.event.special.change = {
3587  
3588                  setup: function() {
3589  
3590                          if ( rformElems.test( this.nodeName ) ) {
3591                                  // IE doesn't fire change on a check/radio until blur; trigger it on click
3592                                  // after a propertychange. Eat the blur-change in special.change.handle.
3593                                  // This still fires onchange a second time for check/radio after blur.
3594                                  if ( this.type === "checkbox" || this.type === "radio" ) {
3595                                          jQuery.event.add( this, "propertychange._change", function( event ) {
3596                                                  if ( event.originalEvent.propertyName === "checked" ) {
3597                                                          this._just_changed = true;
3598                                                  }
3599                                          });
3600                                          jQuery.event.add( this, "click._change", function( event ) {
3601                                                  if ( this._just_changed && !event.isTrigger ) {
3602                                                          this._just_changed = false;
3603                                                          jQuery.event.simulate( "change", this, event, true );
3604                                                  }
3605                                          });
3606                                  }
3607                                  return false;
3608                          }
3609                          // Delegated event; lazy-add a change handler on descendant inputs
3610                          jQuery.event.add( this, "beforeactivate._change", function( e ) {
3611                                  var elem = e.target;
3612  
3613                                  if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
3614                                          jQuery.event.add( elem, "change._change", function( event ) {
3615                                                  if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
3616                                                          jQuery.event.simulate( "change", this.parentNode, event, true );
3617                                                  }
3618                                          });
3619                                          elem._change_attached = true;
3620                                  }
3621                          });
3622                  },
3623  
3624                  handle: function( event ) {
3625                          var elem = event.target;
3626  
3627                          // Swallow native change events from checkbox/radio, we already triggered them above
3628                          if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3629                                  return event.handleObj.handler.apply( this, arguments );
3630                          }
3631                  },
3632  
3633                  teardown: function() {
3634                          jQuery.event.remove( this, "._change" );
3635  
3636                          return rformElems.test( this.nodeName );
3637                  }
3638          };
3639  }
3640  
3641  // Create "bubbling" focus and blur events
3642  if ( !jQuery.support.focusinBubbles ) {
3643          jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3644  
3645                  // Attach a single capturing handler while someone wants focusin/focusout
3646                  var attaches = 0,
3647                          handler = function( event ) {
3648                                  jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
3649                          };
3650  
3651                  jQuery.event.special[ fix ] = {
3652                          setup: function() {
3653                                  if ( attaches++ === 0 ) {
3654                                          document.addEventListener( orig, handler, true );
3655                                  }
3656                          },
3657                          teardown: function() {
3658                                  if ( --attaches === 0 ) {
3659                                          document.removeEventListener( orig, handler, true );
3660                                  }
3661                          }
3662                  };
3663          });
3664  }
3665  
3666  jQuery.fn.extend({
3667  
3668          on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
3669                  var origFn, type;
3670  
3671                  // Types can be a map of types/handlers
3672                  if ( typeof types === "object" ) {
3673                          // ( types-Object, selector, data )
3674                          if ( typeof selector !== "string" ) {
3675                                  // ( types-Object, data )
3676                                  data = selector;
3677                                  selector = undefined;
3678                          }
3679                          for ( type in types ) {
3680                                  this.on( type, selector, data, types[ type ], one );
3681                          }
3682                          return this;
3683                  }
3684  
3685                  if ( data == null && fn == null ) {
3686                          // ( types, fn )
3687                          fn = selector;
3688                          data = selector = undefined;
3689                  } else if ( fn == null ) {
3690                          if ( typeof selector === "string" ) {
3691                                  // ( types, selector, fn )
3692                                  fn = data;
3693                                  data = undefined;
3694                          } else {
3695                                  // ( types, data, fn )
3696                                  fn = data;
3697                                  data = selector;
3698                                  selector = undefined;
3699                          }
3700                  }
3701                  if ( fn === false ) {
3702                          fn = returnFalse;
3703                  } else if ( !fn ) {
3704                          return this;
3705                  }
3706  
3707                  if ( one === 1 ) {
3708                          origFn = fn;
3709                          fn = function( event ) {
3710                                  // Can use an empty set, since event contains the info
3711                                  jQuery().off( event );
3712                                  return origFn.apply( this, arguments );
3713                          };
3714                          // Use same guid so caller can remove using origFn
3715                          fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
3716                  }
3717                  return this.each( function() {
3718                          jQuery.event.add( this, types, fn, data, selector );
3719                  });
3720          },
3721          one: function( types, selector, data, fn ) {
3722                  return this.on.call( this, types, selector, data, fn, 1 );
3723          },
3724          off: function( types, selector, fn ) {
3725                  if ( types && types.preventDefault && types.handleObj ) {
3726                          // ( event )  dispatched jQuery.Event
3727                          var handleObj = types.handleObj;
3728                          jQuery( types.delegateTarget ).off(
3729                                  handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type,
3730                                  handleObj.selector,
3731                                  handleObj.handler
3732                          );
3733                          return this;
3734                  }
3735                  if ( typeof types === "object" ) {
3736                          // ( types-object [, selector] )
3737                          for ( var type in types ) {
3738                                  this.off( type, selector, types[ type ] );
3739                          }
3740                          return this;
3741                  }
3742                  if ( selector === false || typeof selector === "function" ) {
3743                          // ( types [, fn] )
3744                          fn = selector;
3745                          selector = undefined;
3746                  }
3747                  if ( fn === false ) {
3748                          fn = returnFalse;
3749                  }
3750                  return this.each(function() {
3751                          jQuery.event.remove( this, types, fn, selector );
3752                  });
3753          },
3754  
3755          bind: function( types, data, fn ) {
3756                  return this.on( types, null, data, fn );
3757          },
3758          unbind: function( types, fn ) {
3759                  return this.off( types, null, fn );
3760          },
3761  
3762          live: function( types, data, fn ) {
3763                  jQuery( this.context ).on( types, this.selector, data, fn );
3764                  return this;
3765          },
3766          die: function( types, fn ) {
3767                  jQuery( this.context ).off( types, this.selector || "**", fn );
3768                  return this;
3769          },
3770  
3771          delegate: function( selector, types, data, fn ) {
3772                  return this.on( types, selector, data, fn );
3773          },
3774          undelegate: function( selector, types, fn ) {
3775                  // ( namespace ) or ( selector, types [, fn] )
3776                  return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
3777          },
3778  
3779          trigger: function( type, data ) {
3780                  return this.each(function() {
3781                          jQuery.event.trigger( type, data, this );
3782                  });
3783          },
3784          triggerHandler: function( type, data ) {
3785                  if ( this[0] ) {
3786                          return jQuery.event.trigger( type, data, this[0], true );
3787                  }
3788          },
3789  
3790          toggle: function( fn ) {
3791                  // Save reference to arguments for access in closure
3792                  var args = arguments,
3793                          guid = fn.guid || jQuery.guid++,
3794                          i = 0,
3795                          toggler = function( event ) {
3796                                  // Figure out which function to execute
3797                                  var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3798                                  jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3799  
3800                                  // Make sure that clicks stop
3801                                  event.preventDefault();
3802  
3803                                  // and execute the function
3804                                  return args[ lastToggle ].apply( this, arguments ) || false;
3805                          };
3806  
3807                  // link all the functions, so any of them can unbind this click handler
3808                  toggler.guid = guid;
3809                  while ( i < args.length ) {
3810                          args[ i++ ].guid = guid;
3811                  }
3812  
3813                  return this.click( toggler );
3814          },
3815  
3816          hover: function( fnOver, fnOut ) {
3817                  return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3818          }
3819  });
3820  
3821  jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3822          "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3823          "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3824  
3825          // Handle event binding
3826          jQuery.fn[ name ] = function( data, fn ) {
3827                  if ( fn == null ) {
3828                          fn = data;
3829                          data = null;
3830                  }
3831  
3832                  return arguments.length > 0 ?
3833                          this.on( name, null, data, fn ) :
3834                          this.trigger( name );
3835          };
3836  
3837          if ( jQuery.attrFn ) {
3838                  jQuery.attrFn[ name ] = true;
3839          }
3840  
3841          if ( rkeyEvent.test( name ) ) {
3842                  jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
3843          }
3844  
3845          if ( rmouseEvent.test( name ) ) {
3846                  jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
3847          }
3848  });
3849  
3850  
3851  
3852  /*!
3853   * Sizzle CSS Selector Engine
3854   *  Copyright 2011, The Dojo Foundation
3855   *  Released under the MIT, BSD, and GPL Licenses.
3856   *  More information: http://sizzlejs.com/
3857   */
3858  (function(){
3859  
3860  var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3861          expando = "sizcache" + (Math.random() + '').replace('.', ''),
3862          done = 0,
3863          toString = Object.prototype.toString,
3864          hasDuplicate = false,
3865          baseHasDuplicate = true,
3866          rBackslash = /\\/g,
3867          rReturn = /\r\n/g,
3868          rNonWord = /\W/;
3869  
3870  // Here we check if the JavaScript engine is using some sort of
3871  // optimization where it does not always call our comparision
3872  // function. If that is the case, discard the hasDuplicate value.
3873  //   Thus far that includes Google Chrome.
3874  [0, 0].sort(function() {
3875          baseHasDuplicate = false;
3876          return 0;
3877  });
3878  
3879  var Sizzle = function( selector, context, results, seed ) {
3880          results = results || [];
3881          context = context || document;
3882  
3883          var origContext = context;
3884  
3885          if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3886                  return [];
3887          }
3888         
3889          if ( !selector || typeof selector !== "string" ) {
3890                  return results;
3891          }
3892  
3893          var m, set, checkSet, extra, ret, cur, pop, i,
3894                  prune = true,
3895                  contextXML = Sizzle.isXML( context ),
3896                  parts = [],
3897                  soFar = selector;
3898         
3899          // Reset the position of the chunker regexp (start from head)
3900          do {
3901                  chunker.exec( "" );
3902                  m = chunker.exec( soFar );
3903  
3904                  if ( m ) {
3905                          soFar = m[3];
3906                 
3907                          parts.push( m[1] );
3908                 
3909                          if ( m[2] ) {
3910                                  extra = m[3];
3911                                  break;
3912                          }
3913                  }
3914          } while ( m );
3915  
3916          if ( parts.length > 1 && origPOS.exec( selector ) ) {
3917  
3918                  if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3919                          set = posProcess( parts[0] + parts[1], context, seed );
3920  
3921                  } else {
3922                          set = Expr.relative[ parts[0] ] ?
3923                                  [ context ] :
3924                                  Sizzle( parts.shift(), context );
3925  
3926                          while ( parts.length ) {
3927                                  selector = parts.shift();
3928  
3929                                  if ( Expr.relative[ selector ] ) {
3930                                          selector += parts.shift();
3931                                  }
3932                                 
3933                                  set = posProcess( selector, set, seed );
3934                          }
3935                  }
3936  
3937          } else {
3938                  // Take a shortcut and set the context if the root selector is an ID
3939                  // (but not if it'll be faster if the inner selector is an ID)
3940                  if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3941                                  Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3942  
3943                          ret = Sizzle.find( parts.shift(), context, contextXML );
3944                          context = ret.expr ?
3945                                  Sizzle.filter( ret.expr, ret.set )[0] :
3946                                  ret.set[0];
3947                  }
3948  
3949                  if ( context ) {
3950                          ret = seed ?
3951                                  { expr: parts.pop(), set: makeArray(seed) } :
3952                                  Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3953  
3954                          set = ret.expr ?
3955                                  Sizzle.filter( ret.expr, ret.set ) :
3956                                  ret.set;
3957  
3958                          if ( parts.length > 0 ) {
3959                                  checkSet = makeArray( set );
3960  
3961                          } else {
3962                                  prune = false;
3963                          }
3964  
3965                          while ( parts.length ) {
3966                                  cur = parts.pop();
3967                                  pop = cur;
3968  
3969                                  if ( !Expr.relative[ cur ] ) {
3970                                          cur = "";
3971                                  } else {
3972                                          pop = parts.pop();
3973                                  }
3974  
3975                                  if ( pop == null ) {
3976                                          pop = context;
3977                                  }
3978  
3979                                  Expr.relative[ cur ]( checkSet, pop, contextXML );
3980                          }
3981  
3982                  } else {
3983                          checkSet = parts = [];
3984                  }
3985          }
3986  
3987          if ( !checkSet ) {
3988                  checkSet = set;
3989          }
3990  
3991          if ( !checkSet ) {
3992                  Sizzle.error( cur || selector );
3993          }
3994  
3995          if ( toString.call(checkSet) === "[object Array]" ) {
3996                  if ( !prune ) {
3997                          results.push.apply( results, checkSet );
3998  
3999                  } else if ( context && context.nodeType === 1 ) {
4000                          for ( i = 0; checkSet[i] != null; i++ ) {
4001                                  if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
4002                                          results.push( set[i] );
4003                                  }
4004                          }
4005  
4006                  } else {
4007                          for ( i = 0; checkSet[i] != null; i++ ) {
4008                                  if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
4009                                          results.push( set[i] );
4010                                  }
4011                          }
4012                  }
4013  
4014          } else {
4015                  makeArray( checkSet, results );
4016          }
4017  
4018          if ( extra ) {
4019                  Sizzle( extra, origContext, results, seed );
4020                  Sizzle.uniqueSort( results );
4021          }
4022  
4023          return results;
4024  };
4025  
4026  Sizzle.uniqueSort = function( results ) {
4027          if ( sortOrder ) {
4028                  hasDuplicate = baseHasDuplicate;
4029                  results.sort( sortOrder );
4030  
4031                  if ( hasDuplicate ) {
4032                          for ( var i = 1; i < results.length; i++ ) {
4033                                  if ( results[i] === results[ i - 1 ] ) {
4034                                          results.splice( i--, 1 );
4035                                  }
4036                          }
4037                  }
4038          }
4039  
4040          return results;
4041  };
4042  
4043  Sizzle.matches = function( expr, set ) {
4044          return Sizzle( expr, null, null, set );
4045  };
4046  
4047  Sizzle.matchesSelector = function( node, expr ) {
4048          return Sizzle( expr, null, null, [node] ).length > 0;
4049  };
4050  
4051  Sizzle.find = function( expr, context, isXML ) {
4052          var set, i, len, match, type, left;
4053  
4054          if ( !expr ) {
4055                  return [];
4056          }
4057  
4058          for ( i = 0, len = Expr.order.length; i < len; i++ ) {
4059                  type = Expr.order[i];
4060                 
4061                  if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
4062                          left = match[1];
4063                          match.splice( 1, 1 );
4064  
4065                          if ( left.substr( left.length - 1 ) !== "\\" ) {
4066                                  match[1] = (match[1] || "").replace( rBackslash, "" );
4067                                  set = Expr.find[ type ]( match, context, isXML );
4068  
4069                                  if ( set != null ) {
4070                                          expr = expr.replace( Expr.match[ type ], "" );
4071                                          break;
4072                                  }
4073                          }
4074                  }
4075          }
4076  
4077          if ( !set ) {
4078                  set = typeof context.getElementsByTagName !== "undefined" ?
4079                          context.getElementsByTagName( "*" ) :
4080                          [];
4081          }
4082  
4083          return { set: set, expr: expr };
4084  };
4085  
4086  Sizzle.filter = function( expr, set, inplace, not ) {
4087          var match, anyFound,
4088                  type, found, item, filter, left,
4089                  i, pass,
4090                  old = expr,
4091                  result = [],
4092                  curLoop = set,
4093                  isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
4094  
4095          while ( expr && set.length ) {
4096                  for ( type in Expr.filter ) {
4097                          if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
4098                                  filter = Expr.filter[ type ];
4099                                  left = match[1];
4100  
4101                                  anyFound = false;
4102  
4103                                  match.splice(1,1);
4104  
4105                                  if ( left.substr( left.length - 1 ) === "\\" ) {
4106                                          continue;
4107                                  }
4108  
4109                                  if ( curLoop === result ) {
4110                                          result = [];
4111                                  }
4112  
4113                                  if ( Expr.preFilter[ type ] ) {
4114                                          match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
4115  
4116                                          if ( !match ) {
4117                                                  anyFound = found = true;
4118  
4119                                          } else if ( match === true ) {
4120                                                  continue;
4121                                          }
4122                                  }
4123  
4124                                  if ( match ) {
4125                                          for ( i = 0; (item = curLoop[i]) != null; i++ ) {
4126                                                  if ( item ) {
4127                                                          found = filter( item, match, i, curLoop );
4128                                                          pass = not ^ found;
4129  
4130                                                          if ( inplace && found != null ) {
4131                                                                  if ( pass ) {
4132                                                                          anyFound = true;
4133  
4134                                                                  } else {
4135                                                                          curLoop[i] = false;
4136                                                                  }
4137  
4138                                                          } else if ( pass ) {
4139                                                                  result.push( item );
4140                                                                  anyFound = true;
4141                                                          }
4142                                                  }
4143                                          }
4144                                  }
4145  
4146                                  if ( found !== undefined ) {
4147                                          if ( !inplace ) {
4148                                                  curLoop = result;
4149                                          }
4150  
4151                                          expr = expr.replace( Expr.match[ type ], "" );
4152  
4153                                          if ( !anyFound ) {
4154                                                  return [];
4155                                          }
4156  
4157                                          break;
4158                                  }
4159                          }
4160                  }
4161  
4162                  // Improper expression
4163                  if ( expr === old ) {
4164                          if ( anyFound == null ) {
4165                                  Sizzle.error( expr );
4166  
4167                          } else {
4168                                  break;
4169                          }
4170                  }
4171  
4172                  old = expr;
4173          }
4174  
4175          return curLoop;
4176  };
4177  
4178  Sizzle.error = function( msg ) {
4179          throw new Error( "Syntax error, unrecognized expression: " + msg );
4180  };
4181  
4182  /**
4183   * Utility function for retreiving the text value of an array of DOM nodes
4184   * @param {Array|Element} elem
4185   */
4186  var getText = Sizzle.getText = function( elem ) {
4187      var i, node,
4188                  nodeType = elem.nodeType,
4189                  ret = "";
4190  
4191          if ( nodeType ) {
4192                  if ( nodeType === 1 || nodeType === 9 ) {
4193                          // Use textContent || innerText for elements
4194                          if ( typeof elem.textContent === 'string' ) {
4195                                  return elem.textContent;
4196                          } else if ( typeof elem.innerText === 'string' ) {
4197                                  // Replace IE's carriage returns
4198                                  return elem.innerText.replace( rReturn, '' );
4199                          } else {
4200                                  // Traverse it's children
4201                                  for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
4202                                          ret += getText( elem );
4203                                  }
4204                          }
4205                  } else if ( nodeType === 3 || nodeType === 4 ) {
4206                          return elem.nodeValue;
4207                  }
4208          } else {
4209  
4210                  // If no nodeType, this is expected to be an array
4211                  for ( i = 0; (node = elem[i]); i++ ) {
4212                          // Do not traverse comment nodes
4213                          if ( node.nodeType !== 8 ) {
4214                                  ret += getText( node );
4215                          }
4216                  }
4217          }
4218          return ret;
4219  };
4220  
4221  var Expr = Sizzle.selectors = {
4222          order: [ "ID", "NAME", "TAG" ],
4223  
4224          match: {
4225                  ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4226                  CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4227                  NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
4228                  ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
4229                  TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
4230                  CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
4231                  POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
4232                  PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
4233          },
4234  
4235          leftMatch: {},
4236  
4237          attrMap: {
4238                  "class": "className",
4239                  "for": "htmlFor"
4240          },
4241  
4242          attrHandle: {
4243                  href: function( elem ) {
4244                          return elem.getAttribute( "href" );
4245                  },
4246                  type: function( elem ) {
4247                          return elem.getAttribute( "type" );
4248                  }
4249          },
4250  
4251          relative: {
4252                  "+": function(checkSet, part){
4253                          var isPartStr = typeof part === "string",
4254                                  isTag = isPartStr && !rNonWord.test( part ),
4255                                  isPartStrNotTag = isPartStr && !isTag;
4256  
4257                          if ( isTag ) {
4258                                  part = part.toLowerCase();
4259                          }
4260  
4261                          for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4262                                  if ( (elem = checkSet[i]) ) {
4263                                          while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4264  
4265                                          checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
4266                                                  elem || false :
4267                                                  elem === part;
4268                                  }
4269                          }
4270  
4271                          if ( isPartStrNotTag ) {
4272                                  Sizzle.filter( part, checkSet, true );
4273                          }
4274                  },
4275  
4276                  ">": function( checkSet, part ) {
4277                          var elem,
4278                                  isPartStr = typeof part === "string",
4279                                  i = 0,
4280                                  l = checkSet.length;
4281  
4282                          if ( isPartStr && !rNonWord.test( part ) ) {
4283                                  part = part.toLowerCase();
4284  
4285                                  for ( ; i < l; i++ ) {
4286                                          elem = checkSet[i];
4287  
4288                                          if ( elem ) {
4289                                                  var parent = elem.parentNode;
4290                                                  checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4291                                          }
4292                                  }
4293  
4294                          } else {
4295                                  for ( ; i < l; i++ ) {
4296                                          elem = checkSet[i];
4297  
4298                                          if ( elem ) {
4299                                                  checkSet[i] = isPartStr ?
4300                                                          elem.parentNode :
4301                                                          elem.parentNode === part;
4302                                          }
4303                                  }
4304  
4305                                  if ( isPartStr ) {
4306                                          Sizzle.filter( part, checkSet, true );
4307                                  }
4308                          }
4309                  },
4310  
4311                  "": function(checkSet, part, isXML){
4312                          var nodeCheck,
4313                                  doneName = done++,
4314                                  checkFn = dirCheck;
4315  
4316                          if ( typeof part === "string" && !rNonWord.test( part ) ) {
4317                                  part = part.toLowerCase();
4318                                  nodeCheck = part;
4319                                  checkFn = dirNodeCheck;
4320                          }
4321  
4322                          checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4323                  },
4324  
4325                  "~": function( checkSet, part, isXML ) {
4326                          var nodeCheck,
4327                                  doneName = done++,
4328                                  checkFn = dirCheck;
4329  
4330                          if ( typeof part === "string" && !rNonWord.test( part ) ) {
4331                                  part = part.toLowerCase();
4332                                  nodeCheck = part;
4333                                  checkFn = dirNodeCheck;
4334                          }
4335  
4336                          checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4337                  }
4338          },
4339  
4340          find: {
4341                  ID: function( match, context, isXML ) {
4342                          if ( typeof context.getElementById !== "undefined" && !isXML ) {
4343                                  var m = context.getElementById(match[1]);
4344                                  // Check parentNode to catch when Blackberry 4.6 returns
4345                                  // nodes that are no longer in the document #6963
4346                                  return m && m.parentNode ? [m] : [];
4347                          }
4348                  },
4349  
4350                  NAME: function( match, context ) {
4351                          if ( typeof context.getElementsByName !== "undefined" ) {
4352                                  var ret = [],
4353                                          results = context.getElementsByName( match[1] );
4354  
4355                                  for ( var i = 0, l = results.length; i < l; i++ ) {
4356                                          if ( results[i].getAttribute("name") === match[1] ) {
4357                                                  ret.push( results[i] );
4358                                          }
4359                                  }
4360  
4361                                  return ret.length === 0 ? null : ret;
4362                          }
4363                  },
4364  
4365                  TAG: function( match, context ) {
4366                          if ( typeof context.getElementsByTagName !== "undefined" ) {
4367                                  return context.getElementsByTagName( match[1] );
4368                          }
4369                  }
4370          },
4371          preFilter: {
4372                  CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4373                          match = " " + match[1].replace( rBackslash, "" ) + " ";
4374  
4375                          if ( isXML ) {
4376                                  return match;
4377                          }
4378  
4379                          for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4380                                  if ( elem ) {
4381                                          if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4382                                                  if ( !inplace ) {
4383                                                          result.push( elem );
4384                                                  }
4385  
4386                                          } else if ( inplace ) {
4387                                                  curLoop[i] = false;
4388                                          }
4389                                  }
4390                          }
4391  
4392                          return false;
4393                  },
4394  
4395                  ID: function( match ) {
4396                          return match[1].replace( rBackslash, "" );
4397                  },
4398  
4399                  TAG: function( match, curLoop ) {
4400                          return match[1].replace( rBackslash, "" ).toLowerCase();
4401                  },
4402  
4403                  CHILD: function( match ) {
4404                          if ( match[1] === "nth" ) {
4405                                  if ( !match[2] ) {
4406                                          Sizzle.error( match[0] );
4407                                  }
4408  
4409                                  match[2] = match[2].replace(/^\+|\s*/g, '');
4410  
4411                                  // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4412                                  var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
4413                                          match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
4414                                          !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
4415  
4416                                  // calculate the numbers (first)n+(last) including if they are negative
4417                                  match[2] = (test[1] + (test[2] || 1)) - 0;
4418                                  match[3] = test[3] - 0;
4419                          }
4420                          else if ( match[2] ) {
4421                                  Sizzle.error( match[0] );
4422                          }
4423  
4424                          // TODO: Move to normal caching system
4425                          match[0] = done++;
4426  
4427                          return match;
4428                  },
4429  
4430                  ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4431                          var name = match[1] = match[1].replace( rBackslash, "" );
4432                         
4433                          if ( !isXML && Expr.attrMap[name] ) {
4434                                  match[1] = Expr.attrMap[name];
4435                          }
4436  
4437                          // Handle if an un-quoted value was used
4438                          match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
4439  
4440                          if ( match[2] === "~=" ) {
4441                                  match[4] = " " + match[4] + " ";
4442                          }
4443  
4444                          return match;
4445                  },
4446  
4447                  PSEUDO: function( match, curLoop, inplace, result, not ) {
4448                          if ( match[1] === "not" ) {
4449                                  // If we're dealing with a complex expression, or a simple one
4450                                  if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
4451                                          match[3] = Sizzle(match[3], null, null, curLoop);
4452  
4453                                  } else {
4454                                          var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4455  
4456                                          if ( !inplace ) {
4457                                                  result.push.apply( result, ret );
4458                                          }
4459  
4460                                          return false;
4461                                  }
4462  
4463                          } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
4464                                  return true;
4465                          }
4466                         
4467                          return match;
4468                  },
4469  
4470                  POS: function( match ) {
4471                          match.unshift( true );
4472  
4473                          return match;
4474                  }
4475          },
4476         
4477          filters: {
4478                  enabled: function( elem ) {
4479                          return elem.disabled === false && elem.type !== "hidden";
4480                  },
4481  
4482                  disabled: function( elem ) {
4483                          return elem.disabled === true;
4484                  },
4485  
4486                  checked: function( elem ) {
4487                          return elem.checked === true;
4488                  },
4489                 
4490                  selected: function( elem ) {
4491                          // Accessing this property makes selected-by-default
4492                          // options in Safari work properly
4493                          if ( elem.parentNode ) {
4494                                  elem.parentNode.selectedIndex;
4495                          }
4496                         
4497                          return elem.selected === true;
4498                  },
4499  
4500                  parent: function( elem ) {
4501                          return !!elem.firstChild;
4502                  },
4503  
4504                  empty: function( elem ) {
4505                          return !elem.firstChild;
4506                  },
4507  
4508                  has: function( elem, i, match ) {
4509                          return !!Sizzle( match[3], elem ).length;
4510                  },
4511  
4512                  header: function( elem ) {
4513                          return (/h\d/i).test( elem.nodeName );
4514                  },
4515  
4516                  text: function( elem ) {
4517                          var attr = elem.getAttribute( "type" ), type = elem.type;
4518                          // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4519                          // use getAttribute instead to test this case
4520                          return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
4521                  },
4522  
4523                  radio: function( elem ) {
4524                          return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4525                  },
4526  
4527                  checkbox: function( elem ) {
4528                          return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4529                  },
4530  
4531                  file: function( elem ) {
4532                          return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4533                  },
4534  
4535                  password: function( elem ) {
4536                          return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4537                  },
4538  
4539                  submit: function( elem ) {
4540                          var name = elem.nodeName.toLowerCase();
4541                          return (name === "input" || name === "button") && "submit" === elem.type;
4542                  },
4543  
4544                  image: function( elem ) {
4545                          return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4546                  },
4547  
4548                  reset: function( elem ) {
4549                          var name = elem.nodeName.toLowerCase();
4550                          return (name === "input" || name === "button") && "reset" === elem.type;
4551                  },
4552  
4553                  button: function( elem ) {
4554                          var name = elem.nodeName.toLowerCase();
4555                          return name === "input" && "button" === elem.type || name === "button";
4556                  },
4557  
4558                  input: function( elem ) {
4559                          return (/input|select|textarea|button/i).test( elem.nodeName );
4560                  },
4561  
4562                  focus: function( elem ) {
4563                          return elem === elem.ownerDocument.activeElement;
4564                  }
4565          },
4566          setFilters: {
4567                  first: function( elem, i ) {
4568                          return i === 0;
4569                  },
4570  
4571                  last: function( elem, i, match, array ) {
4572                          return i === array.length - 1;
4573                  },
4574  
4575                  even: function( elem, i ) {
4576                          return i % 2 === 0;
4577                  },
4578  
4579                  odd: function( elem, i ) {
4580                          return i % 2 === 1;
4581                  },
4582  
4583                  lt: function( elem, i, match ) {
4584                          return i < match[3] - 0;
4585                  },
4586  
4587                  gt: function( elem, i, match ) {
4588                          return i > match[3] - 0;
4589                  },
4590  
4591                  nth: function( elem, i, match ) {
4592                          return match[3] - 0 === i;
4593                  },
4594  
4595                  eq: function( elem, i, match ) {
4596                          return match[3] - 0 === i;
4597                  }
4598          },
4599          filter: {
4600                  PSEUDO: function( elem, match, i, array ) {
4601                          var name = match[1],
4602                                  filter = Expr.filters[ name ];
4603  
4604                          if ( filter ) {
4605                                  return filter( elem, i, match, array );
4606  
4607                          } else if ( name === "contains" ) {
4608                                  return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
4609  
4610                          } else if ( name === "not" ) {
4611                                  var not = match[3];
4612  
4613                                  for ( var j = 0, l = not.length; j < l; j++ ) {
4614                                          if ( not[j] === elem ) {
4615                                                  return false;
4616                                          }
4617                                  }
4618  
4619                                  return true;
4620  
4621                          } else {
4622                                  Sizzle.error( name );
4623                          }
4624                  },
4625  
4626                  CHILD: function( elem, match ) {
4627                          var first, last,
4628                                  doneName, parent, cache,
4629                                  count, diff,
4630                                  type = match[1],
4631                                  node = elem;
4632  
4633                          switch ( type ) {
4634                                  case "only":
4635                                  case "first":
4636                                          while ( (node = node.previousSibling) )  {
4637                                                  if ( node.nodeType === 1 ) { 
4638                                                          return false; 
4639                                                  }
4640                                          }
4641  
4642                                          if ( type === "first" ) { 
4643                                                  return true; 
4644                                          }
4645  
4646                                          node = elem;
4647  
4648                                  case "last":
4649                                          while ( (node = node.nextSibling) )      {
4650                                                  if ( node.nodeType === 1 ) { 
4651                                                          return false; 
4652                                                  }
4653                                          }
4654  
4655                                          return true;
4656  
4657                                  case "nth":
4658                                          first = match[2];
4659                                          last = match[3];
4660  
4661                                          if ( first === 1 && last === 0 ) {
4662                                                  return true;
4663                                          }
4664                                         
4665                                          doneName = match[0];
4666                                          parent = elem.parentNode;
4667         
4668                                          if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
4669                                                  count = 0;
4670                                                 
4671                                                  for ( node = parent.firstChild; node; node = node.nextSibling ) {
4672                                                          if ( node.nodeType === 1 ) {
4673                                                                  node.nodeIndex = ++count;
4674                                                          }
4675                                                  } 
4676  
4677                                                  parent[ expando ] = doneName;
4678                                          }
4679                                         
4680                                          diff = elem.nodeIndex - last;
4681  
4682                                          if ( first === 0 ) {
4683                                                  return diff === 0;
4684  
4685                                          } else {
4686                                                  return ( diff % first === 0 && diff / first >= 0 );
4687                                          }
4688                          }
4689                  },
4690  
4691                  ID: function( elem, match ) {
4692                          return elem.nodeType === 1 && elem.getAttribute("id") === match;
4693                  },
4694  
4695                  TAG: function( elem, match ) {
4696                          return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
4697                  },
4698                 
4699                  CLASS: function( elem, match ) {
4700                          return (" " + (elem.className || elem.getAttribute("class")) + " ")
4701                                  .indexOf( match ) > -1;
4702                  },
4703  
4704                  ATTR: function( elem, match ) {
4705                          var name = match[1],
4706                                  result = Sizzle.attr ?
4707                                          Sizzle.attr( elem, name ) :
4708                                          Expr.attrHandle[ name ] ?
4709                                          Expr.attrHandle[ name ]( elem ) :
4710                                          elem[ name ] != null ?
4711                                                  elem[ name ] :
4712                                                  elem.getAttribute( name ),
4713                                  value = result + "",
4714                                  type = match[2],
4715                                  check = match[4];
4716  
4717                          return result == null ?
4718                                  type === "!=" :
4719                                  !type && Sizzle.attr ?
4720                                  result != null :
4721                                  type === "=" ?
4722                                  value === check :
4723                                  type === "*=" ?
4724                                  value.indexOf(check) >= 0 :
4725                                  type === "~=" ?
4726                                  (" " + value + " ").indexOf(check) >= 0 :
4727                                  !check ?
4728                                  value && result !== false :
4729                                  type === "!=" ?
4730                                  value !== check :
4731                                  type === "^=" ?
4732                                  value.indexOf(check) === 0 :
4733                                  type === "$=" ?
4734                                  value.substr(value.length - check.length) === check :
4735                                  type === "|=" ?
4736                                  value === check || value.substr(0, check.length + 1) === check + "-" :
4737                                  false;
4738                  },
4739  
4740                  POS: function( elem, match, i, array ) {
4741                          var name = match[2],
4742                                  filter = Expr.setFilters[ name ];
4743  
4744                          if ( filter ) {
4745                                  return filter( elem, i, match, array );
4746                          }
4747                  }
4748          }
4749  };
4750  
4751  var origPOS = Expr.match.POS,
4752          fescape = function(all, num){
4753                  return "\\" + (num - 0 + 1);
4754          };
4755  
4756  for ( var type in Expr.match ) {
4757          Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
4758          Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4759  }
4760  
4761  var makeArray = function( array, results ) {
4762          array = Array.prototype.slice.call( array, 0 );
4763  
4764          if ( results ) {
4765                  results.push.apply( results, array );
4766                  return results;
4767          }
4768         
4769          return array;
4770  };
4771  
4772  // Perform a simple check to determine if the browser is capable of
4773  // converting a NodeList to an array using builtin methods.
4774  // Also verifies that the returned array holds DOM nodes
4775  // (which is not the case in the Blackberry browser)
4776  try {
4777          Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4778  
4779  // Provide a fallback method if it does not work
4780  } catch( e ) {
4781          makeArray = function( array, results ) {
4782                  var i = 0,
4783                          ret = results || [];
4784  
4785                  if ( toString.call(array) === "[object Array]" ) {
4786                          Array.prototype.push.apply( ret, array );
4787  
4788                  } else {
4789                          if ( typeof array.length === "number" ) {
4790                                  for ( var l = array.length; i < l; i++ ) {
4791                                          ret.push( array[i] );
4792                                  }
4793  
4794                          } else {
4795                                  for ( ; array[i]; i++ ) {
4796                                          ret.push( array[i] );
4797                                  }
4798                          }
4799                  }
4800  
4801                  return ret;
4802          };
4803  }
4804  
4805  var sortOrder, siblingCheck;
4806  
4807  if ( document.documentElement.compareDocumentPosition ) {
4808          sortOrder = function( a, b ) {
4809                  if ( a === b ) {
4810                          hasDuplicate = true;
4811                          return 0;
4812                  }
4813  
4814                  if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
4815                          return a.compareDocumentPosition ? -1 : 1;
4816                  }
4817  
4818                  return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4819          };
4820  
4821  } else {
4822          sortOrder = function( a, b ) {
4823                  // The nodes are identical, we can exit early
4824                  if ( a === b ) {
4825                          hasDuplicate = true;
4826                          return 0;
4827  
4828                  // Fallback to using sourceIndex (in IE) if it's available on both nodes
4829                  } else if ( a.sourceIndex && b.sourceIndex ) {
4830                          return a.sourceIndex - b.sourceIndex;
4831                  }
4832  
4833                  var al, bl,
4834                          ap = [],
4835                          bp = [],
4836                          aup = a.parentNode,
4837                          bup = b.parentNode,
4838                          cur = aup;
4839  
4840                  // If the nodes are siblings (or identical) we can do a quick check
4841                  if ( aup === bup ) {
4842                          return siblingCheck( a, b );
4843  
4844                  // If no parents were found then the nodes are disconnected
4845                  } else if ( !aup ) {
4846                          return -1;
4847  
4848                  } else if ( !bup ) {
4849                          return 1;
4850                  }
4851  
4852                  // Otherwise they're somewhere else in the tree so we need
4853                  // to build up a full list of the parentNodes for comparison
4854                  while ( cur ) {
4855                          ap.unshift( cur );
4856                          cur = cur.parentNode;
4857                  }
4858  
4859                  cur = bup;
4860  
4861                  while ( cur ) {
4862                          bp.unshift( cur );
4863                          cur = cur.parentNode;
4864                  }
4865  
4866                  al = ap.length;
4867                  bl = bp.length;
4868  
4869                  // Start walking down the tree looking for a discrepancy
4870                  for ( var i = 0; i < al && i < bl; i++ ) {
4871                          if ( ap[i] !== bp[i] ) {
4872                                  return siblingCheck( ap[i], bp[i] );
4873                          }
4874                  }
4875  
4876                  // We ended someplace up the tree so do a sibling check
4877                  return i === al ?
4878                          siblingCheck( a, bp[i], -1 ) :
4879                          siblingCheck( ap[i], b, 1 );
4880          };
4881  
4882          siblingCheck = function( a, b, ret ) {
4883                  if ( a === b ) {
4884                          return ret;
4885                  }
4886  
4887                  var cur = a.nextSibling;
4888  
4889                  while ( cur ) {
4890                          if ( cur === b ) {
4891                                  return -1;
4892                          }
4893  
4894                          cur = cur.nextSibling;
4895                  }
4896  
4897                  return 1;
4898          };
4899  }
4900  
4901  // Check to see if the browser returns elements by name when
4902  // querying by getElementById (and provide a workaround)
4903  (function(){
4904          // We're going to inject a fake input element with a specified name
4905          var form = document.createElement("div"),
4906                  id = "script" + (new Date()).getTime(),
4907                  root = document.documentElement;
4908  
4909          form.innerHTML = "<a name='" + id + "'/>";
4910  
4911          // Inject it into the root element, check its status, and remove it quickly
4912          root.insertBefore( form, root.firstChild );
4913  
4914          // The workaround has to do additional checks after a getElementById
4915          // Which slows things down for other browsers (hence the branching)
4916          if ( document.getElementById( id ) ) {
4917                  Expr.find.ID = function( match, context, isXML ) {
4918                          if ( typeof context.getElementById !== "undefined" && !isXML ) {
4919                                  var m = context.getElementById(match[1]);
4920  
4921                                  return m ?
4922                                          m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4923                                                  [m] :
4924                                                  undefined :
4925                                          [];
4926                          }
4927                  };
4928  
4929                  Expr.filter.ID = function( elem, match ) {
4930                          var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4931  
4932                          return elem.nodeType === 1 && node && node.nodeValue === match;
4933                  };
4934          }
4935  
4936          root.removeChild( form );
4937  
4938          // release memory in IE
4939          root = form = null;
4940  })();
4941  
4942  (function(){
4943          // Check to see if the browser returns only elements
4944          // when doing getElementsByTagName("*")
4945  
4946          // Create a fake element
4947          var div = document.createElement("div");
4948          div.appendChild( document.createComment("") );
4949  
4950          // Make sure no comments are found
4951          if ( div.getElementsByTagName("*").length > 0 ) {
4952                  Expr.find.TAG = function( match, context ) {
4953                          var results = context.getElementsByTagName( match[1] );
4954  
4955                          // Filter out possible comments
4956                          if ( match[1] === "*" ) {
4957                                  var tmp = [];
4958  
4959                                  for ( var i = 0; results[i]; i++ ) {
4960                                          if ( results[i].nodeType === 1 ) {
4961                                                  tmp.push( results[i] );
4962                                          }
4963                                  }
4964  
4965                                  results = tmp;
4966                          }
4967  
4968                          return results;
4969                  };
4970          }
4971  
4972          // Check to see if an attribute returns normalized href attributes
4973          div.innerHTML = "<a href='#'></a>";
4974  
4975          if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4976                          div.firstChild.getAttribute("href") !== "#" ) {
4977  
4978                  Expr.attrHandle.href = function( elem ) {
4979                          return elem.getAttribute( "href", 2 );
4980                  };
4981          }
4982  
4983          // release memory in IE
4984          div = null;
4985  })();
4986  
4987  if ( document.querySelectorAll ) {
4988          (function(){
4989                  var oldSizzle = Sizzle,
4990                          div = document.createElement("div"),
4991                          id = "__sizzle__";
4992  
4993                  div.innerHTML = "<p class='TEST'></p>";
4994  
4995                  // Safari can't handle uppercase or unicode characters when
4996                  // in quirks mode.
4997                  if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4998                          return;
4999                  }
5000         
5001                  Sizzle = function( query, context, extra, seed ) {
5002                          context = context || document;
5003  
5004                          // Only use querySelectorAll on non-XML documents
5005                          // (ID selectors don't work in non-HTML documents)
5006                          if ( !seed && !Sizzle.isXML(context) ) {
5007                                  // See if we find a selector to speed up
5008                                  var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
5009                                 
5010                                  if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
5011                                          // Speed-up: Sizzle("TAG")
5012                                          if ( match[1] ) {
5013                                                  return makeArray( context.getElementsByTagName( query ), extra );
5014                                         
5015                                          // Speed-up: Sizzle(".CLASS")
5016                                          } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
5017                                                  return makeArray( context.getElementsByClassName( match[2] ), extra );
5018                                          }
5019                                  }
5020                                 
5021                                  if ( context.nodeType === 9 ) {
5022                                          // Speed-up: Sizzle("body")
5023                                          // The body element only exists once, optimize finding it
5024                                          if ( query === "body" && context.body ) {
5025                                                  return makeArray( [ context.body ], extra );
5026                                                 
5027                                          // Speed-up: Sizzle("#ID")
5028                                          } else if ( match && match[3] ) {
5029                                                  var elem = context.getElementById( match[3] );
5030  
5031                                                  // Check parentNode to catch when Blackberry 4.6 returns
5032                                                  // nodes that are no longer in the document #6963
5033                                                  if ( elem && elem.parentNode ) {
5034                                                          // Handle the case where IE and Opera return items
5035                                                          // by name instead of ID
5036                                                          if ( elem.id === match[3] ) {
5037                                                                  return makeArray( [ elem ], extra );
5038                                                          }
5039                                                         
5040                                                  } else {
5041                                                          return makeArray( [], extra );
5042                                                  }
5043                                          }
5044                                         
5045                                          try {
5046                                                  return makeArray( context.querySelectorAll(query), extra );
5047                                          } catch(qsaError) {}
5048  
5049                                  // qSA works strangely on Element-rooted queries
5050                                  // We can work around this by specifying an extra ID on the root
5051                                  // and working up from there (Thanks to Andrew Dupont for the technique)
5052                                  // IE 8 doesn't work on object elements
5053                                  } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
5054                                          var oldContext = context,
5055                                                  old = context.getAttribute( "id" ),
5056                                                  nid = old || id,
5057                                                  hasParent = context.parentNode,
5058                                                  relativeHierarchySelector = /^\s*[+~]/.test( query );
5059  
5060                                          if ( !old ) {
5061                                                  context.setAttribute( "id", nid );
5062                                          } else {
5063                                                  nid = nid.replace( /'/g, "\\$&" );
5064                                          }
5065                                          if ( relativeHierarchySelector && hasParent ) {
5066                                                  context = context.parentNode;
5067                                          }
5068  
5069                                          try {
5070                                                  if ( !relativeHierarchySelector || hasParent ) {
5071                                                          return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
5072                                                  }
5073  
5074                                          } catch(pseudoError) {
5075                                          } finally {
5076                                                  if ( !old ) {
5077                                                          oldContext.removeAttribute( "id" );
5078                                                  }
5079                                          }
5080                                  }
5081                          }
5082                 
5083                          return oldSizzle(query, context, extra, seed);
5084                  };
5085  
5086                  for ( var prop in oldSizzle ) {
5087                          Sizzle[ prop ] = oldSizzle[ prop ];
5088                  }
5089  
5090                  // release memory in IE
5091                  div = null;
5092          })();
5093  }
5094  
5095  (function(){
5096          var html = document.documentElement,
5097                  matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
5098  
5099          if ( matches ) {
5100                  // Check to see if it's possible to do matchesSelector
5101                  // on a disconnected node (IE 9 fails this)
5102                  var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
5103                          pseudoWorks = false;
5104  
5105                  try {
5106                          // This should fail with an exception
5107                          // Gecko does not error, returns false instead
5108                          matches.call( document.documentElement, "[test!='']:sizzle" );
5109         
5110                  } catch( pseudoError ) {
5111                          pseudoWorks = true;
5112                  }
5113  
5114                  Sizzle.matchesSelector = function( node, expr ) {
5115                          // Make sure that attribute selectors are quoted
5116                          expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
5117  
5118                          if ( !Sizzle.isXML( node ) ) {
5119                                  try { 
5120                                          if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
5121                                                  var ret = matches.call( node, expr );
5122  
5123                                                  // IE 9's matchesSelector returns false on disconnected nodes
5124                                                  if ( ret || !disconnectedMatch ||
5125                                                                  // As well, disconnected nodes are said to be in a document
5126                                                                  // fragment in IE 9, so check for that
5127                                                                  node.document && node.document.nodeType !== 11 ) {
5128                                                          return ret;
5129                                                  }
5130                                          }
5131                                  } catch(e) {}
5132                          }
5133  
5134                          return Sizzle(expr, null, null, [node]).length > 0;
5135                  };
5136          }
5137  })();
5138  
5139  (function(){
5140          var div = document.createElement("div");
5141  
5142          div.innerHTML = "<div class='test e'></div><div class='test'></div>";
5143  
5144          // Opera can't find a second classname (in 9.6)
5145          // Also, make sure that getElementsByClassName actually exists
5146          if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
5147                  return;
5148          }
5149  
5150          // Safari caches class attributes, doesn't catch changes (in 3.2)
5151          div.lastChild.className = "e";
5152  
5153          if ( div.getElementsByClassName("e").length === 1 ) {
5154                  return;
5155          }
5156         
5157          Expr.order.splice(1, 0, "CLASS");
5158          Expr.find.CLASS = function( match, context, isXML ) {
5159                  if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
5160                          return context.getElementsByClassName(match[1]);
5161                  }
5162          };
5163  
5164          // release memory in IE
5165          div = null;
5166  })();
5167  
5168  function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5169          for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5170                  var elem = checkSet[i];
5171  
5172                  if ( elem ) {
5173                          var match = false;
5174  
5175                          elem = elem[dir];
5176  
5177                          while ( elem ) {
5178                                  if ( elem[ expando ] === doneName ) {
5179                                          match = checkSet[elem.sizset];
5180                                          break;
5181                                  }
5182  
5183                                  if ( elem.nodeType === 1 && !isXML ){
5184                                          elem[ expando ] = doneName;
5185                                          elem.sizset = i;
5186                                  }
5187  
5188                                  if ( elem.nodeName.toLowerCase() === cur ) {
5189                                          match = elem;
5190                                          break;
5191                                  }
5192  
5193                                  elem = elem[dir];
5194                          }
5195  
5196                          checkSet[i] = match;
5197                  }
5198          }
5199  }
5200  
5201  function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5202          for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5203                  var elem = checkSet[i];
5204  
5205                  if ( elem ) {
5206                          var match = false;
5207                         
5208                          elem = elem[dir];
5209  
5210                          while ( elem ) {
5211                                  if ( elem[ expando ] === doneName ) {
5212                                          match = checkSet[elem.sizset];
5213                                          break;
5214                                  }
5215  
5216                                  if ( elem.nodeType === 1 ) {
5217                                          if ( !isXML ) {
5218                                                  elem[ expando ] = doneName;
5219                                                  elem.sizset = i;
5220                                          }
5221  
5222                                          if ( typeof cur !== "string" ) {
5223                                                  if ( elem === cur ) {
5224                                                          match = true;
5225                                                          break;
5226                                                  }
5227  
5228                                          } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5229                                                  match = elem;
5230                                                  break;
5231                                          }
5232                                  }
5233  
5234                                  elem = elem[dir];
5235                          }
5236  
5237                          checkSet[i] = match;
5238                  }
5239          }
5240  }
5241  
5242  if ( document.documentElement.contains ) {
5243          Sizzle.contains = function( a, b ) {
5244                  return a !== b && (a.contains ? a.contains(b) : true);
5245          };
5246  
5247  } else if ( document.documentElement.compareDocumentPosition ) {
5248          Sizzle.contains = function( a, b ) {
5249                  return !!(a.compareDocumentPosition(b) & 16);
5250          };
5251  
5252  } else {
5253          Sizzle.contains = function() {
5254                  return false;
5255          };
5256  }
5257  
5258  Sizzle.isXML = function( elem ) {
5259          // documentElement is verified for cases where it doesn't yet exist
5260          // (such as loading iframes in IE - #4833)
5261          var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
5262  
5263          return documentElement ? documentElement.nodeName !== "HTML" : false;
5264  };
5265  
5266  var posProcess = function( selector, context, seed ) {
5267          var match,
5268                  tmpSet = [],
5269                  later = "",
5270                  root = context.nodeType ? [context] : context;
5271  
5272          // Position selectors must be done after the filter
5273          // And so must :not(positional) so we move all PSEUDOs to the end
5274          while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5275                  later += match[0];
5276                  selector = selector.replace( Expr.match.PSEUDO, "" );
5277          }
5278  
5279          selector = Expr.relative[selector] ? selector + "*" : selector;
5280  
5281          for ( var i = 0, l = root.length; i < l; i++ ) {
5282                  Sizzle( selector, root[i], tmpSet, seed );
5283          }
5284  
5285          return Sizzle.filter( later, tmpSet );
5286  };
5287  
5288  // EXPOSE
5289  // Override sizzle attribute retrieval
5290  Sizzle.attr = jQuery.attr;
5291  Sizzle.selectors.attrMap = {};
5292  jQuery.find = Sizzle;
5293  jQuery.expr = Sizzle.selectors;
5294  jQuery.expr[":"] = jQuery.expr.filters;
5295  jQuery.unique = Sizzle.uniqueSort;
5296  jQuery.text = Sizzle.getText;
5297  jQuery.isXMLDoc = Sizzle.isXML;
5298  jQuery.contains = Sizzle.contains;
5299  
5300  
5301  })();
5302  
5303  
5304  var runtil = /Until$/,
5305          rparentsprev = /^(?:parents|prevUntil|prevAll)/,
5306          // Note: This RegExp should be improved, or likely pulled from Sizzle
5307          rmultiselector = /,/,
5308          isSimple = /^.[^:#\[\.,]*$/,
5309          slice = Array.prototype.slice,
5310          POS = jQuery.expr.match.POS,
5311          // methods guaranteed to produce a unique set when starting from a unique set
5312          guaranteedUnique = {
5313                  children: true,
5314                  contents: true,
5315                  next: true,
5316                  prev: true
5317          };
5318  
5319  jQuery.fn.extend({
5320          find: function( selector ) {
5321                  var self = this,
5322                          i, l;
5323  
5324                  if ( typeof selector !== "string" ) {
5325                          return jQuery( selector ).filter(function() {
5326                                  for ( i = 0, l = self.length; i < l; i++ ) {
5327                                          if ( jQuery.contains( self[ i ], this ) ) {
5328                                                  return true;
5329                                          }
5330                                  }
5331                          });
5332                  }
5333  
5334                  var ret = this.pushStack( "", "find", selector ),
5335                          length, n, r;
5336  
5337                  for ( i = 0, l = this.length; i < l; i++ ) {
5338                          length = ret.length;
5339                          jQuery.find( selector, this[i], ret );
5340  
5341                          if ( i > 0 ) {
5342                                  // Make sure that the results are unique
5343                                  for ( n = length; n < ret.length; n++ ) {
5344                                          for ( r = 0; r < length; r++ ) {
5345                                                  if ( ret[r] === ret[n] ) {
5346                                                          ret.splice(n--, 1);
5347                                                          break;
5348                                                  }
5349                                          }
5350                                  }
5351                          }
5352                  }
5353  
5354                  return ret;
5355          },
5356  
5357          has: function( target ) {
5358                  var targets = jQuery( target );
5359                  return this.filter(function() {
5360                          for ( var i = 0, l = targets.length; i < l; i++ ) {
5361                                  if ( jQuery.contains( this, targets[i] ) ) {
5362                                          return true;
5363                                  }
5364                          }
5365                  });
5366          },
5367  
5368          not: function( selector ) {
5369                  return this.pushStack( winnow(this, selector, false), "not", selector);
5370          },
5371  
5372          filter: function( selector ) {
5373                  return this.pushStack( winnow(this, selector, true), "filter", selector );
5374          },
5375  
5376          is: function( selector ) {
5377                  return !!selector && ( 
5378                          typeof selector === "string" ?
5379                                  // If this is a positional selector, check membership in the returned set
5380                                  // so $("p:first").is("p:last") won't return true for a doc with two "p".
5381                                  POS.test( selector ) ? 
5382                                          jQuery( selector, this.context ).index( this[0] ) >= 0 :
5383                                          jQuery.filter( selector, this ).length > 0 :
5384                                  this.filter( selector ).length > 0 );
5385          },
5386  
5387          closest: function( selectors, context ) {
5388                  var ret = [], i, l, cur = this[0];
5389                 
5390                  // Array (deprecated as of jQuery 1.7)
5391                  if ( jQuery.isArray( selectors ) ) {
5392                          var level = 1;
5393  
5394                          while ( cur && cur.ownerDocument && cur !== context ) {
5395                                  for ( i = 0; i < selectors.length; i++ ) {
5396  
5397                                          if ( jQuery( cur ).is( selectors[ i ] ) ) {
5398                                                  ret.push({ selector: selectors[ i ], elem: cur, level: level });
5399                                          }
5400                                  }
5401  
5402                                  cur = cur.parentNode;
5403                                  level++;
5404                          }
5405  
5406                          return ret;
5407                  }
5408  
5409                  // String
5410                  var pos = POS.test( selectors ) || typeof selectors !== "string" ?
5411                                  jQuery( selectors, context || this.context ) :
5412                                  0;
5413  
5414                  for ( i = 0, l = this.length; i < l; i++ ) {
5415                          cur = this[i];
5416  
5417                          while ( cur ) {
5418                                  if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5419                                          ret.push( cur );
5420                                          break;
5421  
5422                                  } else {
5423                                          cur = cur.parentNode;
5424                                          if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
5425                                                  break;
5426                                          }
5427                                  }
5428                          }
5429                  }
5430  
5431                  ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5432  
5433                  return this.pushStack( ret, "closest", selectors );
5434          },
5435  
5436          // Determine the position of an element within
5437          // the matched set of elements
5438          index: function( elem ) {
5439  
5440                  // No argument, return index in parent
5441                  if ( !elem ) {
5442                          return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
5443                  }
5444  
5445                  // index in selector
5446                  if ( typeof elem === "string" ) {
5447                          return jQuery.inArray( this[0], jQuery( elem ) );
5448                  }
5449  
5450                  // Locate the position of the desired element
5451                  return jQuery.inArray(
5452                          // If it receives a jQuery object, the first element is used
5453                          elem.jquery ? elem[0] : elem, this );
5454          },
5455  
5456          add: function( selector, context ) {
5457                  var set = typeof selector === "string" ?
5458                                  jQuery( selector, context ) :
5459                                  jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5460                          all = jQuery.merge( this.get(), set );
5461  
5462                  return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
5463                          all :
5464                          jQuery.unique( all ) );
5465          },
5466  
5467          andSelf: function() {
5468                  return this.add( this.prevObject );
5469          }
5470  });
5471  
5472  // A painfully simple check to see if an element is disconnected
5473  // from a document (should be improved, where feasible).
5474  function isDisconnected( node ) {
5475          return !node || !node.parentNode || node.parentNode.nodeType === 11;
5476  }
5477  
5478  jQuery.each({
5479          parent: function( elem ) {
5480                  var parent = elem.parentNode;
5481                  return parent && parent.nodeType !== 11 ? parent : null;
5482          },
5483          parents: function( elem ) {
5484                  return jQuery.dir( elem, "parentNode" );
5485          },
5486          parentsUntil: function( elem, i, until ) {
5487                  return jQuery.dir( elem, "parentNode", until );
5488          },
5489          next: function( elem ) {
5490                  return jQuery.nth( elem, 2, "nextSibling" );
5491          },
5492          prev: function( elem ) {
5493                  return jQuery.nth( elem, 2, "previousSibling" );
5494          },
5495          nextAll: function( elem ) {
5496                  return jQuery.dir( elem, "nextSibling" );
5497          },
5498          prevAll: function( elem ) {
5499                  return jQuery.dir( elem, "previousSibling" );
5500          },
5501          nextUntil: function( elem, i, until ) {
5502                  return jQuery.dir( elem, "nextSibling", until );
5503          },
5504          prevUntil: function( elem, i, until ) {
5505                  return jQuery.dir( elem, "previousSibling", until );
5506          },
5507          siblings: function( elem ) {
5508                  return jQuery.sibling( elem.parentNode.firstChild, elem );
5509          },
5510          children: function( elem ) {
5511                  return jQuery.sibling( elem.firstChild );
5512          },
5513          contents: function( elem ) {
5514                  return jQuery.nodeName( elem, "iframe" ) ?
5515                          elem.contentDocument || elem.contentWindow.document :
5516                          jQuery.makeArray( elem.childNodes );
5517          }
5518  }, function( name, fn ) {
5519          jQuery.fn[ name ] = function( until, selector ) {
5520                  var ret = jQuery.map( this, fn, until );
5521  
5522                  if ( !runtil.test( name ) ) {
5523                          selector = until;
5524                  }
5525  
5526                  if ( selector && typeof selector === "string" ) {
5527                          ret = jQuery.filter( selector, ret );
5528                  }
5529  
5530                  ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5531  
5532                  if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5533                          ret = ret.reverse();
5534                  }
5535  
5536                  return this.pushStack( ret, name, slice.call( arguments ).join(",") );
5537          };
5538  });
5539  
5540  jQuery.extend({
5541          filter: function( expr, elems, not ) {
5542                  if ( not ) {
5543                          expr = ":not(" + expr + ")";
5544                  }
5545  
5546                  return elems.length === 1 ?
5547                          jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5548                          jQuery.find.matches(expr, elems);
5549          },
5550  
5551          dir: function( elem, dir, until ) {
5552                  var matched = [],
5553                          cur = elem[ dir ];
5554  
5555                  while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
5556                          if ( cur.nodeType === 1 ) {
5557                                  matched.push( cur );
5558                          }
5559                          cur = cur[dir];
5560                  }
5561                  return matched;
5562          },
5563  
5564          nth: function( cur, result, dir, elem ) {
5565                  result = result || 1;
5566                  var num = 0;
5567  
5568                  for ( ; cur; cur = cur[dir] ) {
5569                          if ( cur.nodeType === 1 && ++num === result ) {
5570                                  break;
5571                          }
5572                  }
5573  
5574                  return cur;
5575          },
5576  
5577          sibling: function( n, elem ) {
5578                  var r = [];
5579  
5580                  for ( ; n; n = n.nextSibling ) {
5581                          if ( n.nodeType === 1 && n !== elem ) {
5582                                  r.push( n );
5583                          }
5584                  }
5585  
5586                  return r;
5587          }
5588  });
5589  
5590  // Implement the identical functionality for filter and not
5591  function winnow( elements, qualifier, keep ) {
5592  
5593          // Can't pass null or undefined to indexOf in Firefox 4
5594          // Set to 0 to skip string check
5595          qualifier = qualifier || 0;
5596  
5597          if ( jQuery.isFunction( qualifier ) ) {
5598                  return jQuery.grep(elements, function( elem, i ) {
5599                          var retVal = !!qualifier.call( elem, i, elem );
5600                          return retVal === keep;
5601                  });
5602  
5603          } else if ( qualifier.nodeType ) {
5604                  return jQuery.grep(elements, function( elem, i ) {
5605                          return ( elem === qualifier ) === keep;
5606                  });
5607  
5608          } else if ( typeof qualifier === "string" ) {
5609                  var filtered = jQuery.grep(elements, function( elem ) {
5610                          return elem.nodeType === 1;
5611                  });
5612  
5613                  if ( isSimple.test( qualifier ) ) {
5614                          return jQuery.filter(qualifier, filtered, !keep);
5615                  } else {
5616                          qualifier = jQuery.filter( qualifier, filtered );
5617                  }
5618          }
5619  
5620          return jQuery.grep(elements, function( elem, i ) {
5621                  return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
5622          });
5623  }
5624  
5625  
5626  
5627  
5628  function createSafeFragment( document ) {
5629          var list = nodeNames.split( "|" ),
5630          safeFrag = document.createDocumentFragment();
5631  
5632          if ( safeFrag.createElement ) {
5633                  while ( list.length ) {
5634                          safeFrag.createElement(
5635                                  list.pop()
5636                          );
5637                  }
5638          }
5639          return safeFrag;
5640  }
5641  
5642  var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" +
5643                  "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
5644          rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5645          rleadingWhitespace = /^\s+/,
5646          rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
5647          rtagName = /<([\w:]+)/,
5648          rtbody = /<tbody/i,
5649          rhtml = /<|&#?\w+;/,
5650          rnoInnerhtml = /<(?:script|style)/i,
5651          rnocache = /<(?:script|object|embed|option|style)/i,
5652          rnoshimcache = new RegExp("<(?:" + nodeNames + ")", "i"),
5653          // checked="checked" or checked
5654          rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5655          rscriptType = /\/(java|ecma)script/i,
5656          rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
5657          wrapMap = {
5658                  option: [ 1, "<select multiple='multiple'>", "</select>" ],
5659                  legend: [ 1, "<fieldset>", "</fieldset>" ],
5660                  thead: [ 1, "<table>", "</table>" ],
5661                  tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5662                  td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5663                  col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5664                  area: [ 1, "<map>", "</map>" ],
5665                  _default: [ 0, "", "" ]
5666          },
5667          safeFragment = createSafeFragment( document );
5668  
5669  wrapMap.optgroup = wrapMap.option;
5670  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5671  wrapMap.th = wrapMap.td;
5672  
5673  // IE can't serialize <link> and <script> tags normally
5674  if ( !jQuery.support.htmlSerialize ) {
5675          wrapMap._default = [ 1, "div<div>", "</div>" ];
5676  }
5677  
5678  jQuery.fn.extend({
5679          text: function( text ) {
5680                  if ( jQuery.isFunction(text) ) {
5681                          return this.each(function(i) {
5682                                  var self = jQuery( this );
5683  
5684                                  self.text( text.call(this, i, self.text()) );
5685                          });
5686                  }
5687  
5688                  if ( typeof text !== "object" && text !== undefined ) {
5689                          return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
5690                  }
5691  
5692                  return jQuery.text( this );
5693          },
5694  
5695          wrapAll: function( html ) {
5696                  if ( jQuery.isFunction( html ) ) {
5697                          return this.each(function(i) {
5698                                  jQuery(this).wrapAll( html.call(this, i) );
5699                          });
5700                  }
5701  
5702                  if ( this[0] ) {
5703                          // The elements to wrap the target around
5704                          var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5705  
5706                          if ( this[0].parentNode ) {
5707                                  wrap.insertBefore( this[0] );
5708                          }
5709  
5710                          wrap.map(function() {
5711                                  var elem = this;
5712  
5713                                  while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5714                                          elem = elem.firstChild;
5715                                  }
5716  
5717                                  return elem;
5718                          }).append( this );
5719                  }
5720  
5721                  return this;
5722          },
5723  
5724          wrapInner: function( html ) {
5725                  if ( jQuery.isFunction( html ) ) {
5726                          return this.each(function(i) {
5727                                  jQuery(this).wrapInner( html.call(this, i) );
5728                          });
5729                  }
5730  
5731                  return this.each(function() {
5732                          var self = jQuery( this ),
5733                                  contents = self.contents();
5734  
5735                          if ( contents.length ) {
5736                                  contents.wrapAll( html );
5737  
5738                          } else {
5739                                  self.append( html );
5740                          }
5741                  });
5742          },
5743  
5744          wrap: function( html ) {
5745                  var isFunction = jQuery.isFunction( html );
5746  
5747                  return this.each(function(i) {
5748                          jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
5749                  });
5750          },
5751  
5752          unwrap: function() {
5753                  return this.parent().each(function() {
5754                          if ( !jQuery.nodeName( this, "body" ) ) {
5755                                  jQuery( this ).replaceWith( this.childNodes );
5756                          }
5757                  }).end();
5758          },
5759  
5760          append: function() {
5761                  return this.domManip(arguments, true, function( elem ) {
5762                          if ( this.nodeType === 1 ) {
5763                                  this.appendChild( elem );
5764                          }
5765                  });
5766          },
5767  
5768          prepend: function() {
5769                  return this.domManip(arguments, true, function( elem ) {
5770                          if ( this.nodeType === 1 ) {
5771                                  this.insertBefore( elem, this.firstChild );
5772                          }
5773                  });
5774          },
5775  
5776          before: function() {
5777                  if ( this[0] && this[0].parentNode ) {
5778                          return this.domManip(arguments, false, function( elem ) {
5779                                  this.parentNode.insertBefore( elem, this );
5780                          });
5781                  } else if ( arguments.length ) {
5782                          var set = jQuery.clean( arguments );
5783                          set.push.apply( set, this.toArray() );
5784                          return this.pushStack( set, "before", arguments );
5785                  }
5786          },
5787  
5788          after: function() {
5789                  if ( this[0] && this[0].parentNode ) {
5790                          return this.domManip(arguments, false, function( elem ) {
5791                                  this.parentNode.insertBefore( elem, this.nextSibling );
5792                          });
5793                  } else if ( arguments.length ) {
5794                          var set = this.pushStack( this, "after", arguments );
5795                          set.push.apply( set, jQuery.clean(arguments) );
5796                          return set;
5797                  }
5798          },
5799  
5800          // keepData is for internal use only--do not document
5801          remove: function( selector, keepData ) {
5802                  for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5803                          if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5804                                  if ( !keepData && elem.nodeType === 1 ) {
5805                                          jQuery.cleanData( elem.getElementsByTagName("*") );
5806                                          jQuery.cleanData( [ elem ] );
5807                                  }
5808  
5809                                  if ( elem.parentNode ) {
5810                                          elem.parentNode.removeChild( elem );
5811                                  }
5812                          }
5813                  }
5814  
5815                  return this;
5816          },
5817  
5818          empty: function() {
5819                  for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5820                          // Remove element nodes and prevent memory leaks
5821                          if ( elem.nodeType === 1 ) {
5822                                  jQuery.cleanData( elem.getElementsByTagName("*") );
5823                          }
5824  
5825                          // Remove any remaining nodes
5826                          while ( elem.firstChild ) {
5827                                  elem.removeChild( elem.firstChild );
5828                          }
5829                  }
5830  
5831                  return this;
5832          },
5833  
5834          clone: function( dataAndEvents, deepDataAndEvents ) {
5835                  dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5836                  deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5837  
5838                  return this.map( function () {
5839                          return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5840                  });
5841          },
5842  
5843          html: function( value ) {
5844                  if ( value === undefined ) {
5845                          return this[0] && this[0].nodeType === 1 ?
5846                                  this[0].innerHTML.replace(rinlinejQuery, "") :
5847                                  null;
5848  
5849                  // See if we can take a shortcut and just use innerHTML
5850                  } else if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5851                          (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5852                          !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5853  
5854                          value = value.replace(rxhtmlTag, "<$1></$2>");
5855  
5856                          try {
5857                                  for ( var i = 0, l = this.length; i < l; i++ ) {
5858                                          // Remove element nodes and prevent memory leaks
5859                                          if ( this[i].nodeType === 1 ) {
5860                                                  jQuery.cleanData( this[i].getElementsByTagName("*") );
5861                                                  this[i].innerHTML = value;
5862                                          }
5863                                  }
5864  
5865                          // If using innerHTML throws an exception, use the fallback method
5866                          } catch(e) {
5867                                  this.empty().append( value );
5868                          }
5869  
5870                  } else if ( jQuery.isFunction( value ) ) {
5871                          this.each(function(i){
5872                                  var self = jQuery( this );
5873  
5874                                  self.html( value.call(this, i, self.html()) );
5875                          });
5876  
5877                  } else {
5878                          this.empty().append( value );
5879                  }
5880  
5881                  return this;
5882          },
5883  
5884          replaceWith: function( value ) {
5885                  if ( this[0] && this[0].parentNode ) {
5886                          // Make sure that the elements are removed from the DOM before they are inserted
5887                          // this can help fix replacing a parent with child elements
5888                          if ( jQuery.isFunction( value ) ) {
5889                                  return this.each(function(i) {
5890                                          var self = jQuery(this), old = self.html();
5891                                          self.replaceWith( value.call( this, i, old ) );
5892                                  });
5893                          }
5894  
5895                          if ( typeof value !== "string" ) {
5896                                  value = jQuery( value ).detach();
5897                          }
5898  
5899                          return this.each(function() {
5900                                  var next = this.nextSibling,
5901                                          parent = this.parentNode;
5902  
5903                                  jQuery( this ).remove();
5904  
5905                                  if ( next ) {
5906                                          jQuery(next).before( value );
5907                                  } else {
5908                                          jQuery(parent).append( value );
5909                                  }
5910                          });
5911                  } else {
5912                          return this.length ?
5913                                  this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5914                                  this;
5915                  }
5916          },
5917  
5918          detach: function( selector ) {
5919                  return this.remove( selector, true );
5920          },
5921  
5922          domManip: function( args, table, callback ) {
5923                  var results, first, fragment, parent,
5924                          value = args[0],
5925                          scripts = [];
5926  
5927                  // We can't cloneNode fragments that contain checked, in WebKit
5928                  if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5929                          return this.each(function() {
5930                                  jQuery(this).domManip( args, table, callback, true );
5931                          });
5932                  }
5933  
5934                  if ( jQuery.isFunction(value) ) {
5935                          return this.each(function(i) {
5936                                  var self = jQuery(this);
5937                                  args[0] = value.call(this, i, table ? self.html() : undefined);
5938                                  self.domManip( args, table, callback );
5939                          });
5940                  }
5941  
5942                  if ( this[0] ) {
5943                          parent = value && value.parentNode;
5944  
5945                          // If we're in a fragment, just use that instead of building a new one
5946                          if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5947                                  results = { fragment: parent };
5948  
5949                          } else {
5950                                  results = jQuery.buildFragment( args, this, scripts );
5951                          }
5952  
5953                          fragment = results.fragment;
5954  
5955                          if ( fragment.childNodes.length === 1 ) {
5956                                  first = fragment = fragment.firstChild;
5957                          } else {
5958                                  first = fragment.firstChild;
5959                          }
5960  
5961                          if ( first ) {
5962                                  table = table && jQuery.nodeName( first, "tr" );
5963  
5964                                  for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5965                                          callback.call(
5966                                                  table ?
5967                                                          root(this[i], first) :
5968                                                          this[i],
5969                                                  // Make sure that we do not leak memory by inadvertently discarding
5970                                                  // the original fragment (which might have attached data) instead of
5971                                                  // using it; in addition, use the original fragment object for the last
5972                                                  // item instead of first because it can end up being emptied incorrectly
5973                                                  // in certain situations (Bug #8070).
5974                                                  // Fragments from the fragment cache must always be cloned and never used
5975                                                  // in place.
5976                                                  results.cacheable || ( l > 1 && i < lastIndex ) ?
5977                                                          jQuery.clone( fragment, true, true ) :
5978                                                          fragment
5979                                          );
5980                                  }
5981                          }
5982  
5983                          if ( scripts.length ) {
5984                                  jQuery.each( scripts, evalScript );
5985                          }
5986                  }
5987  
5988                  return this;
5989          }
5990  });
5991  
5992  function root( elem, cur ) {
5993          return jQuery.nodeName(elem, "table") ?
5994                  (elem.getElementsByTagName("tbody")[0] ||
5995                  elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5996                  elem;
5997  }
5998  
5999  function cloneCopyEvent( src, dest ) {
6000  
6001          if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
6002                  return;
6003          }
6004  
6005          var type, i, l,
6006                  oldData = jQuery._data( src ),
6007                  curData = jQuery._data( dest, oldData ),
6008                  events = oldData.events;
6009  
6010          if ( events ) {
6011                  delete curData.handle;
6012                  curData.events = {};
6013  
6014                  for ( type in events ) {
6015                          for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6016                                  jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
6017                          }
6018                  }
6019          }
6020  
6021          // make the cloned public data object a copy from the original
6022          if ( curData.data ) {
6023                  curData.data = jQuery.extend( {}, curData.data );
6024          }
6025  }
6026  
6027  function cloneFixAttributes( src, dest ) {
6028          var nodeName;
6029  
6030          // We do not need to do anything for non-Elements
6031          if ( dest.nodeType !== 1 ) {
6032                  return;
6033          }
6034  
6035          // clearAttributes removes the attributes, which we don't want,
6036          // but also removes the attachEvent events, which we *do* want
6037          if ( dest.clearAttributes ) {
6038                  dest.clearAttributes();
6039          }
6040  
6041          // mergeAttributes, in contrast, only merges back on the
6042          // original attributes, not the events
6043          if ( dest.mergeAttributes ) {
6044                  dest.mergeAttributes( src );
6045          }
6046  
6047          nodeName = dest.nodeName.toLowerCase();
6048  
6049          // IE6-8 fail to clone children inside object elements that use
6050          // the proprietary classid attribute value (rather than the type
6051          // attribute) to identify the type of content to display
6052          if ( nodeName === "object" ) {
6053                  dest.outerHTML = src.outerHTML;
6054  
6055          } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
6056                  // IE6-8 fails to persist the checked state of a cloned checkbox
6057                  // or radio button. Worse, IE6-7 fail to give the cloned element
6058                  // a checked appearance if the defaultChecked value isn't also set
6059                  if ( src.checked ) {
6060                          dest.defaultChecked = dest.checked = src.checked;
6061                  }
6062  
6063                  // IE6-7 get confused and end up setting the value of a cloned
6064                  // checkbox/radio button to an empty string instead of "on"
6065                  if ( dest.value !== src.value ) {
6066                          dest.value = src.value;
6067                  }
6068  
6069          // IE6-8 fails to return the selected option to the default selected
6070          // state when cloning options
6071          } else if ( nodeName === "option" ) {
6072                  dest.selected = src.defaultSelected;
6073  
6074          // IE6-8 fails to set the defaultValue to the correct value when
6075          // cloning other types of input fields
6076          } else if ( nodeName === "input" || nodeName === "textarea" ) {
6077                  dest.defaultValue = src.defaultValue;
6078          }
6079  
6080          // Event data gets referenced instead of copied if the expando
6081          // gets copied too
6082          dest.removeAttribute( jQuery.expando );
6083  }
6084  
6085  jQuery.buildFragment = function( args, nodes, scripts ) {
6086          var fragment, cacheable, cacheresults, doc,
6087          first = args[ 0 ];
6088  
6089          // nodes may contain either an explicit document object,
6090          // a jQuery collection or context object.
6091          // If nodes[0] contains a valid object to assign to doc
6092          if ( nodes && nodes[0] ) {
6093                  doc = nodes[0].ownerDocument || nodes[0];
6094          }
6095  
6096          // Ensure that an attr object doesn't incorrectly stand in as a document object
6097          // Chrome and Firefox seem to allow this to occur and will throw exception
6098          // Fixes #8950
6099          if ( !doc.createDocumentFragment ) {
6100                  doc = document;
6101          }
6102  
6103          // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
6104          // Cloning options loses the selected state, so don't cache them
6105          // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
6106          // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
6107          // Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
6108          if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
6109                  first.charAt(0) === "<" && !rnocache.test( first ) &&
6110                  (jQuery.support.checkClone || !rchecked.test( first )) &&
6111                  (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
6112  
6113                  cacheable = true;
6114  
6115                  cacheresults = jQuery.fragments[ first ];
6116                  if ( cacheresults && cacheresults !== 1 ) {
6117                          fragment = cacheresults;
6118                  }
6119          }
6120  
6121          if ( !fragment ) {
6122                  fragment = doc.createDocumentFragment();
6123                  jQuery.clean( args, doc, fragment, scripts );
6124          }
6125  
6126          if ( cacheable ) {
6127                  jQuery.fragments[ first ] = cacheresults ? fragment : 1;
6128          }
6129  
6130          return { fragment: fragment, cacheable: cacheable };
6131  };
6132  
6133  jQuery.fragments = {};
6134  
6135  jQuery.each({
6136          appendTo: "append",
6137          prependTo: "prepend",
6138          insertBefore: "before",
6139          insertAfter: "after",
6140          replaceAll: "replaceWith"
6141  }, function( name, original ) {
6142          jQuery.fn[ name ] = function( selector ) {
6143                  var ret = [],
6144                          insert = jQuery( selector ),
6145                          parent = this.length === 1 && this[0].parentNode;
6146  
6147                  if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
6148                          insert[ original ]( this[0] );
6149                          return this;
6150  
6151                  } else {
6152                          for ( var i = 0, l = insert.length; i < l; i++ ) {
6153                                  var elems = ( i > 0 ? this.clone(true) : this ).get();
6154                                  jQuery( insert[i] )[ original ]( elems );
6155                                  ret = ret.concat( elems );
6156                          }
6157  
6158                          return this.pushStack( ret, name, insert.selector );
6159                  }
6160          };
6161  });
6162  
6163  function getAll( elem ) {
6164          if ( typeof elem.getElementsByTagName !== "undefined" ) {
6165                  return elem.getElementsByTagName( "*" );
6166  
6167          } else if ( typeof elem.querySelectorAll !== "undefined" ) {
6168                  return elem.querySelectorAll( "*" );
6169  
6170          } else {
6171                  return [];
6172          }
6173  }
6174  
6175  // Used in clean, fixes the defaultChecked property
6176  function fixDefaultChecked( elem ) {
6177          if ( elem.type === "checkbox" || elem.type === "radio" ) {
6178                  elem.defaultChecked = elem.checked;
6179          }
6180  }
6181  // Finds all inputs and passes them to fixDefaultChecked
6182  function findInputs( elem ) {
6183          var nodeName = ( elem.nodeName || "" ).toLowerCase();
6184          if ( nodeName === "input" ) {
6185                  fixDefaultChecked( elem );
6186          // Skip scripts, get other children
6187          } else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) {
6188                  jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
6189          }
6190  }
6191  
6192  // Derived From: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js
6193  function shimCloneNode( elem ) {
6194          var div = document.createElement( "div" );
6195          safeFragment.appendChild( div );
6196  
6197          div.innerHTML = elem.outerHTML;
6198          return div.firstChild;
6199  }
6200  
6201  jQuery.extend({
6202          clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6203                  var srcElements,
6204                          destElements,
6205                          i,
6206                          // IE<=8 does not properly clone detached, unknown element nodes
6207                          clone = jQuery.support.html5Clone || !rnoshimcache.test( "<" + elem.nodeName ) ?
6208                                  elem.cloneNode( true ) :
6209                                  shimCloneNode( elem );
6210  
6211                  if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
6212                                  (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6213                          // IE copies events bound via attachEvent when using cloneNode.
6214                          // Calling detachEvent on the clone will also remove the events
6215                          // from the original. In order to get around this, we use some
6216                          // proprietary methods to clear the events. Thanks to MooTools
6217                          // guys for this hotness.
6218  
6219                          cloneFixAttributes( elem, clone );
6220  
6221                          // Using Sizzle here is crazy slow, so we use getElementsByTagName instead
6222                          srcElements = getAll( elem );
6223                          destElements = getAll( clone );
6224  
6225                          // Weird iteration because IE will replace the length property
6226                          // with an element if you are cloning the body and one of the
6227                          // elements on the page has a name or id of "length"
6228                          for ( i = 0; srcElements[i]; ++i ) {
6229                                  // Ensure that the destination node is not null; Fixes #9587
6230                                  if ( destElements[i] ) {
6231                                          cloneFixAttributes( srcElements[i], destElements[i] );
6232                                  }
6233                          }
6234                  }
6235  
6236                  // Copy the events from the original to the clone
6237                  if ( dataAndEvents ) {
6238                          cloneCopyEvent( elem, clone );
6239  
6240                          if ( deepDataAndEvents ) {
6241                                  srcElements = getAll( elem );
6242                                  destElements = getAll( clone );
6243  
6244                                  for ( i = 0; srcElements[i]; ++i ) {
6245                                          cloneCopyEvent( srcElements[i], destElements[i] );
6246                                  }
6247                          }
6248                  }
6249  
6250                  srcElements = destElements = null;
6251  
6252                  // Return the cloned set
6253                  return clone;
6254          },
6255  
6256          clean: function( elems, context, fragment, scripts ) {
6257                  var checkScriptType;
6258  
6259                  context = context || document;
6260  
6261                  // !context.createElement fails in IE with an error but returns typeof 'object'
6262                  if ( typeof context.createElement === "undefined" ) {
6263                          context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
6264                  }
6265  
6266                  var ret = [], j;
6267  
6268                  for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6269                          if ( typeof elem === "number" ) {
6270                                  elem += "";
6271                          }
6272  
6273                          if ( !elem ) {
6274                                  continue;
6275                          }
6276  
6277                          // Convert html string into DOM nodes
6278                          if ( typeof elem === "string" ) {
6279                                  if ( !rhtml.test( elem ) ) {
6280                                          elem = context.createTextNode( elem );
6281                                  } else {
6282                                          // Fix "XHTML"-style tags in all browsers
6283                                          elem = elem.replace(rxhtmlTag, "<$1></$2>");
6284  
6285                                          // Trim whitespace, otherwise indexOf won't work as expected
6286                                          var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),
6287                                                  wrap = wrapMap[ tag ] || wrapMap._default,
6288                                                  depth = wrap[0],
6289                                                  div = context.createElement("div");
6290  
6291                                          // Append wrapper element to unknown element safe doc fragment
6292                                          if ( context === document ) {
6293                                                  // Use the fragment we've already created for this document
6294                                                  safeFragment.appendChild( div );
6295                                          } else {
6296                                                  // Use a fragment created with the owner document
6297                                                  createSafeFragment( context ).appendChild( div );
6298                                          }
6299  
6300                                          // Go to html and back, then peel off extra wrappers
6301                                          div.innerHTML = wrap[1] + elem + wrap[2];
6302  
6303                                          // Move to the right depth
6304                                          while ( depth-- ) {
6305                                                  div = div.lastChild;
6306                                          }
6307  
6308                                          // Remove IE's autoinserted <tbody> from table fragments
6309                                          if ( !jQuery.support.tbody ) {
6310  
6311                                                  // String was a <table>, *may* have spurious <tbody>
6312                                                  var hasBody = rtbody.test(elem),
6313                                                          tbody = tag === "table" && !hasBody ?
6314                                                                  div.firstChild && div.firstChild.childNodes :
6315  
6316                                                                  // String was a bare <thead> or <tfoot>
6317                                                                  wrap[1] === "<table>" && !hasBody ?
6318                                                                          div.childNodes :
6319                                                                          [];
6320  
6321                                                  for ( j = tbody.length - 1; j >= 0 ; --j ) {
6322                                                          if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6323                                                                  tbody[ j ].parentNode.removeChild( tbody[ j ] );
6324                                                          }
6325                                                  }
6326                                          }
6327  
6328                                          // IE completely kills leading whitespace when innerHTML is used
6329                                          if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6330                                                  div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6331                                          }
6332  
6333                                          elem = div.childNodes;
6334                                  }
6335                          }
6336  
6337                          // Resets defaultChecked for any radios and checkboxes
6338                          // about to be appended to the DOM in IE 6/7 (#8060)
6339                          var len;
6340                          if ( !jQuery.support.appendChecked ) {
6341                                  if ( elem[0] && typeof (len = elem.length) === "number" ) {
6342                                          for ( j = 0; j < len; j++ ) {
6343                                                  findInputs( elem[j] );
6344                                          }
6345                                  } else {
6346                                          findInputs( elem );
6347                                  }
6348                          }
6349  
6350                          if ( elem.nodeType ) {
6351                                  ret.push( elem );
6352                          } else {
6353                                  ret = jQuery.merge( ret, elem );
6354                          }
6355                  }
6356  
6357                  if ( fragment ) {
6358                          checkScriptType = function( elem ) {
6359                                  return !elem.type || rscriptType.test( elem.type );
6360                          };
6361                          for ( i = 0; ret[i]; i++ ) {
6362                                  if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
6363                                          scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6364  
6365                                  } else {
6366                                          if ( ret[i].nodeType === 1 ) {
6367                                                  var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6368  
6369                                                  ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6370                                          }
6371                                          fragment.appendChild( ret[i] );
6372                                  }
6373                          }
6374                  }
6375  
6376                  return ret;
6377          },
6378  
6379          cleanData: function( elems ) {
6380                  var data, id,
6381                          cache = jQuery.cache,
6382                          special = jQuery.event.special,
6383                          deleteExpando = jQuery.support.deleteExpando;
6384  
6385                  for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6386                          if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6387                                  continue;
6388                          }
6389  
6390                          id = elem[ jQuery.expando ];
6391  
6392                          if ( id ) {
6393                                  data = cache[ id ];
6394  
6395                                  if ( data && data.events ) {
6396                                          for ( var type in data.events ) {
6397                                                  if ( special[ type ] ) {
6398                                                          jQuery.event.remove( elem, type );
6399  
6400                                                  // This is a shortcut to avoid jQuery.event.remove's overhead
6401                                                  } else {
6402                                                          jQuery.removeEvent( elem, type, data.handle );
6403                                                  }
6404                                          }
6405  
6406                                          // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6407                                          if ( data.handle ) {
6408                                                  data.handle.elem = null;
6409                                          }
6410                                  }
6411  
6412                                  if ( deleteExpando ) {
6413                                          delete elem[ jQuery.expando ];
6414  
6415                                  } else if ( elem.removeAttribute ) {
6416                                          elem.removeAttribute( jQuery.expando );
6417                                  }
6418  
6419                                  delete cache[ id ];
6420                          }
6421                  }
6422          }
6423  });
6424  
6425  function evalScript( i, elem ) {
6426          if ( elem.src ) {
6427                  jQuery.ajax({
6428                          url: elem.src,
6429                          async: false,
6430                          dataType: "script"
6431                  });
6432          } else {
6433                  jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
6434          }
6435  
6436          if ( elem.parentNode ) {
6437                  elem.parentNode.removeChild( elem );
6438          }
6439  }
6440  
6441  
6442  
6443  
6444  var ralpha = /alpha\([^)]*\)/i,
6445          ropacity = /opacity=([^)]*)/,
6446          // fixed for IE9, see #8346
6447          rupper = /([A-Z]|^ms)/g,
6448          rnumpx = /^-?\d+(?:px)?$/i,
6449          rnum = /^-?\d/,
6450          rrelNum = /^([\-+])=([\-+.\de]+)/,
6451  
6452          cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6453          cssWidth = [ "Left", "Right" ],
6454          cssHeight = [ "Top", "Bottom" ],
6455          curCSS,
6456  
6457          getComputedStyle,
6458          currentStyle;
6459  
6460  jQuery.fn.css = function( name, value ) {
6461          // Setting 'undefined' is a no-op
6462          if ( arguments.length === 2 && value === undefined ) {
6463                  return this;
6464          }
6465  
6466          return jQuery.access( this, name, value, true, function( elem, name, value ) {
6467                  return value !== undefined ?
6468                          jQuery.style( elem, name, value ) :
6469                          jQuery.css( elem, name );
6470          });
6471  };
6472  
6473  jQuery.extend({
6474          // Add in style property hooks for overriding the default
6475          // behavior of getting and setting a style property
6476          cssHooks: {
6477                  opacity: {
6478                          get: function( elem, computed ) {
6479                                  if ( computed ) {
6480                                          // We should always get a number back from opacity
6481                                          var ret = curCSS( elem, "opacity", "opacity" );
6482                                          return ret === "" ? "1" : ret;
6483  
6484                                  } else {
6485                                          return elem.style.opacity;
6486                                  }
6487                          }
6488                  }
6489          },
6490  
6491          // Exclude the following css properties to add px
6492          cssNumber: {
6493                  "fillOpacity": true,
6494                  "fontWeight": true,
6495                  "lineHeight": true,
6496                  "opacity": true,
6497                  "orphans": true,
6498                  "widows": true,
6499                  "zIndex": true,
6500                  "zoom": true
6501          },
6502  
6503          // Add in properties whose names you wish to fix before
6504          // setting or getting the value
6505          cssProps: {
6506                  // normalize float css property
6507                  "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6508          },
6509  
6510          // Get and set the style property on a DOM Node
6511          style: function( elem, name, value, extra ) {
6512                  // Don't set styles on text and comment nodes
6513                  if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6514                          return;
6515                  }
6516  
6517                  // Make sure that we're working with the right name
6518                  var ret, type, origName = jQuery.camelCase( name ),
6519                          style = elem.style, hooks = jQuery.cssHooks[ origName ];
6520  
6521                  name = jQuery.cssProps[ origName ] || origName;
6522  
6523                  // Check if we're setting a value
6524                  if ( value !== undefined ) {
6525                          type = typeof value;
6526  
6527                          // convert relative number strings (+= or -=) to relative numbers. #7345
6528                          if ( type === "string" && (ret = rrelNum.exec( value )) ) {
6529                                  value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
6530                                  // Fixes bug #9237
6531                                  type = "number";
6532                          }
6533  
6534                          // Make sure that NaN and null values aren't set. See: #7116
6535                          if ( value == null || type === "number" && isNaN( value ) ) {
6536                                  return;
6537                          }
6538  
6539                          // If a number was passed in, add 'px' to the (except for certain CSS properties)
6540                          if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6541                                  value += "px";
6542                          }
6543  
6544                          // If a hook was provided, use that value, otherwise just set the specified value
6545                          if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
6546                                  // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6547                                  // Fixes bug #5509
6548                                  try {
6549                                          style[ name ] = value;
6550                                  } catch(e) {}
6551                          }
6552  
6553                  } else {
6554                          // If a hook was provided get the non-computed value from there
6555                          if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6556                                  return ret;
6557                          }
6558  
6559                          // Otherwise just get the value from the style object
6560                          return style[ name ];
6561                  }
6562          },
6563  
6564          css: function( elem, name, extra ) {
6565                  var ret, hooks;
6566  
6567                  // Make sure that we're working with the right name
6568                  name = jQuery.camelCase( name );
6569                  hooks = jQuery.cssHooks[ name ];
6570                  name = jQuery.cssProps[ name ] || name;
6571  
6572                  // cssFloat needs a special treatment
6573                  if ( name === "cssFloat" ) {
6574                          name = "float";
6575                  }
6576  
6577                  // If a hook was provided get the computed value from there
6578                  if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6579                          return ret;
6580  
6581                  // Otherwise, if a way to get the computed value exists, use that
6582                  } else if ( curCSS ) {
6583                          return curCSS( elem, name );
6584                  }
6585          },
6586  
6587          // A method for quickly swapping in/out CSS properties to get correct calculations
6588          swap: function( elem, options, callback ) {
6589                  var old = {};
6590  
6591                  // Remember the old values, and insert the new ones
6592                  for ( var name in options ) {
6593                          old[ name ] = elem.style[ name ];
6594                          elem.style[ name ] = options[ name ];
6595                  }
6596  
6597                  callback.call( elem );
6598  
6599                  // Revert the old values
6600                  for ( name in options ) {
6601                          elem.style[ name ] = old[ name ];
6602                  }
6603          }
6604  });
6605  
6606  // DEPRECATED, Use jQuery.css() instead
6607  jQuery.curCSS = jQuery.css;
6608  
6609  jQuery.each(["height", "width"], function( i, name ) {
6610          jQuery.cssHooks[ name ] = {
6611                  get: function( elem, computed, extra ) {
6612                          var val;
6613  
6614                          if ( computed ) {
6615                                  if ( elem.offsetWidth !== 0 ) {
6616                                          return getWH( elem, name, extra );
6617                                  } else {
6618                                          jQuery.swap( elem, cssShow, function() {
6619                                                  val = getWH( elem, name, extra );
6620                                          });
6621                                  }
6622  
6623                                  return val;
6624                          }
6625                  },
6626  
6627                  set: function( elem, value ) {
6628                          if ( rnumpx.test( value ) ) {
6629                                  // ignore negative width and height values #1599
6630                                  value = parseFloat( value );
6631  
6632                                  if ( value >= 0 ) {
6633                                          return value + "px";
6634                                  }
6635  
6636                          } else {
6637                                  return value;
6638                          }
6639                  }
6640          };
6641  });
6642  
6643  if ( !jQuery.support.opacity ) {
6644          jQuery.cssHooks.opacity = {
6645                  get: function( elem, computed ) {
6646                          // IE uses filters for opacity
6647                          return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
6648                                  ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6649                                  computed ? "1" : "";
6650                  },
6651  
6652                  set: function( elem, value ) {
6653                          var style = elem.style,
6654                                  currentStyle = elem.currentStyle,
6655                                  opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
6656                                  filter = currentStyle && currentStyle.filter || style.filter || "";
6657  
6658                          // IE has trouble with opacity if it does not have layout
6659                          // Force it by setting the zoom level
6660                          style.zoom = 1;
6661  
6662                          // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
6663                          if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
6664  
6665                                  // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
6666                                  // if "filter:" is present at all, clearType is disabled, we want to avoid this
6667                                  // style.removeAttribute is IE Only, but so apparently is this code path...
6668                                  style.removeAttribute( "filter" );
6669  
6670                                  // if there there is no filter style applied in a css rule, we are done
6671                                  if ( currentStyle && !currentStyle.filter ) {
6672                                          return;
6673                                  }
6674                          }
6675  
6676                          // otherwise, set new filter values
6677                          style.filter = ralpha.test( filter ) ?
6678                                  filter.replace( ralpha, opacity ) :
6679                                  filter + " " + opacity;
6680                  }
6681          };
6682  }
6683  
6684  jQuery(function() {
6685          // This hook cannot be added until DOM ready because the support test
6686          // for it is not run until after DOM ready
6687          if ( !jQuery.support.reliableMarginRight ) {
6688                  jQuery.cssHooks.marginRight = {
6689                          get: function( elem, computed ) {
6690                                  // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6691                                  // Work around by temporarily setting element display to inline-block
6692                                  var ret;
6693                                  jQuery.swap( elem, { "display": "inline-block" }, function() {
6694                                          if ( computed ) {
6695                                                  ret = curCSS( elem, "margin-right", "marginRight" );
6696                                          } else {
6697                                                  ret = elem.style.marginRight;
6698                                          }
6699                                  });
6700                                  return ret;
6701                          }
6702                  };
6703          }
6704  });
6705  
6706  if ( document.defaultView && document.defaultView.getComputedStyle ) {
6707          getComputedStyle = function( elem, name ) {
6708                  var ret, defaultView, computedStyle;
6709  
6710                  name = name.replace( rupper, "-$1" ).toLowerCase();
6711  
6712                  if ( (defaultView = elem.ownerDocument.defaultView) &&
6713                                  (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6714                          ret = computedStyle.getPropertyValue( name );
6715                          if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6716                                  ret = jQuery.style( elem, name );
6717                          }
6718                  }
6719  
6720                  return ret;
6721          };
6722  }
6723  
6724  if ( document.documentElement.currentStyle ) {
6725          currentStyle = function( elem, name ) {
6726                  var left, rsLeft, uncomputed,
6727                          ret = elem.currentStyle && elem.currentStyle[ name ],
6728                          style = elem.style;
6729  
6730                  // Avoid setting ret to empty string here
6731                  // so we don't default to auto
6732                  if ( ret === null && style && (uncomputed = style[ name ]) ) {
6733                          ret = uncomputed;
6734                  }
6735  
6736                  // From the awesome hack by Dean Edwards
6737                  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6738  
6739                  // If we're not dealing with a regular pixel number
6740                  // but a number that has a weird ending, we need to convert it to pixels
6741                  if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6742  
6743                          // Remember the original values
6744                          left = style.left;
6745                          rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
6746  
6747                          // Put in the new values to get a computed value out
6748                          if ( rsLeft ) {
6749                                  elem.runtimeStyle.left = elem.currentStyle.left;
6750                          }
6751                          style.left = name === "fontSize" ? "1em" : ( ret || 0 );
6752                          ret = style.pixelLeft + "px";
6753  
6754                          // Revert the changed values
6755                          style.left = left;
6756                          if ( rsLeft ) {
6757                                  elem.runtimeStyle.left = rsLeft;
6758                          }
6759                  }
6760  
6761                  return ret === "" ? "auto" : ret;
6762          };
6763  }
6764  
6765  curCSS = getComputedStyle || currentStyle;
6766  
6767  function getWH( elem, name, extra ) {
6768  
6769          // Start with offset property
6770          var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6771                  which = name === "width" ? cssWidth : cssHeight,
6772                  i = 0,
6773                  len = which.length;
6774  
6775          if ( val > 0 ) {
6776                  if ( extra !== "border" ) {
6777                          for ( ; i < len; i++ ) {
6778                                  if ( !extra ) {
6779                                          val -= parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6780                                  }
6781                                  if ( extra === "margin" ) {
6782                                          val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6783                                  } else {
6784                                          val -= parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6785                                  }
6786                          }
6787                  }
6788  
6789                  return val + "px";
6790          }
6791  
6792          // Fall back to computed then uncomputed css if necessary
6793          val = curCSS( elem, name, name );
6794          if ( val < 0 || val == null ) {
6795                  val = elem.style[ name ] || 0;
6796          }
6797          // Normalize "", auto, and prepare for extra
6798          val = parseFloat( val ) || 0;
6799  
6800          // Add padding, border, margin
6801          if ( extra ) {
6802                  for ( ; i < len; i++ ) {
6803                          val += parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6804                          if ( extra !== "padding" ) {
6805                                  val += parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6806                          }
6807                          if ( extra === "margin" ) {
6808                                  val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6809                          }
6810                  }
6811          }
6812  
6813          return val + "px";
6814  }
6815  
6816  if ( jQuery.expr && jQuery.expr.filters ) {
6817          jQuery.expr.filters.hidden = function( elem ) {
6818                  var width = elem.offsetWidth,
6819                          height = elem.offsetHeight;
6820  
6821                  return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
6822          };
6823  
6824          jQuery.expr.filters.visible = function( elem ) {
6825                  return !jQuery.expr.filters.hidden( elem );
6826          };
6827  }
6828  
6829  
6830  
6831  
6832  var r20 = /%20/g,
6833          rbracket = /\[\]$/,
6834          rCRLF = /\r?\n/g,
6835          rhash = /#.*$/,
6836          rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6837          rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
6838          // #7653, #8125, #8152: local protocol detection
6839          rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
6840          rnoContent = /^(?:GET|HEAD)$/,
6841          rprotocol = /^\/\//,
6842          rquery = /\?/,
6843          rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
6844          rselectTextarea = /^(?:select|textarea)/i,
6845          rspacesAjax = /\s+/,
6846          rts = /([?&])_=[^&]*/,
6847          rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6848  
6849          // Keep a copy of the old load method
6850          _load = jQuery.fn.load,
6851  
6852          /* Prefilters
6853           * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6854           * 2) These are called:
6855           *    - BEFORE asking for a transport
6856           *    - AFTER param serialization (s.data is a string if s.processData is true)
6857           * 3) key is the dataType
6858           * 4) the catchall symbol "*" can be used
6859           * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6860           */
6861          prefilters = {},
6862  
6863          /* Transports bindings
6864           * 1) key is the dataType
6865           * 2) the catchall symbol "*" can be used
6866           * 3) selection will start with transport dataType and THEN go to "*" if needed
6867           */
6868          transports = {},
6869  
6870          // Document location
6871          ajaxLocation,
6872  
6873          // Document location segments
6874          ajaxLocParts,
6875  
6876          // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
6877          allTypes = ["*/"] + ["*"];
6878  
6879  // #8138, IE may throw an exception when accessing
6880  // a field from window.location if document.domain has been set
6881  try {
6882          ajaxLocation = location.href;
6883  } catch( e ) {
6884          // Use the href attribute of an A element
6885          // since IE will modify it given document.location
6886          ajaxLocation = document.createElement( "a" );
6887          ajaxLocation.href = "";
6888          ajaxLocation = ajaxLocation.href;
6889  }
6890  
6891  // Segment location into parts
6892  ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
6893  
6894  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6895  function addToPrefiltersOrTransports( structure ) {
6896  
6897          // dataTypeExpression is optional and defaults to "*"
6898          return function( dataTypeExpression, func ) {
6899  
6900                  if ( typeof dataTypeExpression !== "string" ) {
6901                          func = dataTypeExpression;
6902                          dataTypeExpression = "*";
6903                  }
6904  
6905                  if ( jQuery.isFunction( func ) ) {
6906                          var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6907                                  i = 0,
6908                                  length = dataTypes.length,
6909                                  dataType,
6910                                  list,
6911                                  placeBefore;
6912  
6913                          // For each dataType in the dataTypeExpression
6914                          for ( ; i < length; i++ ) {
6915                                  dataType = dataTypes[ i ];
6916                                  // We control if we're asked to add before
6917                                  // any existing element
6918                                  placeBefore = /^\+/.test( dataType );
6919                                  if ( placeBefore ) {
6920                                          dataType = dataType.substr( 1 ) || "*";
6921                                  }
6922                                  list = structure[ dataType ] = structure[ dataType ] || [];
6923                                  // then we add to the structure accordingly
6924                                  list[ placeBefore ? "unshift" : "push" ]( func );
6925                          }
6926                  }
6927          };
6928  }
6929  
6930  // Base inspection function for prefilters and transports
6931  function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6932                  dataType /* internal */, inspected /* internal */ ) {
6933  
6934          dataType = dataType || options.dataTypes[ 0 ];
6935          inspected = inspected || {};
6936  
6937          inspected[ dataType ] = true;
6938  
6939          var list = structure[ dataType ],
6940                  i = 0,
6941                  length = list ? list.length : 0,
6942                  executeOnly = ( structure === prefilters ),
6943                  selection;
6944  
6945          for ( ; i < length && ( executeOnly || !selection ); i++ ) {
6946                  selection = list[ i ]( options, originalOptions, jqXHR );
6947                  // If we got redirected to another dataType
6948                  // we try there if executing only and not done already
6949                  if ( typeof selection === "string" ) {
6950                          if ( !executeOnly || inspected[ selection ] ) {
6951                                  selection = undefined;
6952                          } else {
6953                                  options.dataTypes.unshift( selection );
6954                                  selection = inspectPrefiltersOrTransports(
6955                                                  structure, options, originalOptions, jqXHR, selection, inspected );
6956                          }
6957                  }
6958          }
6959          // If we're only executing or nothing was selected
6960          // we try the catchall dataType if not done already
6961          if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
6962                  selection = inspectPrefiltersOrTransports(
6963                                  structure, options, originalOptions, jqXHR, "*", inspected );
6964          }
6965          // unnecessary when only executing (prefilters)
6966          // but it'll be ignored by the caller in that case
6967          return selection;
6968  }
6969  
6970  // A special extend for ajax options
6971  // that takes "flat" options (not to be deep extended)
6972  // Fixes #9887
6973  function ajaxExtend( target, src ) {
6974          var key, deep,
6975                  flatOptions = jQuery.ajaxSettings.flatOptions || {};
6976          for ( key in src ) {
6977                  if ( src[ key ] !== undefined ) {
6978                          ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
6979                  }
6980          }
6981          if ( deep ) {
6982                  jQuery.extend( true, target, deep );
6983          }
6984  }
6985  
6986  jQuery.fn.extend({
6987          load: function( url, params, callback ) {
6988                  if ( typeof url !== "string" && _load ) {
6989                          return _load.apply( this, arguments );
6990  
6991                  // Don't do a request if no elements are being requested
6992                  } else if ( !this.length ) {
6993                          return this;
6994                  }
6995  
6996                  var off = url.indexOf( " " );
6997                  if ( off >= 0 ) {
6998                          var selector = url.slice( off, url.length );
6999                          url = url.slice( 0, off );
7000                  }
7001  
7002                  // Default to a GET request
7003                  var type = "GET";
7004  
7005                  // If the second parameter was provided
7006                  if ( params ) {
7007                          // If it's a function
7008                          if ( jQuery.isFunction( params ) ) {
7009                                  // We assume that it's the callback
7010                                  callback = params;
7011                                  params = undefined;
7012  
7013                          // Otherwise, build a param string
7014                          } else if ( typeof params === "object" ) {
7015                                  params = jQuery.param( params, jQuery.ajaxSettings.traditional );
7016                                  type = "POST";
7017                          }
7018                  }
7019  
7020                  var self = this;
7021  
7022                  // Request the remote document
7023                  jQuery.ajax({
7024                          url: url,
7025                          type: type,
7026                          dataType: "html",
7027                          data: params,
7028                          // Complete callback (responseText is used internally)
7029                          complete: function( jqXHR, status, responseText ) {
7030                                  // Store the response as specified by the jqXHR object
7031                                  responseText = jqXHR.responseText;
7032                                  // If successful, inject the HTML into all the matched elements
7033                                  if ( jqXHR.isResolved() ) {
7034                                          // #4825: Get the actual response in case
7035                                          // a dataFilter is present in ajaxSettings
7036                                          jqXHR.done(function( r ) {
7037                                                  responseText = r;
7038                                          });
7039                                          // See if a selector was specified
7040                                          self.html( selector ?
7041                                                  // Create a dummy div to hold the results
7042                                                  jQuery("<div>")
7043                                                          // inject the contents of the document in, removing the scripts
7044                                                          // to avoid any 'Permission Denied' errors in IE
7045                                                          .append(responseText.replace(rscript, ""))
7046  
7047                                                          // Locate the specified elements
7048                                                          .find(selector) :
7049  
7050                                                  // If not, just inject the full result
7051                                                  responseText );
7052                                  }
7053  
7054                                  if ( callback ) {
7055                                          self.each( callback, [ responseText, status, jqXHR ] );
7056                                  }
7057                          }
7058                  });
7059  
7060                  return this;
7061          },
7062  
7063          serialize: function() {
7064                  return jQuery.param( this.serializeArray() );
7065          },
7066  
7067          serializeArray: function() {
7068                  return this.map(function(){
7069                          return this.elements ? jQuery.makeArray( this.elements ) : this;
7070                  })
7071                  .filter(function(){
7072                          return this.name && !this.disabled &&
7073                                  ( this.checked || rselectTextarea.test( this.nodeName ) ||
7074                                          rinput.test( this.type ) );
7075                  })
7076                  .map(function( i, elem ){
7077                          var val = jQuery( this ).val();
7078  
7079                          return val == null ?
7080                                  null :
7081                                  jQuery.isArray( val ) ?
7082                                          jQuery.map( val, function( val, i ){
7083                                                  return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
7084                                          }) :
7085                                          { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
7086                  }).get();
7087          }
7088  });
7089  
7090  // Attach a bunch of functions for handling common AJAX events
7091  jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
7092          jQuery.fn[ o ] = function( f ){
7093                  return this.on( o, f );
7094          };
7095  });
7096  
7097  jQuery.each( [ "get", "post" ], function( i, method ) {
7098          jQuery[ method ] = function( url, data, callback, type ) {
7099                  // shift arguments if data argument was omitted
7100                  if ( jQuery.isFunction( data ) ) {
7101                          type = type || callback;
7102                          callback = data;
7103                          data = undefined;
7104                  }
7105  
7106                  return jQuery.ajax({
7107                          type: method,
7108                          url: url,
7109                          data: data,
7110                          success: callback,
7111                          dataType: type
7112                  });
7113          };
7114  });
7115  
7116  jQuery.extend({
7117  
7118          getScript: function( url, callback ) {
7119                  return jQuery.get( url, undefined, callback, "script" );
7120          },
7121  
7122          getJSON: function( url, data, callback ) {
7123                  return jQuery.get( url, data, callback, "json" );
7124          },
7125  
7126          // Creates a full fledged settings object into target
7127          // with both ajaxSettings and settings fields.
7128          // If target is omitted, writes into ajaxSettings.
7129          ajaxSetup: function( target, settings ) {
7130                  if ( settings ) {
7131                          // Building a settings object
7132                          ajaxExtend( target, jQuery.ajaxSettings );
7133                  } else {
7134                          // Extending ajaxSettings
7135                          settings = target;
7136                          target = jQuery.ajaxSettings;
7137                  }
7138                  ajaxExtend( target, settings );
7139                  return target;
7140          },
7141  
7142          ajaxSettings: {
7143                  url: ajaxLocation,
7144                  isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
7145                  global: true,
7146                  type: "GET",
7147                  contentType: "application/x-www-form-urlencoded",
7148                  processData: true,
7149                  async: true,
7150                  /*
7151                  timeout: 0,
7152                  data: null,
7153                  dataType: null,
7154                  username: null,
7155                  password: null,
7156                  cache: null,
7157                  traditional: false,
7158                  headers: {},
7159                  */
7160  
7161                  accepts: {
7162                          xml: "application/xml, text/xml",
7163                          html: "text/html",
7164                          text: "text/plain",
7165                          json: "application/json, text/javascript",
7166                          "*": allTypes
7167                  },
7168  
7169                  contents: {
7170                          xml: /xml/,
7171                          html: /html/,
7172                          json: /json/
7173                  },
7174  
7175                  responseFields: {
7176                          xml: "responseXML",
7177                          text: "responseText"
7178                  },
7179  
7180                  // List of data converters
7181                  // 1) key format is "source_type destination_type" (a single space in-between)
7182                  // 2) the catchall symbol "*" can be used for source_type
7183                  converters: {
7184  
7185                          // Convert anything to text
7186                          "* text": window.String,
7187  
7188                          // Text to html (true = no transformation)
7189                          "text html": true,
7190  
7191                          // Evaluate text as a json expression
7192                          "text json": jQuery.parseJSON,
7193  
7194                          // Parse text as xml
7195                          "text xml": jQuery.parseXML
7196                  },
7197  
7198                  // For options that shouldn't be deep extended:
7199                  // you can add your own custom options here if
7200                  // and when you create one that shouldn't be
7201                  // deep extended (see ajaxExtend)
7202                  flatOptions: {
7203                          context: true,
7204                          url: true
7205                  }
7206          },
7207  
7208          ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
7209          ajaxTransport: addToPrefiltersOrTransports( transports ),
7210  
7211          // Main method
7212          ajax: function( url, options ) {
7213  
7214                  // If url is an object, simulate pre-1.5 signature
7215                  if ( typeof url === "object" ) {
7216                          options = url;
7217                          url = undefined;
7218                  }
7219  
7220                  // Force options to be an object
7221                  options = options || {};
7222  
7223                  var // Create the final options object
7224                          s = jQuery.ajaxSetup( {}, options ),
7225                          // Callbacks context
7226                          callbackContext = s.context || s,
7227                          // Context for global events
7228                          // It's the callbackContext if one was provided in the options
7229                          // and if it's a DOM node or a jQuery collection
7230                          globalEventContext = callbackContext !== s &&
7231                                  ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
7232                                                  jQuery( callbackContext ) : jQuery.event,
7233                          // Deferreds
7234                          deferred = jQuery.Deferred(),
7235                          completeDeferred = jQuery.Callbacks( "once memory" ),
7236                          // Status-dependent callbacks
7237                          statusCode = s.statusCode || {},
7238                          // ifModified key
7239                          ifModifiedKey,
7240                          // Headers (they are sent all at once)
7241                          requestHeaders = {},
7242                          requestHeadersNames = {},
7243                          // Response headers
7244                          responseHeadersString,
7245                          responseHeaders,
7246                          // transport
7247                          transport,
7248                          // timeout handle
7249                          timeoutTimer,
7250                          // Cross-domain detection vars
7251                          parts,
7252                          // The jqXHR state
7253                          state = 0,
7254                          // To know if global events are to be dispatched
7255                          fireGlobals,
7256                          // Loop variable
7257                          i,
7258                          // Fake xhr
7259                          jqXHR = {
7260  
7261                                  readyState: 0,
7262  
7263                                  // Caches the header
7264                                  setRequestHeader: function( name, value ) {
7265                                          if ( !state ) {
7266                                                  var lname = name.toLowerCase();
7267                                                  name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
7268                                                  requestHeaders[ name ] = value;
7269                                          }
7270                                          return this;
7271                                  },
7272  
7273                                  // Raw string
7274                                  getAllResponseHeaders: function() {
7275                                          return state === 2 ? responseHeadersString : null;
7276                                  },
7277  
7278                                  // Builds headers hashtable if needed
7279                                  getResponseHeader: function( key ) {
7280                                          var match;
7281                                          if ( state === 2 ) {
7282                                                  if ( !responseHeaders ) {
7283                                                          responseHeaders = {};
7284                                                          while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7285                                                                  responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7286                                                          }
7287                                                  }
7288                                                  match = responseHeaders[ key.toLowerCase() ];
7289                                          }
7290                                          return match === undefined ? null : match;
7291                                  },
7292  
7293                                  // Overrides response content-type header
7294                                  overrideMimeType: function( type ) {
7295                                          if ( !state ) {
7296                                                  s.mimeType = type;
7297                                          }
7298                                          return this;
7299                                  },
7300  
7301                                  // Cancel the request
7302                                  abort: function( statusText ) {
7303                                          statusText = statusText || "abort";
7304                                          if ( transport ) {
7305                                                  transport.abort( statusText );
7306                                          }
7307                                          done( 0, statusText );
7308                                          return this;
7309                                  }
7310                          };
7311  
7312                  // Callback for when everything is done
7313                  // It is defined here because jslint complains if it is declared
7314                  // at the end of the function (which would be more logical and readable)
7315                  function done( status, nativeStatusText, responses, headers ) {
7316  
7317                          // Called once
7318                          if ( state === 2 ) {
7319                                  return;
7320                          }
7321  
7322                          // State is "done" now
7323                          state = 2;
7324  
7325                          // Clear timeout if it exists
7326                          if ( timeoutTimer ) {
7327                                  clearTimeout( timeoutTimer );
7328                          }
7329  
7330                          // Dereference transport for early garbage collection
7331                          // (no matter how long the jqXHR object will be used)
7332                          transport = undefined;
7333  
7334                          // Cache response headers
7335                          responseHeadersString = headers || "";
7336  
7337                          // Set readyState
7338                          jqXHR.readyState = status > 0 ? 4 : 0;
7339  
7340                          var isSuccess,
7341                                  success,
7342                                  error,
7343                                  statusText = nativeStatusText,
7344                                  response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7345                                  lastModified,
7346                                  etag;
7347  
7348                          // If successful, handle type chaining
7349                          if ( status >= 200 && status < 300 || status === 304 ) {
7350  
7351                                  // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7352                                  if ( s.ifModified ) {
7353  
7354                                          if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7355                                                  jQuery.lastModified[ ifModifiedKey ] = lastModified;
7356                                          }
7357                                          if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7358                                                  jQuery.etag[ ifModifiedKey ] = etag;
7359                                          }
7360                                  }
7361  
7362                                  // If not modified
7363                                  if ( status === 304 ) {
7364  
7365                                          statusText = "notmodified";
7366                                          isSuccess = true;
7367  
7368                                  // If we have data
7369                                  } else {
7370  
7371                                          try {
7372                                                  success = ajaxConvert( s, response );
7373                                                  statusText = "success";
7374                                                  isSuccess = true;
7375                                          } catch(e) {
7376                                                  // We have a parsererror
7377                                                  statusText = "parsererror";
7378                                                  error = e;
7379                                          }
7380                                  }
7381                          } else {
7382                                  // We extract error from statusText
7383                                  // then normalize statusText and status for non-aborts
7384                                  error = statusText;
7385                                  if ( !statusText || status ) {
7386                                          statusText = "error";
7387                                          if ( status < 0 ) {
7388                                                  status = 0;
7389                                          }
7390                                  }
7391                          }
7392  
7393                          // Set data for the fake xhr object
7394                          jqXHR.status = status;
7395                          jqXHR.statusText = "" + ( nativeStatusText || statusText );
7396  
7397                          // Success/Error
7398                          if ( isSuccess ) {
7399                                  deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7400                          } else {
7401                                  deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7402                          }
7403  
7404                          // Status-dependent callbacks
7405                          jqXHR.statusCode( statusCode );
7406                          statusCode = undefined;
7407  
7408                          if ( fireGlobals ) {
7409                                  globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7410                                                  [ jqXHR, s, isSuccess ? success : error ] );
7411                          }
7412  
7413                          // Complete
7414                          completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
7415  
7416                          if ( fireGlobals ) {
7417                                  globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
7418                                  // Handle the global AJAX counter
7419                                  if ( !( --jQuery.active ) ) {
7420                                          jQuery.event.trigger( "ajaxStop" );
7421                                  }
7422                          }
7423                  }
7424  
7425                  // Attach deferreds
7426                  deferred.promise( jqXHR );
7427                  jqXHR.success = jqXHR.done;
7428                  jqXHR.error = jqXHR.fail;
7429                  jqXHR.complete = completeDeferred.add;
7430  
7431                  // Status-dependent callbacks
7432                  jqXHR.statusCode = function( map ) {
7433                          if ( map ) {
7434                                  var tmp;
7435                                  if ( state < 2 ) {
7436                                          for ( tmp in map ) {
7437                                                  statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7438                                          }
7439                                  } else {
7440                                          tmp = map[ jqXHR.status ];
7441                                          jqXHR.then( tmp, tmp );
7442                                  }
7443                          }
7444                          return this;
7445                  };
7446  
7447                  // Remove hash character (#7531: and string promotion)
7448                  // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7449                  // We also use the url parameter if available
7450                  s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7451  
7452                  // Extract dataTypes list
7453                  s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
7454  
7455                  // Determine if a cross-domain request is in order
7456                  if ( s.crossDomain == null ) {
7457                          parts = rurl.exec( s.url.toLowerCase() );
7458                          s.crossDomain = !!( parts &&
7459                                  ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
7460                                          ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7461                                                  ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7462                          );
7463                  }
7464  
7465                  // Convert data if not already a string
7466                  if ( s.data && s.processData && typeof s.data !== "string" ) {
7467                          s.data = jQuery.param( s.data, s.traditional );
7468                  }
7469  
7470                  // Apply prefilters
7471                  inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7472  
7473                  // If request was aborted inside a prefiler, stop there
7474                  if ( state === 2 ) {
7475                          return false;
7476                  }
7477  
7478                  // We can fire global events as of now if asked to
7479                  fireGlobals = s.global;
7480  
7481                  // Uppercase the type
7482                  s.type = s.type.toUpperCase();
7483  
7484                  // Determine if request has content
7485                  s.hasContent = !rnoContent.test( s.type );
7486  
7487                  // Watch for a new set of requests
7488                  if ( fireGlobals && jQuery.active++ === 0 ) {
7489                          jQuery.event.trigger( "ajaxStart" );
7490                  }
7491  
7492                  // More options handling for requests with no content
7493                  if ( !s.hasContent ) {
7494  
7495                          // If data is available, append data to url
7496                          if ( s.data ) {
7497                                  s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7498                                  // #9682: remove data so that it's not used in an eventual retry
7499                                  delete s.data;
7500                          }
7501  
7502                          // Get ifModifiedKey before adding the anti-cache parameter
7503                          ifModifiedKey = s.url;
7504  
7505                          // Add anti-cache in url if needed
7506                          if ( s.cache === false ) {
7507  
7508                                  var ts = jQuery.now(),
7509                                          // try replacing _= if it is there
7510                                          ret = s.url.replace( rts, "$1_=" + ts );
7511  
7512                                  // if nothing was replaced, add timestamp to the end
7513                                  s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7514                          }
7515                  }
7516  
7517                  // Set the correct header, if data is being sent
7518                  if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
7519                          jqXHR.setRequestHeader( "Content-Type", s.contentType );
7520                  }
7521  
7522                  // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7523                  if ( s.ifModified ) {
7524                          ifModifiedKey = ifModifiedKey || s.url;
7525                          if ( jQuery.lastModified[ ifModifiedKey ] ) {
7526                                  jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7527                          }
7528                          if ( jQuery.etag[ ifModifiedKey ] ) {
7529                                  jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7530                          }
7531                  }
7532  
7533                  // Set the Accepts header for the server, depending on the dataType
7534                  jqXHR.setRequestHeader(
7535                          "Accept",
7536                          s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7537                                  s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
7538                                  s.accepts[ "*" ]
7539                  );
7540  
7541                  // Check for headers option
7542                  for ( i in s.headers ) {
7543                          jqXHR.setRequestHeader( i, s.headers[ i ] );
7544                  }
7545  
7546                  // Allow custom headers/mimetypes and early abort
7547                  if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
7548                                  // Abort if not done already
7549                                  jqXHR.abort();
7550                                  return false;
7551  
7552                  }
7553  
7554                  // Install callbacks on deferreds
7555                  for ( i in { success: 1, error: 1, complete: 1 } ) {
7556                          jqXHR[ i ]( s[ i ] );
7557                  }
7558  
7559                  // Get transport
7560                  transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7561  
7562                  // If no transport, we auto-abort
7563                  if ( !transport ) {
7564                          done( -1, "No Transport" );
7565                  } else {
7566                          jqXHR.readyState = 1;
7567                          // Send global event
7568                          if ( fireGlobals ) {
7569                                  globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7570                          }
7571                          // Timeout
7572                          if ( s.async && s.timeout > 0 ) {
7573                                  timeoutTimer = setTimeout( function(){
7574                                          jqXHR.abort( "timeout" );
7575                                  }, s.timeout );
7576                          }
7577  
7578                          try {
7579                                  state = 1;
7580                                  transport.send( requestHeaders, done );
7581                          } catch (e) {
7582                                  // Propagate exception as error if not done
7583                                  if ( state < 2 ) {
7584                                          done( -1, e );
7585                                  // Simply rethrow otherwise
7586                                  } else {
7587                                          throw e;
7588                                  }
7589                          }
7590                  }
7591  
7592                  return jqXHR;
7593          },
7594  
7595          // Serialize an array of form elements or a set of
7596          // key/values into a query string
7597          param: function( a, traditional ) {
7598                  var s = [],
7599                          add = function( key, value ) {
7600                                  // If value is a function, invoke it and return its value
7601                                  value = jQuery.isFunction( value ) ? value() : value;
7602                                  s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7603                          };
7604  
7605                  // Set traditional to true for jQuery <= 1.3.2 behavior.
7606                  if ( traditional === undefined ) {
7607                          traditional = jQuery.ajaxSettings.traditional;
7608                  }
7609  
7610                  // If an array was passed in, assume that it is an array of form elements.
7611                  if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7612                          // Serialize the form elements
7613                          jQuery.each( a, function() {
7614                                  add( this.name, this.value );
7615                          });
7616  
7617                  } else {
7618                          // If traditional, encode the "old" way (the way 1.3.2 or older
7619                          // did it), otherwise encode params recursively.
7620                          for ( var prefix in a ) {
7621                                  buildParams( prefix, a[ prefix ], traditional, add );
7622                          }
7623                  }
7624  
7625                  // Return the resulting serialization
7626                  return s.join( "&" ).replace( r20, "+" );
7627          }
7628  });
7629  
7630  function buildParams( prefix, obj, traditional, add ) {
7631          if ( jQuery.isArray( obj ) ) {
7632                  // Serialize array item.
7633                  jQuery.each( obj, function( i, v ) {
7634                          if ( traditional || rbracket.test( prefix ) ) {
7635                                  // Treat each array item as a scalar.
7636                                  add( prefix, v );
7637  
7638                          } else {
7639                                  // If array item is non-scalar (array or object), encode its
7640                                  // numeric index to resolve deserialization ambiguity issues.
7641                                  // Note that rack (as of 1.0.0) can't currently deserialize
7642                                  // nested arrays properly, and attempting to do so may cause
7643                                  // a server error. Possible fixes are to modify rack's
7644                                  // deserialization algorithm or to provide an option or flag
7645                                  // to force array serialization to be shallow.
7646                                  buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7647                          }
7648                  });
7649  
7650          } else if ( !traditional && obj != null && typeof obj === "object" ) {
7651                  // Serialize object item.
7652                  for ( var name in obj ) {
7653                          buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7654                  }
7655  
7656          } else {
7657                  // Serialize scalar item.
7658                  add( prefix, obj );
7659          }
7660  }
7661  
7662  // This is still on the jQuery object... for now
7663  // Want to move this to jQuery.ajax some day
7664  jQuery.extend({
7665  
7666          // Counter for holding the number of active queries
7667          active: 0,
7668  
7669          // Last-Modified header cache for next request
7670          lastModified: {},
7671          etag: {}
7672  
7673  });
7674  
7675  /* Handles responses to an ajax request:
7676   * - sets all responseXXX fields accordingly
7677   * - finds the right dataType (mediates between content-type and expected dataType)
7678   * - returns the corresponding response
7679   */
7680  function ajaxHandleResponses( s, jqXHR, responses ) {
7681  
7682          var contents = s.contents,
7683                  dataTypes = s.dataTypes,
7684                  responseFields = s.responseFields,
7685                  ct,
7686                  type,
7687                  finalDataType,
7688                  firstDataType;
7689  
7690          // Fill responseXXX fields
7691          for ( type in responseFields ) {
7692                  if ( type in responses ) {
7693                          jqXHR[ responseFields[type] ] = responses[ type ];
7694                  }
7695          }
7696  
7697          // Remove auto dataType and get content-type in the process
7698          while( dataTypes[ 0 ] === "*" ) {
7699                  dataTypes.shift();
7700                  if ( ct === undefined ) {
7701                          ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
7702                  }
7703          }
7704  
7705          // Check if we're dealing with a known content-type
7706          if ( ct ) {
7707                  for ( type in contents ) {
7708                          if ( contents[ type ] && contents[ type ].test( ct ) ) {
7709                                  dataTypes.unshift( type );
7710                                  break;
7711                          }
7712                  }
7713          }
7714  
7715          // Check to see if we have a response for the expected dataType
7716          if ( dataTypes[ 0 ] in responses ) {
7717                  finalDataType = dataTypes[ 0 ];
7718          } else {
7719                  // Try convertible dataTypes
7720                  for ( type in responses ) {
7721                          if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
7722                                  finalDataType = type;
7723                                  break;
7724                          }
7725                          if ( !firstDataType ) {
7726                                  firstDataType = type;
7727                          }
7728                  }
7729                  // Or just use first one
7730                  finalDataType = finalDataType || firstDataType;
7731          }
7732  
7733          // If we found a dataType
7734          // We add the dataType to the list if needed
7735          // and return the corresponding response
7736          if ( finalDataType ) {
7737                  if ( finalDataType !== dataTypes[ 0 ] ) {
7738                          dataTypes.unshift( finalDataType );
7739                  }
7740                  return responses[ finalDataType ];
7741          }
7742  }
7743  
7744  // Chain conversions given the request and the original response
7745  function ajaxConvert( s, response ) {
7746  
7747          // Apply the dataFilter if provided
7748          if ( s.dataFilter ) {
7749                  response = s.dataFilter( response, s.dataType );
7750          }
7751  
7752          var dataTypes = s.dataTypes,
7753                  converters = {},
7754                  i,
7755                  key,
7756                  length = dataTypes.length,
7757                  tmp,
7758                  // Current and previous dataTypes
7759                  current = dataTypes[ 0 ],
7760                  prev,
7761                  // Conversion expression
7762                  conversion,
7763                  // Conversion function
7764                  conv,
7765                  // Conversion functions (transitive conversion)
7766                  conv1,
7767                  conv2;
7768  
7769          // For each dataType in the chain
7770          for ( i = 1; i < length; i++ ) {
7771  
7772                  // Create converters map
7773                  // with lowercased keys
7774                  if ( i === 1 ) {
7775                          for ( key in s.converters ) {
7776                                  if ( typeof key === "string" ) {
7777                                          converters[ key.toLowerCase() ] = s.converters[ key ];
7778                                  }
7779                          }
7780                  }
7781  
7782                  // Get the dataTypes
7783                  prev = current;
7784                  current = dataTypes[ i ];
7785  
7786                  // If current is auto dataType, update it to prev
7787                  if ( current === "*" ) {
7788                          current = prev;
7789                  // If no auto and dataTypes are actually different
7790                  } else if ( prev !== "*" && prev !== current ) {
7791  
7792                          // Get the converter
7793                          conversion = prev + " " + current;
7794                          conv = converters[ conversion ] || converters[ "* " + current ];
7795  
7796                          // If there is no direct converter, search transitively
7797                          if ( !conv ) {
7798                                  conv2 = undefined;
7799                                  for ( conv1 in converters ) {
7800                                          tmp = conv1.split( " " );
7801                                          if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
7802                                                  conv2 = converters[ tmp[1] + " " + current ];
7803                                                  if ( conv2 ) {
7804                                                          conv1 = converters[ conv1 ];
7805                                                          if ( conv1 === true ) {
7806                                                                  conv = conv2;
7807                                                          } else if ( conv2 === true ) {
7808                                                                  conv = conv1;
7809                                                          }
7810                                                          break;
7811                                                  }
7812                                          }
7813                                  }
7814                          }
7815                          // If we found no converter, dispatch an error
7816                          if ( !( conv || conv2 ) ) {
7817                                  jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7818                          }
7819                          // If found converter is not an equivalence
7820                          if ( conv !== true ) {
7821                                  // Convert with 1 or 2 converters accordingly
7822                                  response = conv ? conv( response ) : conv2( conv1(response) );
7823                          }
7824                  }
7825          }
7826          return response;
7827  }
7828  
7829  
7830  
7831  
7832  var jsc = jQuery.now(),
7833          jsre = /(\=)\?(&|$)|\?\?/i;
7834  
7835  // Default jsonp settings
7836  jQuery.ajaxSetup({
7837          jsonp: "callback",
7838          jsonpCallback: function() {
7839                  return jQuery.expando + "_" + ( jsc++ );
7840          }
7841  });
7842  
7843  // Detect, normalize options and install callbacks for jsonp requests
7844  jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7845  
7846          var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7847                  ( typeof s.data === "string" );
7848  
7849          if ( s.dataTypes[ 0 ] === "jsonp" ||
7850                  s.jsonp !== false && ( jsre.test( s.url ) ||
7851                                  inspectData && jsre.test( s.data ) ) ) {
7852  
7853                  var responseContainer,
7854                          jsonpCallback = s.jsonpCallback =
7855                                  jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7856                          previous = window[ jsonpCallback ],
7857                          url = s.url,
7858                          data = s.data,
7859                          replace = "$1" + jsonpCallback + "$2";
7860  
7861                  if ( s.jsonp !== false ) {
7862                          url = url.replace( jsre, replace );
7863                          if ( s.url === url ) {
7864                                  if ( inspectData ) {
7865                                          data = data.replace( jsre, replace );
7866                                  }
7867                                  if ( s.data === data ) {
7868                                          // Add callback manually
7869                                          url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7870                                  }
7871                          }
7872                  }
7873  
7874                  s.url = url;
7875                  s.data = data;
7876  
7877                  // Install callback
7878                  window[ jsonpCallback ] = function( response ) {
7879                          responseContainer = [ response ];
7880                  };
7881  
7882                  // Clean-up function
7883                  jqXHR.always(function() {
7884                          // Set callback back to previous value
7885                          window[ jsonpCallback ] = previous;
7886                          // Call if it was a function and we have a response
7887                          if ( responseContainer && jQuery.isFunction( previous ) ) {
7888                                  window[ jsonpCallback ]( responseContainer[ 0 ] );
7889                          }
7890                  });
7891  
7892                  // Use data converter to retrieve json after script execution
7893                  s.converters["script json"] = function() {
7894                          if ( !responseContainer ) {
7895                                  jQuery.error( jsonpCallback + " was not called" );
7896                          }
7897                          return responseContainer[ 0 ];
7898                  };
7899  
7900                  // force json dataType
7901                  s.dataTypes[ 0 ] = "json";
7902  
7903                  // Delegate to script
7904                  return "script";
7905          }
7906  });
7907  
7908  
7909  
7910  
7911  // Install script dataType
7912  jQuery.ajaxSetup({
7913          accepts: {
7914                  script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7915          },
7916          contents: {
7917                  script: /javascript|ecmascript/
7918          },
7919          converters: {
7920                  "text script": function( text ) {
7921                          jQuery.globalEval( text );
7922                          return text;
7923                  }
7924          }
7925  });
7926  
7927  // Handle cache's special case and global
7928  jQuery.ajaxPrefilter( "script", function( s ) {
7929          if ( s.cache === undefined ) {
7930                  s.cache = false;
7931          }
7932          if ( s.crossDomain ) {
7933                  s.type = "GET";
7934                  s.global = false;
7935          }
7936  });
7937  
7938  // Bind script tag hack transport
7939  jQuery.ajaxTransport( "script", function(s) {
7940  
7941          // This transport only deals with cross domain requests
7942          if ( s.crossDomain ) {
7943  
7944                  var script,
7945                          head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
7946  
7947                  return {
7948  
7949                          send: function( _, callback ) {
7950  
7951                                  script = document.createElement( "script" );
7952  
7953                                  script.async = "async";
7954  
7955                                  if ( s.scriptCharset ) {
7956                                          script.charset = s.scriptCharset;
7957                                  }
7958  
7959                                  script.src = s.url;
7960  
7961                                  // Attach handlers for all browsers
7962                                  script.onload = script.onreadystatechange = function( _, isAbort ) {
7963  
7964                                          if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
7965  
7966                                                  // Handle memory leak in IE
7967                                                  script.onload = script.onreadystatechange = null;
7968  
7969                                                  // Remove the script
7970                                                  if ( head && script.parentNode ) {
7971                                                          head.removeChild( script );
7972                                                  }
7973  
7974                                                  // Dereference the script
7975                                                  script = undefined;
7976  
7977                                                  // Callback if not abort
7978                                                  if ( !isAbort ) {
7979                                                          callback( 200, "success" );
7980                                                  }
7981                                          }
7982                                  };
7983                                  // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
7984                                  // This arises when a base node is used (#2709 and #4378).
7985                                  head.insertBefore( script, head.firstChild );
7986                          },
7987  
7988                          abort: function() {
7989                                  if ( script ) {
7990                                          script.onload( 0, 1 );
7991                                  }
7992                          }
7993                  };
7994          }
7995  });
7996  
7997  
7998  
7999  
8000  var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
8001          xhrOnUnloadAbort = window.ActiveXObject ? function() {
8002                  // Abort all pending requests
8003                  for ( var key in xhrCallbacks ) {
8004                          xhrCallbacks[ key ]( 0, 1 );
8005                  }
8006          } : false,
8007          xhrId = 0,
8008          xhrCallbacks;
8009  
8010  // Functions to create xhrs
8011  function createStandardXHR() {
8012          try {
8013                  return new window.XMLHttpRequest();
8014          } catch( e ) {}
8015  }
8016  
8017  function createActiveXHR() {
8018          try {
8019                  return new window.ActiveXObject( "Microsoft.XMLHTTP" );
8020          } catch( e ) {}
8021  }
8022  
8023  // Create the request object
8024  // (This is still attached to ajaxSettings for backward compatibility)
8025  jQuery.ajaxSettings.xhr = window.ActiveXObject ?
8026          /* Microsoft failed to properly
8027           * implement the XMLHttpRequest in IE7 (can't request local files),
8028           * so we use the ActiveXObject when it is available
8029           * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
8030           * we need a fallback.
8031           */
8032          function() {
8033                  return !this.isLocal && createStandardXHR() || createActiveXHR();
8034          } :
8035          // For all other browsers, use the standard XMLHttpRequest object
8036          createStandardXHR;
8037  
8038  // Determine support properties
8039  (function( xhr ) {
8040          jQuery.extend( jQuery.support, {
8041                  ajax: !!xhr,
8042                  cors: !!xhr && ( "withCredentials" in xhr )
8043          });
8044  })( jQuery.ajaxSettings.xhr() );
8045  
8046  // Create transport if the browser can provide an xhr
8047  if ( jQuery.support.ajax ) {
8048  
8049          jQuery.ajaxTransport(function( s ) {
8050                  // Cross domain only allowed if supported through XMLHttpRequest
8051                  if ( !s.crossDomain || jQuery.support.cors ) {
8052  
8053                          var callback;
8054  
8055                          return {
8056                                  send: function( headers, complete ) {
8057  
8058                                          // Get a new xhr
8059                                          var xhr = s.xhr(),
8060                                                  handle,
8061                                                  i;
8062  
8063                                          // Open the socket
8064                                          // Passing null username, generates a login popup on Opera (#2865)
8065                                          if ( s.username ) {
8066                                                  xhr.open( s.type, s.url, s.async, s.username, s.password );
8067                                          } else {
8068                                                  xhr.open( s.type, s.url, s.async );
8069                                          }
8070  
8071                                          // Apply custom fields if provided
8072                                          if ( s.xhrFields ) {
8073                                                  for ( i in s.xhrFields ) {
8074                                                          xhr[ i ] = s.xhrFields[ i ];
8075                                                  }
8076                                          }
8077  
8078                                          // Override mime type if needed
8079                                          if ( s.mimeType && xhr.overrideMimeType ) {
8080                                                  xhr.overrideMimeType( s.mimeType );
8081                                          }
8082  
8083                                          // X-Requested-With header
8084                                          // For cross-domain requests, seeing as conditions for a preflight are
8085                                          // akin to a jigsaw puzzle, we simply never set it to be sure.
8086                                          // (it can always be set on a per-request basis or even using ajaxSetup)
8087                                          // For same-domain requests, won't change header if already provided.
8088                                          if ( !s.crossDomain && !headers["X-Requested-With"] ) {
8089                                                  headers[ "X-Requested-With" ] = "XMLHttpRequest";
8090                                          }
8091  
8092                                          // Need an extra try/catch for cross domain requests in Firefox 3
8093                                          try {
8094                                                  for ( i in headers ) {
8095                                                          xhr.setRequestHeader( i, headers[ i ] );
8096                                                  }
8097                                          } catch( _ ) {}
8098  
8099                                          // Do send the request
8100                                          // This may raise an exception which is actually
8101                                          // handled in jQuery.ajax (so no try/catch here)
8102                                          xhr.send( ( s.hasContent && s.data ) || null );
8103  
8104                                          // Listener
8105                                          callback = function( _, isAbort ) {
8106  
8107                                                  var status,
8108                                                          statusText,
8109                                                          responseHeaders,
8110                                                          responses,
8111                                                          xml;
8112  
8113                                                  // Firefox throws exceptions when accessing properties
8114                                                  // of an xhr when a network error occured
8115                                                  // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
8116                                                  try {
8117  
8118                                                          // Was never called and is aborted or complete
8119                                                          if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
8120  
8121                                                                  // Only called once
8122                                                                  callback = undefined;
8123  
8124                                                                  // Do not keep as active anymore
8125                                                                  if ( handle ) {
8126                                                                          xhr.onreadystatechange = jQuery.noop;
8127                                                                          if ( xhrOnUnloadAbort ) {
8128                                                                                  delete xhrCallbacks[ handle ];
8129                                                                          }
8130                                                                  }
8131  
8132                                                                  // If it's an abort
8133                                                                  if ( isAbort ) {
8134                                                                          // Abort it manually if needed
8135                                                                          if ( xhr.readyState !== 4 ) {
8136                                                                                  xhr.abort();
8137                                                                          }
8138                                                                  } else {
8139                                                                          status = xhr.status;
8140                                                                          responseHeaders = xhr.getAllResponseHeaders();
8141                                                                          responses = {};
8142                                                                          xml = xhr.responseXML;
8143  
8144                                                                          // Construct response list
8145                                                                          if ( xml && xml.documentElement /* #4958 */ ) {
8146                                                                                  responses.xml = xml;
8147                                                                          }
8148                                                                          responses.text = xhr.responseText;
8149  
8150                                                                          // Firefox throws an exception when accessing
8151                                                                          // statusText for faulty cross-domain requests
8152                                                                          try {
8153                                                                                  statusText = xhr.statusText;
8154                                                                          } catch( e ) {
8155                                                                                  // We normalize with Webkit giving an empty statusText
8156                                                                                  statusText = "";
8157                                                                          }
8158  
8159                                                                          // Filter status for non standard behaviors
8160  
8161                                                                          // If the request is local and we have data: assume a success
8162                                                                          // (success with no data won't get notified, that's the best we
8163                                                                          // can do given current implementations)
8164                                                                          if ( !status && s.isLocal && !s.crossDomain ) {
8165                                                                                  status = responses.text ? 200 : 404;
8166                                                                          // IE - #1450: sometimes returns 1223 when it should be 204
8167                                                                          } else if ( status === 1223 ) {
8168                                                                                  status = 204;
8169                                                                          }
8170                                                                  }
8171                                                          }
8172                                                  } catch( firefoxAccessException ) {
8173                                                          if ( !isAbort ) {
8174                                                                  complete( -1, firefoxAccessException );
8175                                                          }
8176                                                  }
8177  
8178                                                  // Call complete if needed
8179                                                  if ( responses ) {
8180                                                          complete( status, statusText, responses, responseHeaders );
8181                                                  }
8182                                          };
8183  
8184                                          // if we're in sync mode or it's in cache
8185                                          // and has been retrieved directly (IE6 & IE7)
8186                                          // we need to manually fire the callback
8187                                          if ( !s.async || xhr.readyState === 4 ) {
8188                                                  callback();
8189                                          } else {
8190                                                  handle = ++xhrId;
8191                                                  if ( xhrOnUnloadAbort ) {
8192                                                          // Create the active xhrs callbacks list if needed
8193                                                          // and attach the unload handler
8194                                                          if ( !xhrCallbacks ) {
8195                                                                  xhrCallbacks = {};
8196                                                                  jQuery( window ).unload( xhrOnUnloadAbort );
8197                                                          }
8198                                                          // Add to list of active xhrs callbacks
8199                                                          xhrCallbacks[ handle ] = callback;
8200                                                  }
8201                                                  xhr.onreadystatechange = callback;
8202                                          }
8203                                  },
8204  
8205                                  abort: function() {
8206                                          if ( callback ) {
8207                                                  callback(0,1);
8208                                          }
8209                                  }
8210                          };
8211                  }
8212          });
8213  }
8214  
8215  
8216  
8217  
8218  var elemdisplay = {},
8219          iframe, iframeDoc,
8220          rfxtypes = /^(?:toggle|show|hide)$/,
8221          rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
8222          timerId,
8223          fxAttrs = [
8224                  // height animations
8225                  [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
8226                  // width animations
8227                  [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
8228                  // opacity animations
8229                  [ "opacity" ]
8230          ],
8231          fxNow;
8232  
8233  jQuery.fn.extend({
8234          show: function( speed, easing, callback ) {
8235                  var elem, display;
8236  
8237                  if ( speed || speed === 0 ) {
8238                          return this.animate( genFx("show", 3), speed, easing, callback );
8239  
8240                  } else {
8241                          for ( var i = 0, j = this.length; i < j; i++ ) {
8242                                  elem = this[ i ];
8243  
8244                                  if ( elem.style ) {
8245                                          display = elem.style.display;
8246  
8247                                          // Reset the inline display of this element to learn if it is
8248                                          // being hidden by cascaded rules or not
8249                                          if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
8250                                                  display = elem.style.display = "";
8251                                          }
8252  
8253                                          // Set elements which have been overridden with display: none
8254                                          // in a stylesheet to whatever the default browser style is
8255                                          // for such an element
8256                                          if ( display === "" && jQuery.css(elem, "display") === "none" ) {
8257                                                  jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
8258                                          }
8259                                  }
8260                          }
8261  
8262                          // Set the display of most of the elements in a second loop
8263                          // to avoid the constant reflow
8264                          for ( i = 0; i < j; i++ ) {
8265                                  elem = this[ i ];
8266  
8267                                  if ( elem.style ) {
8268                                          display = elem.style.display;
8269  
8270                                          if ( display === "" || display === "none" ) {
8271                                                  elem.style.display = jQuery._data( elem, "olddisplay" ) || "";
8272                                          }
8273                                  }
8274                          }
8275  
8276                          return this;
8277                  }
8278          },
8279  
8280          hide: function( speed, easing, callback ) {
8281                  if ( speed || speed === 0 ) {
8282                          return this.animate( genFx("hide", 3), speed, easing, callback);
8283  
8284                  } else {
8285                          var elem, display,
8286                                  i = 0,
8287                                  j = this.length;
8288  
8289                          for ( ; i < j; i++ ) {
8290                                  elem = this[i];
8291                                  if ( elem.style ) {
8292                                          display = jQuery.css( elem, "display" );
8293  
8294                                          if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) {
8295                                                  jQuery._data( elem, "olddisplay", display );
8296                                          }
8297                                  }
8298                          }
8299  
8300                          // Set the display of the elements in a second loop
8301                          // to avoid the constant reflow
8302                          for ( i = 0; i < j; i++ ) {
8303                                  if ( this[i].style ) {
8304                                          this[i].style.display = "none";
8305                                  }
8306                          }
8307  
8308                          return this;
8309                  }
8310          },
8311  
8312          // Save the old toggle function
8313          _toggle: jQuery.fn.toggle,
8314  
8315          toggle: function( fn, fn2, callback ) {
8316                  var bool = typeof fn === "boolean";
8317  
8318                  if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8319                          this._toggle.apply( this, arguments );
8320  
8321                  } else if ( fn == null || bool ) {
8322                          this.each(function() {
8323                                  var state = bool ? fn : jQuery(this).is(":hidden");
8324                                  jQuery(this)[ state ? "show" : "hide" ]();
8325                          });
8326  
8327                  } else {
8328                          this.animate(genFx("toggle", 3), fn, fn2, callback);
8329                  }
8330  
8331                  return this;
8332          },
8333  
8334          fadeTo: function( speed, to, easing, callback ) {
8335                  return this.filter(":hidden").css("opacity", 0).show().end()
8336                                          .animate({opacity: to}, speed, easing, callback);
8337          },
8338  
8339          animate: function( prop, speed, easing, callback ) {
8340                  var optall = jQuery.speed( speed, easing, callback );
8341  
8342                  if ( jQuery.isEmptyObject( prop ) ) {
8343                          return this.each( optall.complete, [ false ] );
8344                  }
8345  
8346                  // Do not change referenced properties as per-property easing will be lost
8347                  prop = jQuery.extend( {}, prop );
8348  
8349                  function doAnimation() {
8350                          // XXX 'this' does not always have a nodeName when running the
8351                          // test suite
8352  
8353                          if ( optall.queue === false ) {
8354                                  jQuery._mark( this );
8355                          }
8356  
8357                          var opt = jQuery.extend( {}, optall ),
8358                                  isElement = this.nodeType === 1,
8359                                  hidden = isElement && jQuery(this).is(":hidden"),
8360                                  name, val, p, e,
8361                                  parts, start, end, unit,
8362                                  method;
8363  
8364                          // will store per property easing and be used to determine when an animation is complete
8365                          opt.animatedProperties = {};
8366  
8367                          for ( p in prop ) {
8368  
8369                                  // property name normalization
8370                                  name = jQuery.camelCase( p );
8371                                  if ( p !== name ) {
8372                                          prop[ name ] = prop[ p ];
8373                                          delete prop[ p ];
8374                                  }
8375  
8376                                  val = prop[ name ];
8377  
8378                                  // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8379                                  if ( jQuery.isArray( val ) ) {
8380                                          opt.animatedProperties[ name ] = val[ 1 ];
8381                                          val = prop[ name ] = val[ 0 ];
8382                                  } else {
8383                                          opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
8384                                  }
8385  
8386                                  if ( val === "hide" && hidden || val === "show" && !hidden ) {
8387                                          return opt.complete.call( this );
8388                                  }
8389  
8390                                  if ( isElement && ( name === "height" || name === "width" ) ) {
8391                                          // Make sure that nothing sneaks out
8392                                          // Record all 3 overflow attributes because IE does not
8393                                          // change the overflow attribute when overflowX and
8394                                          // overflowY are set to the same value
8395                                          opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8396  
8397                                          // Set display property to inline-block for height/width
8398                                          // animations on inline elements that are having width/height animated
8399                                          if ( jQuery.css( this, "display" ) === "inline" &&
8400                                                          jQuery.css( this, "float" ) === "none" ) {
8401  
8402                                                  // inline-level elements accept inline-block;
8403                                                  // block-level elements need to be inline with layout
8404                                                  if ( !jQuery.support.inlineBlockNeedsLayout || defaultDisplay( this.nodeName ) === "inline" ) {
8405                                                          this.style.display = "inline-block";
8406  
8407                                                  } else {
8408                                                          this.style.zoom = 1;
8409                                                  }
8410                                          }
8411                                  }
8412                          }
8413  
8414                          if ( opt.overflow != null ) {
8415                                  this.style.overflow = "hidden";
8416                          }
8417  
8418                          for ( p in prop ) {
8419                                  e = new jQuery.fx( this, opt, p );
8420                                  val = prop[ p ];
8421  
8422                                  if ( rfxtypes.test( val ) ) {
8423  
8424                                          // Tracks whether to show or hide based on private
8425                                          // data attached to the element
8426                                          method = jQuery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
8427                                          if ( method ) {
8428                                                  jQuery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
8429                                                  e[ method ]();
8430                                          } else {
8431                                                  e[ val ]();
8432                                          }
8433  
8434                                  } else {
8435                                          parts = rfxnum.exec( val );
8436                                          start = e.cur();
8437  
8438                                          if ( parts ) {
8439                                                  end = parseFloat( parts[2] );
8440                                                  unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
8441  
8442                                                  // We need to compute starting value
8443                                                  if ( unit !== "px" ) {
8444                                                          jQuery.style( this, p, (end || 1) + unit);
8445                                                          start = ( (end || 1) / e.cur() ) * start;
8446                                                          jQuery.style( this, p, start + unit);
8447                                                  }
8448  
8449                                                  // If a +=/-= token was provided, we're doing a relative animation
8450                                                  if ( parts[1] ) {
8451                                                          end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8452                                                  }
8453  
8454                                                  e.custom( start, end, unit );
8455  
8456                                          } else {
8457                                                  e.custom( start, val, "" );
8458                                          }
8459                                  }
8460                          }
8461  
8462                          // For JS strict compliance
8463                          return true;
8464                  }
8465  
8466                  return optall.queue === false ?
8467                          this.each( doAnimation ) :
8468                          this.queue( optall.queue, doAnimation );
8469          },
8470  
8471          stop: function( type, clearQueue, gotoEnd ) {
8472                  if ( typeof type !== "string" ) {
8473                          gotoEnd = clearQueue;
8474                          clearQueue = type;
8475                          type = undefined;
8476                  }
8477                  if ( clearQueue && type !== false ) {
8478                          this.queue( type || "fx", [] );
8479                  }
8480  
8481                  return this.each(function() {
8482                          var index,
8483                                  hadTimers = false,
8484                                  timers = jQuery.timers,
8485                                  data = jQuery._data( this );
8486  
8487                          // clear marker counters if we know they won't be
8488                          if ( !gotoEnd ) {
8489                                  jQuery._unmark( true, this );
8490                          }
8491  
8492                          function stopQueue( elem, data, index ) {
8493                                  var hooks = data[ index ];
8494                                  jQuery.removeData( elem, index, true );
8495                                  hooks.stop( gotoEnd );
8496                          }
8497  
8498                          if ( type == null ) {
8499                                  for ( index in data ) {
8500                                          if ( data[ index ] && data[ index ].stop && index.indexOf(".run") === index.length - 4 ) {
8501                                                  stopQueue( this, data, index );
8502                                          }
8503                                  }
8504                          } else if ( data[ index = type + ".run" ] && data[ index ].stop ){
8505                                  stopQueue( this, data, index );
8506                          }
8507  
8508                          for ( index = timers.length; index--; ) {
8509                                  if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
8510                                          if ( gotoEnd ) {
8511  
8512                                                  // force the next step to be the last
8513                                                  timers[ index ]( true );
8514                                          } else {
8515                                                  timers[ index ].saveState();
8516                                          }
8517                                          hadTimers = true;
8518                                          timers.splice( index, 1 );
8519                                  }
8520                          }
8521  
8522                          // start the next in the queue if the last step wasn't forced
8523                          // timers currently will call their complete callbacks, which will dequeue
8524                          // but only if they were gotoEnd
8525                          if ( !( gotoEnd && hadTimers ) ) {
8526                                  jQuery.dequeue( this, type );
8527                          }
8528                  });
8529          }
8530  
8531  });
8532  
8533  // Animations created synchronously will run synchronously
8534  function createFxNow() {
8535          setTimeout( clearFxNow, 0 );
8536          return ( fxNow = jQuery.now() );
8537  }
8538  
8539  function clearFxNow() {
8540          fxNow = undefined;
8541  }
8542  
8543  // Generate parameters to create a standard animation
8544  function genFx( type, num ) {
8545          var obj = {};
8546  
8547          jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice( 0, num )), function() {
8548                  obj[ this ] = type;
8549          });
8550  
8551          return obj;
8552  }
8553  
8554  // Generate shortcuts for custom animations
8555  jQuery.each({
8556          slideDown: genFx( "show", 1 ),
8557          slideUp: genFx( "hide", 1 ),
8558          slideToggle: genFx( "toggle", 1 ),
8559          fadeIn: { opacity: "show" },
8560          fadeOut: { opacity: "hide" },
8561          fadeToggle: { opacity: "toggle" }
8562  }, function( name, props ) {
8563          jQuery.fn[ name ] = function( speed, easing, callback ) {
8564                  return this.animate( props, speed, easing, callback );
8565          };
8566  });
8567  
8568  jQuery.extend({
8569          speed: function( speed, easing, fn ) {
8570                  var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
8571                          complete: fn || !fn && easing ||
8572                                  jQuery.isFunction( speed ) && speed,
8573                          duration: speed,
8574                          easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
8575                  };
8576  
8577                  opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8578                          opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
8579  
8580                  // normalize opt.queue - true/undefined/null -> "fx"
8581                  if ( opt.queue == null || opt.queue === true ) {
8582                          opt.queue = "fx";
8583                  }
8584  
8585                  // Queueing
8586                  opt.old = opt.complete;
8587  
8588                  opt.complete = function( noUnmark ) {
8589                          if ( jQuery.isFunction( opt.old ) ) {
8590                                  opt.old.call( this );
8591                          }
8592  
8593                          if ( opt.queue ) {
8594                                  jQuery.dequeue( this, opt.queue );
8595                          } else if ( noUnmark !== false ) {
8596                                  jQuery._unmark( this );
8597                          }
8598                  };
8599  
8600                  return opt;
8601          },
8602  
8603          easing: {
8604                  linear: function( p, n, firstNum, diff ) {
8605                          return firstNum + diff * p;
8606                  },
8607                  swing: function( p, n, firstNum, diff ) {
8608                          return ( ( -Math.cos( p*Math.PI ) / 2 ) + 0.5 ) * diff + firstNum;
8609                  }
8610          },
8611  
8612          timers: [],
8613  
8614          fx: function( elem, options, prop ) {
8615                  this.options = options;
8616                  this.elem = elem;
8617                  this.prop = prop;
8618  
8619                  options.orig = options.orig || {};
8620          }
8621  
8622  });
8623  
8624  jQuery.fx.prototype = {
8625          // Simple function for setting a style value
8626          update: function() {
8627                  if ( this.options.step ) {
8628                          this.options.step.call( this.elem, this.now, this );
8629                  }
8630  
8631                  ( jQuery.fx.step[ this.prop ] || jQuery.fx.step._default )( this );
8632          },
8633  
8634          // Get the current size
8635          cur: function() {
8636                  if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
8637                          return this.elem[ this.prop ];
8638                  }
8639  
8640                  var parsed,
8641                          r = jQuery.css( this.elem, this.prop );
8642                  // Empty strings, null, undefined and "auto" are converted to 0,
8643                  // complex values such as "rotate(1rad)" are returned as is,
8644                  // simple values such as "10px" are parsed to Float.
8645                  return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
8646          },
8647  
8648          // Start an animation from one number to another
8649          custom: function( from, to, unit ) {
8650                  var self = this,
8651                          fx = jQuery.fx;
8652  
8653                  this.startTime = fxNow || createFxNow();
8654                  this.end = to;
8655                  this.now = this.start = from;
8656                  this.pos = this.state = 0;
8657                  this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8658  
8659                  function t( gotoEnd ) {
8660                          return self.step( gotoEnd );
8661                  }
8662  
8663                  t.queue = this.options.queue;
8664                  t.elem = this.elem;
8665                  t.saveState = function() {
8666                          if ( self.options.hide && jQuery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
8667                                  jQuery._data( self.elem, "fxshow" + self.prop, self.start );
8668                          }
8669                  };
8670  
8671                  if ( t() && jQuery.timers.push(t) && !timerId ) {
8672                          timerId = setInterval( fx.tick, fx.interval );
8673                  }
8674          },
8675  
8676          // Simple 'show' function
8677          show: function() {
8678                  var dataShow = jQuery._data( this.elem, "fxshow" + this.prop );
8679  
8680                  // Remember where we started, so that we can go back to it later
8681                  this.options.orig[ this.prop ] = dataShow || jQuery.style( this.elem, this.prop );
8682                  this.options.show = true;
8683  
8684                  // Begin the animation
8685                  // Make sure that we start at a small width/height to avoid any flash of content
8686                  if ( dataShow !== undefined ) {
8687                          // This show is picking up where a previous hide or show left off
8688                          this.custom( this.cur(), dataShow );
8689                  } else {
8690                          this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
8691                  }
8692  
8693                  // Start by showing the element
8694                  jQuery( this.elem ).show();
8695          },
8696  
8697          // Simple 'hide' function
8698          hide: function() {
8699                  // Remember where we started, so that we can go back to it later
8700                  this.options.orig[ this.prop ] = jQuery._data( this.elem, "fxshow" + this.prop ) || jQuery.style( this.elem, this.prop );
8701                  this.options.hide = true;
8702  
8703                  // Begin the animation
8704                  this.custom( this.cur(), 0 );
8705          },
8706  
8707          // Each step of an animation
8708          step: function( gotoEnd ) {
8709                  var p, n, complete,
8710                          t = fxNow || createFxNow(),
8711                          done = true,
8712                          elem = this.elem,
8713                          options = this.options;
8714  
8715                  if ( gotoEnd || t >= options.duration + this.startTime ) {
8716                          this.now = this.end;
8717                          this.pos = this.state = 1;
8718                          this.update();
8719  
8720                          options.animatedProperties[ this.prop ] = true;
8721  
8722                          for ( p in options.animatedProperties ) {
8723                                  if ( options.animatedProperties[ p ] !== true ) {
8724                                          done = false;
8725                                  }
8726                          }
8727  
8728                          if ( done ) {
8729                                  // Reset the overflow
8730                                  if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8731  
8732                                          jQuery.each( [ "", "X", "Y" ], function( index, value ) {
8733                                                  elem.style[ "overflow" + value ] = options.overflow[ index ];
8734                                          });
8735                                  }
8736  
8737                                  // Hide the element if the "hide" operation was done
8738                                  if ( options.hide ) {
8739                                          jQuery( elem ).hide();
8740                                  }
8741  
8742                                  // Reset the properties, if the item has been hidden or shown
8743                                  if ( options.hide || options.show ) {
8744                                          for ( p in options.animatedProperties ) {
8745                                                  jQuery.style( elem, p, options.orig[ p ] );
8746                                                  jQuery.removeData( elem, "fxshow" + p, true );
8747                                                  // Toggle data is no longer needed
8748                                                  jQuery.removeData( elem, "toggle" + p, true );
8749                                          }
8750                                  }
8751  
8752                                  // Execute the complete function
8753                                  // in the event that the complete function throws an exception
8754                                  // we must ensure it won't be called twice. #5684
8755  
8756                                  complete = options.complete;
8757                                  if ( complete ) {
8758  
8759                                          options.complete = false;
8760                                          complete.call( elem );
8761                                  }
8762                          }
8763  
8764                          return false;
8765  
8766                  } else {
8767                          // classical easing cannot be used with an Infinity duration
8768                          if ( options.duration == Infinity ) {
8769                                  this.now = t;
8770                          } else {
8771                                  n = t - this.startTime;
8772                                  this.state = n / options.duration;
8773  
8774                                  // Perform the easing function, defaults to swing
8775                                  this.pos = jQuery.easing[ options.animatedProperties[this.prop] ]( this.state, n, 0, 1, options.duration );
8776                                  this.now = this.start + ( (this.end - this.start) * this.pos );
8777                          }
8778                          // Perform the next step of the animation
8779                          this.update();
8780                  }
8781  
8782                  return true;
8783          }
8784  };
8785  
8786  jQuery.extend( jQuery.fx, {
8787          tick: function() {
8788                  var timer,
8789                          timers = jQuery.timers,
8790                          i = 0;
8791  
8792                  for ( ; i < timers.length; i++ ) {
8793                          timer = timers[ i ];
8794                          // Checks the timer has not already been removed
8795                          if ( !timer() && timers[ i ] === timer ) {
8796                                  timers.splice( i--, 1 );
8797                          }
8798                  }
8799  
8800                  if ( !timers.length ) {
8801                          jQuery.fx.stop();
8802                  }
8803          },
8804  
8805          interval: 13,
8806  
8807          stop: function() {
8808                  clearInterval( timerId );
8809                  timerId = null;
8810          },
8811  
8812          speeds: {
8813                  slow: 600,
8814                  fast: 200,
8815                  // Default speed
8816                  _default: 400
8817          },
8818  
8819          step: {
8820                  opacity: function( fx ) {
8821                          jQuery.style( fx.elem, "opacity", fx.now );
8822                  },
8823  
8824                  _default: function( fx ) {
8825                          if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8826                                  fx.elem.style[ fx.prop ] = fx.now + fx.unit;
8827                          } else {
8828                                  fx.elem[ fx.prop ] = fx.now;
8829                          }
8830                  }
8831          }
8832  });
8833  
8834  // Adds width/height step functions
8835  // Do not set anything below 0
8836  jQuery.each([ "width", "height" ], function( i, prop ) {
8837          jQuery.fx.step[ prop ] = function( fx ) {
8838                  jQuery.style( fx.elem, prop, Math.max(0, fx.now) + fx.unit );
8839          };
8840  });
8841  
8842  if ( jQuery.expr && jQuery.expr.filters ) {
8843          jQuery.expr.filters.animated = function( elem ) {
8844                  return jQuery.grep(jQuery.timers, function( fn ) {
8845                          return elem === fn.elem;
8846                  }).length;
8847          };
8848  }
8849  
8850  // Try to restore the default display value of an element
8851  function defaultDisplay( nodeName ) {
8852  
8853          if ( !elemdisplay[ nodeName ] ) {
8854  
8855                  var body = document.body,
8856                          elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
8857                          display = elem.css( "display" );
8858                  elem.remove();
8859  
8860                  // If the simple way fails,
8861                  // get element's real default display by attaching it to a temp iframe
8862                  if ( display === "none" || display === "" ) {
8863                          // No iframe to use yet, so create it
8864                          if ( !iframe ) {
8865                                  iframe = document.createElement( "iframe" );
8866                                  iframe.frameBorder = iframe.width = iframe.height = 0;
8867                          }
8868  
8869                          body.appendChild( iframe );
8870  
8871                          // Create a cacheable copy of the iframe document on first call.
8872                          // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
8873                          // document to it; WebKit & Firefox won't allow reusing the iframe document.
8874                          if ( !iframeDoc || !iframe.createElement ) {
8875                                  iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
8876                                  iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
8877                                  iframeDoc.close();
8878                          }
8879  
8880                          elem = iframeDoc.createElement( nodeName );
8881  
8882                          iframeDoc.body.appendChild( elem );
8883  
8884                          display = jQuery.css( elem, "display" );
8885                          body.removeChild( iframe );
8886                  }
8887  
8888                  // Store the correct default display
8889                  elemdisplay[ nodeName ] = display;
8890          }
8891  
8892          return elemdisplay[ nodeName ];
8893  }
8894  
8895  
8896  
8897  
8898  var rtable = /^t(?:able|d|h)$/i,
8899          rroot = /^(?:body|html)$/i;
8900  
8901  if ( "getBoundingClientRect" in document.documentElement ) {
8902          jQuery.fn.offset = function( options ) {
8903                  var elem = this[0], box;
8904  
8905                  if ( options ) {
8906                          return this.each(function( i ) {
8907                                  jQuery.offset.setOffset( this, options, i );
8908                          });
8909                  }
8910  
8911                  if ( !elem || !elem.ownerDocument ) {
8912                          return null;
8913                  }
8914  
8915                  if ( elem === elem.ownerDocument.body ) {
8916                          return jQuery.offset.bodyOffset( elem );
8917                  }
8918  
8919                  try {
8920                          box = elem.getBoundingClientRect();
8921                  } catch(e) {}
8922  
8923                  var doc = elem.ownerDocument,
8924                          docElem = doc.documentElement;
8925  
8926                  // Make sure we're not dealing with a disconnected DOM node
8927                  if ( !box || !jQuery.contains( docElem, elem ) ) {
8928                          return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8929                  }
8930  
8931                  var body = doc.body,
8932                          win = getWindow(doc),
8933                          clientTop  = docElem.clientTop  || body.clientTop  || 0,
8934                          clientLeft = docElem.clientLeft || body.clientLeft || 0,
8935                          scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
8936                          scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
8937                          top  = box.top  + scrollTop  - clientTop,
8938                          left = box.left + scrollLeft - clientLeft;
8939  
8940                  return { top: top, left: left };
8941          };
8942  
8943  } else {
8944          jQuery.fn.offset = function( options ) {
8945                  var elem = this[0];
8946  
8947                  if ( options ) {
8948                          return this.each(function( i ) {
8949                                  jQuery.offset.setOffset( this, options, i );
8950                          });
8951                  }
8952  
8953                  if ( !elem || !elem.ownerDocument ) {
8954                          return null;
8955                  }
8956  
8957                  if ( elem === elem.ownerDocument.body ) {
8958                          return jQuery.offset.bodyOffset( elem );
8959                  }
8960  
8961                  var computedStyle,
8962                          offsetParent = elem.offsetParent,
8963                          prevOffsetParent = elem,
8964                          doc = elem.ownerDocument,
8965                          docElem = doc.documentElement,
8966                          body = doc.body,
8967                          defaultView = doc.defaultView,
8968                          prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8969                          top = elem.offsetTop,
8970                          left = elem.offsetLeft;
8971  
8972                  while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8973                          if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
8974                                  break;
8975                          }
8976  
8977                          computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8978                          top  -= elem.scrollTop;
8979                          left -= elem.scrollLeft;
8980  
8981                          if ( elem === offsetParent ) {
8982                                  top  += elem.offsetTop;
8983                                  left += elem.offsetLeft;
8984  
8985                                  if ( jQuery.support.doesNotAddBorder && !(jQuery.support.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8986                                          top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8987                                          left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8988                                  }
8989  
8990                                  prevOffsetParent = offsetParent;
8991                                  offsetParent = elem.offsetParent;
8992                          }
8993  
8994                          if ( jQuery.support.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8995                                  top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8996                                  left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8997                          }
8998  
8999                          prevComputedStyle = computedStyle;
9000                  }
9001  
9002                  if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
9003                          top  += body.offsetTop;
9004                          left += body.offsetLeft;
9005                  }
9006  
9007                  if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
9008                          top  += Math.max( docElem.scrollTop, body.scrollTop );
9009                          left += Math.max( docElem.scrollLeft, body.scrollLeft );
9010                  }
9011  
9012                  return { top: top, left: left };
9013          };
9014  }
9015  
9016  jQuery.offset = {
9017  
9018          bodyOffset: function( body ) {
9019                  var top = body.offsetTop,
9020                          left = body.offsetLeft;
9021  
9022                  if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
9023                          top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
9024                          left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
9025                  }
9026  
9027                  return { top: top, left: left };
9028          },
9029  
9030          setOffset: function( elem, options, i ) {
9031                  var position = jQuery.css( elem, "position" );
9032  
9033                  // set position first, in-case top/left are set even on static elem
9034                  if ( position === "static" ) {
9035                          elem.style.position = "relative";
9036                  }
9037  
9038                  var curElem = jQuery( elem ),
9039                          curOffset = curElem.offset(),
9040                          curCSSTop = jQuery.css( elem, "top" ),
9041                          curCSSLeft = jQuery.css( elem, "left" ),
9042                          calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
9043                          props = {}, curPosition = {}, curTop, curLeft;
9044  
9045                  // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
9046                  if ( calculatePosition ) {
9047                          curPosition = curElem.position();
9048                          curTop = curPosition.top;
9049                          curLeft = curPosition.left;
9050                  } else {
9051                          curTop = parseFloat( curCSSTop ) || 0;
9052                          curLeft = parseFloat( curCSSLeft ) || 0;
9053                  }
9054  
9055                  if ( jQuery.isFunction( options ) ) {
9056                          options = options.call( elem, i, curOffset );
9057                  }
9058  
9059                  if ( options.top != null ) {
9060                          props.top = ( options.top - curOffset.top ) + curTop;
9061                  }
9062                  if ( options.left != null ) {
9063                          props.left = ( options.left - curOffset.left ) + curLeft;
9064                  }
9065  
9066                  if ( "using" in options ) {
9067                          options.using.call( elem, props );
9068                  } else {
9069                          curElem.css( props );
9070                  }
9071          }
9072  };
9073  
9074  
9075  jQuery.fn.extend({
9076  
9077          position: function() {
9078                  if ( !this[0] ) {
9079                          return null;
9080                  }
9081  
9082                  var elem = this[0],
9083  
9084                  // Get *real* offsetParent
9085                  offsetParent = this.offsetParent(),
9086  
9087                  // Get correct offsets
9088                  offset       = this.offset(),
9089                  parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
9090  
9091                  // Subtract element margins
9092                  // note: when an element has margin: auto the offsetLeft and marginLeft
9093                  // are the same in Safari causing offset.left to incorrectly be 0
9094                  offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
9095                  offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
9096  
9097                  // Add offsetParent borders
9098                  parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
9099                  parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
9100  
9101                  // Subtract the two offsets
9102                  return {
9103                          top:  offset.top  - parentOffset.top,
9104                          left: offset.left - parentOffset.left
9105                  };
9106          },
9107  
9108          offsetParent: function() {
9109                  return this.map(function() {
9110                          var offsetParent = this.offsetParent || document.body;
9111                          while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
9112                                  offsetParent = offsetParent.offsetParent;
9113                          }
9114                          return offsetParent;
9115                  });
9116          }
9117  });
9118  
9119  
9120  // Create scrollLeft and scrollTop methods
9121  jQuery.each( ["Left", "Top"], function( i, name ) {
9122          var method = "scroll" + name;
9123  
9124          jQuery.fn[ method ] = function( val ) {
9125                  var elem, win;
9126  
9127                  if ( val === undefined ) {
9128                          elem = this[ 0 ];
9129  
9130                          if ( !elem ) {
9131                                  return null;
9132                          }
9133  
9134                          win = getWindow( elem );
9135  
9136                          // Return the scroll offset
9137                          return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
9138                                  jQuery.support.boxModel && win.document.documentElement[ method ] ||
9139                                          win.document.body[ method ] :
9140                                  elem[ method ];
9141                  }
9142  
9143                  // Set the scroll offset
9144                  return this.each(function() {
9145                          win = getWindow( this );
9146  
9147                          if ( win ) {
9148                                  win.scrollTo(
9149                                          !i ? val : jQuery( win ).scrollLeft(),
9150                                           i ? val : jQuery( win ).scrollTop()
9151                                  );
9152  
9153                          } else {
9154                                  this[ method ] = val;
9155                          }
9156                  });
9157          };
9158  });
9159  
9160  function getWindow( elem ) {
9161          return jQuery.isWindow( elem ) ?
9162                  elem :
9163                  elem.nodeType === 9 ?
9164                          elem.defaultView || elem.parentWindow :
9165                          false;
9166  }
9167  
9168  
9169  
9170  
9171  // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
9172  jQuery.each([ "Height", "Width" ], function( i, name ) {
9173  
9174          var type = name.toLowerCase();
9175  
9176          // innerHeight and innerWidth
9177          jQuery.fn[ "inner" + name ] = function() {
9178                  var elem = this[0];
9179                  return elem ?
9180                          elem.style ?
9181                          parseFloat( jQuery.css( elem, type, "padding" ) ) :
9182                          this[ type ]() :
9183                          null;
9184          };
9185  
9186          // outerHeight and outerWidth
9187          jQuery.fn[ "outer" + name ] = function( margin ) {
9188                  var elem = this[0];
9189                  return elem ?
9190                          elem.style ?
9191                          parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
9192                          this[ type ]() :
9193                          null;
9194          };
9195  
9196          jQuery.fn[ type ] = function( size ) {
9197                  // Get window width or height
9198                  var elem = this[0];
9199                  if ( !elem ) {
9200                          return size == null ? null : this;
9201                  }
9202  
9203                  if ( jQuery.isFunction( size ) ) {
9204                          return this.each(function( i ) {
9205                                  var self = jQuery( this );
9206                                  self[ type ]( size.call( this, i, self[ type ]() ) );
9207                          });
9208                  }
9209  
9210                  if ( jQuery.isWindow( elem ) ) {
9211                          // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
9212                          // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
9213                          var docElemProp = elem.document.documentElement[ "client" + name ],
9214                                  body = elem.document.body;
9215                          return elem.document.compatMode === "CSS1Compat" && docElemProp ||
9216                                  body && body[ "client" + name ] || docElemProp;
9217  
9218                  // Get document width or height
9219                  } else if ( elem.nodeType === 9 ) {
9220                          // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
9221                          return Math.max(
9222                                  elem.documentElement["client" + name],
9223                                  elem.body["scroll" + name], elem.documentElement["scroll" + name],
9224                                  elem.body["offset" + name], elem.documentElement["offset" + name]
9225                          );
9226  
9227                  // Get or set width or height on the element
9228                  } else if ( size === undefined ) {
9229                          var orig = jQuery.css( elem, type ),
9230                                  ret = parseFloat( orig );
9231  
9232                          return jQuery.isNumeric( ret ) ? ret : orig;
9233  
9234                  // Set the width or height on the element (default to pixels if value is unitless)
9235                  } else {
9236                          return this.css( type, typeof size === "string" ? size : size + "px" );
9237                  }
9238          };
9239  
9240  });
9241  
9242  
9243  
9244  
9245  // Expose jQuery to the global object
9246  window.jQuery = window.$ = jQuery;
9247  
9248  // Expose jQuery as an AMD module, but only for AMD loaders that
9249  // understand the issues with loading multiple versions of jQuery
9250  // in a page that all might call define(). The loader will indicate
9251  // they have special allowances for multiple jQuery versions by
9252  // specifying define.amd.jQuery = true. Register as a named module,
9253  // since jQuery can be concatenated with other files that may use define,
9254  // but not use a proper concatenation script that understands anonymous
9255  // AMD modules. A named AMD is safest and most robust way to register.
9256  // Lowercase jquery is used because AMD module names are derived from
9257  // file names, and jQuery is normally delivered in a lowercase file name.
9258  // Do this after creating the global so that if an AMD module wants to call
9259  // noConflict to hide this version of jQuery, it will work.
9260  if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
9261          define( "jquery", [], function () { return jQuery; } );
9262  }
9263  
9264  
9265  
9266  })( window );
1	/*!
2	 * jQuery JavaScript Library v1.7.1
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: Mon Nov 21 21:11:03 2011 -0500
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	        // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
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	        // Match a standalone tag
51	        rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
52	
53	        // JSON RegExp
54	        rvalidchars = /^[\],:{}\s]*$/,
55	        rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
56	        rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
57	        rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
58	
59	        // Useragent RegExp
60	        rwebkit = /(webkit)[ \/]([\w.]+)/,
61	        ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
62	        rmsie = /(msie) ([\w.]+)/,
63	        rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
64	
65	        // Matches dashed string for camelizing
66	        rdashAlpha = /-([a-z]|[0-9])/ig,
67	        rmsPrefix = /^-ms-/,
68	
69	        // Used by jQuery.camelCase as callback to replace()
70	        fcamelCase = function( all, letter ) {
71	                return ( letter + "" ).toUpperCase();
72	        },
73	
74	        // Keep a UserAgent string for use with jQuery.browser
75	        userAgent = navigator.userAgent,
76	
77	        // For matching the engine and version of the browser
78	        browserMatch,
79	
80	        // The deferred used on DOM ready
81	        readyList,
82	
83	        // The ready event handler
84	        DOMContentLoaded,
85	
86	        // Save a reference to some core methods
87	        toString = Object.prototype.toString,
88	        hasOwn = Object.prototype.hasOwnProperty,
89	        push = Array.prototype.push,
90	        slice = Array.prototype.slice,
91	        trim = String.prototype.trim,
92	        indexOf = Array.prototype.indexOf,
93	
94	        // [[Class]] -> type pairs
95	        class2type = {};
96	
97	jQuery.fn = jQuery.prototype = {
98	        constructor: jQuery,
99	        init: function( selector, context, rootjQuery ) {
100	                var match, elem, ret, doc;
101	
102	                // Handle $(""), $(null), or $(undefined)
103	                if ( !selector ) {
104	                        return this;
105	                }
106	
107	                // Handle $(DOMElement)
108	                if ( selector.nodeType ) {
109	                        this.context = this[0] = selector;
110	                        this.length = 1;
111	                        return this;
112	                }
113	
114	                // The body element only exists once, optimize finding it
115	                if ( selector === "body" && !context && document.body ) {
116	                        this.context = document;
117	                        this[0] = document.body;
118	                        this.selector = selector;
119	                        this.length = 1;
120	                        return this;
121	                }
122	
123	                // Handle HTML strings
124	                if ( typeof selector === "string" ) {
125	                        // Are we dealing with HTML string or an ID?
126	                        if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
127	                                // Assume that strings that start and end with <> are HTML and skip the regex check
128	                                match = [ null, selector, null ];
129	
130	                        } else {
131	                                match = quickExpr.exec( selector );
132	                        }
133	
134	                        // Verify a match, and that no context was specified for #id
135	                        if ( match && (match[1] || !context) ) {
136	
137	                                // HANDLE: $(html) -> $(array)
138	                                if ( match[1] ) {
139	                                        context = context instanceof jQuery ? context[0] : context;
140	                                        doc = ( context ? context.ownerDocument || context : document );
141	
142	                                        // If a single string is passed in and it's a single tag
143	                                        // just do a createElement and skip the rest
144	                                        ret = rsingleTag.exec( selector );
145	
146	                                        if ( ret ) {
147	                                                if ( jQuery.isPlainObject( context ) ) {
148	                                                        selector = [ document.createElement( ret[1] ) ];
149	                                                        jQuery.fn.attr.call( selector, context, true );
150	
151	                                                } else {
152	                                                        selector = [ doc.createElement( ret[1] ) ];
153	                                                }
154	
155	                                        } else {
156	                                                ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
157	                                                selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
158	                                        }
159	
160	                                        return jQuery.merge( this, selector );
161	
162	                                // HANDLE: $("#id")
163	                                } else {
164	                                        elem = document.getElementById( match[2] );
165	
166	                                        // Check parentNode to catch when Blackberry 4.6 returns
167	                                        // nodes that are no longer in the document #6963
168	                                        if ( elem && elem.parentNode ) {
169	                                                // Handle the case where IE and Opera return items
170	                                                // by name instead of ID
171	                                                if ( elem.id !== match[2] ) {
172	                                                        return rootjQuery.find( selector );
173	                                                }
174	
175	                                                // Otherwise, we inject the element directly into the jQuery object
176	                                                this.length = 1;
177	                                                this[0] = elem;
178	                                        }
179	
180	                                        this.context = document;
181	                                        this.selector = selector;
182	                                        return this;
183	                                }
184	
185	                        // HANDLE: $(expr, $(...))
186	                        } else if ( !context || context.jquery ) {
187	                                return ( context || rootjQuery ).find( selector );
188	
189	                        // HANDLE: $(expr, context)
190	                        // (which is just equivalent to: $(context).find(expr)
191	                        } else {
192	                                return this.constructor( context ).find( selector );
193	                        }
194	
195	                // HANDLE: $(function)
196	                // Shortcut for document ready
197	                } else if ( jQuery.isFunction( selector ) ) {
198	                        return rootjQuery.ready( selector );
199	                }
200	
201	                if ( selector.selector !== undefined ) {
202	                        this.selector = selector.selector;
203	                        this.context = selector.context;
204	                }
205	
206	                return jQuery.makeArray( selector, this );
207	        },
208	
209	        // Start with an empty selector
210	        selector: "",
211	
212	        // The current version of jQuery being used
213	        jquery: "1.7.1",
214	
215	        // The default length of a jQuery object is 0
216	        length: 0,
217	
218	        // The number of elements contained in the matched element set
219	        size: function() {
220	                return this.length;
221	        },
222	
223	        toArray: function() {
224	                return slice.call( this, 0 );
225	        },
226	
227	        // Get the Nth element in the matched element set OR
228	        // Get the whole matched element set as a clean array
229	        get: function( num ) {
230	                return num == null ?
231	
232	                        // Return a 'clean' array
233	                        this.toArray() :
234	
235	                        // Return just the object
236	                        ( num < 0 ? this[ this.length + num ] : this[ num ] );
237	        },
238	
239	        // Take an array of elements and push it onto the stack
240	        // (returning the new matched element set)
241	        pushStack: function( elems, name, selector ) {
242	                // Build a new jQuery matched element set
243	                var ret = this.constructor();
244	
245	                if ( jQuery.isArray( elems ) ) {
246	                        push.apply( ret, elems );
247	
248	                } else {
249	                        jQuery.merge( ret, elems );
250	                }
251	
252	                // Add the old object onto the stack (as a reference)
253	                ret.prevObject = this;
254	
255	                ret.context = this.context;
256	
257	                if ( name === "find" ) {
258	                        ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
259	                } else if ( name ) {
260	                        ret.selector = this.selector + "." + name + "(" + selector + ")";
261	                }
262	
263	                // Return the newly-formed element set
264	                return ret;
265	        },
266	
267	        // Execute a callback for every element in the matched set.
268	        // (You can seed the arguments with an array of args, but this is
269	        // only used internally.)
270	        each: function( callback, args ) {
271	                return jQuery.each( this, callback, args );
272	        },
273	
274	        ready: function( fn ) {
275	                // Attach the listeners
276	                jQuery.bindReady();
277	
278	                // Add the callback
279	                readyList.add( fn );
280	
281	                return this;
282	        },
283	
284	        eq: function( i ) {
285	                i = +i;
286	                return i === -1 ?
287	                        this.slice( i ) :
288	                        this.slice( i, i + 1 );
289	        },
290	
291	        first: function() {
292	                return this.eq( 0 );
293	        },
294	
295	        last: function() {
296	                return this.eq( -1 );
297	        },
298	
299	        slice: function() {
300	                return this.pushStack( slice.apply( this, arguments ),
301	                        "slice", slice.call(arguments).join(",") );
302	        },
303	
304	        map: function( callback ) {
305	                return this.pushStack( jQuery.map(this, function( elem, i ) {
306	                        return callback.call( elem, i, elem );
307	                }));
308	        },
309	
310	        end: function() {
311	                return this.prevObject || this.constructor(null);
312	        },
313	
314	        // For internal use only.
315	        // Behaves like an Array's method, not like a jQuery method.
316	        push: push,
317	        sort: [].sort,
318	        splice: [].splice
319	};
320	
321	// Give the init function the jQuery prototype for later instantiation
322	jQuery.fn.init.prototype = jQuery.fn;
323	
324	jQuery.extend = jQuery.fn.extend = function() {
325	        var options, name, src, copy, copyIsArray, clone,
326	                target = arguments[0] || {},
327	                i = 1,
328	                length = arguments.length,
329	                deep = false;
330	
331	        // Handle a deep copy situation
332	        if ( typeof target === "boolean" ) {
333	                deep = target;
334	                target = arguments[1] || {};
335	                // skip the boolean and the target
336	                i = 2;
337	        }
338	
339	        // Handle case when target is a string or something (possible in deep copy)
340	        if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
341	                target = {};
342	        }
343	
344	        // extend jQuery itself if only one argument is passed
345	        if ( length === i ) {
346	                target = this;
347	                --i;
348	        }
349	
350	        for ( ; i < length; i++ ) {
351	                // Only deal with non-null/undefined values
352	                if ( (options = arguments[ i ]) != null ) {
353	                        // Extend the base object
354	                        for ( name in options ) {
355	                                src = target[ name ];
356	                                copy = options[ name ];
357	
358	                                // Prevent never-ending loop
359	                                if ( target === copy ) {
360	                                        continue;
361	                                }
362	
363	                                // Recurse if we're merging plain objects or arrays
364	                                if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
365	                                        if ( copyIsArray ) {
366	                                                copyIsArray = false;
367	                                                clone = src && jQuery.isArray(src) ? src : [];
368	
369	                                        } else {
370	                                                clone = src && jQuery.isPlainObject(src) ? src : {};
371	                                        }
372	
373	                                        // Never move original objects, clone them
374	                                        target[ name ] = jQuery.extend( deep, clone, copy );
375	
376	                                // Don't bring in undefined values
377	                                } else if ( copy !== undefined ) {
378	                                        target[ name ] = copy;
379	                                }
380	                        }
381	                }
382	        }
383	
384	        // Return the modified object
385	        return target;
386	};
387	
388	jQuery.extend({
389	        noConflict: function( deep ) {
390	                if ( window.$ === jQuery ) {
391	                        window.$ = _$;
392	                }
393	
394	                if ( deep && window.jQuery === jQuery ) {
395	                        window.jQuery = _jQuery;
396	                }
397	
398	                return jQuery;
399	        },
400	
401	        // Is the DOM ready to be used? Set to true once it occurs.
402	        isReady: false,
403	
404	        // A counter to track how many items to wait for before
405	        // the ready event fires. See #6781
406	        readyWait: 1,
407	
408	        // Hold (or release) the ready event
409	        holdReady: function( hold ) {
410	                if ( hold ) {
411	                        jQuery.readyWait++;
412	                } else {
413	                        jQuery.ready( true );
414	                }
415	        },
416	
417	        // Handle when the DOM is ready
418	        ready: function( wait ) {
419	                // Either a released hold or an DOMready/load event and not yet ready
420	                if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
421	                        // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
422	                        if ( !document.body ) {
423	                                return setTimeout( jQuery.ready, 1 );
424	                        }
425	
426	                        // Remember that the DOM is ready
427	                        jQuery.isReady = true;
428	
429	                        // If a normal DOM Ready event fired, decrement, and wait if need be
430	                        if ( wait !== true && --jQuery.readyWait > 0 ) {
431	                                return;
432	                        }
433	
434	                        // If there are functions bound, to execute
435	                        readyList.fireWith( document, [ jQuery ] );
436	
437	                        // Trigger any bound ready events
438	                        if ( jQuery.fn.trigger ) {
439	                                jQuery( document ).trigger( "ready" ).off( "ready" );
440	                        }
441	                }
442	        },
443	
444	        bindReady: function() {
445	                if ( readyList ) {
446	                        return;
447	                }
448	
449	                readyList = jQuery.Callbacks( "once memory" );
450	
451	                // Catch cases where $(document).ready() is called after the
452	                // browser event has already occurred.
453	                if ( document.readyState === "complete" ) {
454	                        // Handle it asynchronously to allow scripts the opportunity to delay ready
455	                        return setTimeout( jQuery.ready, 1 );
456	                }
457	
458	                // Mozilla, Opera and webkit nightlies currently support this event
459	                if ( document.addEventListener ) {
460	                        // Use the handy event callback
461	                        document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
462	
463	                        // A fallback to window.onload, that will always work
464	                        window.addEventListener( "load", jQuery.ready, false );
465	
466	                // If IE event model is used
467	                } else if ( document.attachEvent ) {
468	                        // ensure firing before onload,
469	                        // maybe late but safe also for iframes
470	                        document.attachEvent( "onreadystatechange", DOMContentLoaded );
471	
472	                        // A fallback to window.onload, that will always work
473	                        window.attachEvent( "onload", jQuery.ready );
474	
475	                        // If IE and not a frame
476	                        // continually check to see if the document is ready
477	                        var toplevel = false;
478	
479	                        try {
480	                                toplevel = window.frameElement == null;
481	                        } catch(e) {}
482	
483	                        if ( document.documentElement.doScroll && toplevel ) {
484	                                doScrollCheck();
485	                        }
486	                }
487	        },
488	
489	        // See test/unit/core.js for details concerning isFunction.
490	        // Since version 1.3, DOM methods and functions like alert
491	        // aren't supported. They return false on IE (#2968).
492	        isFunction: function( obj ) {
493	                return jQuery.type(obj) === "function";
494	        },
495	
496	        isArray: Array.isArray || function( obj ) {
497	                return jQuery.type(obj) === "array";
498	        },
499	
500	        // A crude way of determining if an object is a window
501	        isWindow: function( obj ) {
502	                return obj && typeof obj === "object" && "setInterval" in obj;
503	        },
504	
505	        isNumeric: function( obj ) {
506	                return !isNaN( parseFloat(obj) ) && isFinite( obj );
507	        },
508	
509	        type: function( obj ) {
510	                return obj == null ?
511	                        String( obj ) :
512	                        class2type[ toString.call(obj) ] || "object";
513	        },
514	
515	        isPlainObject: function( obj ) {
516	                // Must be an Object.
517	                // Because of IE, we also have to check the presence of the constructor property.
518	                // Make sure that DOM nodes and window objects don't pass through, as well
519	                if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
520	                        return false;
521	                }
522	
523	                try {
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	                } catch ( e ) {
531	                        // IE8,9 Will throw exceptions on certain host objects #9897
532	                        return false;
533	                }
534	
535	                // Own properties are enumerated firstly, so to speed up,
536	                // if last one is own, then all properties are own.
537	
538	                var key;
539	                for ( key in obj ) {}
540	
541	                return key === undefined || hasOwn.call( obj, key );
542	        },
543	
544	        isEmptyObject: function( obj ) {
545	                for ( var name in obj ) {
546	                        return false;
547	                }
548	                return true;
549	        },
550	
551	        error: function( msg ) {
552	                throw new Error( msg );
553	        },
554	
555	        parseJSON: function( data ) {
556	                if ( typeof data !== "string" || !data ) {
557	                        return null;
558	                }
559	
560	                // Make sure leading/trailing whitespace is removed (IE can't handle it)
561	                data = jQuery.trim( data );
562	
563	                // Attempt to parse using the native JSON parser first
564	                if ( window.JSON && window.JSON.parse ) {
565	                        return window.JSON.parse( data );
566	                }
567	
568	                // Make sure the incoming data is actual JSON
569	                // Logic borrowed from http://json.org/json2.js
570	                if ( rvalidchars.test( data.replace( rvalidescape, "@" )
571	                        .replace( rvalidtokens, "]" )
572	                        .replace( rvalidbraces, "")) ) {
573	
574	                        return ( new Function( "return " + data ) )();
575	
576	                }
577	                jQuery.error( "Invalid JSON: " + data );
578	        },
579	
580	        // Cross-browser xml parsing
581	        parseXML: function( data ) {
582	                var xml, tmp;
583	                try {
584	                        if ( window.DOMParser ) { // Standard
585	                                tmp = new DOMParser();
586	                                xml = tmp.parseFromString( data , "text/xml" );
587	                        } else { // IE
588	                                xml = new ActiveXObject( "Microsoft.XMLDOM" );
589	                                xml.async = "false";
590	                                xml.loadXML( data );
591	                        }
592	                } catch( e ) {
593	                        xml = undefined;
594	                }
595	                if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
596	                        jQuery.error( "Invalid XML: " + data );
597	                }
598	                return xml;
599	        },
600	
601	        noop: function() {},
602	
603	        // Evaluates a script in a global context
604	        // Workarounds based on findings by Jim Driscoll
605	        // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
606	        globalEval: function( data ) {
607	                if ( data && rnotwhite.test( data ) ) {
608	                        // We use execScript on Internet Explorer
609	                        // We use an anonymous function so that context is window
610	                        // rather than jQuery in Firefox
611	                        ( window.execScript || function( data ) {
612	                                window[ "eval" ].call( window, data );
613	                        } )( data );
614	                }
615	        },
616	
617	        // Convert dashed to camelCase; used by the css and data modules
618	        // Microsoft forgot to hump their vendor prefix (#9572)
619	        camelCase: function( string ) {
620	                return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
621	        },
622	
623	        nodeName: function( elem, name ) {
624	                return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
625	        },
626	
627	        // args is for internal usage only
628	        each: function( object, callback, args ) {
629	                var name, i = 0,
630	                        length = object.length,
631	                        isObj = length === undefined || jQuery.isFunction( object );
632	
633	                if ( args ) {
634	                        if ( isObj ) {
635	                                for ( name in object ) {
636	                                        if ( callback.apply( object[ name ], args ) === false ) {
637	                                                break;
638	                                        }
639	                                }
640	                        } else {
641	                                for ( ; i < length; ) {
642	                                        if ( callback.apply( object[ i++ ], args ) === false ) {
643	                                                break;
644	                                        }
645	                                }
646	                        }
647	
648	                // A special, fast, case for the most common use of each
649	                } else {
650	                        if ( isObj ) {
651	                                for ( name in object ) {
652	                                        if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
653	                                                break;
654	                                        }
655	                                }
656	                        } else {
657	                                for ( ; i < length; ) {
658	                                        if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
659	                                                break;
660	                                        }
661	                                }
662	                        }
663	                }
664	
665	                return object;
666	        },
667	
668	        // Use native String.trim function wherever possible
669	        trim: trim ?
670	                function( text ) {
671	                        return text == null ?
672	                                "" :
673	                                trim.call( text );
674	                } :
675	
676	                // Otherwise use our own trimming functionality
677	                function( text ) {
678	                        return text == null ?
679	                                "" :
680	                                text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
681	                },
682	
683	        // results is for internal usage only
684	        makeArray: function( array, results ) {
685	                var ret = results || [];
686	
687	                if ( array != null ) {
688	                        // The window, strings (and functions) also have 'length'
689	                        // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
690	                        var type = jQuery.type( array );
691	
692	                        if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
693	                                push.call( ret, array );
694	                        } else {
695	                                jQuery.merge( ret, array );
696	                        }
697	                }
698	
699	                return ret;
700	        },
701	
702	        inArray: function( elem, array, i ) {
703	                var len;
704	
705	                if ( array ) {
706	                        if ( indexOf ) {
707	                                return indexOf.call( array, elem, i );
708	                        }
709	
710	                        len = array.length;
711	                        i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
712	
713	                        for ( ; i < len; i++ ) {
714	                                // Skip accessing in sparse arrays
715	                                if ( i in array && array[ i ] === elem ) {
716	                                        return i;
717	                                }
718	                        }
719	                }
720	
721	                return -1;
722	        },
723	
724	        merge: function( first, second ) {
725	                var i = first.length,
726	                        j = 0;
727	
728	                if ( typeof second.length === "number" ) {
729	                        for ( var l = second.length; j < l; j++ ) {
730	                                first[ i++ ] = second[ j ];
731	                        }
732	
733	                } else {
734	                        while ( second[j] !== undefined ) {
735	                                first[ i++ ] = second[ j++ ];
736	                        }
737	                }
738	
739	                first.length = i;
740	
741	                return first;
742	        },
743	
744	        grep: function( elems, callback, inv ) {
745	                var ret = [], retVal;
746	                inv = !!inv;
747	
748	                // Go through the array, only saving the items
749	                // that pass the validator function
750	                for ( var i = 0, length = elems.length; i < length; i++ ) {
751	                        retVal = !!callback( elems[ i ], i );
752	                        if ( inv !== retVal ) {
753	                                ret.push( elems[ i ] );
754	                        }
755	                }
756	
757	                return ret;
758	        },
759	
760	        // arg is for internal usage only
761	        map: function( elems, callback, arg ) {
762	                var value, key, ret = [],
763	                        i = 0,
764	                        length = elems.length,
765	                        // jquery objects are treated as arrays
766	                        isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
767	
768	                // Go through the array, translating each of the items to their
769	                if ( isArray ) {
770	                        for ( ; i < length; i++ ) {
771	                                value = callback( elems[ i ], i, arg );
772	
773	                                if ( value != null ) {
774	                                        ret[ ret.length ] = value;
775	                                }
776	                        }
777	
778	                // Go through every key on the object,
779	                } else {
780	                        for ( key in elems ) {
781	                                value = callback( elems[ key ], key, arg );
782	
783	                                if ( value != null ) {
784	                                        ret[ ret.length ] = value;
785	                                }
786	                        }
787	                }
788	
789	                // Flatten any nested arrays
790	                return ret.concat.apply( [], ret );
791	        },
792	
793	        // A global GUID counter for objects
794	        guid: 1,
795	
796	        // Bind a function to a context, optionally partially applying any
797	        // arguments.
798	        proxy: function( fn, context ) {
799	                if ( typeof context === "string" ) {
800	                        var tmp = fn[ context ];
801	                        context = fn;
802	                        fn = tmp;
803	                }
804	
805	                // Quick check to determine if target is callable, in the spec
806	                // this throws a TypeError, but we will just return undefined.
807	                if ( !jQuery.isFunction( fn ) ) {
808	                        return undefined;
809	                }
810	
811	                // Simulated bind
812	                var args = slice.call( arguments, 2 ),
813	                        proxy = function() {
814	                                return fn.apply( context, args.concat( slice.call( arguments ) ) );
815	                        };
816	
817	                // Set the guid of unique handler to the same of original handler, so it can be removed
818	                proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
819	
820	                return proxy;
821	        },
822	
823	        // Mutifunctional method to get and set values to a collection
824	        // The value/s can optionally be executed if it's a function
825	        access: function( elems, key, value, exec, fn, pass ) {
826	                var length = elems.length;
827	
828	                // Setting many attributes
829	                if ( typeof key === "object" ) {
830	                        for ( var k in key ) {
831	                                jQuery.access( elems, k, key[k], exec, fn, value );
832	                        }
833	                        return elems;
834	                }
835	
836	                // Setting one attribute
837	                if ( value !== undefined ) {
838	                        // Optionally, function values get executed if exec is true
839	                        exec = !pass && exec && jQuery.isFunction(value);
840	
841	                        for ( var i = 0; i < length; i++ ) {
842	                                fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
843	                        }
844	
845	                        return elems;
846	                }
847	
848	                // Getting an attribute
849	                return length ? fn( elems[0], key ) : undefined;
850	        },
851	
852	        now: function() {
853	                return ( new Date() ).getTime();
854	        },
855	
856	        // Use of jQuery.browser is frowned upon.
857	        // More details: http://docs.jquery.com/Utilities/jQuery.browser
858	        uaMatch: function( ua ) {
859	                ua = ua.toLowerCase();
860	
861	                var match = rwebkit.exec( ua ) ||
862	                        ropera.exec( ua ) ||
863	                        rmsie.exec( ua ) ||
864	                        ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
865	                        [];
866	
867	                return { browser: match[1] || "", version: match[2] || "0" };
868	        },
869	
870	        sub: function() {
871	                function jQuerySub( selector, context ) {
872	                        return new jQuerySub.fn.init( selector, context );
873	                }
874	                jQuery.extend( true, jQuerySub, this );
875	                jQuerySub.superclass = this;
876	                jQuerySub.fn = jQuerySub.prototype = this();
877	                jQuerySub.fn.constructor = jQuerySub;
878	                jQuerySub.sub = this.sub;
879	                jQuerySub.fn.init = function init( selector, context ) {
880	                        if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
881	                                context = jQuerySub( context );
882	                        }
883	
884	                        return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
885	                };
886	                jQuerySub.fn.init.prototype = jQuerySub.fn;
887	                var rootjQuerySub = jQuerySub(document);
888	                return jQuerySub;
889	        },
890	
891	        browser: {}
892	});
893	
894	// Populate the class2type map
895	jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
896	        class2type[ "[object " + name + "]" ] = name.toLowerCase();
897	});
898	
899	browserMatch = jQuery.uaMatch( userAgent );
900	if ( browserMatch.browser ) {
901	        jQuery.browser[ browserMatch.browser ] = true;
902	        jQuery.browser.version = browserMatch.version;
903	}
904	
905	// Deprecated, use jQuery.browser.webkit instead
906	if ( jQuery.browser.webkit ) {
907	        jQuery.browser.safari = true;
908	}
909	
910	// IE doesn't match non-breaking spaces with \s
911	if ( rnotwhite.test( "\xA0" ) ) {
912	        trimLeft = /^[\s\xA0]+/;
913	        trimRight = /[\s\xA0]+$/;
914	}
915	
916	// All jQuery objects should point back to these
917	rootjQuery = jQuery(document);
918	
919	// Cleanup functions for the document ready method
920	if ( document.addEventListener ) {
921	        DOMContentLoaded = function() {
922	                document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
923	                jQuery.ready();
924	        };
925	
926	} else if ( document.attachEvent ) {
927	        DOMContentLoaded = function() {
928	                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
929	                if ( document.readyState === "complete" ) {
930	                        document.detachEvent( "onreadystatechange", DOMContentLoaded );
931	                        jQuery.ready();
932	                }
933	        };
934	}
935	
936	// The DOM ready check for Internet Explorer
937	function doScrollCheck() {
938	        if ( jQuery.isReady ) {
939	                return;
940	        }
941	
942	        try {
943	                // If IE is used, use the trick by Diego Perini
944	                // http://javascript.nwbox.com/IEContentLoaded/
945	                document.documentElement.doScroll("left");
946	        } catch(e) {
947	                setTimeout( doScrollCheck, 1 );
948	                return;
949	        }
950	
951	        // and execute any waiting functions
952	        jQuery.ready();
953	}
954	
955	return jQuery;
956	
957	})();
958	
959	
960	// String to Object flags format cache
961	var flagsCache = {};
962	
963	// Convert String-formatted flags into Object-formatted ones and store in cache
964	function createFlags( flags ) {
965	        var object = flagsCache[ flags ] = {},
966	                i, length;
967	        flags = flags.split( /\s+/ );
968	        for ( i = 0, length = flags.length; i < length; i++ ) {
969	                object[ flags[i] ] = true;
970	        }
971	        return object;
972	}
973	
974	/*
975	 * Create a callback list using the following parameters:
976	 *
977	 *      flags:  an optional list of space-separated flags that will change how
978	 *                      the callback list behaves
979	 *
980	 * By default a callback list will act like an event callback list and can be
981	 * "fired" multiple times.
982	 *
983	 * Possible flags:
984	 *
985	 *      once:                   will ensure the callback list can only be fired once (like a Deferred)
986	 *
987	 *      memory:                 will keep track of previous values and will call any callback added
988	 *                                      after the list has been fired right away with the latest "memorized"
989	 *                                      values (like a Deferred)
990	 *
991	 *      unique:                 will ensure a callback can only be added once (no duplicate in the list)
992	 *
993	 *      stopOnFalse:    interrupt callings when a callback returns false
994	 *
995	 */
996	jQuery.Callbacks = function( flags ) {
997	
998	        // Convert flags from String-formatted to Object-formatted
999	        // (we check in cache first)
1000	        flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1001	
1002	        var // Actual callback list
1003	                list = [],
1004	                // Stack of fire calls for repeatable lists
1005	                stack = [],
1006	                // Last fire value (for non-forgettable lists)
1007	                memory,
1008	                // Flag to know if list is currently firing
1009	                firing,
1010	                // First callback to fire (used internally by add and fireWith)
1011	                firingStart,
1012	                // End of the loop when firing
1013	                firingLength,
1014	                // Index of currently firing callback (modified by remove if needed)
1015	                firingIndex,
1016	                // Add one or several callbacks to the list
1017	                add = function( args ) {
1018	                        var i,
1019	                                length,
1020	                                elem,
1021	                                type,
1022	                                actual;
1023	                        for ( i = 0, length = args.length; i < length; i++ ) {
1024	                                elem = args[ i ];
1025	                                type = jQuery.type( elem );
1026	                                if ( type === "array" ) {
1027	                                        // Inspect recursively
1028	                                        add( elem );
1029	                                } else if ( type === "function" ) {
1030	                                        // Add if not in unique mode and callback is not in
1031	                                        if ( !flags.unique || !self.has( elem ) ) {
1032	                                                list.push( elem );
1033	                                        }
1034	                                }
1035	                        }
1036	                },
1037	                // Fire callbacks
1038	                fire = function( context, args ) {
1039	                        args = args || [];
1040	                        memory = !flags.memory || [ context, args ];
1041	                        firing = true;
1042	                        firingIndex = firingStart || 0;
1043	                        firingStart = 0;
1044	                        firingLength = list.length;
1045	                        for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1046	                                if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1047	                                        memory = true; // Mark as halted
1048	                                        break;
1049	                                }
1050	                        }
1051	                        firing = false;
1052	                        if ( list ) {
1053	                                if ( !flags.once ) {
1054	                                        if ( stack && stack.length ) {
1055	                                                memory = stack.shift();
1056	                                                self.fireWith( memory[ 0 ], memory[ 1 ] );
1057	                                        }
1058	                                } else if ( memory === true ) {
1059	                                        self.disable();
1060	                                } else {
1061	                                        list = [];
1062	                                }
1063	                        }
1064	                },
1065	                // Actual Callbacks object
1066	                self = {
1067	                        // Add a callback or a collection of callbacks to the list
1068	                        add: function() {
1069	                                if ( list ) {
1070	                                        var length = list.length;
1071	                                        add( arguments );
1072	                                        // Do we need to add the callbacks to the
1073	                                        // current firing batch?
1074	                                        if ( firing ) {
1075	                                                firingLength = list.length;
1076	                                        // With memory, if we're not firing then
1077	                                        // we should call right away, unless previous
1078	                                        // firing was halted (stopOnFalse)
1079	                                        } else if ( memory && memory !== true ) {
1080	                                                firingStart = length;
1081	                                                fire( memory[ 0 ], memory[ 1 ] );
1082	                                        }
1083	                                }
1084	                                return this;
1085	                        },
1086	                        // Remove a callback from the list
1087	                        remove: function() {
1088	                                if ( list ) {
1089	                                        var args = arguments,
1090	                                                argIndex = 0,
1091	                                                argLength = args.length;
1092	                                        for ( ; argIndex < argLength ; argIndex++ ) {
1093	                                                for ( var i = 0; i < list.length; i++ ) {
1094	                                                        if ( args[ argIndex ] === list[ i ] ) {
1095	                                                                // Handle firingIndex and firingLength
1096	                                                                if ( firing ) {
1097	                                                                        if ( i <= firingLength ) {
1098	                                                                                firingLength--;
1099	                                                                                if ( i <= firingIndex ) {
1100	                                                                                        firingIndex--;
1101	                                                                                }
1102	                                                                        }
1103	                                                                }
1104	                                                                // Remove the element
1105	                                                                list.splice( i--, 1 );
1106	                                                                // If we have some unicity property then
1107	                                                                // we only need to do this once
1108	                                                                if ( flags.unique ) {
1109	                                                                        break;
1110	                                                                }
1111	                                                        }
1112	                                                }
1113	                                        }
1114	                                }
1115	                                return this;
1116	                        },
1117	                        // Control if a given callback is in the list
1118	                        has: function( fn ) {
1119	                                if ( list ) {
1120	                                        var i = 0,
1121	                                                length = list.length;
1122	                                        for ( ; i < length; i++ ) {
1123	                                                if ( fn === list[ i ] ) {
1124	                                                        return true;
1125	                                                }
1126	                                        }
1127	                                }
1128	                                return false;
1129	                        },
1130	                        // Remove all callbacks from the list
1131	                        empty: function() {
1132	                                list = [];
1133	                                return this;
1134	                        },
1135	                        // Have the list do nothing anymore
1136	                        disable: function() {
1137	                                list = stack = memory = undefined;
1138	                                return this;
1139	                        },
1140	                        // Is it disabled?
1141	                        disabled: function() {
1142	                                return !list;
1143	                        },
1144	                        // Lock the list in its current state
1145	                        lock: function() {
1146	                                stack = undefined;
1147	                                if ( !memory || memory === true ) {
1148	                                        self.disable();
1149	                                }
1150	                                return this;
1151	                        },
1152	                        // Is it locked?
1153	                        locked: function() {
1154	                                return !stack;
1155	                        },
1156	                        // Call all callbacks with the given context and arguments
1157	                        fireWith: function( context, args ) {
1158	                                if ( stack ) {
1159	                                        if ( firing ) {
1160	                                                if ( !flags.once ) {
1161	                                                        stack.push( [ context, args ] );
1162	                                                }
1163	                                        } else if ( !( flags.once && memory ) ) {
1164	                                                fire( context, args );
1165	                                        }
1166	                                }
1167	                                return this;
1168	                        },
1169	                        // Call all the callbacks with the given arguments
1170	                        fire: function() {
1171	                                self.fireWith( this, arguments );
1172	                                return this;
1173	                        },
1174	                        // To know if the callbacks have already been called at least once
1175	                        fired: function() {
1176	                                return !!memory;
1177	                        }
1178	                };
1179	
1180	        return self;
1181	};
1182	
1183	
1184	
1185	
1186	var // Static reference to slice
1187	        sliceDeferred = [].slice;
1188	
1189	jQuery.extend({
1190	
1191	        Deferred: function( func ) {
1192	                var doneList = jQuery.Callbacks( "once memory" ),
1193	                        failList = jQuery.Callbacks( "once memory" ),
1194	                        progressList = jQuery.Callbacks( "memory" ),
1195	                        state = "pending",
1196	                        lists = {
1197	                                resolve: doneList,
1198	                                reject: failList,
1199	                                notify: progressList
1200	                        },
1201	                        promise = {
1202	                                done: doneList.add,
1203	                                fail: failList.add,
1204	                                progress: progressList.add,
1205	
1206	                                state: function() {
1207	                                        return state;
1208	                                },
1209	
1210	                                // Deprecated
1211	                                isResolved: doneList.fired,
1212	                                isRejected: failList.fired,
1213	
1214	                                then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1215	                                        deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1216	                                        return this;
1217	                                },
1218	                                always: function() {
1219	                                        deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1220	                                        return this;
1221	                                },
1222	                                pipe: function( fnDone, fnFail, fnProgress ) {
1223	                                        return jQuery.Deferred(function( newDefer ) {
1224	                                                jQuery.each( {
1225	                                                        done: [ fnDone, "resolve" ],
1226	                                                        fail: [ fnFail, "reject" ],
1227	                                                        progress: [ fnProgress, "notify" ]
1228	                                                }, function( handler, data ) {
1229	                                                        var fn = data[ 0 ],
1230	                                                                action = data[ 1 ],
1231	                                                                returned;
1232	                                                        if ( jQuery.isFunction( fn ) ) {
1233	                                                                deferred[ handler ](function() {
1234	                                                                        returned = fn.apply( this, arguments );
1235	                                                                        if ( returned && jQuery.isFunction( returned.promise ) ) {
1236	                                                                                returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1237	                                                                        } else {
1238	                                                                                newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1239	                                                                        }
1240	                                                                });
1241	                                                        } else {
1242	                                                                deferred[ handler ]( newDefer[ action ] );
1243	                                                        }
1244	                                                });
1245	                                        }).promise();
1246	                                },
1247	                                // Get a promise for this deferred
1248	                                // If obj is provided, the promise aspect is added to the object
1249	                                promise: function( obj ) {
1250	                                        if ( obj == null ) {
1251	                                                obj = promise;
1252	                                        } else {
1253	                                                for ( var key in promise ) {
1254	                                                        obj[ key ] = promise[ key ];
1255	                                                }
1256	                                        }
1257	                                        return obj;
1258	                                }
1259	                        },
1260	                        deferred = promise.promise({}),
1261	                        key;
1262	
1263	                for ( key in lists ) {
1264	                        deferred[ key ] = lists[ key ].fire;
1265	                        deferred[ key + "With" ] = lists[ key ].fireWith;
1266	                }
1267	
1268	                // Handle state
1269	                deferred.done( function() {
1270	                        state = "resolved";
1271	                }, failList.disable, progressList.lock ).fail( function() {
1272	                        state = "rejected";
1273	                }, doneList.disable, progressList.lock );
1274	
1275	                // Call given func if any
1276	                if ( func ) {
1277	                        func.call( deferred, deferred );
1278	                }
1279	
1280	                // All done!
1281	                return deferred;
1282	        },
1283	
1284	        // Deferred helper
1285	        when: function( firstParam ) {
1286	                var args = sliceDeferred.call( arguments, 0 ),
1287	                        i = 0,
1288	                        length = args.length,
1289	                        pValues = new Array( length ),
1290	                        count = length,
1291	                        pCount = length,
1292	                        deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1293	                                firstParam :
1294	                                jQuery.Deferred(),
1295	                        promise = deferred.promise();
1296	                function resolveFunc( i ) {
1297	                        return function( value ) {
1298	                                args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1299	                                if ( !( --count ) ) {
1300	                                        deferred.resolveWith( deferred, args );
1301	                                }
1302	                        };
1303	                }
1304	                function progressFunc( i ) {
1305	                        return function( value ) {
1306	                                pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1307	                                deferred.notifyWith( promise, pValues );
1308	                        };
1309	                }
1310	                if ( length > 1 ) {
1311	                        for ( ; i < length; i++ ) {
1312	                                if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1313	                                        args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1314	                                } else {
1315	                                        --count;
1316	                                }
1317	                        }
1318	                        if ( !count ) {
1319	                                deferred.resolveWith( deferred, args );
1320	                        }
1321	                } else if ( deferred !== firstParam ) {
1322	                        deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1323	                }
1324	                return promise;
1325	        }
1326	});
1327	
1328	
1329	
1330	
1331	jQuery.support = (function() {
1332	
1333	        var support,
1334	                all,
1335	                a,
1336	                select,
1337	                opt,
1338	                input,
1339	                marginDiv,
1340	                fragment,
1341	                tds,
1342	                events,
1343	                eventName,
1344	                i,
1345	                isSupported,
1346	                div = document.createElement( "div" ),
1347	                documentElement = document.documentElement;
1348	
1349	        // Preliminary tests
1350	        div.setAttribute("className", "t");
1351	        div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1352	
1353	        all = div.getElementsByTagName( "*" );
1354	        a = div.getElementsByTagName( "a" )[ 0 ];
1355	
1356	        // Can't get basic test support
1357	        if ( !all || !all.length || !a ) {
1358	                return {};
1359	        }
1360	
1361	        // First batch of supports tests
1362	        select = document.createElement( "select" );
1363	        opt = select.appendChild( document.createElement("option") );
1364	        input = div.getElementsByTagName( "input" )[ 0 ];
1365	
1366	        support = {
1367	                // IE strips leading whitespace when .innerHTML is used
1368	                leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1369	
1370	                // Make sure that tbody elements aren't automatically inserted
1371	                // IE will insert them into empty tables
1372	                tbody: !div.getElementsByTagName("tbody").length,
1373	
1374	                // Make sure that link elements get serialized correctly by innerHTML
1375	                // This requires a wrapper element in IE
1376	                htmlSerialize: !!div.getElementsByTagName("link").length,
1377	
1378	                // Get the style information from getAttribute
1379	                // (IE uses .cssText instead)
1380	                style: /top/.test( a.getAttribute("style") ),
1381	
1382	                // Make sure that URLs aren't manipulated
1383	                // (IE normalizes it by default)
1384	                hrefNormalized: ( a.getAttribute("href") === "/a" ),
1385	
1386	                // Make sure that element opacity exists
1387	                // (IE uses filter instead)
1388	                // Use a regex to work around a WebKit issue. See #5145
1389	                opacity: /^0.55/.test( a.style.opacity ),
1390	
1391	                // Verify style float existence
1392	                // (IE uses styleFloat instead of cssFloat)
1393	                cssFloat: !!a.style.cssFloat,
1394	
1395	                // Make sure that if no value is specified for a checkbox
1396	                // that it defaults to "on".
1397	                // (WebKit defaults to "" instead)
1398	                checkOn: ( input.value === "on" ),
1399	
1400	                // Make sure that a selected-by-default option has a working selected property.
1401	                // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1402	                optSelected: opt.selected,
1403	
1404	                // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1405	                getSetAttribute: div.className !== "t",
1406	
1407	                // Tests for enctype support on a form(#6743)
1408	                enctype: !!document.createElement("form").enctype,
1409	
1410	                // Makes sure cloning an html5 element does not cause problems
1411	                // Where outerHTML is undefined, this still works
1412	                html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1413	
1414	                // Will be defined later
1415	                submitBubbles: true,
1416	                changeBubbles: true,
1417	                focusinBubbles: false,
1418	                deleteExpando: true,
1419	                noCloneEvent: true,
1420	                inlineBlockNeedsLayout: false,
1421	                shrinkWrapBlocks: false,
1422	                reliableMarginRight: true
1423	        };
1424	
1425	        // Make sure checked status is properly cloned
1426	        input.checked = true;
1427	        support.noCloneChecked = input.cloneNode( true ).checked;
1428	
1429	        // Make sure that the options inside disabled selects aren't marked as disabled
1430	        // (WebKit marks them as disabled)
1431	        select.disabled = true;
1432	        support.optDisabled = !opt.disabled;
1433	
1434	        // Test to see if it's possible to delete an expando from an element
1435	        // Fails in Internet Explorer
1436	        try {
1437	                delete div.test;
1438	        } catch( e ) {
1439	                support.deleteExpando = false;
1440	        }
1441	
1442	        if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1443	                div.attachEvent( "onclick", function() {
1444	                        // Cloning a node shouldn't copy over any
1445	                        // bound event handlers (IE does this)
1446	                        support.noCloneEvent = false;
1447	                });
1448	                div.cloneNode( true ).fireEvent( "onclick" );
1449	        }
1450	
1451	        // Check if a radio maintains its value
1452	        // after being appended to the DOM
1453	        input = document.createElement("input");
1454	        input.value = "t";
1455	        input.setAttribute("type", "radio");
1456	        support.radioValue = input.value === "t";
1457	
1458	        input.setAttribute("checked", "checked");
1459	        div.appendChild( input );
1460	        fragment = document.createDocumentFragment();
1461	        fragment.appendChild( div.lastChild );
1462	
1463	        // WebKit doesn't clone checked state correctly in fragments
1464	        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1465	
1466	        // Check if a disconnected checkbox will retain its checked
1467	        // value of true after appended to the DOM (IE6/7)
1468	        support.appendChecked = input.checked;
1469	
1470	        fragment.removeChild( input );
1471	        fragment.appendChild( div );
1472	
1473	        div.innerHTML = "";
1474	
1475	        // Check if div with explicit width and no margin-right incorrectly
1476	        // gets computed margin-right based on width of container. For more
1477	        // info see bug #3333
1478	        // Fails in WebKit before Feb 2011 nightlies
1479	        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1480	        if ( window.getComputedStyle ) {
1481	                marginDiv = document.createElement( "div" );
1482	                marginDiv.style.width = "0";
1483	                marginDiv.style.marginRight = "0";
1484	                div.style.width = "2px";
1485	                div.appendChild( marginDiv );
1486	                support.reliableMarginRight =
1487	                        ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1488	        }
1489	
1490	        // Technique from Juriy Zaytsev
1491	        // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1492	        // We only care about the case where non-standard event systems
1493	        // are used, namely in IE. Short-circuiting here helps us to
1494	        // avoid an eval call (in setAttribute) which can cause CSP
1495	        // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1496	        if ( div.attachEvent ) {
1497	                for( i in {
1498	                        submit: 1,
1499	                        change: 1,
1500	                        focusin: 1
1501	                }) {
1502	                        eventName = "on" + i;
1503	                        isSupported = ( eventName in div );
1504	                        if ( !isSupported ) {
1505	                                div.setAttribute( eventName, "return;" );
1506	                                isSupported = ( typeof div[ eventName ] === "function" );
1507	                        }
1508	                        support[ i + "Bubbles" ] = isSupported;
1509	                }
1510	        }
1511	
1512	        fragment.removeChild( div );
1513	
1514	        // Null elements to avoid leaks in IE
1515	        fragment = select = opt = marginDiv = div = input = null;
1516	
1517	        // Run tests that need a body at doc ready
1518	        jQuery(function() {
1519	                var container, outer, inner, table, td, offsetSupport,
1520	                        conMarginTop, ptlm, vb, style, html,
1521	                        body = document.getElementsByTagName("body")[0];
1522	
1523	                if ( !body ) {
1524	                        // Return for frameset docs that don't have a body
1525	                        return;
1526	                }
1527	
1528	                conMarginTop = 1;
1529	                ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";
1530	                vb = "visibility:hidden;border:0;";
1531	                style = "style='" + ptlm + "border:5px solid #000;padding:0;'";
1532	                html = "<div " + style + "><div></div></div>" +
1533	                        "<table " + style + " cellpadding='0' cellspacing='0'>" +
1534	                        "<tr><td></td></tr></table>";
1535	
1536	                container = document.createElement("div");
1537	                container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
1538	                body.insertBefore( container, body.firstChild );
1539	
1540	                // Construct the test element
1541	                div = document.createElement("div");
1542	                container.appendChild( div );
1543	
1544	                // Check if table cells still have offsetWidth/Height when they are set
1545	                // to display:none and there are still other visible table cells in a
1546	                // table row; if so, offsetWidth/Height are not reliable for use when
1547	                // determining if an element has been hidden directly using
1548	                // display:none (it is still safe to use offsets if a parent element is
1549	                // hidden; don safety goggles and see bug #4512 for more information).
1550	                // (only IE 8 fails this test)
1551	                div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1552	                tds = div.getElementsByTagName( "td" );
1553	                isSupported = ( tds[ 0 ].offsetHeight === 0 );
1554	
1555	                tds[ 0 ].style.display = "";
1556	                tds[ 1 ].style.display = "none";
1557	
1558	                // Check if empty table cells still have offsetWidth/Height
1559	                // (IE <= 8 fail this test)
1560	                support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1561	
1562	                // Figure out if the W3C box model works as expected
1563	                div.innerHTML = "";
1564	                div.style.width = div.style.paddingLeft = "1px";
1565	                jQuery.boxModel = support.boxModel = div.offsetWidth === 2;
1566	
1567	                if ( typeof div.style.zoom !== "undefined" ) {
1568	                        // Check if natively block-level elements act like inline-block
1569	                        // elements when setting their display to 'inline' and giving
1570	                        // them layout
1571	                        // (IE < 8 does this)
1572	                        div.style.display = "inline";
1573	                        div.style.zoom = 1;
1574	                        support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1575	
1576	                        // Check if elements with layout shrink-wrap their children
1577	                        // (IE 6 does this)
1578	                        div.style.display = "";
1579	                        div.innerHTML = "<div style='width:4px;'></div>";
1580	                        support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1581	                }
1582	
1583	                div.style.cssText = ptlm + vb;
1584	                div.innerHTML = html;
1585	
1586	                outer = div.firstChild;
1587	                inner = outer.firstChild;
1588	                td = outer.nextSibling.firstChild.firstChild;
1589	
1590	                offsetSupport = {
1591	                        doesNotAddBorder: ( inner.offsetTop !== 5 ),
1592	                        doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
1593	                };
1594	
1595	                inner.style.position = "fixed";
1596	                inner.style.top = "20px";
1597	
1598	                // safari subtracts parent border width here which is 5px
1599	                offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
1600	                inner.style.position = inner.style.top = "";
1601	
1602	                outer.style.overflow = "hidden";
1603	                outer.style.position = "relative";
1604	
1605	                offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
1606	                offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
1607	
1608	                body.removeChild( container );
1609	                div  = container = null;
1610	
1611	                jQuery.extend( support, offsetSupport );
1612	        });
1613	
1614	        return support;
1615	})();
1616	
1617	
1618	
1619	
1620	var rbrace = /^(?:\{.*\}|\[.*\])$/,
1621	        rmultiDash = /([A-Z])/g;
1622	
1623	jQuery.extend({
1624	        cache: {},
1625	
1626	        // Please use with caution
1627	        uuid: 0,
1628	
1629	        // Unique for each copy of jQuery on the page
1630	        // Non-digits removed to match rinlinejQuery
1631	        expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1632	
1633	        // The following elements throw uncatchable exceptions if you
1634	        // attempt to add expando properties to them.
1635	        noData: {
1636	                "embed": true,
1637	                // Ban all objects except for Flash (which handle expandos)
1638	                "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1639	                "applet": true
1640	        },
1641	
1642	        hasData: function( elem ) {
1643	                elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1644	                return !!elem && !isEmptyDataObject( elem );
1645	        },
1646	
1647	        data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1648	                if ( !jQuery.acceptData( elem ) ) {
1649	                        return;
1650	                }
1651	
1652	                var privateCache, thisCache, ret,
1653	                        internalKey = jQuery.expando,
1654	                        getByName = typeof name === "string",
1655	
1656	                        // We have to handle DOM nodes and JS objects differently because IE6-7
1657	                        // can't GC object references properly across the DOM-JS boundary
1658	                        isNode = elem.nodeType,
1659	
1660	                        // Only DOM nodes need the global jQuery cache; JS object data is
1661	                        // attached directly to the object so GC can occur automatically
1662	                        cache = isNode ? jQuery.cache : elem,
1663	
1664	                        // Only defining an ID for JS objects if its cache already exists allows
1665	                        // the code to shortcut on the same path as a DOM node with no cache
1666	                        id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
1667	                        isEvents = name === "events";
1668	
1669	                // Avoid doing any more work than we need to when trying to get data on an
1670	                // object that has no data at all
1671	                if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
1672	                        return;
1673	                }
1674	
1675	                if ( !id ) {
1676	                        // Only DOM nodes need a new unique ID for each element since their data
1677	                        // ends up in the global cache
1678	                        if ( isNode ) {
1679	                                elem[ internalKey ] = id = ++jQuery.uuid;
1680	                        } else {
1681	                                id = internalKey;
1682	                        }
1683	                }
1684	
1685	                if ( !cache[ id ] ) {
1686	                        cache[ id ] = {};
1687	
1688	                        // Avoids exposing jQuery metadata on plain JS objects when the object
1689	                        // is serialized using JSON.stringify
1690	                        if ( !isNode ) {
1691	                                cache[ id ].toJSON = jQuery.noop;
1692	                        }
1693	                }
1694	
1695	                // An object can be passed to jQuery.data instead of a key/value pair; this gets
1696	                // shallow copied over onto the existing cache
1697	                if ( typeof name === "object" || typeof name === "function" ) {
1698	                        if ( pvt ) {
1699	                                cache[ id ] = jQuery.extend( cache[ id ], name );
1700	                        } else {
1701	                                cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1702	                        }
1703	                }
1704	
1705	                privateCache = thisCache = cache[ id ];
1706	
1707	                // jQuery data() is stored in a separate object inside the object's internal data
1708	                // cache in order to avoid key collisions between internal data and user-defined
1709	                // data.
1710	                if ( !pvt ) {
1711	                        if ( !thisCache.data ) {
1712	                                thisCache.data = {};
1713	                        }
1714	
1715	                        thisCache = thisCache.data;
1716	                }
1717	
1718	                if ( data !== undefined ) {
1719	                        thisCache[ jQuery.camelCase( name ) ] = data;
1720	                }
1721	
1722	                // Users should not attempt to inspect the internal events object using jQuery.data,
1723	                // it is undocumented and subject to change. But does anyone listen? No.
1724	                if ( isEvents && !thisCache[ name ] ) {
1725	                        return privateCache.events;
1726	                }
1727	
1728	                // Check for both converted-to-camel and non-converted data property names
1729	                // If a data property was specified
1730	                if ( getByName ) {
1731	
1732	                        // First Try to find as-is property data
1733	                        ret = thisCache[ name ];
1734	
1735	                        // Test for null|undefined property data
1736	                        if ( ret == null ) {
1737	
1738	                                // Try to find the camelCased property
1739	                                ret = thisCache[ jQuery.camelCase( name ) ];
1740	                        }
1741	                } else {
1742	                        ret = thisCache;
1743	                }
1744	
1745	                return ret;
1746	        },
1747	
1748	        removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1749	                if ( !jQuery.acceptData( elem ) ) {
1750	                        return;
1751	                }
1752	
1753	                var thisCache, i, l,
1754	
1755	                        // Reference to internal data cache key
1756	                        internalKey = jQuery.expando,
1757	
1758	                        isNode = elem.nodeType,
1759	
1760	                        // See jQuery.data for more information
1761	                        cache = isNode ? jQuery.cache : elem,
1762	
1763	                        // See jQuery.data for more information
1764	                        id = isNode ? elem[ internalKey ] : internalKey;
1765	
1766	                // If there is already no cache entry for this object, there is no
1767	                // purpose in continuing
1768	                if ( !cache[ id ] ) {
1769	                        return;
1770	                }
1771	
1772	                if ( name ) {
1773	
1774	                        thisCache = pvt ? cache[ id ] : cache[ id ].data;
1775	
1776	                        if ( thisCache ) {
1777	
1778	                                // Support array or space separated string names for data keys
1779	                                if ( !jQuery.isArray( name ) ) {
1780	
1781	                                        // try the string as a key before any manipulation
1782	                                        if ( name in thisCache ) {
1783	                                                name = [ name ];
1784	                                        } else {
1785	
1786	                                                // split the camel cased version by spaces unless a key with the spaces exists
1787	                                                name = jQuery.camelCase( name );
1788	                                                if ( name in thisCache ) {
1789	                                                        name = [ name ];
1790	                                                } else {
1791	                                                        name = name.split( " " );
1792	                                                }
1793	                                        }
1794	                                }
1795	
1796	                                for ( i = 0, l = name.length; i < l; i++ ) {
1797	                                        delete thisCache[ name[i] ];
1798	                                }
1799	
1800	                                // If there is no data left in the cache, we want to continue
1801	                                // and let the cache object itself get destroyed
1802	                                if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1803	                                        return;
1804	                                }
1805	                        }
1806	                }
1807	
1808	                // See jQuery.data for more information
1809	                if ( !pvt ) {
1810	                        delete cache[ id ].data;
1811	
1812	                        // Don't destroy the parent cache unless the internal data object
1813	                        // had been the only thing left in it
1814	                        if ( !isEmptyDataObject(cache[ id ]) ) {
1815	                                return;
1816	                        }
1817	                }
1818	
1819	                // Browsers that fail expando deletion also refuse to delete expandos on
1820	                // the window, but it will allow it on all other JS objects; other browsers
1821	                // don't care
1822	                // Ensure that `cache` is not a window object #10080
1823	                if ( jQuery.support.deleteExpando || !cache.setInterval ) {
1824	                        delete cache[ id ];
1825	                } else {
1826	                        cache[ id ] = null;
1827	                }
1828	
1829	                // We destroyed the cache and need to eliminate the expando on the node to avoid
1830	                // false lookups in the cache for entries that no longer exist
1831	                if ( isNode ) {
1832	                        // IE does not allow us to delete expando properties from nodes,
1833	                        // nor does it have a removeAttribute function on Document nodes;
1834	                        // we must handle all of these cases
1835	                        if ( jQuery.support.deleteExpando ) {
1836	                                delete elem[ internalKey ];
1837	                        } else if ( elem.removeAttribute ) {
1838	                                elem.removeAttribute( internalKey );
1839	                        } else {
1840	                                elem[ internalKey ] = null;
1841	                        }
1842	                }
1843	        },
1844	
1845	        // For internal use only.
1846	        _data: function( elem, name, data ) {
1847	                return jQuery.data( elem, name, data, true );
1848	        },
1849	
1850	        // A method for determining if a DOM node can handle the data expando
1851	        acceptData: function( elem ) {
1852	                if ( elem.nodeName ) {
1853	                        var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1854	
1855	                        if ( match ) {
1856	                                return !(match === true || elem.getAttribute("classid") !== match);
1857	                        }
1858	                }
1859	
1860	                return true;
1861	        }
1862	});
1863	
1864	jQuery.fn.extend({
1865	        data: function( key, value ) {
1866	                var parts, attr, name,
1867	                        data = null;
1868	
1869	                if ( typeof key === "undefined" ) {
1870	                        if ( this.length ) {
1871	                                data = jQuery.data( this[0] );
1872	
1873	                                if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) {
1874	                                        attr = this[0].attributes;
1875	                                        for ( var i = 0, l = attr.length; i < l; i++ ) {
1876	                                                name = attr[i].name;
1877	
1878	                                                if ( name.indexOf( "data-" ) === 0 ) {
1879	                                                        name = jQuery.camelCase( name.substring(5) );
1880	
1881	                                                        dataAttr( this[0], name, data[ name ] );
1882	                                                }
1883	                                        }
1884	                                        jQuery._data( this[0], "parsedAttrs", true );
1885	                                }
1886	                        }
1887	
1888	                        return data;
1889	
1890	                } else if ( typeof key === "object" ) {
1891	                        return this.each(function() {
1892	                                jQuery.data( this, key );
1893	                        });
1894	                }
1895	
1896	                parts = key.split(".");
1897	                parts[1] = parts[1] ? "." + parts[1] : "";
1898	
1899	                if ( value === undefined ) {
1900	                        data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1901	
1902	                        // Try to fetch any internally stored data first
1903	                        if ( data === undefined && this.length ) {
1904	                                data = jQuery.data( this[0], key );
1905	                                data = dataAttr( this[0], key, data );
1906	                        }
1907	
1908	                        return data === undefined && parts[1] ?
1909	                                this.data( parts[0] ) :
1910	                                data;
1911	
1912	                } else {
1913	                        return this.each(function() {
1914	                                var self = jQuery( this ),
1915	                                        args = [ parts[0], value ];
1916	
1917	                                self.triggerHandler( "setData" + parts[1] + "!", args );
1918	                                jQuery.data( this, key, value );
1919	                                self.triggerHandler( "changeData" + parts[1] + "!", args );
1920	                        });
1921	                }
1922	        },
1923	
1924	        removeData: function( key ) {
1925	                return this.each(function() {
1926	                        jQuery.removeData( this, key );
1927	                });
1928	        }
1929	});
1930	
1931	function dataAttr( elem, key, data ) {
1932	        // If nothing was found internally, try to fetch any
1933	        // data from the HTML5 data-* attribute
1934	        if ( data === undefined && elem.nodeType === 1 ) {
1935	
1936	                var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1937	
1938	                data = elem.getAttribute( name );
1939	
1940	                if ( typeof data === "string" ) {
1941	                        try {
1942	                                data = data === "true" ? true :
1943	                                data === "false" ? false :
1944	                                data === "null" ? null :
1945	                                jQuery.isNumeric( data ) ? parseFloat( data ) :
1946	                                        rbrace.test( data ) ? jQuery.parseJSON( data ) :
1947	                                        data;
1948	                        } catch( e ) {}
1949	
1950	                        // Make sure we set the data so it isn't changed later
1951	                        jQuery.data( elem, key, data );
1952	
1953	                } else {
1954	                        data = undefined;
1955	                }
1956	        }
1957	
1958	        return data;
1959	}
1960	
1961	// checks a cache object for emptiness
1962	function isEmptyDataObject( obj ) {
1963	        for ( var name in obj ) {
1964	
1965	                // if the public data object is empty, the private is still empty
1966	                if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1967	                        continue;
1968	                }
1969	                if ( name !== "toJSON" ) {
1970	                        return false;
1971	                }
1972	        }
1973	
1974	        return true;
1975	}
1976	
1977	
1978	
1979	
1980	function handleQueueMarkDefer( elem, type, src ) {
1981	        var deferDataKey = type + "defer",
1982	                queueDataKey = type + "queue",
1983	                markDataKey = type + "mark",
1984	                defer = jQuery._data( elem, deferDataKey );
1985	        if ( defer &&
1986	                ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
1987	                ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
1988	                // Give room for hard-coded callbacks to fire first
1989	                // and eventually mark/queue something else on the element
1990	                setTimeout( function() {
1991	                        if ( !jQuery._data( elem, queueDataKey ) &&
1992	                                !jQuery._data( elem, markDataKey ) ) {
1993	                                jQuery.removeData( elem, deferDataKey, true );
1994	                                defer.fire();
1995	                        }
1996	                }, 0 );
1997	        }
1998	}
1999	
2000	jQuery.extend({
2001	
2002	        _mark: function( elem, type ) {
2003	                if ( elem ) {
2004	                        type = ( type || "fx" ) + "mark";
2005	                        jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
2006	                }
2007	        },
2008	
2009	        _unmark: function( force, elem, type ) {
2010	                if ( force !== true ) {
2011	                        type = elem;
2012	                        elem = force;
2013	                        force = false;
2014	                }
2015	                if ( elem ) {
2016	                        type = type || "fx";
2017	                        var key = type + "mark",
2018	                                count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
2019	                        if ( count ) {
2020	                                jQuery._data( elem, key, count );
2021	                        } else {
2022	                                jQuery.removeData( elem, key, true );
2023	                                handleQueueMarkDefer( elem, type, "mark" );
2024	                        }
2025	                }
2026	        },
2027	
2028	        queue: function( elem, type, data ) {
2029	                var q;
2030	                if ( elem ) {
2031	                        type = ( type || "fx" ) + "queue";
2032	                        q = jQuery._data( elem, type );
2033	
2034	                        // Speed up dequeue by getting out quickly if this is just a lookup
2035	                        if ( data ) {
2036	                                if ( !q || jQuery.isArray(data) ) {
2037	                                        q = jQuery._data( elem, type, jQuery.makeArray(data) );
2038	                                } else {
2039	                                        q.push( data );
2040	                                }
2041	                        }
2042	                        return q || [];
2043	                }
2044	        },
2045	
2046	        dequeue: function( elem, type ) {
2047	                type = type || "fx";
2048	
2049	                var queue = jQuery.queue( elem, type ),
2050	                        fn = queue.shift(),
2051	                        hooks = {};
2052	
2053	                // If the fx queue is dequeued, always remove the progress sentinel
2054	                if ( fn === "inprogress" ) {
2055	                        fn = queue.shift();
2056	                }
2057	
2058	                if ( fn ) {
2059	                        // Add a progress sentinel to prevent the fx queue from being
2060	                        // automatically dequeued
2061	                        if ( type === "fx" ) {
2062	                                queue.unshift( "inprogress" );
2063	                        }
2064	
2065	                        jQuery._data( elem, type + ".run", hooks );
2066	                        fn.call( elem, function() {
2067	                                jQuery.dequeue( elem, type );
2068	                        }, hooks );
2069	                }
2070	
2071	                if ( !queue.length ) {
2072	                        jQuery.removeData( elem, type + "queue " + type + ".run", true );
2073	                        handleQueueMarkDefer( elem, type, "queue" );
2074	                }
2075	        }
2076	});
2077	
2078	jQuery.fn.extend({
2079	        queue: function( type, data ) {
2080	                if ( typeof type !== "string" ) {
2081	                        data = type;
2082	                        type = "fx";
2083	                }
2084	
2085	                if ( data === undefined ) {
2086	                        return jQuery.queue( this[0], type );
2087	                }
2088	                return this.each(function() {
2089	                        var queue = jQuery.queue( this, type, data );
2090	
2091	                        if ( type === "fx" && queue[0] !== "inprogress" ) {
2092	                                jQuery.dequeue( this, type );
2093	                        }
2094	                });
2095	        },
2096	        dequeue: function( type ) {
2097	                return this.each(function() {
2098	                        jQuery.dequeue( this, type );
2099	                });
2100	        },
2101	        // Based off of the plugin by Clint Helfers, with permission.
2102	        // http://blindsignals.com/index.php/2009/07/jquery-delay/
2103	        delay: function( time, type ) {
2104	                time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2105	                type = type || "fx";
2106	
2107	                return this.queue( type, function( next, hooks ) {
2108	                        var timeout = setTimeout( next, time );
2109	                        hooks.stop = function() {
2110	                                clearTimeout( timeout );
2111	                        };
2112	                });
2113	        },
2114	        clearQueue: function( type ) {
2115	                return this.queue( type || "fx", [] );
2116	        },
2117	        // Get a promise resolved when queues of a certain type
2118	        // are emptied (fx is the type by default)
2119	        promise: function( type, object ) {
2120	                if ( typeof type !== "string" ) {
2121	                        object = type;
2122	                        type = undefined;
2123	                }
2124	                type = type || "fx";
2125	                var defer = jQuery.Deferred(),
2126	                        elements = this,
2127	                        i = elements.length,
2128	                        count = 1,
2129	                        deferDataKey = type + "defer",
2130	                        queueDataKey = type + "queue",
2131	                        markDataKey = type + "mark",
2132	                        tmp;
2133	                function resolve() {
2134	                        if ( !( --count ) ) {
2135	                                defer.resolveWith( elements, [ elements ] );
2136	                        }
2137	                }
2138	                while( i-- ) {
2139	                        if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2140	                                        ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2141	                                                jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2142	                                        jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2143	                                count++;
2144	                                tmp.add( resolve );
2145	                        }
2146	                }
2147	                resolve();
2148	                return defer.promise();
2149	        }
2150	});
2151	
2152	
2153	
2154	
2155	var rclass = /[\n\t\r]/g,
2156	        rspace = /\s+/,
2157	        rreturn = /\r/g,
2158	        rtype = /^(?:button|input)$/i,
2159	        rfocusable = /^(?:button|input|object|select|textarea)$/i,
2160	        rclickable = /^a(?:rea)?$/i,
2161	        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2162	        getSetAttribute = jQuery.support.getSetAttribute,
2163	        nodeHook, boolHook, fixSpecified;
2164	
2165	jQuery.fn.extend({
2166	        attr: function( name, value ) {
2167	                return jQuery.access( this, name, value, true, jQuery.attr );
2168	        },
2169	
2170	        removeAttr: function( name ) {
2171	                return this.each(function() {
2172	                        jQuery.removeAttr( this, name );
2173	                });
2174	        },
2175	
2176	        prop: function( name, value ) {
2177	                return jQuery.access( this, name, value, true, jQuery.prop );
2178	        },
2179	
2180	        removeProp: function( name ) {
2181	                name = jQuery.propFix[ name ] || name;
2182	                return this.each(function() {
2183	                        // try/catch handles cases where IE balks (such as removing a property on window)
2184	                        try {
2185	                                this[ name ] = undefined;
2186	                                delete this[ name ];
2187	                        } catch( e ) {}
2188	                });
2189	        },
2190	
2191	        addClass: function( value ) {
2192	                var classNames, i, l, elem,
2193	                        setClass, c, cl;
2194	
2195	                if ( jQuery.isFunction( value ) ) {
2196	                        return this.each(function( j ) {
2197	                                jQuery( this ).addClass( value.call(this, j, this.className) );
2198	                        });
2199	                }
2200	
2201	                if ( value && typeof value === "string" ) {
2202	                        classNames = value.split( rspace );
2203	
2204	                        for ( i = 0, l = this.length; i < l; i++ ) {
2205	                                elem = this[ i ];
2206	
2207	                                if ( elem.nodeType === 1 ) {
2208	                                        if ( !elem.className && classNames.length === 1 ) {
2209	                                                elem.className = value;
2210	
2211	                                        } else {
2212	                                                setClass = " " + elem.className + " ";
2213	
2214	                                                for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2215	                                                        if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2216	                                                                setClass += classNames[ c ] + " ";
2217	                                                        }
2218	                                                }
2219	                                                elem.className = jQuery.trim( setClass );
2220	                                        }
2221	                                }
2222	                        }
2223	                }
2224	
2225	                return this;
2226	        },
2227	
2228	        removeClass: function( value ) {
2229	                var classNames, i, l, elem, className, c, cl;
2230	
2231	                if ( jQuery.isFunction( value ) ) {
2232	                        return this.each(function( j ) {
2233	                                jQuery( this ).removeClass( value.call(this, j, this.className) );
2234	                        });
2235	                }
2236	
2237	                if ( (value && typeof value === "string") || value === undefined ) {
2238	                        classNames = ( value || "" ).split( rspace );
2239	
2240	                        for ( i = 0, l = this.length; i < l; i++ ) {
2241	                                elem = this[ i ];
2242	
2243	                                if ( elem.nodeType === 1 && elem.className ) {
2244	                                        if ( value ) {
2245	                                                className = (" " + elem.className + " ").replace( rclass, " " );
2246	                                                for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2247	                                                        className = className.replace(" " + classNames[ c ] + " ", " ");
2248	                                                }
2249	                                                elem.className = jQuery.trim( className );
2250	
2251	                                        } else {
2252	                                                elem.className = "";
2253	                                        }
2254	                                }
2255	                        }
2256	                }
2257	
2258	                return this;
2259	        },
2260	
2261	        toggleClass: function( value, stateVal ) {
2262	                var type = typeof value,
2263	                        isBool = typeof stateVal === "boolean";
2264	
2265	                if ( jQuery.isFunction( value ) ) {
2266	                        return this.each(function( i ) {
2267	                                jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2268	                        });
2269	                }
2270	
2271	                return this.each(function() {
2272	                        if ( type === "string" ) {
2273	                                // toggle individual class names
2274	                                var className,
2275	                                        i = 0,
2276	                                        self = jQuery( this ),
2277	                                        state = stateVal,
2278	                                        classNames = value.split( rspace );
2279	
2280	                                while ( (className = classNames[ i++ ]) ) {
2281	                                        // check each className given, space seperated list
2282	                                        state = isBool ? state : !self.hasClass( className );
2283	                                        self[ state ? "addClass" : "removeClass" ]( className );
2284	                                }
2285	
2286	                        } else if ( type === "undefined" || type === "boolean" ) {
2287	                                if ( this.className ) {
2288	                                        // store className if set
2289	                                        jQuery._data( this, "__className__", this.className );
2290	                                }
2291	
2292	                                // toggle whole className
2293	                                this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2294	                        }
2295	                });
2296	        },
2297	
2298	        hasClass: function( selector ) {
2299	                var className = " " + selector + " ",
2300	                        i = 0,
2301	                        l = this.length;
2302	                for ( ; i < l; i++ ) {
2303	                        if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2304	                                return true;
2305	                        }
2306	                }
2307	
2308	                return false;
2309	        },
2310	
2311	        val: function( value ) {
2312	                var hooks, ret, isFunction,
2313	                        elem = this[0];
2314	
2315	                if ( !arguments.length ) {
2316	                        if ( elem ) {
2317	                                hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2318	
2319	                                if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2320	                                        return ret;
2321	                                }
2322	
2323	                                ret = elem.value;
2324	
2325	                                return typeof ret === "string" ?
2326	                                        // handle most common string cases
2327	                                        ret.replace(rreturn, "") :
2328	                                        // handle cases where value is null/undef or number
2329	                                        ret == null ? "" : ret;
2330	                        }
2331	
2332	                        return;
2333	                }
2334	
2335	                isFunction = jQuery.isFunction( value );
2336	
2337	                return this.each(function( i ) {
2338	                        var self = jQuery(this), val;
2339	
2340	                        if ( this.nodeType !== 1 ) {
2341	                                return;
2342	                        }
2343	
2344	                        if ( isFunction ) {
2345	                                val = value.call( this, i, self.val() );
2346	                        } else {
2347	                                val = value;
2348	                        }
2349	
2350	                        // Treat null/undefined as ""; convert numbers to string
2351	                        if ( val == null ) {
2352	                                val = "";
2353	                        } else if ( typeof val === "number" ) {
2354	                                val += "";
2355	                        } else if ( jQuery.isArray( val ) ) {
2356	                                val = jQuery.map(val, function ( value ) {
2357	                                        return value == null ? "" : value + "";
2358	                                });
2359	                        }
2360	
2361	                        hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2362	
2363	                        // If set returns undefined, fall back to normal setting
2364	                        if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2365	                                this.value = val;
2366	                        }
2367	                });
2368	        }
2369	});
2370	
2371	jQuery.extend({
2372	        valHooks: {
2373	                option: {
2374	                        get: function( elem ) {
2375	                                // attributes.value is undefined in Blackberry 4.7 but
2376	                                // uses .value. See #6932
2377	                                var val = elem.attributes.value;
2378	                                return !val || val.specified ? elem.value : elem.text;
2379	                        }
2380	                },
2381	                select: {
2382	                        get: function( elem ) {
2383	                                var value, i, max, option,
2384	                                        index = elem.selectedIndex,
2385	                                        values = [],
2386	                                        options = elem.options,
2387	                                        one = elem.type === "select-one";
2388	
2389	                                // Nothing was selected
2390	                                if ( index < 0 ) {
2391	                                        return null;
2392	                                }
2393	
2394	                                // Loop through all the selected options
2395	                                i = one ? index : 0;
2396	                                max = one ? index + 1 : options.length;
2397	                                for ( ; i < max; i++ ) {
2398	                                        option = options[ i ];
2399	
2400	                                        // Don't return options that are disabled or in a disabled optgroup
2401	                                        if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2402	                                                        (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2403	
2404	                                                // Get the specific value for the option
2405	                                                value = jQuery( option ).val();
2406	
2407	                                                // We don't need an array for one selects
2408	                                                if ( one ) {
2409	                                                        return value;
2410	                                                }
2411	
2412	                                                // Multi-Selects return an array
2413	                                                values.push( value );
2414	                                        }
2415	                                }
2416	
2417	                                // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2418	                                if ( one && !values.length && options.length ) {
2419	                                        return jQuery( options[ index ] ).val();
2420	                                }
2421	
2422	                                return values;
2423	                        },
2424	
2425	                        set: function( elem, value ) {
2426	                                var values = jQuery.makeArray( value );
2427	
2428	                                jQuery(elem).find("option").each(function() {
2429	                                        this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2430	                                });
2431	
2432	                                if ( !values.length ) {
2433	                                        elem.selectedIndex = -1;
2434	                                }
2435	                                return values;
2436	                        }
2437	                }
2438	        },
2439	
2440	        attrFn: {
2441	                val: true,
2442	                css: true,
2443	                html: true,
2444	                text: true,
2445	                data: true,
2446	                width: true,
2447	                height: true,
2448	                offset: true
2449	        },
2450	
2451	        attr: function( elem, name, value, pass ) {
2452	                var ret, hooks, notxml,
2453	                        nType = elem.nodeType;
2454	
2455	                // don't get/set attributes on text, comment and attribute nodes
2456	                if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2457	                        return;
2458	                }
2459	
2460	                if ( pass && name in jQuery.attrFn ) {
2461	                        return jQuery( elem )[ name ]( value );
2462	                }
2463	
2464	                // Fallback to prop when attributes are not supported
2465	                if ( typeof elem.getAttribute === "undefined" ) {
2466	                        return jQuery.prop( elem, name, value );
2467	                }
2468	
2469	                notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2470	
2471	                // All attributes are lowercase
2472	                // Grab necessary hook if one is defined
2473	                if ( notxml ) {
2474	                        name = name.toLowerCase();
2475	                        hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2476	                }
2477	
2478	                if ( value !== undefined ) {
2479	
2480	                        if ( value === null ) {
2481	                                jQuery.removeAttr( elem, name );
2482	                                return;
2483	
2484	                        } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2485	                                return ret;
2486	
2487	                        } else {
2488	                                elem.setAttribute( name, "" + value );
2489	                                return value;
2490	                        }
2491	
2492	                } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2493	                        return ret;
2494	
2495	                } else {
2496	
2497	                        ret = elem.getAttribute( name );
2498	
2499	                        // Non-existent attributes return null, we normalize to undefined
2500	                        return ret === null ?
2501	                                undefined :
2502	                                ret;
2503	                }
2504	        },
2505	
2506	        removeAttr: function( elem, value ) {
2507	                var propName, attrNames, name, l,
2508	                        i = 0;
2509	
2510	                if ( value && elem.nodeType === 1 ) {
2511	                        attrNames = value.toLowerCase().split( rspace );
2512	                        l = attrNames.length;
2513	
2514	                        for ( ; i < l; i++ ) {
2515	                                name = attrNames[ i ];
2516	
2517	                                if ( name ) {
2518	                                        propName = jQuery.propFix[ name ] || name;
2519	
2520	                                        // See #9699 for explanation of this approach (setting first, then removal)
2521	                                        jQuery.attr( elem, name, "" );
2522	                                        elem.removeAttribute( getSetAttribute ? name : propName );
2523	
2524	                                        // Set corresponding property to false for boolean attributes
2525	                                        if ( rboolean.test( name ) && propName in elem ) {
2526	                                                elem[ propName ] = false;
2527	                                        }
2528	                                }
2529	                        }
2530	                }
2531	        },
2532	
2533	        attrHooks: {
2534	                type: {
2535	                        set: function( elem, value ) {
2536	                                // We can't allow the type property to be changed (since it causes problems in IE)
2537	                                if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2538	                                        jQuery.error( "type property can't be changed" );
2539	                                } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2540	                                        // Setting the type on a radio button after the value resets the value in IE6-9
2541	                                        // Reset value to it's default in case type is set after value
2542	                                        // This is for element creation
2543	                                        var val = elem.value;
2544	                                        elem.setAttribute( "type", value );
2545	                                        if ( val ) {
2546	                                                elem.value = val;
2547	                                        }
2548	                                        return value;
2549	                                }
2550	                        }
2551	                },
2552	                // Use the value property for back compat
2553	                // Use the nodeHook for button elements in IE6/7 (#1954)
2554	                value: {
2555	                        get: function( elem, name ) {
2556	                                if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2557	                                        return nodeHook.get( elem, name );
2558	                                }
2559	                                return name in elem ?
2560	                                        elem.value :
2561	                                        null;
2562	                        },
2563	                        set: function( elem, value, name ) {
2564	                                if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2565	                                        return nodeHook.set( elem, value, name );
2566	                                }
2567	                                // Does not return so that setAttribute is also used
2568	                                elem.value = value;
2569	                        }
2570	                }
2571	        },
2572	
2573	        propFix: {
2574	                tabindex: "tabIndex",
2575	                readonly: "readOnly",
2576	                "for": "htmlFor",
2577	                "class": "className",
2578	                maxlength: "maxLength",
2579	                cellspacing: "cellSpacing",
2580	                cellpadding: "cellPadding",
2581	                rowspan: "rowSpan",
2582	                colspan: "colSpan",
2583	                usemap: "useMap",
2584	                frameborder: "frameBorder",
2585	                contenteditable: "contentEditable"
2586	        },
2587	
2588	        prop: function( elem, name, value ) {
2589	                var ret, hooks, notxml,
2590	                        nType = elem.nodeType;
2591	
2592	                // don't get/set properties on text, comment and attribute nodes
2593	                if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2594	                        return;
2595	                }
2596	
2597	                notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2598	
2599	                if ( notxml ) {
2600	                        // Fix name and attach hooks
2601	                        name = jQuery.propFix[ name ] || name;
2602	                        hooks = jQuery.propHooks[ name ];
2603	                }
2604	
2605	                if ( value !== undefined ) {
2606	                        if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2607	                                return ret;
2608	
2609	                        } else {
2610	                                return ( elem[ name ] = value );
2611	                        }
2612	
2613	                } else {
2614	                        if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2615	                                return ret;
2616	
2617	                        } else {
2618	                                return elem[ name ];
2619	                        }
2620	                }
2621	        },
2622	
2623	        propHooks: {
2624	                tabIndex: {
2625	                        get: function( elem ) {
2626	                                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2627	                                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2628	                                var attributeNode = elem.getAttributeNode("tabindex");
2629	
2630	                                return attributeNode && attributeNode.specified ?
2631	                                        parseInt( attributeNode.value, 10 ) :
2632	                                        rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2633	                                                0 :
2634	                                                undefined;
2635	                        }
2636	                }
2637	        }
2638	});
2639	
2640	// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2641	jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2642	
2643	// Hook for boolean attributes
2644	boolHook = {
2645	        get: function( elem, name ) {
2646	                // Align boolean attributes with corresponding properties
2647	                // Fall back to attribute presence where some booleans are not supported
2648	                var attrNode,
2649	                        property = jQuery.prop( elem, name );
2650	                return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2651	                        name.toLowerCase() :
2652	                        undefined;
2653	        },
2654	        set: function( elem, value, name ) {
2655	                var propName;
2656	                if ( value === false ) {
2657	                        // Remove boolean attributes when set to false
2658	                        jQuery.removeAttr( elem, name );
2659	                } else {
2660	                        // value is true since we know at this point it's type boolean and not false
2661	                        // Set boolean attributes to the same name and set the DOM property
2662	                        propName = jQuery.propFix[ name ] || name;
2663	                        if ( propName in elem ) {
2664	                                // Only set the IDL specifically if it already exists on the element
2665	                                elem[ propName ] = true;
2666	                        }
2667	
2668	                        elem.setAttribute( name, name.toLowerCase() );
2669	                }
2670	                return name;
2671	        }
2672	};
2673	
2674	// IE6/7 do not support getting/setting some attributes with get/setAttribute
2675	if ( !getSetAttribute ) {
2676	
2677	        fixSpecified = {
2678	                name: true,
2679	                id: true
2680	        };
2681	
2682	        // Use this for any attribute in IE6/7
2683	        // This fixes almost every IE6/7 issue
2684	        nodeHook = jQuery.valHooks.button = {
2685	                get: function( elem, name ) {
2686	                        var ret;
2687	                        ret = elem.getAttributeNode( name );
2688	                        return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2689	                                ret.nodeValue :
2690	                                undefined;
2691	                },
2692	                set: function( elem, value, name ) {
2693	                        // Set the existing or create a new attribute node
2694	                        var ret = elem.getAttributeNode( name );
2695	                        if ( !ret ) {
2696	                                ret = document.createAttribute( name );
2697	                                elem.setAttributeNode( ret );
2698	                        }
2699	                        return ( ret.nodeValue = value + "" );
2700	                }
2701	        };
2702	
2703	        // Apply the nodeHook to tabindex
2704	        jQuery.attrHooks.tabindex.set = nodeHook.set;
2705	
2706	        // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2707	        // This is for removals
2708	        jQuery.each([ "width", "height" ], function( i, name ) {
2709	                jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2710	                        set: function( elem, value ) {
2711	                                if ( value === "" ) {
2712	                                        elem.setAttribute( name, "auto" );
2713	                                        return value;
2714	                                }
2715	                        }
2716	                });
2717	        });
2718	
2719	        // Set contenteditable to false on removals(#10429)
2720	        // Setting to empty string throws an error as an invalid value
2721	        jQuery.attrHooks.contenteditable = {
2722	                get: nodeHook.get,
2723	                set: function( elem, value, name ) {
2724	                        if ( value === "" ) {
2725	                                value = "false";
2726	                        }
2727	                        nodeHook.set( elem, value, name );
2728	                }
2729	        };
2730	}
2731	
2732	
2733	// Some attributes require a special call on IE
2734	if ( !jQuery.support.hrefNormalized ) {
2735	        jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2736	                jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2737	                        get: function( elem ) {
2738	                                var ret = elem.getAttribute( name, 2 );
2739	                                return ret === null ? undefined : ret;
2740	                        }
2741	                });
2742	        });
2743	}
2744	
2745	if ( !jQuery.support.style ) {
2746	        jQuery.attrHooks.style = {
2747	                get: function( elem ) {
2748	                        // Return undefined in the case of empty string
2749	                        // Normalize to lowercase since IE uppercases css property names
2750	                        return elem.style.cssText.toLowerCase() || undefined;
2751	                },
2752	                set: function( elem, value ) {
2753	                        return ( elem.style.cssText = "" + value );
2754	                }
2755	        };
2756	}
2757	
2758	// Safari mis-reports the default selected property of an option
2759	// Accessing the parent's selectedIndex property fixes it
2760	if ( !jQuery.support.optSelected ) {
2761	        jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2762	                get: function( elem ) {
2763	                        var parent = elem.parentNode;
2764	
2765	                        if ( parent ) {
2766	                                parent.selectedIndex;
2767	
2768	                                // Make sure that it also works with optgroups, see #5701
2769	                                if ( parent.parentNode ) {
2770	                                        parent.parentNode.selectedIndex;
2771	                                }
2772	                        }
2773	                        return null;
2774	                }
2775	        });
2776	}
2777	
2778	// IE6/7 call enctype encoding
2779	if ( !jQuery.support.enctype ) {
2780	        jQuery.propFix.enctype = "encoding";
2781	}
2782	
2783	// Radios and checkboxes getter/setter
2784	if ( !jQuery.support.checkOn ) {
2785	        jQuery.each([ "radio", "checkbox" ], function() {
2786	                jQuery.valHooks[ this ] = {
2787	                        get: function( elem ) {
2788	                                // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2789	                                return elem.getAttribute("value") === null ? "on" : elem.value;
2790	                        }
2791	                };
2792	        });
2793	}
2794	jQuery.each([ "radio", "checkbox" ], function() {
2795	        jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2796	                set: function( elem, value ) {
2797	                        if ( jQuery.isArray( value ) ) {
2798	                                return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2799	                        }
2800	                }
2801	        });
2802	});
2803	
2804	
2805	
2806	
2807	var rformElems = /^(?:textarea|input|select)$/i,
2808	        rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
2809	        rhoverHack = /\bhover(\.\S+)?\b/,
2810	        rkeyEvent = /^key/,
2811	        rmouseEvent = /^(?:mouse|contextmenu)|click/,
2812	        rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2813	        rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
2814	        quickParse = function( selector ) {
2815	                var quick = rquickIs.exec( selector );
2816	                if ( quick ) {
2817	                        //   0  1    2   3
2818	                        // [ _, tag, id, class ]
2819	                        quick[1] = ( quick[1] || "" ).toLowerCase();
2820	                        quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
2821	                }
2822	                return quick;
2823	        },
2824	        quickIs = function( elem, m ) {
2825	                var attrs = elem.attributes || {};
2826	                return (
2827	                        (!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
2828	                        (!m[2] || (attrs.id || {}).value === m[2]) &&
2829	                        (!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
2830	                );
2831	        },
2832	        hoverHack = function( events ) {
2833	                return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2834	        };
2835	
2836	/*
2837	 * Helper functions for managing events -- not part of the public interface.
2838	 * Props to Dean Edwards' addEvent library for many of the ideas.
2839	 */
2840	jQuery.event = {
2841	
2842	        add: function( elem, types, handler, data, selector ) {
2843	
2844	                var elemData, eventHandle, events,
2845	                        t, tns, type, namespaces, handleObj,
2846	                        handleObjIn, quick, handlers, special;
2847	
2848	                // Don't attach events to noData or text/comment nodes (allow plain objects tho)
2849	                if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2850	                        return;
2851	                }
2852	
2853	                // Caller can pass in an object of custom data in lieu of the handler
2854	                if ( handler.handler ) {
2855	                        handleObjIn = handler;
2856	                        handler = handleObjIn.handler;
2857	                }
2858	
2859	                // Make sure that the handler has a unique ID, used to find/remove it later
2860	                if ( !handler.guid ) {
2861	                        handler.guid = jQuery.guid++;
2862	                }
2863	
2864	                // Init the element's event structure and main handler, if this is the first
2865	                events = elemData.events;
2866	                if ( !events ) {
2867	                        elemData.events = events = {};
2868	                }
2869	                eventHandle = elemData.handle;
2870	                if ( !eventHandle ) {
2871	                        elemData.handle = eventHandle = function( e ) {
2872	                                // Discard the second event of a jQuery.event.trigger() and
2873	                                // when an event is called after a page has unloaded
2874	                                return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2875	                                        jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2876	                                        undefined;
2877	                        };
2878	                        // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2879	                        eventHandle.elem = elem;
2880	                }
2881	
2882	                // Handle multiple events separated by a space
2883	                // jQuery(...).bind("mouseover mouseout", fn);
2884	                types = jQuery.trim( hoverHack(types) ).split( " " );
2885	                for ( t = 0; t < types.length; t++ ) {
2886	
2887	                        tns = rtypenamespace.exec( types[t] ) || [];
2888	                        type = tns[1];
2889	                        namespaces = ( tns[2] || "" ).split( "." ).sort();
2890	
2891	                        // If event changes its type, use the special event handlers for the changed type
2892	                        special = jQuery.event.special[ type ] || {};
2893	
2894	                        // If selector defined, determine special event api type, otherwise given type
2895	                        type = ( selector ? special.delegateType : special.bindType ) || type;
2896	
2897	                        // Update special based on newly reset type
2898	                        special = jQuery.event.special[ type ] || {};
2899	
2900	                        // handleObj is passed to all event handlers
2901	                        handleObj = jQuery.extend({
2902	                                type: type,
2903	                                origType: tns[1],
2904	                                data: data,
2905	                                handler: handler,
2906	                                guid: handler.guid,
2907	                                selector: selector,
2908	                                quick: quickParse( selector ),
2909	                                namespace: namespaces.join(".")
2910	                        }, handleObjIn );
2911	
2912	                        // Init the event handler queue if we're the first
2913	                        handlers = events[ type ];
2914	                        if ( !handlers ) {
2915	                                handlers = events[ type ] = [];
2916	                                handlers.delegateCount = 0;
2917	
2918	                                // Only use addEventListener/attachEvent if the special events handler returns false
2919	                                if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2920	                                        // Bind the global event handler to the element
2921	                                        if ( elem.addEventListener ) {
2922	                                                elem.addEventListener( type, eventHandle, false );
2923	
2924	                                        } else if ( elem.attachEvent ) {
2925	                                                elem.attachEvent( "on" + type, eventHandle );
2926	                                        }
2927	                                }
2928	                        }
2929	
2930	                        if ( special.add ) {
2931	                                special.add.call( elem, handleObj );
2932	
2933	                                if ( !handleObj.handler.guid ) {
2934	                                        handleObj.handler.guid = handler.guid;
2935	                                }
2936	                        }
2937	
2938	                        // Add to the element's handler list, delegates in front
2939	                        if ( selector ) {
2940	                                handlers.splice( handlers.delegateCount++, 0, handleObj );
2941	                        } else {
2942	                                handlers.push( handleObj );
2943	                        }
2944	
2945	                        // Keep track of which events have ever been used, for event optimization
2946	                        jQuery.event.global[ type ] = true;
2947	                }
2948	
2949	                // Nullify elem to prevent memory leaks in IE
2950	                elem = null;
2951	        },
2952	
2953	        global: {},
2954	
2955	        // Detach an event or set of events from an element
2956	        remove: function( elem, types, handler, selector, mappedTypes ) {
2957	
2958	                var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2959	                        t, tns, type, origType, namespaces, origCount,
2960	                        j, events, special, handle, eventType, handleObj;
2961	
2962	                if ( !elemData || !(events = elemData.events) ) {
2963	                        return;
2964	                }
2965	
2966	                // Once for each type.namespace in types; type may be omitted
2967	                types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
2968	                for ( t = 0; t < types.length; t++ ) {
2969	                        tns = rtypenamespace.exec( types[t] ) || [];
2970	                        type = origType = tns[1];
2971	                        namespaces = tns[2];
2972	
2973	                        // Unbind all events (on this namespace, if provided) for the element
2974	                        if ( !type ) {
2975	                                for ( type in events ) {
2976	                                        jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2977	                                }
2978	                                continue;
2979	                        }
2980	
2981	                        special = jQuery.event.special[ type ] || {};
2982	                        type = ( selector? special.delegateType : special.bindType ) || type;
2983	                        eventType = events[ type ] || [];
2984	                        origCount = eventType.length;
2985	                        namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
2986	
2987	                        // Remove matching events
2988	                        for ( j = 0; j < eventType.length; j++ ) {
2989	                                handleObj = eventType[ j ];
2990	
2991	                                if ( ( mappedTypes || origType === handleObj.origType ) &&
2992	                                         ( !handler || handler.guid === handleObj.guid ) &&
2993	                                         ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
2994	                                         ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2995	                                        eventType.splice( j--, 1 );
2996	
2997	                                        if ( handleObj.selector ) {
2998	                                                eventType.delegateCount--;
2999	                                        }
3000	                                        if ( special.remove ) {
3001	                                                special.remove.call( elem, handleObj );
3002	                                        }
3003	                                }
3004	                        }
3005	
3006	                        // Remove generic event handler if we removed something and no more handlers exist
3007	                        // (avoids potential for endless recursion during removal of special event handlers)
3008	                        if ( eventType.length === 0 && origCount !== eventType.length ) {
3009	                                if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
3010	                                        jQuery.removeEvent( elem, type, elemData.handle );
3011	                                }
3012	
3013	                                delete events[ type ];
3014	                        }
3015	                }
3016	
3017	                // Remove the expando if it's no longer used
3018	                if ( jQuery.isEmptyObject( events ) ) {
3019	                        handle = elemData.handle;
3020	                        if ( handle ) {
3021	                                handle.elem = null;
3022	                        }
3023	
3024	                        // removeData also checks for emptiness and clears the expando if empty
3025	                        // so use it instead of delete
3026	                        jQuery.removeData( elem, [ "events", "handle" ], true );
3027	                }
3028	        },
3029	
3030	        // Events that are safe to short-circuit if no handlers are attached.
3031	        // Native DOM events should not be added, they may have inline handlers.
3032	        customEvent: {
3033	                "getData": true,
3034	                "setData": true,
3035	                "changeData": true
3036	        },
3037	
3038	        trigger: function( event, data, elem, onlyHandlers ) {
3039	                // Don't do events on text and comment nodes
3040	                if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
3041	                        return;
3042	                }
3043	
3044	                // Event object or event type
3045	                var type = event.type || event,
3046	                        namespaces = [],
3047	                        cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
3048	
3049	                // focus/blur morphs to focusin/out; ensure we're not firing them right now
3050	                if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
3051	                        return;
3052	                }
3053	
3054	                if ( type.indexOf( "!" ) >= 0 ) {
3055	                        // Exclusive events trigger only for the exact event (no namespaces)
3056	                        type = type.slice(0, -1);
3057	                        exclusive = true;
3058	                }
3059	
3060	                if ( type.indexOf( "." ) >= 0 ) {
3061	                        // Namespaced trigger; create a regexp to match event type in handle()
3062	                        namespaces = type.split(".");
3063	                        type = namespaces.shift();
3064	                        namespaces.sort();
3065	                }
3066	
3067	                if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
3068	                        // No jQuery handlers for this event type, and it can't have inline handlers
3069	                        return;
3070	                }
3071	
3072	                // Caller can pass in an Event, Object, or just an event type string
3073	                event = typeof event === "object" ?
3074	                        // jQuery.Event object
3075	                        event[ jQuery.expando ] ? event :
3076	                        // Object literal
3077	                        new jQuery.Event( type, event ) :
3078	                        // Just the event type (string)
3079	                        new jQuery.Event( type );
3080	
3081	                event.type = type;
3082	                event.isTrigger = true;
3083	                event.exclusive = exclusive;
3084	                event.namespace = namespaces.join( "." );
3085	                event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3086	                ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
3087	
3088	                // Handle a global trigger
3089	                if ( !elem ) {
3090	
3091	                        // TODO: Stop taunting the data cache; remove global events and always attach to document
3092	                        cache = jQuery.cache;
3093	                        for ( i in cache ) {
3094	                                if ( cache[ i ].events && cache[ i ].events[ type ] ) {
3095	                                        jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
3096	                                }
3097	                        }
3098	                        return;
3099	                }
3100	
3101	                // Clean up the event in case it is being reused
3102	                event.result = undefined;
3103	                if ( !event.target ) {
3104	                        event.target = elem;
3105	                }
3106	
3107	                // Clone any incoming data and prepend the event, creating the handler arg list
3108	                data = data != null ? jQuery.makeArray( data ) : [];
3109	                data.unshift( event );
3110	
3111	                // Allow special events to draw outside the lines
3112	                special = jQuery.event.special[ type ] || {};
3113	                if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
3114	                        return;
3115	                }
3116	
3117	                // Determine event propagation path in advance, per W3C events spec (#9951)
3118	                // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
3119	                eventPath = [[ elem, special.bindType || type ]];
3120	                if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
3121	
3122	                        bubbleType = special.delegateType || type;
3123	                        cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
3124	                        old = null;
3125	                        for ( ; cur; cur = cur.parentNode ) {
3126	                                eventPath.push([ cur, bubbleType ]);
3127	                                old = cur;
3128	                        }
3129	
3130	                        // Only add window if we got to document (e.g., not plain obj or detached DOM)
3131	                        if ( old && old === elem.ownerDocument ) {
3132	                                eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
3133	                        }
3134	                }
3135	
3136	                // Fire handlers on the event path
3137	                for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
3138	
3139	                        cur = eventPath[i][0];
3140	                        event.type = eventPath[i][1];
3141	
3142	                        handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
3143	                        if ( handle ) {
3144	                                handle.apply( cur, data );
3145	                        }
3146	                        // Note that this is a bare JS function and not a jQuery handler
3147	                        handle = ontype && cur[ ontype ];
3148	                        if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
3149	                                event.preventDefault();
3150	                        }
3151	                }
3152	                event.type = type;
3153	
3154	                // If nobody prevented the default action, do it now
3155	                if ( !onlyHandlers && !event.isDefaultPrevented() ) {
3156	
3157	                        if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
3158	                                !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
3159	
3160	                                // Call a native DOM method on the target with the same name name as the event.
3161	                                // Can't use an .isFunction() check here because IE6/7 fails that test.
3162	                                // Don't do default actions on window, that's where global variables be (#6170)
3163	                                // IE<9 dies on focus/blur to hidden element (#1486)
3164	                                if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
3165	
3166	                                        // Don't re-trigger an onFOO event when we call its FOO() method
3167	                                        old = elem[ ontype ];
3168	
3169	                                        if ( old ) {
3170	                                                elem[ ontype ] = null;
3171	                                        }
3172	
3173	                                        // Prevent re-triggering of the same event, since we already bubbled it above
3174	                                        jQuery.event.triggered = type;
3175	                                        elem[ type ]();
3176	                                        jQuery.event.triggered = undefined;
3177	
3178	                                        if ( old ) {
3179	                                                elem[ ontype ] = old;
3180	                                        }
3181	                                }
3182	                        }
3183	                }
3184	
3185	                return event.result;
3186	        },
3187	
3188	        dispatch: function( event ) {
3189	
3190	                // Make a writable jQuery.Event from the native event object
3191	                event = jQuery.event.fix( event || window.event );
3192	
3193	                var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
3194	                        delegateCount = handlers.delegateCount,
3195	                        args = [].slice.call( arguments, 0 ),
3196	                        run_all = !event.exclusive && !event.namespace,
3197	                        handlerQueue = [],
3198	                        i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
3199	
3200	                // Use the fix-ed jQuery.Event rather than the (read-only) native event
3201	                args[0] = event;
3202	                event.delegateTarget = this;
3203	
3204	                // Determine handlers that should run if there are delegated events
3205	                // Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861)
3206	                if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) {
3207	
3208	                        // Pregenerate a single jQuery object for reuse with .is()
3209	                        jqcur = jQuery(this);
3210	                        jqcur.context = this.ownerDocument || this;
3211	
3212	                        for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3213	                                selMatch = {};
3214	                                matches = [];
3215	                                jqcur[0] = cur;
3216	                                for ( i = 0; i < delegateCount; i++ ) {
3217	                                        handleObj = handlers[ i ];
3218	                                        sel = handleObj.selector;
3219	
3220	                                        if ( selMatch[ sel ] === undefined ) {
3221	                                                selMatch[ sel ] = (
3222	                                                        handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
3223	                                                );
3224	                                        }
3225	                                        if ( selMatch[ sel ] ) {
3226	                                                matches.push( handleObj );
3227	                                        }
3228	                                }
3229	                                if ( matches.length ) {
3230	                                        handlerQueue.push({ elem: cur, matches: matches });
3231	                                }
3232	                        }
3233	                }
3234	
3235	                // Add the remaining (directly-bound) handlers
3236	                if ( handlers.length > delegateCount ) {
3237	                        handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3238	                }
3239	
3240	                // Run delegates first; they may want to stop propagation beneath us
3241	                for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3242	                        matched = handlerQueue[ i ];
3243	                        event.currentTarget = matched.elem;
3244	
3245	                        for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3246	                                handleObj = matched.matches[ j ];
3247	
3248	                                // Triggered event must either 1) be non-exclusive and have no namespace, or
3249	                                // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3250	                                if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3251	
3252	                                        event.data = handleObj.data;
3253	                                        event.handleObj = handleObj;
3254	
3255	                                        ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3256	                                                        .apply( matched.elem, args );
3257	
3258	                                        if ( ret !== undefined ) {
3259	                                                event.result = ret;
3260	                                                if ( ret === false ) {
3261	                                                        event.preventDefault();
3262	                                                        event.stopPropagation();
3263	                                                }
3264	                                        }
3265	                                }
3266	                        }
3267	                }
3268	
3269	                return event.result;
3270	        },
3271	
3272	        // Includes some event props shared by KeyEvent and MouseEvent
3273	        // *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3274	        props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3275	
3276	        fixHooks: {},
3277	
3278	        keyHooks: {
3279	                props: "char charCode key keyCode".split(" "),
3280	                filter: function( event, original ) {
3281	
3282	                        // Add which for key events
3283	                        if ( event.which == null ) {
3284	                                event.which = original.charCode != null ? original.charCode : original.keyCode;
3285	                        }
3286	
3287	                        return event;
3288	                }
3289	        },
3290	
3291	        mouseHooks: {
3292	                props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3293	                filter: function( event, original ) {
3294	                        var eventDoc, doc, body,
3295	                                button = original.button,
3296	                                fromElement = original.fromElement;
3297	
3298	                        // Calculate pageX/Y if missing and clientX/Y available
3299	                        if ( event.pageX == null && original.clientX != null ) {
3300	                                eventDoc = event.target.ownerDocument || document;
3301	                                doc = eventDoc.documentElement;
3302	                                body = eventDoc.body;
3303	
3304	                                event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3305	                                event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3306	                        }
3307	
3308	                        // Add relatedTarget, if necessary
3309	                        if ( !event.relatedTarget && fromElement ) {
3310	                                event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3311	                        }
3312	
3313	                        // Add which for click: 1 === left; 2 === middle; 3 === right
3314	                        // Note: button is not normalized, so don't use it
3315	                        if ( !event.which && button !== undefined ) {
3316	                                event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3317	                        }
3318	
3319	                        return event;
3320	                }
3321	        },
3322	
3323	        fix: function( event ) {
3324	                if ( event[ jQuery.expando ] ) {
3325	                        return event;
3326	                }
3327	
3328	                // Create a writable copy of the event object and normalize some properties
3329	                var i, prop,
3330	                        originalEvent = event,
3331	                        fixHook = jQuery.event.fixHooks[ event.type ] || {},
3332	                        copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3333	
3334	                event = jQuery.Event( originalEvent );
3335	
3336	                for ( i = copy.length; i; ) {
3337	                        prop = copy[ --i ];
3338	                        event[ prop ] = originalEvent[ prop ];
3339	                }
3340	
3341	                // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3342	                if ( !event.target ) {
3343	                        event.target = originalEvent.srcElement || document;
3344	                }
3345	
3346	                // Target should not be a text node (#504, Safari)
3347	                if ( event.target.nodeType === 3 ) {
3348	                        event.target = event.target.parentNode;
3349	                }
3350	
3351	                // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
3352	                if ( event.metaKey === undefined ) {
3353	                        event.metaKey = event.ctrlKey;
3354	                }
3355	
3356	                return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3357	        },
3358	
3359	        special: {
3360	                ready: {
3361	                        // Make sure the ready event is setup
3362	                        setup: jQuery.bindReady
3363	                },
3364	
3365	                load: {
3366	                        // Prevent triggered image.load events from bubbling to window.load
3367	                        noBubble: true
3368	                },
3369	
3370	                focus: {
3371	                        delegateType: "focusin"
3372	                },
3373	                blur: {
3374	                        delegateType: "focusout"
3375	                },
3376	
3377	                beforeunload: {
3378	                        setup: function( data, namespaces, eventHandle ) {
3379	                                // We only want to do this special case on windows
3380	                                if ( jQuery.isWindow( this ) ) {
3381	                                        this.onbeforeunload = eventHandle;
3382	                                }
3383	                        },
3384	
3385	                        teardown: function( namespaces, eventHandle ) {
3386	                                if ( this.onbeforeunload === eventHandle ) {
3387	                                        this.onbeforeunload = null;
3388	                                }
3389	                        }
3390	                }
3391	        },
3392	
3393	        simulate: function( type, elem, event, bubble ) {
3394	                // Piggyback on a donor event to simulate a different one.
3395	                // Fake originalEvent to avoid donor's stopPropagation, but if the
3396	                // simulated event prevents default then we do the same on the donor.
3397	                var e = jQuery.extend(
3398	                        new jQuery.Event(),
3399	                        event,
3400	                        { type: type,
3401	                                isSimulated: true,
3402	                                originalEvent: {}
3403	                        }
3404	                );
3405	                if ( bubble ) {
3406	                        jQuery.event.trigger( e, null, elem );
3407	                } else {
3408	                        jQuery.event.dispatch.call( elem, e );
3409	                }
3410	                if ( e.isDefaultPrevented() ) {
3411	                        event.preventDefault();
3412	                }
3413	        }
3414	};
3415	
3416	// Some plugins are using, but it's undocumented/deprecated and will be removed.
3417	// The 1.7 special event interface should provide all the hooks needed now.
3418	jQuery.event.handle = jQuery.event.dispatch;
3419	
3420	jQuery.removeEvent = document.removeEventListener ?
3421	        function( elem, type, handle ) {
3422	                if ( elem.removeEventListener ) {
3423	                        elem.removeEventListener( type, handle, false );
3424	                }
3425	        } :
3426	        function( elem, type, handle ) {
3427	                if ( elem.detachEvent ) {
3428	                        elem.detachEvent( "on" + type, handle );
3429	                }
3430	        };
3431	
3432	jQuery.Event = function( src, props ) {
3433	        // Allow instantiation without the 'new' keyword
3434	        if ( !(this instanceof jQuery.Event) ) {
3435	                return new jQuery.Event( src, props );
3436	        }
3437	
3438	        // Event object
3439	        if ( src && src.type ) {
3440	                this.originalEvent = src;
3441	                this.type = src.type;
3442	
3443	                // Events bubbling up the document may have been marked as prevented
3444	                // by a handler lower down the tree; reflect the correct value.
3445	                this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3446	                        src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3447	
3448	        // Event type
3449	        } else {
3450	                this.type = src;
3451	        }
3452	
3453	        // Put explicitly provided properties onto the event object
3454	        if ( props ) {
3455	                jQuery.extend( this, props );
3456	        }
3457	
3458	        // Create a timestamp if incoming event doesn't have one
3459	        this.timeStamp = src && src.timeStamp || jQuery.now();
3460	
3461	        // Mark it as fixed
3462	        this[ jQuery.expando ] = true;
3463	};
3464	
3465	function returnFalse() {
3466	        return false;
3467	}
3468	function returnTrue() {
3469	        return true;
3470	}
3471	
3472	// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3473	// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3474	jQuery.Event.prototype = {
3475	        preventDefault: function() {
3476	                this.isDefaultPrevented = returnTrue;
3477	
3478	                var e = this.originalEvent;
3479	                if ( !e ) {
3480	                        return;
3481	                }
3482	
3483	                // if preventDefault exists run it on the original event
3484	                if ( e.preventDefault ) {
3485	                        e.preventDefault();
3486	
3487	                // otherwise set the returnValue property of the original event to false (IE)
3488	                } else {
3489	                        e.returnValue = false;
3490	                }
3491	        },
3492	        stopPropagation: function() {
3493	                this.isPropagationStopped = returnTrue;
3494	
3495	                var e = this.originalEvent;
3496	                if ( !e ) {
3497	                        return;
3498	                }
3499	                // if stopPropagation exists run it on the original event
3500	                if ( e.stopPropagation ) {
3501	                        e.stopPropagation();
3502	                }
3503	                // otherwise set the cancelBubble property of the original event to true (IE)
3504	                e.cancelBubble = true;
3505	        },
3506	        stopImmediatePropagation: function() {
3507	                this.isImmediatePropagationStopped = returnTrue;
3508	                this.stopPropagation();
3509	        },
3510	        isDefaultPrevented: returnFalse,
3511	        isPropagationStopped: returnFalse,
3512	        isImmediatePropagationStopped: returnFalse
3513	};
3514	
3515	// Create mouseenter/leave events using mouseover/out and event-time checks
3516	jQuery.each({
3517	        mouseenter: "mouseover",
3518	        mouseleave: "mouseout"
3519	}, function( orig, fix ) {
3520	        jQuery.event.special[ orig ] = {
3521	                delegateType: fix,
3522	                bindType: fix,
3523	
3524	                handle: function( event ) {
3525	                        var target = this,
3526	                                related = event.relatedTarget,
3527	                                handleObj = event.handleObj,
3528	                                selector = handleObj.selector,
3529	                                ret;
3530	
3531	                        // For mousenter/leave call the handler if related is outside the target.
3532	                        // NB: No relatedTarget if the mouse left/entered the browser window
3533	                        if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3534	                                event.type = handleObj.origType;
3535	                                ret = handleObj.handler.apply( this, arguments );
3536	                                event.type = fix;
3537	                        }
3538	                        return ret;
3539	                }
3540	        };
3541	});
3542	
3543	// IE submit delegation
3544	if ( !jQuery.support.submitBubbles ) {
3545	
3546	        jQuery.event.special.submit = {
3547	                setup: function() {
3548	                        // Only need this for delegated form submit events
3549	                        if ( jQuery.nodeName( this, "form" ) ) {
3550	                                return false;
3551	                        }
3552	
3553	                        // Lazy-add a submit handler when a descendant form may potentially be submitted
3554	                        jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
3555	                                // Node name check avoids a VML-related crash in IE (#9807)
3556	                                var elem = e.target,
3557	                                        form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3558	                                if ( form && !form._submit_attached ) {
3559	                                        jQuery.event.add( form, "submit._submit", function( event ) {
3560	                                                // If form was submitted by the user, bubble the event up the tree
3561	                                                if ( this.parentNode && !event.isTrigger ) {
3562	                                                        jQuery.event.simulate( "submit", this.parentNode, event, true );
3563	                                                }
3564	                                        });
3565	                                        form._submit_attached = true;
3566	                                }
3567	                        });
3568	                        // return undefined since we don't need an event listener
3569	                },
3570	
3571	                teardown: function() {
3572	                        // Only need this for delegated form submit events
3573	                        if ( jQuery.nodeName( this, "form" ) ) {
3574	                                return false;
3575	                        }
3576	
3577	                        // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3578	                        jQuery.event.remove( this, "._submit" );
3579	                }
3580	        };
3581	}
3582	
3583	// IE change delegation and checkbox/radio fix
3584	if ( !jQuery.support.changeBubbles ) {
3585	
3586	        jQuery.event.special.change = {
3587	
3588	                setup: function() {
3589	
3590	                        if ( rformElems.test( this.nodeName ) ) {
3591	                                // IE doesn't fire change on a check/radio until blur; trigger it on click
3592	                                // after a propertychange. Eat the blur-change in special.change.handle.
3593	                                // This still fires onchange a second time for check/radio after blur.
3594	                                if ( this.type === "checkbox" || this.type === "radio" ) {
3595	                                        jQuery.event.add( this, "propertychange._change", function( event ) {
3596	                                                if ( event.originalEvent.propertyName === "checked" ) {
3597	                                                        this._just_changed = true;
3598	                                                }
3599	                                        });
3600	                                        jQuery.event.add( this, "click._change", function( event ) {
3601	                                                if ( this._just_changed && !event.isTrigger ) {
3602	                                                        this._just_changed = false;
3603	                                                        jQuery.event.simulate( "change", this, event, true );
3604	                                                }
3605	                                        });
3606	                                }
3607	                                return false;
3608	                        }
3609	                        // Delegated event; lazy-add a change handler on descendant inputs
3610	                        jQuery.event.add( this, "beforeactivate._change", function( e ) {
3611	                                var elem = e.target;
3612	
3613	                                if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
3614	                                        jQuery.event.add( elem, "change._change", function( event ) {
3615	                                                if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
3616	                                                        jQuery.event.simulate( "change", this.parentNode, event, true );
3617	                                                }
3618	                                        });
3619	                                        elem._change_attached = true;
3620	                                }
3621	                        });
3622	                },
3623	
3624	                handle: function( event ) {
3625	                        var elem = event.target;
3626	
3627	                        // Swallow native change events from checkbox/radio, we already triggered them above
3628	                        if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3629	                                return event.handleObj.handler.apply( this, arguments );
3630	                        }
3631	                },
3632	
3633	                teardown: function() {
3634	                        jQuery.event.remove( this, "._change" );
3635	
3636	                        return rformElems.test( this.nodeName );
3637	                }
3638	        };
3639	}
3640	
3641	// Create "bubbling" focus and blur events
3642	if ( !jQuery.support.focusinBubbles ) {
3643	        jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3644	
3645	                // Attach a single capturing handler while someone wants focusin/focusout
3646	                var attaches = 0,
3647	                        handler = function( event ) {
3648	                                jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
3649	                        };
3650	
3651	                jQuery.event.special[ fix ] = {
3652	                        setup: function() {
3653	                                if ( attaches++ === 0 ) {
3654	                                        document.addEventListener( orig, handler, true );
3655	                                }
3656	                        },
3657	                        teardown: function() {
3658	                                if ( --attaches === 0 ) {
3659	                                        document.removeEventListener( orig, handler, true );
3660	                                }
3661	                        }
3662	                };
3663	        });
3664	}
3665	
3666	jQuery.fn.extend({
3667	
3668	        on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
3669	                var origFn, type;
3670	
3671	                // Types can be a map of types/handlers
3672	                if ( typeof types === "object" ) {
3673	                        // ( types-Object, selector, data )
3674	                        if ( typeof selector !== "string" ) {
3675	                                // ( types-Object, data )
3676	                                data = selector;
3677	                                selector = undefined;
3678	                        }
3679	                        for ( type in types ) {
3680	                                this.on( type, selector, data, types[ type ], one );
3681	                        }
3682	                        return this;
3683	                }
3684	
3685	                if ( data == null && fn == null ) {
3686	                        // ( types, fn )
3687	                        fn = selector;
3688	                        data = selector = undefined;
3689	                } else if ( fn == null ) {
3690	                        if ( typeof selector === "string" ) {
3691	                                // ( types, selector, fn )
3692	                                fn = data;
3693	                                data = undefined;
3694	                        } else {
3695	                                // ( types, data, fn )
3696	                                fn = data;
3697	                                data = selector;
3698	                                selector = undefined;
3699	                        }
3700	                }
3701	                if ( fn === false ) {
3702	                        fn = returnFalse;
3703	                } else if ( !fn ) {
3704	                        return this;
3705	                }
3706	
3707	                if ( one === 1 ) {
3708	                        origFn = fn;
3709	                        fn = function( event ) {
3710	                                // Can use an empty set, since event contains the info
3711	                                jQuery().off( event );
3712	                                return origFn.apply( this, arguments );
3713	                        };
3714	                        // Use same guid so caller can remove using origFn
3715	                        fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
3716	                }
3717	                return this.each( function() {
3718	                        jQuery.event.add( this, types, fn, data, selector );
3719	                });
3720	        },
3721	        one: function( types, selector, data, fn ) {
3722	                return this.on.call( this, types, selector, data, fn, 1 );
3723	        },
3724	        off: function( types, selector, fn ) {
3725	                if ( types && types.preventDefault && types.handleObj ) {
3726	                        // ( event )  dispatched jQuery.Event
3727	                        var handleObj = types.handleObj;
3728	                        jQuery( types.delegateTarget ).off(
3729	                                handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type,
3730	                                handleObj.selector,
3731	                                handleObj.handler
3732	                        );
3733	                        return this;
3734	                }
3735	                if ( typeof types === "object" ) {
3736	                        // ( types-object [, selector] )
3737	                        for ( var type in types ) {
3738	                                this.off( type, selector, types[ type ] );
3739	                        }
3740	                        return this;
3741	                }
3742	                if ( selector === false || typeof selector === "function" ) {
3743	                        // ( types [, fn] )
3744	                        fn = selector;
3745	                        selector = undefined;
3746	                }
3747	                if ( fn === false ) {
3748	                        fn = returnFalse;
3749	                }
3750	                return this.each(function() {
3751	                        jQuery.event.remove( this, types, fn, selector );
3752	                });
3753	        },
3754	
3755	        bind: function( types, data, fn ) {
3756	                return this.on( types, null, data, fn );
3757	        },
3758	        unbind: function( types, fn ) {
3759	                return this.off( types, null, fn );
3760	        },
3761	
3762	        live: function( types, data, fn ) {
3763	                jQuery( this.context ).on( types, this.selector, data, fn );
3764	                return this;
3765	        },
3766	        die: function( types, fn ) {
3767	                jQuery( this.context ).off( types, this.selector || "**", fn );
3768	                return this;
3769	        },
3770	
3771	        delegate: function( selector, types, data, fn ) {
3772	                return this.on( types, selector, data, fn );
3773	        },
3774	        undelegate: function( selector, types, fn ) {
3775	                // ( namespace ) or ( selector, types [, fn] )
3776	                return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
3777	        },
3778	
3779	        trigger: function( type, data ) {
3780	                return this.each(function() {
3781	                        jQuery.event.trigger( type, data, this );
3782	                });
3783	        },
3784	        triggerHandler: function( type, data ) {
3785	                if ( this[0] ) {
3786	                        return jQuery.event.trigger( type, data, this[0], true );
3787	                }
3788	        },
3789	
3790	        toggle: function( fn ) {
3791	                // Save reference to arguments for access in closure
3792	                var args = arguments,
3793	                        guid = fn.guid || jQuery.guid++,
3794	                        i = 0,
3795	                        toggler = function( event ) {
3796	                                // Figure out which function to execute
3797	                                var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3798	                                jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3799	
3800	                                // Make sure that clicks stop
3801	                                event.preventDefault();
3802	
3803	                                // and execute the function
3804	                                return args[ lastToggle ].apply( this, arguments ) || false;
3805	                        };
3806	
3807	                // link all the functions, so any of them can unbind this click handler
3808	                toggler.guid = guid;
3809	                while ( i < args.length ) {
3810	                        args[ i++ ].guid = guid;
3811	                }
3812	
3813	                return this.click( toggler );
3814	        },
3815	
3816	        hover: function( fnOver, fnOut ) {
3817	                return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3818	        }
3819	});
3820	
3821	jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3822	        "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3823	        "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3824	
3825	        // Handle event binding
3826	        jQuery.fn[ name ] = function( data, fn ) {
3827	                if ( fn == null ) {
3828	                        fn = data;
3829	                        data = null;
3830	                }
3831	
3832	                return arguments.length > 0 ?
3833	                        this.on( name, null, data, fn ) :
3834	                        this.trigger( name );
3835	        };
3836	
3837	        if ( jQuery.attrFn ) {
3838	                jQuery.attrFn[ name ] = true;
3839	        }
3840	
3841	        if ( rkeyEvent.test( name ) ) {
3842	                jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
3843	        }
3844	
3845	        if ( rmouseEvent.test( name ) ) {
3846	                jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
3847	        }
3848	});
3849	
3850	
3851	
3852	/*!
3853	 * Sizzle CSS Selector Engine
3854	 *  Copyright 2011, The Dojo Foundation
3855	 *  Released under the MIT, BSD, and GPL Licenses.
3856	 *  More information: http://sizzlejs.com/
3857	 */
3858	(function(){
3859	
3860	var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3861	        expando = "sizcache" + (Math.random() + '').replace('.', ''),
3862	        done = 0,
3863	        toString = Object.prototype.toString,
3864	        hasDuplicate = false,
3865	        baseHasDuplicate = true,
3866	        rBackslash = /\\/g,
3867	        rReturn = /\r\n/g,
3868	        rNonWord = /\W/;
3869	
3870	// Here we check if the JavaScript engine is using some sort of
3871	// optimization where it does not always call our comparision
3872	// function. If that is the case, discard the hasDuplicate value.
3873	//   Thus far that includes Google Chrome.
3874	[0, 0].sort(function() {
3875	        baseHasDuplicate = false;
3876	        return 0;
3877	});
3878	
3879	var Sizzle = function( selector, context, results, seed ) {
3880	        results = results || [];
3881	        context = context || document;
3882	
3883	        var origContext = context;
3884	
3885	        if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3886	                return [];
3887	        }
3888	       
3889	        if ( !selector || typeof selector !== "string" ) {
3890	                return results;
3891	        }
3892	
3893	        var m, set, checkSet, extra, ret, cur, pop, i,
3894	                prune = true,
3895	                contextXML = Sizzle.isXML( context ),
3896	                parts = [],
3897	                soFar = selector;
3898	       
3899	        // Reset the position of the chunker regexp (start from head)
3900	        do {
3901	                chunker.exec( "" );
3902	                m = chunker.exec( soFar );
3903	
3904	                if ( m ) {
3905	                        soFar = m[3];
3906	               
3907	                        parts.push( m[1] );
3908	               
3909	                        if ( m[2] ) {
3910	                                extra = m[3];
3911	                                break;
3912	                        }
3913	                }
3914	        } while ( m );
3915	
3916	        if ( parts.length > 1 && origPOS.exec( selector ) ) {
3917	
3918	                if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3919	                        set = posProcess( parts[0] + parts[1], context, seed );
3920	
3921	                } else {
3922	                        set = Expr.relative[ parts[0] ] ?
3923	                                [ context ] :
3924	                                Sizzle( parts.shift(), context );
3925	
3926	                        while ( parts.length ) {
3927	                                selector = parts.shift();
3928	
3929	                                if ( Expr.relative[ selector ] ) {
3930	                                        selector += parts.shift();
3931	                                }
3932	                               
3933	                                set = posProcess( selector, set, seed );
3934	                        }
3935	                }
3936	
3937	        } else {
3938	                // Take a shortcut and set the context if the root selector is an ID
3939	                // (but not if it'll be faster if the inner selector is an ID)
3940	                if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3941	                                Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3942	
3943	                        ret = Sizzle.find( parts.shift(), context, contextXML );
3944	                        context = ret.expr ?
3945	                                Sizzle.filter( ret.expr, ret.set )[0] :
3946	                                ret.set[0];
3947	                }
3948	
3949	                if ( context ) {
3950	                        ret = seed ?
3951	                                { expr: parts.pop(), set: makeArray(seed) } :
3952	                                Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3953	
3954	                        set = ret.expr ?
3955	                                Sizzle.filter( ret.expr, ret.set ) :
3956	                                ret.set;
3957	
3958	                        if ( parts.length > 0 ) {
3959	                                checkSet = makeArray( set );
3960	
3961	                        } else {
3962	                                prune = false;
3963	                        }
3964	
3965	                        while ( parts.length ) {
3966	                                cur = parts.pop();
3967	                                pop = cur;
3968	
3969	                                if ( !Expr.relative[ cur ] ) {
3970	                                        cur = "";
3971	                                } else {
3972	                                        pop = parts.pop();
3973	                                }
3974	
3975	                                if ( pop == null ) {
3976	                                        pop = context;
3977	                                }
3978	
3979	                                Expr.relative[ cur ]( checkSet, pop, contextXML );
3980	                        }
3981	
3982	                } else {
3983	                        checkSet = parts = [];
3984	                }
3985	        }
3986	
3987	        if ( !checkSet ) {
3988	                checkSet = set;
3989	        }
3990	
3991	        if ( !checkSet ) {
3992	                Sizzle.error( cur || selector );
3993	        }
3994	
3995	        if ( toString.call(checkSet) === "[object Array]" ) {
3996	                if ( !prune ) {
3997	                        results.push.apply( results, checkSet );
3998	
3999	                } else if ( context && context.nodeType === 1 ) {
4000	                        for ( i = 0; checkSet[i] != null; i++ ) {
4001	                                if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
4002	                                        results.push( set[i] );
4003	                                }
4004	                        }
4005	
4006	                } else {
4007	                        for ( i = 0; checkSet[i] != null; i++ ) {
4008	                                if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
4009	                                        results.push( set[i] );
4010	                                }
4011	                        }
4012	                }
4013	
4014	        } else {
4015	                makeArray( checkSet, results );
4016	        }
4017	
4018	        if ( extra ) {
4019	                Sizzle( extra, origContext, results, seed );
4020	                Sizzle.uniqueSort( results );
4021	        }
4022	
4023	        return results;
4024	};
4025	
4026	Sizzle.uniqueSort = function( results ) {
4027	        if ( sortOrder ) {
4028	                hasDuplicate = baseHasDuplicate;
4029	                results.sort( sortOrder );
4030	
4031	                if ( hasDuplicate ) {
4032	                        for ( var i = 1; i < results.length; i++ ) {
4033	                                if ( results[i] === results[ i - 1 ] ) {
4034	                                        results.splice( i--, 1 );
4035	                                }
4036	                        }
4037	                }
4038	        }
4039	
4040	        return results;
4041	};
4042	
4043	Sizzle.matches = function( expr, set ) {
4044	        return Sizzle( expr, null, null, set );
4045	};
4046	
4047	Sizzle.matchesSelector = function( node, expr ) {
4048	        return Sizzle( expr, null, null, [node] ).length > 0;
4049	};
4050	
4051	Sizzle.find = function( expr, context, isXML ) {
4052	        var set, i, len, match, type, left;
4053	
4054	        if ( !expr ) {
4055	                return [];
4056	        }
4057	
4058	        for ( i = 0, len = Expr.order.length; i < len; i++ ) {
4059	                type = Expr.order[i];
4060	               
4061	                if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
4062	                        left = match[1];
4063	                        match.splice( 1, 1 );
4064	
4065	                        if ( left.substr( left.length - 1 ) !== "\\" ) {
4066	                                match[1] = (match[1] || "").replace( rBackslash, "" );
4067	                                set = Expr.find[ type ]( match, context, isXML );
4068	
4069	                                if ( set != null ) {
4070	                                        expr = expr.replace( Expr.match[ type ], "" );
4071	                                        break;
4072	                                }
4073	                        }
4074	                }
4075	        }
4076	
4077	        if ( !set ) {
4078	                set = typeof context.getElementsByTagName !== "undefined" ?
4079	                        context.getElementsByTagName( "*" ) :
4080	                        [];
4081	        }
4082	
4083	        return { set: set, expr: expr };
4084	};
4085	
4086	Sizzle.filter = function( expr, set, inplace, not ) {
4087	        var match, anyFound,
4088	                type, found, item, filter, left,
4089	                i, pass,
4090	                old = expr,
4091	                result = [],
4092	                curLoop = set,
4093	                isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
4094	
4095	        while ( expr && set.length ) {
4096	                for ( type in Expr.filter ) {
4097	                        if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
4098	                                filter = Expr.filter[ type ];
4099	                                left = match[1];
4100	
4101	                                anyFound = false;
4102	
4103	                                match.splice(1,1);
4104	
4105	                                if ( left.substr( left.length - 1 ) === "\\" ) {
4106	                                        continue;
4107	                                }
4108	
4109	                                if ( curLoop === result ) {
4110	                                        result = [];
4111	                                }
4112	
4113	                                if ( Expr.preFilter[ type ] ) {
4114	                                        match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
4115	
4116	                                        if ( !match ) {
4117	                                                anyFound = found = true;
4118	
4119	                                        } else if ( match === true ) {
4120	                                                continue;
4121	                                        }
4122	                                }
4123	
4124	                                if ( match ) {
4125	                                        for ( i = 0; (item = curLoop[i]) != null; i++ ) {
4126	                                                if ( item ) {
4127	                                                        found = filter( item, match, i, curLoop );
4128	                                                        pass = not ^ found;
4129	
4130	                                                        if ( inplace && found != null ) {
4131	                                                                if ( pass ) {
4132	                                                                        anyFound = true;
4133	
4134	                                                                } else {
4135	                                                                        curLoop[i] = false;
4136	                                                                }
4137	
4138	                                                        } else if ( pass ) {
4139	                                                                result.push( item );
4140	                                                                anyFound = true;
4141	                                                        }
4142	                                                }
4143	                                        }
4144	                                }
4145	
4146	                                if ( found !== undefined ) {
4147	                                        if ( !inplace ) {
4148	                                                curLoop = result;
4149	                                        }
4150	
4151	                                        expr = expr.replace( Expr.match[ type ], "" );
4152	
4153	                                        if ( !anyFound ) {
4154	                                                return [];
4155	                                        }
4156	
4157	                                        break;
4158	                                }
4159	                        }
4160	                }
4161	
4162	                // Improper expression
4163	                if ( expr === old ) {
4164	                        if ( anyFound == null ) {
4165	                                Sizzle.error( expr );
4166	
4167	                        } else {
4168	                                break;
4169	                        }
4170	                }
4171	
4172	                old = expr;
4173	        }
4174	
4175	        return curLoop;
4176	};
4177	
4178	Sizzle.error = function( msg ) {
4179	        throw new Error( "Syntax error, unrecognized expression: " + msg );
4180	};
4181	
4182	/**
4183	 * Utility function for retreiving the text value of an array of DOM nodes
4184	 * @param {Array|Element} elem
4185	 */
4186	var getText = Sizzle.getText = function( elem ) {
4187	    var i, node,
4188	                nodeType = elem.nodeType,
4189	                ret = "";
4190	
4191	        if ( nodeType ) {
4192	                if ( nodeType === 1 || nodeType === 9 ) {
4193	                        // Use textContent || innerText for elements
4194	                        if ( typeof elem.textContent === 'string' ) {
4195	                                return elem.textContent;
4196	                        } else if ( typeof elem.innerText === 'string' ) {
4197	                                // Replace IE's carriage returns
4198	                                return elem.innerText.replace( rReturn, '' );
4199	                        } else {
4200	                                // Traverse it's children
4201	                                for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
4202	                                        ret += getText( elem );
4203	                                }
4204	                        }
4205	                } else if ( nodeType === 3 || nodeType === 4 ) {
4206	                        return elem.nodeValue;
4207	                }
4208	        } else {
4209	
4210	                // If no nodeType, this is expected to be an array
4211	                for ( i = 0; (node = elem[i]); i++ ) {
4212	                        // Do not traverse comment nodes
4213	                        if ( node.nodeType !== 8 ) {
4214	                                ret += getText( node );
4215	                        }
4216	                }
4217	        }
4218	        return ret;
4219	};
4220	
4221	var Expr = Sizzle.selectors = {
4222	        order: [ "ID", "NAME", "TAG" ],
4223	
4224	        match: {
4225	                ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4226	                CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4227	                NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
4228	                ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
4229	                TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
4230	                CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
4231	                POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
4232	                PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
4233	        },
4234	
4235	        leftMatch: {},
4236	
4237	        attrMap: {
4238	                "class": "className",
4239	                "for": "htmlFor"
4240	        },
4241	
4242	        attrHandle: {
4243	                href: function( elem ) {
4244	                        return elem.getAttribute( "href" );
4245	                },
4246	                type: function( elem ) {
4247	                        return elem.getAttribute( "type" );
4248	                }
4249	        },
4250	
4251	        relative: {
4252	                "+": function(checkSet, part){
4253	                        var isPartStr = typeof part === "string",
4254	                                isTag = isPartStr && !rNonWord.test( part ),
4255	                                isPartStrNotTag = isPartStr && !isTag;
4256	
4257	                        if ( isTag ) {
4258	                                part = part.toLowerCase();
4259	                        }
4260	
4261	                        for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4262	                                if ( (elem = checkSet[i]) ) {
4263	                                        while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4264	
4265	                                        checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
4266	                                                elem || false :
4267	                                                elem === part;
4268	                                }
4269	                        }
4270	
4271	                        if ( isPartStrNotTag ) {
4272	                                Sizzle.filter( part, checkSet, true );
4273	                        }
4274	                },
4275	
4276	                ">": function( checkSet, part ) {
4277	                        var elem,
4278	                                isPartStr = typeof part === "string",
4279	                                i = 0,
4280	                                l = checkSet.length;
4281	
4282	                        if ( isPartStr && !rNonWord.test( part ) ) {
4283	                                part = part.toLowerCase();
4284	
4285	                                for ( ; i < l; i++ ) {
4286	                                        elem = checkSet[i];
4287	
4288	                                        if ( elem ) {
4289	                                                var parent = elem.parentNode;
4290	                                                checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4291	                                        }
4292	                                }
4293	
4294	                        } else {
4295	                                for ( ; i < l; i++ ) {
4296	                                        elem = checkSet[i];
4297	
4298	                                        if ( elem ) {
4299	                                                checkSet[i] = isPartStr ?
4300	                                                        elem.parentNode :
4301	                                                        elem.parentNode === part;
4302	                                        }
4303	                                }
4304	
4305	                                if ( isPartStr ) {
4306	                                        Sizzle.filter( part, checkSet, true );
4307	                                }
4308	                        }
4309	                },
4310	
4311	                "": function(checkSet, part, isXML){
4312	                        var nodeCheck,
4313	                                doneName = done++,
4314	                                checkFn = dirCheck;
4315	
4316	                        if ( typeof part === "string" && !rNonWord.test( part ) ) {
4317	                                part = part.toLowerCase();
4318	                                nodeCheck = part;
4319	                                checkFn = dirNodeCheck;
4320	                        }
4321	
4322	                        checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4323	                },
4324	
4325	                "~": function( checkSet, part, isXML ) {
4326	                        var nodeCheck,
4327	                                doneName = done++,
4328	                                checkFn = dirCheck;
4329	
4330	                        if ( typeof part === "string" && !rNonWord.test( part ) ) {
4331	                                part = part.toLowerCase();
4332	                                nodeCheck = part;
4333	                                checkFn = dirNodeCheck;
4334	                        }
4335	
4336	                        checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4337	                }
4338	        },
4339	
4340	        find: {
4341	                ID: function( match, context, isXML ) {
4342	                        if ( typeof context.getElementById !== "undefined" && !isXML ) {
4343	                                var m = context.getElementById(match[1]);
4344	                                // Check parentNode to catch when Blackberry 4.6 returns
4345	                                // nodes that are no longer in the document #6963
4346	                                return m && m.parentNode ? [m] : [];
4347	                        }
4348	                },
4349	
4350	                NAME: function( match, context ) {
4351	                        if ( typeof context.getElementsByName !== "undefined" ) {
4352	                                var ret = [],
4353	                                        results = context.getElementsByName( match[1] );
4354	
4355	                                for ( var i = 0, l = results.length; i < l; i++ ) {
4356	                                        if ( results[i].getAttribute("name") === match[1] ) {
4357	                                                ret.push( results[i] );
4358	                                        }
4359	                                }
4360	
4361	                                return ret.length === 0 ? null : ret;
4362	                        }
4363	                },
4364	
4365	                TAG: function( match, context ) {
4366	                        if ( typeof context.getElementsByTagName !== "undefined" ) {
4367	                                return context.getElementsByTagName( match[1] );
4368	                        }
4369	                }
4370	        },
4371	        preFilter: {
4372	                CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4373	                        match = " " + match[1].replace( rBackslash, "" ) + " ";
4374	
4375	                        if ( isXML ) {
4376	                                return match;
4377	                        }
4378	
4379	                        for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4380	                                if ( elem ) {
4381	                                        if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4382	                                                if ( !inplace ) {
4383	                                                        result.push( elem );
4384	                                                }
4385	
4386	                                        } else if ( inplace ) {
4387	                                                curLoop[i] = false;
4388	                                        }
4389	                                }
4390	                        }
4391	
4392	                        return false;
4393	                },
4394	
4395	                ID: function( match ) {
4396	                        return match[1].replace( rBackslash, "" );
4397	                },
4398	
4399	                TAG: function( match, curLoop ) {
4400	                        return match[1].replace( rBackslash, "" ).toLowerCase();
4401	                },
4402	
4403	                CHILD: function( match ) {
4404	                        if ( match[1] === "nth" ) {
4405	                                if ( !match[2] ) {
4406	                                        Sizzle.error( match[0] );
4407	                                }
4408	
4409	                                match[2] = match[2].replace(/^\+|\s*/g, '');
4410	
4411	                                // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4412	                                var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
4413	                                        match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
4414	                                        !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
4415	
4416	                                // calculate the numbers (first)n+(last) including if they are negative
4417	                                match[2] = (test[1] + (test[2] || 1)) - 0;
4418	                                match[3] = test[3] - 0;
4419	                        }
4420	                        else if ( match[2] ) {
4421	                                Sizzle.error( match[0] );
4422	                        }
4423	
4424	                        // TODO: Move to normal caching system
4425	                        match[0] = done++;
4426	
4427	                        return match;
4428	                },
4429	
4430	                ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4431	                        var name = match[1] = match[1].replace( rBackslash, "" );
4432	                       
4433	                        if ( !isXML && Expr.attrMap[name] ) {
4434	                                match[1] = Expr.attrMap[name];
4435	                        }
4436	
4437	                        // Handle if an un-quoted value was used
4438	                        match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
4439	
4440	                        if ( match[2] === "~=" ) {
4441	                                match[4] = " " + match[4] + " ";
4442	                        }
4443	
4444	                        return match;
4445	                },
4446	
4447	                PSEUDO: function( match, curLoop, inplace, result, not ) {
4448	                        if ( match[1] === "not" ) {
4449	                                // If we're dealing with a complex expression, or a simple one
4450	                                if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
4451	                                        match[3] = Sizzle(match[3], null, null, curLoop);
4452	
4453	                                } else {
4454	                                        var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4455	
4456	                                        if ( !inplace ) {
4457	                                                result.push.apply( result, ret );
4458	                                        }
4459	
4460	                                        return false;
4461	                                }
4462	
4463	                        } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
4464	                                return true;
4465	                        }
4466	                       
4467	                        return match;
4468	                },
4469	
4470	                POS: function( match ) {
4471	                        match.unshift( true );
4472	
4473	                        return match;
4474	                }
4475	        },
4476	       
4477	        filters: {
4478	                enabled: function( elem ) {
4479	                        return elem.disabled === false && elem.type !== "hidden";
4480	                },
4481	
4482	                disabled: function( elem ) {
4483	                        return elem.disabled === true;
4484	                },
4485	
4486	                checked: function( elem ) {
4487	                        return elem.checked === true;
4488	                },
4489	               
4490	                selected: function( elem ) {
4491	                        // Accessing this property makes selected-by-default
4492	                        // options in Safari work properly
4493	                        if ( elem.parentNode ) {
4494	                                elem.parentNode.selectedIndex;
4495	                        }
4496	                       
4497	                        return elem.selected === true;
4498	                },
4499	
4500	                parent: function( elem ) {
4501	                        return !!elem.firstChild;
4502	                },
4503	
4504	                empty: function( elem ) {
4505	                        return !elem.firstChild;
4506	                },
4507	
4508	                has: function( elem, i, match ) {
4509	                        return !!Sizzle( match[3], elem ).length;
4510	                },
4511	
4512	                header: function( elem ) {
4513	                        return (/h\d/i).test( elem.nodeName );
4514	                },
4515	
4516	                text: function( elem ) {
4517	                        var attr = elem.getAttribute( "type" ), type = elem.type;
4518	                        // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4519	                        // use getAttribute instead to test this case
4520	                        return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
4521	                },
4522	
4523	                radio: function( elem ) {
4524	                        return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4525	                },
4526	
4527	                checkbox: function( elem ) {
4528	                        return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4529	                },
4530	
4531	                file: function( elem ) {
4532	                        return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4533	                },
4534	
4535	                password: function( elem ) {
4536	                        return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4537	                },
4538	
4539	                submit: function( elem ) {
4540	                        var name = elem.nodeName.toLowerCase();
4541	                        return (name === "input" || name === "button") && "submit" === elem.type;
4542	                },
4543	
4544	                image: function( elem ) {
4545	                        return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4546	                },
4547	
4548	                reset: function( elem ) {
4549	                        var name = elem.nodeName.toLowerCase();
4550	                        return (name === "input" || name === "button") && "reset" === elem.type;
4551	                },
4552	
4553	                button: function( elem ) {
4554	                        var name = elem.nodeName.toLowerCase();
4555	                        return name === "input" && "button" === elem.type || name === "button";
4556	                },
4557	
4558	                input: function( elem ) {
4559	                        return (/input|select|textarea|button/i).test( elem.nodeName );
4560	                },
4561	
4562	                focus: function( elem ) {
4563	                        return elem === elem.ownerDocument.activeElement;
4564	                }
4565	        },
4566	        setFilters: {
4567	                first: function( elem, i ) {
4568	                        return i === 0;
4569	                },
4570	
4571	                last: function( elem, i, match, array ) {
4572	                        return i === array.length - 1;
4573	                },
4574	
4575	                even: function( elem, i ) {
4576	                        return i % 2 === 0;
4577	                },
4578	
4579	                odd: function( elem, i ) {
4580	                        return i % 2 === 1;
4581	                },
4582	
4583	                lt: function( elem, i, match ) {
4584	                        return i < match[3] - 0;
4585	                },
4586	
4587	                gt: function( elem, i, match ) {
4588	                        return i > match[3] - 0;
4589	                },
4590	
4591	                nth: function( elem, i, match ) {
4592	                        return match[3] - 0 === i;
4593	                },
4594	
4595	                eq: function( elem, i, match ) {
4596	                        return match[3] - 0 === i;
4597	                }
4598	        },
4599	        filter: {
4600	                PSEUDO: function( elem, match, i, array ) {
4601	                        var name = match[1],
4602	                                filter = Expr.filters[ name ];
4603	
4604	                        if ( filter ) {
4605	                                return filter( elem, i, match, array );
4606	
4607	                        } else if ( name === "contains" ) {
4608	                                return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
4609	
4610	                        } else if ( name === "not" ) {
4611	                                var not = match[3];
4612	
4613	                                for ( var j = 0, l = not.length; j < l; j++ ) {
4614	                                        if ( not[j] === elem ) {
4615	                                                return false;
4616	                                        }
4617	                                }
4618	
4619	                                return true;
4620	
4621	                        } else {
4622	                                Sizzle.error( name );
4623	                        }
4624	                },
4625	
4626	                CHILD: function( elem, match ) {
4627	                        var first, last,
4628	                                doneName, parent, cache,
4629	                                count, diff,
4630	                                type = match[1],
4631	                                node = elem;
4632	
4633	                        switch ( type ) {
4634	                                case "only":
4635	                                case "first":
4636	                                        while ( (node = node.previousSibling) )  {
4637	                                                if ( node.nodeType === 1 ) { 
4638	                                                        return false; 
4639	                                                }
4640	                                        }
4641	
4642	                                        if ( type === "first" ) { 
4643	                                                return true; 
4644	                                        }
4645	
4646	                                        node = elem;
4647	
4648	                                case "last":
4649	                                        while ( (node = node.nextSibling) )      {
4650	                                                if ( node.nodeType === 1 ) { 
4651	                                                        return false; 
4652	                                                }
4653	                                        }
4654	
4655	                                        return true;
4656	
4657	                                case "nth":
4658	                                        first = match[2];
4659	                                        last = match[3];
4660	
4661	                                        if ( first === 1 && last === 0 ) {
4662	                                                return true;
4663	                                        }
4664	                                       
4665	                                        doneName = match[0];
4666	                                        parent = elem.parentNode;
4667	       
4668	                                        if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
4669	                                                count = 0;
4670	                                               
4671	                                                for ( node = parent.firstChild; node; node = node.nextSibling ) {
4672	                                                        if ( node.nodeType === 1 ) {
4673	                                                                node.nodeIndex = ++count;
4674	                                                        }
4675	                                                } 
4676	
4677	                                                parent[ expando ] = doneName;
4678	                                        }
4679	                                       
4680	                                        diff = elem.nodeIndex - last;
4681	
4682	                                        if ( first === 0 ) {
4683	                                                return diff === 0;
4684	
4685	                                        } else {
4686	                                                return ( diff % first === 0 && diff / first >= 0 );
4687	                                        }
4688	                        }
4689	                },
4690	
4691	                ID: function( elem, match ) {
4692	                        return elem.nodeType === 1 && elem.getAttribute("id") === match;
4693	                },
4694	
4695	                TAG: function( elem, match ) {
4696	                        return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
4697	                },
4698	               
4699	                CLASS: function( elem, match ) {
4700	                        return (" " + (elem.className || elem.getAttribute("class")) + " ")
4701	                                .indexOf( match ) > -1;
4702	                },
4703	
4704	                ATTR: function( elem, match ) {
4705	                        var name = match[1],
4706	                                result = Sizzle.attr ?
4707	                                        Sizzle.attr( elem, name ) :
4708	                                        Expr.attrHandle[ name ] ?
4709	                                        Expr.attrHandle[ name ]( elem ) :
4710	                                        elem[ name ] != null ?
4711	                                                elem[ name ] :
4712	                                                elem.getAttribute( name ),
4713	                                value = result + "",
4714	                                type = match[2],
4715	                                check = match[4];
4716	
4717	                        return result == null ?
4718	                                type === "!=" :
4719	                                !type && Sizzle.attr ?
4720	                                result != null :
4721	                                type === "=" ?
4722	                                value === check :
4723	                                type === "*=" ?
4724	                                value.indexOf(check) >= 0 :
4725	                                type === "~=" ?
4726	                                (" " + value + " ").indexOf(check) >= 0 :
4727	                                !check ?
4728	                                value && result !== false :
4729	                                type === "!=" ?
4730	                                value !== check :
4731	                                type === "^=" ?
4732	                                value.indexOf(check) === 0 :
4733	                                type === "$=" ?
4734	                                value.substr(value.length - check.length) === check :
4735	                                type === "|=" ?
4736	                                value === check || value.substr(0, check.length + 1) === check + "-" :
4737	                                false;
4738	                },
4739	
4740	                POS: function( elem, match, i, array ) {
4741	                        var name = match[2],
4742	                                filter = Expr.setFilters[ name ];
4743	
4744	                        if ( filter ) {
4745	                                return filter( elem, i, match, array );
4746	                        }
4747	                }
4748	        }
4749	};
4750	
4751	var origPOS = Expr.match.POS,
4752	        fescape = function(all, num){
4753	                return "\\" + (num - 0 + 1);
4754	        };
4755	
4756	for ( var type in Expr.match ) {
4757	        Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
4758	        Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4759	}
4760	
4761	var makeArray = function( array, results ) {
4762	        array = Array.prototype.slice.call( array, 0 );
4763	
4764	        if ( results ) {
4765	                results.push.apply( results, array );
4766	                return results;
4767	        }
4768	       
4769	        return array;
4770	};
4771	
4772	// Perform a simple check to determine if the browser is capable of
4773	// converting a NodeList to an array using builtin methods.
4774	// Also verifies that the returned array holds DOM nodes
4775	// (which is not the case in the Blackberry browser)
4776	try {
4777	        Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4778	
4779	// Provide a fallback method if it does not work
4780	} catch( e ) {
4781	        makeArray = function( array, results ) {
4782	                var i = 0,
4783	                        ret = results || [];
4784	
4785	                if ( toString.call(array) === "[object Array]" ) {
4786	                        Array.prototype.push.apply( ret, array );
4787	
4788	                } else {
4789	                        if ( typeof array.length === "number" ) {
4790	                                for ( var l = array.length; i < l; i++ ) {
4791	                                        ret.push( array[i] );
4792	                                }
4793	
4794	                        } else {
4795	                                for ( ; array[i]; i++ ) {
4796	                                        ret.push( array[i] );
4797	                                }
4798	                        }
4799	                }
4800	
4801	                return ret;
4802	        };
4803	}
4804	
4805	var sortOrder, siblingCheck;
4806	
4807	if ( document.documentElement.compareDocumentPosition ) {
4808	        sortOrder = function( a, b ) {
4809	                if ( a === b ) {
4810	                        hasDuplicate = true;
4811	                        return 0;
4812	                }
4813	
4814	                if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
4815	                        return a.compareDocumentPosition ? -1 : 1;
4816	                }
4817	
4818	                return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4819	        };
4820	
4821	} else {
4822	        sortOrder = function( a, b ) {
4823	                // The nodes are identical, we can exit early
4824	                if ( a === b ) {
4825	                        hasDuplicate = true;
4826	                        return 0;
4827	
4828	                // Fallback to using sourceIndex (in IE) if it's available on both nodes
4829	                } else if ( a.sourceIndex && b.sourceIndex ) {
4830	                        return a.sourceIndex - b.sourceIndex;
4831	                }
4832	
4833	                var al, bl,
4834	                        ap = [],
4835	                        bp = [],
4836	                        aup = a.parentNode,
4837	                        bup = b.parentNode,
4838	                        cur = aup;
4839	
4840	                // If the nodes are siblings (or identical) we can do a quick check
4841	                if ( aup === bup ) {
4842	                        return siblingCheck( a, b );
4843	
4844	                // If no parents were found then the nodes are disconnected
4845	                } else if ( !aup ) {
4846	                        return -1;
4847	
4848	                } else if ( !bup ) {
4849	                        return 1;
4850	                }
4851	
4852	                // Otherwise they're somewhere else in the tree so we need
4853	                // to build up a full list of the parentNodes for comparison
4854	                while ( cur ) {
4855	                        ap.unshift( cur );
4856	                        cur = cur.parentNode;
4857	                }
4858	
4859	                cur = bup;
4860	
4861	                while ( cur ) {
4862	                        bp.unshift( cur );
4863	                        cur = cur.parentNode;
4864	                }
4865	
4866	                al = ap.length;
4867	                bl = bp.length;
4868	
4869	                // Start walking down the tree looking for a discrepancy
4870	                for ( var i = 0; i < al && i < bl; i++ ) {
4871	                        if ( ap[i] !== bp[i] ) {
4872	                                return siblingCheck( ap[i], bp[i] );
4873	                        }
4874	                }
4875	
4876	                // We ended someplace up the tree so do a sibling check
4877	                return i === al ?
4878	                        siblingCheck( a, bp[i], -1 ) :
4879	                        siblingCheck( ap[i], b, 1 );
4880	        };
4881	
4882	        siblingCheck = function( a, b, ret ) {
4883	                if ( a === b ) {
4884	                        return ret;
4885	                }
4886	
4887	                var cur = a.nextSibling;
4888	
4889	                while ( cur ) {
4890	                        if ( cur === b ) {
4891	                                return -1;
4892	                        }
4893	
4894	                        cur = cur.nextSibling;
4895	                }
4896	
4897	                return 1;
4898	        };
4899	}
4900	
4901	// Check to see if the browser returns elements by name when
4902	// querying by getElementById (and provide a workaround)
4903	(function(){
4904	        // We're going to inject a fake input element with a specified name
4905	        var form = document.createElement("div"),
4906	                id = "script" + (new Date()).getTime(),
4907	                root = document.documentElement;
4908	
4909	        form.innerHTML = "<a name='" + id + "'/>";
4910	
4911	        // Inject it into the root element, check its status, and remove it quickly
4912	        root.insertBefore( form, root.firstChild );
4913	
4914	        // The workaround has to do additional checks after a getElementById
4915	        // Which slows things down for other browsers (hence the branching)
4916	        if ( document.getElementById( id ) ) {
4917	                Expr.find.ID = function( match, context, isXML ) {
4918	                        if ( typeof context.getElementById !== "undefined" && !isXML ) {
4919	                                var m = context.getElementById(match[1]);
4920	
4921	                                return m ?
4922	                                        m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4923	                                                [m] :
4924	                                                undefined :
4925	                                        [];
4926	                        }
4927	                };
4928	
4929	                Expr.filter.ID = function( elem, match ) {
4930	                        var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4931	
4932	                        return elem.nodeType === 1 && node && node.nodeValue === match;
4933	                };
4934	        }
4935	
4936	        root.removeChild( form );
4937	
4938	        // release memory in IE
4939	        root = form = null;
4940	})();
4941	
4942	(function(){
4943	        // Check to see if the browser returns only elements
4944	        // when doing getElementsByTagName("*")
4945	
4946	        // Create a fake element
4947	        var div = document.createElement("div");
4948	        div.appendChild( document.createComment("") );
4949	
4950	        // Make sure no comments are found
4951	        if ( div.getElementsByTagName("*").length > 0 ) {
4952	                Expr.find.TAG = function( match, context ) {
4953	                        var results = context.getElementsByTagName( match[1] );
4954	
4955	                        // Filter out possible comments
4956	                        if ( match[1] === "*" ) {
4957	                                var tmp = [];
4958	
4959	                                for ( var i = 0; results[i]; i++ ) {
4960	                                        if ( results[i].nodeType === 1 ) {
4961	                                                tmp.push( results[i] );
4962	                                        }
4963	                                }
4964	
4965	                                results = tmp;
4966	                        }
4967	
4968	                        return results;
4969	                };
4970	        }
4971	
4972	        // Check to see if an attribute returns normalized href attributes
4973	        div.innerHTML = "<a href='#'></a>";
4974	
4975	        if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4976	                        div.firstChild.getAttribute("href") !== "#" ) {
4977	
4978	                Expr.attrHandle.href = function( elem ) {
4979	                        return elem.getAttribute( "href", 2 );
4980	                };
4981	        }
4982	
4983	        // release memory in IE
4984	        div = null;
4985	})();
4986	
4987	if ( document.querySelectorAll ) {
4988	        (function(){
4989	                var oldSizzle = Sizzle,
4990	                        div = document.createElement("div"),
4991	                        id = "__sizzle__";
4992	
4993	                div.innerHTML = "<p class='TEST'></p>";
4994	
4995	                // Safari can't handle uppercase or unicode characters when
4996	                // in quirks mode.
4997	                if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4998	                        return;
4999	                }
5000	       
5001	                Sizzle = function( query, context, extra, seed ) {
5002	                        context = context || document;
5003	
5004	                        // Only use querySelectorAll on non-XML documents
5005	                        // (ID selectors don't work in non-HTML documents)
5006	                        if ( !seed && !Sizzle.isXML(context) ) {
5007	                                // See if we find a selector to speed up
5008	                                var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
5009	                               
5010	                                if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
5011	                                        // Speed-up: Sizzle("TAG")
5012	                                        if ( match[1] ) {
5013	                                                return makeArray( context.getElementsByTagName( query ), extra );
5014	                                       
5015	                                        // Speed-up: Sizzle(".CLASS")
5016	                                        } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
5017	                                                return makeArray( context.getElementsByClassName( match[2] ), extra );
5018	                                        }
5019	                                }
5020	                               
5021	                                if ( context.nodeType === 9 ) {
5022	                                        // Speed-up: Sizzle("body")
5023	                                        // The body element only exists once, optimize finding it
5024	                                        if ( query === "body" && context.body ) {
5025	                                                return makeArray( [ context.body ], extra );
5026	                                               
5027	                                        // Speed-up: Sizzle("#ID")
5028	                                        } else if ( match && match[3] ) {
5029	                                                var elem = context.getElementById( match[3] );
5030	
5031	                                                // Check parentNode to catch when Blackberry 4.6 returns
5032	                                                // nodes that are no longer in the document #6963
5033	                                                if ( elem && elem.parentNode ) {
5034	                                                        // Handle the case where IE and Opera return items
5035	                                                        // by name instead of ID
5036	                                                        if ( elem.id === match[3] ) {
5037	                                                                return makeArray( [ elem ], extra );
5038	                                                        }
5039	                                                       
5040	                                                } else {
5041	                                                        return makeArray( [], extra );
5042	                                                }
5043	                                        }
5044	                                       
5045	                                        try {
5046	                                                return makeArray( context.querySelectorAll(query), extra );
5047	                                        } catch(qsaError) {}
5048	
5049	                                // qSA works strangely on Element-rooted queries
5050	                                // We can work around this by specifying an extra ID on the root
5051	                                // and working up from there (Thanks to Andrew Dupont for the technique)
5052	                                // IE 8 doesn't work on object elements
5053	                                } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
5054	                                        var oldContext = context,
5055	                                                old = context.getAttribute( "id" ),
5056	                                                nid = old || id,
5057	                                                hasParent = context.parentNode,
5058	                                                relativeHierarchySelector = /^\s*[+~]/.test( query );
5059	
5060	                                        if ( !old ) {
5061	                                                context.setAttribute( "id", nid );
5062	                                        } else {
5063	                                                nid = nid.replace( /'/g, "\\$&" );
5064	                                        }
5065	                                        if ( relativeHierarchySelector && hasParent ) {
5066	                                                context = context.parentNode;
5067	                                        }
5068	
5069	                                        try {
5070	                                                if ( !relativeHierarchySelector || hasParent ) {
5071	                                                        return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
5072	                                                }
5073	
5074	                                        } catch(pseudoError) {
5075	                                        } finally {
5076	                                                if ( !old ) {
5077	                                                        oldContext.removeAttribute( "id" );
5078	                                                }
5079	                                        }
5080	                                }
5081	                        }
5082	               
5083	                        return oldSizzle(query, context, extra, seed);
5084	                };
5085	
5086	                for ( var prop in oldSizzle ) {
5087	                        Sizzle[ prop ] = oldSizzle[ prop ];
5088	                }
5089	
5090	                // release memory in IE
5091	                div = null;
5092	        })();
5093	}
5094	
5095	(function(){
5096	        var html = document.documentElement,
5097	                matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
5098	
5099	        if ( matches ) {
5100	                // Check to see if it's possible to do matchesSelector
5101	                // on a disconnected node (IE 9 fails this)
5102	                var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
5103	                        pseudoWorks = false;
5104	
5105	                try {
5106	                        // This should fail with an exception
5107	                        // Gecko does not error, returns false instead
5108	                        matches.call( document.documentElement, "[test!='']:sizzle" );
5109	       
5110	                } catch( pseudoError ) {
5111	                        pseudoWorks = true;
5112	                }
5113	
5114	                Sizzle.matchesSelector = function( node, expr ) {
5115	                        // Make sure that attribute selectors are quoted
5116	                        expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
5117	
5118	                        if ( !Sizzle.isXML( node ) ) {
5119	                                try { 
5120	                                        if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
5121	                                                var ret = matches.call( node, expr );
5122	
5123	                                                // IE 9's matchesSelector returns false on disconnected nodes
5124	                                                if ( ret || !disconnectedMatch ||
5125	                                                                // As well, disconnected nodes are said to be in a document
5126	                                                                // fragment in IE 9, so check for that
5127	                                                                node.document && node.document.nodeType !== 11 ) {
5128	                                                        return ret;
5129	                                                }
5130	                                        }
5131	                                } catch(e) {}
5132	                        }
5133	
5134	                        return Sizzle(expr, null, null, [node]).length > 0;
5135	                };
5136	        }
5137	})();
5138	
5139	(function(){
5140	        var div = document.createElement("div");
5141	
5142	        div.innerHTML = "<div class='test e'></div><div class='test'></div>";
5143	
5144	        // Opera can't find a second classname (in 9.6)
5145	        // Also, make sure that getElementsByClassName actually exists
5146	        if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
5147	                return;
5148	        }
5149	
5150	        // Safari caches class attributes, doesn't catch changes (in 3.2)
5151	        div.lastChild.className = "e";
5152	
5153	        if ( div.getElementsByClassName("e").length === 1 ) {
5154	                return;
5155	        }
5156	       
5157	        Expr.order.splice(1, 0, "CLASS");
5158	        Expr.find.CLASS = function( match, context, isXML ) {
5159	                if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
5160	                        return context.getElementsByClassName(match[1]);
5161	                }
5162	        };
5163	
5164	        // release memory in IE
5165	        div = null;
5166	})();
5167	
5168	function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5169	        for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5170	                var elem = checkSet[i];
5171	
5172	                if ( elem ) {
5173	                        var match = false;
5174	
5175	                        elem = elem[dir];
5176	
5177	                        while ( elem ) {
5178	                                if ( elem[ expando ] === doneName ) {
5179	                                        match = checkSet[elem.sizset];
5180	                                        break;
5181	                                }
5182	
5183	                                if ( elem.nodeType === 1 && !isXML ){
5184	                                        elem[ expando ] = doneName;
5185	                                        elem.sizset = i;
5186	                                }
5187	
5188	                                if ( elem.nodeName.toLowerCase() === cur ) {
5189	                                        match = elem;
5190	                                        break;
5191	                                }
5192	
5193	                                elem = elem[dir];
5194	                        }
5195	
5196	                        checkSet[i] = match;
5197	                }
5198	        }
5199	}
5200	
5201	function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5202	        for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5203	                var elem = checkSet[i];
5204	
5205	                if ( elem ) {
5206	                        var match = false;
5207	                       
5208	                        elem = elem[dir];
5209	
5210	                        while ( elem ) {
5211	                                if ( elem[ expando ] === doneName ) {
5212	                                        match = checkSet[elem.sizset];
5213	                                        break;
5214	                                }
5215	
5216	                                if ( elem.nodeType === 1 ) {
5217	                                        if ( !isXML ) {
5218	                                                elem[ expando ] = doneName;
5219	                                                elem.sizset = i;
5220	                                        }
5221	
5222	                                        if ( typeof cur !== "string" ) {
5223	                                                if ( elem === cur ) {
5224	                                                        match = true;
5225	                                                        break;
5226	                                                }
5227	
5228	                                        } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5229	                                                match = elem;
5230	                                                break;
5231	                                        }
5232	                                }
5233	
5234	                                elem = elem[dir];
5235	                        }
5236	
5237	                        checkSet[i] = match;
5238	                }
5239	        }
5240	}
5241	
5242	if ( document.documentElement.contains ) {
5243	        Sizzle.contains = function( a, b ) {
5244	                return a !== b && (a.contains ? a.contains(b) : true);
5245	        };
5246	
5247	} else if ( document.documentElement.compareDocumentPosition ) {
5248	        Sizzle.contains = function( a, b ) {
5249	                return !!(a.compareDocumentPosition(b) & 16);
5250	        };
5251	
5252	} else {
5253	        Sizzle.contains = function() {
5254	                return false;
5255	        };
5256	}
5257	
5258	Sizzle.isXML = function( elem ) {
5259	        // documentElement is verified for cases where it doesn't yet exist
5260	        // (such as loading iframes in IE - #4833)
5261	        var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
5262	
5263	        return documentElement ? documentElement.nodeName !== "HTML" : false;
5264	};
5265	
5266	var posProcess = function( selector, context, seed ) {
5267	        var match,
5268	                tmpSet = [],
5269	                later = "",
5270	                root = context.nodeType ? [context] : context;
5271	
5272	        // Position selectors must be done after the filter
5273	        // And so must :not(positional) so we move all PSEUDOs to the end
5274	        while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5275	                later += match[0];
5276	                selector = selector.replace( Expr.match.PSEUDO, "" );
5277	        }
5278	
5279	        selector = Expr.relative[selector] ? selector + "*" : selector;
5280	
5281	        for ( var i = 0, l = root.length; i < l; i++ ) {
5282	                Sizzle( selector, root[i], tmpSet, seed );
5283	        }
5284	
5285	        return Sizzle.filter( later, tmpSet );
5286	};
5287	
5288	// EXPOSE
5289	// Override sizzle attribute retrieval
5290	Sizzle.attr = jQuery.attr;
5291	Sizzle.selectors.attrMap = {};
5292	jQuery.find = Sizzle;
5293	jQuery.expr = Sizzle.selectors;
5294	jQuery.expr[":"] = jQuery.expr.filters;
5295	jQuery.unique = Sizzle.uniqueSort;
5296	jQuery.text = Sizzle.getText;
5297	jQuery.isXMLDoc = Sizzle.isXML;
5298	jQuery.contains = Sizzle.contains;
5299	
5300	
5301	})();
5302	
5303	
5304	var runtil = /Until$/,
5305	        rparentsprev = /^(?:parents|prevUntil|prevAll)/,
5306	        // Note: This RegExp should be improved, or likely pulled from Sizzle
5307	        rmultiselector = /,/,
5308	        isSimple = /^.[^:#\[\.,]*$/,
5309	        slice = Array.prototype.slice,
5310	        POS = jQuery.expr.match.POS,
5311	        // methods guaranteed to produce a unique set when starting from a unique set
5312	        guaranteedUnique = {
5313	                children: true,
5314	                contents: true,
5315	                next: true,
5316	                prev: true
5317	        };
5318	
5319	jQuery.fn.extend({
5320	        find: function( selector ) {
5321	                var self = this,
5322	                        i, l;
5323	
5324	                if ( typeof selector !== "string" ) {
5325	                        return jQuery( selector ).filter(function() {
5326	                                for ( i = 0, l = self.length; i < l; i++ ) {
5327	                                        if ( jQuery.contains( self[ i ], this ) ) {
5328	                                                return true;
5329	                                        }
5330	                                }
5331	                        });
5332	                }
5333	
5334	                var ret = this.pushStack( "", "find", selector ),
5335	                        length, n, r;
5336	
5337	                for ( i = 0, l = this.length; i < l; i++ ) {
5338	                        length = ret.length;
5339	                        jQuery.find( selector, this[i], ret );
5340	
5341	                        if ( i > 0 ) {
5342	                                // Make sure that the results are unique
5343	                                for ( n = length; n < ret.length; n++ ) {
5344	                                        for ( r = 0; r < length; r++ ) {
5345	                                                if ( ret[r] === ret[n] ) {
5346	                                                        ret.splice(n--, 1);
5347	                                                        break;
5348	                                                }
5349	                                        }
5350	                                }
5351	                        }
5352	                }
5353	
5354	                return ret;
5355	        },
5356	
5357	        has: function( target ) {
5358	                var targets = jQuery( target );
5359	                return this.filter(function() {
5360	                        for ( var i = 0, l = targets.length; i < l; i++ ) {
5361	                                if ( jQuery.contains( this, targets[i] ) ) {
5362	                                        return true;
5363	                                }
5364	                        }
5365	                });
5366	        },
5367	
5368	        not: function( selector ) {
5369	                return this.pushStack( winnow(this, selector, false), "not", selector);
5370	        },
5371	
5372	        filter: function( selector ) {
5373	                return this.pushStack( winnow(this, selector, true), "filter", selector );
5374	        },
5375	
5376	        is: function( selector ) {
5377	                return !!selector && ( 
5378	                        typeof selector === "string" ?
5379	                                // If this is a positional selector, check membership in the returned set
5380	                                // so $("p:first").is("p:last") won't return true for a doc with two "p".
5381	                                POS.test( selector ) ? 
5382	                                        jQuery( selector, this.context ).index( this[0] ) >= 0 :
5383	                                        jQuery.filter( selector, this ).length > 0 :
5384	                                this.filter( selector ).length > 0 );
5385	        },
5386	
5387	        closest: function( selectors, context ) {
5388	                var ret = [], i, l, cur = this[0];
5389	               
5390	                // Array (deprecated as of jQuery 1.7)
5391	                if ( jQuery.isArray( selectors ) ) {
5392	                        var level = 1;
5393	
5394	                        while ( cur && cur.ownerDocument && cur !== context ) {
5395	                                for ( i = 0; i < selectors.length; i++ ) {
5396	
5397	                                        if ( jQuery( cur ).is( selectors[ i ] ) ) {
5398	                                                ret.push({ selector: selectors[ i ], elem: cur, level: level });
5399	                                        }
5400	                                }
5401	
5402	                                cur = cur.parentNode;
5403	                                level++;
5404	                        }
5405	
5406	                        return ret;
5407	                }
5408	
5409	                // String
5410	                var pos = POS.test( selectors ) || typeof selectors !== "string" ?
5411	                                jQuery( selectors, context || this.context ) :
5412	                                0;
5413	
5414	                for ( i = 0, l = this.length; i < l; i++ ) {
5415	                        cur = this[i];
5416	
5417	                        while ( cur ) {
5418	                                if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5419	                                        ret.push( cur );
5420	                                        break;
5421	
5422	                                } else {
5423	                                        cur = cur.parentNode;
5424	                                        if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
5425	                                                break;
5426	                                        }
5427	                                }
5428	                        }
5429	                }
5430	
5431	                ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5432	
5433	                return this.pushStack( ret, "closest", selectors );
5434	        },
5435	
5436	        // Determine the position of an element within
5437	        // the matched set of elements
5438	        index: function( elem ) {
5439	
5440	                // No argument, return index in parent
5441	                if ( !elem ) {
5442	                        return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
5443	                }
5444	
5445	                // index in selector
5446	                if ( typeof elem === "string" ) {
5447	                        return jQuery.inArray( this[0], jQuery( elem ) );
5448	                }
5449	
5450	                // Locate the position of the desired element
5451	                return jQuery.inArray(
5452	                        // If it receives a jQuery object, the first element is used
5453	                        elem.jquery ? elem[0] : elem, this );
5454	        },
5455	
5456	        add: function( selector, context ) {
5457	                var set = typeof selector === "string" ?
5458	                                jQuery( selector, context ) :
5459	                                jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5460	                        all = jQuery.merge( this.get(), set );
5461	
5462	                return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
5463	                        all :
5464	                        jQuery.unique( all ) );
5465	        },
5466	
5467	        andSelf: function() {
5468	                return this.add( this.prevObject );
5469	        }
5470	});
5471	
5472	// A painfully simple check to see if an element is disconnected
5473	// from a document (should be improved, where feasible).
5474	function isDisconnected( node ) {
5475	        return !node || !node.parentNode || node.parentNode.nodeType === 11;
5476	}
5477	
5478	jQuery.each({
5479	        parent: function( elem ) {
5480	                var parent = elem.parentNode;
5481	                return parent && parent.nodeType !== 11 ? parent : null;
5482	        },
5483	        parents: function( elem ) {
5484	                return jQuery.dir( elem, "parentNode" );
5485	        },
5486	        parentsUntil: function( elem, i, until ) {
5487	                return jQuery.dir( elem, "parentNode", until );
5488	        },
5489	        next: function( elem ) {
5490	                return jQuery.nth( elem, 2, "nextSibling" );
5491	        },
5492	        prev: function( elem ) {
5493	                return jQuery.nth( elem, 2, "previousSibling" );
5494	        },
5495	        nextAll: function( elem ) {
5496	                return jQuery.dir( elem, "nextSibling" );
5497	        },
5498	        prevAll: function( elem ) {
5499	                return jQuery.dir( elem, "previousSibling" );
5500	        },
5501	        nextUntil: function( elem, i, until ) {
5502	                return jQuery.dir( elem, "nextSibling", until );
5503	        },
5504	        prevUntil: function( elem, i, until ) {
5505	                return jQuery.dir( elem, "previousSibling", until );
5506	        },
5507	        siblings: function( elem ) {
5508	                return jQuery.sibling( elem.parentNode.firstChild, elem );
5509	        },
5510	        children: function( elem ) {
5511	                return jQuery.sibling( elem.firstChild );
5512	        },
5513	        contents: function( elem ) {
5514	                return jQuery.nodeName( elem, "iframe" ) ?
5515	                        elem.contentDocument || elem.contentWindow.document :
5516	                        jQuery.makeArray( elem.childNodes );
5517	        }
5518	}, function( name, fn ) {
5519	        jQuery.fn[ name ] = function( until, selector ) {
5520	                var ret = jQuery.map( this, fn, until );
5521	
5522	                if ( !runtil.test( name ) ) {
5523	                        selector = until;
5524	                }
5525	
5526	                if ( selector && typeof selector === "string" ) {
5527	                        ret = jQuery.filter( selector, ret );
5528	                }
5529	
5530	                ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5531	
5532	                if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5533	                        ret = ret.reverse();
5534	                }
5535	
5536	                return this.pushStack( ret, name, slice.call( arguments ).join(",") );
5537	        };
5538	});
5539	
5540	jQuery.extend({
5541	        filter: function( expr, elems, not ) {
5542	                if ( not ) {
5543	                        expr = ":not(" + expr + ")";
5544	                }
5545	
5546	                return elems.length === 1 ?
5547	                        jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5548	                        jQuery.find.matches(expr, elems);
5549	        },
5550	
5551	        dir: function( elem, dir, until ) {
5552	                var matched = [],
5553	                        cur = elem[ dir ];
5554	
5555	                while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
5556	                        if ( cur.nodeType === 1 ) {
5557	                                matched.push( cur );
5558	                        }
5559	                        cur = cur[dir];
5560	                }
5561	                return matched;
5562	        },
5563	
5564	        nth: function( cur, result, dir, elem ) {
5565	                result = result || 1;
5566	                var num = 0;
5567	
5568	                for ( ; cur; cur = cur[dir] ) {
5569	                        if ( cur.nodeType === 1 && ++num === result ) {
5570	                                break;
5571	                        }
5572	                }
5573	
5574	                return cur;
5575	        },
5576	
5577	        sibling: function( n, elem ) {
5578	                var r = [];
5579	
5580	                for ( ; n; n = n.nextSibling ) {
5581	                        if ( n.nodeType === 1 && n !== elem ) {
5582	                                r.push( n );
5583	                        }
5584	                }
5585	
5586	                return r;
5587	        }
5588	});
5589	
5590	// Implement the identical functionality for filter and not
5591	function winnow( elements, qualifier, keep ) {
5592	
5593	        // Can't pass null or undefined to indexOf in Firefox 4
5594	        // Set to 0 to skip string check
5595	        qualifier = qualifier || 0;
5596	
5597	        if ( jQuery.isFunction( qualifier ) ) {
5598	                return jQuery.grep(elements, function( elem, i ) {
5599	                        var retVal = !!qualifier.call( elem, i, elem );
5600	                        return retVal === keep;
5601	                });
5602	
5603	        } else if ( qualifier.nodeType ) {
5604	                return jQuery.grep(elements, function( elem, i ) {
5605	                        return ( elem === qualifier ) === keep;
5606	                });
5607	
5608	        } else if ( typeof qualifier === "string" ) {
5609	                var filtered = jQuery.grep(elements, function( elem ) {
5610	                        return elem.nodeType === 1;
5611	                });
5612	
5613	                if ( isSimple.test( qualifier ) ) {
5614	                        return jQuery.filter(qualifier, filtered, !keep);
5615	                } else {
5616	                        qualifier = jQuery.filter( qualifier, filtered );
5617	                }
5618	        }
5619	
5620	        return jQuery.grep(elements, function( elem, i ) {
5621	                return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
5622	        });
5623	}
5624	
5625	
5626	
5627	
5628	function createSafeFragment( document ) {
5629	        var list = nodeNames.split( "|" ),
5630	        safeFrag = document.createDocumentFragment();
5631	
5632	        if ( safeFrag.createElement ) {
5633	                while ( list.length ) {
5634	                        safeFrag.createElement(
5635	                                list.pop()
5636	                        );
5637	                }
5638	        }
5639	        return safeFrag;
5640	}
5641	
5642	var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" +
5643	                "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
5644	        rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5645	        rleadingWhitespace = /^\s+/,
5646	        rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
5647	        rtagName = /<([\w:]+)/,
5648	        rtbody = /<tbody/i,
5649	        rhtml = /<|&#?\w+;/,
5650	        rnoInnerhtml = /<(?:script|style)/i,
5651	        rnocache = /<(?:script|object|embed|option|style)/i,
5652	        rnoshimcache = new RegExp("<(?:" + nodeNames + ")", "i"),
5653	        // checked="checked" or checked
5654	        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5655	        rscriptType = /\/(java|ecma)script/i,
5656	        rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
5657	        wrapMap = {
5658	                option: [ 1, "<select multiple='multiple'>", "</select>" ],
5659	                legend: [ 1, "<fieldset>", "</fieldset>" ],
5660	                thead: [ 1, "<table>", "</table>" ],
5661	                tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5662	                td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5663	                col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5664	                area: [ 1, "<map>", "</map>" ],
5665	                _default: [ 0, "", "" ]
5666	        },
5667	        safeFragment = createSafeFragment( document );
5668	
5669	wrapMap.optgroup = wrapMap.option;
5670	wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5671	wrapMap.th = wrapMap.td;
5672	
5673	// IE can't serialize <link> and <script> tags normally
5674	if ( !jQuery.support.htmlSerialize ) {
5675	        wrapMap._default = [ 1, "div<div>", "</div>" ];
5676	}
5677	
5678	jQuery.fn.extend({
5679	        text: function( text ) {
5680	                if ( jQuery.isFunction(text) ) {
5681	                        return this.each(function(i) {
5682	                                var self = jQuery( this );
5683	
5684	                                self.text( text.call(this, i, self.text()) );
5685	                        });
5686	                }
5687	
5688	                if ( typeof text !== "object" && text !== undefined ) {
5689	                        return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
5690	                }
5691	
5692	                return jQuery.text( this );
5693	        },
5694	
5695	        wrapAll: function( html ) {
5696	                if ( jQuery.isFunction( html ) ) {
5697	                        return this.each(function(i) {
5698	                                jQuery(this).wrapAll( html.call(this, i) );
5699	                        });
5700	                }
5701	
5702	                if ( this[0] ) {
5703	                        // The elements to wrap the target around
5704	                        var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5705	
5706	                        if ( this[0].parentNode ) {
5707	                                wrap.insertBefore( this[0] );
5708	                        }
5709	
5710	                        wrap.map(function() {
5711	                                var elem = this;
5712	
5713	                                while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5714	                                        elem = elem.firstChild;
5715	                                }
5716	
5717	                                return elem;
5718	                        }).append( this );
5719	                }
5720	
5721	                return this;
5722	        },
5723	
5724	        wrapInner: function( html ) {
5725	                if ( jQuery.isFunction( html ) ) {
5726	                        return this.each(function(i) {
5727	                                jQuery(this).wrapInner( html.call(this, i) );
5728	                        });
5729	                }
5730	
5731	                return this.each(function() {
5732	                        var self = jQuery( this ),
5733	                                contents = self.contents();
5734	
5735	                        if ( contents.length ) {
5736	                                contents.wrapAll( html );
5737	
5738	                        } else {
5739	                                self.append( html );
5740	                        }
5741	                });
5742	        },
5743	
5744	        wrap: function( html ) {
5745	                var isFunction = jQuery.isFunction( html );
5746	
5747	                return this.each(function(i) {
5748	                        jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
5749	                });
5750	        },
5751	
5752	        unwrap: function() {
5753	                return this.parent().each(function() {
5754	                        if ( !jQuery.nodeName( this, "body" ) ) {
5755	                                jQuery( this ).replaceWith( this.childNodes );
5756	                        }
5757	                }).end();
5758	        },
5759	
5760	        append: function() {
5761	                return this.domManip(arguments, true, function( elem ) {
5762	                        if ( this.nodeType === 1 ) {
5763	                                this.appendChild( elem );
5764	                        }
5765	                });
5766	        },
5767	
5768	        prepend: function() {
5769	                return this.domManip(arguments, true, function( elem ) {
5770	                        if ( this.nodeType === 1 ) {
5771	                                this.insertBefore( elem, this.firstChild );
5772	                        }
5773	                });
5774	        },
5775	
5776	        before: function() {
5777	                if ( this[0] && this[0].parentNode ) {
5778	                        return this.domManip(arguments, false, function( elem ) {
5779	                                this.parentNode.insertBefore( elem, this );
5780	                        });
5781	                } else if ( arguments.length ) {
5782	                        var set = jQuery.clean( arguments );
5783	                        set.push.apply( set, this.toArray() );
5784	                        return this.pushStack( set, "before", arguments );
5785	                }
5786	        },
5787	
5788	        after: function() {
5789	                if ( this[0] && this[0].parentNode ) {
5790	                        return this.domManip(arguments, false, function( elem ) {
5791	                                this.parentNode.insertBefore( elem, this.nextSibling );
5792	                        });
5793	                } else if ( arguments.length ) {
5794	                        var set = this.pushStack( this, "after", arguments );
5795	                        set.push.apply( set, jQuery.clean(arguments) );
5796	                        return set;
5797	                }
5798	        },
5799	
5800	        // keepData is for internal use only--do not document
5801	        remove: function( selector, keepData ) {
5802	                for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5803	                        if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5804	                                if ( !keepData && elem.nodeType === 1 ) {
5805	                                        jQuery.cleanData( elem.getElementsByTagName("*") );
5806	                                        jQuery.cleanData( [ elem ] );
5807	                                }
5808	
5809	                                if ( elem.parentNode ) {
5810	                                        elem.parentNode.removeChild( elem );
5811	                                }
5812	                        }
5813	                }
5814	
5815	                return this;
5816	        },
5817	
5818	        empty: function() {
5819	                for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5820	                        // Remove element nodes and prevent memory leaks
5821	                        if ( elem.nodeType === 1 ) {
5822	                                jQuery.cleanData( elem.getElementsByTagName("*") );
5823	                        }
5824	
5825	                        // Remove any remaining nodes
5826	                        while ( elem.firstChild ) {
5827	                                elem.removeChild( elem.firstChild );
5828	                        }
5829	                }
5830	
5831	                return this;
5832	        },
5833	
5834	        clone: function( dataAndEvents, deepDataAndEvents ) {
5835	                dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5836	                deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5837	
5838	                return this.map( function () {
5839	                        return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5840	                });
5841	        },
5842	
5843	        html: function( value ) {
5844	                if ( value === undefined ) {
5845	                        return this[0] && this[0].nodeType === 1 ?
5846	                                this[0].innerHTML.replace(rinlinejQuery, "") :
5847	                                null;
5848	
5849	                // See if we can take a shortcut and just use innerHTML
5850	                } else if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5851	                        (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5852	                        !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5853	
5854	                        value = value.replace(rxhtmlTag, "<$1></$2>");
5855	
5856	                        try {
5857	                                for ( var i = 0, l = this.length; i < l; i++ ) {
5858	                                        // Remove element nodes and prevent memory leaks
5859	                                        if ( this[i].nodeType === 1 ) {
5860	                                                jQuery.cleanData( this[i].getElementsByTagName("*") );
5861	                                                this[i].innerHTML = value;
5862	                                        }
5863	                                }
5864	
5865	                        // If using innerHTML throws an exception, use the fallback method
5866	                        } catch(e) {
5867	                                this.empty().append( value );
5868	                        }
5869	
5870	                } else if ( jQuery.isFunction( value ) ) {
5871	                        this.each(function(i){
5872	                                var self = jQuery( this );
5873	
5874	                                self.html( value.call(this, i, self.html()) );
5875	                        });
5876	
5877	                } else {
5878	                        this.empty().append( value );
5879	                }
5880	
5881	                return this;
5882	        },
5883	
5884	        replaceWith: function( value ) {
5885	                if ( this[0] && this[0].parentNode ) {
5886	                        // Make sure that the elements are removed from the DOM before they are inserted
5887	                        // this can help fix replacing a parent with child elements
5888	                        if ( jQuery.isFunction( value ) ) {
5889	                                return this.each(function(i) {
5890	                                        var self = jQuery(this), old = self.html();
5891	                                        self.replaceWith( value.call( this, i, old ) );
5892	                                });
5893	                        }
5894	
5895	                        if ( typeof value !== "string" ) {
5896	                                value = jQuery( value ).detach();
5897	                        }
5898	
5899	                        return this.each(function() {
5900	                                var next = this.nextSibling,
5901	                                        parent = this.parentNode;
5902	
5903	                                jQuery( this ).remove();
5904	
5905	                                if ( next ) {
5906	                                        jQuery(next).before( value );
5907	                                } else {
5908	                                        jQuery(parent).append( value );
5909	                                }
5910	                        });
5911	                } else {
5912	                        return this.length ?
5913	                                this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5914	                                this;
5915	                }
5916	        },
5917	
5918	        detach: function( selector ) {
5919	                return this.remove( selector, true );
5920	        },
5921	
5922	        domManip: function( args, table, callback ) {
5923	                var results, first, fragment, parent,
5924	                        value = args[0],
5925	                        scripts = [];
5926	
5927	                // We can't cloneNode fragments that contain checked, in WebKit
5928	                if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5929	                        return this.each(function() {
5930	                                jQuery(this).domManip( args, table, callback, true );
5931	                        });
5932	                }
5933	
5934	                if ( jQuery.isFunction(value) ) {
5935	                        return this.each(function(i) {
5936	                                var self = jQuery(this);
5937	                                args[0] = value.call(this, i, table ? self.html() : undefined);
5938	                                self.domManip( args, table, callback );
5939	                        });
5940	                }
5941	
5942	                if ( this[0] ) {
5943	                        parent = value && value.parentNode;
5944	
5945	                        // If we're in a fragment, just use that instead of building a new one
5946	                        if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5947	                                results = { fragment: parent };
5948	
5949	                        } else {
5950	                                results = jQuery.buildFragment( args, this, scripts );
5951	                        }
5952	
5953	                        fragment = results.fragment;
5954	
5955	                        if ( fragment.childNodes.length === 1 ) {
5956	                                first = fragment = fragment.firstChild;
5957	                        } else {
5958	                                first = fragment.firstChild;
5959	                        }
5960	
5961	                        if ( first ) {
5962	                                table = table && jQuery.nodeName( first, "tr" );
5963	
5964	                                for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5965	                                        callback.call(
5966	                                                table ?
5967	                                                        root(this[i], first) :
5968	                                                        this[i],
5969	                                                // Make sure that we do not leak memory by inadvertently discarding
5970	                                                // the original fragment (which might have attached data) instead of
5971	                                                // using it; in addition, use the original fragment object for the last
5972	                                                // item instead of first because it can end up being emptied incorrectly
5973	                                                // in certain situations (Bug #8070).
5974	                                                // Fragments from the fragment cache must always be cloned and never used
5975	                                                // in place.
5976	                                                results.cacheable || ( l > 1 && i < lastIndex ) ?
5977	                                                        jQuery.clone( fragment, true, true ) :
5978	                                                        fragment
5979	                                        );
5980	                                }
5981	                        }
5982	
5983	                        if ( scripts.length ) {
5984	                                jQuery.each( scripts, evalScript );
5985	                        }
5986	                }
5987	
5988	                return this;
5989	        }
5990	});
5991	
5992	function root( elem, cur ) {
5993	        return jQuery.nodeName(elem, "table") ?
5994	                (elem.getElementsByTagName("tbody")[0] ||
5995	                elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5996	                elem;
5997	}
5998	
5999	function cloneCopyEvent( src, dest ) {
6000	
6001	        if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
6002	                return;
6003	        }
6004	
6005	        var type, i, l,
6006	                oldData = jQuery._data( src ),
6007	                curData = jQuery._data( dest, oldData ),
6008	                events = oldData.events;
6009	
6010	        if ( events ) {
6011	                delete curData.handle;
6012	                curData.events = {};
6013	
6014	                for ( type in events ) {
6015	                        for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6016	                                jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
6017	                        }
6018	                }
6019	        }
6020	
6021	        // make the cloned public data object a copy from the original
6022	        if ( curData.data ) {
6023	                curData.data = jQuery.extend( {}, curData.data );
6024	        }
6025	}
6026	
6027	function cloneFixAttributes( src, dest ) {
6028	        var nodeName;
6029	
6030	        // We do not need to do anything for non-Elements
6031	        if ( dest.nodeType !== 1 ) {
6032	                return;
6033	        }
6034	
6035	        // clearAttributes removes the attributes, which we don't want,
6036	        // but also removes the attachEvent events, which we *do* want
6037	        if ( dest.clearAttributes ) {
6038	                dest.clearAttributes();
6039	        }
6040	
6041	        // mergeAttributes, in contrast, only merges back on the
6042	        // original attributes, not the events
6043	        if ( dest.mergeAttributes ) {
6044	                dest.mergeAttributes( src );
6045	        }
6046	
6047	        nodeName = dest.nodeName.toLowerCase();
6048	
6049	        // IE6-8 fail to clone children inside object elements that use
6050	        // the proprietary classid attribute value (rather than the type
6051	        // attribute) to identify the type of content to display
6052	        if ( nodeName === "object" ) {
6053	                dest.outerHTML = src.outerHTML;
6054	
6055	        } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
6056	                // IE6-8 fails to persist the checked state of a cloned checkbox
6057	                // or radio button. Worse, IE6-7 fail to give the cloned element
6058	                // a checked appearance if the defaultChecked value isn't also set
6059	                if ( src.checked ) {
6060	                        dest.defaultChecked = dest.checked = src.checked;
6061	                }
6062	
6063	                // IE6-7 get confused and end up setting the value of a cloned
6064	                // checkbox/radio button to an empty string instead of "on"
6065	                if ( dest.value !== src.value ) {
6066	                        dest.value = src.value;
6067	                }
6068	
6069	        // IE6-8 fails to return the selected option to the default selected
6070	        // state when cloning options
6071	        } else if ( nodeName === "option" ) {
6072	                dest.selected = src.defaultSelected;
6073	
6074	        // IE6-8 fails to set the defaultValue to the correct value when
6075	        // cloning other types of input fields
6076	        } else if ( nodeName === "input" || nodeName === "textarea" ) {
6077	                dest.defaultValue = src.defaultValue;
6078	        }
6079	
6080	        // Event data gets referenced instead of copied if the expando
6081	        // gets copied too
6082	        dest.removeAttribute( jQuery.expando );
6083	}
6084	
6085	jQuery.buildFragment = function( args, nodes, scripts ) {
6086	        var fragment, cacheable, cacheresults, doc,
6087	        first = args[ 0 ];
6088	
6089	        // nodes may contain either an explicit document object,
6090	        // a jQuery collection or context object.
6091	        // If nodes[0] contains a valid object to assign to doc
6092	        if ( nodes && nodes[0] ) {
6093	                doc = nodes[0].ownerDocument || nodes[0];
6094	        }
6095	
6096	        // Ensure that an attr object doesn't incorrectly stand in as a document object
6097	        // Chrome and Firefox seem to allow this to occur and will throw exception
6098	        // Fixes #8950
6099	        if ( !doc.createDocumentFragment ) {
6100	                doc = document;
6101	        }
6102	
6103	        // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
6104	        // Cloning options loses the selected state, so don't cache them
6105	        // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
6106	        // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
6107	        // Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
6108	        if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
6109	                first.charAt(0) === "<" && !rnocache.test( first ) &&
6110	                (jQuery.support.checkClone || !rchecked.test( first )) &&
6111	                (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
6112	
6113	                cacheable = true;
6114	
6115	                cacheresults = jQuery.fragments[ first ];
6116	                if ( cacheresults && cacheresults !== 1 ) {
6117	                        fragment = cacheresults;
6118	                }
6119	        }
6120	
6121	        if ( !fragment ) {
6122	                fragment = doc.createDocumentFragment();
6123	                jQuery.clean( args, doc, fragment, scripts );
6124	        }
6125	
6126	        if ( cacheable ) {
6127	                jQuery.fragments[ first ] = cacheresults ? fragment : 1;
6128	        }
6129	
6130	        return { fragment: fragment, cacheable: cacheable };
6131	};
6132	
6133	jQuery.fragments = {};
6134	
6135	jQuery.each({
6136	        appendTo: "append",
6137	        prependTo: "prepend",
6138	        insertBefore: "before",
6139	        insertAfter: "after",
6140	        replaceAll: "replaceWith"
6141	}, function( name, original ) {
6142	        jQuery.fn[ name ] = function( selector ) {
6143	                var ret = [],
6144	                        insert = jQuery( selector ),
6145	                        parent = this.length === 1 && this[0].parentNode;
6146	
6147	                if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
6148	                        insert[ original ]( this[0] );
6149	                        return this;
6150	
6151	                } else {
6152	                        for ( var i = 0, l = insert.length; i < l; i++ ) {
6153	                                var elems = ( i > 0 ? this.clone(true) : this ).get();
6154	                                jQuery( insert[i] )[ original ]( elems );
6155	                                ret = ret.concat( elems );
6156	                        }
6157	
6158	                        return this.pushStack( ret, name, insert.selector );
6159	                }
6160	        };
6161	});
6162	
6163	function getAll( elem ) {
6164	        if ( typeof elem.getElementsByTagName !== "undefined" ) {
6165	                return elem.getElementsByTagName( "*" );
6166	
6167	        } else if ( typeof elem.querySelectorAll !== "undefined" ) {
6168	                return elem.querySelectorAll( "*" );
6169	
6170	        } else {
6171	                return [];
6172	        }
6173	}
6174	
6175	// Used in clean, fixes the defaultChecked property
6176	function fixDefaultChecked( elem ) {
6177	        if ( elem.type === "checkbox" || elem.type === "radio" ) {
6178	                elem.defaultChecked = elem.checked;
6179	        }
6180	}
6181	// Finds all inputs and passes them to fixDefaultChecked
6182	function findInputs( elem ) {
6183	        var nodeName = ( elem.nodeName || "" ).toLowerCase();
6184	        if ( nodeName === "input" ) {
6185	                fixDefaultChecked( elem );
6186	        // Skip scripts, get other children
6187	        } else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) {
6188	                jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
6189	        }
6190	}
6191	
6192	// Derived From: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js
6193	function shimCloneNode( elem ) {
6194	        var div = document.createElement( "div" );
6195	        safeFragment.appendChild( div );
6196	
6197	        div.innerHTML = elem.outerHTML;
6198	        return div.firstChild;
6199	}
6200	
6201	jQuery.extend({
6202	        clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6203	                var srcElements,
6204	                        destElements,
6205	                        i,
6206	                        // IE<=8 does not properly clone detached, unknown element nodes
6207	                        clone = jQuery.support.html5Clone || !rnoshimcache.test( "<" + elem.nodeName ) ?
6208	                                elem.cloneNode( true ) :
6209	                                shimCloneNode( elem );
6210	
6211	                if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
6212	                                (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6213	                        // IE copies events bound via attachEvent when using cloneNode.
6214	                        // Calling detachEvent on the clone will also remove the events
6215	                        // from the original. In order to get around this, we use some
6216	                        // proprietary methods to clear the events. Thanks to MooTools
6217	                        // guys for this hotness.
6218	
6219	                        cloneFixAttributes( elem, clone );
6220	
6221	                        // Using Sizzle here is crazy slow, so we use getElementsByTagName instead
6222	                        srcElements = getAll( elem );
6223	                        destElements = getAll( clone );
6224	
6225	                        // Weird iteration because IE will replace the length property
6226	                        // with an element if you are cloning the body and one of the
6227	                        // elements on the page has a name or id of "length"
6228	                        for ( i = 0; srcElements[i]; ++i ) {
6229	                                // Ensure that the destination node is not null; Fixes #9587
6230	                                if ( destElements[i] ) {
6231	                                        cloneFixAttributes( srcElements[i], destElements[i] );
6232	                                }
6233	                        }
6234	                }
6235	
6236	                // Copy the events from the original to the clone
6237	                if ( dataAndEvents ) {
6238	                        cloneCopyEvent( elem, clone );
6239	
6240	                        if ( deepDataAndEvents ) {
6241	                                srcElements = getAll( elem );
6242	                                destElements = getAll( clone );
6243	
6244	                                for ( i = 0; srcElements[i]; ++i ) {
6245	                                        cloneCopyEvent( srcElements[i], destElements[i] );
6246	                                }
6247	                        }
6248	                }
6249	
6250	                srcElements = destElements = null;
6251	
6252	                // Return the cloned set
6253	                return clone;
6254	        },
6255	
6256	        clean: function( elems, context, fragment, scripts ) {
6257	                var checkScriptType;
6258	
6259	                context = context || document;
6260	
6261	                // !context.createElement fails in IE with an error but returns typeof 'object'
6262	                if ( typeof context.createElement === "undefined" ) {
6263	                        context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
6264	                }
6265	
6266	                var ret = [], j;
6267	
6268	                for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6269	                        if ( typeof elem === "number" ) {
6270	                                elem += "";
6271	                        }
6272	
6273	                        if ( !elem ) {
6274	                                continue;
6275	                        }
6276	
6277	                        // Convert html string into DOM nodes
6278	                        if ( typeof elem === "string" ) {
6279	                                if ( !rhtml.test( elem ) ) {
6280	                                        elem = context.createTextNode( elem );
6281	                                } else {
6282	                                        // Fix "XHTML"-style tags in all browsers
6283	                                        elem = elem.replace(rxhtmlTag, "<$1></$2>");
6284	
6285	                                        // Trim whitespace, otherwise indexOf won't work as expected
6286	                                        var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),
6287	                                                wrap = wrapMap[ tag ] || wrapMap._default,
6288	                                                depth = wrap[0],
6289	                                                div = context.createElement("div");
6290	
6291	                                        // Append wrapper element to unknown element safe doc fragment
6292	                                        if ( context === document ) {
6293	                                                // Use the fragment we've already created for this document
6294	                                                safeFragment.appendChild( div );
6295	                                        } else {
6296	                                                // Use a fragment created with the owner document
6297	                                                createSafeFragment( context ).appendChild( div );
6298	                                        }
6299	
6300	                                        // Go to html and back, then peel off extra wrappers
6301	                                        div.innerHTML = wrap[1] + elem + wrap[2];
6302	
6303	                                        // Move to the right depth
6304	                                        while ( depth-- ) {
6305	                                                div = div.lastChild;
6306	                                        }
6307	
6308	                                        // Remove IE's autoinserted <tbody> from table fragments
6309	                                        if ( !jQuery.support.tbody ) {
6310	
6311	                                                // String was a <table>, *may* have spurious <tbody>
6312	                                                var hasBody = rtbody.test(elem),
6313	                                                        tbody = tag === "table" && !hasBody ?
6314	                                                                div.firstChild && div.firstChild.childNodes :
6315	
6316	                                                                // String was a bare <thead> or <tfoot>
6317	                                                                wrap[1] === "<table>" && !hasBody ?
6318	                                                                        div.childNodes :
6319	                                                                        [];
6320	
6321	                                                for ( j = tbody.length - 1; j >= 0 ; --j ) {
6322	                                                        if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6323	                                                                tbody[ j ].parentNode.removeChild( tbody[ j ] );
6324	                                                        }
6325	                                                }
6326	                                        }
6327	
6328	                                        // IE completely kills leading whitespace when innerHTML is used
6329	                                        if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6330	                                                div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6331	                                        }
6332	
6333	                                        elem = div.childNodes;
6334	                                }
6335	                        }
6336	
6337	                        // Resets defaultChecked for any radios and checkboxes
6338	                        // about to be appended to the DOM in IE 6/7 (#8060)
6339	                        var len;
6340	                        if ( !jQuery.support.appendChecked ) {
6341	                                if ( elem[0] && typeof (len = elem.length) === "number" ) {
6342	                                        for ( j = 0; j < len; j++ ) {
6343	                                                findInputs( elem[j] );
6344	                                        }
6345	                                } else {
6346	                                        findInputs( elem );
6347	                                }
6348	                        }
6349	
6350	                        if ( elem.nodeType ) {
6351	                                ret.push( elem );
6352	                        } else {
6353	                                ret = jQuery.merge( ret, elem );
6354	                        }
6355	                }
6356	
6357	                if ( fragment ) {
6358	                        checkScriptType = function( elem ) {
6359	                                return !elem.type || rscriptType.test( elem.type );
6360	                        };
6361	                        for ( i = 0; ret[i]; i++ ) {
6362	                                if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
6363	                                        scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6364	
6365	                                } else {
6366	                                        if ( ret[i].nodeType === 1 ) {
6367	                                                var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6368	
6369	                                                ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6370	                                        }
6371	                                        fragment.appendChild( ret[i] );
6372	                                }
6373	                        }
6374	                }
6375	
6376	                return ret;
6377	        },
6378	
6379	        cleanData: function( elems ) {
6380	                var data, id,
6381	                        cache = jQuery.cache,
6382	                        special = jQuery.event.special,
6383	                        deleteExpando = jQuery.support.deleteExpando;
6384	
6385	                for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6386	                        if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6387	                                continue;
6388	                        }
6389	
6390	                        id = elem[ jQuery.expando ];
6391	
6392	                        if ( id ) {
6393	                                data = cache[ id ];
6394	
6395	                                if ( data && data.events ) {
6396	                                        for ( var type in data.events ) {
6397	                                                if ( special[ type ] ) {
6398	                                                        jQuery.event.remove( elem, type );
6399	
6400	                                                // This is a shortcut to avoid jQuery.event.remove's overhead
6401	                                                } else {
6402	                                                        jQuery.removeEvent( elem, type, data.handle );
6403	                                                }
6404	                                        }
6405	
6406	                                        // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6407	                                        if ( data.handle ) {
6408	                                                data.handle.elem = null;
6409	                                        }
6410	                                }
6411	
6412	                                if ( deleteExpando ) {
6413	                                        delete elem[ jQuery.expando ];
6414	
6415	                                } else if ( elem.removeAttribute ) {
6416	                                        elem.removeAttribute( jQuery.expando );
6417	                                }
6418	
6419	                                delete cache[ id ];
6420	                        }
6421	                }
6422	        }
6423	});
6424	
6425	function evalScript( i, elem ) {
6426	        if ( elem.src ) {
6427	                jQuery.ajax({
6428	                        url: elem.src,
6429	                        async: false,
6430	                        dataType: "script"
6431	                });
6432	        } else {
6433	                jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
6434	        }
6435	
6436	        if ( elem.parentNode ) {
6437	                elem.parentNode.removeChild( elem );
6438	        }
6439	}
6440	
6441	
6442	
6443	
6444	var ralpha = /alpha\([^)]*\)/i,
6445	        ropacity = /opacity=([^)]*)/,
6446	        // fixed for IE9, see #8346
6447	        rupper = /([A-Z]|^ms)/g,
6448	        rnumpx = /^-?\d+(?:px)?$/i,
6449	        rnum = /^-?\d/,
6450	        rrelNum = /^([\-+])=([\-+.\de]+)/,
6451	
6452	        cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6453	        cssWidth = [ "Left", "Right" ],
6454	        cssHeight = [ "Top", "Bottom" ],
6455	        curCSS,
6456	
6457	        getComputedStyle,
6458	        currentStyle;
6459	
6460	jQuery.fn.css = function( name, value ) {
6461	        // Setting 'undefined' is a no-op
6462	        if ( arguments.length === 2 && value === undefined ) {
6463	                return this;
6464	        }
6465	
6466	        return jQuery.access( this, name, value, true, function( elem, name, value ) {
6467	                return value !== undefined ?
6468	                        jQuery.style( elem, name, value ) :
6469	                        jQuery.css( elem, name );
6470	        });
6471	};
6472	
6473	jQuery.extend({
6474	        // Add in style property hooks for overriding the default
6475	        // behavior of getting and setting a style property
6476	        cssHooks: {
6477	                opacity: {
6478	                        get: function( elem, computed ) {
6479	                                if ( computed ) {
6480	                                        // We should always get a number back from opacity
6481	                                        var ret = curCSS( elem, "opacity", "opacity" );
6482	                                        return ret === "" ? "1" : ret;
6483	
6484	                                } else {
6485	                                        return elem.style.opacity;
6486	                                }
6487	                        }
6488	                }
6489	        },
6490	
6491	        // Exclude the following css properties to add px
6492	        cssNumber: {
6493	                "fillOpacity": true,
6494	                "fontWeight": true,
6495	                "lineHeight": true,
6496	                "opacity": true,
6497	                "orphans": true,
6498	                "widows": true,
6499	                "zIndex": true,
6500	                "zoom": true
6501	        },
6502	
6503	        // Add in properties whose names you wish to fix before
6504	        // setting or getting the value
6505	        cssProps: {
6506	                // normalize float css property
6507	                "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6508	        },
6509	
6510	        // Get and set the style property on a DOM Node
6511	        style: function( elem, name, value, extra ) {
6512	                // Don't set styles on text and comment nodes
6513	                if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6514	                        return;
6515	                }
6516	
6517	                // Make sure that we're working with the right name
6518	                var ret, type, origName = jQuery.camelCase( name ),
6519	                        style = elem.style, hooks = jQuery.cssHooks[ origName ];
6520	
6521	                name = jQuery.cssProps[ origName ] || origName;
6522	
6523	                // Check if we're setting a value
6524	                if ( value !== undefined ) {
6525	                        type = typeof value;
6526	
6527	                        // convert relative number strings (+= or -=) to relative numbers. #7345
6528	                        if ( type === "string" && (ret = rrelNum.exec( value )) ) {
6529	                                value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
6530	                                // Fixes bug #9237
6531	                                type = "number";
6532	                        }
6533	
6534	                        // Make sure that NaN and null values aren't set. See: #7116
6535	                        if ( value == null || type === "number" && isNaN( value ) ) {
6536	                                return;
6537	                        }
6538	
6539	                        // If a number was passed in, add 'px' to the (except for certain CSS properties)
6540	                        if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6541	                                value += "px";
6542	                        }
6543	
6544	                        // If a hook was provided, use that value, otherwise just set the specified value
6545	                        if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
6546	                                // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6547	                                // Fixes bug #5509
6548	                                try {
6549	                                        style[ name ] = value;
6550	                                } catch(e) {}
6551	                        }
6552	
6553	                } else {
6554	                        // If a hook was provided get the non-computed value from there
6555	                        if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6556	                                return ret;
6557	                        }
6558	
6559	                        // Otherwise just get the value from the style object
6560	                        return style[ name ];
6561	                }
6562	        },
6563	
6564	        css: function( elem, name, extra ) {
6565	                var ret, hooks;
6566	
6567	                // Make sure that we're working with the right name
6568	                name = jQuery.camelCase( name );
6569	                hooks = jQuery.cssHooks[ name ];
6570	                name = jQuery.cssProps[ name ] || name;
6571	
6572	                // cssFloat needs a special treatment
6573	                if ( name === "cssFloat" ) {
6574	                        name = "float";
6575	                }
6576	
6577	                // If a hook was provided get the computed value from there
6578	                if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6579	                        return ret;
6580	
6581	                // Otherwise, if a way to get the computed value exists, use that
6582	                } else if ( curCSS ) {
6583	                        return curCSS( elem, name );
6584	                }
6585	        },
6586	
6587	        // A method for quickly swapping in/out CSS properties to get correct calculations
6588	        swap: function( elem, options, callback ) {
6589	                var old = {};
6590	
6591	                // Remember the old values, and insert the new ones
6592	                for ( var name in options ) {
6593	                        old[ name ] = elem.style[ name ];
6594	                        elem.style[ name ] = options[ name ];
6595	                }
6596	
6597	                callback.call( elem );
6598	
6599	                // Revert the old values
6600	                for ( name in options ) {
6601	                        elem.style[ name ] = old[ name ];
6602	                }
6603	        }
6604	});
6605	
6606	// DEPRECATED, Use jQuery.css() instead
6607	jQuery.curCSS = jQuery.css;
6608	
6609	jQuery.each(["height", "width"], function( i, name ) {
6610	        jQuery.cssHooks[ name ] = {
6611	                get: function( elem, computed, extra ) {
6612	                        var val;
6613	
6614	                        if ( computed ) {
6615	                                if ( elem.offsetWidth !== 0 ) {
6616	                                        return getWH( elem, name, extra );
6617	                                } else {
6618	                                        jQuery.swap( elem, cssShow, function() {
6619	                                                val = getWH( elem, name, extra );
6620	                                        });
6621	                                }
6622	
6623	                                return val;
6624	                        }
6625	                },
6626	
6627	                set: function( elem, value ) {
6628	                        if ( rnumpx.test( value ) ) {
6629	                                // ignore negative width and height values #1599
6630	                                value = parseFloat( value );
6631	
6632	                                if ( value >= 0 ) {
6633	                                        return value + "px";
6634	                                }
6635	
6636	                        } else {
6637	                                return value;
6638	                        }
6639	                }
6640	        };
6641	});
6642	
6643	if ( !jQuery.support.opacity ) {
6644	        jQuery.cssHooks.opacity = {
6645	                get: function( elem, computed ) {
6646	                        // IE uses filters for opacity
6647	                        return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
6648	                                ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6649	                                computed ? "1" : "";
6650	                },
6651	
6652	                set: function( elem, value ) {
6653	                        var style = elem.style,
6654	                                currentStyle = elem.currentStyle,
6655	                                opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
6656	                                filter = currentStyle && currentStyle.filter || style.filter || "";
6657	
6658	                        // IE has trouble with opacity if it does not have layout
6659	                        // Force it by setting the zoom level
6660	                        style.zoom = 1;
6661	
6662	                        // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
6663	                        if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
6664	
6665	                                // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
6666	                                // if "filter:" is present at all, clearType is disabled, we want to avoid this
6667	                                // style.removeAttribute is IE Only, but so apparently is this code path...
6668	                                style.removeAttribute( "filter" );
6669	
6670	                                // if there there is no filter style applied in a css rule, we are done
6671	                                if ( currentStyle && !currentStyle.filter ) {
6672	                                        return;
6673	                                }
6674	                        }
6675	
6676	                        // otherwise, set new filter values
6677	                        style.filter = ralpha.test( filter ) ?
6678	                                filter.replace( ralpha, opacity ) :
6679	                                filter + " " + opacity;
6680	                }
6681	        };
6682	}
6683	
6684	jQuery(function() {
6685	        // This hook cannot be added until DOM ready because the support test
6686	        // for it is not run until after DOM ready
6687	        if ( !jQuery.support.reliableMarginRight ) {
6688	                jQuery.cssHooks.marginRight = {
6689	                        get: function( elem, computed ) {
6690	                                // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6691	                                // Work around by temporarily setting element display to inline-block
6692	                                var ret;
6693	                                jQuery.swap( elem, { "display": "inline-block" }, function() {
6694	                                        if ( computed ) {
6695	                                                ret = curCSS( elem, "margin-right", "marginRight" );
6696	                                        } else {
6697	                                                ret = elem.style.marginRight;
6698	                                        }
6699	                                });
6700	                                return ret;
6701	                        }
6702	                };
6703	        }
6704	});
6705	
6706	if ( document.defaultView && document.defaultView.getComputedStyle ) {
6707	        getComputedStyle = function( elem, name ) {
6708	                var ret, defaultView, computedStyle;
6709	
6710	                name = name.replace( rupper, "-$1" ).toLowerCase();
6711	
6712	                if ( (defaultView = elem.ownerDocument.defaultView) &&
6713	                                (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6714	                        ret = computedStyle.getPropertyValue( name );
6715	                        if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6716	                                ret = jQuery.style( elem, name );
6717	                        }
6718	                }
6719	
6720	                return ret;
6721	        };
6722	}
6723	
6724	if ( document.documentElement.currentStyle ) {
6725	        currentStyle = function( elem, name ) {
6726	                var left, rsLeft, uncomputed,
6727	                        ret = elem.currentStyle && elem.currentStyle[ name ],
6728	                        style = elem.style;
6729	
6730	                // Avoid setting ret to empty string here
6731	                // so we don't default to auto
6732	                if ( ret === null && style && (uncomputed = style[ name ]) ) {
6733	                        ret = uncomputed;
6734	                }
6735	
6736	                // From the awesome hack by Dean Edwards
6737	                // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6738	
6739	                // If we're not dealing with a regular pixel number
6740	                // but a number that has a weird ending, we need to convert it to pixels
6741	                if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6742	
6743	                        // Remember the original values
6744	                        left = style.left;
6745	                        rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
6746	
6747	                        // Put in the new values to get a computed value out
6748	                        if ( rsLeft ) {
6749	                                elem.runtimeStyle.left = elem.currentStyle.left;
6750	                        }
6751	                        style.left = name === "fontSize" ? "1em" : ( ret || 0 );
6752	                        ret = style.pixelLeft + "px";
6753	
6754	                        // Revert the changed values
6755	                        style.left = left;
6756	                        if ( rsLeft ) {
6757	                                elem.runtimeStyle.left = rsLeft;
6758	                        }
6759	                }
6760	
6761	                return ret === "" ? "auto" : ret;
6762	        };
6763	}
6764	
6765	curCSS = getComputedStyle || currentStyle;
6766	
6767	function getWH( elem, name, extra ) {
6768	
6769	        // Start with offset property
6770	        var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6771	                which = name === "width" ? cssWidth : cssHeight,
6772	                i = 0,
6773	                len = which.length;
6774	
6775	        if ( val > 0 ) {
6776	                if ( extra !== "border" ) {
6777	                        for ( ; i < len; i++ ) {
6778	                                if ( !extra ) {
6779	                                        val -= parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6780	                                }
6781	                                if ( extra === "margin" ) {
6782	                                        val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6783	                                } else {
6784	                                        val -= parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6785	                                }
6786	                        }
6787	                }
6788	
6789	                return val + "px";
6790	        }
6791	
6792	        // Fall back to computed then uncomputed css if necessary
6793	        val = curCSS( elem, name, name );
6794	        if ( val < 0 || val == null ) {
6795	                val = elem.style[ name ] || 0;
6796	        }
6797	        // Normalize "", auto, and prepare for extra
6798	        val = parseFloat( val ) || 0;
6799	
6800	        // Add padding, border, margin
6801	        if ( extra ) {
6802	                for ( ; i < len; i++ ) {
6803	                        val += parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6804	                        if ( extra !== "padding" ) {
6805	                                val += parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6806	                        }
6807	                        if ( extra === "margin" ) {
6808	                                val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6809	                        }
6810	                }
6811	        }
6812	
6813	        return val + "px";
6814	}
6815	
6816	if ( jQuery.expr && jQuery.expr.filters ) {
6817	        jQuery.expr.filters.hidden = function( elem ) {
6818	                var width = elem.offsetWidth,
6819	                        height = elem.offsetHeight;
6820	
6821	                return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
6822	        };
6823	
6824	        jQuery.expr.filters.visible = function( elem ) {
6825	                return !jQuery.expr.filters.hidden( elem );
6826	        };
6827	}
6828	
6829	
6830	
6831	
6832	var r20 = /%20/g,
6833	        rbracket = /\[\]$/,
6834	        rCRLF = /\r?\n/g,
6835	        rhash = /#.*$/,
6836	        rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6837	        rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
6838	        // #7653, #8125, #8152: local protocol detection
6839	        rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
6840	        rnoContent = /^(?:GET|HEAD)$/,
6841	        rprotocol = /^\/\//,
6842	        rquery = /\?/,
6843	        rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
6844	        rselectTextarea = /^(?:select|textarea)/i,
6845	        rspacesAjax = /\s+/,
6846	        rts = /([?&])_=[^&]*/,
6847	        rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6848	
6849	        // Keep a copy of the old load method
6850	        _load = jQuery.fn.load,
6851	
6852	        /* Prefilters
6853	         * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6854	         * 2) These are called:
6855	         *    - BEFORE asking for a transport
6856	         *    - AFTER param serialization (s.data is a string if s.processData is true)
6857	         * 3) key is the dataType
6858	         * 4) the catchall symbol "*" can be used
6859	         * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6860	         */
6861	        prefilters = {},
6862	
6863	        /* Transports bindings
6864	         * 1) key is the dataType
6865	         * 2) the catchall symbol "*" can be used
6866	         * 3) selection will start with transport dataType and THEN go to "*" if needed
6867	         */
6868	        transports = {},
6869	
6870	        // Document location
6871	        ajaxLocation,
6872	
6873	        // Document location segments
6874	        ajaxLocParts,
6875	
6876	        // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
6877	        allTypes = ["*/"] + ["*"];
6878	
6879	// #8138, IE may throw an exception when accessing
6880	// a field from window.location if document.domain has been set
6881	try {
6882	        ajaxLocation = location.href;
6883	} catch( e ) {
6884	        // Use the href attribute of an A element
6885	        // since IE will modify it given document.location
6886	        ajaxLocation = document.createElement( "a" );
6887	        ajaxLocation.href = "";
6888	        ajaxLocation = ajaxLocation.href;
6889	}
6890	
6891	// Segment location into parts
6892	ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
6893	
6894	// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6895	function addToPrefiltersOrTransports( structure ) {
6896	
6897	        // dataTypeExpression is optional and defaults to "*"
6898	        return function( dataTypeExpression, func ) {
6899	
6900	                if ( typeof dataTypeExpression !== "string" ) {
6901	                        func = dataTypeExpression;
6902	                        dataTypeExpression = "*";
6903	                }
6904	
6905	                if ( jQuery.isFunction( func ) ) {
6906	                        var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6907	                                i = 0,
6908	                                length = dataTypes.length,
6909	                                dataType,
6910	                                list,
6911	                                placeBefore;
6912	
6913	                        // For each dataType in the dataTypeExpression
6914	                        for ( ; i < length; i++ ) {
6915	                                dataType = dataTypes[ i ];
6916	                                // We control if we're asked to add before
6917	                                // any existing element
6918	                                placeBefore = /^\+/.test( dataType );
6919	                                if ( placeBefore ) {
6920	                                        dataType = dataType.substr( 1 ) || "*";
6921	                                }
6922	                                list = structure[ dataType ] = structure[ dataType ] || [];
6923	                                // then we add to the structure accordingly
6924	                                list[ placeBefore ? "unshift" : "push" ]( func );
6925	                        }
6926	                }
6927	        };
6928	}
6929	
6930	// Base inspection function for prefilters and transports
6931	function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6932	                dataType /* internal */, inspected /* internal */ ) {
6933	
6934	        dataType = dataType || options.dataTypes[ 0 ];
6935	        inspected = inspected || {};
6936	
6937	        inspected[ dataType ] = true;
6938	
6939	        var list = structure[ dataType ],
6940	                i = 0,
6941	                length = list ? list.length : 0,
6942	                executeOnly = ( structure === prefilters ),
6943	                selection;
6944	
6945	        for ( ; i < length && ( executeOnly || !selection ); i++ ) {
6946	                selection = list[ i ]( options, originalOptions, jqXHR );
6947	                // If we got redirected to another dataType
6948	                // we try there if executing only and not done already
6949	                if ( typeof selection === "string" ) {
6950	                        if ( !executeOnly || inspected[ selection ] ) {
6951	                                selection = undefined;
6952	                        } else {
6953	                                options.dataTypes.unshift( selection );
6954	                                selection = inspectPrefiltersOrTransports(
6955	                                                structure, options, originalOptions, jqXHR, selection, inspected );
6956	                        }
6957	                }
6958	        }
6959	        // If we're only executing or nothing was selected
6960	        // we try the catchall dataType if not done already
6961	        if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
6962	                selection = inspectPrefiltersOrTransports(
6963	                                structure, options, originalOptions, jqXHR, "*", inspected );
6964	        }
6965	        // unnecessary when only executing (prefilters)
6966	        // but it'll be ignored by the caller in that case
6967	        return selection;
6968	}
6969	
6970	// A special extend for ajax options
6971	// that takes "flat" options (not to be deep extended)
6972	// Fixes #9887
6973	function ajaxExtend( target, src ) {
6974	        var key, deep,
6975	                flatOptions = jQuery.ajaxSettings.flatOptions || {};
6976	        for ( key in src ) {
6977	                if ( src[ key ] !== undefined ) {
6978	                        ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
6979	                }
6980	        }
6981	        if ( deep ) {
6982	                jQuery.extend( true, target, deep );
6983	        }
6984	}
6985	
6986	jQuery.fn.extend({
6987	        load: function( url, params, callback ) {
6988	                if ( typeof url !== "string" && _load ) {
6989	                        return _load.apply( this, arguments );
6990	
6991	                // Don't do a request if no elements are being requested
6992	                } else if ( !this.length ) {
6993	                        return this;
6994	                }
6995	
6996	                var off = url.indexOf( " " );
6997	                if ( off >= 0 ) {
6998	                        var selector = url.slice( off, url.length );
6999	                        url = url.slice( 0, off );
7000	                }
7001	
7002	                // Default to a GET request
7003	                var type = "GET";
7004	
7005	                // If the second parameter was provided
7006	                if ( params ) {
7007	                        // If it's a function
7008	                        if ( jQuery.isFunction( params ) ) {
7009	                                // We assume that it's the callback
7010	                                callback = params;
7011	                                params = undefined;
7012	
7013	                        // Otherwise, build a param string
7014	                        } else if ( typeof params === "object" ) {
7015	                                params = jQuery.param( params, jQuery.ajaxSettings.traditional );
7016	                                type = "POST";
7017	                        }
7018	                }
7019	
7020	                var self = this;
7021	
7022	                // Request the remote document
7023	                jQuery.ajax({
7024	                        url: url,
7025	                        type: type,
7026	                        dataType: "html",
7027	                        data: params,
7028	                        // Complete callback (responseText is used internally)
7029	                        complete: function( jqXHR, status, responseText ) {
7030	                                // Store the response as specified by the jqXHR object
7031	                                responseText = jqXHR.responseText;
7032	                                // If successful, inject the HTML into all the matched elements
7033	                                if ( jqXHR.isResolved() ) {
7034	                                        // #4825: Get the actual response in case
7035	                                        // a dataFilter is present in ajaxSettings
7036	                                        jqXHR.done(function( r ) {
7037	                                                responseText = r;
7038	                                        });
7039	                                        // See if a selector was specified
7040	                                        self.html( selector ?
7041	                                                // Create a dummy div to hold the results
7042	                                                jQuery("<div>")
7043	                                                        // inject the contents of the document in, removing the scripts
7044	                                                        // to avoid any 'Permission Denied' errors in IE
7045	                                                        .append(responseText.replace(rscript, ""))
7046	
7047	                                                        // Locate the specified elements
7048	                                                        .find(selector) :
7049	
7050	                                                // If not, just inject the full result
7051	                                                responseText );
7052	                                }
7053	
7054	                                if ( callback ) {
7055	                                        self.each( callback, [ responseText, status, jqXHR ] );
7056	                                }
7057	                        }
7058	                });
7059	
7060	                return this;
7061	        },
7062	
7063	        serialize: function() {
7064	                return jQuery.param( this.serializeArray() );
7065	        },
7066	
7067	        serializeArray: function() {
7068	                return this.map(function(){
7069	                        return this.elements ? jQuery.makeArray( this.elements ) : this;
7070	                })
7071	                .filter(function(){
7072	                        return this.name && !this.disabled &&
7073	                                ( this.checked || rselectTextarea.test( this.nodeName ) ||
7074	                                        rinput.test( this.type ) );
7075	                })
7076	                .map(function( i, elem ){
7077	                        var val = jQuery( this ).val();
7078	
7079	                        return val == null ?
7080	                                null :
7081	                                jQuery.isArray( val ) ?
7082	                                        jQuery.map( val, function( val, i ){
7083	                                                return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
7084	                                        }) :
7085	                                        { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
7086	                }).get();
7087	        }
7088	});
7089	
7090	// Attach a bunch of functions for handling common AJAX events
7091	jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
7092	        jQuery.fn[ o ] = function( f ){
7093	                return this.on( o, f );
7094	        };
7095	});
7096	
7097	jQuery.each( [ "get", "post" ], function( i, method ) {
7098	        jQuery[ method ] = function( url, data, callback, type ) {
7099	                // shift arguments if data argument was omitted
7100	                if ( jQuery.isFunction( data ) ) {
7101	                        type = type || callback;
7102	                        callback = data;
7103	                        data = undefined;
7104	                }
7105	
7106	                return jQuery.ajax({
7107	                        type: method,
7108	                        url: url,
7109	                        data: data,
7110	                        success: callback,
7111	                        dataType: type
7112	                });
7113	        };
7114	});
7115	
7116	jQuery.extend({
7117	
7118	        getScript: function( url, callback ) {
7119	                return jQuery.get( url, undefined, callback, "script" );
7120	        },
7121	
7122	        getJSON: function( url, data, callback ) {
7123	                return jQuery.get( url, data, callback, "json" );
7124	        },
7125	
7126	        // Creates a full fledged settings object into target
7127	        // with both ajaxSettings and settings fields.
7128	        // If target is omitted, writes into ajaxSettings.
7129	        ajaxSetup: function( target, settings ) {
7130	                if ( settings ) {
7131	                        // Building a settings object
7132	                        ajaxExtend( target, jQuery.ajaxSettings );
7133	                } else {
7134	                        // Extending ajaxSettings
7135	                        settings = target;
7136	                        target = jQuery.ajaxSettings;
7137	                }
7138	                ajaxExtend( target, settings );
7139	                return target;
7140	        },
7141	
7142	        ajaxSettings: {
7143	                url: ajaxLocation,
7144	                isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
7145	                global: true,
7146	                type: "GET",
7147	                contentType: "application/x-www-form-urlencoded",
7148	                processData: true,
7149	                async: true,
7150	                /*
7151	                timeout: 0,
7152	                data: null,
7153	                dataType: null,
7154	                username: null,
7155	                password: null,
7156	                cache: null,
7157	                traditional: false,
7158	                headers: {},
7159	                */
7160	
7161	                accepts: {
7162	                        xml: "application/xml, text/xml",
7163	                        html: "text/html",
7164	                        text: "text/plain",
7165	                        json: "application/json, text/javascript",
7166	                        "*": allTypes
7167	                },
7168	
7169	                contents: {
7170	                        xml: /xml/,
7171	                        html: /html/,
7172	                        json: /json/
7173	                },
7174	
7175	                responseFields: {
7176	                        xml: "responseXML",
7177	                        text: "responseText"
7178	                },
7179	
7180	                // List of data converters
7181	                // 1) key format is "source_type destination_type" (a single space in-between)
7182	                // 2) the catchall symbol "*" can be used for source_type
7183	                converters: {
7184	
7185	                        // Convert anything to text
7186	                        "* text": window.String,
7187	
7188	                        // Text to html (true = no transformation)
7189	                        "text html": true,
7190	
7191	                        // Evaluate text as a json expression
7192	                        "text json": jQuery.parseJSON,
7193	
7194	                        // Parse text as xml
7195	                        "text xml": jQuery.parseXML
7196	                },
7197	
7198	                // For options that shouldn't be deep extended:
7199	                // you can add your own custom options here if
7200	                // and when you create one that shouldn't be
7201	                // deep extended (see ajaxExtend)
7202	                flatOptions: {
7203	                        context: true,
7204	                        url: true
7205	                }
7206	        },
7207	
7208	        ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
7209	        ajaxTransport: addToPrefiltersOrTransports( transports ),
7210	
7211	        // Main method
7212	        ajax: function( url, options ) {
7213	
7214	                // If url is an object, simulate pre-1.5 signature
7215	                if ( typeof url === "object" ) {
7216	                        options = url;
7217	                        url = undefined;
7218	                }
7219	
7220	                // Force options to be an object
7221	                options = options || {};
7222	
7223	                var // Create the final options object
7224	                        s = jQuery.ajaxSetup( {}, options ),
7225	                        // Callbacks context
7226	                        callbackContext = s.context || s,
7227	                        // Context for global events
7228	                        // It's the callbackContext if one was provided in the options
7229	                        // and if it's a DOM node or a jQuery collection
7230	                        globalEventContext = callbackContext !== s &&
7231	                                ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
7232	                                                jQuery( callbackContext ) : jQuery.event,
7233	                        // Deferreds
7234	                        deferred = jQuery.Deferred(),
7235	                        completeDeferred = jQuery.Callbacks( "once memory" ),
7236	                        // Status-dependent callbacks
7237	                        statusCode = s.statusCode || {},
7238	                        // ifModified key
7239	                        ifModifiedKey,
7240	                        // Headers (they are sent all at once)
7241	                        requestHeaders = {},
7242	                        requestHeadersNames = {},
7243	                        // Response headers
7244	                        responseHeadersString,
7245	                        responseHeaders,
7246	                        // transport
7247	                        transport,
7248	                        // timeout handle
7249	                        timeoutTimer,
7250	                        // Cross-domain detection vars
7251	                        parts,
7252	                        // The jqXHR state
7253	                        state = 0,
7254	                        // To know if global events are to be dispatched
7255	                        fireGlobals,
7256	                        // Loop variable
7257	                        i,
7258	                        // Fake xhr
7259	                        jqXHR = {
7260	
7261	                                readyState: 0,
7262	
7263	                                // Caches the header
7264	                                setRequestHeader: function( name, value ) {
7265	                                        if ( !state ) {
7266	                                                var lname = name.toLowerCase();
7267	                                                name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
7268	                                                requestHeaders[ name ] = value;
7269	                                        }
7270	                                        return this;
7271	                                },
7272	
7273	                                // Raw string
7274	                                getAllResponseHeaders: function() {
7275	                                        return state === 2 ? responseHeadersString : null;
7276	                                },
7277	
7278	                                // Builds headers hashtable if needed
7279	                                getResponseHeader: function( key ) {
7280	                                        var match;
7281	                                        if ( state === 2 ) {
7282	                                                if ( !responseHeaders ) {
7283	                                                        responseHeaders = {};
7284	                                                        while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7285	                                                                responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7286	                                                        }
7287	                                                }
7288	                                                match = responseHeaders[ key.toLowerCase() ];
7289	                                        }
7290	                                        return match === undefined ? null : match;
7291	                                },
7292	
7293	                                // Overrides response content-type header
7294	                                overrideMimeType: function( type ) {
7295	                                        if ( !state ) {
7296	                                                s.mimeType = type;
7297	                                        }
7298	                                        return this;
7299	                                },
7300	
7301	                                // Cancel the request
7302	                                abort: function( statusText ) {
7303	                                        statusText = statusText || "abort";
7304	                                        if ( transport ) {
7305	                                                transport.abort( statusText );
7306	                                        }
7307	                                        done( 0, statusText );
7308	                                        return this;
7309	                                }
7310	                        };
7311	
7312	                // Callback for when everything is done
7313	                // It is defined here because jslint complains if it is declared
7314	                // at the end of the function (which would be more logical and readable)
7315	                function done( status, nativeStatusText, responses, headers ) {
7316	
7317	                        // Called once
7318	                        if ( state === 2 ) {
7319	                                return;
7320	                        }
7321	
7322	                        // State is "done" now
7323	                        state = 2;
7324	
7325	                        // Clear timeout if it exists
7326	                        if ( timeoutTimer ) {
7327	                                clearTimeout( timeoutTimer );
7328	                        }
7329	
7330	                        // Dereference transport for early garbage collection
7331	                        // (no matter how long the jqXHR object will be used)
7332	                        transport = undefined;
7333	
7334	                        // Cache response headers
7335	                        responseHeadersString = headers || "";
7336	
7337	                        // Set readyState
7338	                        jqXHR.readyState = status > 0 ? 4 : 0;
7339	
7340	                        var isSuccess,
7341	                                success,
7342	                                error,
7343	                                statusText = nativeStatusText,
7344	                                response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7345	                                lastModified,
7346	                                etag;
7347	
7348	                        // If successful, handle type chaining
7349	                        if ( status >= 200 && status < 300 || status === 304 ) {
7350	
7351	                                // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7352	                                if ( s.ifModified ) {
7353	
7354	                                        if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7355	                                                jQuery.lastModified[ ifModifiedKey ] = lastModified;
7356	                                        }
7357	                                        if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7358	                                                jQuery.etag[ ifModifiedKey ] = etag;
7359	                                        }
7360	                                }
7361	
7362	                                // If not modified
7363	                                if ( status === 304 ) {
7364	
7365	                                        statusText = "notmodified";
7366	                                        isSuccess = true;
7367	
7368	                                // If we have data
7369	                                } else {
7370	
7371	                                        try {
7372	                                                success = ajaxConvert( s, response );
7373	                                                statusText = "success";
7374	                                                isSuccess = true;
7375	                                        } catch(e) {
7376	                                                // We have a parsererror
7377	                                                statusText = "parsererror";
7378	                                                error = e;
7379	                                        }
7380	                                }
7381	                        } else {
7382	                                // We extract error from statusText
7383	                                // then normalize statusText and status for non-aborts
7384	                                error = statusText;
7385	                                if ( !statusText || status ) {
7386	                                        statusText = "error";
7387	                                        if ( status < 0 ) {
7388	                                                status = 0;
7389	                                        }
7390	                                }
7391	                        }
7392	
7393	                        // Set data for the fake xhr object
7394	                        jqXHR.status = status;
7395	                        jqXHR.statusText = "" + ( nativeStatusText || statusText );
7396	
7397	                        // Success/Error
7398	                        if ( isSuccess ) {
7399	                                deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7400	                        } else {
7401	                                deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7402	                        }
7403	
7404	                        // Status-dependent callbacks
7405	                        jqXHR.statusCode( statusCode );
7406	                        statusCode = undefined;
7407	
7408	                        if ( fireGlobals ) {
7409	                                globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7410	                                                [ jqXHR, s, isSuccess ? success : error ] );
7411	                        }
7412	
7413	                        // Complete
7414	                        completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
7415	
7416	                        if ( fireGlobals ) {
7417	                                globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
7418	                                // Handle the global AJAX counter
7419	                                if ( !( --jQuery.active ) ) {
7420	                                        jQuery.event.trigger( "ajaxStop" );
7421	                                }
7422	                        }
7423	                }
7424	
7425	                // Attach deferreds
7426	                deferred.promise( jqXHR );
7427	                jqXHR.success = jqXHR.done;
7428	                jqXHR.error = jqXHR.fail;
7429	                jqXHR.complete = completeDeferred.add;
7430	
7431	                // Status-dependent callbacks
7432	                jqXHR.statusCode = function( map ) {
7433	                        if ( map ) {
7434	                                var tmp;
7435	                                if ( state < 2 ) {
7436	                                        for ( tmp in map ) {
7437	                                                statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7438	                                        }
7439	                                } else {
7440	                                        tmp = map[ jqXHR.status ];
7441	                                        jqXHR.then( tmp, tmp );
7442	                                }
7443	                        }
7444	                        return this;
7445	                };
7446	
7447	                // Remove hash character (#7531: and string promotion)
7448	                // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7449	                // We also use the url parameter if available
7450	                s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7451	
7452	                // Extract dataTypes list
7453	                s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
7454	
7455	                // Determine if a cross-domain request is in order
7456	                if ( s.crossDomain == null ) {
7457	                        parts = rurl.exec( s.url.toLowerCase() );
7458	                        s.crossDomain = !!( parts &&
7459	                                ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
7460	                                        ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7461	                                                ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7462	                        );
7463	                }
7464	
7465	                // Convert data if not already a string
7466	                if ( s.data && s.processData && typeof s.data !== "string" ) {
7467	                        s.data = jQuery.param( s.data, s.traditional );
7468	                }
7469	
7470	                // Apply prefilters
7471	                inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7472	
7473	                // If request was aborted inside a prefiler, stop there
7474	                if ( state === 2 ) {
7475	                        return false;
7476	                }
7477	
7478	                // We can fire global events as of now if asked to
7479	                fireGlobals = s.global;
7480	
7481	                // Uppercase the type
7482	                s.type = s.type.toUpperCase();
7483	
7484	                // Determine if request has content
7485	                s.hasContent = !rnoContent.test( s.type );
7486	
7487	                // Watch for a new set of requests
7488	                if ( fireGlobals && jQuery.active++ === 0 ) {
7489	                        jQuery.event.trigger( "ajaxStart" );
7490	                }
7491	
7492	                // More options handling for requests with no content
7493	                if ( !s.hasContent ) {
7494	
7495	                        // If data is available, append data to url
7496	                        if ( s.data ) {
7497	                                s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7498	                                // #9682: remove data so that it's not used in an eventual retry
7499	                                delete s.data;
7500	                        }
7501	
7502	                        // Get ifModifiedKey before adding the anti-cache parameter
7503	                        ifModifiedKey = s.url;
7504	
7505	                        // Add anti-cache in url if needed
7506	                        if ( s.cache === false ) {
7507	
7508	                                var ts = jQuery.now(),
7509	                                        // try replacing _= if it is there
7510	                                        ret = s.url.replace( rts, "$1_=" + ts );
7511	
7512	                                // if nothing was replaced, add timestamp to the end
7513	                                s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7514	                        }
7515	                }
7516	
7517	                // Set the correct header, if data is being sent
7518	                if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
7519	                        jqXHR.setRequestHeader( "Content-Type", s.contentType );
7520	                }
7521	
7522	                // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7523	                if ( s.ifModified ) {
7524	                        ifModifiedKey = ifModifiedKey || s.url;
7525	                        if ( jQuery.lastModified[ ifModifiedKey ] ) {
7526	                                jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7527	                        }
7528	                        if ( jQuery.etag[ ifModifiedKey ] ) {
7529	                                jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7530	                        }
7531	                }
7532	
7533	                // Set the Accepts header for the server, depending on the dataType
7534	                jqXHR.setRequestHeader(
7535	                        "Accept",
7536	                        s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7537	                                s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
7538	                                s.accepts[ "*" ]
7539	                );
7540	
7541	                // Check for headers option
7542	                for ( i in s.headers ) {
7543	                        jqXHR.setRequestHeader( i, s.headers[ i ] );
7544	                }
7545	
7546	                // Allow custom headers/mimetypes and early abort
7547	                if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
7548	                                // Abort if not done already
7549	                                jqXHR.abort();
7550	                                return false;
7551	
7552	                }
7553	
7554	                // Install callbacks on deferreds
7555	                for ( i in { success: 1, error: 1, complete: 1 } ) {
7556	                        jqXHR[ i ]( s[ i ] );
7557	                }
7558	
7559	                // Get transport
7560	                transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7561	
7562	                // If no transport, we auto-abort
7563	                if ( !transport ) {
7564	                        done( -1, "No Transport" );
7565	                } else {
7566	                        jqXHR.readyState = 1;
7567	                        // Send global event
7568	                        if ( fireGlobals ) {
7569	                                globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7570	                        }
7571	                        // Timeout
7572	                        if ( s.async && s.timeout > 0 ) {
7573	                                timeoutTimer = setTimeout( function(){
7574	                                        jqXHR.abort( "timeout" );
7575	                                }, s.timeout );
7576	                        }
7577	
7578	                        try {
7579	                                state = 1;
7580	                                transport.send( requestHeaders, done );
7581	                        } catch (e) {
7582	                                // Propagate exception as error if not done
7583	                                if ( state < 2 ) {
7584	                                        done( -1, e );
7585	                                // Simply rethrow otherwise
7586	                                } else {
7587	                                        throw e;
7588	                                }
7589	                        }
7590	                }
7591	
7592	                return jqXHR;
7593	        },
7594	
7595	        // Serialize an array of form elements or a set of
7596	        // key/values into a query string
7597	        param: function( a, traditional ) {
7598	                var s = [],
7599	                        add = function( key, value ) {
7600	                                // If value is a function, invoke it and return its value
7601	                                value = jQuery.isFunction( value ) ? value() : value;
7602	                                s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7603	                        };
7604	
7605	                // Set traditional to true for jQuery <= 1.3.2 behavior.
7606	                if ( traditional === undefined ) {
7607	                        traditional = jQuery.ajaxSettings.traditional;
7608	                }
7609	
7610	                // If an array was passed in, assume that it is an array of form elements.
7611	                if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7612	                        // Serialize the form elements
7613	                        jQuery.each( a, function() {
7614	                                add( this.name, this.value );
7615	                        });
7616	
7617	                } else {
7618	                        // If traditional, encode the "old" way (the way 1.3.2 or older
7619	                        // did it), otherwise encode params recursively.
7620	                        for ( var prefix in a ) {
7621	                                buildParams( prefix, a[ prefix ], traditional, add );
7622	                        }
7623	                }
7624	
7625	                // Return the resulting serialization
7626	                return s.join( "&" ).replace( r20, "+" );
7627	        }
7628	});
7629	
7630	function buildParams( prefix, obj, traditional, add ) {
7631	        if ( jQuery.isArray( obj ) ) {
7632	                // Serialize array item.
7633	                jQuery.each( obj, function( i, v ) {
7634	                        if ( traditional || rbracket.test( prefix ) ) {
7635	                                // Treat each array item as a scalar.
7636	                                add( prefix, v );
7637	
7638	                        } else {
7639	                                // If array item is non-scalar (array or object), encode its
7640	                                // numeric index to resolve deserialization ambiguity issues.
7641	                                // Note that rack (as of 1.0.0) can't currently deserialize
7642	                                // nested arrays properly, and attempting to do so may cause
7643	                                // a server error. Possible fixes are to modify rack's
7644	                                // deserialization algorithm or to provide an option or flag
7645	                                // to force array serialization to be shallow.
7646	                                buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7647	                        }
7648	                });
7649	
7650	        } else if ( !traditional && obj != null && typeof obj === "object" ) {
7651	                // Serialize object item.
7652	                for ( var name in obj ) {
7653	                        buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7654	                }
7655	
7656	        } else {
7657	                // Serialize scalar item.
7658	                add( prefix, obj );
7659	        }
7660	}
7661	
7662	// This is still on the jQuery object... for now
7663	// Want to move this to jQuery.ajax some day
7664	jQuery.extend({
7665	
7666	        // Counter for holding the number of active queries
7667	        active: 0,
7668	
7669	        // Last-Modified header cache for next request
7670	        lastModified: {},
7671	        etag: {}
7672	
7673	});
7674	
7675	/* Handles responses to an ajax request:
7676	 * - sets all responseXXX fields accordingly
7677	 * - finds the right dataType (mediates between content-type and expected dataType)
7678	 * - returns the corresponding response
7679	 */
7680	function ajaxHandleResponses( s, jqXHR, responses ) {
7681	
7682	        var contents = s.contents,
7683	                dataTypes = s.dataTypes,
7684	                responseFields = s.responseFields,
7685	                ct,
7686	                type,
7687	                finalDataType,
7688	                firstDataType;
7689	
7690	        // Fill responseXXX fields
7691	        for ( type in responseFields ) {
7692	                if ( type in responses ) {
7693	                        jqXHR[ responseFields[type] ] = responses[ type ];
7694	                }
7695	        }
7696	
7697	        // Remove auto dataType and get content-type in the process
7698	        while( dataTypes[ 0 ] === "*" ) {
7699	                dataTypes.shift();
7700	                if ( ct === undefined ) {
7701	                        ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
7702	                }
7703	        }
7704	
7705	        // Check if we're dealing with a known content-type
7706	        if ( ct ) {
7707	                for ( type in contents ) {
7708	                        if ( contents[ type ] && contents[ type ].test( ct ) ) {
7709	                                dataTypes.unshift( type );
7710	                                break;
7711	                        }
7712	                }
7713	        }
7714	
7715	        // Check to see if we have a response for the expected dataType
7716	        if ( dataTypes[ 0 ] in responses ) {
7717	                finalDataType = dataTypes[ 0 ];
7718	        } else {
7719	                // Try convertible dataTypes
7720	                for ( type in responses ) {
7721	                        if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
7722	                                finalDataType = type;
7723	                                break;
7724	                        }
7725	                        if ( !firstDataType ) {
7726	                                firstDataType = type;
7727	                        }
7728	                }
7729	                // Or just use first one
7730	                finalDataType = finalDataType || firstDataType;
7731	        }
7732	
7733	        // If we found a dataType
7734	        // We add the dataType to the list if needed
7735	        // and return the corresponding response
7736	        if ( finalDataType ) {
7737	                if ( finalDataType !== dataTypes[ 0 ] ) {
7738	                        dataTypes.unshift( finalDataType );
7739	                }
7740	                return responses[ finalDataType ];
7741	        }
7742	}
7743	
7744	// Chain conversions given the request and the original response
7745	function ajaxConvert( s, response ) {
7746	
7747	        // Apply the dataFilter if provided
7748	        if ( s.dataFilter ) {
7749	                response = s.dataFilter( response, s.dataType );
7750	        }
7751	
7752	        var dataTypes = s.dataTypes,
7753	                converters = {},
7754	                i,
7755	                key,
7756	                length = dataTypes.length,
7757	                tmp,
7758	                // Current and previous dataTypes
7759	                current = dataTypes[ 0 ],
7760	                prev,
7761	                // Conversion expression
7762	                conversion,
7763	                // Conversion function
7764	                conv,
7765	                // Conversion functions (transitive conversion)
7766	                conv1,
7767	                conv2;
7768	
7769	        // For each dataType in the chain
7770	        for ( i = 1; i < length; i++ ) {
7771	
7772	                // Create converters map
7773	                // with lowercased keys
7774	                if ( i === 1 ) {
7775	                        for ( key in s.converters ) {
7776	                                if ( typeof key === "string" ) {
7777	                                        converters[ key.toLowerCase() ] = s.converters[ key ];
7778	                                }
7779	                        }
7780	                }
7781	
7782	                // Get the dataTypes
7783	                prev = current;
7784	                current = dataTypes[ i ];
7785	
7786	                // If current is auto dataType, update it to prev
7787	                if ( current === "*" ) {
7788	                        current = prev;
7789	                // If no auto and dataTypes are actually different
7790	                } else if ( prev !== "*" && prev !== current ) {
7791	
7792	                        // Get the converter
7793	                        conversion = prev + " " + current;
7794	                        conv = converters[ conversion ] || converters[ "* " + current ];
7795	
7796	                        // If there is no direct converter, search transitively
7797	                        if ( !conv ) {
7798	                                conv2 = undefined;
7799	                                for ( conv1 in converters ) {
7800	                                        tmp = conv1.split( " " );
7801	                                        if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
7802	                                                conv2 = converters[ tmp[1] + " " + current ];
7803	                                                if ( conv2 ) {
7804	                                                        conv1 = converters[ conv1 ];
7805	                                                        if ( conv1 === true ) {
7806	                                                                conv = conv2;
7807	                                                        } else if ( conv2 === true ) {
7808	                                                                conv = conv1;
7809	                                                        }
7810	                                                        break;
7811	                                                }
7812	                                        }
7813	                                }
7814	                        }
7815	                        // If we found no converter, dispatch an error
7816	                        if ( !( conv || conv2 ) ) {
7817	                                jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7818	                        }
7819	                        // If found converter is not an equivalence
7820	                        if ( conv !== true ) {
7821	                                // Convert with 1 or 2 converters accordingly
7822	                                response = conv ? conv( response ) : conv2( conv1(response) );
7823	                        }
7824	                }
7825	        }
7826	        return response;
7827	}
7828	
7829	
7830	
7831	
7832	var jsc = jQuery.now(),
7833	        jsre = /(\=)\?(&|$)|\?\?/i;
7834	
7835	// Default jsonp settings
7836	jQuery.ajaxSetup({
7837	        jsonp: "callback",
7838	        jsonpCallback: function() {
7839	                return jQuery.expando + "_" + ( jsc++ );
7840	        }
7841	});
7842	
7843	// Detect, normalize options and install callbacks for jsonp requests
7844	jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7845	
7846	        var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7847	                ( typeof s.data === "string" );
7848	
7849	        if ( s.dataTypes[ 0 ] === "jsonp" ||
7850	                s.jsonp !== false && ( jsre.test( s.url ) ||
7851	                                inspectData && jsre.test( s.data ) ) ) {
7852	
7853	                var responseContainer,
7854	                        jsonpCallback = s.jsonpCallback =
7855	                                jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7856	                        previous = window[ jsonpCallback ],
7857	                        url = s.url,
7858	                        data = s.data,
7859	                        replace = "$1" + jsonpCallback + "$2";
7860	
7861	                if ( s.jsonp !== false ) {
7862	                        url = url.replace( jsre, replace );
7863	                        if ( s.url === url ) {
7864	                                if ( inspectData ) {
7865	                                        data = data.replace( jsre, replace );
7866	                                }
7867	                                if ( s.data === data ) {
7868	                                        // Add callback manually
7869	                                        url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7870	                                }
7871	                        }
7872	                }
7873	
7874	                s.url = url;
7875	                s.data = data;
7876	
7877	                // Install callback
7878	                window[ jsonpCallback ] = function( response ) {
7879	                        responseContainer = [ response ];
7880	                };
7881	
7882	                // Clean-up function
7883	                jqXHR.always(function() {
7884	                        // Set callback back to previous value
7885	                        window[ jsonpCallback ] = previous;
7886	                        // Call if it was a function and we have a response
7887	                        if ( responseContainer && jQuery.isFunction( previous ) ) {
7888	                                window[ jsonpCallback ]( responseContainer[ 0 ] );
7889	                        }
7890	                });
7891	
7892	                // Use data converter to retrieve json after script execution
7893	                s.converters["script json"] = function() {
7894	                        if ( !responseContainer ) {
7895	                                jQuery.error( jsonpCallback + " was not called" );
7896	                        }
7897	                        return responseContainer[ 0 ];
7898	                };
7899	
7900	                // force json dataType
7901	                s.dataTypes[ 0 ] = "json";
7902	
7903	                // Delegate to script
7904	                return "script";
7905	        }
7906	});
7907	
7908	
7909	
7910	
7911	// Install script dataType
7912	jQuery.ajaxSetup({
7913	        accepts: {
7914	                script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7915	        },
7916	        contents: {
7917	                script: /javascript|ecmascript/
7918	        },
7919	        converters: {
7920	                "text script": function( text ) {
7921	                        jQuery.globalEval( text );
7922	                        return text;
7923	                }
7924	        }
7925	});
7926	
7927	// Handle cache's special case and global
7928	jQuery.ajaxPrefilter( "script", function( s ) {
7929	        if ( s.cache === undefined ) {
7930	                s.cache = false;
7931	        }
7932	        if ( s.crossDomain ) {
7933	                s.type = "GET";
7934	                s.global = false;
7935	        }
7936	});
7937	
7938	// Bind script tag hack transport
7939	jQuery.ajaxTransport( "script", function(s) {
7940	
7941	        // This transport only deals with cross domain requests
7942	        if ( s.crossDomain ) {
7943	
7944	                var script,
7945	                        head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
7946	
7947	                return {
7948	
7949	                        send: function( _, callback ) {
7950	
7951	                                script = document.createElement( "script" );
7952	
7953	                                script.async = "async";
7954	
7955	                                if ( s.scriptCharset ) {
7956	                                        script.charset = s.scriptCharset;
7957	                                }
7958	
7959	                                script.src = s.url;
7960	
7961	                                // Attach handlers for all browsers
7962	                                script.onload = script.onreadystatechange = function( _, isAbort ) {
7963	
7964	                                        if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
7965	
7966	                                                // Handle memory leak in IE
7967	                                                script.onload = script.onreadystatechange = null;
7968	
7969	                                                // Remove the script
7970	                                                if ( head && script.parentNode ) {
7971	                                                        head.removeChild( script );
7972	                                                }
7973	
7974	                                                // Dereference the script
7975	                                                script = undefined;
7976	
7977	                                                // Callback if not abort
7978	                                                if ( !isAbort ) {
7979	                                                        callback( 200, "success" );
7980	                                                }
7981	                                        }
7982	                                };
7983	                                // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
7984	                                // This arises when a base node is used (#2709 and #4378).
7985	                                head.insertBefore( script, head.firstChild );
7986	                        },
7987	
7988	                        abort: function() {
7989	                                if ( script ) {
7990	                                        script.onload( 0, 1 );
7991	                                }
7992	                        }
7993	                };
7994	        }
7995	});
7996	
7997	
7998	
7999	
8000	var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
8001	        xhrOnUnloadAbort = window.ActiveXObject ? function() {
8002	                // Abort all pending requests
8003	                for ( var key in xhrCallbacks ) {
8004	                        xhrCallbacks[ key ]( 0, 1 );
8005	                }
8006	        } : false,
8007	        xhrId = 0,
8008	        xhrCallbacks;
8009	
8010	// Functions to create xhrs
8011	function createStandardXHR() {
8012	        try {
8013	                return new window.XMLHttpRequest();
8014	        } catch( e ) {}
8015	}
8016	
8017	function createActiveXHR() {
8018	        try {
8019	                return new window.ActiveXObject( "Microsoft.XMLHTTP" );
8020	        } catch( e ) {}
8021	}
8022	
8023	// Create the request object
8024	// (This is still attached to ajaxSettings for backward compatibility)
8025	jQuery.ajaxSettings.xhr = window.ActiveXObject ?
8026	        /* Microsoft failed to properly
8027	         * implement the XMLHttpRequest in IE7 (can't request local files),
8028	         * so we use the ActiveXObject when it is available
8029	         * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
8030	         * we need a fallback.
8031	         */
8032	        function() {
8033	                return !this.isLocal && createStandardXHR() || createActiveXHR();
8034	        } :
8035	        // For all other browsers, use the standard XMLHttpRequest object
8036	        createStandardXHR;
8037	
8038	// Determine support properties
8039	(function( xhr ) {
8040	        jQuery.extend( jQuery.support, {
8041	                ajax: !!xhr,
8042	                cors: !!xhr && ( "withCredentials" in xhr )
8043	        });
8044	})( jQuery.ajaxSettings.xhr() );
8045	
8046	// Create transport if the browser can provide an xhr
8047	if ( jQuery.support.ajax ) {
8048	
8049	        jQuery.ajaxTransport(function( s ) {
8050	                // Cross domain only allowed if supported through XMLHttpRequest
8051	                if ( !s.crossDomain || jQuery.support.cors ) {
8052	
8053	                        var callback;
8054	
8055	                        return {
8056	                                send: function( headers, complete ) {
8057	
8058	                                        // Get a new xhr
8059	                                        var xhr = s.xhr(),
8060	                                                handle,
8061	                                                i;
8062	
8063	                                        // Open the socket
8064	                                        // Passing null username, generates a login popup on Opera (#2865)
8065	                                        if ( s.username ) {
8066	                                                xhr.open( s.type, s.url, s.async, s.username, s.password );
8067	                                        } else {
8068	                                                xhr.open( s.type, s.url, s.async );
8069	                                        }
8070	
8071	                                        // Apply custom fields if provided
8072	                                        if ( s.xhrFields ) {
8073	                                                for ( i in s.xhrFields ) {
8074	                                                        xhr[ i ] = s.xhrFields[ i ];
8075	                                                }
8076	                                        }
8077	
8078	                                        // Override mime type if needed
8079	                                        if ( s.mimeType && xhr.overrideMimeType ) {
8080	                                                xhr.overrideMimeType( s.mimeType );
8081	                                        }
8082	
8083	                                        // X-Requested-With header
8084	                                        // For cross-domain requests, seeing as conditions for a preflight are
8085	                                        // akin to a jigsaw puzzle, we simply never set it to be sure.
8086	                                        // (it can always be set on a per-request basis or even using ajaxSetup)
8087	                                        // For same-domain requests, won't change header if already provided.
8088	                                        if ( !s.crossDomain && !headers["X-Requested-With"] ) {
8089	                                                headers[ "X-Requested-With" ] = "XMLHttpRequest";
8090	                                        }
8091	
8092	                                        // Need an extra try/catch for cross domain requests in Firefox 3
8093	                                        try {
8094	                                                for ( i in headers ) {
8095	                                                        xhr.setRequestHeader( i, headers[ i ] );
8096	                                                }
8097	                                        } catch( _ ) {}
8098	
8099	                                        // Do send the request
8100	                                        // This may raise an exception which is actually
8101	                                        // handled in jQuery.ajax (so no try/catch here)
8102	                                        xhr.send( ( s.hasContent && s.data ) || null );
8103	
8104	                                        // Listener
8105	                                        callback = function( _, isAbort ) {
8106	
8107	                                                var status,
8108	                                                        statusText,
8109	                                                        responseHeaders,
8110	                                                        responses,
8111	                                                        xml;
8112	
8113	                                                // Firefox throws exceptions when accessing properties
8114	                                                // of an xhr when a network error occured
8115	                                                // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
8116	                                                try {
8117	
8118	                                                        // Was never called and is aborted or complete
8119	                                                        if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
8120	
8121	                                                                // Only called once
8122	                                                                callback = undefined;
8123	
8124	                                                                // Do not keep as active anymore
8125	                                                                if ( handle ) {
8126	                                                                        xhr.onreadystatechange = jQuery.noop;
8127	                                                                        if ( xhrOnUnloadAbort ) {
8128	                                                                                delete xhrCallbacks[ handle ];
8129	                                                                        }
8130	                                                                }
8131	
8132	                                                                // If it's an abort
8133	                                                                if ( isAbort ) {
8134	                                                                        // Abort it manually if needed
8135	                                                                        if ( xhr.readyState !== 4 ) {
8136	                                                                                xhr.abort();
8137	                                                                        }
8138	                                                                } else {
8139	                                                                        status = xhr.status;
8140	                                                                        responseHeaders = xhr.getAllResponseHeaders();
8141	                                                                        responses = {};
8142	                                                                        xml = xhr.responseXML;
8143	
8144	                                                                        // Construct response list
8145	                                                                        if ( xml && xml.documentElement /* #4958 */ ) {
8146	                                                                                responses.xml = xml;
8147	                                                                        }
8148	                                                                        responses.text = xhr.responseText;
8149	
8150	                                                                        // Firefox throws an exception when accessing
8151	                                                                        // statusText for faulty cross-domain requests
8152	                                                                        try {
8153	                                                                                statusText = xhr.statusText;
8154	                                                                        } catch( e ) {
8155	                                                                                // We normalize with Webkit giving an empty statusText
8156	                                                                                statusText = "";
8157	                                                                        }
8158	
8159	                                                                        // Filter status for non standard behaviors
8160	
8161	                                                                        // If the request is local and we have data: assume a success
8162	                                                                        // (success with no data won't get notified, that's the best we
8163	                                                                        // can do given current implementations)
8164	                                                                        if ( !status && s.isLocal && !s.crossDomain ) {
8165	                                                                                status = responses.text ? 200 : 404;
8166	                                                                        // IE - #1450: sometimes returns 1223 when it should be 204
8167	                                                                        } else if ( status === 1223 ) {
8168	                                                                                status = 204;
8169	                                                                        }
8170	                                                                }
8171	                                                        }
8172	                                                } catch( firefoxAccessException ) {
8173	                                                        if ( !isAbort ) {
8174	                                                                complete( -1, firefoxAccessException );
8175	                                                        }
8176	                                                }
8177	
8178	                                                // Call complete if needed
8179	                                                if ( responses ) {
8180	                                                        complete( status, statusText, responses, responseHeaders );
8181	                                                }
8182	                                        };
8183	
8184	                                        // if we're in sync mode or it's in cache
8185	                                        // and has been retrieved directly (IE6 & IE7)
8186	                                        // we need to manually fire the callback
8187	                                        if ( !s.async || xhr.readyState === 4 ) {
8188	                                                callback();
8189	                                        } else {
8190	                                                handle = ++xhrId;
8191	                                                if ( xhrOnUnloadAbort ) {
8192	                                                        // Create the active xhrs callbacks list if needed
8193	                                                        // and attach the unload handler
8194	                                                        if ( !xhrCallbacks ) {
8195	                                                                xhrCallbacks = {};
8196	                                                                jQuery( window ).unload( xhrOnUnloadAbort );
8197	                                                        }
8198	                                                        // Add to list of active xhrs callbacks
8199	                                                        xhrCallbacks[ handle ] = callback;
8200	                                                }
8201	                                                xhr.onreadystatechange = callback;
8202	                                        }
8203	                                },
8204	
8205	                                abort: function() {
8206	                                        if ( callback ) {
8207	                                                callback(0,1);
8208	                                        }
8209	                                }
8210	                        };
8211	                }
8212	        });
8213	}
8214	
8215	
8216	
8217	
8218	var elemdisplay = {},
8219	        iframe, iframeDoc,
8220	        rfxtypes = /^(?:toggle|show|hide)$/,
8221	        rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
8222	        timerId,
8223	        fxAttrs = [
8224	                // height animations
8225	                [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
8226	                // width animations
8227	                [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
8228	                // opacity animations
8229	                [ "opacity" ]
8230	        ],
8231	        fxNow;
8232	
8233	jQuery.fn.extend({
8234	        show: function( speed, easing, callback ) {
8235	                var elem, display;
8236	
8237	                if ( speed || speed === 0 ) {
8238	                        return this.animate( genFx("show", 3), speed, easing, callback );
8239	
8240	                } else {
8241	                        for ( var i = 0, j = this.length; i < j; i++ ) {
8242	                                elem = this[ i ];
8243	
8244	                                if ( elem.style ) {
8245	                                        display = elem.style.display;
8246	
8247	                                        // Reset the inline display of this element to learn if it is
8248	                                        // being hidden by cascaded rules or not
8249	                                        if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
8250	                                                display = elem.style.display = "";
8251	                                        }
8252	
8253	                                        // Set elements which have been overridden with display: none
8254	                                        // in a stylesheet to whatever the default browser style is
8255	                                        // for such an element
8256	                                        if ( display === "" && jQuery.css(elem, "display") === "none" ) {
8257	                                                jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
8258	                                        }
8259	                                }
8260	                        }
8261	
8262	                        // Set the display of most of the elements in a second loop
8263	                        // to avoid the constant reflow
8264	                        for ( i = 0; i < j; i++ ) {
8265	                                elem = this[ i ];
8266	
8267	                                if ( elem.style ) {
8268	                                        display = elem.style.display;
8269	
8270	                                        if ( display === "" || display === "none" ) {
8271	                                                elem.style.display = jQuery._data( elem, "olddisplay" ) || "";
8272	                                        }
8273	                                }
8274	                        }
8275	
8276	                        return this;
8277	                }
8278	        },
8279	
8280	        hide: function( speed, easing, callback ) {
8281	                if ( speed || speed === 0 ) {
8282	                        return this.animate( genFx("hide", 3), speed, easing, callback);
8283	
8284	                } else {
8285	                        var elem, display,
8286	                                i = 0,
8287	                                j = this.length;
8288	
8289	                        for ( ; i < j; i++ ) {
8290	                                elem = this[i];
8291	                                if ( elem.style ) {
8292	                                        display = jQuery.css( elem, "display" );
8293	
8294	                                        if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) {
8295	                                                jQuery._data( elem, "olddisplay", display );
8296	                                        }
8297	                                }
8298	                        }
8299	
8300	                        // Set the display of the elements in a second loop
8301	                        // to avoid the constant reflow
8302	                        for ( i = 0; i < j; i++ ) {
8303	                                if ( this[i].style ) {
8304	                                        this[i].style.display = "none";
8305	                                }
8306	                        }
8307	
8308	                        return this;
8309	                }
8310	        },
8311	
8312	        // Save the old toggle function
8313	        _toggle: jQuery.fn.toggle,
8314	
8315	        toggle: function( fn, fn2, callback ) {
8316	                var bool = typeof fn === "boolean";
8317	
8318	                if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8319	                        this._toggle.apply( this, arguments );
8320	
8321	                } else if ( fn == null || bool ) {
8322	                        this.each(function() {
8323	                                var state = bool ? fn : jQuery(this).is(":hidden");
8324	                                jQuery(this)[ state ? "show" : "hide" ]();
8325	                        });
8326	
8327	                } else {
8328	                        this.animate(genFx("toggle", 3), fn, fn2, callback);
8329	                }
8330	
8331	                return this;
8332	        },
8333	
8334	        fadeTo: function( speed, to, easing, callback ) {
8335	                return this.filter(":hidden").css("opacity", 0).show().end()
8336	                                        .animate({opacity: to}, speed, easing, callback);
8337	        },
8338	
8339	        animate: function( prop, speed, easing, callback ) {
8340	                var optall = jQuery.speed( speed, easing, callback );
8341	
8342	                if ( jQuery.isEmptyObject( prop ) ) {
8343	                        return this.each( optall.complete, [ false ] );
8344	                }
8345	
8346	                // Do not change referenced properties as per-property easing will be lost
8347	                prop = jQuery.extend( {}, prop );
8348	
8349	                function doAnimation() {
8350	                        // XXX 'this' does not always have a nodeName when running the
8351	                        // test suite
8352	
8353	                        if ( optall.queue === false ) {
8354	                                jQuery._mark( this );
8355	                        }
8356	
8357	                        var opt = jQuery.extend( {}, optall ),
8358	                                isElement = this.nodeType === 1,
8359	                                hidden = isElement && jQuery(this).is(":hidden"),
8360	                                name, val, p, e,
8361	                                parts, start, end, unit,
8362	                                method;
8363	
8364	                        // will store per property easing and be used to determine when an animation is complete
8365	                        opt.animatedProperties = {};
8366	
8367	                        for ( p in prop ) {
8368	
8369	                                // property name normalization
8370	                                name = jQuery.camelCase( p );
8371	                                if ( p !== name ) {
8372	                                        prop[ name ] = prop[ p ];
8373	                                        delete prop[ p ];
8374	                                }
8375	
8376	                                val = prop[ name ];
8377	
8378	                                // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8379	                                if ( jQuery.isArray( val ) ) {
8380	                                        opt.animatedProperties[ name ] = val[ 1 ];
8381	                                        val = prop[ name ] = val[ 0 ];
8382	                                } else {
8383	                                        opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
8384	                                }
8385	
8386	                                if ( val === "hide" && hidden || val === "show" && !hidden ) {
8387	                                        return opt.complete.call( this );
8388	                                }
8389	
8390	                                if ( isElement && ( name === "height" || name === "width" ) ) {
8391	                                        // Make sure that nothing sneaks out
8392	                                        // Record all 3 overflow attributes because IE does not
8393	                                        // change the overflow attribute when overflowX and
8394	                                        // overflowY are set to the same value
8395	                                        opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8396	
8397	                                        // Set display property to inline-block for height/width
8398	                                        // animations on inline elements that are having width/height animated
8399	                                        if ( jQuery.css( this, "display" ) === "inline" &&
8400	                                                        jQuery.css( this, "float" ) === "none" ) {
8401	
8402	                                                // inline-level elements accept inline-block;
8403	                                                // block-level elements need to be inline with layout
8404	                                                if ( !jQuery.support.inlineBlockNeedsLayout || defaultDisplay( this.nodeName ) === "inline" ) {
8405	                                                        this.style.display = "inline-block";
8406	
8407	                                                } else {
8408	                                                        this.style.zoom = 1;
8409	                                                }
8410	                                        }
8411	                                }
8412	                        }
8413	
8414	                        if ( opt.overflow != null ) {
8415	                                this.style.overflow = "hidden";
8416	                        }
8417	
8418	                        for ( p in prop ) {
8419	                                e = new jQuery.fx( this, opt, p );
8420	                                val = prop[ p ];
8421	
8422	                                if ( rfxtypes.test( val ) ) {
8423	
8424	                                        // Tracks whether to show or hide based on private
8425	                                        // data attached to the element
8426	                                        method = jQuery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
8427	                                        if ( method ) {
8428	                                                jQuery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
8429	                                                e[ method ]();
8430	                                        } else {
8431	                                                e[ val ]();
8432	                                        }
8433	
8434	                                } else {
8435	                                        parts = rfxnum.exec( val );
8436	                                        start = e.cur();
8437	
8438	                                        if ( parts ) {
8439	                                                end = parseFloat( parts[2] );
8440	                                                unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
8441	
8442	                                                // We need to compute starting value
8443	                                                if ( unit !== "px" ) {
8444	                                                        jQuery.style( this, p, (end || 1) + unit);
8445	                                                        start = ( (end || 1) / e.cur() ) * start;
8446	                                                        jQuery.style( this, p, start + unit);
8447	                                                }
8448	
8449	                                                // If a +=/-= token was provided, we're doing a relative animation
8450	                                                if ( parts[1] ) {
8451	                                                        end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8452	                                                }
8453	
8454	                                                e.custom( start, end, unit );
8455	
8456	                                        } else {
8457	                                                e.custom( start, val, "" );
8458	                                        }
8459	                                }
8460	                        }
8461	
8462	                        // For JS strict compliance
8463	                        return true;
8464	                }
8465	
8466	                return optall.queue === false ?
8467	                        this.each( doAnimation ) :
8468	                        this.queue( optall.queue, doAnimation );
8469	        },
8470	
8471	        stop: function( type, clearQueue, gotoEnd ) {
8472	                if ( typeof type !== "string" ) {
8473	                        gotoEnd = clearQueue;
8474	                        clearQueue = type;
8475	                        type = undefined;
8476	                }
8477	                if ( clearQueue && type !== false ) {
8478	                        this.queue( type || "fx", [] );
8479	                }
8480	
8481	                return this.each(function() {
8482	                        var index,
8483	                                hadTimers = false,
8484	                                timers = jQuery.timers,
8485	                                data = jQuery._data( this );
8486	
8487	                        // clear marker counters if we know they won't be
8488	                        if ( !gotoEnd ) {
8489	                                jQuery._unmark( true, this );
8490	                        }
8491	
8492	                        function stopQueue( elem, data, index ) {
8493	                                var hooks = data[ index ];
8494	                                jQuery.removeData( elem, index, true );
8495	                                hooks.stop( gotoEnd );
8496	                        }
8497	
8498	                        if ( type == null ) {
8499	                                for ( index in data ) {
8500	                                        if ( data[ index ] && data[ index ].stop && index.indexOf(".run") === index.length - 4 ) {
8501	                                                stopQueue( this, data, index );
8502	                                        }
8503	                                }
8504	                        } else if ( data[ index = type + ".run" ] && data[ index ].stop ){
8505	                                stopQueue( this, data, index );
8506	                        }
8507	
8508	                        for ( index = timers.length; index--; ) {
8509	                                if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
8510	                                        if ( gotoEnd ) {
8511	
8512	                                                // force the next step to be the last
8513	                                                timers[ index ]( true );
8514	                                        } else {
8515	                                                timers[ index ].saveState();
8516	                                        }
8517	                                        hadTimers = true;
8518	                                        timers.splice( index, 1 );
8519	                                }
8520	                        }
8521	
8522	                        // start the next in the queue if the last step wasn't forced
8523	                        // timers currently will call their complete callbacks, which will dequeue
8524	                        // but only if they were gotoEnd
8525	                        if ( !( gotoEnd && hadTimers ) ) {
8526	                                jQuery.dequeue( this, type );
8527	                        }
8528	                });
8529	        }
8530	
8531	});
8532	
8533	// Animations created synchronously will run synchronously
8534	function createFxNow() {
8535	        setTimeout( clearFxNow, 0 );
8536	        return ( fxNow = jQuery.now() );
8537	}
8538	
8539	function clearFxNow() {
8540	        fxNow = undefined;
8541	}
8542	
8543	// Generate parameters to create a standard animation
8544	function genFx( type, num ) {
8545	        var obj = {};
8546	
8547	        jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice( 0, num )), function() {
8548	                obj[ this ] = type;
8549	        });
8550	
8551	        return obj;
8552	}
8553	
8554	// Generate shortcuts for custom animations
8555	jQuery.each({
8556	        slideDown: genFx( "show", 1 ),
8557	        slideUp: genFx( "hide", 1 ),
8558	        slideToggle: genFx( "toggle", 1 ),
8559	        fadeIn: { opacity: "show" },
8560	        fadeOut: { opacity: "hide" },
8561	        fadeToggle: { opacity: "toggle" }
8562	}, function( name, props ) {
8563	        jQuery.fn[ name ] = function( speed, easing, callback ) {
8564	                return this.animate( props, speed, easing, callback );
8565	        };
8566	});
8567	
8568	jQuery.extend({
8569	        speed: function( speed, easing, fn ) {
8570	                var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
8571	                        complete: fn || !fn && easing ||
8572	                                jQuery.isFunction( speed ) && speed,
8573	                        duration: speed,
8574	                        easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
8575	                };
8576	
8577	                opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8578	                        opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
8579	
8580	                // normalize opt.queue - true/undefined/null -> "fx"
8581	                if ( opt.queue == null || opt.queue === true ) {
8582	                        opt.queue = "fx";
8583	                }
8584	
8585	                // Queueing
8586	                opt.old = opt.complete;
8587	
8588	                opt.complete = function( noUnmark ) {
8589	                        if ( jQuery.isFunction( opt.old ) ) {
8590	                                opt.old.call( this );
8591	                        }
8592	
8593	                        if ( opt.queue ) {
8594	                                jQuery.dequeue( this, opt.queue );
8595	                        } else if ( noUnmark !== false ) {
8596	                                jQuery._unmark( this );
8597	                        }
8598	                };
8599	
8600	                return opt;
8601	        },
8602	
8603	        easing: {
8604	                linear: function( p, n, firstNum, diff ) {
8605	                        return firstNum + diff * p;
8606	                },
8607	                swing: function( p, n, firstNum, diff ) {
8608	                        return ( ( -Math.cos( p*Math.PI ) / 2 ) + 0.5 ) * diff + firstNum;
8609	                }
8610	        },
8611	
8612	        timers: [],
8613	
8614	        fx: function( elem, options, prop ) {
8615	                this.options = options;
8616	                this.elem = elem;
8617	                this.prop = prop;
8618	
8619	                options.orig = options.orig || {};
8620	        }
8621	
8622	});
8623	
8624	jQuery.fx.prototype = {
8625	        // Simple function for setting a style value
8626	        update: function() {
8627	                if ( this.options.step ) {
8628	                        this.options.step.call( this.elem, this.now, this );
8629	                }
8630	
8631	                ( jQuery.fx.step[ this.prop ] || jQuery.fx.step._default )( this );
8632	        },
8633	
8634	        // Get the current size
8635	        cur: function() {
8636	                if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
8637	                        return this.elem[ this.prop ];
8638	                }
8639	
8640	                var parsed,
8641	                        r = jQuery.css( this.elem, this.prop );
8642	                // Empty strings, null, undefined and "auto" are converted to 0,
8643	                // complex values such as "rotate(1rad)" are returned as is,
8644	                // simple values such as "10px" are parsed to Float.
8645	                return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
8646	        },
8647	
8648	        // Start an animation from one number to another
8649	        custom: function( from, to, unit ) {
8650	                var self = this,
8651	                        fx = jQuery.fx;
8652	
8653	                this.startTime = fxNow || createFxNow();
8654	                this.end = to;
8655	                this.now = this.start = from;
8656	                this.pos = this.state = 0;
8657	                this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8658	
8659	                function t( gotoEnd ) {
8660	                        return self.step( gotoEnd );
8661	                }
8662	
8663	                t.queue = this.options.queue;
8664	                t.elem = this.elem;
8665	                t.saveState = function() {
8666	                        if ( self.options.hide && jQuery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
8667	                                jQuery._data( self.elem, "fxshow" + self.prop, self.start );
8668	                        }
8669	                };
8670	
8671	                if ( t() && jQuery.timers.push(t) && !timerId ) {
8672	                        timerId = setInterval( fx.tick, fx.interval );
8673	                }
8674	        },
8675	
8676	        // Simple 'show' function
8677	        show: function() {
8678	                var dataShow = jQuery._data( this.elem, "fxshow" + this.prop );
8679	
8680	                // Remember where we started, so that we can go back to it later
8681	                this.options.orig[ this.prop ] = dataShow || jQuery.style( this.elem, this.prop );
8682	                this.options.show = true;
8683	
8684	                // Begin the animation
8685	                // Make sure that we start at a small width/height to avoid any flash of content
8686	                if ( dataShow !== undefined ) {
8687	                        // This show is picking up where a previous hide or show left off
8688	                        this.custom( this.cur(), dataShow );
8689	                } else {
8690	                        this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
8691	                }
8692	
8693	                // Start by showing the element
8694	                jQuery( this.elem ).show();
8695	        },
8696	
8697	        // Simple 'hide' function
8698	        hide: function() {
8699	                // Remember where we started, so that we can go back to it later
8700	                this.options.orig[ this.prop ] = jQuery._data( this.elem, "fxshow" + this.prop ) || jQuery.style( this.elem, this.prop );
8701	                this.options.hide = true;
8702	
8703	                // Begin the animation
8704	                this.custom( this.cur(), 0 );
8705	        },
8706	
8707	        // Each step of an animation
8708	        step: function( gotoEnd ) {
8709	                var p, n, complete,
8710	                        t = fxNow || createFxNow(),
8711	                        done = true,
8712	                        elem = this.elem,
8713	                        options = this.options;
8714	
8715	                if ( gotoEnd || t >= options.duration + this.startTime ) {
8716	                        this.now = this.end;
8717	                        this.pos = this.state = 1;
8718	                        this.update();
8719	
8720	                        options.animatedProperties[ this.prop ] = true;
8721	
8722	                        for ( p in options.animatedProperties ) {
8723	                                if ( options.animatedProperties[ p ] !== true ) {
8724	                                        done = false;
8725	                                }
8726	                        }
8727	
8728	                        if ( done ) {
8729	                                // Reset the overflow
8730	                                if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8731	
8732	                                        jQuery.each( [ "", "X", "Y" ], function( index, value ) {
8733	                                                elem.style[ "overflow" + value ] = options.overflow[ index ];
8734	                                        });
8735	                                }
8736	
8737	                                // Hide the element if the "hide" operation was done
8738	                                if ( options.hide ) {
8739	                                        jQuery( elem ).hide();
8740	                                }
8741	
8742	                                // Reset the properties, if the item has been hidden or shown
8743	                                if ( options.hide || options.show ) {
8744	                                        for ( p in options.animatedProperties ) {
8745	                                                jQuery.style( elem, p, options.orig[ p ] );
8746	                                                jQuery.removeData( elem, "fxshow" + p, true );
8747	                                                // Toggle data is no longer needed
8748	                                                jQuery.removeData( elem, "toggle" + p, true );
8749	                                        }
8750	                                }
8751	
8752	                                // Execute the complete function
8753	                                // in the event that the complete function throws an exception
8754	                                // we must ensure it won't be called twice. #5684
8755	
8756	                                complete = options.complete;
8757	                                if ( complete ) {
8758	
8759	                                        options.complete = false;
8760	                                        complete.call( elem );
8761	                                }
8762	                        }
8763	
8764	                        return false;
8765	
8766	                } else {
8767	                        // classical easing cannot be used with an Infinity duration
8768	                        if ( options.duration == Infinity ) {
8769	                                this.now = t;
8770	                        } else {
8771	                                n = t - this.startTime;
8772	                                this.state = n / options.duration;
8773	
8774	                                // Perform the easing function, defaults to swing
8775	                                this.pos = jQuery.easing[ options.animatedProperties[this.prop] ]( this.state, n, 0, 1, options.duration );
8776	                                this.now = this.start + ( (this.end - this.start) * this.pos );
8777	                        }
8778	                        // Perform the next step of the animation
8779	                        this.update();
8780	                }
8781	
8782	                return true;
8783	        }
8784	};
8785	
8786	jQuery.extend( jQuery.fx, {
8787	        tick: function() {
8788	                var timer,
8789	                        timers = jQuery.timers,
8790	                        i = 0;
8791	
8792	                for ( ; i < timers.length; i++ ) {
8793	                        timer = timers[ i ];
8794	                        // Checks the timer has not already been removed
8795	                        if ( !timer() && timers[ i ] === timer ) {
8796	                                timers.splice( i--, 1 );
8797	                        }
8798	                }
8799	
8800	                if ( !timers.length ) {
8801	                        jQuery.fx.stop();
8802	                }
8803	        },
8804	
8805	        interval: 13,
8806	
8807	        stop: function() {
8808	                clearInterval( timerId );
8809	                timerId = null;
8810	        },
8811	
8812	        speeds: {
8813	                slow: 600,
8814	                fast: 200,
8815	                // Default speed
8816	                _default: 400
8817	        },
8818	
8819	        step: {
8820	                opacity: function( fx ) {
8821	                        jQuery.style( fx.elem, "opacity", fx.now );
8822	                },
8823	
8824	                _default: function( fx ) {
8825	                        if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8826	                                fx.elem.style[ fx.prop ] = fx.now + fx.unit;
8827	                        } else {
8828	                                fx.elem[ fx.prop ] = fx.now;
8829	                        }
8830	                }
8831	        }
8832	});
8833	
8834	// Adds width/height step functions
8835	// Do not set anything below 0
8836	jQuery.each([ "width", "height" ], function( i, prop ) {
8837	        jQuery.fx.step[ prop ] = function( fx ) {
8838	                jQuery.style( fx.elem, prop, Math.max(0, fx.now) + fx.unit );
8839	        };
8840	});
8841	
8842	if ( jQuery.expr && jQuery.expr.filters ) {
8843	        jQuery.expr.filters.animated = function( elem ) {
8844	                return jQuery.grep(jQuery.timers, function( fn ) {
8845	                        return elem === fn.elem;
8846	                }).length;
8847	        };
8848	}
8849	
8850	// Try to restore the default display value of an element
8851	function defaultDisplay( nodeName ) {
8852	
8853	        if ( !elemdisplay[ nodeName ] ) {
8854	
8855	                var body = document.body,
8856	                        elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
8857	                        display = elem.css( "display" );
8858	                elem.remove();
8859	
8860	                // If the simple way fails,
8861	                // get element's real default display by attaching it to a temp iframe
8862	                if ( display === "none" || display === "" ) {
8863	                        // No iframe to use yet, so create it
8864	                        if ( !iframe ) {
8865	                                iframe = document.createElement( "iframe" );
8866	                                iframe.frameBorder = iframe.width = iframe.height = 0;
8867	                        }
8868	
8869	                        body.appendChild( iframe );
8870	
8871	                        // Create a cacheable copy of the iframe document on first call.
8872	                        // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
8873	                        // document to it; WebKit & Firefox won't allow reusing the iframe document.
8874	                        if ( !iframeDoc || !iframe.createElement ) {
8875	                                iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
8876	                                iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
8877	                                iframeDoc.close();
8878	                        }
8879	
8880	                        elem = iframeDoc.createElement( nodeName );
8881	
8882	                        iframeDoc.body.appendChild( elem );
8883	
8884	                        display = jQuery.css( elem, "display" );
8885	                        body.removeChild( iframe );
8886	                }
8887	
8888	                // Store the correct default display
8889	                elemdisplay[ nodeName ] = display;
8890	        }
8891	
8892	        return elemdisplay[ nodeName ];
8893	}
8894	
8895	
8896	
8897	
8898	var rtable = /^t(?:able|d|h)$/i,
8899	        rroot = /^(?:body|html)$/i;
8900	
8901	if ( "getBoundingClientRect" in document.documentElement ) {
8902	        jQuery.fn.offset = function( options ) {
8903	                var elem = this[0], box;
8904	
8905	                if ( options ) {
8906	                        return this.each(function( i ) {
8907	                                jQuery.offset.setOffset( this, options, i );
8908	                        });
8909	                }
8910	
8911	                if ( !elem || !elem.ownerDocument ) {
8912	                        return null;
8913	                }
8914	
8915	                if ( elem === elem.ownerDocument.body ) {
8916	                        return jQuery.offset.bodyOffset( elem );
8917	                }
8918	
8919	                try {
8920	                        box = elem.getBoundingClientRect();
8921	                } catch(e) {}
8922	
8923	                var doc = elem.ownerDocument,
8924	                        docElem = doc.documentElement;
8925	
8926	                // Make sure we're not dealing with a disconnected DOM node
8927	                if ( !box || !jQuery.contains( docElem, elem ) ) {
8928	                        return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8929	                }
8930	
8931	                var body = doc.body,
8932	                        win = getWindow(doc),
8933	                        clientTop  = docElem.clientTop  || body.clientTop  || 0,
8934	                        clientLeft = docElem.clientLeft || body.clientLeft || 0,
8935	                        scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
8936	                        scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
8937	                        top  = box.top  + scrollTop  - clientTop,
8938	                        left = box.left + scrollLeft - clientLeft;
8939	
8940	                return { top: top, left: left };
8941	        };
8942	
8943	} else {
8944	        jQuery.fn.offset = function( options ) {
8945	                var elem = this[0];
8946	
8947	                if ( options ) {
8948	                        return this.each(function( i ) {
8949	                                jQuery.offset.setOffset( this, options, i );
8950	                        });
8951	                }
8952	
8953	                if ( !elem || !elem.ownerDocument ) {
8954	                        return null;
8955	                }
8956	
8957	                if ( elem === elem.ownerDocument.body ) {
8958	                        return jQuery.offset.bodyOffset( elem );
8959	                }
8960	
8961	                var computedStyle,
8962	                        offsetParent = elem.offsetParent,
8963	                        prevOffsetParent = elem,
8964	                        doc = elem.ownerDocument,
8965	                        docElem = doc.documentElement,
8966	                        body = doc.body,
8967	                        defaultView = doc.defaultView,
8968	                        prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8969	                        top = elem.offsetTop,
8970	                        left = elem.offsetLeft;
8971	
8972	                while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8973	                        if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
8974	                                break;
8975	                        }
8976	
8977	                        computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8978	                        top  -= elem.scrollTop;
8979	                        left -= elem.scrollLeft;
8980	
8981	                        if ( elem === offsetParent ) {
8982	                                top  += elem.offsetTop;
8983	                                left += elem.offsetLeft;
8984	
8985	                                if ( jQuery.support.doesNotAddBorder && !(jQuery.support.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8986	                                        top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8987	                                        left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8988	                                }
8989	
8990	                                prevOffsetParent = offsetParent;
8991	                                offsetParent = elem.offsetParent;
8992	                        }
8993	
8994	                        if ( jQuery.support.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8995	                                top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
8996	                                left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8997	                        }
8998	
8999	                        prevComputedStyle = computedStyle;
9000	                }
9001	
9002	                if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
9003	                        top  += body.offsetTop;
9004	                        left += body.offsetLeft;
9005	                }
9006	
9007	                if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
9008	                        top  += Math.max( docElem.scrollTop, body.scrollTop );
9009	                        left += Math.max( docElem.scrollLeft, body.scrollLeft );
9010	                }
9011	
9012	                return { top: top, left: left };
9013	        };
9014	}
9015	
9016	jQuery.offset = {
9017	
9018	        bodyOffset: function( body ) {
9019	                var top = body.offsetTop,
9020	                        left = body.offsetLeft;
9021	
9022	                if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
9023	                        top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
9024	                        left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
9025	                }
9026	
9027	                return { top: top, left: left };
9028	        },
9029	
9030	        setOffset: function( elem, options, i ) {
9031	                var position = jQuery.css( elem, "position" );
9032	
9033	                // set position first, in-case top/left are set even on static elem
9034	                if ( position === "static" ) {
9035	                        elem.style.position = "relative";
9036	                }
9037	
9038	                var curElem = jQuery( elem ),
9039	                        curOffset = curElem.offset(),
9040	                        curCSSTop = jQuery.css( elem, "top" ),
9041	                        curCSSLeft = jQuery.css( elem, "left" ),
9042	                        calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
9043	                        props = {}, curPosition = {}, curTop, curLeft;
9044	
9045	                // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
9046	                if ( calculatePosition ) {
9047	                        curPosition = curElem.position();
9048	                        curTop = curPosition.top;
9049	                        curLeft = curPosition.left;
9050	                } else {
9051	                        curTop = parseFloat( curCSSTop ) || 0;
9052	                        curLeft = parseFloat( curCSSLeft ) || 0;
9053	                }
9054	
9055	                if ( jQuery.isFunction( options ) ) {
9056	                        options = options.call( elem, i, curOffset );
9057	                }
9058	
9059	                if ( options.top != null ) {
9060	                        props.top = ( options.top - curOffset.top ) + curTop;
9061	                }
9062	                if ( options.left != null ) {
9063	                        props.left = ( options.left - curOffset.left ) + curLeft;
9064	                }
9065	
9066	                if ( "using" in options ) {
9067	                        options.using.call( elem, props );
9068	                } else {
9069	                        curElem.css( props );
9070	                }
9071	        }
9072	};
9073	
9074	
9075	jQuery.fn.extend({
9076	
9077	        position: function() {
9078	                if ( !this[0] ) {
9079	                        return null;
9080	                }
9081	
9082	                var elem = this[0],
9083	
9084	                // Get *real* offsetParent
9085	                offsetParent = this.offsetParent(),
9086	
9087	                // Get correct offsets
9088	                offset       = this.offset(),
9089	                parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
9090	
9091	                // Subtract element margins
9092	                // note: when an element has margin: auto the offsetLeft and marginLeft
9093	                // are the same in Safari causing offset.left to incorrectly be 0
9094	                offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
9095	                offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
9096	
9097	                // Add offsetParent borders
9098	                parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
9099	                parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
9100	
9101	                // Subtract the two offsets
9102	                return {
9103	                        top:  offset.top  - parentOffset.top,
9104	                        left: offset.left - parentOffset.left
9105	                };
9106	        },
9107	
9108	        offsetParent: function() {
9109	                return this.map(function() {
9110	                        var offsetParent = this.offsetParent || document.body;
9111	                        while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
9112	                                offsetParent = offsetParent.offsetParent;
9113	                        }
9114	                        return offsetParent;
9115	                });
9116	        }
9117	});
9118	
9119	
9120	// Create scrollLeft and scrollTop methods
9121	jQuery.each( ["Left", "Top"], function( i, name ) {
9122	        var method = "scroll" + name;
9123	
9124	        jQuery.fn[ method ] = function( val ) {
9125	                var elem, win;
9126	
9127	                if ( val === undefined ) {
9128	                        elem = this[ 0 ];
9129	
9130	                        if ( !elem ) {
9131	                                return null;
9132	                        }
9133	
9134	                        win = getWindow( elem );
9135	
9136	                        // Return the scroll offset
9137	                        return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
9138	                                jQuery.support.boxModel && win.document.documentElement[ method ] ||
9139	                                        win.document.body[ method ] :
9140	                                elem[ method ];
9141	                }
9142	
9143	                // Set the scroll offset
9144	                return this.each(function() {
9145	                        win = getWindow( this );
9146	
9147	                        if ( win ) {
9148	                                win.scrollTo(
9149	                                        !i ? val : jQuery( win ).scrollLeft(),
9150	                                         i ? val : jQuery( win ).scrollTop()
9151	                                );
9152	
9153	                        } else {
9154	                                this[ method ] = val;
9155	                        }
9156	                });
9157	        };
9158	});
9159	
9160	function getWindow( elem ) {
9161	        return jQuery.isWindow( elem ) ?
9162	                elem :
9163	                elem.nodeType === 9 ?
9164	                        elem.defaultView || elem.parentWindow :
9165	                        false;
9166	}
9167	
9168	
9169	
9170	
9171	// Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
9172	jQuery.each([ "Height", "Width" ], function( i, name ) {
9173	
9174	        var type = name.toLowerCase();
9175	
9176	        // innerHeight and innerWidth
9177	        jQuery.fn[ "inner" + name ] = function() {
9178	                var elem = this[0];
9179	                return elem ?
9180	                        elem.style ?
9181	                        parseFloat( jQuery.css( elem, type, "padding" ) ) :
9182	                        this[ type ]() :
9183	                        null;
9184	        };
9185	
9186	        // outerHeight and outerWidth
9187	        jQuery.fn[ "outer" + name ] = function( margin ) {
9188	                var elem = this[0];
9189	                return elem ?
9190	                        elem.style ?
9191	                        parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
9192	                        this[ type ]() :
9193	                        null;
9194	        };
9195	
9196	        jQuery.fn[ type ] = function( size ) {
9197	                // Get window width or height
9198	                var elem = this[0];
9199	                if ( !elem ) {
9200	                        return size == null ? null : this;
9201	                }
9202	
9203	                if ( jQuery.isFunction( size ) ) {
9204	                        return this.each(function( i ) {
9205	                                var self = jQuery( this );
9206	                                self[ type ]( size.call( this, i, self[ type ]() ) );
9207	                        });
9208	                }
9209	
9210	                if ( jQuery.isWindow( elem ) ) {
9211	                        // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
9212	                        // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
9213	                        var docElemProp = elem.document.documentElement[ "client" + name ],
9214	                                body = elem.document.body;
9215	                        return elem.document.compatMode === "CSS1Compat" && docElemProp ||
9216	                                body && body[ "client" + name ] || docElemProp;
9217	
9218	                // Get document width or height
9219	                } else if ( elem.nodeType === 9 ) {
9220	                        // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
9221	                        return Math.max(
9222	                                elem.documentElement["client" + name],
9223	                                elem.body["scroll" + name], elem.documentElement["scroll" + name],
9224	                                elem.body["offset" + name], elem.documentElement["offset" + name]
9225	                        );
9226	
9227	                // Get or set width or height on the element
9228	                } else if ( size === undefined ) {
9229	                        var orig = jQuery.css( elem, type ),
9230	                                ret = parseFloat( orig );
9231	
9232	                        return jQuery.isNumeric( ret ) ? ret : orig;
9233	
9234	                // Set the width or height on the element (default to pixels if value is unitless)
9235	                } else {
9236	                        return this.css( type, typeof size === "string" ? size : size + "px" );
9237	                }
9238	        };
9239	
9240	});
9241	
9242	
9243	
9244	
9245	// Expose jQuery to the global object
9246	window.jQuery = window.$ = jQuery;
9247	
9248	// Expose jQuery as an AMD module, but only for AMD loaders that
9249	// understand the issues with loading multiple versions of jQuery
9250	// in a page that all might call define(). The loader will indicate
9251	// they have special allowances for multiple jQuery versions by
9252	// specifying define.amd.jQuery = true. Register as a named module,
9253	// since jQuery can be concatenated with other files that may use define,
9254	// but not use a proper concatenation script that understands anonymous
9255	// AMD modules. A named AMD is safest and most robust way to register.
9256	// Lowercase jquery is used because AMD module names are derived from
9257	// file names, and jQuery is normally delivered in a lowercase file name.
9258	// Do this after creating the global so that if an AMD module wants to call
9259	// noConflict to hide this version of jQuery, it will work.
9260	if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
9261	        define( "jquery", [], function () { return jQuery; } );
9262	}
9263	
9264	
9265	
9266	})( window );

联系我们
文章看不懂？联系我们为您免费解答！免费助力个人，小企站点！
① 电话：020-2206-9892
② QQ咨询：1025174874
③ 邮件：info@361sale.com
④ 工作时间：周一至周五，9:30-18:30，节假日休息