[Summary view] [Print] [Text view]

   1  /*!

   2   * jQuery JavaScript Library v1.3.2

   3   * http://jquery.com/

   4   *

   5   * Copyright (c) 2009 John Resig

   6   * Dual licensed under the MIT and GPL licenses.

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

   8   *

   9   * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)

  10   * Revision: 6246

  11   */
  12  (function(){
  13  
  14  var 
  15      // Will speed up references to window, and allows munging its name.

  16      window = this,
  17      // Will speed up references to undefined, and allows munging its name.

  18      undefined,
  19      // Map over jQuery in case of overwrite

  20      _jQuery = window.jQuery,
  21      // Map over the $ in case of overwrite

  22      _$ = window.$,
  23  
  24      jQuery = window.jQuery = window.$ = function( selector, context ) {
  25          // The jQuery object is actually just the init constructor 'enhanced'

  26          return new jQuery.fn.init( selector, context );
  27      },
  28  
  29      // A simple way to check for HTML strings or ID strings

  30      // (both of which we optimize for)

  31      quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
  32      // Is it a simple selector

  33      isSimple = /^.[^:#\[\.,]*$/;
  34  
  35  jQuery.fn = jQuery.prototype = {
  36      init: function( selector, context ) {
  37          // Make sure that a selection was provided

  38          selector = selector || document;
  39  
  40          // Handle $(DOMElement)

  41          if ( selector.nodeType ) {
  42              this[0] = selector;
  43              this.length = 1;
  44              this.context = selector;
  45              return this;
  46          }
  47          // Handle HTML strings

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

  50              var match = quickExpr.exec( selector );
  51  
  52              // Verify a match, and that no context was specified for #id

  53              if ( match && (match[1] || !context) ) {
  54  
  55                  // HANDLE: $(html) -> $(array)

  56                  if ( match[1] )
  57                      selector = jQuery.clean( [ match[1] ], context );
  58  
  59                  // HANDLE: $("#id")

  60                  else {
  61                      var elem = document.getElementById( match[3] );
  62  
  63                      // Handle the case where IE and Opera return items

  64                      // by name instead of ID

  65                      if ( elem && elem.id != match[3] )
  66                          return jQuery().find( selector );
  67  
  68                      // Otherwise, we inject the element directly into the jQuery object

  69                      var ret = jQuery( elem || [] );
  70                      ret.context = document;
  71                      ret.selector = selector;
  72                      return ret;
  73                  }
  74  
  75              // HANDLE: $(expr, [context])

  76              // (which is just equivalent to: $(content).find(expr)

  77              } else
  78                  return jQuery( context ).find( selector );
  79  
  80          // HANDLE: $(function)

  81          // Shortcut for document ready

  82          } else if ( jQuery.isFunction( selector ) )
  83              return jQuery( document ).ready( selector );
  84  
  85          // Make sure that old selector state is passed along

  86          if ( selector.selector && selector.context ) {
  87              this.selector = selector.selector;
  88              this.context = selector.context;
  89          }
  90  
  91          return this.setArray(jQuery.isArray( selector ) ?
  92              selector :
  93              jQuery.makeArray(selector));
  94      },
  95  
  96      // Start with an empty selector

  97      selector: "",
  98  
  99      // The current version of jQuery being used

 100      jquery: "1.3.2",
 101  
 102      // The number of elements contained in the matched element set

 103      size: function() {
 104          return this.length;
 105      },
 106  
 107      // Get the Nth element in the matched element set OR

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

 109      get: function( num ) {
 110          return num === undefined ?
 111  
 112              // Return a 'clean' array

 113              Array.prototype.slice.call( this ) :
 114  
 115              // Return just the object

 116              this[ num ];
 117      },
 118  
 119      // Take an array of elements and push it onto the stack

 120      // (returning the new matched element set)

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

 123          var ret = jQuery( elems );
 124  
 125          // Add the old object onto the stack (as a reference)

 126          ret.prevObject = this;
 127  
 128          ret.context = this.context;
 129  
 130          if ( name === "find" )
 131              ret.selector = this.selector + (this.selector ? " " : "") + selector;
 132          else if ( name )
 133              ret.selector = this.selector + "." + name + "(" + selector + ")";
 134  
 135          // Return the newly-formed element set

 136          return ret;
 137      },
 138  
 139      // Force the current matched set of elements to become

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

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

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

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

 145          this.length = 0;
 146          Array.prototype.push.apply( this, elems );
 147  
 148          return this;
 149      },
 150  
 151      // Execute a callback for every element in the matched set.

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

 153      // only used internally.)

 154      each: function( callback, args ) {
 155          return jQuery.each( this, callback, args );
 156      },
 157  
 158      // Determine the position of an element within

 159      // the matched set of elements

 160      index: function( elem ) {
 161          // Locate the position of the desired element

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

 164              elem && elem.jquery ? elem[0] : elem
 165          , this );
 166      },
 167  
 168      attr: function( name, value, type ) {
 169          var options = name;
 170  
 171          // Look for the case where we're accessing a style value

 172          if ( typeof name === "string" )
 173              if ( value === undefined )
 174                  return this[0] && jQuery[ type || "attr" ]( this[0], name );
 175  
 176              else {
 177                  options = {};
 178                  options[ name ] = value;
 179              }
 180  
 181          // Check to see if we're setting style values

 182          return this.each(function(i){
 183              // Set all the styles

 184              for ( name in options )
 185                  jQuery.attr(
 186                      type ?
 187                          this.style :
 188                          this,
 189                      name, jQuery.prop( this, options[ name ], type, i, name )
 190                  );
 191          });
 192      },
 193  
 194      css: function( key, value ) {
 195          // ignore negative width and height values

 196          if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
 197              value = undefined;
 198          return this.attr( key, value, "curCSS" );
 199      },
 200  
 201      text: function( text ) {
 202          if ( typeof text !== "object" && text != null )
 203              return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
 204  
 205          var ret = "";
 206  
 207          jQuery.each( text || this, function(){
 208              jQuery.each( this.childNodes, function(){
 209                  if ( this.nodeType != 8 )
 210                      ret += this.nodeType != 1 ?
 211                          this.nodeValue :
 212                          jQuery.fn.text( [ this ] );
 213              });
 214          });
 215  
 216          return ret;
 217      },
 218  
 219      wrapAll: function( html ) {
 220          if ( this[0] ) {
 221              // The elements to wrap the target around

 222              var wrap = jQuery( html, this[0].ownerDocument ).clone();
 223  
 224              if ( this[0].parentNode )
 225                  wrap.insertBefore( this[0] );
 226  
 227              wrap.map(function(){
 228                  var elem = this;
 229  
 230                  while ( elem.firstChild )
 231                      elem = elem.firstChild;
 232  
 233                  return elem;
 234              }).append(this);
 235          }
 236  
 237          return this;
 238      },
 239  
 240      wrapInner: function( html ) {
 241          return this.each(function(){
 242              jQuery( this ).contents().wrapAll( html );
 243          });
 244      },
 245  
 246      wrap: function( html ) {
 247          return this.each(function(){
 248              jQuery( this ).wrapAll( html );
 249          });
 250      },
 251  
 252      append: function() {
 253          return this.domManip(arguments, true, function(elem){
 254              if (this.nodeType == 1)
 255                  this.appendChild( elem );
 256          });
 257      },
 258  
 259      prepend: function() {
 260          return this.domManip(arguments, true, function(elem){
 261              if (this.nodeType == 1)
 262                  this.insertBefore( elem, this.firstChild );
 263          });
 264      },
 265  
 266      before: function() {
 267          return this.domManip(arguments, false, function(elem){
 268              this.parentNode.insertBefore( elem, this );
 269          });
 270      },
 271  
 272      after: function() {
 273          return this.domManip(arguments, false, function(elem){
 274              this.parentNode.insertBefore( elem, this.nextSibling );
 275          });
 276      },
 277  
 278      end: function() {
 279          return this.prevObject || jQuery( [] );
 280      },
 281  
 282      // For internal use only.

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

 284      push: [].push,
 285      sort: [].sort,
 286      splice: [].splice,
 287  
 288      find: function( selector ) {
 289          if ( this.length === 1 ) {
 290              var ret = this.pushStack( [], "find", selector );
 291              ret.length = 0;
 292              jQuery.find( selector, this[0], ret );
 293              return ret;
 294          } else {
 295              return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){
 296                  return jQuery.find( selector, elem );
 297              })), "find", selector );
 298          }
 299      },
 300  
 301      clone: function( events ) {
 302          // Do the clone

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

 306                  // using cloneNode. Calling detachEvent on the

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

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

 309                  // Unfortunately, this means some modifications to

 310                  // attributes in IE that are actually only stored

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

 312                  // the name attribute on an input).

 313                  var html = this.outerHTML;
 314                  if ( !html ) {
 315                      var div = this.ownerDocument.createElement("div");
 316                      div.appendChild( this.cloneNode(true) );
 317                      html = div.innerHTML;
 318                  }
 319  
 320                  return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];
 321              } else
 322                  return this.cloneNode(true);
 323          });
 324  
 325          // Copy the events from the original to the clone

 326          if ( events === true ) {
 327              var orig = this.find("*").andSelf(), i = 0;
 328  
 329              ret.find("*").andSelf().each(function(){
 330                  if ( this.nodeName !== orig[i].nodeName )
 331                      return;
 332  
 333                  var events = jQuery.data( orig[i], "events" );
 334  
 335                  for ( var type in events ) {
 336                      for ( var handler in events[ type ] ) {
 337                          jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
 338                      }
 339                  }
 340  
 341                  i++;
 342              });
 343          }
 344  
 345          // Return the cloned set

 346          return ret;
 347      },
 348  
 349      filter: function( selector ) {
 350          return this.pushStack(
 351              jQuery.isFunction( selector ) &&
 352              jQuery.grep(this, function(elem, i){
 353                  return selector.call( elem, i );
 354              }) ||
 355  
 356              jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
 357                  return elem.nodeType === 1;
 358              }) ), "filter", selector );
 359      },
 360  
 361      closest: function( selector ) {
 362          var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,
 363              closer = 0;
 364  
 365          return this.map(function(){
 366              var cur = this;
 367              while ( cur && cur.ownerDocument ) {
 368                  if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {
 369                      jQuery.data(cur, "closest", closer);
 370                      return cur;
 371                  }
 372                  cur = cur.parentNode;
 373                  closer++;
 374              }
 375          });
 376      },
 377  
 378      not: function( selector ) {
 379          if ( typeof selector === "string" )
 380              // test special case where just one selector is passed in

 381              if ( isSimple.test( selector ) )
 382                  return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
 383              else
 384                  selector = jQuery.multiFilter( selector, this );
 385  
 386          var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
 387          return this.filter(function() {
 388              return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
 389          });
 390      },
 391  
 392      add: function( selector ) {
 393          return this.pushStack( jQuery.unique( jQuery.merge(
 394              this.get(),
 395              typeof selector === "string" ?
 396                  jQuery( selector ) :
 397                  jQuery.makeArray( selector )
 398          )));
 399      },
 400  
 401      is: function( selector ) {
 402          return !!selector && jQuery.multiFilter( selector, this ).length > 0;
 403      },
 404  
 405      hasClass: function( selector ) {
 406          return !!selector && this.is( "." + selector );
 407      },
 408  
 409      val: function( value ) {
 410          if ( value === undefined ) {            
 411              var elem = this[0];
 412  
 413              if ( elem ) {
 414                  if( jQuery.nodeName( elem, 'option' ) )
 415                      return (elem.attributes.value || {}).specified ? elem.value : elem.text;
 416                  
 417                  // We need to handle select boxes special

 418                  if ( jQuery.nodeName( elem, "select" ) ) {
 419                      var index = elem.selectedIndex,
 420                          values = [],
 421                          options = elem.options,
 422                          one = elem.type == "select-one";
 423  
 424                      // Nothing was selected

 425                      if ( index < 0 )
 426                          return null;
 427  
 428                      // Loop through all the selected options

 429                      for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
 430                          var option = options[ i ];
 431  
 432                          if ( option.selected ) {
 433                              // Get the specifc value for the option

 434                              value = jQuery(option).val();
 435  
 436                              // We don't need an array for one selects

 437                              if ( one )
 438                                  return value;
 439  
 440                              // Multi-Selects return an array

 441                              values.push( value );
 442                          }
 443                      }
 444  
 445                      return values;                
 446                  }
 447  
 448                  // Everything else, we just grab the value

 449                  return (elem.value || "").replace(/\r/g, "");
 450  
 451              }
 452  
 453              return undefined;
 454          }
 455  
 456          if ( typeof value === "number" )
 457              value += '';
 458  
 459          return this.each(function(){
 460              if ( this.nodeType != 1 )
 461                  return;
 462  
 463              if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
 464                  this.checked = (jQuery.inArray(this.value, value) >= 0 ||
 465                      jQuery.inArray(this.name, value) >= 0);
 466  
 467              else if ( jQuery.nodeName( this, "select" ) ) {
 468                  var values = jQuery.makeArray(value);
 469  
 470                  jQuery( "option", this ).each(function(){
 471                      this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
 472                          jQuery.inArray( this.text, values ) >= 0);
 473                  });
 474  
 475                  if ( !values.length )
 476                      this.selectedIndex = -1;
 477  
 478              } else
 479                  this.value = value;
 480          });
 481      },
 482  
 483      html: function( value ) {
 484          return value === undefined ?
 485              (this[0] ?
 486                  this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :
 487                  null) :
 488              this.empty().append( value );
 489      },
 490  
 491      replaceWith: function( value ) {
 492          return this.after( value ).remove();
 493      },
 494  
 495      eq: function( i ) {
 496          return this.slice( i, +i + 1 );
 497      },
 498  
 499      slice: function() {
 500          return this.pushStack( Array.prototype.slice.apply( this, arguments ),
 501              "slice", Array.prototype.slice.call(arguments).join(",") );
 502      },
 503  
 504      map: function( callback ) {
 505          return this.pushStack( jQuery.map(this, function(elem, i){
 506              return callback.call( elem, i, elem );
 507          }));
 508      },
 509  
 510      andSelf: function() {
 511          return this.add( this.prevObject );
 512      },
 513  
 514      domManip: function( args, table, callback ) {
 515          if ( this[0] ) {
 516              var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
 517                  scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
 518                  first = fragment.firstChild;
 519  
 520              if ( first )
 521                  for ( var i = 0, l = this.length; i < l; i++ )
 522                      callback.call( root(this[i], first), this.length > 1 || i > 0 ?
 523                              fragment.cloneNode(true) : fragment );
 524          
 525              if ( scripts )
 526                  jQuery.each( scripts, evalScript );
 527          }
 528  
 529          return this;
 530          
 531  		function root( elem, cur ) {
 532              return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
 533                  (elem.getElementsByTagName("tbody")[0] ||
 534                  elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
 535                  elem;
 536          }
 537      }
 538  };
 539  
 540  // Give the init function the jQuery prototype for later instantiation

 541  jQuery.fn.init.prototype = jQuery.fn;
 542  
 543  function evalScript( i, elem ) {
 544      if ( elem.src )
 545          jQuery.ajax({
 546              url: elem.src,
 547              async: false,
 548              dataType: "script"
 549          });
 550  
 551      else
 552          jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
 553  
 554      if ( elem.parentNode )
 555          elem.parentNode.removeChild( elem );
 556  }
 557  
 558  function now(){
 559      return +new Date;
 560  }
 561  
 562  jQuery.extend = jQuery.fn.extend = function() {
 563      // copy reference to target object

 564      var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
 565  
 566      // Handle a deep copy situation

 567      if ( typeof target === "boolean" ) {
 568          deep = target;
 569          target = arguments[1] || {};
 570          // skip the boolean and the target

 571          i = 2;
 572      }
 573  
 574      // Handle case when target is a string or something (possible in deep copy)

 575      if ( typeof target !== "object" && !jQuery.isFunction(target) )
 576          target = {};
 577  
 578      // extend jQuery itself if only one argument is passed

 579      if ( length == i ) {
 580          target = this;
 581          --i;
 582      }
 583  
 584      for ( ; i < length; i++ )
 585          // Only deal with non-null/undefined values

 586          if ( (options = arguments[ i ]) != null )
 587              // Extend the base object

 588              for ( var name in options ) {
 589                  var src = target[ name ], copy = options[ name ];
 590  
 591                  // Prevent never-ending loop

 592                  if ( target === copy )
 593                      continue;
 594  
 595                  // Recurse if we're merging object values

 596                  if ( deep && copy && typeof copy === "object" && !copy.nodeType )
 597                      target[ name ] = jQuery.extend( deep, 
 598                          // Never move original objects, clone them

 599                          src || ( copy.length != null ? [ ] : { } )
 600                      , copy );
 601  
 602                  // Don't bring in undefined values

 603                  else if ( copy !== undefined )
 604                      target[ name ] = copy;
 605  
 606              }
 607  
 608      // Return the modified object

 609      return target;
 610  };
 611  
 612  // exclude the following css properties to add px

 613  var    exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
 614      // cache defaultView

 615      defaultView = document.defaultView || {},
 616      toString = Object.prototype.toString;
 617  
 618  jQuery.extend({
 619      noConflict: function( deep ) {
 620          window.$ = _$;
 621  
 622          if ( deep )
 623              window.jQuery = _jQuery;
 624  
 625          return jQuery;
 626      },
 627  
 628      // See test/unit/core.js for details concerning isFunction.

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

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

 631      isFunction: function( obj ) {
 632          return toString.call(obj) === "[object Function]";
 633      },
 634  
 635      isArray: function( obj ) {
 636          return toString.call(obj) === "[object Array]";
 637      },
 638  
 639      // check if an element is in a (or is an) XML document

 640      isXMLDoc: function( elem ) {
 641          return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
 642              !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
 643      },
 644  
 645      // Evalulates a script in a global context

 646      globalEval: function( data ) {
 647          if ( data && /\S/.test(data) ) {
 648              // Inspired by code by Andrea Giammarchi

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

 650              var head = document.getElementsByTagName("head")[0] || document.documentElement,
 651                  script = document.createElement("script");
 652  
 653              script.type = "text/javascript";
 654              if ( jQuery.support.scriptEval )
 655                  script.appendChild( document.createTextNode( data ) );
 656              else
 657                  script.text = data;
 658  
 659              // Use insertBefore instead of appendChild  to circumvent an IE6 bug.

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

 661              head.insertBefore( script, head.firstChild );
 662              head.removeChild( script );
 663          }
 664      },
 665  
 666      nodeName: function( elem, name ) {
 667          return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
 668      },
 669  
 670      // args is for internal usage only

 671      each: function( object, callback, args ) {
 672          var name, i = 0, length = object.length;
 673  
 674          if ( args ) {
 675              if ( length === undefined ) {
 676                  for ( name in object )
 677                      if ( callback.apply( object[ name ], args ) === false )
 678                          break;
 679              } else
 680                  for ( ; i < length; )
 681                      if ( callback.apply( object[ i++ ], args ) === false )
 682                          break;
 683  
 684          // A special, fast, case for the most common use of each

 685          } else {
 686              if ( length === undefined ) {
 687                  for ( name in object )
 688                      if ( callback.call( object[ name ], name, object[ name ] ) === false )
 689                          break;
 690              } else
 691                  for ( var value = object[0];
 692                      i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
 693          }
 694  
 695          return object;
 696      },
 697  
 698      prop: function( elem, value, type, i, name ) {
 699          // Handle executable functions

 700          if ( jQuery.isFunction( value ) )
 701              value = value.call( elem, i );
 702  
 703          // Handle passing in a number to a CSS property

 704          return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
 705              value + "px" :
 706              value;
 707      },
 708  
 709      className: {
 710          // internal only, use addClass("class")

 711          add: function( elem, classNames ) {
 712              jQuery.each((classNames || "").split(/\s+/), function(i, className){
 713                  if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
 714                      elem.className += (elem.className ? " " : "") + className;
 715              });
 716          },
 717  
 718          // internal only, use removeClass("class")

 719          remove: function( elem, classNames ) {
 720              if (elem.nodeType == 1)
 721                  elem.className = classNames !== undefined ?
 722                      jQuery.grep(elem.className.split(/\s+/), function(className){
 723                          return !jQuery.className.has( classNames, className );
 724                      }).join(" ") :
 725                      "";
 726          },
 727  
 728          // internal only, use hasClass("class")

 729          has: function( elem, className ) {
 730              return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
 731          }
 732      },
 733  
 734      // A method for quickly swapping in/out CSS properties to get correct calculations

 735      swap: function( elem, options, callback ) {
 736          var old = {};
 737          // Remember the old values, and insert the new ones

 738          for ( var name in options ) {
 739              old[ name ] = elem.style[ name ];
 740              elem.style[ name ] = options[ name ];
 741          }
 742  
 743          callback.call( elem );
 744  
 745          // Revert the old values

 746          for ( var name in options )
 747              elem.style[ name ] = old[ name ];
 748      },
 749  
 750      css: function( elem, name, force, extra ) {
 751          if ( name == "width" || name == "height" ) {
 752              var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
 753  
 754  			function getWH() {
 755                  val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
 756  
 757                  if ( extra === "border" )
 758                      return;
 759  
 760                  jQuery.each( which, function() {
 761                      if ( !extra )
 762                          val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
 763                      if ( extra === "margin" )
 764                          val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
 765                      else
 766                          val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
 767                  });
 768              }
 769  
 770              if ( elem.offsetWidth !== 0 )
 771                  getWH();
 772              else
 773                  jQuery.swap( elem, props, getWH );
 774  
 775              return Math.max(0, Math.round(val));
 776          }
 777  
 778          return jQuery.curCSS( elem, name, force );
 779      },
 780  
 781      curCSS: function( elem, name, force ) {
 782          var ret, style = elem.style;
 783  
 784          // We need to handle opacity special in IE

 785          if ( name == "opacity" && !jQuery.support.opacity ) {
 786              ret = jQuery.attr( style, "opacity" );
 787  
 788              return ret == "" ?
 789                  "1" :
 790                  ret;
 791          }
 792  
 793          // Make sure we're using the right name for getting the float value

 794          if ( name.match( /float/i ) )
 795              name = styleFloat;
 796  
 797          if ( !force && style && style[ name ] )
 798              ret = style[ name ];
 799  
 800          else if ( defaultView.getComputedStyle ) {
 801  
 802              // Only "float" is needed here

 803              if ( name.match( /float/i ) )
 804                  name = "float";
 805  
 806              name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
 807  
 808              var computedStyle = defaultView.getComputedStyle( elem, null );
 809  
 810              if ( computedStyle )
 811                  ret = computedStyle.getPropertyValue( name );
 812  
 813              // We should always get a number back from opacity

 814              if ( name == "opacity" && ret == "" )
 815                  ret = "1";
 816  
 817          } else if ( elem.currentStyle ) {
 818              var camelCase = name.replace(/\-(\w)/g, function(all, letter){
 819                  return letter.toUpperCase();
 820              });
 821  
 822              ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
 823  
 824              // From the awesome hack by Dean Edwards

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

 826  
 827              // If we're not dealing with a regular pixel number

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

 829              if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
 830                  // Remember the original values

 831                  var left = style.left, rsLeft = elem.runtimeStyle.left;
 832  
 833                  // Put in the new values to get a computed value out

 834                  elem.runtimeStyle.left = elem.currentStyle.left;
 835                  style.left = ret || 0;
 836                  ret = style.pixelLeft + "px";
 837  
 838                  // Revert the changed values

 839                  style.left = left;
 840                  elem.runtimeStyle.left = rsLeft;
 841              }
 842          }
 843  
 844          return ret;
 845      },
 846  
 847      clean: function( elems, context, fragment ) {
 848          context = context || document;
 849  
 850          // !context.createElement fails in IE with an error but returns typeof 'object'

 851          if ( typeof context.createElement === "undefined" )
 852              context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
 853  
 854          // If a single string is passed in and it's a single tag

 855          // just do a createElement and skip the rest

 856          if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
 857              var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
 858              if ( match )
 859                  return [ context.createElement( match[1] ) ];
 860          }
 861  
 862          var ret = [], scripts = [], div = context.createElement("div");
 863  
 864          jQuery.each(elems, function(i, elem){
 865              if ( typeof elem === "number" )
 866                  elem += '';
 867  
 868              if ( !elem )
 869                  return;
 870  
 871              // Convert html string into DOM nodes

 872              if ( typeof elem === "string" ) {
 873                  // Fix "XHTML"-style tags in all browsers

 874                  elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
 875                      return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
 876                          all :
 877                          front + "></" + tag + ">";
 878                  });
 879  
 880                  // Trim whitespace, otherwise indexOf won't work as expected

 881                  var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();
 882  
 883                  var wrap =
 884                      // option or optgroup

 885                      !tags.indexOf("<opt") &&
 886                      [ 1, "<select multiple='multiple'>", "</select>" ] ||
 887  
 888                      !tags.indexOf("<leg") &&
 889                      [ 1, "<fieldset>", "</fieldset>" ] ||
 890  
 891                      tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
 892                      [ 1, "<table>", "</table>" ] ||
 893  
 894                      !tags.indexOf("<tr") &&
 895                      [ 2, "<table><tbody>", "</tbody></table>" ] ||
 896  
 897                       // <thead> matched above

 898                      (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
 899                      [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
 900  
 901                      !tags.indexOf("<col") &&
 902                      [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
 903  
 904                      // IE can't serialize <link> and <script> tags normally

 905                      !jQuery.support.htmlSerialize &&
 906                      [ 1, "div<div>", "</div>" ] ||
 907  
 908                      [ 0, "", "" ];
 909  
 910                  // Go to html and back, then peel off extra wrappers

 911                  div.innerHTML = wrap[1] + elem + wrap[2];
 912  
 913                  // Move to the right depth

 914                  while ( wrap[0]-- )
 915                      div = div.lastChild;
 916  
 917                  // Remove IE's autoinserted <tbody> from table fragments

 918                  if ( !jQuery.support.tbody ) {
 919  
 920                      // String was a <table>, *may* have spurious <tbody>

 921                      var hasBody = /<tbody/i.test(elem),
 922                          tbody = !tags.indexOf("<table") && !hasBody ?
 923                              div.firstChild && div.firstChild.childNodes :
 924  
 925                          // String was a bare <thead> or <tfoot>

 926                          wrap[1] == "<table>" && !hasBody ?
 927                              div.childNodes :
 928                              [];
 929  
 930                      for ( var j = tbody.length - 1; j >= 0 ; --j )
 931                          if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
 932                              tbody[ j ].parentNode.removeChild( tbody[ j ] );
 933  
 934                      }
 935  
 936                  // IE completely kills leading whitespace when innerHTML is used

 937                  if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
 938                      div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
 939                  
 940                  elem = jQuery.makeArray( div.childNodes );
 941              }
 942  
 943              if ( elem.nodeType )
 944                  ret.push( elem );
 945              else
 946                  ret = jQuery.merge( ret, elem );
 947  
 948          });
 949  
 950          if ( fragment ) {
 951              for ( var i = 0; ret[i]; i++ ) {
 952                  if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
 953                      scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
 954                  } else {
 955                      if ( ret[i].nodeType === 1 )
 956                          ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
 957                      fragment.appendChild( ret[i] );
 958                  }
 959              }
 960              
 961              return scripts;
 962          }
 963  
 964          return ret;
 965      },
 966  
 967      attr: function( elem, name, value ) {
 968          // don't set attributes on text and comment nodes

 969          if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
 970              return undefined;
 971  
 972          var notxml = !jQuery.isXMLDoc( elem ),
 973              // Whether we are setting (or getting)

 974              set = value !== undefined;
 975  
 976          // Try to normalize/fix the name

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

 980          // IE elem.getAttribute passes even for style

 981          if ( elem.tagName ) {
 982  
 983              // These attributes require special treatment

 984              var special = /href|src|style/.test( name );
 985  
 986              // Safari mis-reports the default selected property of a hidden option

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

 988              if ( name == "selected" && elem.parentNode )
 989                  elem.parentNode.selectedIndex;
 990  
 991              // If applicable, access the attribute via the DOM 0 way

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

 995                      if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
 996                          throw "type property can't be changed";
 997  
 998                      elem[ name ] = value;
 999                  }
1000  
1001                  // browsers index elements by id/name on forms, give priority to attributes.

1002                  if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1003                      return elem.getAttributeNode( name ).nodeValue;
1004  
1005                  // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set

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

1007                  if ( name == "tabIndex" ) {
1008                      var attributeNode = elem.getAttributeNode( "tabIndex" );
1009                      return attributeNode && attributeNode.specified
1010                          ? attributeNode.value
1011                          : elem.nodeName.match(/(button|input|object|select|textarea)/i)
1012                              ? 0
1013                              : elem.nodeName.match(/^(a|area)$/i) && elem.href
1014                                  ? 0
1015                                  : undefined;
1016                  }
1017  
1018                  return elem[ name ];
1019              }
1020  
1021              if ( !jQuery.support.style && notxml &&  name == "style" )
1022                  return jQuery.attr( elem.style, "cssText", value );
1023  
1024              if ( set )
1025                  // convert the value to a string (all browsers do this but IE) see #1070

1026                  elem.setAttribute( name, "" + value );
1027  
1028              var attr = !jQuery.support.hrefNormalized && notxml && special
1029                      // Some attributes require a special call on IE

1030                      ? elem.getAttribute( name, 2 )
1031                      : elem.getAttribute( name );
1032  
1033              // Non-existent attributes return null, we normalize to undefined

1034              return attr === null ? undefined : attr;
1035          }
1036  
1037          // elem is actually elem.style ... set the style

1038  
1039          // IE uses filters for opacity

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

1043                  // Force it by setting the zoom level

1044                  elem.zoom = 1;
1045  
1046                  // Set the alpha filter to set the opacity

1047                  elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1048                      (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1049              }
1050  
1051              return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1052                  (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1053                  "";
1054          }
1055  
1056          name = name.replace(/-([a-z])/ig, function(all, letter){
1057              return letter.toUpperCase();
1058          });
1059  
1060          if ( set )
1061              elem[ name ] = value;
1062  
1063          return elem[ name ];
1064      },
1065  
1066      trim: function( text ) {
1067          return (text || "").replace( /^\s+|\s+$/g, "" );
1068      },
1069  
1070      makeArray: function( array ) {
1071          var ret = [];
1072  
1073          if( array != null ){
1074              var i = array.length;
1075              // The window, strings (and functions) also have 'length'

1076              if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
1077                  ret[0] = array;
1078              else
1079                  while( i )
1080                      ret[--i] = array[i];
1081          }
1082  
1083          return ret;
1084      },
1085  
1086      inArray: function( elem, array ) {
1087          for ( var i = 0, length = array.length; i < length; i++ )
1088          // Use === because on IE, window == document

1089              if ( array[ i ] === elem )
1090                  return i;
1091  
1092          return -1;
1093      },
1094  
1095      merge: function( first, second ) {
1096          // We have to loop this way because IE & Opera overwrite the length

1097          // expando of getElementsByTagName

1098          var i = 0, elem, pos = first.length;
1099          // Also, we need to make sure that the correct elements are being returned

1100          // (IE returns comment nodes in a '*' query)

1101          if ( !jQuery.support.getAll ) {
1102              while ( (elem = second[ i++ ]) != null )
1103                  if ( elem.nodeType != 8 )
1104                      first[ pos++ ] = elem;
1105  
1106          } else
1107              while ( (elem = second[ i++ ]) != null )
1108                  first[ pos++ ] = elem;
1109  
1110          return first;
1111      },
1112  
1113      unique: function( array ) {
1114          var ret = [], done = {};
1115  
1116          try {
1117  
1118              for ( var i = 0, length = array.length; i < length; i++ ) {
1119                  var id = jQuery.data( array[ i ] );
1120  
1121                  if ( !done[ id ] ) {
1122                      done[ id ] = true;
1123                      ret.push( array[ i ] );
1124                  }
1125              }
1126  
1127          } catch( e ) {
1128              ret = array;
1129          }
1130  
1131          return ret;
1132      },
1133  
1134      grep: function( elems, callback, inv ) {
1135          var ret = [];
1136  
1137          // Go through the array, only saving the items

1138          // that pass the validator function

1139          for ( var i = 0, length = elems.length; i < length; i++ )
1140              if ( !inv != !callback( elems[ i ], i ) )
1141                  ret.push( elems[ i ] );
1142  
1143          return ret;
1144      },
1145  
1146      map: function( elems, callback ) {
1147          var ret = [];
1148  
1149          // Go through the array, translating each of the items to their

1150          // new value (or values).

1151          for ( var i = 0, length = elems.length; i < length; i++ ) {
1152              var value = callback( elems[ i ], i );
1153  
1154              if ( value != null )
1155                  ret[ ret.length ] = value;
1156          }
1157  
1158          return ret.concat.apply( [], ret );
1159      }
1160  });
1161  
1162  // Use of jQuery.browser is deprecated.

1163  // It's included for backwards compatibility and plugins,

1164  // although they should work to migrate away.

1165  
1166  var userAgent = navigator.userAgent.toLowerCase();
1167  
1168  // Figure out what browser is being used

1169  jQuery.browser = {
1170      version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
1171      safari: /webkit/.test( userAgent ),
1172      opera: /opera/.test( userAgent ),
1173      msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1174      mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1175  };
1176  
1177  jQuery.each({
1178      parent: function(elem){return elem.parentNode;},
1179      parents: function(elem){return jQuery.dir(elem,"parentNode");},
1180      next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1181      prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1182      nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1183      prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1184      siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1185      children: function(elem){return jQuery.sibling(elem.firstChild);},
1186      contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1187  }, function(name, fn){
1188      jQuery.fn[ name ] = function( selector ) {
1189          var ret = jQuery.map( this, fn );
1190  
1191          if ( selector && typeof selector == "string" )
1192              ret = jQuery.multiFilter( selector, ret );
1193  
1194          return this.pushStack( jQuery.unique( ret ), name, selector );
1195      };
1196  });
1197  
1198  jQuery.each({
1199      appendTo: "append",
1200      prependTo: "prepend",
1201      insertBefore: "before",
1202      insertAfter: "after",
1203      replaceAll: "replaceWith"
1204  }, function(name, original){
1205      jQuery.fn[ name ] = function( selector ) {
1206          var ret = [], insert = jQuery( selector );
1207  
1208          for ( var i = 0, l = insert.length; i < l; i++ ) {
1209              var elems = (i > 0 ? this.clone(true) : this).get();
1210              jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
1211              ret = ret.concat( elems );
1212          }
1213  
1214          return this.pushStack( ret, name, selector );
1215      };
1216  });
1217  
1218  jQuery.each({
1219      removeAttr: function( name ) {
1220          jQuery.attr( this, name, "" );
1221          if (this.nodeType == 1)
1222              this.removeAttribute( name );
1223      },
1224  
1225      addClass: function( classNames ) {
1226          jQuery.className.add( this, classNames );
1227      },
1228  
1229      removeClass: function( classNames ) {
1230          jQuery.className.remove( this, classNames );
1231      },
1232  
1233      toggleClass: function( classNames, state ) {
1234          if( typeof state !== "boolean" )
1235              state = !jQuery.className.has( this, classNames );
1236          jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1237      },
1238  
1239      remove: function( selector ) {
1240          if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
1241              // Prevent memory leaks

1242              jQuery( "*", this ).add([this]).each(function(){
1243                  jQuery.event.remove(this);
1244                  jQuery.removeData(this);
1245              });
1246              if (this.parentNode)
1247                  this.parentNode.removeChild( this );
1248          }
1249      },
1250  
1251      empty: function() {
1252          // Remove element nodes and prevent memory leaks

1253          jQuery(this).children().remove();
1254  
1255          // Remove any remaining nodes

1256          while ( this.firstChild )
1257              this.removeChild( this.firstChild );
1258      }
1259  }, function(name, fn){
1260      jQuery.fn[ name ] = function(){
1261          return this.each( fn, arguments );
1262      };
1263  });
1264  
1265  // Helper function used by the dimensions and offset modules

1266  function num(elem, prop) {
1267      return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1268  }
1269  var expando = "jQuery" + now(), uuid = 0, windowData = {};
1270  
1271  jQuery.extend({
1272      cache: {},
1273  
1274      data: function( elem, name, data ) {
1275          elem = elem == window ?
1276              windowData :
1277              elem;
1278  
1279          var id = elem[ expando ];
1280  
1281          // Compute a unique ID for the element

1282          if ( !id )
1283              id = elem[ expando ] = ++uuid;
1284  
1285          // Only generate the data cache if we're

1286          // trying to access or manipulate it

1287          if ( name && !jQuery.cache[ id ] )
1288              jQuery.cache[ id ] = {};
1289  
1290          // Prevent overriding the named cache with undefined values

1291          if ( data !== undefined )
1292              jQuery.cache[ id ][ name ] = data;
1293  
1294          // Return the named cache data, or the ID for the element

1295          return name ?
1296              jQuery.cache[ id ][ name ] :
1297              id;
1298      },
1299  
1300      removeData: function( elem, name ) {
1301          elem = elem == window ?
1302              windowData :
1303              elem;
1304  
1305          var id = elem[ expando ];
1306  
1307          // If we want to remove a specific section of the element's data

1308          if ( name ) {
1309              if ( jQuery.cache[ id ] ) {
1310                  // Remove the section of cache data

1311                  delete jQuery.cache[ id ][ name ];
1312  
1313                  // If we've removed all the data, remove the element's cache

1314                  name = "";
1315  
1316                  for ( name in jQuery.cache[ id ] )
1317                      break;
1318  
1319                  if ( !name )
1320                      jQuery.removeData( elem );
1321              }
1322  
1323          // Otherwise, we want to remove all of the element's data

1324          } else {
1325              // Clean up the element expando

1326              try {
1327                  delete elem[ expando ];
1328              } catch(e){
1329                  // IE has trouble directly removing the expando

1330                  // but it's ok with using removeAttribute

1331                  if ( elem.removeAttribute )
1332                      elem.removeAttribute( expando );
1333              }
1334  
1335              // Completely remove the data cache

1336              delete jQuery.cache[ id ];
1337          }
1338      },
1339      queue: function( elem, type, data ) {
1340          if ( elem ){
1341      
1342              type = (type || "fx") + "queue";
1343      
1344              var q = jQuery.data( elem, type );
1345      
1346              if ( !q || jQuery.isArray(data) )
1347                  q = jQuery.data( elem, type, jQuery.makeArray(data) );
1348              else if( data )
1349                  q.push( data );
1350      
1351          }
1352          return q;
1353      },
1354  
1355      dequeue: function( elem, type ){
1356          var queue = jQuery.queue( elem, type ),
1357              fn = queue.shift();
1358          
1359          if( !type || type === "fx" )
1360              fn = queue[0];
1361              
1362          if( fn !== undefined )
1363              fn.call(elem);
1364      }
1365  });
1366  
1367  jQuery.fn.extend({
1368      data: function( key, value ){
1369          var parts = key.split(".");
1370          parts[1] = parts[1] ? "." + parts[1] : "";
1371  
1372          if ( value === undefined ) {
1373              var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1374  
1375              if ( data === undefined && this.length )
1376                  data = jQuery.data( this[0], key );
1377  
1378              return data === undefined && parts[1] ?
1379                  this.data( parts[0] ) :
1380                  data;
1381          } else
1382              return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
1383                  jQuery.data( this, key, value );
1384              });
1385      },
1386  
1387      removeData: function( key ){
1388          return this.each(function(){
1389              jQuery.removeData( this, key );
1390          });
1391      },
1392      queue: function(type, data){
1393          if ( typeof type !== "string" ) {
1394              data = type;
1395              type = "fx";
1396          }
1397  
1398          if ( data === undefined )
1399              return jQuery.queue( this[0], type );
1400  
1401          return this.each(function(){
1402              var queue = jQuery.queue( this, type, data );
1403              
1404               if( type == "fx" && queue.length == 1 )
1405                  queue[0].call(this);
1406          });
1407      },
1408      dequeue: function(type){
1409          return this.each(function(){
1410              jQuery.dequeue( this, type );
1411          });
1412      }
1413  });/*!

1414   * Sizzle CSS Selector Engine - v0.9.3

1415   *  Copyright 2009, The Dojo Foundation

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

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

1418   */
1419  (function(){
1420  
1421  var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
1422      done = 0,
1423      toString = Object.prototype.toString;
1424  
1425  var Sizzle = function(selector, context, results, seed) {
1426      results = results || [];
1427      context = context || document;
1428  
1429      if ( context.nodeType !== 1 && context.nodeType !== 9 )
1430          return [];
1431      
1432      if ( !selector || typeof selector !== "string" ) {
1433          return results;
1434      }
1435  
1436      var parts = [], m, set, checkSet, check, mode, extra, prune = true;
1437      
1438      // Reset the position of the chunker regexp (start from head)

1439      chunker.lastIndex = 0;
1440      
1441      while ( (m = chunker.exec(selector)) !== null ) {
1442          parts.push( m[1] );
1443          
1444          if ( m[2] ) {
1445              extra = RegExp.rightContext;
1446              break;
1447          }
1448      }
1449  
1450      if ( parts.length > 1 && origPOS.exec( selector ) ) {
1451          if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
1452              set = posProcess( parts[0] + parts[1], context );
1453          } else {
1454              set = Expr.relative[ parts[0] ] ?
1455                  [ context ] :
1456                  Sizzle( parts.shift(), context );
1457  
1458              while ( parts.length ) {
1459                  selector = parts.shift();
1460  
1461                  if ( Expr.relative[ selector ] )
1462                      selector += parts.shift();
1463  
1464                  set = posProcess( selector, set );
1465              }
1466          }
1467      } else {
1468          var ret = seed ?
1469              { expr: parts.pop(), set: makeArray(seed) } :
1470              Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
1471          set = Sizzle.filter( ret.expr, ret.set );
1472  
1473          if ( parts.length > 0 ) {
1474              checkSet = makeArray(set);
1475          } else {
1476              prune = false;
1477          }
1478  
1479          while ( parts.length ) {
1480              var cur = parts.pop(), pop = cur;
1481  
1482              if ( !Expr.relative[ cur ] ) {
1483                  cur = "";
1484              } else {
1485                  pop = parts.pop();
1486              }
1487  
1488              if ( pop == null ) {
1489                  pop = context;
1490              }
1491  
1492              Expr.relative[ cur ]( checkSet, pop, isXML(context) );
1493          }
1494      }
1495  
1496      if ( !checkSet ) {
1497          checkSet = set;
1498      }
1499  
1500      if ( !checkSet ) {
1501          throw "Syntax error, unrecognized expression: " + (cur || selector);
1502      }
1503  
1504      if ( toString.call(checkSet) === "[object Array]" ) {
1505          if ( !prune ) {
1506              results.push.apply( results, checkSet );
1507          } else if ( context.nodeType === 1 ) {
1508              for ( var i = 0; checkSet[i] != null; i++ ) {
1509                  if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
1510                      results.push( set[i] );
1511                  }
1512              }
1513          } else {
1514              for ( var i = 0; checkSet[i] != null; i++ ) {
1515                  if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
1516                      results.push( set[i] );
1517                  }
1518              }
1519          }
1520      } else {
1521          makeArray( checkSet, results );
1522      }
1523  
1524      if ( extra ) {
1525          Sizzle( extra, context, results, seed );
1526  
1527          if ( sortOrder ) {
1528              hasDuplicate = false;
1529              results.sort(sortOrder);
1530  
1531              if ( hasDuplicate ) {
1532                  for ( var i = 1; i < results.length; i++ ) {
1533                      if ( results[i] === results[i-1] ) {
1534                          results.splice(i--, 1);
1535                      }
1536                  }
1537              }
1538          }
1539      }
1540  
1541      return results;
1542  };
1543  
1544  Sizzle.matches = function(expr, set){
1545      return Sizzle(expr, null, null, set);
1546  };
1547  
1548  Sizzle.find = function(expr, context, isXML){
1549      var set, match;
1550  
1551      if ( !expr ) {
1552          return [];
1553      }
1554  
1555      for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
1556          var type = Expr.order[i], match;
1557          
1558          if ( (match = Expr.match[ type ].exec( expr )) ) {
1559              var left = RegExp.leftContext;
1560  
1561              if ( left.substr( left.length - 1 ) !== "\\" ) {
1562                  match[1] = (match[1] || "").replace(/\\/g, "");
1563                  set = Expr.find[ type ]( match, context, isXML );
1564                  if ( set != null ) {
1565                      expr = expr.replace( Expr.match[ type ], "" );
1566                      break;
1567                  }
1568              }
1569          }
1570      }
1571  
1572      if ( !set ) {
1573          set = context.getElementsByTagName("*");
1574      }
1575  
1576      return {set: set, expr: expr};
1577  };
1578  
1579  Sizzle.filter = function(expr, set, inplace, not){
1580      var old = expr, result = [], curLoop = set, match, anyFound,
1581          isXMLFilter = set && set[0] && isXML(set[0]);
1582  
1583      while ( expr && set.length ) {
1584          for ( var type in Expr.filter ) {
1585              if ( (match = Expr.match[ type ].exec( expr )) != null ) {
1586                  var filter = Expr.filter[ type ], found, item;
1587                  anyFound = false;
1588  
1589                  if ( curLoop == result ) {
1590                      result = [];
1591                  }
1592  
1593                  if ( Expr.preFilter[ type ] ) {
1594                      match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
1595  
1596                      if ( !match ) {
1597                          anyFound = found = true;
1598                      } else if ( match === true ) {
1599                          continue;
1600                      }
1601                  }
1602  
1603                  if ( match ) {
1604                      for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
1605                          if ( item ) {
1606                              found = filter( item, match, i, curLoop );
1607                              var pass = not ^ !!found;
1608  
1609                              if ( inplace && found != null ) {
1610                                  if ( pass ) {
1611                                      anyFound = true;
1612                                  } else {
1613                                      curLoop[i] = false;
1614                                  }
1615                              } else if ( pass ) {
1616                                  result.push( item );
1617                                  anyFound = true;
1618                              }
1619                          }
1620                      }
1621                  }
1622  
1623                  if ( found !== undefined ) {
1624                      if ( !inplace ) {
1625                          curLoop = result;
1626                      }
1627  
1628                      expr = expr.replace( Expr.match[ type ], "" );
1629  
1630                      if ( !anyFound ) {
1631                          return [];
1632                      }
1633  
1634                      break;
1635                  }
1636              }
1637          }
1638  
1639          // Improper expression

1640          if ( expr == old ) {
1641              if ( anyFound == null ) {
1642                  throw "Syntax error, unrecognized expression: " + expr;
1643              } else {
1644                  break;
1645              }
1646          }
1647  
1648          old = expr;
1649      }
1650  
1651      return curLoop;
1652  };
1653  
1654  var Expr = Sizzle.selectors = {
1655      order: [ "ID", "NAME", "TAG" ],
1656      match: {
1657          ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1658          CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1659          NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
1660          ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
1661          TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
1662          CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
1663          POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
1664          PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
1665      },
1666      attrMap: {
1667          "class": "className",
1668          "for": "htmlFor"
1669      },
1670      attrHandle: {
1671          href: function(elem){
1672              return elem.getAttribute("href");
1673          }
1674      },
1675      relative: {
1676          "+": function(checkSet, part, isXML){
1677              var isPartStr = typeof part === "string",
1678                  isTag = isPartStr && !/\W/.test(part),
1679                  isPartStrNotTag = isPartStr && !isTag;
1680  
1681              if ( isTag && !isXML ) {
1682                  part = part.toUpperCase();
1683              }
1684  
1685              for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
1686                  if ( (elem = checkSet[i]) ) {
1687                      while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
1688  
1689                      checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
1690                          elem || false :
1691                          elem === part;
1692                  }
1693              }
1694  
1695              if ( isPartStrNotTag ) {
1696                  Sizzle.filter( part, checkSet, true );
1697              }
1698          },
1699          ">": function(checkSet, part, isXML){
1700              var isPartStr = typeof part === "string";
1701  
1702              if ( isPartStr && !/\W/.test(part) ) {
1703                  part = isXML ? part : part.toUpperCase();
1704  
1705                  for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1706                      var elem = checkSet[i];
1707                      if ( elem ) {
1708                          var parent = elem.parentNode;
1709                          checkSet[i] = parent.nodeName === part ? parent : false;
1710                      }
1711                  }
1712              } else {
1713                  for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1714                      var elem = checkSet[i];
1715                      if ( elem ) {
1716                          checkSet[i] = isPartStr ?
1717                              elem.parentNode :
1718                              elem.parentNode === part;
1719                      }
1720                  }
1721  
1722                  if ( isPartStr ) {
1723                      Sizzle.filter( part, checkSet, true );
1724                  }
1725              }
1726          },
1727          "": function(checkSet, part, isXML){
1728              var doneName = done++, checkFn = dirCheck;
1729  
1730              if ( !part.match(/\W/) ) {
1731                  var nodeCheck = part = isXML ? part : part.toUpperCase();
1732                  checkFn = dirNodeCheck;
1733              }
1734  
1735              checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
1736          },
1737          "~": function(checkSet, part, isXML){
1738              var doneName = done++, checkFn = dirCheck;
1739  
1740              if ( typeof part === "string" && !part.match(/\W/) ) {
1741                  var nodeCheck = part = isXML ? part : part.toUpperCase();
1742                  checkFn = dirNodeCheck;
1743              }
1744  
1745              checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
1746          }
1747      },
1748      find: {
1749          ID: function(match, context, isXML){
1750              if ( typeof context.getElementById !== "undefined" && !isXML ) {
1751                  var m = context.getElementById(match[1]);
1752                  return m ? [m] : [];
1753              }
1754          },
1755          NAME: function(match, context, isXML){
1756              if ( typeof context.getElementsByName !== "undefined" ) {
1757                  var ret = [], results = context.getElementsByName(match[1]);
1758  
1759                  for ( var i = 0, l = results.length; i < l; i++ ) {
1760                      if ( results[i].getAttribute("name") === match[1] ) {
1761                          ret.push( results[i] );
1762                      }
1763                  }
1764  
1765                  return ret.length === 0 ? null : ret;
1766              }
1767          },
1768          TAG: function(match, context){
1769              return context.getElementsByTagName(match[1]);
1770          }
1771      },
1772      preFilter: {
1773          CLASS: function(match, curLoop, inplace, result, not, isXML){
1774              match = " " + match[1].replace(/\\/g, "") + " ";
1775  
1776              if ( isXML ) {
1777                  return match;
1778              }
1779  
1780              for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
1781                  if ( elem ) {
1782                      if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
1783                          if ( !inplace )
1784                              result.push( elem );
1785                      } else if ( inplace ) {
1786                          curLoop[i] = false;
1787                      }
1788                  }
1789              }
1790  
1791              return false;
1792          },
1793          ID: function(match){
1794              return match[1].replace(/\\/g, "");
1795          },
1796          TAG: function(match, curLoop){
1797              for ( var i = 0; curLoop[i] === false; i++ ){}
1798              return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
1799          },
1800          CHILD: function(match){
1801              if ( match[1] == "nth" ) {
1802                  // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'

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

1808                  match[2] = (test[1] + (test[2] || 1)) - 0;
1809                  match[3] = test[3] - 0;
1810              }
1811  
1812              // TODO: Move to normal caching system

1813              match[0] = done++;
1814  
1815              return match;
1816          },
1817          ATTR: function(match, curLoop, inplace, result, not, isXML){
1818              var name = match[1].replace(/\\/g, "");
1819              
1820              if ( !isXML && Expr.attrMap[name] ) {
1821                  match[1] = Expr.attrMap[name];
1822              }
1823  
1824              if ( match[2] === "~=" ) {
1825                  match[4] = " " + match[4] + " ";
1826              }
1827  
1828              return match;
1829          },
1830          PSEUDO: function(match, curLoop, inplace, result, not){
1831              if ( match[1] === "not" ) {
1832                  // If we're dealing with a complex expression, or a simple one

1833                  if ( match[3].match(chunker).length > 1 || /^\w/.test(match[3]) ) {
1834                      match[3] = Sizzle(match[3], null, null, curLoop);
1835                  } else {
1836                      var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
1837                      if ( !inplace ) {
1838                          result.push.apply( result, ret );
1839                      }
1840                      return false;
1841                  }
1842              } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
1843                  return true;
1844              }
1845              
1846              return match;
1847          },
1848          POS: function(match){
1849              match.unshift( true );
1850              return match;
1851          }
1852      },
1853      filters: {
1854          enabled: function(elem){
1855              return elem.disabled === false && elem.type !== "hidden";
1856          },
1857          disabled: function(elem){
1858              return elem.disabled === true;
1859          },
1860          checked: function(elem){
1861              return elem.checked === true;
1862          },
1863          selected: function(elem){
1864              // Accessing this property makes selected-by-default

1865              // options in Safari work properly

1866              elem.parentNode.selectedIndex;
1867              return elem.selected === true;
1868          },
1869          parent: function(elem){
1870              return !!elem.firstChild;
1871          },
1872          empty: function(elem){
1873              return !elem.firstChild;
1874          },
1875          has: function(elem, i, match){
1876              return !!Sizzle( match[3], elem ).length;
1877          },
1878          header: function(elem){
1879              return /h\d/i.test( elem.nodeName );
1880          },
1881          text: function(elem){
1882              return "text" === elem.type;
1883          },
1884          radio: function(elem){
1885              return "radio" === elem.type;
1886          },
1887          checkbox: function(elem){
1888              return "checkbox" === elem.type;
1889          },
1890          file: function(elem){
1891              return "file" === elem.type;
1892          },
1893          password: function(elem){
1894              return "password" === elem.type;
1895          },
1896          submit: function(elem){
1897              return "submit" === elem.type;
1898          },
1899          image: function(elem){
1900              return "image" === elem.type;
1901          },
1902          reset: function(elem){
1903              return "reset" === elem.type;
1904          },
1905          button: function(elem){
1906              return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
1907          },
1908          input: function(elem){
1909              return /input|select|textarea|button/i.test(elem.nodeName);
1910          }
1911      },
1912      setFilters: {
1913          first: function(elem, i){
1914              return i === 0;
1915          },
1916          last: function(elem, i, match, array){
1917              return i === array.length - 1;
1918          },
1919          even: function(elem, i){
1920              return i % 2 === 0;
1921          },
1922          odd: function(elem, i){
1923              return i % 2 === 1;
1924          },
1925          lt: function(elem, i, match){
1926              return i < match[3] - 0;
1927          },
1928          gt: function(elem, i, match){
1929              return i > match[3] - 0;
1930          },
1931          nth: function(elem, i, match){
1932              return match[3] - 0 == i;
1933          },
1934          eq: function(elem, i, match){
1935              return match[3] - 0 == i;
1936          }
1937      },
1938      filter: {
1939          PSEUDO: function(elem, match, i, array){
1940              var name = match[1], filter = Expr.filters[ name ];
1941  
1942              if ( filter ) {
1943                  return filter( elem, i, match, array );
1944              } else if ( name === "contains" ) {
1945                  return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
1946              } else if ( name === "not" ) {
1947                  var not = match[3];
1948  
1949                  for ( var i = 0, l = not.length; i < l; i++ ) {
1950                      if ( not[i] === elem ) {
1951                          return false;
1952                      }
1953                  }
1954  
1955                  return true;
1956              }
1957          },
1958          CHILD: function(elem, match){
1959              var type = match[1], node = elem;
1960              switch (type) {
1961                  case 'only':
1962                  case 'first':
1963                      while (node = node.previousSibling)  {
1964                          if ( node.nodeType === 1 ) return false;
1965                      }
1966                      if ( type == 'first') return true;
1967                      node = elem;
1968                  case 'last':
1969                      while (node = node.nextSibling)  {
1970                          if ( node.nodeType === 1 ) return false;
1971                      }
1972                      return true;
1973                  case 'nth':
1974                      var first = match[2], last = match[3];
1975  
1976                      if ( first == 1 && last == 0 ) {
1977                          return true;
1978                      }
1979                      
1980                      var doneName = match[0],
1981                          parent = elem.parentNode;
1982      
1983                      if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
1984                          var count = 0;
1985                          for ( node = parent.firstChild; node; node = node.nextSibling ) {
1986                              if ( node.nodeType === 1 ) {
1987                                  node.nodeIndex = ++count;
1988                              }
1989                          } 
1990                          parent.sizcache = doneName;
1991                      }
1992                      
1993                      var diff = elem.nodeIndex - last;
1994                      if ( first == 0 ) {
1995                          return diff == 0;
1996                      } else {
1997                          return ( diff % first == 0 && diff / first >= 0 );
1998                      }
1999              }
2000          },
2001          ID: function(elem, match){
2002              return elem.nodeType === 1 && elem.getAttribute("id") === match;
2003          },
2004          TAG: function(elem, match){
2005              return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
2006          },
2007          CLASS: function(elem, match){
2008              return (" " + (elem.className || elem.getAttribute("class")) + " ")
2009                  .indexOf( match ) > -1;
2010          },
2011          ATTR: function(elem, match){
2012              var name = match[1],
2013                  result = Expr.attrHandle[ name ] ?
2014                      Expr.attrHandle[ name ]( elem ) :
2015                      elem[ name ] != null ?
2016                          elem[ name ] :
2017                          elem.getAttribute( name ),
2018                  value = result + "",
2019                  type = match[2],
2020                  check = match[4];
2021  
2022              return result == null ?
2023                  type === "!=" :
2024                  type === "=" ?
2025                  value === check :
2026                  type === "*=" ?
2027                  value.indexOf(check) >= 0 :
2028                  type === "~=" ?
2029                  (" " + value + " ").indexOf(check) >= 0 :
2030                  !check ?
2031                  value && result !== false :
2032                  type === "!=" ?
2033                  value != check :
2034                  type === "^=" ?
2035                  value.indexOf(check) === 0 :
2036                  type === "$=" ?
2037                  value.substr(value.length - check.length) === check :
2038                  type === "|=" ?
2039                  value === check || value.substr(0, check.length + 1) === check + "-" :
2040                  false;
2041          },
2042          POS: function(elem, match, i, array){
2043              var name = match[2], filter = Expr.setFilters[ name ];
2044  
2045              if ( filter ) {
2046                  return filter( elem, i, match, array );
2047              }
2048          }
2049      }
2050  };
2051  
2052  var origPOS = Expr.match.POS;
2053  
2054  for ( var type in Expr.match ) {
2055      Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
2056  }
2057  
2058  var makeArray = function(array, results) {
2059      array = Array.prototype.slice.call( array );
2060  
2061      if ( results ) {
2062          results.push.apply( results, array );
2063          return results;
2064      }
2065      
2066      return array;
2067  };
2068  
2069  // Perform a simple check to determine if the browser is capable of

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

2071  try {
2072      Array.prototype.slice.call( document.documentElement.childNodes );
2073  
2074  // Provide a fallback method if it does not work

2075  } catch(e){
2076      makeArray = function(array, results) {
2077          var ret = results || [];
2078  
2079          if ( toString.call(array) === "[object Array]" ) {
2080              Array.prototype.push.apply( ret, array );
2081          } else {
2082              if ( typeof array.length === "number" ) {
2083                  for ( var i = 0, l = array.length; i < l; i++ ) {
2084                      ret.push( array[i] );
2085                  }
2086              } else {
2087                  for ( var i = 0; array[i]; i++ ) {
2088                      ret.push( array[i] );
2089                  }
2090              }
2091          }
2092  
2093          return ret;
2094      };
2095  }
2096  
2097  var sortOrder;
2098  
2099  if ( document.documentElement.compareDocumentPosition ) {
2100      sortOrder = function( a, b ) {
2101          var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
2102          if ( ret === 0 ) {
2103              hasDuplicate = true;
2104          }
2105          return ret;
2106      };
2107  } else if ( "sourceIndex" in document.documentElement ) {
2108      sortOrder = function( a, b ) {
2109          var ret = a.sourceIndex - b.sourceIndex;
2110          if ( ret === 0 ) {
2111              hasDuplicate = true;
2112          }
2113          return ret;
2114      };
2115  } else if ( document.createRange ) {
2116      sortOrder = function( a, b ) {
2117          var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
2118          aRange.selectNode(a);
2119          aRange.collapse(true);
2120          bRange.selectNode(b);
2121          bRange.collapse(true);
2122          var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
2123          if ( ret === 0 ) {
2124              hasDuplicate = true;
2125          }
2126          return ret;
2127      };
2128  }
2129  
2130  // Check to see if the browser returns elements by name when

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

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

2134      var form = document.createElement("form"),
2135          id = "script" + (new Date).getTime();
2136      form.innerHTML = "<input name='" + id + "'/>";
2137  
2138      // Inject it into the root element, check its status, and remove it quickly

2139      var root = document.documentElement;
2140      root.insertBefore( form, root.firstChild );
2141  
2142      // The workaround has to do additional checks after a getElementById

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

2144      if ( !!document.getElementById( id ) ) {
2145          Expr.find.ID = function(match, context, isXML){
2146              if ( typeof context.getElementById !== "undefined" && !isXML ) {
2147                  var m = context.getElementById(match[1]);
2148                  return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
2149              }
2150          };
2151  
2152          Expr.filter.ID = function(elem, match){
2153              var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
2154              return elem.nodeType === 1 && node && node.nodeValue === match;
2155          };
2156      }
2157  
2158      root.removeChild( form );
2159  })();
2160  
2161  (function(){
2162      // Check to see if the browser returns only elements

2163      // when doing getElementsByTagName("*")

2164  
2165      // Create a fake element

2166      var div = document.createElement("div");
2167      div.appendChild( document.createComment("") );
2168  
2169      // Make sure no comments are found

2170      if ( div.getElementsByTagName("*").length > 0 ) {
2171          Expr.find.TAG = function(match, context){
2172              var results = context.getElementsByTagName(match[1]);
2173  
2174              // Filter out possible comments

2175              if ( match[1] === "*" ) {
2176                  var tmp = [];
2177  
2178                  for ( var i = 0; results[i]; i++ ) {
2179                      if ( results[i].nodeType === 1 ) {
2180                          tmp.push( results[i] );
2181                      }
2182                  }
2183  
2184                  results = tmp;
2185              }
2186  
2187              return results;
2188          };
2189      }
2190  
2191      // Check to see if an attribute returns normalized href attributes

2192      div.innerHTML = "<a href='#'></a>";
2193      if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
2194              div.firstChild.getAttribute("href") !== "#" ) {
2195          Expr.attrHandle.href = function(elem){
2196              return elem.getAttribute("href", 2);
2197          };
2198      }
2199  })();
2200  
2201  if ( document.querySelectorAll ) (function(){
2202      var oldSizzle = Sizzle, div = document.createElement("div");
2203      div.innerHTML = "<p class='TEST'></p>";
2204  
2205      // Safari can't handle uppercase or unicode characters when

2206      // in quirks mode.

2207      if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
2208          return;
2209      }
2210      
2211      Sizzle = function(query, context, extra, seed){
2212          context = context || document;
2213  
2214          // Only use querySelectorAll on non-XML documents

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

2216          if ( !seed && context.nodeType === 9 && !isXML(context) ) {
2217              try {
2218                  return makeArray( context.querySelectorAll(query), extra );
2219              } catch(e){}
2220          }
2221          
2222          return oldSizzle(query, context, extra, seed);
2223      };
2224  
2225      Sizzle.find = oldSizzle.find;
2226      Sizzle.filter = oldSizzle.filter;
2227      Sizzle.selectors = oldSizzle.selectors;
2228      Sizzle.matches = oldSizzle.matches;
2229  })();
2230  
2231  if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2232      var div = document.createElement("div");
2233      div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2234  
2235      // Opera can't find a second classname (in 9.6)

2236      if ( div.getElementsByClassName("e").length === 0 )
2237          return;
2238  
2239      // Safari caches class attributes, doesn't catch changes (in 3.2)

2240      div.lastChild.className = "e";
2241  
2242      if ( div.getElementsByClassName("e").length === 1 )
2243          return;
2244  
2245      Expr.order.splice(1, 0, "CLASS");
2246      Expr.find.CLASS = function(match, context, isXML) {
2247          if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248              return context.getElementsByClassName(match[1]);
2249          }
2250      };
2251  })();
2252  
2253  function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2254      var sibDir = dir == "previousSibling" && !isXML;
2255      for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2256          var elem = checkSet[i];
2257          if ( elem ) {
2258              if ( sibDir && elem.nodeType === 1 ){
2259                  elem.sizcache = doneName;
2260                  elem.sizset = i;
2261              }
2262              elem = elem[dir];
2263              var match = false;
2264  
2265              while ( elem ) {
2266                  if ( elem.sizcache === doneName ) {
2267                      match = checkSet[elem.sizset];
2268                      break;
2269                  }
2270  
2271                  if ( elem.nodeType === 1 && !isXML ){
2272                      elem.sizcache = doneName;
2273                      elem.sizset = i;
2274                  }
2275  
2276                  if ( elem.nodeName === cur ) {
2277                      match = elem;
2278                      break;
2279                  }
2280  
2281                  elem = elem[dir];
2282              }
2283  
2284              checkSet[i] = match;
2285          }
2286      }
2287  }
2288  
2289  function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2290      var sibDir = dir == "previousSibling" && !isXML;
2291      for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2292          var elem = checkSet[i];
2293          if ( elem ) {
2294              if ( sibDir && elem.nodeType === 1 ) {
2295                  elem.sizcache = doneName;
2296                  elem.sizset = i;
2297              }
2298              elem = elem[dir];
2299              var match = false;
2300  
2301              while ( elem ) {
2302                  if ( elem.sizcache === doneName ) {
2303                      match = checkSet[elem.sizset];
2304                      break;
2305                  }
2306  
2307                  if ( elem.nodeType === 1 ) {
2308                      if ( !isXML ) {
2309                          elem.sizcache = doneName;
2310                          elem.sizset = i;
2311                      }
2312                      if ( typeof cur !== "string" ) {
2313                          if ( elem === cur ) {
2314                              match = true;
2315                              break;
2316                          }
2317  
2318                      } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
2319                          match = elem;
2320                          break;
2321                      }
2322                  }
2323  
2324                  elem = elem[dir];
2325              }
2326  
2327              checkSet[i] = match;
2328          }
2329      }
2330  }
2331  
2332  var contains = document.compareDocumentPosition ?  function(a, b){
2333      return a.compareDocumentPosition(b) & 16;
2334  } : function(a, b){
2335      return a !== b && (a.contains ? a.contains(b) : true);
2336  };
2337  
2338  var isXML = function(elem){
2339      return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
2340          !!elem.ownerDocument && isXML( elem.ownerDocument );
2341  };
2342  
2343  var posProcess = function(selector, context){
2344      var tmpSet = [], later = "", match,
2345          root = context.nodeType ? [context] : context;
2346  
2347      // Position selectors must be done after the filter

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

2349      while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
2350          later += match[0];
2351          selector = selector.replace( Expr.match.PSEUDO, "" );
2352      }
2353  
2354      selector = Expr.relative[selector] ? selector + "*" : selector;
2355  
2356      for ( var i = 0, l = root.length; i < l; i++ ) {
2357          Sizzle( selector, root[i], tmpSet );
2358      }
2359  
2360      return Sizzle.filter( later, tmpSet );
2361  };
2362  
2363  // EXPOSE

2364  jQuery.find = Sizzle;
2365  jQuery.filter = Sizzle.filter;
2366  jQuery.expr = Sizzle.selectors;
2367  jQuery.expr[":"] = jQuery.expr.filters;
2368  
2369  Sizzle.selectors.filters.hidden = function(elem){
2370      return elem.offsetWidth === 0 || elem.offsetHeight === 0;
2371  };
2372  
2373  Sizzle.selectors.filters.visible = function(elem){
2374      return elem.offsetWidth > 0 || elem.offsetHeight > 0;
2375  };
2376  
2377  Sizzle.selectors.filters.animated = function(elem){
2378      return jQuery.grep(jQuery.timers, function(fn){
2379          return elem === fn.elem;
2380      }).length;
2381  };
2382  
2383  jQuery.multiFilter = function( expr, elems, not ) {
2384      if ( not ) {
2385          expr = ":not(" + expr + ")";
2386      }
2387  
2388      return Sizzle.matches(expr, elems);
2389  };
2390  
2391  jQuery.dir = function( elem, dir ){
2392      var matched = [], cur = elem[dir];
2393      while ( cur && cur != document ) {
2394          if ( cur.nodeType == 1 )
2395              matched.push( cur );
2396          cur = cur[dir];
2397      }
2398      return matched;
2399  };
2400  
2401  jQuery.nth = function(cur, result, dir, elem){
2402      result = result || 1;
2403      var num = 0;
2404  
2405      for ( ; cur; cur = cur[dir] )
2406          if ( cur.nodeType == 1 && ++num == result )
2407              break;
2408  
2409      return cur;
2410  };
2411  
2412  jQuery.sibling = function(n, elem){
2413      var r = [];
2414  
2415      for ( ; n; n = n.nextSibling ) {
2416          if ( n.nodeType == 1 && n != elem )
2417              r.push( n );
2418      }
2419  
2420      return r;
2421  };
2422  
2423  return;
2424  
2425  window.Sizzle = Sizzle;
2426  
2427  })();
2428  /*

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

2430   * Many of the ideas behind this code originated from

2431   * Dean Edwards' addEvent library.

2432   */
2433  jQuery.event = {
2434  
2435      // Bind an event to an element

2436      // Original by Dean Edwards

2437      add: function(elem, types, handler, data) {
2438          if ( elem.nodeType == 3 || elem.nodeType == 8 )
2439              return;
2440  
2441          // For whatever reason, IE has trouble passing the window object

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

2443          if ( elem.setInterval && elem != window )
2444              elem = window;
2445  
2446          // Make sure that the function being executed has a unique ID

2447          if ( !handler.guid )
2448              handler.guid = this.guid++;
2449  
2450          // if data is passed, bind to handler

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

2453              var fn = handler;
2454  
2455              // Create unique handler function, wrapped around original handler

2456              handler = this.proxy( fn );
2457  
2458              // Store data in unique handler

2459              handler.data = data;
2460          }
2461  
2462          // Init the element's event structure

2463          var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
2464              handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
2465                  // Handle the second event of a trigger and when

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

2467                  return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
2468                      jQuery.event.handle.apply(arguments.callee.elem, arguments) :
2469                      undefined;
2470              });
2471          // Add elem as a property of the handle function

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

2473          // event in IE.

2474          handle.elem = elem;
2475  
2476          // Handle multiple events separated by a space

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

2478          jQuery.each(types.split(/\s+/), function(index, type) {
2479              // Namespaced event handlers

2480              var namespaces = type.split(".");
2481              type = namespaces.shift();
2482              handler.type = namespaces.slice().sort().join(".");
2483  
2484              // Get the current list of functions bound to this event

2485              var handlers = events[type];
2486              
2487              if ( jQuery.event.specialAll[type] )
2488                  jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
2489  
2490              // Init the event handler queue

2491              if (!handlers) {
2492                  handlers = events[type] = {};
2493  
2494                  // Check for a special event handler

2495                  // Only use addEventListener/attachEvent if the special

2496                  // events handler returns false

2497                  if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
2498                      // Bind the global event handler to the element

2499                      if (elem.addEventListener)
2500                          elem.addEventListener(type, handle, false);
2501                      else if (elem.attachEvent)
2502                          elem.attachEvent("on" + type, handle);
2503                  }
2504              }
2505  
2506              // Add the function to the element's handler list

2507              handlers[handler.guid] = handler;
2508  
2509              // Keep track of which events have been used, for global triggering

2510              jQuery.event.global[type] = true;
2511          });
2512  
2513          // Nullify elem to prevent memory leaks in IE

2514          elem = null;
2515      },
2516  
2517      guid: 1,
2518      global: {},
2519  
2520      // Detach an event or set of events from an element

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

2523          if ( elem.nodeType == 3 || elem.nodeType == 8 )
2524              return;
2525  
2526          var events = jQuery.data(elem, "events"), ret, index;
2527  
2528          if ( events ) {
2529              // Unbind all events for the element

2530              if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
2531                  for ( var type in events )
2532                      this.remove( elem, type + (types || "") );
2533              else {
2534                  // types is actually an event object here

2535                  if ( types.type ) {
2536                      handler = types.handler;
2537                      types = types.type;
2538                  }
2539  
2540                  // Handle multiple events seperated by a space

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

2542                  jQuery.each(types.split(/\s+/), function(index, type){
2543                      // Namespaced event handlers

2544                      var namespaces = type.split(".");
2545                      type = namespaces.shift();
2546                      var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
2547  
2548                      if ( events[type] ) {
2549                          // remove the given handler for the given type

2550                          if ( handler )
2551                              delete events[type][handler.guid];
2552  
2553                          // remove all handlers for the given type

2554                          else
2555                              for ( var handle in events[type] )
2556                                  // Handle the removal of namespaced events

2557                                  if ( namespace.test(events[type][handle].type) )
2558                                      delete events[type][handle];
2559                                      
2560                          if ( jQuery.event.specialAll[type] )
2561                              jQuery.event.specialAll[type].teardown.call(elem, namespaces);
2562  
2563                          // remove generic event handler if no more handlers exist

2564                          for ( ret in events[type] ) break;
2565                          if ( !ret ) {
2566                              if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
2567                                  if (elem.removeEventListener)
2568                                      elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
2569                                  else if (elem.detachEvent)
2570                                      elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
2571                              }
2572                              ret = null;
2573                              delete events[type];
2574                          }
2575                      }
2576                  });
2577              }
2578  
2579              // Remove the expando if it's no longer used

2580              for ( ret in events ) break;
2581              if ( !ret ) {
2582                  var handle = jQuery.data( elem, "handle" );
2583                  if ( handle ) handle.elem = null;
2584                  jQuery.removeData( elem, "events" );
2585                  jQuery.removeData( elem, "handle" );
2586              }
2587          }
2588      },
2589  
2590      // bubbling is internal

2591      trigger: function( event, data, elem, bubbling ) {
2592          // Event object or event type

2593          var type = event.type || event;
2594  
2595          if( !bubbling ){
2596              event = typeof event === "object" ?
2597                  // jQuery.Event object

2598                  event[expando] ? event :
2599                  // Object literal

2600                  jQuery.extend( jQuery.Event(type), event ) :
2601                  // Just the event type (string)

2602                  jQuery.Event(type);
2603  
2604              if ( type.indexOf("!") >= 0 ) {
2605                  event.type = type = type.slice(0, -1);
2606                  event.exclusive = true;
2607              }
2608  
2609              // Handle a global trigger

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

2612                  event.stopPropagation();
2613                  // Only trigger if we've ever bound an event for it

2614                  if ( this.global[type] )
2615                      jQuery.each( jQuery.cache, function(){
2616                          if ( this.events && this.events[type] )
2617                              jQuery.event.trigger( event, data, this.handle.elem );
2618                      });
2619              }
2620  
2621              // Handle triggering a single element

2622  
2623              // don't do events on text and comment nodes

2624              if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 )
2625                  return undefined;
2626              
2627              // Clean up in case it is reused

2628              event.result = undefined;
2629              event.target = elem;
2630              
2631              // Clone the incoming data, if any

2632              data = jQuery.makeArray(data);
2633              data.unshift( event );
2634          }
2635  
2636          event.currentTarget = elem;
2637  
2638          // Trigger the event, it is assumed that "handle" is a function

2639          var handle = jQuery.data(elem, "handle");
2640          if ( handle )
2641              handle.apply( elem, data );
2642  
2643          // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)

2644          if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2645              event.result = false;
2646  
2647          // Trigger the native events (except for clicks on links)

2648          if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2649              this.triggered = true;
2650              try {
2651                  elem[ type ]();
2652              // prevent IE from throwing an error for some hidden elements

2653              } catch (e) {}
2654          }
2655  
2656          this.triggered = false;
2657  
2658          if ( !event.isPropagationStopped() ) {
2659              var parent = elem.parentNode || elem.ownerDocument;
2660              if ( parent )
2661                  jQuery.event.trigger(event, data, parent, true);
2662          }
2663      },
2664  
2665      handle: function(event) {
2666          // returned undefined or false

2667          var all, handlers;
2668  
2669          event = arguments[0] = jQuery.event.fix( event || window.event );
2670          event.currentTarget = this;
2671          
2672          // Namespaced event handlers

2673          var namespaces = event.type.split(".");
2674          event.type = namespaces.shift();
2675  
2676          // Cache this now, all = true means, any handler

2677          all = !namespaces.length && !event.exclusive;
2678          
2679          var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
2680  
2681          handlers = ( jQuery.data(this, "events") || {} )[event.type];
2682  
2683          for ( var j in handlers ) {
2684              var handler = handlers[j];
2685  
2686              // Filter the functions by class

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

2689                  // So that we can later remove it

2690                  event.handler = handler;
2691                  event.data = handler.data;
2692  
2693                  var ret = handler.apply(this, arguments);
2694  
2695                  if( ret !== undefined ){
2696                      event.result = ret;
2697                      if ( ret === false ) {
2698                          event.preventDefault();
2699                          event.stopPropagation();
2700                      }
2701                  }
2702  
2703                  if( event.isImmediatePropagationStopped() )
2704                      break;
2705  
2706              }
2707          }
2708      },
2709  
2710      props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2711  
2712      fix: function(event) {
2713          if ( event[expando] )
2714              return event;
2715  
2716          // store a copy of the original event object

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

2718          var originalEvent = event;
2719          event = jQuery.Event( originalEvent );
2720  
2721          for ( var i = this.props.length, prop; i; ){
2722              prop = this.props[ --i ];
2723              event[ prop ] = originalEvent[ prop ];
2724          }
2725  
2726          // Fix target property, if necessary

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

2729  
2730          // check if target is a textnode (safari)

2731          if ( event.target.nodeType == 3 )
2732              event.target = event.target.parentNode;
2733  
2734          // Add relatedTarget, if necessary

2735          if ( !event.relatedTarget && event.fromElement )
2736              event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2737  
2738          // Calculate pageX/Y if missing and clientX/Y available

2739          if ( event.pageX == null && event.clientX != null ) {
2740              var doc = document.documentElement, body = document.body;
2741              event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2742              event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2743          }
2744  
2745          // Add which for key events

2746          if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2747              event.which = event.charCode || event.keyCode;
2748  
2749          // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)

2750          if ( !event.metaKey && event.ctrlKey )
2751              event.metaKey = event.ctrlKey;
2752  
2753          // Add which for click: 1 == left; 2 == middle; 3 == right

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

2755          if ( !event.which && event.button )
2756              event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2757  
2758          return event;
2759      },
2760  
2761      proxy: function( fn, proxy ){
2762          proxy = proxy || function(){ return fn.apply(this, arguments); };
2763          // Set the guid of unique handler to the same of original handler, so it can be removed

2764          proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
2765          // So proxy can be declared as an argument

2766          return proxy;
2767      },
2768  
2769      special: {
2770          ready: {
2771              // Make sure the ready event is setup

2772              setup: bindReady,
2773              teardown: function() {}
2774          }
2775      },
2776      
2777      specialAll: {
2778          live: {
2779              setup: function( selector, namespaces ){
2780                  jQuery.event.add( this, namespaces[0], liveHandler );
2781              },
2782              teardown:  function( namespaces ){
2783                  if ( namespaces.length ) {
2784                      var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
2785                      
2786                      jQuery.each( (jQuery.data(this, "events").live || {}), function(){
2787                          if ( name.test(this.type) )
2788                              remove++;
2789                      });
2790                      
2791                      if ( remove < 1 )
2792                          jQuery.event.remove( this, namespaces[0], liveHandler );
2793                  }
2794              }
2795          }
2796      }
2797  };
2798  
2799  jQuery.Event = function( src ){
2800      // Allow instantiation without the 'new' keyword

2801      if( !this.preventDefault )
2802          return new jQuery.Event(src);
2803      
2804      // Event object

2805      if( src && src.type ){
2806          this.originalEvent = src;
2807          this.type = src.type;
2808      // Event type

2809      }else
2810          this.type = src;
2811  
2812      // timeStamp is buggy for some events on Firefox(#3843)

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

2814      this.timeStamp = now();
2815      
2816      // Mark it as fixed

2817      this[expando] = true;
2818  };
2819  
2820  function returnFalse(){
2821      return false;
2822  }
2823  function returnTrue(){
2824      return true;
2825  }
2826  
2827  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding

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

2829  jQuery.Event.prototype = {
2830      preventDefault: function() {
2831          this.isDefaultPrevented = returnTrue;
2832  
2833          var e = this.originalEvent;
2834          if( !e )
2835              return;
2836          // if preventDefault exists run it on the original event

2837          if (e.preventDefault)
2838              e.preventDefault();
2839          // otherwise set the returnValue property of the original event to false (IE)

2840          e.returnValue = false;
2841      },
2842      stopPropagation: function() {
2843          this.isPropagationStopped = returnTrue;
2844  
2845          var e = this.originalEvent;
2846          if( !e )
2847              return;
2848          // if stopPropagation exists run it on the original event

2849          if (e.stopPropagation)
2850              e.stopPropagation();
2851          // otherwise set the cancelBubble property of the original event to true (IE)

2852          e.cancelBubble = true;
2853      },
2854      stopImmediatePropagation:function(){
2855          this.isImmediatePropagationStopped = returnTrue;
2856          this.stopPropagation();
2857      },
2858      isDefaultPrevented: returnFalse,
2859      isPropagationStopped: returnFalse,
2860      isImmediatePropagationStopped: returnFalse
2861  };
2862  // Checks if an event happened on an element within another element

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

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

2866      var parent = event.relatedTarget;
2867      // Traverse up the tree

2868      while ( parent && parent != this )
2869          try { parent = parent.parentNode; }
2870          catch(e) { parent = this; }
2871      
2872      if( parent != this ){
2873          // set the correct event type

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

2876          jQuery.event.handle.apply( this, arguments );
2877      }
2878  };
2879      
2880  jQuery.each({ 
2881      mouseover: 'mouseenter', 
2882      mouseout: 'mouseleave'
2883  }, function( orig, fix ){
2884      jQuery.event.special[ fix ] = {
2885          setup: function(){
2886              jQuery.event.add( this, orig, withinElement, fix );
2887          },
2888          teardown: function(){
2889              jQuery.event.remove( this, orig, withinElement );
2890          }
2891      };               
2892  });
2893  
2894  jQuery.fn.extend({
2895      bind: function( type, data, fn ) {
2896          return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2897              jQuery.event.add( this, type, fn || data, fn && data );
2898          });
2899      },
2900  
2901      one: function( type, data, fn ) {
2902          var one = jQuery.event.proxy( fn || data, function(event) {
2903              jQuery(this).unbind(event, one);
2904              return (fn || data).apply( this, arguments );
2905          });
2906          return this.each(function(){
2907              jQuery.event.add( this, type, one, fn && data);
2908          });
2909      },
2910  
2911      unbind: function( type, fn ) {
2912          return this.each(function(){
2913              jQuery.event.remove( this, type, fn );
2914          });
2915      },
2916  
2917      trigger: function( type, data ) {
2918          return this.each(function(){
2919              jQuery.event.trigger( type, data, this );
2920          });
2921      },
2922  
2923      triggerHandler: function( type, data ) {
2924          if( this[0] ){
2925              var event = jQuery.Event(type);
2926              event.preventDefault();
2927              event.stopPropagation();
2928              jQuery.event.trigger( event, data, this[0] );
2929              return event.result;
2930          }        
2931      },
2932  
2933      toggle: function( fn ) {
2934          // Save reference to arguments for access in closure

2935          var args = arguments, i = 1;
2936  
2937          // link all the functions, so any of them can unbind this click handler

2938          while( i < args.length )
2939              jQuery.event.proxy( fn, args[i++] );
2940  
2941          return this.click( jQuery.event.proxy( fn, function(event) {
2942              // Figure out which function to execute

2943              this.lastToggle = ( this.lastToggle || 0 ) % i;
2944  
2945              // Make sure that clicks stop

2946              event.preventDefault();
2947  
2948              // and execute the function

2949              return args[ this.lastToggle++ ].apply( this, arguments ) || false;
2950          }));
2951      },
2952  
2953      hover: function(fnOver, fnOut) {
2954          return this.mouseenter(fnOver).mouseleave(fnOut);
2955      },
2956  
2957      ready: function(fn) {
2958          // Attach the listeners

2959          bindReady();
2960  
2961          // If the DOM is already ready

2962          if ( jQuery.isReady )
2963              // Execute the function immediately

2964              fn.call( document, jQuery );
2965  
2966          // Otherwise, remember the function for later

2967          else
2968              // Add the function to the wait list

2969              jQuery.readyList.push( fn );
2970  
2971          return this;
2972      },
2973      
2974      live: function( type, fn ){
2975          var proxy = jQuery.event.proxy( fn );
2976          proxy.guid += this.selector + type;
2977  
2978          jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
2979  
2980          return this;
2981      },
2982      
2983      die: function( type, fn ){
2984          jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
2985          return this;
2986      }
2987  });
2988  
2989  function liveHandler( event ){
2990      var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"),
2991          stop = true,
2992          elems = [];
2993  
2994      jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
2995          if ( check.test(fn.type) ) {
2996              var elem = jQuery(event.target).closest(fn.data)[0];
2997              if ( elem )
2998                  elems.push({ elem: elem, fn: fn });
2999          }
3000      });
3001  
3002      elems.sort(function(a,b) {
3003          return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "closest");
3004      });
3005      
3006      jQuery.each(elems, function(){
3007          if ( this.fn.call(this.elem, event, this.fn.data) === false )
3008              return (stop = false);
3009      });
3010  
3011      return stop;
3012  }
3013  
3014  function liveConvert(type, selector){
3015      return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].join(".");
3016  }
3017  
3018  jQuery.extend({
3019      isReady: false,
3020      readyList: [],
3021      // Handle when the DOM is ready

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

3024          if ( !jQuery.isReady ) {
3025              // Remember that the DOM is ready

3026              jQuery.isReady = true;
3027  
3028              // If there are functions bound, to execute

3029              if ( jQuery.readyList ) {
3030                  // Execute all of them

3031                  jQuery.each( jQuery.readyList, function(){
3032                      this.call( document, jQuery );
3033                  });
3034  
3035                  // Reset the list of functions

3036                  jQuery.readyList = null;
3037              }
3038  
3039              // Trigger any bound ready events

3040              jQuery(document).triggerHandler("ready");
3041          }
3042      }
3043  });
3044  
3045  var readyBound = false;
3046  
3047  function bindReady(){
3048      if ( readyBound ) return;
3049      readyBound = true;
3050  
3051      // Mozilla, Opera and webkit nightlies currently support this event

3052      if ( document.addEventListener ) {
3053          // Use the handy event callback

3054          document.addEventListener( "DOMContentLoaded", function(){
3055              document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
3056              jQuery.ready();
3057          }, false );
3058  
3059      // If IE event model is used

3060      } else if ( document.attachEvent ) {
3061          // ensure firing before onload,

3062          // maybe late but safe also for iframes

3063          document.attachEvent("onreadystatechange", function(){
3064              if ( document.readyState === "complete" ) {
3065                  document.detachEvent( "onreadystatechange", arguments.callee );
3066                  jQuery.ready();
3067              }
3068          });
3069  
3070          // If IE and not an iframe

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

3072          if ( document.documentElement.doScroll && window == window.top ) (function(){
3073              if ( jQuery.isReady ) return;
3074  
3075              try {
3076                  // If IE is used, use the trick by Diego Perini

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

3078                  document.documentElement.doScroll("left");
3079              } catch( error ) {
3080                  setTimeout( arguments.callee, 0 );
3081                  return;
3082              }
3083  
3084              // and execute any waiting functions

3085              jQuery.ready();
3086          })();
3087      }
3088  
3089      // A fallback to window.onload, that will always work

3090      jQuery.event.add( window, "load", jQuery.ready );
3091  }
3092  
3093  jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
3094      "mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
3095      "change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
3096  
3097      // Handle event binding

3098      jQuery.fn[name] = function(fn){
3099          return fn ? this.bind(name, fn) : this.trigger(name);
3100      };
3101  });
3102  
3103  // Prevent memory leaks in IE

3104  // And prevent errors on refresh with events like mouseover in other browsers

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

3106  jQuery( window ).bind( 'unload', function(){ 
3107      for ( var id in jQuery.cache )
3108          // Skip the window

3109          if ( id != 1 && jQuery.cache[ id ].handle )
3110              jQuery.event.remove( jQuery.cache[ id ].handle.elem );
3111  }); 
3112  (function(){
3113  
3114      jQuery.support = {};
3115  
3116      var root = document.documentElement,
3117          script = document.createElement("script"),
3118          div = document.createElement("div"),
3119          id = "script" + (new Date).getTime();
3120  
3121      div.style.display = "none";
3122      div.innerHTML = '   <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>';
3123  
3124      var all = div.getElementsByTagName("*"),
3125          a = div.getElementsByTagName("a")[0];
3126  
3127      // Can't get basic test support

3128      if ( !all || !all.length || !a ) {
3129          return;
3130      }
3131  
3132      jQuery.support = {
3133          // IE strips leading whitespace when .innerHTML is used

3134          leadingWhitespace: div.firstChild.nodeType == 3,
3135          
3136          // Make sure that tbody elements aren't automatically inserted

3137          // IE will insert them into empty tables

3138          tbody: !div.getElementsByTagName("tbody").length,
3139          
3140          // Make sure that you can get all elements in an <object> element

3141          // IE 7 always returns no results

3142          objectAll: !!div.getElementsByTagName("object")[0]
3143              .getElementsByTagName("*").length,
3144          
3145          // Make sure that link elements get serialized correctly by innerHTML

3146          // This requires a wrapper element in IE

3147          htmlSerialize: !!div.getElementsByTagName("link").length,
3148          
3149          // Get the style information from getAttribute

3150          // (IE uses .cssText insted)

3151          style: /red/.test( a.getAttribute("style") ),
3152          
3153          // Make sure that URLs aren't manipulated

3154          // (IE normalizes it by default)

3155          hrefNormalized: a.getAttribute("href") === "/a",
3156          
3157          // Make sure that element opacity exists

3158          // (IE uses filter instead)

3159          opacity: a.style.opacity === "0.5",
3160          
3161          // Verify style float existence

3162          // (IE uses styleFloat instead of cssFloat)

3163          cssFloat: !!a.style.cssFloat,
3164  
3165          // Will be defined later

3166          scriptEval: false,
3167          noCloneEvent: true,
3168          boxModel: null
3169      };
3170      
3171      script.type = "text/javascript";
3172      try {
3173          script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
3174      } catch(e){}
3175  
3176      root.insertBefore( script, root.firstChild );
3177      
3178      // Make sure that the execution of code works by injecting a script

3179      // tag with appendChild/createTextNode

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

3181      if ( window[ id ] ) {
3182          jQuery.support.scriptEval = true;
3183          delete window[ id ];
3184      }
3185  
3186      root.removeChild( script );
3187  
3188      if ( div.attachEvent && div.fireEvent ) {
3189          div.attachEvent("onclick", function(){
3190              // Cloning a node shouldn't copy over any

3191              // bound event handlers (IE does this)

3192              jQuery.support.noCloneEvent = false;
3193              div.detachEvent("onclick", arguments.callee);
3194          });
3195          div.cloneNode(true).fireEvent("onclick");
3196      }
3197  
3198      // Figure out if the W3C box model works as expected

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

3200      jQuery(function(){
3201          var div = document.createElement("div");
3202          div.style.width = div.style.paddingLeft = "1px";
3203  
3204          document.body.appendChild( div );
3205          jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
3206          document.body.removeChild( div ).style.display = 'none';
3207      });
3208  })();
3209  
3210  var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat";
3211  
3212  jQuery.props = {
3213      "for": "htmlFor",
3214      "class": "className",
3215      "float": styleFloat,
3216      cssFloat: styleFloat,
3217      styleFloat: styleFloat,
3218      readonly: "readOnly",
3219      maxlength: "maxLength",
3220      cellspacing: "cellSpacing",
3221      rowspan: "rowSpan",
3222      tabindex: "tabIndex"
3223  };
3224  jQuery.fn.extend({
3225      // Keep a copy of the old load

3226      _load: jQuery.fn.load,
3227  
3228      load: function( url, params, callback ) {
3229          if ( typeof url !== "string" )
3230              return this._load( url );
3231  
3232          var off = url.indexOf(" ");
3233          if ( off >= 0 ) {
3234              var selector = url.slice(off, url.length);
3235              url = url.slice(0, off);
3236          }
3237  
3238          // Default to a GET request

3239          var type = "GET";
3240  
3241          // If the second parameter was provided

3242          if ( params )
3243              // If it's a function

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

3246                  callback = params;
3247                  params = null;
3248  
3249              // Otherwise, build a param string

3250              } else if( typeof params === "object" ) {
3251                  params = jQuery.param( params );
3252                  type = "POST";
3253              }
3254  
3255          var self = this;
3256  
3257          // Request the remote document

3258          jQuery.ajax({
3259              url: url,
3260              type: type,
3261              dataType: "html",
3262              data: params,
3263              complete: function(res, status){
3264                  // If successful, inject the HTML into all the matched elements

3265                  if ( status == "success" || status == "notmodified" )
3266                      // See if a selector was specified

3267                      self.html( selector ?
3268                          // Create a dummy div to hold the results

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

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

3272                              .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
3273  
3274                              // Locate the specified elements

3275                              .find(selector) :
3276  
3277                          // If not, just inject the full result

3278                          res.responseText );
3279  
3280                  if( callback )
3281                      self.each( callback, [res.responseText, status, res] );
3282              }
3283          });
3284          return this;
3285      },
3286  
3287      serialize: function() {
3288          return jQuery.param(this.serializeArray());
3289      },
3290      serializeArray: function() {
3291          return this.map(function(){
3292              return this.elements ? jQuery.makeArray(this.elements) : this;
3293          })
3294          .filter(function(){
3295              return this.name && !this.disabled &&
3296                  (this.checked || /select|textarea/i.test(this.nodeName) ||
3297                      /text|hidden|password|search/i.test(this.type));
3298          })
3299          .map(function(i, elem){
3300              var val = jQuery(this).val();
3301              return val == null ? null :
3302                  jQuery.isArray(val) ?
3303                      jQuery.map( val, function(val, i){
3304                          return {name: elem.name, value: val};
3305                      }) :
3306                      {name: elem.name, value: val};
3307          }).get();
3308      }
3309  });
3310  
3311  // Attach a bunch of functions for handling common AJAX events

3312  jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
3313      jQuery.fn[o] = function(f){
3314          return this.bind(o, f);
3315      };
3316  });
3317  
3318  var jsc = now();
3319  
3320  jQuery.extend({
3321    
3322      get: function( url, data, callback, type ) {
3323          // shift arguments if data argument was ommited

3324          if ( jQuery.isFunction( data ) ) {
3325              callback = data;
3326              data = null;
3327          }
3328  
3329          return jQuery.ajax({
3330              type: "GET",
3331              url: url,
3332              data: data,
3333              success: callback,
3334              dataType: type
3335          });
3336      },
3337  
3338      getScript: function( url, callback ) {
3339          return jQuery.get(url, null, callback, "script");
3340      },
3341  
3342      getJSON: function( url, data, callback ) {
3343          return jQuery.get(url, data, callback, "json");
3344      },
3345  
3346      post: function( url, data, callback, type ) {
3347          if ( jQuery.isFunction( data ) ) {
3348              callback = data;
3349              data = {};
3350          }
3351  
3352          return jQuery.ajax({
3353              type: "POST",
3354              url: url,
3355              data: data,
3356              success: callback,
3357              dataType: type
3358          });
3359      },
3360  
3361      ajaxSetup: function( settings ) {
3362          jQuery.extend( jQuery.ajaxSettings, settings );
3363      },
3364  
3365      ajaxSettings: {
3366          url: location.href,
3367          global: true,
3368          type: "GET",
3369          contentType: "application/x-www-form-urlencoded",
3370          processData: true,
3371          async: true,
3372          /*

3373          timeout: 0,

3374          data: null,

3375          username: null,

3376          password: null,

3377          */
3378          // Create the request object; Microsoft failed to properly

3379          // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available

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

3381          xhr:function(){
3382              return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
3383          },
3384          accepts: {
3385              xml: "application/xml, text/xml",
3386              html: "text/html",
3387              script: "text/javascript, application/javascript",
3388              json: "application/json, text/javascript",
3389              text: "text/plain",
3390              _default: "*/*"

3391          }

3392      },

3393  

3394      // Last-Modified header cache for next request

3395      lastModified: {},

3396  

3397      ajax: function( s ) {

3398          // Extend the settings, but re-extend 's' so that it can be

3399          // checked again later (in the test suite, specifically)

3400          s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));

3401  

3402          var jsonp, jsre = /=\?(&|$)/g, status, data,

3403              type = s.type.toUpperCase();

3404  

3405          // convert data if not already a string

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

3407              s.data = jQuery.param(s.data);

3408  

3409          // Handle JSONP Parameter Callbacks

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

3411              if ( type == "GET" ) {

3412                  if ( !s.url.match(jsre) )

3413                      s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";

3414              } else if ( !s.data || !s.data.match(jsre) )

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

3416              s.dataType = "json";

3417          }

3418  

3419          // Build temporary JSONP function

3420          if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {

3421              jsonp = "jsonp" + jsc++;

3422  

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

3424              if ( s.data )

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

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

3427  

3428              // We need to make sure

3429              // that a JSONP style response is executed properly

3430              s.dataType = "script";

3431  

3432              // Handle JSONP-style loading

3433              window[ jsonp ] = function(tmp){

3434                  data = tmp;

3435                  success();

3436                  complete();

3437                  // Garbage collect

3438                  window[ jsonp ] = undefined;

3439                  try{ delete window[ jsonp ]; } catch(e){}

3440                  if ( head )

3441                      head.removeChild( script );

3442              };

3443          }

3444  

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

3446              s.cache = false;

3447  

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

3449              var ts = now();

3450              // try replacing _= if it is there

3451              var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");

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

3453              s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");

3454          }

3455  

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

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

3458              s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;

3459  

3460              // IE likes to send both get and post data, prevent this

3461              s.data = null;

3462          }

3463  

3464          // Watch for a new set of requests

3465          if ( s.global && ! jQuery.active++ )

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

3467  

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

3469          var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );

3470  

3471          // If we're requesting a remote document

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

3473          if ( s.dataType == "script" && type == "GET" && parts

3474              && ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){

3475  

3476              var head = document.getElementsByTagName("head")[0];

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

3478              script.src = s.url;

3479              if (s.scriptCharset)

3480                  script.charset = s.scriptCharset;

3481  

3482              // Handle Script loading

3483              if ( !jsonp ) {

3484                  var done = false;

3485  

3486                  // Attach handlers for all browsers

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

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

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

3490                          done = true;

3491                          success();

3492                          complete();

3493  

3494                          // Handle memory leak in IE

3495                          script.onload = script.onreadystatechange = null;

3496                          head.removeChild( script );

3497                      }

3498                  };

3499              }

3500  

3501              head.appendChild(script);

3502  

3503              // We handle everything using the script element injection

3504              return undefined;

3505          }

3506  

3507          var requestDone = false;

3508  

3509          // Create the request object

3510          var xhr = s.xhr();

3511  

3512          // Open the socket

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

3514          if( s.username )

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

3516          else

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

3518  

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

3520          try {

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

3522              if ( s.data )

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

3524  

3525              // Set the If-Modified-Since header, if ifModified mode.

3526              if ( s.ifModified )

3527                  xhr.setRequestHeader("If-Modified-Since",

3528                      jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );

3529  

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

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

3532  

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

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

3535                  s.accepts[ s.dataType ] + ", */*" :
3536                  s.accepts._default );
3537          } catch(e){}
3538  
3539          // Allow custom headers/mimetypes and early abort

3540          if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
3541              // Handle the global AJAX counter

3542              if ( s.global && ! --jQuery.active )
3543                  jQuery.event.trigger( "ajaxStop" );
3544              // close opended socket

3545              xhr.abort();
3546              return false;
3547          }
3548  
3549          if ( s.global )
3550              jQuery.event.trigger("ajaxSend", [xhr, s]);
3551  
3552          // Wait for a response to come back

3553          var onreadystatechange = function(isTimeout){
3554              // The request was aborted, clear the interval and decrement jQuery.active

3555              if (xhr.readyState == 0) {
3556                  if (ival) {
3557                      // clear poll interval

3558                      clearInterval(ival);
3559                      ival = null;
3560                      // Handle the global AJAX counter

3561                      if ( s.global && ! --jQuery.active )
3562                          jQuery.event.trigger( "ajaxStop" );
3563                  }
3564              // The transfer is complete and the data is available, or the request timed out

3565              } else if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
3566                  requestDone = true;
3567  
3568                  // clear poll interval

3569                  if (ival) {
3570                      clearInterval(ival);
3571                      ival = null;
3572                  }
3573  
3574                  status = isTimeout == "timeout" ? "timeout" :
3575                      !jQuery.httpSuccess( xhr ) ? "error" :
3576                      s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
3577                      "success";
3578  
3579                  if ( status == "success" ) {
3580                      // Watch for, and catch, XML document parse errors

3581                      try {
3582                          // process the data (runs the xml through httpData regardless of callback)

3583                          data = jQuery.httpData( xhr, s.dataType, s );
3584                      } catch(e) {
3585                          status = "parsererror";
3586                      }
3587                  }
3588  
3589                  // Make sure that the request was successful or notmodified

3590                  if ( status == "success" ) {
3591                      // Cache Last-Modified header, if ifModified mode.

3592                      var modRes;
3593                      try {
3594                          modRes = xhr.getResponseHeader("Last-Modified");
3595                      } catch(e) {} // swallow exception thrown by FF if header is not available

3596  
3597                      if ( s.ifModified && modRes )
3598                          jQuery.lastModified[s.url] = modRes;
3599  
3600                      // JSONP handles its own success callback

3601                      if ( !jsonp )
3602                          success();
3603                  } else
3604                      jQuery.handleError(s, xhr, status);
3605  
3606                  // Fire the complete handlers

3607                  complete();
3608  
3609                  if ( isTimeout )
3610                      xhr.abort();
3611  
3612                  // Stop memory leaks

3613                  if ( s.async )
3614                      xhr = null;
3615              }
3616          };
3617  
3618          if ( s.async ) {
3619              // don't attach the handler to the request, just poll it instead

3620              var ival = setInterval(onreadystatechange, 13);
3621  
3622              // Timeout checker

3623              if ( s.timeout > 0 )
3624                  setTimeout(function(){
3625                      // Check to see if the request is still happening

3626                      if ( xhr && !requestDone )
3627                          onreadystatechange( "timeout" );
3628                  }, s.timeout);
3629          }
3630  
3631          // Send the data

3632          try {
3633              xhr.send(s.data);
3634          } catch(e) {
3635              jQuery.handleError(s, xhr, null, e);
3636          }
3637  
3638          // firefox 1.5 doesn't fire statechange for sync requests

3639          if ( !s.async )
3640              onreadystatechange();
3641  
3642  		function success(){
3643              // If a local callback was specified, fire it and pass it the data

3644              if ( s.success )
3645                  s.success( data, status );
3646  
3647              // Fire the global callback

3648              if ( s.global )
3649                  jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
3650          }
3651  
3652  		function complete(){
3653              // Process result

3654              if ( s.complete )
3655                  s.complete(xhr, status);
3656  
3657              // The request was completed

3658              if ( s.global )
3659                  jQuery.event.trigger( "ajaxComplete", [xhr, s] );
3660  
3661              // Handle the global AJAX counter

3662              if ( s.global && ! --jQuery.active )
3663                  jQuery.event.trigger( "ajaxStop" );
3664          }
3665  
3666          // return XMLHttpRequest to allow aborting the request etc.

3667          return xhr;
3668      },
3669  
3670      handleError: function( s, xhr, status, e ) {
3671          // If a local callback was specified, fire it

3672          if ( s.error ) s.error( xhr, status, e );
3673  
3674          // Fire the global callback

3675          if ( s.global )
3676              jQuery.event.trigger( "ajaxError", [xhr, s, e] );
3677      },
3678  
3679      // Counter for holding the number of active queries

3680      active: 0,
3681  
3682      // Determines if an XMLHttpRequest was successful or not

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

3686              return !xhr.status && location.protocol == "file:" ||
3687                  ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223;
3688          } catch(e){}
3689          return false;
3690      },
3691  
3692      // Determines if an XMLHttpRequest returns NotModified

3693      httpNotModified: function( xhr, url ) {
3694          try {
3695              var xhrRes = xhr.getResponseHeader("Last-Modified");
3696  
3697              // Firefox always returns 200. check Last-Modified date

3698              return xhr.status == 304 || xhrRes == jQuery.lastModified[url];
3699          } catch(e){}
3700          return false;
3701      },
3702  
3703      httpData: function( xhr, type, s ) {
3704          var ct = xhr.getResponseHeader("content-type"),
3705              xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
3706              data = xml ? xhr.responseXML : xhr.responseText;
3707  
3708          if ( xml && data.documentElement.tagName == "parsererror" )
3709              throw "parsererror";
3710              
3711          // Allow a pre-filtering function to sanitize the response

3712          // s != null is checked to keep backwards compatibility

3713          if( s && s.dataFilter )
3714              data = s.dataFilter( data, type );
3715  
3716          // The filter can actually parse the response

3717          if( typeof data === "string" ){
3718  
3719              // If the type is "script", eval it in global context

3720              if ( type == "script" )
3721                  jQuery.globalEval( data );
3722  
3723              // Get the JavaScript object, if JSON is used.

3724              if ( type == "json" )
3725                  data = window["eval"]("(" + data + ")");
3726          }
3727          
3728          return data;
3729      },
3730  
3731      // Serialize an array of form elements or a set of

3732      // key/values into a query string

3733      param: function( a ) {
3734          var s = [ ];
3735  
3736  		function add( key, value ){
3737              s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
3738          };
3739  
3740          // If an array was passed in, assume that it is an array

3741          // of form elements

3742          if ( jQuery.isArray(a) || a.jquery )
3743              // Serialize the form elements

3744              jQuery.each( a, function(){
3745                  add( this.name, this.value );
3746              });
3747  
3748          // Otherwise, assume that it's an object of key/value pairs

3749          else
3750              // Serialize the key/values

3751              for ( var j in a )
3752                  // If the value is an array then the key names need to be repeated

3753                  if ( jQuery.isArray(a[j]) )
3754                      jQuery.each( a[j], function(){
3755                          add( j, this );
3756                      });
3757                  else
3758                      add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
3759  
3760          // Return the resulting serialization

3761          return s.join("&").replace(/%20/g, "+");
3762      }
3763  
3764  });
3765  var elemdisplay = {},
3766      timerId,
3767      fxAttrs = [
3768          // height animations

3769          [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
3770          // width animations

3771          [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
3772          // opacity animations

3773          [ "opacity" ]
3774      ];
3775  
3776  function genFx( type, num ){
3777      var obj = {};
3778      jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){
3779          obj[ this ] = type;
3780      });
3781      return obj;
3782  }
3783  
3784  jQuery.fn.extend({
3785      show: function(speed,callback){
3786          if ( speed ) {
3787              return this.animate( genFx("show", 3), speed, callback);
3788          } else {
3789              for ( var i = 0, l = this.length; i < l; i++ ){
3790                  var old = jQuery.data(this[i], "olddisplay");
3791                  
3792                  this[i].style.display = old || "";
3793                  
3794                  if ( jQuery.css(this[i], "display") === "none" ) {
3795                      var tagName = this[i].tagName, display;
3796                      
3797                      if ( elemdisplay[ tagName ] ) {
3798                          display = elemdisplay[ tagName ];
3799                      } else {
3800                          var elem = jQuery("<" + tagName + " />").appendTo("body");
3801                          
3802                          display = elem.css("display");
3803                          if ( display === "none" )
3804                              display = "block";
3805                          
3806                          elem.remove();
3807                          
3808                          elemdisplay[ tagName ] = display;
3809                      }
3810                      
3811                      jQuery.data(this[i], "olddisplay", display);
3812                  }
3813              }
3814  
3815              // Set the display of the elements in a second loop

3816              // to avoid the constant reflow

3817              for ( var i = 0, l = this.length; i < l; i++ ){
3818                  this[i].style.display = jQuery.data(this[i], "olddisplay") || "";
3819              }
3820              
3821              return this;
3822          }
3823      },
3824  
3825      hide: function(speed,callback){
3826          if ( speed ) {
3827              return this.animate( genFx("hide", 3), speed, callback);
3828          } else {
3829              for ( var i = 0, l = this.length; i < l; i++ ){
3830                  var old = jQuery.data(this[i], "olddisplay");
3831                  if ( !old && old !== "none" )
3832                      jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
3833              }
3834  
3835              // Set the display of the elements in a second loop

3836              // to avoid the constant reflow

3837              for ( var i = 0, l = this.length; i < l; i++ ){
3838                  this[i].style.display = "none";
3839              }
3840  
3841              return this;
3842          }
3843      },
3844  
3845      // Save the old toggle function

3846      _toggle: jQuery.fn.toggle,
3847  
3848      toggle: function( fn, fn2 ){
3849          var bool = typeof fn === "boolean";
3850  
3851          return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
3852              this._toggle.apply( this, arguments ) :
3853              fn == null || bool ?
3854                  this.each(function(){
3855                      var state = bool ? fn : jQuery(this).is(":hidden");
3856                      jQuery(this)[ state ? "show" : "hide" ]();
3857                  }) :
3858                  this.animate(genFx("toggle", 3), fn, fn2);
3859      },
3860  
3861      fadeTo: function(speed,to,callback){
3862          return this.animate({opacity: to}, speed, callback);
3863      },
3864  
3865      animate: function( prop, speed, easing, callback ) {
3866          var optall = jQuery.speed(speed, easing, callback);
3867  
3868          return this[ optall.queue === false ? "each" : "queue" ](function(){
3869          
3870              var opt = jQuery.extend({}, optall), p,
3871                  hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
3872                  self = this;
3873      
3874              for ( p in prop ) {
3875                  if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
3876                      return opt.complete.call(this);
3877  
3878                  if ( ( p == "height" || p == "width" ) && this.style ) {
3879                      // Store display property

3880                      opt.display = jQuery.css(this, "display");
3881  
3882                      // Make sure that nothing sneaks out

3883                      opt.overflow = this.style.overflow;
3884                  }
3885              }
3886  
3887              if ( opt.overflow != null )
3888                  this.style.overflow = "hidden";
3889  
3890              opt.curAnim = jQuery.extend({}, prop);
3891  
3892              jQuery.each( prop, function(name, val){
3893                  var e = new jQuery.fx( self, opt, name );
3894  
3895                  if ( /toggle|show|hide/.test(val) )
3896                      e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3897                  else {
3898                      var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3899                          start = e.cur(true) || 0;
3900  
3901                      if ( parts ) {
3902                          var end = parseFloat(parts[2]),
3903                              unit = parts[3] || "px";
3904  
3905                          // We need to compute starting value

3906                          if ( unit != "px" ) {
3907                              self.style[ name ] = (end || 1) + unit;
3908                              start = ((end || 1) / e.cur(true)) * start;
3909                              self.style[ name ] = start + unit;
3910                          }
3911  
3912                          // If a +=/-= token was provided, we're doing a relative animation

3913                          if ( parts[1] )
3914                              end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3915  
3916                          e.custom( start, end, unit );
3917                      } else
3918                          e.custom( start, val, "" );
3919                  }
3920              });
3921  
3922              // For JS strict compliance

3923              return true;
3924          });
3925      },
3926  
3927      stop: function(clearQueue, gotoEnd){
3928          var timers = jQuery.timers;
3929  
3930          if (clearQueue)
3931              this.queue([]);
3932  
3933          this.each(function(){
3934              // go in reverse order so anything added to the queue during the loop is ignored

3935              for ( var i = timers.length - 1; i >= 0; i-- )
3936                  if ( timers[i].elem == this ) {
3937                      if (gotoEnd)
3938                          // force the next step to be the last

3939                          timers[i](true);
3940                      timers.splice(i, 1);
3941                  }
3942          });
3943  
3944          // start the next in the queue if the last step wasn't forced

3945          if (!gotoEnd)
3946              this.dequeue();
3947  
3948          return this;
3949      }
3950  
3951  });
3952  
3953  // Generate shortcuts for custom animations

3954  jQuery.each({
3955      slideDown: genFx("show", 1),
3956      slideUp: genFx("hide", 1),
3957      slideToggle: genFx("toggle", 1),
3958      fadeIn: { opacity: "show" },
3959      fadeOut: { opacity: "hide" }
3960  }, function( name, props ){
3961      jQuery.fn[ name ] = function( speed, callback ){
3962          return this.animate( props, speed, callback );
3963      };
3964  });
3965  
3966  jQuery.extend({
3967  
3968      speed: function(speed, easing, fn) {
3969          var opt = typeof speed === "object" ? speed : {
3970              complete: fn || !fn && easing ||
3971                  jQuery.isFunction( speed ) && speed,
3972              duration: speed,
3973              easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
3974          };
3975  
3976          opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
3977              jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
3978  
3979          // Queueing

3980          opt.old = opt.complete;
3981          opt.complete = function(){
3982              if ( opt.queue !== false )
3983                  jQuery(this).dequeue();
3984              if ( jQuery.isFunction( opt.old ) )
3985                  opt.old.call( this );
3986          };
3987  
3988          return opt;
3989      },
3990  
3991      easing: {
3992          linear: function( p, n, firstNum, diff ) {
3993              return firstNum + diff * p;
3994          },
3995          swing: function( p, n, firstNum, diff ) {
3996              return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
3997          }
3998      },
3999  
4000      timers: [],
4001  
4002      fx: function( elem, options, prop ){
4003          this.options = options;
4004          this.elem = elem;
4005          this.prop = prop;
4006  
4007          if ( !options.orig )
4008              options.orig = {};
4009      }
4010  
4011  });
4012  
4013  jQuery.fx.prototype = {
4014  
4015      // Simple function for setting a style value

4016      update: function(){
4017          if ( this.options.step )
4018              this.options.step.call( this.elem, this.now, this );
4019  
4020          (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
4021  
4022          // Set display property to block for height/width animations

4023          if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
4024              this.elem.style.display = "block";
4025      },
4026  
4027      // Get the current size

4028      cur: function(force){
4029          if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
4030              return this.elem[ this.prop ];
4031  
4032          var r = parseFloat(jQuery.css(this.elem, this.prop, force));
4033          return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
4034      },
4035  
4036      // Start an animation from one number to another

4037      custom: function(from, to, unit){
4038          this.startTime = now();
4039          this.start = from;
4040          this.end = to;
4041          this.unit = unit || this.unit || "px";
4042          this.now = this.start;
4043          this.pos = this.state = 0;
4044  
4045          var self = this;
4046          function t(gotoEnd){
4047              return self.step(gotoEnd);
4048          }
4049  
4050          t.elem = this.elem;
4051  
4052          if ( t() && jQuery.timers.push(t) && !timerId ) {
4053              timerId = setInterval(function(){
4054                  var timers = jQuery.timers;
4055  
4056                  for ( var i = 0; i < timers.length; i++ )
4057                      if ( !timers[i]() )
4058                          timers.splice(i--, 1);
4059  
4060                  if ( !timers.length ) {
4061                      clearInterval( timerId );
4062                      timerId = undefined;
4063                  }
4064              }, 13);
4065          }
4066      },
4067  
4068      // Simple 'show' function

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

4071          this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
4072          this.options.show = true;
4073  
4074          // Begin the animation

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

4076          // flash of content

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

4080          jQuery(this.elem).show();
4081      },
4082  
4083      // Simple 'hide' function

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

4086          this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
4087          this.options.hide = true;
4088  
4089          // Begin the animation

4090          this.custom(this.cur(), 0);
4091      },
4092  
4093      // Each step of an animation

4094      step: function(gotoEnd){
4095          var t = now();
4096  
4097          if ( gotoEnd || t >= this.options.duration + this.startTime ) {
4098              this.now = this.end;
4099              this.pos = this.state = 1;
4100              this.update();
4101  
4102              this.options.curAnim[ this.prop ] = true;
4103  
4104              var done = true;
4105              for ( var i in this.options.curAnim )
4106                  if ( this.options.curAnim[i] !== true )
4107                      done = false;
4108  
4109              if ( done ) {
4110                  if ( this.options.display != null ) {
4111                      // Reset the overflow

4112                      this.elem.style.overflow = this.options.overflow;
4113  
4114                      // Reset the display

4115                      this.elem.style.display = this.options.display;
4116                      if ( jQuery.css(this.elem, "display") == "none" )
4117                          this.elem.style.display = "block";
4118                  }
4119  
4120                  // Hide the element if the "hide" operation was done

4121                  if ( this.options.hide )
4122                      jQuery(this.elem).hide();
4123  
4124                  // Reset the properties, if the item has been hidden or shown

4125                  if ( this.options.hide || this.options.show )
4126                      for ( var p in this.options.curAnim )
4127                          jQuery.attr(this.elem.style, p, this.options.orig[p]);
4128                      
4129                  // Execute the complete function

4130                  this.options.complete.call( this.elem );
4131              }
4132  
4133              return false;
4134          } else {
4135              var n = t - this.startTime;
4136              this.state = n / this.options.duration;
4137  
4138              // Perform the easing function, defaults to swing

4139              this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
4140              this.now = this.start + ((this.end - this.start) * this.pos);
4141  
4142              // Perform the next step of the animation

4143              this.update();
4144          }
4145  
4146          return true;
4147      }
4148  
4149  };
4150  
4151  jQuery.extend( jQuery.fx, {
4152      speeds:{
4153          slow: 600,
4154           fast: 200,
4155           // Default speed

4156           _default: 400
4157      },
4158      step: {
4159  
4160          opacity: function(fx){
4161              jQuery.attr(fx.elem.style, "opacity", fx.now);
4162          },
4163  
4164          _default: function(fx){
4165              if ( fx.elem.style && fx.elem.style[ fx.prop ] != null )
4166                  fx.elem.style[ fx.prop ] = fx.now + fx.unit;
4167              else
4168                  fx.elem[ fx.prop ] = fx.now;
4169          }
4170      }
4171  });
4172  if ( document.documentElement["getBoundingClientRect"] )
4173      jQuery.fn.offset = function() {
4174          if ( !this[0] ) return { top: 0, left: 0 };
4175          if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4176          var box  = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
4177              clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
4178              top  = box.top  + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
4179              left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
4180          return { top: top, left: left };
4181      };
4182  else 
4183      jQuery.fn.offset = function() {
4184          if ( !this[0] ) return { top: 0, left: 0 };
4185          if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4186          jQuery.offset.initialized || jQuery.offset.initialize();
4187  
4188          var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
4189              doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
4190              body = doc.body, defaultView = doc.defaultView,
4191              prevComputedStyle = defaultView.getComputedStyle(elem, null),
4192              top = elem.offsetTop, left = elem.offsetLeft;
4193  
4194          while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
4195              computedStyle = defaultView.getComputedStyle(elem, null);
4196              top -= elem.scrollTop, left -= elem.scrollLeft;
4197              if ( elem === offsetParent ) {
4198                  top += elem.offsetTop, left += elem.offsetLeft;
4199                  if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
4200                      top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
4201                      left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
4202                  prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
4203              }
4204              if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
4205                  top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
4206                  left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
4207              prevComputedStyle = computedStyle;
4208          }
4209  
4210          if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
4211              top  += body.offsetTop,
4212              left += body.offsetLeft;
4213  
4214          if ( prevComputedStyle.position === "fixed" )
4215              top  += Math.max(docElem.scrollTop, body.scrollTop),
4216              left += Math.max(docElem.scrollLeft, body.scrollLeft);
4217  
4218          return { top: top, left: left };
4219      };
4220  
4221  jQuery.offset = {
4222      initialize: function() {
4223          if ( this.initialized ) return;
4224          var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop,
4225              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>';
4226  
4227          rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
4228          for ( prop in rules ) container.style[prop] = rules[prop];
4229  
4230          container.innerHTML = html;
4231          body.insertBefore(container, body.firstChild);
4232          innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
4233  
4234          this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
4235          this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
4236  
4237          innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
4238          this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
4239  
4240          body.style.marginTop = '1px';
4241          this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
4242          body.style.marginTop = bodyMarginTop;
4243  
4244          body.removeChild(container);
4245          this.initialized = true;
4246      },
4247  
4248      bodyOffset: function(body) {
4249          jQuery.offset.initialized || jQuery.offset.initialize();
4250          var top = body.offsetTop, left = body.offsetLeft;
4251          if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
4252              top  += parseInt( jQuery.curCSS(body, 'marginTop',  true), 10 ) || 0,
4253              left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0;
4254          return { top: top, left: left };
4255      }
4256  };
4257  
4258  
4259  jQuery.fn.extend({
4260      position: function() {
4261          var left = 0, top = 0, results;
4262  
4263          if ( this[0] ) {
4264              // Get *real* offsetParent

4265              var offsetParent = this.offsetParent(),
4266  
4267              // Get correct offsets

4268              offset       = this.offset(),
4269              parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
4270  
4271              // Subtract element margins

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

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

4274              offset.top  -= num( this, 'marginTop'  );
4275              offset.left -= num( this, 'marginLeft' );
4276  
4277              // Add offsetParent borders

4278              parentOffset.top  += num( offsetParent, 'borderTopWidth'  );
4279              parentOffset.left += num( offsetParent, 'borderLeftWidth' );
4280  
4281              // Subtract the two offsets

4282              results = {
4283                  top:  offset.top  - parentOffset.top,
4284                  left: offset.left - parentOffset.left
4285              };
4286          }
4287  
4288          return results;
4289      },
4290  
4291      offsetParent: function() {
4292          var offsetParent = this[0].offsetParent || document.body;
4293          while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
4294              offsetParent = offsetParent.offsetParent;
4295          return jQuery(offsetParent);
4296      }
4297  });
4298  
4299  
4300  // Create scrollLeft and scrollTop methods

4301  jQuery.each( ['Left', 'Top'], function(i, name) {
4302      var method = 'scroll' + name;
4303      
4304      jQuery.fn[ method ] = function(val) {
4305          if (!this[0]) return null;
4306  
4307          return val !== undefined ?
4308  
4309              // Set the scroll offset

4310              this.each(function() {
4311                  this == window || this == document ?
4312                      window.scrollTo(
4313                          !i ? val : jQuery(window).scrollLeft(),
4314                           i ? val : jQuery(window).scrollTop()
4315                      ) :
4316                      this[ method ] = val;
4317              }) :
4318  
4319              // Return the scroll offset

4320              this[0] == window || this[0] == document ?
4321                  self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
4322                      jQuery.boxModel && document.documentElement[ method ] ||
4323                      document.body[ method ] :
4324                  this[0][ method ];
4325      };
4326  });
4327  // Create innerHeight, innerWidth, outerHeight and outerWidth methods

4328  jQuery.each([ "Height", "Width" ], function(i, name){
4329  
4330      var tl = i ? "Left"  : "Top",  // top or left
4331          br = i ? "Right" : "Bottom", // bottom or right
4332          lower = name.toLowerCase();
4333  
4334      // innerHeight and innerWidth

4335      jQuery.fn["inner" + name] = function(){
4336          return this[0] ?
4337              jQuery.css( this[0], lower, false, "padding" ) :
4338              null;
4339      };
4340  
4341      // outerHeight and outerWidth

4342      jQuery.fn["outer" + name] = function(margin) {
4343          return this[0] ?
4344              jQuery.css( this[0], lower, false, margin ? "margin" : "border" ) :
4345              null;
4346      };
4347      
4348      var type = name.toLowerCase();
4349  
4350      jQuery.fn[ type ] = function( size ) {
4351          // Get window width or height

4352          return this[0] == window ?
4353              // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode

4354              document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
4355              document.body[ "client" + name ] :
4356  
4357              // Get document width or height

4358              this[0] == document ?
4359                  // Either scroll[Width/Height] or offset[Width/Height], whichever is greater

4360                  Math.max(
4361                      document.documentElement["client" + name],
4362                      document.body["scroll" + name], document.documentElement["scroll" + name],
4363                      document.body["offset" + name], document.documentElement["offset" + name]
4364                  ) :
4365  
4366                  // Get or set width or height on the element

4367                  size === undefined ?
4368                      // Get width or height on the element

4369                      (this.length ? jQuery.css( this[0], type ) : null) :
4370  
4371                      // Set the width or height on the element (default to pixels if value is unitless)

4372                      this.css( type, typeof size === "string" ? size : size + "px" );
4373      };
4374  
4375  });
4376  })();