[Summary view] [Print] [Text view]

   1  /*!

   2   * jQuery JavaScript Library v1.4

   3   * http://jquery.com/

   4   *

   5   * Copyright 2010, John Resig

   6   * Dual licensed under the MIT or GPL Version 2 licenses.

   7   * http://docs.jquery.com/License

   8   *

   9   * Includes Sizzle.js

  10   * http://sizzlejs.com/

  11   * Copyright 2010, The Dojo Foundation

  12   * Released under the MIT, BSD, and GPL Licenses.

  13   *

  14   * Date: Wed Jan 13 15:23:05 2010 -0500

  15   */
  16  (function( window, undefined ) {
  17  
  18  // Define a local copy of jQuery

  19  var jQuery = function( selector, context ) {
  20          // The jQuery object is actually just the init constructor 'enhanced'

  21          return new jQuery.fn.init( selector, context );
  22      },
  23  
  24      // Map over jQuery in case of overwrite

  25      _jQuery = window.jQuery,
  26  
  27      // Map over the $ in case of overwrite

  28      _$ = window.$,
  29  
  30      // Use the correct document accordingly with window argument (sandbox)

  31      document = window.document,
  32  
  33      // A central reference to the root jQuery(document)

  34      rootjQuery,
  35  
  36      // A simple way to check for HTML strings or ID strings

  37      // (both of which we optimize for)

  38      quickExpr = /^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,
  39  
  40      // Is it a simple selector

  41      isSimple = /^.[^:#\[\.,]*$/,
  42  
  43      // Check if a string has a non-whitespace character in it

  44      rnotwhite = /\S/,
  45  
  46      // Used for trimming whitespace

  47      rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,
  48  
  49      // Match a standalone tag

  50      rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
  51  
  52      // Keep a UserAgent string for use with jQuery.browser

  53      userAgent = navigator.userAgent,
  54  
  55      // For matching the engine and version of the browser

  56      browserMatch,
  57      
  58      // Has the ready events already been bound?

  59      readyBound = false,
  60      
  61      // The functions to execute on DOM ready

  62      readyList = [],
  63  
  64      // The ready event handler

  65      DOMContentLoaded,
  66  
  67      // Save a reference to some core methods

  68      toString = Object.prototype.toString,
  69      hasOwnProperty = Object.prototype.hasOwnProperty,
  70      push = Array.prototype.push,
  71      slice = Array.prototype.slice,
  72      indexOf = Array.prototype.indexOf;
  73  
  74  jQuery.fn = jQuery.prototype = {
  75      init: function( selector, context ) {
  76          var match, elem, ret, doc;
  77  
  78          // Handle $(""), $(null), or $(undefined)

  79          if ( !selector ) {
  80              return this;
  81          }
  82  
  83          // Handle $(DOMElement)

  84          if ( selector.nodeType ) {
  85              this.context = this[0] = selector;
  86              this.length = 1;
  87              return this;
  88          }
  89  
  90          // Handle HTML strings

  91          if ( typeof selector === "string" ) {
  92              // Are we dealing with HTML string or an ID?

  93              match = quickExpr.exec( selector );
  94  
  95              // Verify a match, and that no context was specified for #id

  96              if ( match && (match[1] || !context) ) {
  97  
  98                  // HANDLE: $(html) -> $(array)

  99                  if ( match[1] ) {
 100                      doc = (context ? context.ownerDocument || context : document);
 101  
 102                      // If a single string is passed in and it's a single tag

 103                      // just do a createElement and skip the rest

 104                      ret = rsingleTag.exec( selector );
 105  
 106                      if ( ret ) {
 107                          if ( jQuery.isPlainObject( context ) ) {
 108                              selector = [ document.createElement( ret[1] ) ];
 109                              jQuery.fn.attr.call( selector, context, true );
 110  
 111                          } else {
 112                              selector = [ doc.createElement( ret[1] ) ];
 113                          }
 114  
 115                      } else {
 116                          ret = buildFragment( [ match[1] ], [ doc ] );
 117                          selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
 118                      }
 119  
 120                  // HANDLE: $("#id")

 121                  } else {
 122                      elem = document.getElementById( match[2] );
 123  
 124                      if ( elem ) {
 125                          // Handle the case where IE and Opera return items

 126                          // by name instead of ID

 127                          if ( elem.id !== match[2] ) {
 128                              return rootjQuery.find( selector );
 129                          }
 130  
 131                          // Otherwise, we inject the element directly into the jQuery object

 132                          this.length = 1;
 133                          this[0] = elem;
 134                      }
 135  
 136                      this.context = document;
 137                      this.selector = selector;
 138                      return this;
 139                  }
 140  
 141              // HANDLE: $("TAG")

 142              } else if ( !context && /^\w+$/.test( selector ) ) {
 143                  this.selector = selector;
 144                  this.context = document;
 145                  selector = document.getElementsByTagName( selector );
 146  
 147              // HANDLE: $(expr, $(...))

 148              } else if ( !context || context.jquery ) {
 149                  return (context || rootjQuery).find( selector );
 150  
 151              // HANDLE: $(expr, context)

 152              // (which is just equivalent to: $(context).find(expr)

 153              } else {
 154                  return jQuery( context ).find( selector );
 155              }
 156  
 157          // HANDLE: $(function)

 158          // Shortcut for document ready

 159          } else if ( jQuery.isFunction( selector ) ) {
 160              return rootjQuery.ready( selector );
 161          }
 162  
 163          if (selector.selector !== undefined) {
 164              this.selector = selector.selector;
 165              this.context = selector.context;
 166          }
 167  
 168          return jQuery.isArray( selector ) ?
 169              this.setArray( selector ) :
 170              jQuery.makeArray( selector, this );
 171      },
 172  
 173      // Start with an empty selector

 174      selector: "",
 175  
 176      // The current version of jQuery being used

 177      jquery: "1.4",
 178  
 179      // The default length of a jQuery object is 0

 180      length: 0,
 181  
 182      // The number of elements contained in the matched element set

 183      size: function() {
 184          return this.length;
 185      },
 186  
 187      toArray: function() {
 188          return slice.call( this, 0 );
 189      },
 190  
 191      // Get the Nth element in the matched element set OR

 192      // Get the whole matched element set as a clean array

 193      get: function( num ) {
 194          return num == null ?
 195  
 196              // Return a 'clean' array

 197              this.toArray() :
 198  
 199              // Return just the object

 200              ( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
 201      },
 202  
 203      // Take an array of elements and push it onto the stack

 204      // (returning the new matched element set)

 205      pushStack: function( elems, name, selector ) {
 206          // Build a new jQuery matched element set

 207          var ret = jQuery( elems || null );
 208  
 209          // Add the old object onto the stack (as a reference)

 210          ret.prevObject = this;
 211  
 212          ret.context = this.context;
 213  
 214          if ( name === "find" ) {
 215              ret.selector = this.selector + (this.selector ? " " : "") + selector;
 216          } else if ( name ) {
 217              ret.selector = this.selector + "." + name + "(" + selector + ")";
 218          }
 219  
 220          // Return the newly-formed element set

 221          return ret;
 222      },
 223  
 224      // Force the current matched set of elements to become

 225      // the specified array of elements (destroying the stack in the process)

 226      // You should use pushStack() in order to do this, but maintain the stack

 227      setArray: function( elems ) {
 228          // Resetting the length to 0, then using the native Array push

 229          // is a super-fast way to populate an object with array-like properties

 230          this.length = 0;
 231          push.apply( this, elems );
 232  
 233          return this;
 234      },
 235  
 236      // Execute a callback for every element in the matched set.

 237      // (You can seed the arguments with an array of args, but this is

 238      // only used internally.)

 239      each: function( callback, args ) {
 240          return jQuery.each( this, callback, args );
 241      },
 242      
 243      ready: function( fn ) {
 244          // Attach the listeners

 245          jQuery.bindReady();
 246  
 247          // If the DOM is already ready

 248          if ( jQuery.isReady ) {
 249              // Execute the function immediately

 250              fn.call( document, jQuery );
 251  
 252          // Otherwise, remember the function for later

 253          } else if ( readyList ) {
 254              // Add the function to the wait list

 255              readyList.push( fn );
 256          }
 257  
 258          return this;
 259      },
 260      
 261      eq: function( i ) {
 262          return i === -1 ?
 263              this.slice( i ) :
 264              this.slice( i, +i + 1 );
 265      },
 266  
 267      first: function() {
 268          return this.eq( 0 );
 269      },
 270  
 271      last: function() {
 272          return this.eq( -1 );
 273      },
 274  
 275      slice: function() {
 276          return this.pushStack( slice.apply( this, arguments ),
 277              "slice", slice.call(arguments).join(",") );
 278      },
 279  
 280      map: function( callback ) {
 281          return this.pushStack( jQuery.map(this, function( elem, i ) {
 282              return callback.call( elem, i, elem );
 283          }));
 284      },
 285      
 286      end: function() {
 287          return this.prevObject || jQuery(null);
 288      },
 289  
 290      // For internal use only.

 291      // Behaves like an Array's method, not like a jQuery method.

 292      push: push,
 293      sort: [].sort,
 294      splice: [].splice
 295  };
 296  
 297  // Give the init function the jQuery prototype for later instantiation

 298  jQuery.fn.init.prototype = jQuery.fn;
 299  
 300  jQuery.extend = jQuery.fn.extend = function() {
 301      // copy reference to target object

 302      var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
 303  
 304      // Handle a deep copy situation

 305      if ( typeof target === "boolean" ) {
 306          deep = target;
 307          target = arguments[1] || {};
 308          // skip the boolean and the target

 309          i = 2;
 310      }
 311  
 312      // Handle case when target is a string or something (possible in deep copy)

 313      if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
 314          target = {};
 315      }
 316  
 317      // extend jQuery itself if only one argument is passed

 318      if ( length === i ) {
 319          target = this;
 320          --i;
 321      }
 322  
 323      for ( ; i < length; i++ ) {
 324          // Only deal with non-null/undefined values

 325          if ( (options = arguments[ i ]) != null ) {
 326              // Extend the base object

 327              for ( name in options ) {
 328                  src = target[ name ];
 329                  copy = options[ name ];
 330  
 331                  // Prevent never-ending loop

 332                  if ( target === copy ) {
 333                      continue;
 334                  }
 335  
 336                  // Recurse if we're merging object literal values or arrays

 337                  if ( deep && copy && ( jQuery.isPlainObject(copy) || jQuery.isArray(copy) ) ) {
 338                      var clone = src && ( jQuery.isPlainObject(src) || jQuery.isArray(src) ) ? src
 339                          : jQuery.isArray(copy) ? [] : {};
 340  
 341                      // Never move original objects, clone them

 342                      target[ name ] = jQuery.extend( deep, clone, copy );
 343  
 344                  // Don't bring in undefined values

 345                  } else if ( copy !== undefined ) {
 346                      target[ name ] = copy;
 347                  }
 348              }
 349          }
 350      }
 351  
 352      // Return the modified object

 353      return target;
 354  };
 355  
 356  jQuery.extend({
 357      noConflict: function( deep ) {
 358          window.$ = _$;
 359  
 360          if ( deep ) {
 361              window.jQuery = _jQuery;
 362          }
 363  
 364          return jQuery;
 365      },
 366      
 367      // Is the DOM ready to be used? Set to true once it occurs.

 368      isReady: false,
 369      
 370      // Handle when the DOM is ready

 371      ready: function() {
 372          // Make sure that the DOM is not already loaded

 373          if ( !jQuery.isReady ) {
 374              // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).

 375              if ( !document.body ) {
 376                  return setTimeout( jQuery.ready, 13 );
 377              }
 378  
 379              // Remember that the DOM is ready

 380              jQuery.isReady = true;
 381  
 382              // If there are functions bound, to execute

 383              if ( readyList ) {
 384                  // Execute all of them

 385                  var fn, i = 0;
 386                  while ( (fn = readyList[ i++ ]) ) {
 387                      fn.call( document, jQuery );
 388                  }
 389  
 390                  // Reset the list of functions

 391                  readyList = null;
 392              }
 393  
 394              // Trigger any bound ready events

 395              if ( jQuery.fn.triggerHandler ) {
 396                  jQuery( document ).triggerHandler( "ready" );
 397              }
 398          }
 399      },
 400      
 401      bindReady: function() {
 402          if ( readyBound ) {
 403              return;
 404          }
 405  
 406          readyBound = true;
 407  
 408          // Catch cases where $(document).ready() is called after the

 409          // browser event has already occurred.

 410          if ( document.readyState === "complete" ) {
 411              return jQuery.ready();
 412          }
 413  
 414          // Mozilla, Opera and webkit nightlies currently support this event

 415          if ( document.addEventListener ) {
 416              // Use the handy event callback

 417              document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 418              
 419              // A fallback to window.onload, that will always work

 420              window.addEventListener( "load", jQuery.ready, false );
 421  
 422          // If IE event model is used

 423          } else if ( document.attachEvent ) {
 424              // ensure firing before onload,

 425              // maybe late but safe also for iframes

 426              document.attachEvent("onreadystatechange", DOMContentLoaded);
 427              
 428              // A fallback to window.onload, that will always work

 429              window.attachEvent( "onload", jQuery.ready );
 430  
 431              // If IE and not a frame

 432              // continually check to see if the document is ready

 433              var toplevel = false;
 434  
 435              try {
 436                  toplevel = window.frameElement == null;
 437              } catch(e) {}
 438  
 439              if ( document.documentElement.doScroll && toplevel ) {
 440                  doScrollCheck();
 441              }
 442          }
 443      },
 444  
 445      // See test/unit/core.js for details concerning isFunction.

 446      // Since version 1.3, DOM methods and functions like alert

 447      // aren't supported. They return false on IE (#2968).

 448      isFunction: function( obj ) {
 449          return toString.call(obj) === "[object Function]";
 450      },
 451  
 452      isArray: function( obj ) {
 453          return toString.call(obj) === "[object Array]";
 454      },
 455  
 456      isPlainObject: function( obj ) {
 457          // Must be an Object.

 458          // Because of IE, we also have to check the presence of the constructor property.

 459          // Make sure that DOM nodes and window objects don't pass through, as well

 460          if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) {
 461              return false;
 462          }
 463          
 464          // Not own constructor property must be Object

 465          if ( obj.constructor
 466              && !hasOwnProperty.call(obj, "constructor")
 467              && !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
 468              return false;
 469          }
 470          
 471          // Own properties are enumerated firstly, so to speed up,

 472          // if last one is own, then all properties are own.

 473      
 474          var key;
 475          for ( key in obj ) {}
 476          
 477          return key === undefined || hasOwnProperty.call( obj, key );
 478      },
 479  
 480      isEmptyObject: function( obj ) {
 481          for ( var name in obj ) {
 482              return false;
 483          }
 484          return true;
 485      },
 486  
 487      noop: function() {},
 488  
 489      // Evalulates a script in a global context

 490      globalEval: function( data ) {
 491          if ( data && rnotwhite.test(data) ) {
 492              // Inspired by code by Andrea Giammarchi

 493              // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html

 494              var head = document.getElementsByTagName("head")[0] || document.documentElement,
 495                  script = document.createElement("script");
 496  
 497              script.type = "text/javascript";
 498  
 499              if ( jQuery.support.scriptEval ) {
 500                  script.appendChild( document.createTextNode( data ) );
 501              } else {
 502                  script.text = data;
 503              }
 504  
 505              // Use insertBefore instead of appendChild to circumvent an IE6 bug.

 506              // This arises when a base node is used (#2709).

 507              head.insertBefore( script, head.firstChild );
 508              head.removeChild( script );
 509          }
 510      },
 511  
 512      nodeName: function( elem, name ) {
 513          return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
 514      },
 515  
 516      // args is for internal usage only

 517      each: function( object, callback, args ) {
 518          var name, i = 0,
 519              length = object.length,
 520              isObj = length === undefined || jQuery.isFunction(object);
 521  
 522          if ( args ) {
 523              if ( isObj ) {
 524                  for ( name in object ) {
 525                      if ( callback.apply( object[ name ], args ) === false ) {
 526                          break;
 527                      }
 528                  }
 529              } else {
 530                  for ( ; i < length; ) {
 531                      if ( callback.apply( object[ i++ ], args ) === false ) {
 532                          break;
 533                      }
 534                  }
 535              }
 536  
 537          // A special, fast, case for the most common use of each

 538          } else {
 539              if ( isObj ) {
 540                  for ( name in object ) {
 541                      if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
 542                          break;
 543                      }
 544                  }
 545              } else {
 546                  for ( var value = object[0];
 547                      i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
 548              }
 549          }
 550  
 551          return object;
 552      },
 553  
 554      trim: function( text ) {
 555          return (text || "").replace( rtrim, "" );
 556      },
 557  
 558      // results is for internal usage only

 559      makeArray: function( array, results ) {
 560          var ret = results || [];
 561  
 562          if ( array != null ) {
 563              // The window, strings (and functions) also have 'length'

 564              // The extra typeof function check is to prevent crashes

 565              // in Safari 2 (See: #3039)

 566              if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) {
 567                  push.call( ret, array );
 568              } else {
 569                  jQuery.merge( ret, array );
 570              }
 571          }
 572  
 573          return ret;
 574      },
 575  
 576      inArray: function( elem, array ) {
 577          if ( array.indexOf ) {
 578              return array.indexOf( elem );
 579          }
 580  
 581          for ( var i = 0, length = array.length; i < length; i++ ) {
 582              if ( array[ i ] === elem ) {
 583                  return i;
 584              }
 585          }
 586  
 587          return -1;
 588      },
 589  
 590      merge: function( first, second ) {
 591          var i = first.length, j = 0;
 592  
 593          if ( typeof second.length === "number" ) {
 594              for ( var l = second.length; j < l; j++ ) {
 595                  first[ i++ ] = second[ j ];
 596              }
 597          } else {
 598              while ( second[j] !== undefined ) {
 599                  first[ i++ ] = second[ j++ ];
 600              }
 601          }
 602  
 603          first.length = i;
 604  
 605          return first;
 606      },
 607  
 608      grep: function( elems, callback, inv ) {
 609          var ret = [];
 610  
 611          // Go through the array, only saving the items

 612          // that pass the validator function

 613          for ( var i = 0, length = elems.length; i < length; i++ ) {
 614              if ( !inv !== !callback( elems[ i ], i ) ) {
 615                  ret.push( elems[ i ] );
 616              }
 617          }
 618  
 619          return ret;
 620      },
 621  
 622      // arg is for internal usage only

 623      map: function( elems, callback, arg ) {
 624          var ret = [], value;
 625  
 626          // Go through the array, translating each of the items to their

 627          // new value (or values).

 628          for ( var i = 0, length = elems.length; i < length; i++ ) {
 629              value = callback( elems[ i ], i, arg );
 630  
 631              if ( value != null ) {
 632                  ret[ ret.length ] = value;
 633              }
 634          }
 635  
 636          return ret.concat.apply( [], ret );
 637      },
 638  
 639      // A global GUID counter for objects

 640      guid: 1,
 641  
 642      proxy: function( fn, proxy, thisObject ) {
 643          if ( arguments.length === 2 ) {
 644              if ( typeof proxy === "string" ) {
 645                  thisObject = fn;
 646                  fn = thisObject[ proxy ];
 647                  proxy = undefined;
 648  
 649              } else if ( proxy && !jQuery.isFunction( proxy ) ) {
 650                  thisObject = proxy;
 651                  proxy = undefined;
 652              }
 653          }
 654  
 655          if ( !proxy && fn ) {
 656              proxy = function() {
 657                  return fn.apply( thisObject || this, arguments );
 658              };
 659          }
 660  
 661          // Set the guid of unique handler to the same of original handler, so it can be removed

 662          if ( fn ) {
 663              proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
 664          }
 665  
 666          // So proxy can be declared as an argument

 667          return proxy;
 668      },
 669  
 670      // Use of jQuery.browser is frowned upon.

 671      // More details: http://docs.jquery.com/Utilities/jQuery.browser

 672      uaMatch: function( ua ) {
 673          var ret = { browser: "" };
 674  
 675          ua = ua.toLowerCase();
 676  
 677          if ( /webkit/.test( ua ) ) {
 678              ret = { browser: "webkit", version: /webkit[\/ ]([\w.]+)/ };
 679  
 680          } else if ( /opera/.test( ua ) ) {
 681              ret = { browser: "opera", version:  /version/.test( ua ) ? /version[\/ ]([\w.]+)/ : /opera[\/ ]([\w.]+)/ };
 682              
 683          } else if ( /msie/.test( ua ) ) {
 684              ret = { browser: "msie", version: /msie ([\w.]+)/ };
 685  
 686          } else if ( /mozilla/.test( ua ) && !/compatible/.test( ua ) ) {
 687              ret = { browser: "mozilla", version: /rv:([\w.]+)/ };
 688          }
 689  
 690          ret.version = (ret.version && ret.version.exec( ua ) || [0, "0"])[1];
 691  
 692          return ret;
 693      },
 694  
 695      browser: {}
 696  });
 697  
 698  browserMatch = jQuery.uaMatch( userAgent );
 699  if ( browserMatch.browser ) {
 700      jQuery.browser[ browserMatch.browser ] = true;
 701      jQuery.browser.version = browserMatch.version;
 702  }
 703  
 704  // Deprecated, use jQuery.browser.webkit instead

 705  if ( jQuery.browser.webkit ) {
 706      jQuery.browser.safari = true;
 707  }
 708  
 709  if ( indexOf ) {
 710      jQuery.inArray = function( elem, array ) {
 711          return indexOf.call( array, elem );
 712      };
 713  }
 714  
 715  // All jQuery objects should point back to these

 716  rootjQuery = jQuery(document);
 717  
 718  // Cleanup functions for the document ready method

 719  if ( document.addEventListener ) {
 720      DOMContentLoaded = function() {
 721          document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 722          jQuery.ready();
 723      };
 724  
 725  } else if ( document.attachEvent ) {
 726      DOMContentLoaded = function() {
 727          // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).

 728          if ( document.readyState === "complete" ) {
 729              document.detachEvent( "onreadystatechange", DOMContentLoaded );
 730              jQuery.ready();
 731          }
 732      };
 733  }
 734  
 735  // The DOM ready check for Internet Explorer

 736  function doScrollCheck() {
 737      if ( jQuery.isReady ) {
 738          return;
 739      }
 740  
 741      try {
 742          // If IE is used, use the trick by Diego Perini

 743          // http://javascript.nwbox.com/IEContentLoaded/

 744          document.documentElement.doScroll("left");
 745      } catch( error ) {
 746          setTimeout( doScrollCheck, 1 );
 747          return;
 748      }
 749  
 750      // and execute any waiting functions

 751      jQuery.ready();
 752  }
 753  
 754  if ( indexOf ) {
 755      jQuery.inArray = function( elem, array ) {
 756          return indexOf.call( array, elem );
 757      };
 758  }
 759  
 760  function evalScript( i, elem ) {
 761      if ( elem.src ) {
 762          jQuery.ajax({
 763              url: elem.src,
 764              async: false,
 765              dataType: "script"
 766          });
 767      } else {
 768          jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
 769      }
 770  
 771      if ( elem.parentNode ) {
 772          elem.parentNode.removeChild( elem );
 773      }
 774  }
 775  
 776  // Mutifunctional method to get and set values to a collection

 777  // The value/s can be optionally by executed if its a function

 778  function access( elems, key, value, exec, fn, pass ) {
 779      var length = elems.length;
 780      
 781      // Setting many attributes

 782      if ( typeof key === "object" ) {
 783          for ( var k in key ) {
 784              access( elems, k, key[k], exec, fn, value );
 785          }
 786          return elems;
 787      }
 788      
 789      // Setting one attribute

 790      if ( value !== undefined ) {
 791          // Optionally, function values get executed if exec is true

 792          exec = !pass && exec && jQuery.isFunction(value);
 793          
 794          for ( var i = 0; i < length; i++ ) {
 795              fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
 796          }
 797          
 798          return elems;
 799      }
 800      
 801      // Getting an attribute

 802      return length ? fn( elems[0], key ) : null;
 803  }
 804  
 805  function now() {
 806      return (new Date).getTime();
 807  }
 808  (function() {
 809  
 810      jQuery.support = {};
 811  
 812      var root = document.documentElement,
 813          script = document.createElement("script"),
 814          div = document.createElement("div"),
 815          id = "script" + now();
 816  
 817      div.style.display = "none";
 818      div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
 819  
 820      var all = div.getElementsByTagName("*"),
 821          a = div.getElementsByTagName("a")[0];
 822  
 823      // Can't get basic test support

 824      if ( !all || !all.length || !a ) {
 825          return;
 826      }
 827  
 828      jQuery.support = {
 829          // IE strips leading whitespace when .innerHTML is used

 830          leadingWhitespace: div.firstChild.nodeType === 3,
 831  
 832          // Make sure that tbody elements aren't automatically inserted

 833          // IE will insert them into empty tables

 834          tbody: !div.getElementsByTagName("tbody").length,
 835  
 836          // Make sure that link elements get serialized correctly by innerHTML

 837          // This requires a wrapper element in IE

 838          htmlSerialize: !!div.getElementsByTagName("link").length,
 839  
 840          // Get the style information from getAttribute

 841          // (IE uses .cssText insted)

 842          style: /red/.test( a.getAttribute("style") ),
 843  
 844          // Make sure that URLs aren't manipulated

 845          // (IE normalizes it by default)

 846          hrefNormalized: a.getAttribute("href") === "/a",
 847  
 848          // Make sure that element opacity exists

 849          // (IE uses filter instead)

 850          // Use a regex to work around a WebKit issue. See #5145

 851          opacity: /^0.55$/.test( a.style.opacity ),
 852  
 853          // Verify style float existence

 854          // (IE uses styleFloat instead of cssFloat)

 855          cssFloat: !!a.style.cssFloat,
 856  
 857          // Make sure that if no value is specified for a checkbox

 858          // that it defaults to "on".

 859          // (WebKit defaults to "" instead)

 860          checkOn: div.getElementsByTagName("input")[0].value === "on",
 861  
 862          // Make sure that a selected-by-default option has a working selected property.

 863          // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)

 864          optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected,
 865  
 866          // Will be defined later

 867          scriptEval: false,
 868          noCloneEvent: true,
 869          boxModel: null
 870      };
 871  
 872      script.type = "text/javascript";
 873      try {
 874          script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
 875      } catch(e) {}
 876  
 877      root.insertBefore( script, root.firstChild );
 878  
 879      // Make sure that the execution of code works by injecting a script

 880      // tag with appendChild/createTextNode

 881      // (IE doesn't support this, fails, and uses .text instead)

 882      if ( window[ id ] ) {
 883          jQuery.support.scriptEval = true;
 884          delete window[ id ];
 885      }
 886  
 887      root.removeChild( script );
 888  
 889      if ( div.attachEvent && div.fireEvent ) {
 890          div.attachEvent("onclick", function click() {
 891              // Cloning a node shouldn't copy over any

 892              // bound event handlers (IE does this)

 893              jQuery.support.noCloneEvent = false;
 894              div.detachEvent("onclick", click);
 895          });
 896          div.cloneNode(true).fireEvent("onclick");
 897      }
 898  
 899      // Figure out if the W3C box model works as expected

 900      // document.body must exist before we can do this

 901      // TODO: This timeout is temporary until I move ready into core.js.

 902      jQuery(function() {
 903          var div = document.createElement("div");
 904          div.style.width = div.style.paddingLeft = "1px";
 905  
 906          document.body.appendChild( div );
 907          jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
 908          document.body.removeChild( div ).style.display = 'none';
 909          div = null;
 910      });
 911  
 912      // Technique from Juriy Zaytsev

 913      // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/

 914      var eventSupported = function( eventName ) { 
 915          var el = document.createElement("div"); 
 916          eventName = "on" + eventName; 
 917  
 918          var isSupported = (eventName in el); 
 919          if ( !isSupported ) { 
 920              el.setAttribute(eventName, "return;"); 
 921              isSupported = typeof el[eventName] === "function"; 
 922          } 
 923          el = null; 
 924  
 925          return isSupported; 
 926      };
 927      
 928      jQuery.support.submitBubbles = eventSupported("submit");
 929      jQuery.support.changeBubbles = eventSupported("change");
 930  
 931      // release memory in IE

 932      root = script = div = all = a = null;
 933  })();
 934  
 935  jQuery.props = {
 936      "for": "htmlFor",
 937      "class": "className",
 938      readonly: "readOnly",
 939      maxlength: "maxLength",
 940      cellspacing: "cellSpacing",
 941      rowspan: "rowSpan",
 942      colspan: "colSpan",
 943      tabindex: "tabIndex",
 944      usemap: "useMap",
 945      frameborder: "frameBorder"
 946  };
 947  var expando = "jQuery" + now(), uuid = 0, windowData = {};
 948  var emptyObject = {};
 949  
 950  jQuery.extend({
 951      cache: {},
 952      
 953      expando:expando,
 954  
 955      // The following elements throw uncatchable exceptions if you

 956      // attempt to add expando properties to them.

 957      noData: {
 958          "embed": true,
 959          "object": true,
 960          "applet": true
 961      },
 962  
 963      data: function( elem, name, data ) {
 964          if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
 965              return;
 966          }
 967  
 968          elem = elem == window ?
 969              windowData :
 970              elem;
 971  
 972          var id = elem[ expando ], cache = jQuery.cache, thisCache;
 973  
 974          // Handle the case where there's no name immediately

 975          if ( !name && !id ) {
 976              return null;
 977          }
 978  
 979          // Compute a unique ID for the element

 980          if ( !id ) { 
 981              id = ++uuid;
 982          }
 983  
 984          // Avoid generating a new cache unless none exists and we

 985          // want to manipulate it.

 986          if ( typeof name === "object" ) {
 987              elem[ expando ] = id;
 988              thisCache = cache[ id ] = jQuery.extend(true, {}, name);
 989          } else if ( cache[ id ] ) {
 990              thisCache = cache[ id ];
 991          } else if ( typeof data === "undefined" ) {
 992              thisCache = emptyObject;
 993          } else {
 994              thisCache = cache[ id ] = {};
 995          }
 996  
 997          // Prevent overriding the named cache with undefined values

 998          if ( data !== undefined ) {
 999              elem[ expando ] = id;
1000              thisCache[ name ] = data;
1001          }
1002  
1003          return typeof name === "string" ? thisCache[ name ] : thisCache;
1004      },
1005  
1006      removeData: function( elem, name ) {
1007          if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1008              return;
1009          }
1010  
1011          elem = elem == window ?
1012              windowData :
1013              elem;
1014  
1015          var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];
1016  
1017          // If we want to remove a specific section of the element's data

1018          if ( name ) {
1019              if ( thisCache ) {
1020                  // Remove the section of cache data

1021                  delete thisCache[ name ];
1022  
1023                  // If we've removed all the data, remove the element's cache

1024                  if ( jQuery.isEmptyObject(thisCache) ) {
1025                      jQuery.removeData( elem );
1026                  }
1027              }
1028  
1029          // Otherwise, we want to remove all of the element's data

1030          } else {
1031              // Clean up the element expando

1032              try {
1033                  delete elem[ expando ];
1034              } catch( e ) {
1035                  // IE has trouble directly removing the expando

1036                  // but it's ok with using removeAttribute

1037                  if ( elem.removeAttribute ) {
1038                      elem.removeAttribute( expando );
1039                  }
1040              }
1041  
1042              // Completely remove the data cache

1043              delete cache[ id ];
1044          }
1045      }
1046  });
1047  
1048  jQuery.fn.extend({
1049      data: function( key, value ) {
1050          if ( typeof key === "undefined" && this.length ) {
1051              return jQuery.data( this[0] );
1052  
1053          } else if ( typeof key === "object" ) {
1054              return this.each(function() {
1055                  jQuery.data( this, key );
1056              });
1057          }
1058  
1059          var parts = key.split(".");
1060          parts[1] = parts[1] ? "." + parts[1] : "";
1061  
1062          if ( value === undefined ) {
1063              var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1064  
1065              if ( data === undefined && this.length ) {
1066                  data = jQuery.data( this[0], key );
1067              }
1068              return data === undefined && parts[1] ?
1069                  this.data( parts[0] ) :
1070                  data;
1071          } else {
1072              return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function() {
1073                  jQuery.data( this, key, value );
1074              });
1075          }
1076      },
1077  
1078      removeData: function( key ) {
1079          return this.each(function() {
1080              jQuery.removeData( this, key );
1081          });
1082      }
1083  });
1084  jQuery.extend({
1085      queue: function( elem, type, data ) {
1086          if ( !elem ) {
1087              return;
1088          }
1089  
1090          type = (type || "fx") + "queue";
1091          var q = jQuery.data( elem, type );
1092  
1093          // Speed up dequeue by getting out quickly if this is just a lookup

1094          if ( !data ) {
1095              return q || [];
1096          }
1097  
1098          if ( !q || jQuery.isArray(data) ) {
1099              q = jQuery.data( elem, type, jQuery.makeArray(data) );
1100  
1101          } else {
1102              q.push( data );
1103          }
1104  
1105          return q;
1106      },
1107  
1108      dequeue: function( elem, type ) {
1109          type = type || "fx";
1110  
1111          var queue = jQuery.queue( elem, type ), fn = queue.shift();
1112  
1113          // If the fx queue is dequeued, always remove the progress sentinel

1114          if ( fn === "inprogress" ) {
1115              fn = queue.shift();
1116          }
1117  
1118          if ( fn ) {
1119              // Add a progress sentinel to prevent the fx queue from being

1120              // automatically dequeued

1121              if ( type === "fx" ) {
1122                  queue.unshift("inprogress");
1123              }
1124  
1125              fn.call(elem, function() {
1126                  jQuery.dequeue(elem, type);
1127              });
1128          }
1129      }
1130  });
1131  
1132  jQuery.fn.extend({
1133      queue: function( type, data ) {
1134          if ( typeof type !== "string" ) {
1135              data = type;
1136              type = "fx";
1137          }
1138  
1139          if ( data === undefined ) {
1140              return jQuery.queue( this[0], type );
1141          }
1142          return this.each(function( i, elem ) {
1143              var queue = jQuery.queue( this, type, data );
1144  
1145              if ( type === "fx" && queue[0] !== "inprogress" ) {
1146                  jQuery.dequeue( this, type );
1147              }
1148          });
1149      },
1150      dequeue: function( type ) {
1151          return this.each(function() {
1152              jQuery.dequeue( this, type );
1153          });
1154      },
1155  
1156      // Based off of the plugin by Clint Helfers, with permission.

1157      // http://blindsignals.com/index.php/2009/07/jquery-delay/

1158      delay: function( time, type ) {
1159          time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1160          type = type || "fx";
1161  
1162          return this.queue( type, function() {
1163              var elem = this;
1164              setTimeout(function() {
1165                  jQuery.dequeue( elem, type );
1166              }, time );
1167          });
1168      },
1169  
1170      clearQueue: function( type ) {
1171          return this.queue( type || "fx", [] );
1172      }
1173  });
1174  var rclass = /[\n\t]/g,
1175      rspace = /\s+/,
1176      rreturn = /\r/g,
1177      rspecialurl = /href|src|style/,
1178      rtype = /(button|input)/i,
1179      rfocusable = /(button|input|object|select|textarea)/i,
1180      rclickable = /^(a|area)$/i,
1181      rradiocheck = /radio|checkbox/;
1182  
1183  jQuery.fn.extend({
1184      attr: function( name, value ) {
1185          return access( this, name, value, true, jQuery.attr );
1186      },
1187  
1188      removeAttr: function( name, fn ) {
1189          return this.each(function(){
1190              jQuery.attr( this, name, "" );
1191              if ( this.nodeType === 1 ) {
1192                  this.removeAttribute( name );
1193              }
1194          });
1195      },
1196  
1197      addClass: function( value ) {
1198          if ( jQuery.isFunction(value) ) {
1199              return this.each(function(i) {
1200                  var self = jQuery(this);
1201                  self.addClass( value.call(this, i, self.attr("class")) );
1202              });
1203          }
1204  
1205          if ( value && typeof value === "string" ) {
1206              var classNames = (value || "").split( rspace );
1207  
1208              for ( var i = 0, l = this.length; i < l; i++ ) {
1209                  var elem = this[i];
1210  
1211                  if ( elem.nodeType === 1 ) {
1212                      if ( !elem.className ) {
1213                          elem.className = value;
1214  
1215                      } else {
1216                          var className = " " + elem.className + " ";
1217                          for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1218                              if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1219                                  elem.className += " " + classNames[c];
1220                              }
1221                          }
1222                      }
1223                  }
1224              }
1225          }
1226  
1227          return this;
1228      },
1229  
1230      removeClass: function( value ) {
1231          if ( jQuery.isFunction(value) ) {
1232              return this.each(function(i) {
1233                  var self = jQuery(this);
1234                  self.removeClass( value.call(this, i, self.attr("class")) );
1235              });
1236          }
1237  
1238          if ( (value && typeof value === "string") || value === undefined ) {
1239              var classNames = (value || "").split(rspace);
1240  
1241              for ( var i = 0, l = this.length; i < l; i++ ) {
1242                  var elem = this[i];
1243  
1244                  if ( elem.nodeType === 1 && elem.className ) {
1245                      if ( value ) {
1246                          var className = (" " + elem.className + " ").replace(rclass, " ");
1247                          for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1248                              className = className.replace(" " + classNames[c] + " ", " ");
1249                          }
1250                          elem.className = className.substring(1, className.length - 1);
1251  
1252                      } else {
1253                          elem.className = "";
1254                      }
1255                  }
1256              }
1257          }
1258  
1259          return this;
1260      },
1261  
1262      toggleClass: function( value, stateVal ) {
1263          var type = typeof value, isBool = typeof stateVal === "boolean";
1264  
1265          if ( jQuery.isFunction( value ) ) {
1266              return this.each(function(i) {
1267                  var self = jQuery(this);
1268                  self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1269              });
1270          }
1271  
1272          return this.each(function() {
1273              if ( type === "string" ) {
1274                  // toggle individual class names

1275                  var className, i = 0, self = jQuery(this),
1276                      state = stateVal,
1277                      classNames = value.split( rspace );
1278  
1279                  while ( (className = classNames[ i++ ]) ) {
1280                      // check each className given, space seperated list

1281                      state = isBool ? state : !self.hasClass( className );
1282                      self[ state ? "addClass" : "removeClass" ]( className );
1283                  }
1284  
1285              } else if ( type === "undefined" || type === "boolean" ) {
1286                  if ( this.className ) {
1287                      // store className if set

1288                      jQuery.data( this, "__className__", this.className );
1289                  }
1290  
1291                  // toggle whole className

1292                  this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1293              }
1294          });
1295      },
1296  
1297      hasClass: function( selector ) {
1298          var className = " " + selector + " ";
1299          for ( var i = 0, l = this.length; i < l; i++ ) {
1300              if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1301                  return true;
1302              }
1303          }
1304  
1305          return false;
1306      },
1307  
1308      val: function( value ) {
1309          if ( value === undefined ) {
1310              var elem = this[0];
1311  
1312              if ( elem ) {
1313                  if ( jQuery.nodeName( elem, "option" ) ) {
1314                      return (elem.attributes.value || {}).specified ? elem.value : elem.text;
1315                  }
1316  
1317                  // We need to handle select boxes special

1318                  if ( jQuery.nodeName( elem, "select" ) ) {
1319                      var index = elem.selectedIndex,
1320                          values = [],
1321                          options = elem.options,
1322                          one = elem.type === "select-one";
1323  
1324                      // Nothing was selected

1325                      if ( index < 0 ) {
1326                          return null;
1327                      }
1328  
1329                      // Loop through all the selected options

1330                      for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1331                          var option = options[ i ];
1332  
1333                          if ( option.selected ) {
1334                              // Get the specifc value for the option

1335                              value = jQuery(option).val();
1336  
1337                              // We don't need an array for one selects

1338                              if ( one ) {
1339                                  return value;
1340                              }
1341  
1342                              // Multi-Selects return an array

1343                              values.push( value );
1344                          }
1345                      }
1346  
1347                      return values;
1348                  }
1349  
1350                  // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified

1351                  if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1352                      return elem.getAttribute("value") === null ? "on" : elem.value;
1353                  }
1354                  
1355  
1356                  // Everything else, we just grab the value

1357                  return (elem.value || "").replace(rreturn, "");
1358  
1359              }
1360  
1361              return undefined;
1362          }
1363  
1364          var isFunction = jQuery.isFunction(value);
1365  
1366          return this.each(function(i) {
1367              var self = jQuery(this), val = value;
1368  
1369              if ( this.nodeType !== 1 ) {
1370                  return;
1371              }
1372  
1373              if ( isFunction ) {
1374                  val = value.call(this, i, self.val());
1375              }
1376  
1377              // Typecast each time if the value is a Function and the appended

1378              // value is therefore different each time.

1379              if ( typeof val === "number" ) {
1380                  val += "";
1381              }
1382  
1383              if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1384                  this.checked = jQuery.inArray( self.val(), val ) >= 0;
1385  
1386              } else if ( jQuery.nodeName( this, "select" ) ) {
1387                  var values = jQuery.makeArray(val);
1388  
1389                  jQuery( "option", this ).each(function() {
1390                      this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1391                  });
1392  
1393                  if ( !values.length ) {
1394                      this.selectedIndex = -1;
1395                  }
1396  
1397              } else {
1398                  this.value = val;
1399              }
1400          });
1401      }
1402  });
1403  
1404  jQuery.extend({
1405      attrFn: {
1406          val: true,
1407          css: true,
1408          html: true,
1409          text: true,
1410          data: true,
1411          width: true,
1412          height: true,
1413          offset: true
1414      },
1415          
1416      attr: function( elem, name, value, pass ) {
1417          // don't set attributes on text and comment nodes

1418          if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1419              return undefined;
1420          }
1421  
1422          if ( pass && name in jQuery.attrFn ) {
1423              return jQuery(elem)[name](value);
1424          }
1425  
1426          var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1427              // Whether we are setting (or getting)

1428              set = value !== undefined;
1429  
1430          // Try to normalize/fix the name

1431          name = notxml && jQuery.props[ name ] || name;
1432  
1433          // Only do all the following if this is a node (faster for style)

1434          if ( elem.nodeType === 1 ) {
1435              // These attributes require special treatment

1436              var special = rspecialurl.test( name );
1437  
1438              // Safari mis-reports the default selected property of an option

1439              // Accessing the parent's selectedIndex property fixes it

1440              if ( name === "selected" && !jQuery.support.optSelected ) {
1441                  var parent = elem.parentNode;
1442                  if ( parent ) {
1443                      parent.selectedIndex;
1444      
1445                      // Make sure that it also works with optgroups, see #5701

1446                      if ( parent.parentNode ) {
1447                          parent.parentNode.selectedIndex;
1448                      }
1449                  }
1450              }
1451  
1452              // If applicable, access the attribute via the DOM 0 way

1453              if ( name in elem && notxml && !special ) {
1454                  if ( set ) {
1455                      // We can't allow the type property to be changed (since it causes problems in IE)

1456                      if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1457                          throw "type property can't be changed";
1458                      }
1459  
1460                      elem[ name ] = value;
1461                  }
1462  
1463                  // browsers index elements by id/name on forms, give priority to attributes.

1464                  if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1465                      return elem.getAttributeNode( name ).nodeValue;
1466                  }
1467  
1468                  // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set

1469                  // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/

1470                  if ( name === "tabIndex" ) {
1471                      var attributeNode = elem.getAttributeNode( "tabIndex" );
1472  
1473                      return attributeNode && attributeNode.specified ?
1474                          attributeNode.value :
1475                          rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1476                              0 :
1477                              undefined;
1478                  }
1479  
1480                  return elem[ name ];
1481              }
1482  
1483              if ( !jQuery.support.style && notxml && name === "style" ) {
1484                  if ( set ) {
1485                      elem.style.cssText = "" + value;
1486                  }
1487  
1488                  return elem.style.cssText;
1489              }
1490  
1491              if ( set ) {
1492                  // convert the value to a string (all browsers do this but IE) see #1070

1493                  elem.setAttribute( name, "" + value );
1494              }
1495  
1496              var attr = !jQuery.support.hrefNormalized && notxml && special ?
1497                      // Some attributes require a special call on IE

1498                      elem.getAttribute( name, 2 ) :
1499                      elem.getAttribute( name );
1500  
1501              // Non-existent attributes return null, we normalize to undefined

1502              return attr === null ? undefined : attr;
1503          }
1504  
1505          // elem is actually elem.style ... set the style

1506          // Using attr for specific style information is now deprecated. Use style insead.

1507          return jQuery.style( elem, name, value );
1508      }
1509  });
1510  var fcleanup = function( nm ) {
1511      return nm.replace(/[^\w\s\.\|`]/g, function( ch ) {
1512          return "\\" + ch;
1513      });
1514  };
1515  
1516  /*

1517   * A number of helper functions used for managing events.

1518   * Many of the ideas behind this code originated from

1519   * Dean Edwards' addEvent library.

1520   */
1521  jQuery.event = {
1522  
1523      // Bind an event to an element

1524      // Original by Dean Edwards

1525      add: function( elem, types, handler, data ) {
1526          if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1527              return;
1528          }
1529  
1530          // For whatever reason, IE has trouble passing the window object

1531          // around, causing it to be cloned in the process

1532          if ( elem.setInterval && ( elem !== window && !elem.frameElement ) ) {
1533              elem = window;
1534          }
1535  
1536          // Make sure that the function being executed has a unique ID

1537          if ( !handler.guid ) {
1538              handler.guid = jQuery.guid++;
1539          }
1540  
1541          // if data is passed, bind to handler

1542          if ( data !== undefined ) {
1543              // Create temporary function pointer to original handler

1544              var fn = handler;
1545  
1546              // Create unique handler function, wrapped around original handler

1547              handler = jQuery.proxy( fn );
1548  
1549              // Store data in unique handler

1550              handler.data = data;
1551          }
1552  
1553          // Init the element's event structure

1554          var events = jQuery.data( elem, "events" ) || jQuery.data( elem, "events", {} ),
1555              handle = jQuery.data( elem, "handle" ), eventHandle;
1556  
1557          if ( !handle ) {
1558              eventHandle = function() {
1559                  // Handle the second event of a trigger and when

1560                  // an event is called after a page has unloaded

1561                  return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1562                      jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1563                      undefined;
1564              };
1565  
1566              handle = jQuery.data( elem, "handle", eventHandle );
1567          }
1568  
1569          // If no handle is found then we must be trying to bind to one of the

1570          // banned noData elements

1571          if ( !handle ) {
1572              return;
1573          }
1574  
1575          // Add elem as a property of the handle function

1576          // This is to prevent a memory leak with non-native

1577          // event in IE.

1578          handle.elem = elem;
1579  
1580          // Handle multiple events separated by a space

1581          // jQuery(...).bind("mouseover mouseout", fn);

1582          types = types.split( /\s+/ );
1583          var type, i=0;
1584          while ( (type = types[ i++ ]) ) {
1585              // Namespaced event handlers

1586              var namespaces = type.split(".");
1587              type = namespaces.shift();
1588              handler.type = namespaces.slice(0).sort().join(".");
1589  
1590              // Get the current list of functions bound to this event

1591              var handlers = events[ type ],
1592                  special = this.special[ type ] || {};
1593  
1594              
1595  
1596              // Init the event handler queue

1597              if ( !handlers ) {
1598                  handlers = events[ type ] = {};
1599  
1600                  // Check for a special event handler

1601                  // Only use addEventListener/attachEvent if the special

1602                  // events handler returns false

1603                  if ( !special.setup || special.setup.call( elem, data, namespaces, handler) === false ) {
1604                      // Bind the global event handler to the element

1605                      if ( elem.addEventListener ) {
1606                          elem.addEventListener( type, handle, false );
1607                      } else if ( elem.attachEvent ) {
1608                          elem.attachEvent( "on" + type, handle );
1609                      }
1610                  }
1611              }
1612              
1613              if ( special.add ) { 
1614                  var modifiedHandler = special.add.call( elem, handler, data, namespaces, handlers ); 
1615                  if ( modifiedHandler && jQuery.isFunction( modifiedHandler ) ) { 
1616                      modifiedHandler.guid = modifiedHandler.guid || handler.guid; 
1617                      handler = modifiedHandler; 
1618                  } 
1619              } 
1620              
1621              // Add the function to the element's handler list

1622              handlers[ handler.guid ] = handler;
1623  
1624              // Keep track of which events have been used, for global triggering

1625              this.global[ type ] = true;
1626          }
1627  
1628          // Nullify elem to prevent memory leaks in IE

1629          elem = null;
1630      },
1631  
1632      global: {},
1633  
1634      // Detach an event or set of events from an element

1635      remove: function( elem, types, handler ) {
1636          // don't do events on text and comment nodes

1637          if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1638              return;
1639          }
1640  
1641          var events = jQuery.data( elem, "events" ), ret, type, fn;
1642  
1643          if ( events ) {
1644              // Unbind all events for the element

1645              if ( types === undefined || (typeof types === "string" && types.charAt(0) === ".") ) {
1646                  for ( type in events ) {
1647                      this.remove( elem, type + (types || "") );
1648                  }
1649              } else {
1650                  // types is actually an event object here

1651                  if ( types.type ) {
1652                      handler = types.handler;
1653                      types = types.type;
1654                  }
1655  
1656                  // Handle multiple events separated by a space

1657                  // jQuery(...).unbind("mouseover mouseout", fn);

1658                  types = types.split(/\s+/);
1659                  var i = 0;
1660                  while ( (type = types[ i++ ]) ) {
1661                      // Namespaced event handlers

1662                      var namespaces = type.split(".");
1663                      type = namespaces.shift();
1664                      var all = !namespaces.length,
1665                          cleaned = jQuery.map( namespaces.slice(0).sort(), fcleanup ),
1666                          namespace = new RegExp("(^|\\.)" + cleaned.join("\\.(?:.*\\.)?") + "(\\.|$)"),
1667                          special = this.special[ type ] || {};
1668  
1669                      if ( events[ type ] ) {
1670                          // remove the given handler for the given type

1671                          if ( handler ) {
1672                              fn = events[ type ][ handler.guid ];
1673                              delete events[ type ][ handler.guid ];
1674  
1675                          // remove all handlers for the given type

1676                          } else {
1677                              for ( var handle in events[ type ] ) {
1678                                  // Handle the removal of namespaced events

1679                                  if ( all || namespace.test( events[ type ][ handle ].type ) ) {
1680                                      delete events[ type ][ handle ];
1681                                  }
1682                              }
1683                          }
1684  
1685                          if ( special.remove ) {
1686                              special.remove.call( elem, namespaces, fn);
1687                          }
1688  
1689                          // remove generic event handler if no more handlers exist

1690                          for ( ret in events[ type ] ) {
1691                              break;
1692                          }
1693                          if ( !ret ) {
1694                              if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
1695                                  if ( elem.removeEventListener ) {
1696                                      elem.removeEventListener( type, jQuery.data( elem, "handle" ), false );
1697                                  } else if ( elem.detachEvent ) {
1698                                      elem.detachEvent( "on" + type, jQuery.data( elem, "handle" ) );
1699                                  }
1700                              }
1701                              ret = null;
1702                              delete events[ type ];
1703                          }
1704                      }
1705                  }
1706              }
1707  
1708              // Remove the expando if it's no longer used

1709              for ( ret in events ) {
1710                  break;
1711              }
1712              if ( !ret ) {
1713                  var handle = jQuery.data( elem, "handle" );
1714                  if ( handle ) {
1715                      handle.elem = null;
1716                  }
1717                  jQuery.removeData( elem, "events" );
1718                  jQuery.removeData( elem, "handle" );
1719              }
1720          }
1721      },
1722  
1723      // bubbling is internal

1724      trigger: function( event, data, elem /*, bubbling */ ) {
1725          // Event object or event type

1726          var type = event.type || event,
1727              bubbling = arguments[3];
1728  
1729          if ( !bubbling ) {
1730              event = typeof event === "object" ?
1731                  // jQuery.Event object

1732                  event[expando] ? event :
1733                  // Object literal

1734                  jQuery.extend( jQuery.Event(type), event ) :
1735                  // Just the event type (string)

1736                  jQuery.Event(type);
1737  
1738              if ( type.indexOf("!") >= 0 ) {
1739                  event.type = type = type.slice(0, -1);
1740                  event.exclusive = true;
1741              }
1742  
1743              // Handle a global trigger

1744              if ( !elem ) {
1745                  // Don't bubble custom events when global (to avoid too much overhead)

1746                  event.stopPropagation();
1747  
1748                  // Only trigger if we've ever bound an event for it

1749                  if ( this.global[ type ] ) {
1750                      jQuery.each( jQuery.cache, function() {
1751                          if ( this.events && this.events[type] ) {
1752                              jQuery.event.trigger( event, data, this.handle.elem );
1753                          }
1754                      });
1755                  }
1756              }
1757  
1758              // Handle triggering a single element

1759  
1760              // don't do events on text and comment nodes

1761              if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1762                  return undefined;
1763              }
1764  
1765              // Clean up in case it is reused

1766              event.result = undefined;
1767              event.target = elem;
1768  
1769              // Clone the incoming data, if any

1770              data = jQuery.makeArray( data );
1771              data.unshift( event );
1772          }
1773  
1774          event.currentTarget = elem;
1775  
1776          // Trigger the event, it is assumed that "handle" is a function

1777          var handle = jQuery.data( elem, "handle" );
1778          if ( handle ) {
1779              handle.apply( elem, data );
1780          }
1781  
1782          var nativeFn, nativeHandler;
1783          try {
1784              if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
1785                  nativeFn = elem[ type ];
1786                  nativeHandler = elem[ "on" + type ];
1787              }
1788          // prevent IE from throwing an error for some elements with some event types, see #3533

1789          } catch (e) {}
1790  
1791          var isClick = jQuery.nodeName(elem, "a") && type === "click";
1792  
1793          // Trigger the native events (except for clicks on links)

1794          if ( !bubbling && nativeFn && !event.isDefaultPrevented() && !isClick ) {
1795              this.triggered = true;
1796              try {
1797                  elem[ type ]();
1798              // prevent IE from throwing an error for some hidden elements

1799              } catch (e) {}
1800  
1801          // Handle triggering native .onfoo handlers

1802          } else if ( nativeHandler && elem[ "on" + type ].apply( elem, data ) === false ) {
1803              event.result = false;
1804          }
1805  
1806          this.triggered = false;
1807  
1808          if ( !event.isPropagationStopped() ) {
1809              var parent = elem.parentNode || elem.ownerDocument;
1810              if ( parent ) {
1811                  jQuery.event.trigger( event, data, parent, true );
1812              }
1813          }
1814      },
1815  
1816      handle: function( event ) {
1817          // returned undefined or false

1818          var all, handlers;
1819  
1820          event = arguments[0] = jQuery.event.fix( event || window.event );
1821          event.currentTarget = this;
1822  
1823          // Namespaced event handlers

1824          var namespaces = event.type.split(".");
1825          event.type = namespaces.shift();
1826  
1827          // Cache this now, all = true means, any handler

1828          all = !namespaces.length && !event.exclusive;
1829  
1830          var namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
1831  
1832          handlers = ( jQuery.data(this, "events") || {} )[ event.type ];
1833  
1834          for ( var j in handlers ) {
1835              var handler = handlers[ j ];
1836  
1837              // Filter the functions by class

1838              if ( all || namespace.test(handler.type) ) {
1839                  // Pass in a reference to the handler function itself

1840                  // So that we can later remove it

1841                  event.handler = handler;
1842                  event.data = handler.data;
1843  
1844                  var ret = handler.apply( this, arguments );
1845  
1846                  if ( ret !== undefined ) {
1847                      event.result = ret;
1848                      if ( ret === false ) {
1849                          event.preventDefault();
1850                          event.stopPropagation();
1851                      }
1852                  }
1853  
1854                  if ( event.isImmediatePropagationStopped() ) {
1855                      break;
1856                  }
1857  
1858              }
1859          }
1860  
1861          return event.result;
1862      },
1863  
1864      props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1865  
1866      fix: function( event ) {
1867          if ( event[ expando ] ) {
1868              return event;
1869          }
1870  
1871          // store a copy of the original event object

1872          // and "clone" to set read-only properties

1873          var originalEvent = event;
1874          event = jQuery.Event( originalEvent );
1875  
1876          for ( var i = this.props.length, prop; i; ) {
1877              prop = this.props[ --i ];
1878              event[ prop ] = originalEvent[ prop ];
1879          }
1880  
1881          // Fix target property, if necessary

1882          if ( !event.target ) {
1883              event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either

1884          }
1885  
1886          // check if target is a textnode (safari)

1887          if ( event.target.nodeType === 3 ) {
1888              event.target = event.target.parentNode;
1889          }
1890  
1891          // Add relatedTarget, if necessary

1892          if ( !event.relatedTarget && event.fromElement ) {
1893              event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1894          }
1895  
1896          // Calculate pageX/Y if missing and clientX/Y available

1897          if ( event.pageX == null && event.clientX != null ) {
1898              var doc = document.documentElement, body = document.body;
1899              event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1900              event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
1901          }
1902  
1903          // Add which for key events

1904          if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
1905              event.which = event.charCode || event.keyCode;
1906          }
1907  
1908          // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)

1909          if ( !event.metaKey && event.ctrlKey ) {
1910              event.metaKey = event.ctrlKey;
1911          }
1912  
1913          // Add which for click: 1 === left; 2 === middle; 3 === right

1914          // Note: button is not normalized, so don't use it

1915          if ( !event.which && event.button !== undefined ) {
1916              event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
1917          }
1918  
1919          return event;
1920      },
1921  
1922      // Deprecated, use jQuery.guid instead

1923      guid: 1E8,
1924  
1925      // Deprecated, use jQuery.proxy instead

1926      proxy: jQuery.proxy,
1927  
1928      special: {
1929          ready: {
1930              // Make sure the ready event is setup

1931              setup: jQuery.bindReady,
1932              teardown: jQuery.noop
1933          },
1934  
1935          live: {
1936              add: function( proxy, data, namespaces, live ) {
1937                  jQuery.extend( proxy, data || {} );
1938  
1939                  proxy.guid += data.selector + data.live; 
1940                  jQuery.event.add( this, data.live, liveHandler, data ); 
1941                  
1942              },
1943  
1944              remove: function( namespaces ) {
1945                  if ( namespaces.length ) {
1946                      var remove = 0, name = new RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
1947  
1948                      jQuery.each( (jQuery.data(this, "events").live || {}), function() {
1949                          if ( name.test(this.type) ) {
1950                              remove++;
1951                          }
1952                      });
1953  
1954                      if ( remove < 1 ) {
1955                          jQuery.event.remove( this, namespaces[0], liveHandler );
1956                      }
1957                  }
1958              },
1959              special: {}
1960          },
1961          beforeunload: {
1962              setup: function( data, namespaces, fn ) {
1963                  // We only want to do this special case on windows

1964                  if ( this.setInterval ) {
1965                      this.onbeforeunload = fn;
1966                  }
1967  
1968                  return false;
1969              },
1970              teardown: function( namespaces, fn ) {
1971                  if ( this.onbeforeunload === fn ) {
1972                      this.onbeforeunload = null;
1973                  }
1974              }
1975          }
1976      }
1977  };
1978  
1979  jQuery.Event = function( src ) {
1980      // Allow instantiation without the 'new' keyword

1981      if ( !this.preventDefault ) {
1982          return new jQuery.Event( src );
1983      }
1984  
1985      // Event object

1986      if ( src && src.type ) {
1987          this.originalEvent = src;
1988          this.type = src.type;
1989      // Event type

1990      } else {
1991          this.type = src;
1992      }
1993  
1994      // timeStamp is buggy for some events on Firefox(#3843)

1995      // So we won't rely on the native value

1996      this.timeStamp = now();
1997  
1998      // Mark it as fixed

1999      this[ expando ] = true;
2000  };
2001  
2002  function returnFalse() {
2003      return false;
2004  }
2005  function returnTrue() {
2006      return true;
2007  }
2008  
2009  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding

2010  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html

2011  jQuery.Event.prototype = {
2012      preventDefault: function() {
2013          this.isDefaultPrevented = returnTrue;
2014  
2015          var e = this.originalEvent;
2016          if ( !e ) {
2017              return;
2018          }
2019          
2020          // if preventDefault exists run it on the original event

2021          if ( e.preventDefault ) {
2022              e.preventDefault();
2023          }
2024          // otherwise set the returnValue property of the original event to false (IE)

2025          e.returnValue = false;
2026      },
2027      stopPropagation: function() {
2028          this.isPropagationStopped = returnTrue;
2029  
2030          var e = this.originalEvent;
2031          if ( !e ) {
2032              return;
2033          }
2034          // if stopPropagation exists run it on the original event

2035          if ( e.stopPropagation ) {
2036              e.stopPropagation();
2037          }
2038          // otherwise set the cancelBubble property of the original event to true (IE)

2039          e.cancelBubble = true;
2040      },
2041      stopImmediatePropagation: function() {
2042          this.isImmediatePropagationStopped = returnTrue;
2043          this.stopPropagation();
2044      },
2045      isDefaultPrevented: returnFalse,
2046      isPropagationStopped: returnFalse,
2047      isImmediatePropagationStopped: returnFalse
2048  };
2049  
2050  // Checks if an event happened on an element within another element

2051  // Used in jQuery.event.special.mouseenter and mouseleave handlers

2052  var withinElement = function( event ) {
2053      // Check if mouse(over|out) are still within the same parent element

2054      var parent = event.relatedTarget;
2055  
2056      // Traverse up the tree

2057      while ( parent && parent !== this ) {
2058          // Firefox sometimes assigns relatedTarget a XUL element

2059          // which we cannot access the parentNode property of

2060          try {
2061              parent = parent.parentNode;
2062  
2063          // assuming we've left the element since we most likely mousedover a xul element

2064          } catch(e) {
2065              break;
2066          }
2067      }
2068  
2069      if ( parent !== this ) {
2070          // set the correct event type

2071          event.type = event.data;
2072  
2073          // handle event if we actually just moused on to a non sub-element

2074          jQuery.event.handle.apply( this, arguments );
2075      }
2076  
2077  },
2078  
2079  // In case of event delegation, we only need to rename the event.type,

2080  // liveHandler will take care of the rest.

2081  delegate = function( event ) {
2082      event.type = event.data;
2083      jQuery.event.handle.apply( this, arguments );
2084  };
2085  
2086  // Create mouseenter and mouseleave events

2087  jQuery.each({
2088      mouseenter: "mouseover",
2089      mouseleave: "mouseout"
2090  }, function( orig, fix ) {
2091      jQuery.event.special[ orig ] = {
2092          setup: function( data ) {
2093              jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2094          },
2095          teardown: function( data ) {
2096              jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2097          }
2098      };
2099  });
2100  
2101  // submit delegation

2102  if ( !jQuery.support.submitBubbles ) {
2103  
2104  jQuery.event.special.submit = {
2105      setup: function( data, namespaces, fn ) {
2106          if ( this.nodeName.toLowerCase() !== "form" ) {
2107              jQuery.event.add(this, "click.specialSubmit." + fn.guid, function( e ) {
2108                  var elem = e.target, type = elem.type;
2109  
2110                  if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2111                      return trigger( "submit", this, arguments );
2112                  }
2113              });
2114       
2115              jQuery.event.add(this, "keypress.specialSubmit." + fn.guid, function( e ) {
2116                  var elem = e.target, type = elem.type;
2117  
2118                  if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2119                      return trigger( "submit", this, arguments );
2120                  }
2121              });
2122  
2123          } else {
2124              return false;
2125          }
2126      },
2127  
2128      remove: function( namespaces, fn ) {
2129          jQuery.event.remove( this, "click.specialSubmit" + (fn ? "."+fn.guid : "") );
2130          jQuery.event.remove( this, "keypress.specialSubmit" + (fn ? "."+fn.guid : "") );
2131      }
2132  };
2133  
2134  }
2135  
2136  // change delegation, happens here so we have bind.

2137  if ( !jQuery.support.changeBubbles ) {
2138  
2139  var formElems = /textarea|input|select/i;
2140  
2141  function getVal( elem ) {
2142      var type = elem.type, val = elem.value;
2143  
2144      if ( type === "radio" || type === "checkbox" ) {
2145          val = elem.checked;
2146  
2147      } else if ( type === "select-multiple" ) {
2148          val = elem.selectedIndex > -1 ?
2149              jQuery.map( elem.options, function( elem ) {
2150                  return elem.selected;
2151              }).join("-") :
2152              "";
2153  
2154      } else if ( elem.nodeName.toLowerCase() === "select" ) {
2155          val = elem.selectedIndex;
2156      }
2157  
2158      return val;
2159  }
2160  
2161  function testChange( e ) {
2162          var elem = e.target, data, val;
2163  
2164          if ( !formElems.test( elem.nodeName ) || elem.readOnly ) {
2165              return;
2166          }
2167  
2168          data = jQuery.data( elem, "_change_data" );
2169          val = getVal(elem);
2170  
2171          if ( val === data ) {
2172              return;
2173          }
2174  
2175          // the current data will be also retrieved by beforeactivate

2176          if ( e.type !== "focusout" || elem.type !== "radio" ) {
2177              jQuery.data( elem, "_change_data", val );
2178          }
2179  
2180          if ( elem.type !== "select" && (data != null || val) ) {
2181              e.type = "change";
2182              return jQuery.event.trigger( e, arguments[1], this );
2183          }
2184  }
2185  
2186  jQuery.event.special.change = {
2187      filters: {
2188          focusout: testChange, 
2189  
2190          click: function( e ) {
2191              var elem = e.target, type = elem.type;
2192  
2193              if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2194                  return testChange.call( this, e );
2195              }
2196          },
2197  
2198          // Change has to be called before submit

2199          // Keydown will be called before keypress, which is used in submit-event delegation

2200          keydown: function( e ) {
2201              var elem = e.target, type = elem.type;
2202  
2203              if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2204                  (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2205                  type === "select-multiple" ) {
2206                  return testChange.call( this, e );
2207              }
2208          },
2209  
2210          // Beforeactivate happens also before the previous element is blurred

2211          // with this event you can't trigger a change event, but you can store

2212          // information/focus[in] is not needed anymore

2213          beforeactivate: function( e ) {
2214              var elem = e.target;
2215  
2216              if ( elem.nodeName.toLowerCase() === "input" && elem.type === "radio" ) {
2217                  jQuery.data( elem, "_change_data", getVal(elem) );
2218              }
2219          }
2220      },
2221      setup: function( data, namespaces, fn ) {
2222          for ( var type in changeFilters ) {
2223              jQuery.event.add( this, type + ".specialChange." + fn.guid, changeFilters[type] );
2224          }
2225  
2226          return formElems.test( this.nodeName );
2227      },
2228      remove: function( namespaces, fn ) {
2229          for ( var type in changeFilters ) {
2230              jQuery.event.remove( this, type + ".specialChange" + (fn ? "."+fn.guid : ""), changeFilters[type] );
2231          }
2232  
2233          return formElems.test( this.nodeName );
2234      }
2235  };
2236  
2237  var changeFilters = jQuery.event.special.change.filters;
2238  
2239  }
2240  
2241  function trigger( type, elem, args ) {
2242      args[0].type = type;
2243      return jQuery.event.handle.apply( elem, args );
2244  }
2245  
2246  // Create "bubbling" focus and blur events

2247  if ( document.addEventListener ) {
2248      jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2249          jQuery.event.special[ fix ] = {
2250              setup: function() {
2251                  this.addEventListener( orig, handler, true );
2252              }, 
2253              teardown: function() { 
2254                  this.removeEventListener( orig, handler, true );
2255              }
2256          };
2257  
2258  		function handler( e ) { 
2259              e = jQuery.event.fix( e );
2260              e.type = fix;
2261              return jQuery.event.handle.call( this, e );
2262          }
2263      });
2264  }
2265  
2266  jQuery.each(["bind", "one"], function( i, name ) {
2267      jQuery.fn[ name ] = function( type, data, fn ) {
2268          // Handle object literals

2269          if ( typeof type === "object" ) {
2270              for ( var key in type ) {
2271                  this[ name ](key, data, type[key], fn);
2272              }
2273              return this;
2274          }
2275          
2276          if ( jQuery.isFunction( data ) ) {
2277              thisObject = fn;
2278              fn = data;
2279              data = undefined;
2280          }
2281  
2282          var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2283              jQuery( this ).unbind( event, handler );
2284              return fn.apply( this, arguments );
2285          }) : fn;
2286  
2287          return type === "unload" && name !== "one" ?
2288              this.one( type, data, fn, thisObject ) :
2289              this.each(function() {
2290                  jQuery.event.add( this, type, handler, data );
2291              });
2292      };
2293  });
2294  
2295  jQuery.fn.extend({
2296      unbind: function( type, fn ) {
2297          // Handle object literals

2298          if ( typeof type === "object" && !type.preventDefault ) {
2299              for ( var key in type ) {
2300                  this.unbind(key, type[key]);
2301              }
2302              return this;
2303          }
2304  
2305          return this.each(function() {
2306              jQuery.event.remove( this, type, fn );
2307          });
2308      },
2309      trigger: function( type, data ) {
2310          return this.each(function() {
2311              jQuery.event.trigger( type, data, this );
2312          });
2313      },
2314  
2315      triggerHandler: function( type, data ) {
2316          if ( this[0] ) {
2317              var event = jQuery.Event( type );
2318              event.preventDefault();
2319              event.stopPropagation();
2320              jQuery.event.trigger( event, data, this[0] );
2321              return event.result;
2322          }
2323      },
2324  
2325      toggle: function( fn ) {
2326          // Save reference to arguments for access in closure

2327          var args = arguments, i = 1;
2328  
2329          // link all the functions, so any of them can unbind this click handler

2330          while ( i < args.length ) {
2331              jQuery.proxy( fn, args[ i++ ] );
2332          }
2333  
2334          return this.click( jQuery.proxy( fn, function( event ) {
2335              // Figure out which function to execute

2336              var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2337              jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2338  
2339              // Make sure that clicks stop

2340              event.preventDefault();
2341  
2342              // and execute the function

2343              return args[ lastToggle ].apply( this, arguments ) || false;
2344          }));
2345      },
2346  
2347      hover: function( fnOver, fnOut ) {
2348          return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2349      },
2350  
2351      live: function( type, data, fn ) {
2352          if ( jQuery.isFunction( data ) ) {
2353              fn = data;
2354              data = undefined;
2355          }
2356  
2357          jQuery( this.context ).bind( liveConvert( type, this.selector ), {
2358              data: data, selector: this.selector, live: type
2359          }, fn );
2360  
2361          return this;
2362      },
2363  
2364      die: function( type, fn ) {
2365          jQuery( this.context ).unbind( liveConvert( type, this.selector ), fn ? { guid: fn.guid + this.selector + type } : null );
2366          return this;
2367      }
2368  });
2369  
2370  function liveHandler( event ) {
2371      var stop = true, elems = [], selectors = [], args = arguments,
2372          related, match, fn, elem, j, i, data,
2373          live = jQuery.extend({}, jQuery.data( this, "events" ).live);
2374  
2375      for ( j in live ) {
2376          fn = live[j];
2377          if ( fn.live === event.type ||
2378                  fn.altLive && jQuery.inArray(event.type, fn.altLive) > -1 ) {
2379  
2380              data = fn.data;
2381              if ( !(data.beforeFilter && data.beforeFilter[event.type] && 
2382                      !data.beforeFilter[event.type](event)) ) {
2383                  selectors.push( fn.selector );
2384              }
2385          } else {
2386              delete live[j];
2387          }
2388      }
2389  
2390      match = jQuery( event.target ).closest( selectors, event.currentTarget );
2391  
2392      for ( i = 0, l = match.length; i < l; i++ ) {
2393          for ( j in live ) {
2394              fn = live[j];
2395              elem = match[i].elem;
2396              related = null;
2397  
2398              if ( match[i].selector === fn.selector ) {
2399                  // Those two events require additional checking

2400                  if ( fn.live === "mouseenter" || fn.live === "mouseleave" ) {
2401                      related = jQuery( event.relatedTarget ).closest( fn.selector )[0];
2402                  }
2403  
2404                  if ( !related || related !== elem ) {
2405                      elems.push({ elem: elem, fn: fn });
2406                  }
2407              }
2408          }
2409      }
2410  
2411      for ( i = 0, l = elems.length; i < l; i++ ) {
2412          match = elems[i];
2413          event.currentTarget = match.elem;
2414          event.data = match.fn.data;
2415          if ( match.fn.apply( match.elem, args ) === false ) {
2416              stop = false;
2417              break;
2418          }
2419      }
2420  
2421      return stop;
2422  }
2423  
2424  function liveConvert( type, selector ) {
2425      return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "&")].join(".");
2426  }
2427  
2428  jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2429      "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2430      "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2431  
2432      // Handle event binding

2433      jQuery.fn[ name ] = function( fn ) {
2434          return fn ? this.bind( name, fn ) : this.trigger( name );
2435      };
2436  
2437      if ( jQuery.attrFn ) {
2438          jQuery.attrFn[ name ] = true;
2439      }
2440  });
2441  
2442  // Prevent memory leaks in IE

2443  // Window isn't included so as not to unbind existing unload events

2444  // More info:

2445  //  - http://isaacschlueter.com/2006/10/msie-memory-leaks/

2446  if ( window.attachEvent && !window.addEventListener ) {
2447      window.attachEvent("onunload", function() {
2448          for ( var id in jQuery.cache ) {
2449              if ( jQuery.cache[ id ].handle ) {
2450                  // Try/Catch is to handle iframes being unloaded, see #4280

2451                  try {
2452                      jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2453                  } catch(e) {}
2454              }
2455          }
2456      });
2457  }
2458  /*!

2459   * Sizzle CSS Selector Engine - v1.0

2460   *  Copyright 2009, The Dojo Foundation

2461   *  Released under the MIT, BSD, and GPL Licenses.

2462   *  More information: http://sizzlejs.com/

2463   */
2464  (function(){
2465  
2466  var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2467      done = 0,
2468      toString = Object.prototype.toString,
2469      hasDuplicate = false,
2470      baseHasDuplicate = true;
2471  
2472  // Here we check if the JavaScript engine is using some sort of

2473  // optimization where it does not always call our comparision

2474  // function. If that is the case, discard the hasDuplicate value.

2475  //   Thus far that includes Google Chrome.

2476  [0, 0].sort(function(){
2477      baseHasDuplicate = false;
2478      return 0;
2479  });
2480  
2481  var Sizzle = function(selector, context, results, seed) {
2482      results = results || [];
2483      var origContext = context = context || document;
2484  
2485      if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
2486          return [];
2487      }
2488      
2489      if ( !selector || typeof selector !== "string" ) {
2490          return results;
2491      }
2492  
2493      var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context),
2494          soFar = selector;
2495      
2496      // Reset the position of the chunker regexp (start from head)

2497      while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
2498          soFar = m[3];
2499          
2500          parts.push( m[1] );
2501          
2502          if ( m[2] ) {
2503              extra = m[3];
2504              break;
2505          }
2506      }
2507  
2508      if ( parts.length > 1 && origPOS.exec( selector ) ) {
2509          if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
2510              set = posProcess( parts[0] + parts[1], context );
2511          } else {
2512              set = Expr.relative[ parts[0] ] ?
2513                  [ context ] :
2514                  Sizzle( parts.shift(), context );
2515  
2516              while ( parts.length ) {
2517                  selector = parts.shift();
2518  
2519                  if ( Expr.relative[ selector ] ) {
2520                      selector += parts.shift();
2521                  }
2522                  
2523                  set = posProcess( selector, set );
2524              }
2525          }
2526      } else {
2527          // Take a shortcut and set the context if the root selector is an ID

2528          // (but not if it'll be faster if the inner selector is an ID)

2529          if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
2530                  Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
2531              var ret = Sizzle.find( parts.shift(), context, contextXML );
2532              context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
2533          }
2534  
2535          if ( context ) {
2536              var ret = seed ?
2537                  { expr: parts.pop(), set: makeArray(seed) } :
2538                  Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
2539              set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
2540  
2541              if ( parts.length > 0 ) {
2542                  checkSet = makeArray(set);
2543              } else {
2544                  prune = false;
2545              }
2546  
2547              while ( parts.length ) {
2548                  var cur = parts.pop(), pop = cur;
2549  
2550                  if ( !Expr.relative[ cur ] ) {
2551                      cur = "";
2552                  } else {
2553                      pop = parts.pop();
2554                  }
2555  
2556                  if ( pop == null ) {
2557                      pop = context;
2558                  }
2559  
2560                  Expr.relative[ cur ]( checkSet, pop, contextXML );
2561              }
2562          } else {
2563              checkSet = parts = [];
2564          }
2565      }
2566  
2567      if ( !checkSet ) {
2568          checkSet = set;
2569      }
2570  
2571      if ( !checkSet ) {
2572          throw "Syntax error, unrecognized expression: " + (cur || selector);
2573      }
2574  
2575      if ( toString.call(checkSet) === "[object Array]" ) {
2576          if ( !prune ) {
2577              results.push.apply( results, checkSet );
2578          } else if ( context && context.nodeType === 1 ) {
2579              for ( var i = 0; checkSet[i] != null; i++ ) {
2580                  if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
2581                      results.push( set[i] );
2582                  }
2583              }
2584          } else {
2585              for ( var i = 0; checkSet[i] != null; i++ ) {
2586                  if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
2587                      results.push( set[i] );
2588                  }
2589              }
2590          }
2591      } else {
2592          makeArray( checkSet, results );
2593      }
2594  
2595      if ( extra ) {
2596          Sizzle( extra, origContext, results, seed );
2597          Sizzle.uniqueSort( results );
2598      }
2599  
2600      return results;
2601  };
2602  
2603  Sizzle.uniqueSort = function(results){
2604      if ( sortOrder ) {
2605          hasDuplicate = baseHasDuplicate;
2606          results.sort(sortOrder);
2607  
2608          if ( hasDuplicate ) {
2609              for ( var i = 1; i < results.length; i++ ) {
2610                  if ( results[i] === results[i-1] ) {
2611                      results.splice(i--, 1);
2612                  }
2613              }
2614          }
2615      }
2616  
2617      return results;
2618  };
2619  
2620  Sizzle.matches = function(expr, set){
2621      return Sizzle(expr, null, null, set);
2622  };
2623  
2624  Sizzle.find = function(expr, context, isXML){
2625      var set, match;
2626  
2627      if ( !expr ) {
2628          return [];
2629      }
2630  
2631      for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
2632          var type = Expr.order[i], match;
2633          
2634          if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
2635              var left = match[1];
2636              match.splice(1,1);
2637  
2638              if ( left.substr( left.length - 1 ) !== "\\" ) {
2639                  match[1] = (match[1] || "").replace(/\\/g, "");
2640                  set = Expr.find[ type ]( match, context, isXML );
2641                  if ( set != null ) {
2642                      expr = expr.replace( Expr.match[ type ], "" );
2643                      break;
2644                  }
2645              }
2646          }
2647      }
2648  
2649      if ( !set ) {
2650          set = context.getElementsByTagName("*");
2651      }
2652  
2653      return {set: set, expr: expr};
2654  };
2655  
2656  Sizzle.filter = function(expr, set, inplace, not){
2657      var old = expr, result = [], curLoop = set, match, anyFound,
2658          isXMLFilter = set && set[0] && isXML(set[0]);
2659  
2660      while ( expr && set.length ) {
2661          for ( var type in Expr.filter ) {
2662              if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
2663                  var filter = Expr.filter[ type ], found, item, left = match[1];
2664                  anyFound = false;
2665  
2666                  match.splice(1,1);
2667  
2668                  if ( left.substr( left.length - 1 ) === "\\" ) {
2669                      continue;
2670                  }
2671  
2672                  if ( curLoop === result ) {
2673                      result = [];
2674                  }
2675  
2676                  if ( Expr.preFilter[ type ] ) {
2677                      match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
2678  
2679                      if ( !match ) {
2680                          anyFound = found = true;
2681                      } else if ( match === true ) {
2682                          continue;
2683                      }
2684                  }
2685  
2686                  if ( match ) {
2687                      for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
2688                          if ( item ) {
2689                              found = filter( item, match, i, curLoop );
2690                              var pass = not ^ !!found;
2691  
2692                              if ( inplace && found != null ) {
2693                                  if ( pass ) {
2694                                      anyFound = true;
2695                                  } else {
2696                                      curLoop[i] = false;
2697                                  }
2698                              } else if ( pass ) {
2699                                  result.push( item );
2700                                  anyFound = true;
2701                              }
2702                          }
2703                      }
2704                  }
2705  
2706                  if ( found !== undefined ) {
2707                      if ( !inplace ) {
2708                          curLoop = result;
2709                      }
2710  
2711                      expr = expr.replace( Expr.match[ type ], "" );
2712  
2713                      if ( !anyFound ) {
2714                          return [];
2715                      }
2716  
2717                      break;
2718                  }
2719              }
2720          }
2721  
2722          // Improper expression

2723          if ( expr === old ) {
2724              if ( anyFound == null ) {
2725                  throw "Syntax error, unrecognized expression: " + expr;
2726              } else {
2727                  break;
2728              }
2729          }
2730  
2731          old = expr;
2732      }
2733  
2734      return curLoop;
2735  };
2736  
2737  var Expr = Sizzle.selectors = {
2738      order: [ "ID", "NAME", "TAG" ],
2739      match: {
2740          ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2741          CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2742          NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
2743          ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
2744          TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
2745          CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
2746          POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
2747          PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
2748      },
2749      leftMatch: {},
2750      attrMap: {
2751          "class": "className",
2752          "for": "htmlFor"
2753      },
2754      attrHandle: {
2755          href: function(elem){
2756              return elem.getAttribute("href");
2757          }
2758      },
2759      relative: {
2760          "+": function(checkSet, part){
2761              var isPartStr = typeof part === "string",
2762                  isTag = isPartStr && !/\W/.test(part),
2763                  isPartStrNotTag = isPartStr && !isTag;
2764  
2765              if ( isTag ) {
2766                  part = part.toLowerCase();
2767              }
2768  
2769              for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
2770                  if ( (elem = checkSet[i]) ) {
2771                      while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
2772  
2773                      checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
2774                          elem || false :
2775                          elem === part;
2776                  }
2777              }
2778  
2779              if ( isPartStrNotTag ) {
2780                  Sizzle.filter( part, checkSet, true );
2781              }
2782          },
2783          ">": function(checkSet, part){
2784              var isPartStr = typeof part === "string";
2785  
2786              if ( isPartStr && !/\W/.test(part) ) {
2787                  part = part.toLowerCase();
2788  
2789                  for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2790                      var elem = checkSet[i];
2791                      if ( elem ) {
2792                          var parent = elem.parentNode;
2793                          checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
2794                      }
2795                  }
2796              } else {
2797                  for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2798                      var elem = checkSet[i];
2799                      if ( elem ) {
2800                          checkSet[i] = isPartStr ?
2801                              elem.parentNode :
2802                              elem.parentNode === part;
2803                      }
2804                  }
2805  
2806                  if ( isPartStr ) {
2807                      Sizzle.filter( part, checkSet, true );
2808                  }
2809              }
2810          },
2811          "": function(checkSet, part, isXML){
2812              var doneName = done++, checkFn = dirCheck;
2813  
2814              if ( typeof part === "string" && !/\W/.test(part) ) {
2815                  var nodeCheck = part = part.toLowerCase();
2816                  checkFn = dirNodeCheck;
2817              }
2818  
2819              checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
2820          },
2821          "~": function(checkSet, part, isXML){
2822              var doneName = done++, checkFn = dirCheck;
2823  
2824              if ( typeof part === "string" && !/\W/.test(part) ) {
2825                  var nodeCheck = part = part.toLowerCase();
2826                  checkFn = dirNodeCheck;
2827              }
2828  
2829              checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
2830          }
2831      },
2832      find: {
2833          ID: function(match, context, isXML){
2834              if ( typeof context.getElementById !== "undefined" && !isXML ) {
2835                  var m = context.getElementById(match[1]);
2836                  return m ? [m] : [];
2837              }
2838          },
2839          NAME: function(match, context){
2840              if ( typeof context.getElementsByName !== "undefined" ) {
2841                  var ret = [], results = context.getElementsByName(match[1]);
2842  
2843                  for ( var i = 0, l = results.length; i < l; i++ ) {
2844                      if ( results[i].getAttribute("name") === match[1] ) {
2845                          ret.push( results[i] );
2846                      }
2847                  }
2848  
2849                  return ret.length === 0 ? null : ret;
2850              }
2851          },
2852          TAG: function(match, context){
2853              return context.getElementsByTagName(match[1]);
2854          }
2855      },
2856      preFilter: {
2857          CLASS: function(match, curLoop, inplace, result, not, isXML){
2858              match = " " + match[1].replace(/\\/g, "") + " ";
2859  
2860              if ( isXML ) {
2861                  return match;
2862              }
2863  
2864              for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
2865                  if ( elem ) {
2866                      if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
2867                          if ( !inplace ) {
2868                              result.push( elem );
2869                          }
2870                      } else if ( inplace ) {
2871                          curLoop[i] = false;
2872                      }
2873                  }
2874              }
2875  
2876              return false;
2877          },
2878          ID: function(match){
2879              return match[1].replace(/\\/g, "");
2880          },
2881          TAG: function(match, curLoop){
2882              return match[1].toLowerCase();
2883          },
2884          CHILD: function(match){
2885              if ( match[1] === "nth" ) {
2886                  // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'

2887                  var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
2888                      match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
2889                      !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
2890  
2891                  // calculate the numbers (first)n+(last) including if they are negative

2892                  match[2] = (test[1] + (test[2] || 1)) - 0;
2893                  match[3] = test[3] - 0;
2894              }
2895  
2896              // TODO: Move to normal caching system

2897              match[0] = done++;
2898  
2899              return match;
2900          },
2901          ATTR: function(match, curLoop, inplace, result, not, isXML){
2902              var name = match[1].replace(/\\/g, "");
2903              
2904              if ( !isXML && Expr.attrMap[name] ) {
2905                  match[1] = Expr.attrMap[name];
2906              }
2907  
2908              if ( match[2] === "~=" ) {
2909                  match[4] = " " + match[4] + " ";
2910              }
2911  
2912              return match;
2913          },
2914          PSEUDO: function(match, curLoop, inplace, result, not){
2915              if ( match[1] === "not" ) {
2916                  // If we're dealing with a complex expression, or a simple one

2917                  if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
2918                      match[3] = Sizzle(match[3], null, null, curLoop);
2919                  } else {
2920                      var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
2921                      if ( !inplace ) {
2922                          result.push.apply( result, ret );
2923                      }
2924                      return false;
2925                  }
2926              } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
2927                  return true;
2928              }
2929              
2930              return match;
2931          },
2932          POS: function(match){
2933              match.unshift( true );
2934              return match;
2935          }
2936      },
2937      filters: {
2938          enabled: function(elem){
2939              return elem.disabled === false && elem.type !== "hidden";
2940          },
2941          disabled: function(elem){
2942              return elem.disabled === true;
2943          },
2944          checked: function(elem){
2945              return elem.checked === true;
2946          },
2947          selected: function(elem){
2948              // Accessing this property makes selected-by-default

2949              // options in Safari work properly

2950              elem.parentNode.selectedIndex;
2951              return elem.selected === true;
2952          },
2953          parent: function(elem){
2954              return !!elem.firstChild;
2955          },
2956          empty: function(elem){
2957              return !elem.firstChild;
2958          },
2959          has: function(elem, i, match){
2960              return !!Sizzle( match[3], elem ).length;
2961          },
2962          header: function(elem){
2963              return /h\d/i.test( elem.nodeName );
2964          },
2965          text: function(elem){
2966              return "text" === elem.type;
2967          },
2968          radio: function(elem){
2969              return "radio" === elem.type;
2970          },
2971          checkbox: function(elem){
2972              return "checkbox" === elem.type;
2973          },
2974          file: function(elem){
2975              return "file" === elem.type;
2976          },
2977          password: function(elem){
2978              return "password" === elem.type;
2979          },
2980          submit: function(elem){
2981              return "submit" === elem.type;
2982          },
2983          image: function(elem){
2984              return "image" === elem.type;
2985          },
2986          reset: function(elem){
2987              return "reset" === elem.type;
2988          },
2989          button: function(elem){
2990              return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
2991          },
2992          input: function(elem){
2993              return /input|select|textarea|button/i.test(elem.nodeName);
2994          }
2995      },
2996      setFilters: {
2997          first: function(elem, i){
2998              return i === 0;
2999          },
3000          last: function(elem, i, match, array){
3001              return i === array.length - 1;
3002          },
3003          even: function(elem, i){
3004              return i % 2 === 0;
3005          },
3006          odd: function(elem, i){
3007              return i % 2 === 1;
3008          },
3009          lt: function(elem, i, match){
3010              return i < match[3] - 0;
3011          },
3012          gt: function(elem, i, match){
3013              return i > match[3] - 0;
3014          },
3015          nth: function(elem, i, match){
3016              return match[3] - 0 === i;
3017          },
3018          eq: function(elem, i, match){
3019              return match[3] - 0 === i;
3020          }
3021      },
3022      filter: {
3023          PSEUDO: function(elem, match, i, array){
3024              var name = match[1], filter = Expr.filters[ name ];
3025  
3026              if ( filter ) {
3027                  return filter( elem, i, match, array );
3028              } else if ( name === "contains" ) {
3029                  return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
3030              } else if ( name === "not" ) {
3031                  var not = match[3];
3032  
3033                  for ( var i = 0, l = not.length; i < l; i++ ) {
3034                      if ( not[i] === elem ) {
3035                          return false;
3036                      }
3037                  }
3038  
3039                  return true;
3040              } else {
3041                  throw "Syntax error, unrecognized expression: " + name;
3042              }
3043          },
3044          CHILD: function(elem, match){
3045              var type = match[1], node = elem;
3046              switch (type) {
3047                  case 'only':
3048                  case 'first':
3049                      while ( (node = node.previousSibling) )     {
3050                          if ( node.nodeType === 1 ) { 
3051                              return false; 
3052                          }
3053                      }
3054                      if ( type === "first" ) { 
3055                          return true; 
3056                      }
3057                      node = elem;
3058                  case 'last':
3059                      while ( (node = node.nextSibling) )     {
3060                          if ( node.nodeType === 1 ) { 
3061                              return false; 
3062                          }
3063                      }
3064                      return true;
3065                  case 'nth':
3066                      var first = match[2], last = match[3];
3067  
3068                      if ( first === 1 && last === 0 ) {
3069                          return true;
3070                      }
3071                      
3072                      var doneName = match[0],
3073                          parent = elem.parentNode;
3074      
3075                      if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3076                          var count = 0;
3077                          for ( node = parent.firstChild; node; node = node.nextSibling ) {
3078                              if ( node.nodeType === 1 ) {
3079                                  node.nodeIndex = ++count;
3080                              }
3081                          } 
3082                          parent.sizcache = doneName;
3083                      }
3084                      
3085                      var diff = elem.nodeIndex - last;
3086                      if ( first === 0 ) {
3087                          return diff === 0;
3088                      } else {
3089                          return ( diff % first === 0 && diff / first >= 0 );
3090                      }
3091              }
3092          },
3093          ID: function(elem, match){
3094              return elem.nodeType === 1 && elem.getAttribute("id") === match;
3095          },
3096          TAG: function(elem, match){
3097              return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3098          },
3099          CLASS: function(elem, match){
3100              return (" " + (elem.className || elem.getAttribute("class")) + " ")
3101                  .indexOf( match ) > -1;
3102          },
3103          ATTR: function(elem, match){
3104              var name = match[1],
3105                  result = Expr.attrHandle[ name ] ?
3106                      Expr.attrHandle[ name ]( elem ) :
3107                      elem[ name ] != null ?
3108                          elem[ name ] :
3109                          elem.getAttribute( name ),
3110                  value = result + "",
3111                  type = match[2],
3112                  check = match[4];
3113  
3114              return result == null ?
3115                  type === "!=" :
3116                  type === "=" ?
3117                  value === check :
3118                  type === "*=" ?
3119                  value.indexOf(check) >= 0 :
3120                  type === "~=" ?
3121                  (" " + value + " ").indexOf(check) >= 0 :
3122                  !check ?
3123                  value && result !== false :
3124                  type === "!=" ?
3125                  value !== check :
3126                  type === "^=" ?
3127                  value.indexOf(check) === 0 :
3128                  type === "$=" ?
3129                  value.substr(value.length - check.length) === check :
3130                  type === "|=" ?
3131                  value === check || value.substr(0, check.length + 1) === check + "-" :
3132                  false;
3133          },
3134          POS: function(elem, match, i, array){
3135              var name = match[2], filter = Expr.setFilters[ name ];
3136  
3137              if ( filter ) {
3138                  return filter( elem, i, match, array );
3139              }
3140          }
3141      }
3142  };
3143  
3144  var origPOS = Expr.match.POS;
3145  
3146  for ( var type in Expr.match ) {
3147      Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
3148      Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){
3149          return "\\" + (num - 0 + 1);
3150      }));
3151  }
3152  
3153  var makeArray = function(array, results) {
3154      array = Array.prototype.slice.call( array, 0 );
3155  
3156      if ( results ) {
3157          results.push.apply( results, array );
3158          return results;
3159      }
3160      
3161      return array;
3162  };
3163  
3164  // Perform a simple check to determine if the browser is capable of

3165  // converting a NodeList to an array using builtin methods.

3166  try {
3167      Array.prototype.slice.call( document.documentElement.childNodes, 0 );
3168  
3169  // Provide a fallback method if it does not work

3170  } catch(e){
3171      makeArray = function(array, results) {
3172          var ret = results || [];
3173  
3174          if ( toString.call(array) === "[object Array]" ) {
3175              Array.prototype.push.apply( ret, array );
3176          } else {
3177              if ( typeof array.length === "number" ) {
3178                  for ( var i = 0, l = array.length; i < l; i++ ) {
3179                      ret.push( array[i] );
3180                  }
3181              } else {
3182                  for ( var i = 0; array[i]; i++ ) {
3183                      ret.push( array[i] );
3184                  }
3185              }
3186          }
3187  
3188          return ret;
3189      };
3190  }
3191  
3192  var sortOrder;
3193  
3194  if ( document.documentElement.compareDocumentPosition ) {
3195      sortOrder = function( a, b ) {
3196          if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3197              if ( a == b ) {
3198                  hasDuplicate = true;
3199              }
3200              return a.compareDocumentPosition ? -1 : 1;
3201          }
3202  
3203          var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
3204          if ( ret === 0 ) {
3205              hasDuplicate = true;
3206          }
3207          return ret;
3208      };
3209  } else if ( "sourceIndex" in document.documentElement ) {
3210      sortOrder = function( a, b ) {
3211          if ( !a.sourceIndex || !b.sourceIndex ) {
3212              if ( a == b ) {
3213                  hasDuplicate = true;
3214              }
3215              return a.sourceIndex ? -1 : 1;
3216          }
3217  
3218          var ret = a.sourceIndex - b.sourceIndex;
3219          if ( ret === 0 ) {
3220              hasDuplicate = true;
3221          }
3222          return ret;
3223      };
3224  } else if ( document.createRange ) {
3225      sortOrder = function( a, b ) {
3226          if ( !a.ownerDocument || !b.ownerDocument ) {
3227              if ( a == b ) {
3228                  hasDuplicate = true;
3229              }
3230              return a.ownerDocument ? -1 : 1;
3231          }
3232  
3233          var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
3234          aRange.setStart(a, 0);
3235          aRange.setEnd(a, 0);
3236          bRange.setStart(b, 0);
3237          bRange.setEnd(b, 0);
3238          var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
3239          if ( ret === 0 ) {
3240              hasDuplicate = true;
3241          }
3242          return ret;
3243      };
3244  }
3245  
3246  // Utility function for retreiving the text value of an array of DOM nodes

3247  function getText( elems ) {
3248      var ret = "", elem;
3249  
3250      for ( var i = 0; elems[i]; i++ ) {
3251          elem = elems[i];
3252  
3253          // Get the text from text nodes and CDATA nodes

3254          if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3255              ret += elem.nodeValue;
3256  
3257          // Traverse everything else, except comment nodes

3258          } else if ( elem.nodeType !== 8 ) {
3259              ret += getText( elem.childNodes );
3260          }
3261      }
3262  
3263      return ret;
3264  }
3265  
3266  // Check to see if the browser returns elements by name when

3267  // querying by getElementById (and provide a workaround)

3268  (function(){
3269      // We're going to inject a fake input element with a specified name

3270      var form = document.createElement("div"),
3271          id = "script" + (new Date).getTime();
3272      form.innerHTML = "<a name='" + id + "'/>";
3273  
3274      // Inject it into the root element, check its status, and remove it quickly

3275      var root = document.documentElement;
3276      root.insertBefore( form, root.firstChild );
3277  
3278      // The workaround has to do additional checks after a getElementById

3279      // Which slows things down for other browsers (hence the branching)

3280      if ( document.getElementById( id ) ) {
3281          Expr.find.ID = function(match, context, isXML){
3282              if ( typeof context.getElementById !== "undefined" && !isXML ) {
3283                  var m = context.getElementById(match[1]);
3284                  return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
3285              }
3286          };
3287  
3288          Expr.filter.ID = function(elem, match){
3289              var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
3290              return elem.nodeType === 1 && node && node.nodeValue === match;
3291          };
3292      }
3293  
3294      root.removeChild( form );
3295      root = form = null; // release memory in IE

3296  })();
3297  
3298  (function(){
3299      // Check to see if the browser returns only elements

3300      // when doing getElementsByTagName("*")

3301  
3302      // Create a fake element

3303      var div = document.createElement("div");
3304      div.appendChild( document.createComment("") );
3305  
3306      // Make sure no comments are found

3307      if ( div.getElementsByTagName("*").length > 0 ) {
3308          Expr.find.TAG = function(match, context){
3309              var results = context.getElementsByTagName(match[1]);
3310  
3311              // Filter out possible comments

3312              if ( match[1] === "*" ) {
3313                  var tmp = [];
3314  
3315                  for ( var i = 0; results[i]; i++ ) {
3316                      if ( results[i].nodeType === 1 ) {
3317                          tmp.push( results[i] );
3318                      }
3319                  }
3320  
3321                  results = tmp;
3322              }
3323  
3324              return results;
3325          };
3326      }
3327  
3328      // Check to see if an attribute returns normalized href attributes

3329      div.innerHTML = "<a href='#'></a>";
3330      if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
3331              div.firstChild.getAttribute("href") !== "#" ) {
3332          Expr.attrHandle.href = function(elem){
3333              return elem.getAttribute("href", 2);
3334          };
3335      }
3336  
3337      div = null; // release memory in IE

3338  })();
3339  
3340  if ( document.querySelectorAll ) {
3341      (function(){
3342          var oldSizzle = Sizzle, div = document.createElement("div");
3343          div.innerHTML = "<p class='TEST'></p>";
3344  
3345          // Safari can't handle uppercase or unicode characters when

3346          // in quirks mode.

3347          if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
3348              return;
3349          }
3350      
3351          Sizzle = function(query, context, extra, seed){
3352              context = context || document;
3353  
3354              // Only use querySelectorAll on non-XML documents

3355              // (ID selectors don't work in non-HTML documents)

3356              if ( !seed && context.nodeType === 9 && !isXML(context) ) {
3357                  try {
3358                      return makeArray( context.querySelectorAll(query), extra );
3359                  } catch(e){}
3360              }
3361          
3362              return oldSizzle(query, context, extra, seed);
3363          };
3364  
3365          for ( var prop in oldSizzle ) {
3366              Sizzle[ prop ] = oldSizzle[ prop ];
3367          }
3368  
3369          div = null; // release memory in IE

3370      })();
3371  }
3372  
3373  (function(){
3374      var div = document.createElement("div");
3375  
3376      div.innerHTML = "<div class='test e'></div><div class='test'></div>";
3377  
3378      // Opera can't find a second classname (in 9.6)

3379      // Also, make sure that getElementsByClassName actually exists

3380      if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
3381          return;
3382      }
3383  
3384      // Safari caches class attributes, doesn't catch changes (in 3.2)

3385      div.lastChild.className = "e";
3386  
3387      if ( div.getElementsByClassName("e").length === 1 ) {
3388          return;
3389      }
3390      
3391      Expr.order.splice(1, 0, "CLASS");
3392      Expr.find.CLASS = function(match, context, isXML) {
3393          if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
3394              return context.getElementsByClassName(match[1]);
3395          }
3396      };
3397  
3398      div = null; // release memory in IE

3399  })();
3400  
3401  function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3402      for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3403          var elem = checkSet[i];
3404          if ( elem ) {
3405              elem = elem[dir];
3406              var match = false;
3407  
3408              while ( elem ) {
3409                  if ( elem.sizcache === doneName ) {
3410                      match = checkSet[elem.sizset];
3411                      break;
3412                  }
3413  
3414                  if ( elem.nodeType === 1 && !isXML ){
3415                      elem.sizcache = doneName;
3416                      elem.sizset = i;
3417                  }
3418  
3419                  if ( elem.nodeName.toLowerCase() === cur ) {
3420                      match = elem;
3421                      break;
3422                  }
3423  
3424                  elem = elem[dir];
3425              }
3426  
3427              checkSet[i] = match;
3428          }
3429      }
3430  }
3431  
3432  function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3433      for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3434          var elem = checkSet[i];
3435          if ( elem ) {
3436              elem = elem[dir];
3437              var match = false;
3438  
3439              while ( elem ) {
3440                  if ( elem.sizcache === doneName ) {
3441                      match = checkSet[elem.sizset];
3442                      break;
3443                  }
3444  
3445                  if ( elem.nodeType === 1 ) {
3446                      if ( !isXML ) {
3447                          elem.sizcache = doneName;
3448                          elem.sizset = i;
3449                      }
3450                      if ( typeof cur !== "string" ) {
3451                          if ( elem === cur ) {
3452                              match = true;
3453                              break;
3454                          }
3455  
3456                      } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
3457                          match = elem;
3458                          break;
3459                      }
3460                  }
3461  
3462                  elem = elem[dir];
3463              }
3464  
3465              checkSet[i] = match;
3466          }
3467      }
3468  }
3469  
3470  var contains = document.compareDocumentPosition ? function(a, b){
3471      return a.compareDocumentPosition(b) & 16;
3472  } : function(a, b){
3473      return a !== b && (a.contains ? a.contains(b) : true);
3474  };
3475  
3476  var isXML = function(elem){
3477      // documentElement is verified for cases where it doesn't yet exist

3478      // (such as loading iframes in IE - #4833) 

3479      var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
3480      return documentElement ? documentElement.nodeName !== "HTML" : false;
3481  };
3482  
3483  var posProcess = function(selector, context){
3484      var tmpSet = [], later = "", match,
3485          root = context.nodeType ? [context] : context;
3486  
3487      // Position selectors must be done after the filter

3488      // And so must :not(positional) so we move all PSEUDOs to the end

3489      while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
3490          later += match[0];
3491          selector = selector.replace( Expr.match.PSEUDO, "" );
3492      }
3493  
3494      selector = Expr.relative[selector] ? selector + "*" : selector;
3495  
3496      for ( var i = 0, l = root.length; i < l; i++ ) {
3497          Sizzle( selector, root[i], tmpSet );
3498      }
3499  
3500      return Sizzle.filter( later, tmpSet );
3501  };
3502  
3503  // EXPOSE

3504  jQuery.find = Sizzle;
3505  jQuery.expr = Sizzle.selectors;
3506  jQuery.expr[":"] = jQuery.expr.filters;
3507  jQuery.unique = Sizzle.uniqueSort;
3508  jQuery.getText = getText;
3509  jQuery.isXMLDoc = isXML;
3510  jQuery.contains = contains;
3511  
3512  return;
3513  
3514  window.Sizzle = Sizzle;
3515  
3516  })();
3517  var runtil = /Until$/,
3518      rparentsprev = /^(?:parents|prevUntil|prevAll)/,
3519      // Note: This RegExp should be improved, or likely pulled from Sizzle

3520      rmultiselector = /,/,
3521      slice = Array.prototype.slice;
3522  
3523  // Implement the identical functionality for filter and not

3524  var winnow = function( elements, qualifier, keep ) {
3525      if ( jQuery.isFunction( qualifier ) ) {
3526          return jQuery.grep(elements, function( elem, i ) {
3527              return !!qualifier.call( elem, i, elem ) === keep;
3528          });
3529  
3530      } else if ( qualifier.nodeType ) {
3531          return jQuery.grep(elements, function( elem, i ) {
3532              return (elem === qualifier) === keep;
3533          });
3534  
3535      } else if ( typeof qualifier === "string" ) {
3536          var filtered = jQuery.grep(elements, function( elem ) {
3537              return elem.nodeType === 1;
3538          });
3539  
3540          if ( isSimple.test( qualifier ) ) {
3541              return jQuery.filter(qualifier, filtered, !keep);
3542          } else {
3543              qualifier = jQuery.filter( qualifier, elements );
3544          }
3545      }
3546  
3547      return jQuery.grep(elements, function( elem, i ) {
3548          return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
3549      });
3550  };
3551  
3552  jQuery.fn.extend({
3553      find: function( selector ) {
3554          var ret = this.pushStack( "", "find", selector ), length = 0;
3555  
3556          for ( var i = 0, l = this.length; i < l; i++ ) {
3557              length = ret.length;
3558              jQuery.find( selector, this[i], ret );
3559  
3560              if ( i > 0 ) {
3561                  // Make sure that the results are unique

3562                  for ( var n = length; n < ret.length; n++ ) {
3563                      for ( var r = 0; r < length; r++ ) {
3564                          if ( ret[r] === ret[n] ) {
3565                              ret.splice(n--, 1);
3566                              break;
3567                          }
3568                      }
3569                  }
3570              }
3571          }
3572  
3573          return ret;
3574      },
3575  
3576      has: function( target ) {
3577          var targets = jQuery( target );
3578          return this.filter(function() {
3579              for ( var i = 0, l = targets.length; i < l; i++ ) {
3580                  if ( jQuery.contains( this, targets[i] ) ) {
3581                      return true;
3582                  }
3583              }
3584          });
3585      },
3586  
3587      not: function( selector ) {
3588          return this.pushStack( winnow(this, selector, false), "not", selector);
3589      },
3590  
3591      filter: function( selector ) {
3592          return this.pushStack( winnow(this, selector, true), "filter", selector );
3593      },
3594      
3595      is: function( selector ) {
3596          return !!selector && jQuery.filter( selector, this ).length > 0;
3597      },
3598  
3599      closest: function( selectors, context ) {
3600          if ( jQuery.isArray( selectors ) ) {
3601              var ret = [], cur = this[0], match, matches = {}, selector;
3602  
3603              if ( cur && selectors.length ) {
3604                  for ( var i = 0, l = selectors.length; i < l; i++ ) {
3605                      selector = selectors[i];
3606  
3607                      if ( !matches[selector] ) {
3608                          matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
3609                              jQuery( selector, context || this.context ) :
3610                              selector;
3611                      }
3612                  }
3613  
3614                  while ( cur && cur.ownerDocument && cur !== context ) {
3615                      for ( selector in matches ) {
3616                          match = matches[selector];
3617  
3618                          if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
3619                              ret.push({ selector: selector, elem: cur });
3620                              delete matches[selector];
3621                          }
3622                      }
3623                      cur = cur.parentNode;
3624                  }
3625              }
3626  
3627              return ret;
3628          }
3629  
3630          var pos = jQuery.expr.match.POS.test( selectors ) ? 
3631              jQuery( selectors, context || this.context ) : null;
3632  
3633          return this.map(function( i, cur ) {
3634              while ( cur && cur.ownerDocument && cur !== context ) {
3635                  if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selectors) ) {
3636                      return cur;
3637                  }
3638                  cur = cur.parentNode;
3639              }
3640              return null;
3641          });
3642      },
3643      
3644      // Determine the position of an element within

3645      // the matched set of elements

3646      index: function( elem ) {
3647          if ( !elem || typeof elem === "string" ) {
3648              return jQuery.inArray( this[0],
3649                  // If it receives a string, the selector is used

3650                  // If it receives nothing, the siblings are used

3651                  elem ? jQuery( elem ) : this.parent().children() );
3652          }
3653          // Locate the position of the desired element

3654          return jQuery.inArray(
3655              // If it receives a jQuery object, the first element is used

3656              elem.jquery ? elem[0] : elem, this );
3657      },
3658  
3659      add: function( selector, context ) {
3660          var set = typeof selector === "string" ?
3661                  jQuery( selector, context || this.context ) :
3662                  jQuery.makeArray( selector ),
3663              all = jQuery.merge( this.get(), set );
3664  
3665          return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
3666              all :
3667              jQuery.unique( all ) );
3668      },
3669  
3670      andSelf: function() {
3671          return this.add( this.prevObject );
3672      }
3673  });
3674  
3675  // A painfully simple check to see if an element is disconnected

3676  // from a document (should be improved, where feasible).

3677  function isDisconnected( node ) {
3678      return !node || !node.parentNode || node.parentNode.nodeType === 11;
3679  }
3680  
3681  jQuery.each({
3682      parent: function( elem ) {
3683          var parent = elem.parentNode;
3684          return parent && parent.nodeType !== 11 ? parent : null;
3685      },
3686      parents: function( elem ) {
3687          return jQuery.dir( elem, "parentNode" );
3688      },
3689      parentsUntil: function( elem, i, until ) {
3690          return jQuery.dir( elem, "parentNode", until );
3691      },
3692      next: function( elem ) {
3693          return jQuery.nth( elem, 2, "nextSibling" );
3694      },
3695      prev: function( elem ) {
3696          return jQuery.nth( elem, 2, "previousSibling" );
3697      },
3698      nextAll: function( elem ) {
3699          return jQuery.dir( elem, "nextSibling" );
3700      },
3701      prevAll: function( elem ) {
3702          return jQuery.dir( elem, "previousSibling" );
3703      },
3704      nextUntil: function( elem, i, until ) {
3705          return jQuery.dir( elem, "nextSibling", until );
3706      },
3707      prevUntil: function( elem, i, until ) {
3708          return jQuery.dir( elem, "previousSibling", until );
3709      },
3710      siblings: function( elem ) {
3711          return jQuery.sibling( elem.parentNode.firstChild, elem );
3712      },
3713      children: function( elem ) {
3714          return jQuery.sibling( elem.firstChild );
3715      },
3716      contents: function( elem ) {
3717          return jQuery.nodeName( elem, "iframe" ) ?
3718              elem.contentDocument || elem.contentWindow.document :
3719              jQuery.makeArray( elem.childNodes );
3720      }
3721  }, function( name, fn ) {
3722      jQuery.fn[ name ] = function( until, selector ) {
3723          var ret = jQuery.map( this, fn, until );
3724          
3725          if ( !runtil.test( name ) ) {
3726              selector = until;
3727          }
3728  
3729          if ( selector && typeof selector === "string" ) {
3730              ret = jQuery.filter( selector, ret );
3731          }
3732  
3733          ret = this.length > 1 ? jQuery.unique( ret ) : ret;
3734  
3735          if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
3736              ret = ret.reverse();
3737          }
3738  
3739          return this.pushStack( ret, name, slice.call(arguments).join(",") );
3740      };
3741  });
3742  
3743  jQuery.extend({
3744      filter: function( expr, elems, not ) {
3745          if ( not ) {
3746              expr = ":not(" + expr + ")";
3747          }
3748  
3749          return jQuery.find.matches(expr, elems);
3750      },
3751      
3752      dir: function( elem, dir, until ) {
3753          var matched = [], cur = elem[dir];
3754          while ( cur && cur.nodeType !== 9 && (until === undefined || !jQuery( cur ).is( until )) ) {
3755              if ( cur.nodeType === 1 ) {
3756                  matched.push( cur );
3757              }
3758              cur = cur[dir];
3759          }
3760          return matched;
3761      },
3762  
3763      nth: function( cur, result, dir, elem ) {
3764          result = result || 1;
3765          var num = 0;
3766  
3767          for ( ; cur; cur = cur[dir] ) {
3768              if ( cur.nodeType === 1 && ++num === result ) {
3769                  break;
3770              }
3771          }
3772  
3773          return cur;
3774      },
3775  
3776      sibling: function( n, elem ) {
3777          var r = [];
3778  
3779          for ( ; n; n = n.nextSibling ) {
3780              if ( n.nodeType === 1 && n !== elem ) {
3781                  r.push( n );
3782              }
3783          }
3784  
3785          return r;
3786      }
3787  });
3788  var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
3789      rleadingWhitespace = /^\s+/,
3790      rxhtmlTag = /(<([\w:]+)[^>]*?)\/>/g,
3791      rselfClosing = /^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,
3792      rtagName = /<([\w:]+)/,
3793      rtbody = /<tbody/i,
3794      rhtml = /<|&\w+;/,
3795      fcloseTag = function( all, front, tag ) {
3796          return rselfClosing.test( tag ) ?
3797              all :
3798              front + "></" + tag + ">";
3799      },
3800      wrapMap = {
3801          option: [ 1, "<select multiple='multiple'>", "</select>" ],
3802          legend: [ 1, "<fieldset>", "</fieldset>" ],
3803          thead: [ 1, "<table>", "</table>" ],
3804          tr: [ 2, "<table><tbody>", "</tbody></table>" ],
3805          td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
3806          col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
3807          area: [ 1, "<map>", "</map>" ],
3808          _default: [ 0, "", "" ]
3809      };
3810  
3811  wrapMap.optgroup = wrapMap.option;
3812  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
3813  wrapMap.th = wrapMap.td;
3814  
3815  // IE can't serialize <link> and <script> tags normally

3816  if ( !jQuery.support.htmlSerialize ) {
3817      wrapMap._default = [ 1, "div<div>", "</div>" ];
3818  }
3819  
3820  jQuery.fn.extend({
3821      text: function( text ) {
3822          if ( jQuery.isFunction(text) ) {
3823              return this.each(function(i) {
3824                  var self = jQuery(this);
3825                  return self.text( text.call(this, i, self.text()) );
3826              });
3827          }
3828  
3829          if ( typeof text !== "object" && text !== undefined ) {
3830              return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
3831          }
3832  
3833          return jQuery.getText( this );
3834      },
3835  
3836      wrapAll: function( html ) {
3837          if ( jQuery.isFunction( html ) ) {
3838              return this.each(function(i) {
3839                  jQuery(this).wrapAll( html.call(this, i) );
3840              });
3841          }
3842  
3843          if ( this[0] ) {
3844              // The elements to wrap the target around

3845              var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
3846  
3847              if ( this[0].parentNode ) {
3848                  wrap.insertBefore( this[0] );
3849              }
3850  
3851              wrap.map(function() {
3852                  var elem = this;
3853  
3854                  while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
3855                      elem = elem.firstChild;
3856                  }
3857  
3858                  return elem;
3859              }).append(this);
3860          }
3861  
3862          return this;
3863      },
3864  
3865      wrapInner: function( html ) {
3866          return this.each(function() {
3867              var self = jQuery( this ), contents = self.contents();
3868  
3869              if ( contents.length ) {
3870                  contents.wrapAll( html );
3871  
3872              } else {
3873                  self.append( html );
3874              }
3875          });
3876      },
3877  
3878      wrap: function( html ) {
3879          return this.each(function() {
3880              jQuery( this ).wrapAll( html );
3881          });
3882      },
3883  
3884      unwrap: function() {
3885          return this.parent().each(function() {
3886              if ( !jQuery.nodeName( this, "body" ) ) {
3887                  jQuery( this ).replaceWith( this.childNodes );
3888              }
3889          }).end();
3890      },
3891  
3892      append: function() {
3893          return this.domManip(arguments, true, function( elem ) {
3894              if ( this.nodeType === 1 ) {
3895                  this.appendChild( elem );
3896              }
3897          });
3898      },
3899  
3900      prepend: function() {
3901          return this.domManip(arguments, true, function( elem ) {
3902              if ( this.nodeType === 1 ) {
3903                  this.insertBefore( elem, this.firstChild );
3904              }
3905          });
3906      },
3907  
3908      before: function() {
3909          if ( this[0] && this[0].parentNode ) {
3910              return this.domManip(arguments, false, function( elem ) {
3911                  this.parentNode.insertBefore( elem, this );
3912              });
3913          } else if ( arguments.length ) {
3914              var set = jQuery(arguments[0]);
3915              set.push.apply( set, this.toArray() );
3916              return this.pushStack( set, "before", arguments );
3917          }
3918      },
3919  
3920      after: function() {
3921          if ( this[0] && this[0].parentNode ) {
3922              return this.domManip(arguments, false, function( elem ) {
3923                  this.parentNode.insertBefore( elem, this.nextSibling );
3924              });
3925          } else if ( arguments.length ) {
3926              var set = this.pushStack( this, "after", arguments );
3927              set.push.apply( set, jQuery(arguments[0]).toArray() );
3928              return set;
3929          }
3930      },
3931  
3932      clone: function( events ) {
3933          // Do the clone

3934          var ret = this.map(function() {
3935              if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
3936                  // IE copies events bound via attachEvent when

3937                  // using cloneNode. Calling detachEvent on the

3938                  // clone will also remove the events from the orignal

3939                  // In order to get around this, we use innerHTML.

3940                  // Unfortunately, this means some modifications to

3941                  // attributes in IE that are actually only stored

3942                  // as properties will not be copied (such as the

3943                  // the name attribute on an input).

3944                  var html = this.outerHTML, ownerDocument = this.ownerDocument;
3945                  if ( !html ) {
3946                      var div = ownerDocument.createElement("div");
3947                      div.appendChild( this.cloneNode(true) );
3948                      html = div.innerHTML;
3949                  }
3950  
3951                  return jQuery.clean([html.replace(rinlinejQuery, "")
3952                      .replace(rleadingWhitespace, "")], ownerDocument)[0];
3953              } else {
3954                  return this.cloneNode(true);
3955              }
3956          });
3957  
3958          // Copy the events from the original to the clone

3959          if ( events === true ) {
3960              cloneCopyEvent( this, ret );
3961              cloneCopyEvent( this.find("*"), ret.find("*") );
3962          }
3963  
3964          // Return the cloned set

3965          return ret;
3966      },
3967  
3968      html: function( value ) {
3969          if ( value === undefined ) {
3970              return this[0] && this[0].nodeType === 1 ?
3971                  this[0].innerHTML.replace(rinlinejQuery, "") :
3972                  null;
3973  
3974          // See if we can take a shortcut and just use innerHTML

3975          } else if ( typeof value === "string" && !/<script/i.test( value ) &&
3976              (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
3977              !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
3978  
3979              try {
3980                  for ( var i = 0, l = this.length; i < l; i++ ) {
3981                      // Remove element nodes and prevent memory leaks

3982                      if ( this[i].nodeType === 1 ) {
3983                          cleanData( this[i].getElementsByTagName("*") );
3984                          this[i].innerHTML = value;
3985                      }
3986                  }
3987  
3988              // If using innerHTML throws an exception, use the fallback method

3989              } catch(e) {
3990                  this.empty().append( value );
3991              }
3992  
3993          } else if ( jQuery.isFunction( value ) ) {
3994              this.each(function(i){
3995                  var self = jQuery(this), old = self.html();
3996                  self.empty().append(function(){
3997                      return value.call( this, i, old );
3998                  });
3999              });
4000  
4001          } else {
4002              this.empty().append( value );
4003          }
4004  
4005          return this;
4006      },
4007  
4008      replaceWith: function( value ) {
4009          if ( this[0] && this[0].parentNode ) {
4010              // Make sure that the elements are removed from the DOM before they are inserted

4011              // this can help fix replacing a parent with child elements

4012              if ( !jQuery.isFunction( value ) ) {
4013                  value = jQuery( value ).detach();
4014              }
4015  
4016              return this.each(function() {
4017                  var next = this.nextSibling, parent = this.parentNode;
4018  
4019                  jQuery(this).remove();
4020  
4021                  if ( next ) {
4022                      jQuery(next).before( value );
4023                  } else {
4024                      jQuery(parent).append( value );
4025                  }
4026              });
4027          } else {
4028              return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4029          }
4030      },
4031  
4032      detach: function( selector ) {
4033          return this.remove( selector, true );
4034      },
4035  
4036      domManip: function( args, table, callback ) {
4037          var results, first, value = args[0], scripts = [];
4038  
4039          if ( jQuery.isFunction(value) ) {
4040              return this.each(function(i) {
4041                  var self = jQuery(this);
4042                  args[0] = value.call(this, i, table ? self.html() : undefined);
4043                  return self.domManip( args, table, callback );
4044              });
4045          }
4046  
4047          if ( this[0] ) {
4048              // If we're in a fragment, just use that instead of building a new one

4049              if ( args[0] && args[0].parentNode && args[0].parentNode.nodeType === 11 ) {
4050                  results = { fragment: args[0].parentNode };
4051              } else {
4052                  results = buildFragment( args, this, scripts );
4053              }
4054  
4055              first = results.fragment.firstChild;
4056  
4057              if ( first ) {
4058                  table = table && jQuery.nodeName( first, "tr" );
4059  
4060                  for ( var i = 0, l = this.length; i < l; i++ ) {
4061                      callback.call(
4062                          table ?
4063                              root(this[i], first) :
4064                              this[i],
4065                          results.cacheable || this.length > 1 || i > 0 ?
4066                              results.fragment.cloneNode(true) :
4067                              results.fragment
4068                      );
4069                  }
4070              }
4071  
4072              if ( scripts ) {
4073                  jQuery.each( scripts, evalScript );
4074              }
4075          }
4076  
4077          return this;
4078  
4079  		function root( elem, cur ) {
4080              return jQuery.nodeName(elem, "table") ?
4081                  (elem.getElementsByTagName("tbody")[0] ||
4082                  elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4083                  elem;
4084          }
4085      }
4086  });
4087  
4088  function cloneCopyEvent(orig, ret) {
4089      var i = 0;
4090  
4091      ret.each(function() {
4092          if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
4093              return;
4094          }
4095  
4096          var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
4097  
4098          if ( events ) {
4099              delete curData.handle;
4100              curData.events = {};
4101  
4102              for ( var type in events ) {
4103                  for ( var handler in events[ type ] ) {
4104                      jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
4105                  }
4106              }
4107          }
4108      });
4109  }
4110  
4111  function buildFragment( args, nodes, scripts ) {
4112      var fragment, cacheable, cached, cacheresults, doc;
4113  
4114      if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && args[0].indexOf("<option") < 0 ) {
4115          cacheable = true;
4116          cacheresults = jQuery.fragments[ args[0] ];
4117          if ( cacheresults ) {
4118              if ( cacheresults !== 1 ) {
4119                  fragment = cacheresults;
4120              }
4121              cached = true;
4122          }
4123      }
4124  
4125      if ( !fragment ) {
4126          doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
4127          fragment = doc.createDocumentFragment();
4128          jQuery.clean( args, doc, fragment, scripts );
4129      }
4130  
4131      if ( cacheable ) {
4132          jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
4133      }
4134  
4135      return { fragment: fragment, cacheable: cacheable };
4136  }
4137  
4138  jQuery.fragments = {};
4139  
4140  jQuery.each({
4141      appendTo: "append",
4142      prependTo: "prepend",
4143      insertBefore: "before",
4144      insertAfter: "after",
4145      replaceAll: "replaceWith"
4146  }, function( name, original ) {
4147      jQuery.fn[ name ] = function( selector ) {
4148          var ret = [], insert = jQuery( selector );
4149  
4150          for ( var i = 0, l = insert.length; i < l; i++ ) {
4151              var elems = (i > 0 ? this.clone(true) : this).get();
4152              jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
4153              ret = ret.concat( elems );
4154          }
4155          return this.pushStack( ret, name, insert.selector );
4156      };
4157  });
4158  
4159  jQuery.each({
4160      // keepData is for internal use only--do not document

4161      remove: function( selector, keepData ) {
4162          if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
4163              if ( !keepData && this.nodeType === 1 ) {
4164                  cleanData( this.getElementsByTagName("*") );
4165                  cleanData( [ this ] );
4166              }
4167  
4168              if ( this.parentNode ) {
4169                   this.parentNode.removeChild( this );
4170              }
4171          }
4172      },
4173  
4174      empty: function() {
4175          // Remove element nodes and prevent memory leaks

4176          if ( this.nodeType === 1 ) {
4177              cleanData( this.getElementsByTagName("*") );
4178          }
4179  
4180          // Remove any remaining nodes

4181          while ( this.firstChild ) {
4182              this.removeChild( this.firstChild );
4183          }
4184      }
4185  }, function( name, fn ) {
4186      jQuery.fn[ name ] = function() {
4187          return this.each( fn, arguments );
4188      };
4189  });
4190  
4191  jQuery.extend({
4192      clean: function( elems, context, fragment, scripts ) {
4193          context = context || document;
4194  
4195          // !context.createElement fails in IE with an error but returns typeof 'object'

4196          if ( typeof context.createElement === "undefined" ) {
4197              context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
4198          }
4199  
4200          var ret = [];
4201  
4202          jQuery.each(elems, function( i, elem ) {
4203              if ( typeof elem === "number" ) {
4204                  elem += "";
4205              }
4206  
4207              if ( !elem ) {
4208                  return;
4209              }
4210  
4211              // Convert html string into DOM nodes

4212              if ( typeof elem === "string" && !rhtml.test( elem ) ) {
4213                  elem = context.createTextNode( elem );
4214  
4215              } else if ( typeof elem === "string" ) {
4216                  // Fix "XHTML"-style tags in all browsers

4217                  elem = elem.replace(rxhtmlTag, fcloseTag);
4218  
4219                  // Trim whitespace, otherwise indexOf won't work as expected

4220                  var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
4221                      wrap = wrapMap[ tag ] || wrapMap._default,
4222                      depth = wrap[0],
4223                      div = context.createElement("div");
4224  
4225                  // Go to html and back, then peel off extra wrappers

4226                  div.innerHTML = wrap[1] + elem + wrap[2];
4227  
4228                  // Move to the right depth

4229                  while ( depth-- ) {
4230                      div = div.lastChild;
4231                  }
4232  
4233                  // Remove IE's autoinserted <tbody> from table fragments

4234                  if ( !jQuery.support.tbody ) {
4235  
4236                      // String was a <table>, *may* have spurious <tbody>

4237                      var hasBody = rtbody.test(elem),
4238                          tbody = tag === "table" && !hasBody ?
4239                              div.firstChild && div.firstChild.childNodes :
4240  
4241                              // String was a bare <thead> or <tfoot>

4242                              wrap[1] === "<table>" && !hasBody ?
4243                                  div.childNodes :
4244                                  [];
4245  
4246                      for ( var j = tbody.length - 1; j >= 0 ; --j ) {
4247                          if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
4248                              tbody[ j ].parentNode.removeChild( tbody[ j ] );
4249                          }
4250                      }
4251  
4252                  }
4253  
4254                  // IE completely kills leading whitespace when innerHTML is used

4255                  if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
4256                      div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
4257                  }
4258  
4259                  elem = jQuery.makeArray( div.childNodes );
4260              }
4261  
4262              if ( elem.nodeType ) {
4263                  ret.push( elem );
4264              } else {
4265                  ret = jQuery.merge( ret, elem );
4266              }
4267  
4268          });
4269  
4270          if ( fragment ) {
4271              for ( var i = 0; ret[i]; i++ ) {
4272                  if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
4273                      scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
4274                  } else {
4275                      if ( ret[i].nodeType === 1 ) {
4276                          ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
4277                      }
4278                      fragment.appendChild( ret[i] );
4279                  }
4280              }
4281          }
4282  
4283          return ret;
4284      }
4285  });
4286  
4287  function cleanData( elems ) {
4288      for ( var i = 0, elem, id; (elem = elems[i]) != null; i++ ) {
4289          if ( !jQuery.noData[elem.nodeName.toLowerCase()] && (id = elem[expando]) ) {
4290              delete jQuery.cache[ id ];
4291          }
4292      }
4293  }
4294  // exclude the following css properties to add px

4295  var rexclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
4296      ralpha = /alpha\([^)]*\)/,
4297      ropacity = /opacity=([^)]*)/,
4298      rfloat = /float/i,
4299      rdashAlpha = /-([a-z])/ig,
4300      rupper = /([A-Z])/g,
4301      rnumpx = /^-?\d+(?:px)?$/i,
4302      rnum = /^-?\d/,
4303  
4304      cssShow = { position: "absolute", visibility: "hidden", display:"block" },
4305      cssWidth = [ "Left", "Right" ],
4306      cssHeight = [ "Top", "Bottom" ],
4307  
4308      // cache check for defaultView.getComputedStyle

4309      getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
4310      // normalize float css property

4311      styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat",
4312      fcamelCase = function( all, letter ) {
4313          return letter.toUpperCase();
4314      };
4315  
4316  jQuery.fn.css = function( name, value ) {
4317      return access( this, name, value, true, function( elem, name, value ) {
4318          if ( value === undefined ) {
4319              return jQuery.curCSS( elem, name );
4320          }
4321          
4322          if ( typeof value === "number" && !rexclude.test(name) ) {
4323              value += "px";
4324          }
4325  
4326          jQuery.style( elem, name, value );
4327      });
4328  };
4329  
4330  jQuery.extend({
4331      style: function( elem, name, value ) {
4332          // don't set styles on text and comment nodes

4333          if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
4334              return undefined;
4335          }
4336  
4337          // ignore negative width and height values #1599

4338          if ( (name === "width" || name === "height") && parseFloat(value) < 0 ) {
4339              value = undefined;
4340          }
4341  
4342          var style = elem.style || elem, set = value !== undefined;
4343  
4344          // IE uses filters for opacity

4345          if ( !jQuery.support.opacity && name === "opacity" ) {
4346              if ( set ) {
4347                  // IE has trouble with opacity if it does not have layout

4348                  // Force it by setting the zoom level

4349                  style.zoom = 1;
4350  
4351                  // Set the alpha filter to set the opacity

4352                  var opacity = parseInt( value, 10 ) + "" === "NaN" ? "" : "alpha(opacity=" + value * 100 + ")";
4353                  var filter = style.filter || jQuery.curCSS( elem, "filter" ) || "";
4354                  style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : opacity;
4355              }
4356  
4357              return style.filter && style.filter.indexOf("opacity=") >= 0 ?
4358                  (parseFloat( ropacity.exec(style.filter)[1] ) / 100) + "":
4359                  "";
4360          }
4361  
4362          // Make sure we're using the right name for getting the float value

4363          if ( rfloat.test( name ) ) {
4364              name = styleFloat;
4365          }
4366  
4367          name = name.replace(rdashAlpha, fcamelCase);
4368  
4369          if ( set ) {
4370              style[ name ] = value;
4371          }
4372  
4373          return style[ name ];
4374      },
4375  
4376      css: function( elem, name, force, extra ) {
4377          if ( name === "width" || name === "height" ) {
4378              var val, props = cssShow, which = name === "width" ? cssWidth : cssHeight;
4379  
4380  			function getWH() {
4381                  val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
4382  
4383                  if ( extra === "border" ) {
4384                      return;
4385                  }
4386  
4387                  jQuery.each( which, function() {
4388                      if ( !extra ) {
4389                          val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
4390                      }
4391  
4392                      if ( extra === "margin" ) {
4393                          val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
4394                      } else {
4395                          val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
4396                      }
4397                  });
4398              }
4399  
4400              if ( elem.offsetWidth !== 0 ) {
4401                  getWH();
4402              } else {
4403                  jQuery.swap( elem, props, getWH );
4404              }
4405  
4406              return Math.max(0, Math.round(val));
4407          }
4408  
4409          return jQuery.curCSS( elem, name, force );
4410      },
4411  
4412      curCSS: function( elem, name, force ) {
4413          var ret, style = elem.style, filter;
4414  
4415          // IE uses filters for opacity

4416          if ( !jQuery.support.opacity && name === "opacity" && elem.currentStyle ) {
4417              ret = ropacity.test(elem.currentStyle.filter || "") ?
4418                  (parseFloat(RegExp.$1) / 100) + "" :
4419                  "";
4420  
4421              return ret === "" ?
4422                  "1" :
4423                  ret;
4424          }
4425  
4426          // Make sure we're using the right name for getting the float value

4427          if ( rfloat.test( name ) ) {
4428              name = styleFloat;
4429          }
4430  
4431          if ( !force && style && style[ name ] ) {
4432              ret = style[ name ];
4433  
4434          } else if ( getComputedStyle ) {
4435  
4436              // Only "float" is needed here

4437              if ( rfloat.test( name ) ) {
4438                  name = "float";
4439              }
4440  
4441              name = name.replace( rupper, "-$1" ).toLowerCase();
4442  
4443              var defaultView = elem.ownerDocument.defaultView;
4444  
4445              if ( !defaultView ) {
4446                  return null;
4447              }
4448  
4449              var computedStyle = defaultView.getComputedStyle( elem, null );
4450  
4451              if ( computedStyle ) {
4452                  ret = computedStyle.getPropertyValue( name );
4453              }
4454  
4455              // We should always get a number back from opacity

4456              if ( name === "opacity" && ret === "" ) {
4457                  ret = "1";
4458              }
4459  
4460          } else if ( elem.currentStyle ) {
4461              var camelCase = name.replace(rdashAlpha, fcamelCase);
4462  
4463              ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
4464  
4465              // From the awesome hack by Dean Edwards

4466              // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

4467  
4468              // If we're not dealing with a regular pixel number

4469              // but a number that has a weird ending, we need to convert it to pixels

4470              if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
4471                  // Remember the original values

4472                  var left = style.left, rsLeft = elem.runtimeStyle.left;
4473  
4474                  // Put in the new values to get a computed value out

4475                  elem.runtimeStyle.left = elem.currentStyle.left;
4476                  style.left = camelCase === "fontSize" ? "1em" : (ret || 0);
4477                  ret = style.pixelLeft + "px";
4478  
4479                  // Revert the changed values

4480                  style.left = left;
4481                  elem.runtimeStyle.left = rsLeft;
4482              }
4483          }
4484  
4485          return ret;
4486      },
4487  
4488      // A method for quickly swapping in/out CSS properties to get correct calculations

4489      swap: function( elem, options, callback ) {
4490          var old = {};
4491  
4492          // Remember the old values, and insert the new ones

4493          for ( var name in options ) {
4494              old[ name ] = elem.style[ name ];
4495              elem.style[ name ] = options[ name ];
4496          }
4497  
4498          callback.call( elem );
4499  
4500          // Revert the old values

4501          for ( var name in options ) {
4502              elem.style[ name ] = old[ name ];
4503          }
4504      }
4505  });
4506  
4507  if ( jQuery.expr && jQuery.expr.filters ) {
4508      jQuery.expr.filters.hidden = function( elem ) {
4509          var width = elem.offsetWidth, height = elem.offsetHeight,
4510              skip = elem.nodeName.toLowerCase() === "tr";
4511  
4512          return width === 0 && height === 0 && !skip ?
4513              true :
4514              width > 0 && height > 0 && !skip ?
4515                  false :
4516                  jQuery.curCSS(elem, "display") === "none";
4517      };
4518  
4519      jQuery.expr.filters.visible = function( elem ) {
4520          return !jQuery.expr.filters.hidden( elem );
4521      };
4522  }
4523  var jsc = now(),
4524      rscript = /<script(.|\s)*?\/script>/gi,
4525      rselectTextarea = /select|textarea/i,
4526      rinput = /color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,
4527      jsre = /=\?(&|$)/,
4528      rquery = /\?/,
4529      rts = /(\?|&)_=.*?(&|$)/,
4530      rurl = /^(\w+:)?\/\/([^\/?#]+)/,
4531      r20 = /%20/g;
4532  
4533  jQuery.fn.extend({
4534      // Keep a copy of the old load

4535      _load: jQuery.fn.load,
4536  
4537      load: function( url, params, callback ) {
4538          if ( typeof url !== "string" ) {
4539              return this._load( url );
4540  
4541          // Don't do a request if no elements are being requested

4542          } else if ( !this.length ) {
4543              return this;
4544          }
4545  
4546          var off = url.indexOf(" ");
4547          if ( off >= 0 ) {
4548              var selector = url.slice(off, url.length);
4549              url = url.slice(0, off);
4550          }
4551  
4552          // Default to a GET request

4553          var type = "GET";
4554  
4555          // If the second parameter was provided

4556          if ( params ) {
4557              // If it's a function

4558              if ( jQuery.isFunction( params ) ) {
4559                  // We assume that it's the callback

4560                  callback = params;
4561                  params = null;
4562  
4563              // Otherwise, build a param string

4564              } else if ( typeof params === "object" ) {
4565                  params = jQuery.param( params, jQuery.ajaxSettings.traditional );
4566                  type = "POST";
4567              }
4568          }
4569  
4570          // Request the remote document

4571          jQuery.ajax({
4572              url: url,
4573              type: type,
4574              dataType: "html",
4575              data: params,
4576              context:this,
4577              complete: function( res, status ) {
4578                  // If successful, inject the HTML into all the matched elements

4579                  if ( status === "success" || status === "notmodified" ) {
4580                      // See if a selector was specified

4581                      this.html( selector ?
4582                          // Create a dummy div to hold the results

4583                          jQuery("<div />")
4584                              // inject the contents of the document in, removing the scripts

4585                              // to avoid any 'Permission Denied' errors in IE

4586                              .append(res.responseText.replace(rscript, ""))
4587  
4588                              // Locate the specified elements

4589                              .find(selector) :
4590  
4591                          // If not, just inject the full result

4592                          res.responseText );
4593                  }
4594  
4595                  if ( callback ) {
4596                      this.each( callback, [res.responseText, status, res] );
4597                  }
4598              }
4599          });
4600  
4601          return this;
4602      },
4603  
4604      serialize: function() {
4605          return jQuery.param(this.serializeArray());
4606      },
4607      serializeArray: function() {
4608          return this.map(function() {
4609              return this.elements ? jQuery.makeArray(this.elements) : this;
4610          })
4611          .filter(function() {
4612              return this.name && !this.disabled &&
4613                  (this.checked || rselectTextarea.test(this.nodeName) ||
4614                      rinput.test(this.type));
4615          })
4616          .map(function( i, elem ) {
4617              var val = jQuery(this).val();
4618  
4619              return val == null ?
4620                  null :
4621                  jQuery.isArray(val) ?
4622                      jQuery.map( val, function( val, i ) {
4623                          return { name: elem.name, value: val };
4624                      }) :
4625                      { name: elem.name, value: val };
4626          }).get();
4627      }
4628  });
4629  
4630  // Attach a bunch of functions for handling common AJAX events

4631  jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
4632      jQuery.fn[o] = function( f ) {
4633          return this.bind(o, f);
4634      };
4635  });
4636  
4637  jQuery.extend({
4638  
4639      get: function( url, data, callback, type ) {
4640          // shift arguments if data argument was omited

4641          if ( jQuery.isFunction( data ) ) {
4642              type = type || callback;
4643              callback = data;
4644              data = null;
4645          }
4646  
4647          return jQuery.ajax({
4648              type: "GET",
4649              url: url,
4650              data: data,
4651              success: callback,
4652              dataType: type
4653          });
4654      },
4655  
4656      getScript: function( url, callback ) {
4657          return jQuery.get(url, null, callback, "script");
4658      },
4659  
4660      getJSON: function( url, data, callback ) {
4661          return jQuery.get(url, data, callback, "json");
4662      },
4663  
4664      post: function( url, data, callback, type ) {
4665          // shift arguments if data argument was omited

4666          if ( jQuery.isFunction( data ) ) {
4667              type = type || callback;
4668              callback = data;
4669              data = {};
4670          }
4671  
4672          return jQuery.ajax({
4673              type: "POST",
4674              url: url,
4675              data: data,
4676              success: callback,
4677              dataType: type
4678          });
4679      },
4680  
4681      ajaxSetup: function( settings ) {
4682          jQuery.extend( jQuery.ajaxSettings, settings );
4683      },
4684  
4685      ajaxSettings: {
4686          url: location.href,
4687          global: true,
4688          type: "GET",
4689          contentType: "application/x-www-form-urlencoded",
4690          processData: true,
4691          async: true,
4692          /*

4693          timeout: 0,

4694          data: null,

4695          username: null,

4696          password: null,

4697          traditional: false,

4698          */
4699          // Create the request object; Microsoft failed to properly

4700          // implement the XMLHttpRequest in IE7 (can't request local files),

4701          // so we use the ActiveXObject when it is available

4702          // This function can be overriden by calling jQuery.ajaxSetup

4703          xhr: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ?
4704              function() {
4705                  return new window.XMLHttpRequest();
4706              } :
4707              function() {
4708                  try {
4709                      return new window.ActiveXObject("Microsoft.XMLHTTP");
4710                  } catch(e) {}
4711              },
4712          accepts: {
4713              xml: "application/xml, text/xml",
4714              html: "text/html",
4715              script: "text/javascript, application/javascript",
4716              json: "application/json, text/javascript",
4717              text: "text/plain",
4718              _default: "*/*"

4719          }

4720      },

4721  

4722      // Last-Modified header cache for next request

4723      lastModified: {},

4724      etag: {},

4725  

4726      ajax: function( origSettings ) {

4727          var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings);

4728          

4729          var jsonp, status, data,

4730              callbackContext = s.context || s,

4731              type = s.type.toUpperCase();

4732  

4733          // convert data if not already a string

4734          if ( s.data && s.processData && typeof s.data !== "string" ) {

4735              s.data = jQuery.param( s.data, s.traditional );

4736          }

4737  

4738          // Handle JSONP Parameter Callbacks

4739          if ( s.dataType === "jsonp" ) {

4740              if ( type === "GET" ) {

4741                  if ( !jsre.test( s.url ) ) {

4742                      s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";

4743                  }

4744              } else if ( !s.data || !jsre.test(s.data) ) {

4745                  s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";

4746              }

4747              s.dataType = "json";

4748          }

4749  

4750          // Build temporary JSONP function

4751          if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {

4752              jsonp = s.jsonpCallback || ("jsonp" + jsc++);

4753  

4754              // Replace the =? sequence both in the query string and the data

4755              if ( s.data ) {

4756                  s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");

4757              }

4758  

4759              s.url = s.url.replace(jsre, "=" + jsonp + "$1");

4760  

4761              // We need to make sure

4762              // that a JSONP style response is executed properly

4763              s.dataType = "script";

4764  

4765              // Handle JSONP-style loading

4766              window[ jsonp ] = window[ jsonp ] || function( tmp ) {

4767                  data = tmp;

4768                  success();

4769                  complete();

4770                  // Garbage collect

4771                  window[ jsonp ] = undefined;

4772  

4773                  try {

4774                      delete window[ jsonp ];

4775                  } catch(e) {}

4776  

4777                  if ( head ) {

4778                      head.removeChild( script );

4779                  }

4780              };

4781          }

4782  

4783          if ( s.dataType === "script" && s.cache === null ) {

4784              s.cache = false;

4785          }

4786  

4787          if ( s.cache === false && type === "GET" ) {

4788              var ts = now();

4789  

4790              // try replacing _= if it is there

4791              var ret = s.url.replace(rts, "$1_=" + ts + "$2");

4792  

4793              // if nothing was replaced, add timestamp to the end

4794              s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");

4795          }

4796  

4797          // If data is available, append data to url for get requests

4798          if ( s.data && type === "GET" ) {

4799              s.url += (rquery.test(s.url) ? "&" : "?") + s.data;

4800          }

4801  

4802          // Watch for a new set of requests

4803          if ( s.global && ! jQuery.active++ ) {

4804              jQuery.event.trigger( "ajaxStart" );

4805          }

4806  

4807          // Matches an absolute URL, and saves the domain

4808          var parts = rurl.exec( s.url ),

4809              remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);

4810  

4811          // If we're requesting a remote document

4812          // and trying to load JSON or Script with a GET

4813          if ( s.dataType === "script" && type === "GET" && remote ) {

4814              var head = document.getElementsByTagName("head")[0] || document.documentElement;

4815              var script = document.createElement("script");

4816              script.src = s.url;

4817              if ( s.scriptCharset ) {

4818                  script.charset = s.scriptCharset;

4819              }

4820  

4821              // Handle Script loading

4822              if ( !jsonp ) {

4823                  var done = false;

4824  

4825                  // Attach handlers for all browsers

4826                  script.onload = script.onreadystatechange = function() {

4827                      if ( !done && (!this.readyState ||

4828                              this.readyState === "loaded" || this.readyState === "complete") ) {

4829                          done = true;

4830                          success();

4831                          complete();

4832  

4833                          // Handle memory leak in IE

4834                          script.onload = script.onreadystatechange = null;

4835                          if ( head && script.parentNode ) {

4836                              head.removeChild( script );

4837                          }

4838                      }

4839                  };

4840              }

4841  

4842              // Use insertBefore instead of appendChild  to circumvent an IE6 bug.

4843              // This arises when a base node is used (#2709 and #4378).

4844              head.insertBefore( script, head.firstChild );

4845  

4846              // We handle everything using the script element injection

4847              return undefined;

4848          }

4849  

4850          var requestDone = false;

4851  

4852          // Create the request object

4853          var xhr = s.xhr();

4854  

4855          if ( !xhr ) {

4856              return;

4857          }

4858  

4859          // Open the socket

4860          // Passing null username, generates a login popup on Opera (#2865)

4861          if ( s.username ) {

4862              xhr.open(type, s.url, s.async, s.username, s.password);

4863          } else {

4864              xhr.open(type, s.url, s.async);

4865          }

4866  

4867          // Need an extra try/catch for cross domain requests in Firefox 3

4868          try {

4869              // Set the correct header, if data is being sent

4870              if ( s.data || origSettings && origSettings.contentType ) {

4871                  xhr.setRequestHeader("Content-Type", s.contentType);

4872              }

4873  

4874              // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.

4875              if ( s.ifModified ) {

4876                  if ( jQuery.lastModified[s.url] ) {

4877                      xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);

4878                  }

4879  

4880                  if ( jQuery.etag[s.url] ) {

4881                      xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);

4882                  }

4883              }

4884  

4885              // Set header so the called script knows that it's an XMLHttpRequest

4886              // Only send the header if it's not a remote XHR

4887              if ( !remote ) {

4888                  xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");

4889              }

4890  

4891              // Set the Accepts header for the server, depending on the dataType

4892              xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?

4893                  s.accepts[ s.dataType ] + ", */*" :
4894                  s.accepts._default );
4895          } catch(e) {}
4896  
4897          // Allow custom headers/mimetypes and early abort

4898          if ( s.beforeSend && s.beforeSend.call(callbackContext, xhr, s) === false ) {
4899              // Handle the global AJAX counter

4900              if ( s.global && ! --jQuery.active ) {
4901                  jQuery.event.trigger( "ajaxStop" );
4902              }
4903  
4904              // close opended socket

4905              xhr.abort();
4906              return false;
4907          }
4908  
4909          if ( s.global ) {
4910              trigger("ajaxSend", [xhr, s]);
4911          }
4912  
4913          // Wait for a response to come back

4914          var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
4915              // The request was aborted

4916              if ( !xhr || xhr.readyState === 0 ) {
4917                  // Opera doesn't call onreadystatechange before this point

4918                  // so we simulate the call

4919                  if ( !requestDone ) {
4920                      complete();
4921                  }
4922  
4923                  requestDone = true;
4924                  if ( xhr ) {
4925                      xhr.onreadystatechange = jQuery.noop;
4926                  }
4927  
4928              // The transfer is complete and the data is available, or the request timed out

4929              } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
4930                  requestDone = true;
4931                  xhr.onreadystatechange = jQuery.noop;
4932  
4933                  status = isTimeout === "timeout" ?
4934                      "timeout" :
4935                      !jQuery.httpSuccess( xhr ) ?
4936                          "error" :
4937                          s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
4938                              "notmodified" :
4939                              "success";
4940  
4941                  if ( status === "success" ) {
4942                      // Watch for, and catch, XML document parse errors

4943                      try {
4944                          // process the data (runs the xml through httpData regardless of callback)

4945                          data = jQuery.httpData( xhr, s.dataType, s );
4946                      } catch(e) {
4947                          status = "parsererror";
4948                      }
4949                  }
4950  
4951                  // Make sure that the request was successful or notmodified

4952                  if ( status === "success" || status === "notmodified" ) {
4953                      // JSONP handles its own success callback

4954                      if ( !jsonp ) {
4955                          success();
4956                      }
4957                  } else {
4958                      jQuery.handleError(s, xhr, status);
4959                  }
4960  
4961                  // Fire the complete handlers

4962                  complete();
4963  
4964                  if ( isTimeout === "timeout" ) {
4965                      xhr.abort();
4966                  }
4967  
4968                  // Stop memory leaks

4969                  if ( s.async ) {
4970                      xhr = null;
4971                  }
4972              }
4973          };
4974  
4975          // Override the abort handler, if we can (IE doesn't allow it, but that's OK)

4976          // Opera doesn't fire onreadystatechange at all on abort

4977          try {
4978              var oldAbort = xhr.abort;
4979              xhr.abort = function() {
4980                  if ( xhr ) {
4981                      oldAbort.call( xhr );
4982                      if ( xhr ) {
4983                          xhr.readyState = 0;
4984                      }
4985                  }
4986  
4987                  onreadystatechange();
4988              };
4989          } catch(e) { }
4990  
4991          // Timeout checker

4992          if ( s.async && s.timeout > 0 ) {
4993              setTimeout(function() {
4994                  // Check to see if the request is still happening

4995                  if ( xhr && !requestDone ) {
4996                      onreadystatechange( "timeout" );
4997                  }
4998              }, s.timeout);
4999          }
5000  
5001          // Send the data

5002          try {
5003              xhr.send( type === "POST" || type === "PUT" || type === "DELETE" ? s.data : null );
5004          } catch(e) {
5005              jQuery.handleError(s, xhr, null, e);
5006              // Fire the complete handlers

5007              complete();
5008          }
5009  
5010          // firefox 1.5 doesn't fire statechange for sync requests

5011          if ( !s.async ) {
5012              onreadystatechange();
5013          }
5014  
5015  		function success() {
5016              // If a local callback was specified, fire it and pass it the data

5017              if ( s.success ) {
5018                  s.success.call( callbackContext, data, status, xhr );
5019              }
5020  
5021              // Fire the global callback

5022              if ( s.global ) {
5023                  trigger( "ajaxSuccess", [xhr, s] );
5024              }
5025          }
5026  
5027  		function complete() {
5028              // Process result

5029              if ( s.complete ) {
5030                  s.complete.call( callbackContext, xhr, status);
5031              }
5032  
5033              // The request was completed

5034              if ( s.global ) {
5035                  trigger( "ajaxComplete", [xhr, s] );
5036              }
5037  
5038              // Handle the global AJAX counter

5039              if ( s.global && ! --jQuery.active ) {
5040                  jQuery.event.trigger( "ajaxStop" );
5041              }
5042          }
5043          
5044  		function trigger(type, args) {
5045              (s.context ? jQuery(s.context) : jQuery.event).trigger(type, args);
5046          }
5047  
5048          // return XMLHttpRequest to allow aborting the request etc.

5049          return xhr;
5050      },
5051  
5052      handleError: function( s, xhr, status, e ) {
5053          // If a local callback was specified, fire it

5054          if ( s.error ) {
5055              s.error.call( s.context || window, xhr, status, e );
5056          }
5057  
5058          // Fire the global callback

5059          if ( s.global ) {
5060              (s.context ? jQuery(s.context) : jQuery.event).trigger( "ajaxError", [xhr, s, e] );
5061          }
5062      },
5063  
5064      // Counter for holding the number of active queries

5065      active: 0,
5066  
5067      // Determines if an XMLHttpRequest was successful or not

5068      httpSuccess: function( xhr ) {
5069          try {
5070              // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450

5071              return !xhr.status && location.protocol === "file:" ||
5072                  // Opera returns 0 when status is 304

5073                  ( xhr.status >= 200 && xhr.status < 300 ) ||
5074                  xhr.status === 304 || xhr.status === 1223 || xhr.status === 0;
5075          } catch(e) {}
5076  
5077          return false;
5078      },
5079  
5080      // Determines if an XMLHttpRequest returns NotModified

5081      httpNotModified: function( xhr, url ) {
5082          var lastModified = xhr.getResponseHeader("Last-Modified"),
5083              etag = xhr.getResponseHeader("Etag");
5084  
5085          if ( lastModified ) {
5086              jQuery.lastModified[url] = lastModified;
5087          }
5088  
5089          if ( etag ) {
5090              jQuery.etag[url] = etag;
5091          }
5092  
5093          // Opera returns 0 when status is 304

5094          return xhr.status === 304 || xhr.status === 0;
5095      },
5096  
5097      httpData: function( xhr, type, s ) {
5098          var ct = xhr.getResponseHeader("content-type") || "",
5099              xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
5100              data = xml ? xhr.responseXML : xhr.responseText;
5101  
5102          if ( xml && data.documentElement.nodeName === "parsererror" ) {
5103              throw "parsererror";
5104          }
5105  
5106          // Allow a pre-filtering function to sanitize the response

5107          // s is checked to keep backwards compatibility

5108          if ( s && s.dataFilter ) {
5109              data = s.dataFilter( data, type );
5110          }
5111  
5112          // The filter can actually parse the response

5113          if ( typeof data === "string" ) {
5114              // Get the JavaScript object, if JSON is used.

5115              if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
5116                  // Make sure the incoming data is actual JSON

5117                  // Logic borrowed from http://json.org/json2.js

5118                  if (/^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
5119                      .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]")
5120                      .replace(/(?:^|:|,)(?:\s*\[)+/g, ""))) {
5121  
5122                      // Try to use the native JSON parser first

5123                      if ( window.JSON && window.JSON.parse ) {
5124                          data = window.JSON.parse( data );
5125  
5126                      } else {
5127                          data = (new Function("return " + data))();
5128                      }
5129  
5130                  } else {
5131                      throw "Invalid JSON: " + data;
5132                  }
5133  
5134              // If the type is "script", eval it in global context

5135              } else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
5136                  jQuery.globalEval( data );
5137              }
5138          }
5139  
5140          return data;
5141      },
5142  
5143      // Serialize an array of form elements or a set of

5144      // key/values into a query string

5145      param: function( a, traditional ) {
5146          
5147          var s = [];
5148          
5149          // Set traditional to true for jQuery <= 1.3.2 behavior.

5150          if ( traditional === undefined ) {
5151              traditional = jQuery.ajaxSettings.traditional;
5152          }
5153          
5154  		function add( key, value ) {
5155              // If value is a function, invoke it and return its value

5156              value = jQuery.isFunction(value) ? value() : value;
5157              s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
5158          }
5159          
5160          // If an array was passed in, assume that it is an array of form elements.

5161          if ( jQuery.isArray(a) || a.jquery ) {
5162              // Serialize the form elements

5163              jQuery.each( a, function() {
5164                  add( this.name, this.value );
5165              });
5166              
5167          } else {
5168              // If traditional, encode the "old" way (the way 1.3.2 or older

5169              // did it), otherwise encode params recursively.

5170              jQuery.each( a, function buildParams( prefix, obj ) {
5171                  
5172                  if ( jQuery.isArray(obj) ) {
5173                      // Serialize array item.

5174                      jQuery.each( obj, function( i, v ) {
5175                          if ( traditional ) {
5176                              // Treat each array item as a scalar.

5177                              add( prefix, v );
5178                          } else {
5179                              // If array item is non-scalar (array or object), encode its

5180                              // numeric index to resolve deserialization ambiguity issues.

5181                              // Note that rack (as of 1.0.0) can't currently deserialize

5182                              // nested arrays properly, and attempting to do so may cause

5183                              // a server error. Possible fixes are to modify rack's

5184                              // deserialization algorithm or to provide an option or flag

5185                              // to force array serialization to be shallow.

5186                              buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v );
5187                          }
5188                      });
5189                      
5190                  } else if ( !traditional && obj != null && typeof obj === "object" ) {
5191                      // Serialize object item.

5192                      jQuery.each( obj, function( k, v ) {
5193                          buildParams( prefix + "[" + k + "]", v );
5194                      });
5195                      
5196                  } else {
5197                      // Serialize scalar item.

5198                      add( prefix, obj );
5199                  }
5200              });
5201          }
5202          
5203          // Return the resulting serialization

5204          return s.join("&").replace(r20, "+");
5205      }
5206  
5207  });
5208  var elemdisplay = {},
5209      rfxtypes = /toggle|show|hide/,
5210      rfxnum = /^([+-]=)?([\d+-.]+)(.*)$/,
5211      timerId,
5212      fxAttrs = [
5213          // height animations

5214          [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
5215          // width animations

5216          [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
5217          // opacity animations

5218          [ "opacity" ]
5219      ];
5220  
5221  jQuery.fn.extend({
5222      show: function( speed, callback ) {
5223          if ( speed != null ) {
5224              return this.animate( genFx("show", 3), speed, callback);
5225  
5226          } else {
5227              for ( var i = 0, l = this.length; i < l; i++ ) {
5228                  var old = jQuery.data(this[i], "olddisplay");
5229  
5230                  this[i].style.display = old || "";
5231  
5232                  if ( jQuery.css(this[i], "display") === "none" ) {
5233                      var nodeName = this[i].nodeName, display;
5234  
5235                      if ( elemdisplay[ nodeName ] ) {
5236                          display = elemdisplay[ nodeName ];
5237  
5238                      } else {
5239                          var elem = jQuery("<" + nodeName + " />").appendTo("body");
5240  
5241                          display = elem.css("display");
5242  
5243                          if ( display === "none" ) {
5244                              display = "block";
5245                          }
5246  
5247                          elem.remove();
5248  
5249                          elemdisplay[ nodeName ] = display;
5250                      }
5251  
5252                      jQuery.data(this[i], "olddisplay", display);
5253                  }
5254              }
5255  
5256              // Set the display of the elements in a second loop

5257              // to avoid the constant reflow

5258              for ( var j = 0, k = this.length; j < k; j++ ) {
5259                  this[j].style.display = jQuery.data(this[j], "olddisplay") || "";
5260              }
5261  
5262              return this;
5263          }
5264      },
5265  
5266  
5267  
5268  
5269  
5270      hide: function( speed, callback ) {
5271          if ( speed != null ) {
5272              return this.animate( genFx("hide", 3), speed, callback);
5273  
5274          } else {
5275              for ( var i = 0, l = this.length; i < l; i++ ) {
5276                  var old = jQuery.data(this[i], "olddisplay");
5277                  if ( !old && old !== "none" ) {
5278                      jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
5279                  }
5280              }
5281  
5282              // Set the display of the elements in a second loop

5283              // to avoid the constant reflow

5284              for ( var j = 0, k = this.length; j < k; j++ ) {
5285                  this[j].style.display = "none";
5286              }
5287  
5288              return this;
5289          }
5290      },
5291  
5292      // Save the old toggle function

5293      _toggle: jQuery.fn.toggle,
5294  
5295      toggle: function( fn, fn2 ) {
5296          var bool = typeof fn === "boolean";
5297  
5298          if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
5299              this._toggle.apply( this, arguments );
5300  
5301          } else if ( fn == null || bool ) {
5302              this.each(function() {
5303                  var state = bool ? fn : jQuery(this).is(":hidden");
5304                  jQuery(this)[ state ? "show" : "hide" ]();
5305              });
5306  
5307          } else {
5308              this.animate(genFx("toggle", 3), fn, fn2);
5309          }
5310  
5311          return this;
5312      },
5313  
5314      fadeTo: function( speed, to, callback ) {
5315          return this.filter(":hidden").css("opacity", 0).show().end()
5316                      .animate({opacity: to}, speed, callback);
5317      },
5318  
5319      animate: function( prop, speed, easing, callback ) {
5320          var optall = jQuery.speed(speed, easing, callback);
5321  
5322          if ( jQuery.isEmptyObject( prop ) ) {
5323              return this.each( optall.complete );
5324          }
5325  
5326          return this[ optall.queue === false ? "each" : "queue" ](function() {
5327              var opt = jQuery.extend({}, optall), p,
5328                  hidden = this.nodeType === 1 && jQuery(this).is(":hidden"),
5329                  self = this;
5330  
5331              for ( p in prop ) {
5332                  var name = p.replace(rdashAlpha, fcamelCase);
5333  
5334                  if ( p !== name ) {
5335                      prop[ name ] = prop[ p ];
5336                      delete prop[ p ];
5337                      p = name;
5338                  }
5339  
5340                  if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
5341                      return opt.complete.call(this);
5342                  }
5343  
5344                  if ( ( p === "height" || p === "width" ) && this.style ) {
5345                      // Store display property

5346                      opt.display = jQuery.css(this, "display");
5347  
5348                      // Make sure that nothing sneaks out

5349                      opt.overflow = this.style.overflow;
5350                  }
5351  
5352                  if ( jQuery.isArray( prop[p] ) ) {
5353                      // Create (if needed) and add to specialEasing

5354                      (opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
5355                      prop[p] = prop[p][0];
5356                  }
5357              }
5358  
5359              if ( opt.overflow != null ) {
5360                  this.style.overflow = "hidden";
5361              }
5362  
5363              opt.curAnim = jQuery.extend({}, prop);
5364  
5365              jQuery.each( prop, function( name, val ) {
5366                  var e = new jQuery.fx( self, opt, name );
5367  
5368                  if ( rfxtypes.test(val) ) {
5369                      e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
5370  
5371                  } else {
5372                      var parts = rfxnum.exec(val),
5373                          start = e.cur(true) || 0;
5374  
5375                      if ( parts ) {
5376                          var end = parseFloat( parts[2] ),
5377                              unit = parts[3] || "px";
5378  
5379                          // We need to compute starting value

5380                          if ( unit !== "px" ) {
5381                              self.style[ name ] = (end || 1) + unit;
5382                              start = ((end || 1) / e.cur(true)) * start;
5383                              self.style[ name ] = start + unit;
5384                          }
5385  
5386                          // If a +=/-= token was provided, we're doing a relative animation

5387                          if ( parts[1] ) {
5388                              end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
5389                          }
5390  
5391                          e.custom( start, end, unit );
5392  
5393                      } else {
5394                          e.custom( start, val, "" );
5395                      }
5396                  }
5397              });
5398  
5399              // For JS strict compliance

5400              return true;
5401          });
5402      },
5403  
5404      stop: function( clearQueue, gotoEnd ) {
5405          var timers = jQuery.timers;
5406  
5407          if ( clearQueue ) {
5408              this.queue([]);
5409          }
5410  
5411          this.each(function() {
5412              // go in reverse order so anything added to the queue during the loop is ignored

5413              for ( var i = timers.length - 1; i >= 0; i-- ) {
5414                  if ( timers[i].elem === this ) {
5415                      if (gotoEnd) {
5416                          // force the next step to be the last

5417                          timers[i](true);
5418                      }
5419  
5420                      timers.splice(i, 1);
5421                  }
5422              }
5423          });
5424  
5425          // start the next in the queue if the last step wasn't forced

5426          if ( !gotoEnd ) {
5427              this.dequeue();
5428          }
5429  
5430          return this;
5431      }
5432  
5433  });
5434  
5435  // Generate shortcuts for custom animations

5436  jQuery.each({
5437      slideDown: genFx("show", 1),
5438      slideUp: genFx("hide", 1),
5439      slideToggle: genFx("toggle", 1),
5440      fadeIn: { opacity: "show" },
5441      fadeOut: { opacity: "hide" }
5442  }, function( name, props ) {
5443      jQuery.fn[ name ] = function( speed, callback ) {
5444          return this.animate( props, speed, callback );
5445      };
5446  });
5447  
5448  jQuery.extend({
5449      speed: function( speed, easing, fn ) {
5450          var opt = speed && typeof speed === "object" ? speed : {
5451              complete: fn || !fn && easing ||
5452                  jQuery.isFunction( speed ) && speed,
5453              duration: speed,
5454              easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
5455          };
5456  
5457          opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
5458              jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
5459  
5460          // Queueing

5461          opt.old = opt.complete;
5462          opt.complete = function() {
5463              if ( opt.queue !== false ) {
5464                  jQuery(this).dequeue();
5465              }
5466              if ( jQuery.isFunction( opt.old ) ) {
5467                  opt.old.call( this );
5468              }
5469          };
5470  
5471          return opt;
5472      },
5473  
5474      easing: {
5475          linear: function( p, n, firstNum, diff ) {
5476              return firstNum + diff * p;
5477          },
5478          swing: function( p, n, firstNum, diff ) {
5479              return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
5480          }
5481      },
5482  
5483      timers: [],
5484  
5485      fx: function( elem, options, prop ) {
5486          this.options = options;
5487          this.elem = elem;
5488          this.prop = prop;
5489  
5490          if ( !options.orig ) {
5491              options.orig = {};
5492          }
5493      }
5494  
5495  });
5496  
5497  jQuery.fx.prototype = {
5498      // Simple function for setting a style value

5499      update: function() {
5500          if ( this.options.step ) {
5501              this.options.step.call( this.elem, this.now, this );
5502          }
5503  
5504          (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
5505  
5506          // Set display property to block for height/width animations

5507          if ( ( this.prop === "height" || this.prop === "width" ) && this.elem.style ) {
5508              this.elem.style.display = "block";
5509          }
5510      },
5511  
5512      // Get the current size

5513      cur: function( force ) {
5514          if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
5515              return this.elem[ this.prop ];
5516          }
5517  
5518          var r = parseFloat(jQuery.css(this.elem, this.prop, force));
5519          return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
5520      },
5521  
5522      // Start an animation from one number to another

5523      custom: function( from, to, unit ) {
5524          this.startTime = now();
5525          this.start = from;
5526          this.end = to;
5527          this.unit = unit || this.unit || "px";
5528          this.now = this.start;
5529          this.pos = this.state = 0;
5530  
5531          var self = this;
5532          function t( gotoEnd ) {
5533              return self.step(gotoEnd);
5534          }
5535  
5536          t.elem = this.elem;
5537  
5538          if ( t() && jQuery.timers.push(t) && !timerId ) {
5539              timerId = setInterval(jQuery.fx.tick, 13);
5540          }
5541      },
5542  
5543      // Simple 'show' function

5544      show: function() {
5545          // Remember where we started, so that we can go back to it later

5546          this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5547          this.options.show = true;
5548  
5549          // Begin the animation

5550          // Make sure that we start at a small width/height to avoid any

5551          // flash of content

5552          this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
5553  
5554          // Start by showing the element

5555          jQuery( this.elem ).show();
5556      },
5557  
5558      // Simple 'hide' function

5559      hide: function() {
5560          // Remember where we started, so that we can go back to it later

5561          this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5562          this.options.hide = true;
5563  
5564          // Begin the animation

5565          this.custom(this.cur(), 0);
5566      },
5567  
5568      // Each step of an animation

5569      step: function( gotoEnd ) {
5570          var t = now(), done = true;
5571  
5572          if ( gotoEnd || t >= this.options.duration + this.startTime ) {
5573              this.now = this.end;
5574              this.pos = this.state = 1;
5575              this.update();
5576  
5577              this.options.curAnim[ this.prop ] = true;
5578  
5579              for ( var i in this.options.curAnim ) {
5580                  if ( this.options.curAnim[i] !== true ) {
5581                      done = false;
5582                  }
5583              }
5584  
5585              if ( done ) {
5586                  if ( this.options.display != null ) {
5587                      // Reset the overflow

5588                      this.elem.style.overflow = this.options.overflow;
5589  
5590                      // Reset the display

5591                      var old = jQuery.data(this.elem, "olddisplay");
5592                      this.elem.style.display = old ? old : this.options.display;
5593  
5594                      if ( jQuery.css(this.elem, "display") === "none" ) {
5595                          this.elem.style.display = "block";
5596                      }
5597                  }
5598  
5599                  // Hide the element if the "hide" operation was done

5600                  if ( this.options.hide ) {
5601                      jQuery(this.elem).hide();
5602                  }
5603  
5604                  // Reset the properties, if the item has been hidden or shown

5605                  if ( this.options.hide || this.options.show ) {
5606                      for ( var p in this.options.curAnim ) {
5607                          jQuery.style(this.elem, p, this.options.orig[p]);
5608                      }
5609                  }
5610  
5611                  // Execute the complete function

5612                  this.options.complete.call( this.elem );
5613              }
5614  
5615              return false;
5616  
5617          } else {
5618              var n = t - this.startTime;
5619              this.state = n / this.options.duration;
5620  
5621              // Perform the easing function, defaults to swing

5622              var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
5623              var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
5624              this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
5625              this.now = this.start + ((this.end - this.start) * this.pos);
5626  
5627              // Perform the next step of the animation

5628              this.update();
5629          }
5630  
5631          return true;
5632      }
5633  };
5634  
5635  jQuery.extend( jQuery.fx, {
5636      tick: function() {
5637          var timers = jQuery.timers;
5638  
5639          for ( var i = 0; i < timers.length; i++ ) {
5640              if ( !timers[i]() ) {
5641                  timers.splice(i--, 1);
5642              }
5643          }
5644  
5645          if ( !timers.length ) {
5646              jQuery.fx.stop();
5647          }
5648      },
5649          
5650      stop: function() {
5651          clearInterval( timerId );
5652          timerId = null;
5653      },
5654      
5655      speeds: {
5656          slow: 600,
5657           fast: 200,
5658           // Default speed

5659           _default: 400
5660      },
5661  
5662      step: {
5663          opacity: function( fx ) {
5664              jQuery.style(fx.elem, "opacity", fx.now);
5665          },
5666  
5667          _default: function( fx ) {
5668              if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
5669                  fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
5670              } else {
5671                  fx.elem[ fx.prop ] = fx.now;
5672              }
5673          }
5674      }
5675  });
5676  
5677  if ( jQuery.expr && jQuery.expr.filters ) {
5678      jQuery.expr.filters.animated = function( elem ) {
5679          return jQuery.grep(jQuery.timers, function( fn ) {
5680              return elem === fn.elem;
5681          }).length;
5682      };
5683  }
5684  
5685  function genFx( type, num ) {
5686      var obj = {};
5687  
5688      jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
5689          obj[ this ] = type;
5690      });
5691  
5692      return obj;
5693  }
5694  if ( "getBoundingClientRect" in document.documentElement ) {
5695      jQuery.fn.offset = function( options ) {
5696          var elem = this[0];
5697  
5698          if ( !elem || !elem.ownerDocument ) {
5699              return null;
5700          }
5701  
5702          if ( options ) { 
5703              return this.each(function( i ) {
5704                  jQuery.offset.setOffset( this, options, i );
5705              });
5706          }
5707  
5708          if ( elem === elem.ownerDocument.body ) {
5709              return jQuery.offset.bodyOffset( elem );
5710          }
5711  
5712          var box = elem.getBoundingClientRect(), doc = elem.ownerDocument, body = doc.body, docElem = doc.documentElement,
5713              clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
5714              top  = box.top  + (self.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
5715              left = box.left + (self.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
5716  
5717          return { top: top, left: left };
5718      };
5719  
5720  } else {
5721      jQuery.fn.offset = function( options ) {
5722          var elem = this[0];
5723  
5724          if ( !elem || !elem.ownerDocument ) {
5725              return null;
5726          }
5727  
5728          if ( options ) { 
5729              return this.each(function( i ) {
5730                  jQuery.offset.setOffset( this, options, i );
5731              });
5732          }
5733  
5734          if ( elem === elem.ownerDocument.body ) {
5735              return jQuery.offset.bodyOffset( elem );
5736          }
5737  
5738          jQuery.offset.initialize();
5739  
5740          var offsetParent = elem.offsetParent, prevOffsetParent = elem,
5741              doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
5742              body = doc.body, defaultView = doc.defaultView,
5743              prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
5744              top = elem.offsetTop, left = elem.offsetLeft;
5745  
5746          while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
5747              if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
5748                  break;
5749              }
5750  
5751              computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
5752              top  -= elem.scrollTop;
5753              left -= elem.scrollLeft;
5754  
5755              if ( elem === offsetParent ) {
5756                  top  += elem.offsetTop;
5757                  left += elem.offsetLeft;
5758  
5759                  if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.nodeName)) ) {
5760                      top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5761                      left += parseFloat( computedStyle.borderLeftWidth ) || 0;
5762                  }
5763  
5764                  prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
5765              }
5766  
5767              if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
5768                  top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5769                  left += parseFloat( computedStyle.borderLeftWidth ) || 0;
5770              }
5771  
5772              prevComputedStyle = computedStyle;
5773          }
5774  
5775          if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
5776              top  += body.offsetTop;
5777              left += body.offsetLeft;
5778          }
5779  
5780          if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
5781              top  += Math.max( docElem.scrollTop, body.scrollTop );
5782              left += Math.max( docElem.scrollLeft, body.scrollLeft );
5783          }
5784  
5785          return { top: top, left: left };
5786      };
5787  }
5788  
5789  jQuery.offset = {
5790      initialize: function() {
5791          var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.curCSS(body, "marginTop", true) ) || 0,
5792              html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
5793  
5794          jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
5795  
5796          container.innerHTML = html;
5797          body.insertBefore( container, body.firstChild );
5798          innerDiv = container.firstChild;
5799          checkDiv = innerDiv.firstChild;
5800          td = innerDiv.nextSibling.firstChild.firstChild;
5801  
5802          this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
5803          this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
5804  
5805          checkDiv.style.position = "fixed", checkDiv.style.top = "20px";
5806          // safari subtracts parent border width here which is 5px

5807          this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
5808          checkDiv.style.position = checkDiv.style.top = "";
5809  
5810          innerDiv.style.overflow = "hidden", innerDiv.style.position = "relative";
5811          this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
5812  
5813          this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
5814  
5815          body.removeChild( container );
5816          body = container = innerDiv = checkDiv = table = td = null;
5817          jQuery.offset.initialize = jQuery.noop;
5818      },
5819  
5820      bodyOffset: function( body ) {
5821          var top = body.offsetTop, left = body.offsetLeft;
5822  
5823          jQuery.offset.initialize();
5824  
5825          if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
5826              top  += parseFloat( jQuery.curCSS(body, "marginTop",  true) ) || 0;
5827              left += parseFloat( jQuery.curCSS(body, "marginLeft", true) ) || 0;
5828          }
5829  
5830          return { top: top, left: left };
5831      },
5832      
5833      setOffset: function( elem, options, i ) {
5834          // set position first, in-case top/left are set even on static elem

5835          if ( /static/.test( jQuery.curCSS( elem, "position" ) ) ) {
5836              elem.style.position = "relative";
5837          }
5838          var curElem   = jQuery( elem ),
5839              curOffset = curElem.offset(),
5840              curTop    = parseInt( jQuery.curCSS( elem, "top",  true ), 10 ) || 0,
5841              curLeft   = parseInt( jQuery.curCSS( elem, "left", true ), 10 ) || 0;
5842  
5843          if ( jQuery.isFunction( options ) ) {
5844              options = options.call( elem, i, curOffset );
5845          }
5846  
5847          var props = {
5848              top:  (options.top  - curOffset.top)  + curTop,
5849              left: (options.left - curOffset.left) + curLeft
5850          };
5851          
5852          if ( "using" in options ) {
5853              options.using.call( elem, props );
5854          } else {
5855              curElem.css( props );
5856          }
5857      }
5858  };
5859  
5860  
5861  jQuery.fn.extend({
5862      position: function() {
5863          if ( !this[0] ) {
5864              return null;
5865          }
5866  
5867          var elem = this[0],
5868  
5869          // Get *real* offsetParent

5870          offsetParent = this.offsetParent(),
5871  
5872          // Get correct offsets

5873          offset       = this.offset(),
5874          parentOffset = /^body|html$/i.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
5875  
5876          // Subtract element margins

5877          // note: when an element has margin: auto the offsetLeft and marginLeft

5878          // are the same in Safari causing offset.left to incorrectly be 0

5879          offset.top  -= parseFloat( jQuery.curCSS(elem, "marginTop",  true) ) || 0;
5880          offset.left -= parseFloat( jQuery.curCSS(elem, "marginLeft", true) ) || 0;
5881  
5882          // Add offsetParent borders

5883          parentOffset.top  += parseFloat( jQuery.curCSS(offsetParent[0], "borderTopWidth",  true) ) || 0;
5884          parentOffset.left += parseFloat( jQuery.curCSS(offsetParent[0], "borderLeftWidth", true) ) || 0;
5885  
5886          // Subtract the two offsets

5887          return {
5888              top:  offset.top  - parentOffset.top,
5889              left: offset.left - parentOffset.left
5890          };
5891      },
5892  
5893      offsetParent: function() {
5894          return this.map(function() {
5895              var offsetParent = this.offsetParent || document.body;
5896              while ( offsetParent && (!/^body|html$/i.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
5897                  offsetParent = offsetParent.offsetParent;
5898              }
5899              return offsetParent;
5900          });
5901      }
5902  });
5903  
5904  
5905  // Create scrollLeft and scrollTop methods

5906  jQuery.each( ["Left", "Top"], function( i, name ) {
5907      var method = "scroll" + name;
5908  
5909      jQuery.fn[ method ] = function(val) {
5910          var elem = this[0], win;
5911          
5912          if ( !elem ) {
5913              return null;
5914          }
5915  
5916          if ( val !== undefined ) {
5917              // Set the scroll offset

5918              return this.each(function() {
5919                  win = getWindow( this );
5920  
5921                  if ( win ) {
5922                      win.scrollTo(
5923                          !i ? val : jQuery(win).scrollLeft(),
5924                           i ? val : jQuery(win).scrollTop()
5925                      );
5926  
5927                  } else {
5928                      this[ method ] = val;
5929                  }
5930              });
5931          } else {
5932              win = getWindow( elem );
5933  
5934              // Return the scroll offset

5935              return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
5936                  jQuery.support.boxModel && win.document.documentElement[ method ] ||
5937                      win.document.body[ method ] :
5938                  elem[ method ];
5939          }
5940      };
5941  });
5942  
5943  function getWindow( elem ) {
5944      return ("scrollTo" in elem && elem.document) ?
5945          elem :
5946          elem.nodeType === 9 ?
5947              elem.defaultView || elem.parentWindow :
5948              false;
5949  }
5950  // Create innerHeight, innerWidth, outerHeight and outerWidth methods

5951  jQuery.each([ "Height", "Width" ], function( i, name ) {
5952  
5953      var type = name.toLowerCase();
5954  
5955      // innerHeight and innerWidth

5956      jQuery.fn["inner" + name] = function() {
5957          return this[0] ?
5958              jQuery.css( this[0], type, false, "padding" ) :
5959              null;
5960      };
5961  
5962      // outerHeight and outerWidth

5963      jQuery.fn["outer" + name] = function( margin ) {
5964          return this[0] ?
5965              jQuery.css( this[0], type, false, margin ? "margin" : "border" ) :
5966              null;
5967      };
5968  
5969      jQuery.fn[ type ] = function( size ) {
5970          // Get window width or height

5971          var elem = this[0];
5972          if ( !elem ) {
5973              return size == null ? null : this;
5974          }
5975  
5976          return ("scrollTo" in elem && elem.document) ? // does it walk and quack like a window?
5977              // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode

5978              elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
5979              elem.document.body[ "client" + name ] :
5980  
5981              // Get document width or height

5982              (elem.nodeType === 9) ? // is it a document
5983                  // Either scroll[Width/Height] or offset[Width/Height], whichever is greater

5984                  Math.max(
5985                      elem.documentElement["client" + name],
5986                      elem.body["scroll" + name], elem.documentElement["scroll" + name],
5987                      elem.body["offset" + name], elem.documentElement["offset" + name]
5988                  ) :
5989  
5990                  // Get or set width or height on the element

5991                  size === undefined ?
5992                      // Get width or height on the element

5993                      jQuery.css( elem, type ) :
5994  
5995                      // Set the width or height on the element (default to pixels if value is unitless)

5996                      this.css( type, typeof size === "string" ? size : size + "px" );
5997      };
5998  
5999  });
6000  // Expose jQuery to the global object

6001  window.jQuery = window.$ = jQuery;
6002  
6003  })(window);