[Summary view] [Print] [Text view]

   1  (function(){
   2  /*
   3   * jQuery 1.2.6 - New Wave Javascript
   4   *
   5   * Copyright (c) 2008 John Resig (jquery.com)
   6   * Dual licensed under the MIT (MIT-LICENSE.txt)
   7   * and GPL (GPL-LICENSE.txt) licenses.
   8   *
   9   * $Date: 2009-03-17 18:35:18 $
  10   * $Rev: 5685 $
  11   */
  12  
  13  // Map over jQuery in case of overwrite
  14  var _jQuery = window.jQuery,
  15  // Map over the $ in case of overwrite
  16      _$ = window.$;
  17  
  18  var jQuery = window.jQuery = window.$ = function( selector, context ) {
  19      // The jQuery object is actually just the init constructor 'enhanced'
  20      return new jQuery.fn.init( selector, context );
  21  };
  22  
  23  // A simple way to check for HTML strings or ID strings
  24  // (both of which we optimize for)
  25  var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/,
  26  
  27  // Is it a simple selector
  28      isSimple = /^.[^:#\[\.]*$/,
  29  
  30  // Will speed up references to undefined, and allows munging its name.
  31      undefined;
  32  
  33  jQuery.fn = jQuery.prototype = {
  34      init: function( selector, context ) {
  35          // Make sure that a selection was provided
  36          selector = selector || document;
  37  
  38          // Handle $(DOMElement)
  39          if ( selector.nodeType ) {
  40              this[0] = selector;
  41              this.length = 1;
  42              return this;
  43          }
  44          // Handle HTML strings
  45          if ( typeof selector == "string" ) {
  46              // Are we dealing with HTML string or an ID?
  47              var match = quickExpr.exec( selector );
  48  
  49              // Verify a match, and that no context was specified for #id
  50              if ( match && (match[1] || !context) ) {
  51  
  52                  // HANDLE: $(html) -> $(array)
  53                  if ( match[1] )
  54                      selector = jQuery.clean( [ match[1] ], context );
  55  
  56                  // HANDLE: $("#id")
  57                  else {
  58                      var elem = document.getElementById( match[3] );
  59  
  60                      // Make sure an element was located
  61                      if ( elem ){
  62                          // Handle the case where IE and Opera return items
  63                          // by name instead of ID
  64                          if ( elem.id != match[3] )
  65                              return jQuery().find( selector );
  66  
  67                          // Otherwise, we inject the element directly into the jQuery object
  68                          return jQuery( elem );
  69                      }
  70                      selector = [];
  71                  }
  72  
  73              // HANDLE: $(expr, [context])
  74              // (which is just equivalent to: $(content).find(expr)
  75              } else
  76                  return jQuery( context ).find( selector );
  77  
  78          // HANDLE: $(function)
  79          // Shortcut for document ready
  80          } else if ( jQuery.isFunction( selector ) )
  81              return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
  82  
  83          return this.setArray(jQuery.makeArray(selector));
  84      },
  85  
  86      // The current version of jQuery being used
  87      jquery: "1.2.6",
  88  
  89      // The number of elements contained in the matched element set
  90      size: function() {
  91          return this.length;
  92      },
  93  
  94      // The number of elements contained in the matched element set
  95      length: 0,
  96  
  97      // Get the Nth element in the matched element set OR
  98      // Get the whole matched element set as a clean array
  99      get: function( num ) {
 100          return num == undefined ?
 101  
 102              // Return a 'clean' array
 103              jQuery.makeArray( this ) :
 104  
 105              // Return just the object
 106              this[ num ];
 107      },
 108  
 109      // Take an array of elements and push it onto the stack
 110      // (returning the new matched element set)
 111      pushStack: function( elems ) {
 112          // Build a new jQuery matched element set
 113          var ret = jQuery( elems );
 114  
 115          // Add the old object onto the stack (as a reference)
 116          ret.prevObject = this;
 117  
 118          // Return the newly-formed element set
 119          return ret;
 120      },
 121  
 122      // Force the current matched set of elements to become
 123      // the specified array of elements (destroying the stack in the process)
 124      // You should use pushStack() in order to do this, but maintain the stack
 125      setArray: function( elems ) {
 126          // Resetting the length to 0, then using the native Array push
 127          // is a super-fast way to populate an object with array-like properties
 128          this.length = 0;
 129          Array.prototype.push.apply( this, elems );
 130  
 131          return this;
 132      },
 133  
 134      // Execute a callback for every element in the matched set.
 135      // (You can seed the arguments with an array of args, but this is
 136      // only used internally.)
 137      each: function( callback, args ) {
 138          return jQuery.each( this, callback, args );
 139      },
 140  
 141      // Determine the position of an element within
 142      // the matched set of elements
 143      index: function( elem ) {
 144          var ret = -1;
 145  
 146          // Locate the position of the desired element
 147          return jQuery.inArray(
 148              // If it receives a jQuery object, the first element is used
 149              elem && elem.jquery ? elem[0] : elem
 150          , this );
 151      },
 152  
 153      attr: function( name, value, type ) {
 154          var options = name;
 155  
 156          // Look for the case where we're accessing a style value
 157          if ( name.constructor == String )
 158              if ( value === undefined )
 159                  return this[0] && jQuery[ type || "attr" ]( this[0], name );
 160  
 161              else {
 162                  options = {};
 163                  options[ name ] = value;
 164              }
 165  
 166          // Check to see if we're setting style values
 167          return this.each(function(i){
 168              // Set all the styles
 169              for ( name in options )
 170                  jQuery.attr(
 171                      type ?
 172                          this.style :
 173                          this,
 174                      name, jQuery.prop( this, options[ name ], type, i, name )
 175                  );
 176          });
 177      },
 178  
 179      css: function( key, value ) {
 180          // ignore negative width and height values
 181          if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
 182              value = undefined;
 183          return this.attr( key, value, "curCSS" );
 184      },
 185  
 186      text: function( text ) {
 187          if ( typeof text != "object" && text != null )
 188              return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
 189  
 190          var ret = "";
 191  
 192          jQuery.each( text || this, function(){
 193              jQuery.each( this.childNodes, function(){
 194                  if ( this.nodeType != 8 )
 195                      ret += this.nodeType != 1 ?
 196                          this.nodeValue :
 197                          jQuery.fn.text( [ this ] );
 198              });
 199          });
 200  
 201          return ret;
 202      },
 203  
 204      wrapAll: function( html ) {
 205          if ( this[0] )
 206              // The elements to wrap the target around
 207              jQuery( html, this[0].ownerDocument )
 208                  .clone()
 209                  .insertBefore( this[0] )
 210                  .map(function(){
 211                      var elem = this;
 212  
 213                      while ( elem.firstChild )
 214                          elem = elem.firstChild;
 215  
 216                      return elem;
 217                  })
 218                  .append(this);
 219  
 220          return this;
 221      },
 222  
 223      wrapInner: function( html ) {
 224          return this.each(function(){
 225              jQuery( this ).contents().wrapAll( html );
 226          });
 227      },
 228  
 229      wrap: function( html ) {
 230          return this.each(function(){
 231              jQuery( this ).wrapAll( html );
 232          });
 233      },
 234  
 235      append: function() {
 236          return this.domManip(arguments, true, false, function(elem){
 237              if (this.nodeType == 1)
 238                  this.appendChild( elem );
 239          });
 240      },
 241  
 242      prepend: function() {
 243          return this.domManip(arguments, true, true, function(elem){
 244              if (this.nodeType == 1)
 245                  this.insertBefore( elem, this.firstChild );
 246          });
 247      },
 248  
 249      before: function() {
 250          return this.domManip(arguments, false, false, function(elem){
 251              this.parentNode.insertBefore( elem, this );
 252          });
 253      },
 254  
 255      after: function() {
 256          return this.domManip(arguments, false, true, function(elem){
 257              this.parentNode.insertBefore( elem, this.nextSibling );
 258          });
 259      },
 260  
 261      end: function() {
 262          return this.prevObject || jQuery( [] );
 263      },
 264  
 265      find: function( selector ) {
 266          var elems = jQuery.map(this, function(elem){
 267              return jQuery.find( selector, elem );
 268          });
 269  
 270          return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
 271              jQuery.unique( elems ) :
 272              elems );
 273      },
 274  
 275      clone: function( events ) {
 276          // Do the clone
 277          var ret = this.map(function(){
 278              if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
 279                  // IE copies events bound via attachEvent when
 280                  // using cloneNode. Calling detachEvent on the
 281                  // clone will also remove the events from the orignal
 282                  // In order to get around this, we use innerHTML.
 283                  // Unfortunately, this means some modifications to
 284                  // attributes in IE that are actually only stored
 285                  // as properties will not be copied (such as the
 286                  // the name attribute on an input).
 287                  var clone = this.cloneNode(true),
 288                      container = document.createElement("div");
 289                  container.appendChild(clone);
 290                  return jQuery.clean([container.innerHTML])[0];
 291              } else
 292                  return this.cloneNode(true);
 293          });
 294  
 295          // Need to set the expando to null on the cloned set if it exists
 296          // removeData doesn't work here, IE removes it from the original as well
 297          // this is primarily for IE but the data expando shouldn't be copied over in any browser
 298          var clone = ret.find("*").andSelf().each(function(){
 299              if ( this[ expando ] != undefined )
 300                  this[ expando ] = null;
 301          });
 302  
 303          // Copy the events from the original to the clone
 304          if ( events === true )
 305              this.find("*").andSelf().each(function(i){
 306                  if (this.nodeType == 3)
 307                      return;
 308                  var events = jQuery.data( this, "events" );
 309  
 310                  for ( var type in events )
 311                      for ( var handler in events[ type ] )
 312                          jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
 313              });
 314  
 315          // Return the cloned set
 316          return ret;
 317      },
 318  
 319      filter: function( selector ) {
 320          return this.pushStack(
 321              jQuery.isFunction( selector ) &&
 322              jQuery.grep(this, function(elem, i){
 323                  return selector.call( elem, i );
 324              }) ||
 325  
 326              jQuery.multiFilter( selector, this ) );
 327      },
 328  
 329      not: function( selector ) {
 330          if ( selector.constructor == String )
 331              // test special case where just one selector is passed in
 332              if ( isSimple.test( selector ) )
 333                  return this.pushStack( jQuery.multiFilter( selector, this, true ) );
 334              else
 335                  selector = jQuery.multiFilter( selector, this );
 336  
 337          var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
 338          return this.filter(function() {
 339              return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
 340          });
 341      },
 342  
 343      add: function( selector ) {
 344          return this.pushStack( jQuery.unique( jQuery.merge(
 345              this.get(),
 346              typeof selector == 'string' ?
 347                  jQuery( selector ) :
 348                  jQuery.makeArray( selector )
 349          )));
 350      },
 351  
 352      is: function( selector ) {
 353          return !!selector && jQuery.multiFilter( selector, this ).length > 0;
 354      },
 355  
 356      hasClass: function( selector ) {
 357          return this.is( "." + selector );
 358      },
 359  
 360      val: function( value ) {
 361          if ( value == undefined ) {
 362  
 363              if ( this.length ) {
 364                  var elem = this[0];
 365  
 366                  // We need to handle select boxes special
 367                  if ( jQuery.nodeName( elem, "select" ) ) {
 368                      var index = elem.selectedIndex,
 369                          values = [],
 370                          options = elem.options,
 371                          one = elem.type == "select-one";
 372  
 373                      // Nothing was selected
 374                      if ( index < 0 )
 375                          return null;
 376  
 377                      // Loop through all the selected options
 378                      for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
 379                          var option = options[ i ];
 380  
 381                          if ( option.selected ) {
 382                              // Get the specifc value for the option
 383                              value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
 384  
 385                              // We don't need an array for one selects
 386                              if ( one )
 387                                  return value;
 388  
 389                              // Multi-Selects return an array
 390                              values.push( value );
 391                          }
 392                      }
 393  
 394                      return values;
 395  
 396                  // Everything else, we just grab the value
 397                  } else
 398                      return (this[0].value || "").replace(/\r/g, "");
 399  
 400              }
 401  
 402              return undefined;
 403          }
 404  
 405          if( value.constructor == Number )
 406              value += '';
 407  
 408          return this.each(function(){
 409              if ( this.nodeType != 1 )
 410                  return;
 411  
 412              if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
 413                  this.checked = (jQuery.inArray(this.value, value) >= 0 ||
 414                      jQuery.inArray(this.name, value) >= 0);
 415  
 416              else if ( jQuery.nodeName( this, "select" ) ) {
 417                  var values = jQuery.makeArray(value);
 418  
 419                  jQuery( "option", this ).each(function(){
 420                      this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
 421                          jQuery.inArray( this.text, values ) >= 0);
 422                  });
 423  
 424                  if ( !values.length )
 425                      this.selectedIndex = -1;
 426  
 427              } else
 428                  this.value = value;
 429          });
 430      },
 431  
 432      html: function( value ) {
 433          return value == undefined ?
 434              (this[0] ?
 435                  this[0].innerHTML :
 436                  null) :
 437              this.empty().append( value );
 438      },
 439  
 440      replaceWith: function( value ) {
 441          return this.after( value ).remove();
 442      },
 443  
 444      eq: function( i ) {
 445          return this.slice( i, i + 1 );
 446      },
 447  
 448      slice: function() {
 449          return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
 450      },
 451  
 452      map: function( callback ) {
 453          return this.pushStack( jQuery.map(this, function(elem, i){
 454              return callback.call( elem, i, elem );
 455          }));
 456      },
 457  
 458      andSelf: function() {
 459          return this.add( this.prevObject );
 460      },
 461  
 462      data: function( key, value ){
 463          var parts = key.split(".");
 464          parts[1] = parts[1] ? "." + parts[1] : "";
 465  
 466          if ( value === undefined ) {
 467              var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
 468  
 469              if ( data === undefined && this.length )
 470                  data = jQuery.data( this[0], key );
 471  
 472              return data === undefined && parts[1] ?
 473                  this.data( parts[0] ) :
 474                  data;
 475          } else
 476              return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
 477                  jQuery.data( this, key, value );
 478              });
 479      },
 480  
 481      removeData: function( key ){
 482          return this.each(function(){
 483              jQuery.removeData( this, key );
 484          });
 485      },
 486  
 487      domManip: function( args, table, reverse, callback ) {
 488          var clone = this.length > 1, elems;
 489  
 490          return this.each(function(){
 491              if ( !elems ) {
 492                  elems = jQuery.clean( args, this.ownerDocument );
 493  
 494                  if ( reverse )
 495                      elems.reverse();
 496              }
 497  
 498              var obj = this;
 499  
 500              if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
 501                  obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );
 502  
 503              var scripts = jQuery( [] );
 504  
 505              jQuery.each(elems, function(){
 506                  var elem = clone ?
 507                      jQuery( this ).clone( true )[0] :
 508                      this;
 509  
 510                  // execute all scripts after the elements have been injected
 511                  if ( jQuery.nodeName( elem, "script" ) )
 512                      scripts = scripts.add( elem );
 513                  else {
 514                      // Remove any inner scripts for later evaluation
 515                      if ( elem.nodeType == 1 )
 516                          scripts = scripts.add( jQuery( "script", elem ).remove() );
 517  
 518                      // Inject the elements into the document
 519                      callback.call( obj, elem );
 520                  }
 521              });
 522  
 523              scripts.each( evalScript );
 524          });
 525      }
 526  };
 527  
 528  // Give the init function the jQuery prototype for later instantiation
 529  jQuery.fn.init.prototype = jQuery.fn;
 530  
 531  function evalScript( i, elem ) {
 532      if ( elem.src )
 533          jQuery.ajax({
 534              url: elem.src,
 535              async: false,
 536              dataType: "script"
 537          });
 538  
 539      else
 540          jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
 541  
 542      if ( elem.parentNode )
 543          elem.parentNode.removeChild( elem );
 544  }
 545  
 546  function now(){
 547      return +new Date;
 548  }
 549  
 550  jQuery.extend = jQuery.fn.extend = function() {
 551      // copy reference to target object
 552      var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
 553  
 554      // Handle a deep copy situation
 555      if ( target.constructor == Boolean ) {
 556          deep = target;
 557          target = arguments[1] || {};
 558          // skip the boolean and the target
 559          i = 2;
 560      }
 561  
 562      // Handle case when target is a string or something (possible in deep copy)
 563      if ( typeof target != "object" && typeof target != "function" )
 564          target = {};
 565  
 566      // extend jQuery itself if only one argument is passed
 567      if ( length == i ) {
 568          target = this;
 569          --i;
 570      }
 571  
 572      for ( ; i < length; i++ )
 573          // Only deal with non-null/undefined values
 574          if ( (options = arguments[ i ]) != null )
 575              // Extend the base object
 576              for ( var name in options ) {
 577                  var src = target[ name ], copy = options[ name ];
 578  
 579                  // Prevent never-ending loop
 580                  if ( target === copy )
 581                      continue;
 582  
 583                  // Recurse if we're merging object values
 584                  if ( deep && copy && typeof copy == "object" && !copy.nodeType )
 585                      target[ name ] = jQuery.extend( deep, 
 586                          // Never move original objects, clone them
 587                          src || ( copy.length != null ? [ ] : { } )
 588                      , copy );
 589  
 590                  // Don't bring in undefined values
 591                  else if ( copy !== undefined )
 592                      target[ name ] = copy;
 593  
 594              }
 595  
 596      // Return the modified object
 597      return target;
 598  };
 599  
 600  var expando = "jQuery" + now(), uuid = 0, windowData = {},
 601      // exclude the following css properties to add px
 602      exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
 603      // cache defaultView
 604      defaultView = document.defaultView || {};
 605  
 606  jQuery.extend({
 607      noConflict: function( deep ) {
 608          window.$ = _$;
 609  
 610          if ( deep )
 611              window.jQuery = _jQuery;
 612  
 613          return jQuery;
 614      },
 615  
 616      // See test/unit/core.js for details concerning this function.
 617      isFunction: function( fn ) {
 618          return !!fn && typeof fn != "string" && !fn.nodeName &&
 619              fn.constructor != Array && /^[\s[]?function/.test( fn + "" );
 620      },
 621  
 622      // check if an element is in a (or is an) XML document
 623      isXMLDoc: function( elem ) {
 624          return elem.documentElement && !elem.body ||
 625              elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
 626      },
 627  
 628      // Evalulates a script in a global context
 629      globalEval: function( data ) {
 630          data = jQuery.trim( data );
 631  
 632          if ( data ) {
 633              // Inspired by code by Andrea Giammarchi
 634              // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
 635              var head = document.getElementsByTagName("head")[0] || document.documentElement,
 636                  script = document.createElement("script");
 637  
 638              script.type = "text/javascript";
 639              if ( jQuery.browser.msie )
 640                  script.text = data;
 641              else
 642                  script.appendChild( document.createTextNode( data ) );
 643  
 644              // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
 645              // This arises when a base node is used (#2709).
 646              head.insertBefore( script, head.firstChild );
 647              head.removeChild( script );
 648          }
 649      },
 650  
 651      nodeName: function( elem, name ) {
 652          return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
 653      },
 654  
 655      cache: {},
 656  
 657      data: function( elem, name, data ) {
 658          elem = elem == window ?
 659              windowData :
 660              elem;
 661  
 662          var id = elem[ expando ];
 663  
 664          // Compute a unique ID for the element
 665          if ( !id )
 666              id = elem[ expando ] = ++uuid;
 667  
 668          // Only generate the data cache if we're
 669          // trying to access or manipulate it
 670          if ( name && !jQuery.cache[ id ] )
 671              jQuery.cache[ id ] = {};
 672  
 673          // Prevent overriding the named cache with undefined values
 674          if ( data !== undefined )
 675              jQuery.cache[ id ][ name ] = data;
 676  
 677          // Return the named cache data, or the ID for the element
 678          return name ?
 679              jQuery.cache[ id ][ name ] :
 680              id;
 681      },
 682  
 683      removeData: function( elem, name ) {
 684          elem = elem == window ?
 685              windowData :
 686              elem;
 687  
 688          var id = elem[ expando ];
 689  
 690          // If we want to remove a specific section of the element's data
 691          if ( name ) {
 692              if ( jQuery.cache[ id ] ) {
 693                  // Remove the section of cache data
 694                  delete jQuery.cache[ id ][ name ];
 695  
 696                  // If we've removed all the data, remove the element's cache
 697                  name = "";
 698  
 699                  for ( name in jQuery.cache[ id ] )
 700                      break;
 701  
 702                  if ( !name )
 703                      jQuery.removeData( elem );
 704              }
 705  
 706          // Otherwise, we want to remove all of the element's data
 707          } else {
 708              // Clean up the element expando
 709              try {
 710                  delete elem[ expando ];
 711              } catch(e){
 712                  // IE has trouble directly removing the expando
 713                  // but it's ok with using removeAttribute
 714                  if ( elem.removeAttribute )
 715                      elem.removeAttribute( expando );
 716              }
 717  
 718              // Completely remove the data cache
 719              delete jQuery.cache[ id ];
 720          }
 721      },
 722  
 723      // args is for internal usage only
 724      each: function( object, callback, args ) {
 725          var name, i = 0, length = object.length;
 726  
 727          if ( args ) {
 728              if ( length == undefined ) {
 729                  for ( name in object )
 730                      if ( callback.apply( object[ name ], args ) === false )
 731                          break;
 732              } else
 733                  for ( ; i < length; )
 734                      if ( callback.apply( object[ i++ ], args ) === false )
 735                          break;
 736  
 737          // A special, fast, case for the most common use of each
 738          } else {
 739              if ( length == undefined ) {
 740                  for ( name in object )
 741                      if ( callback.call( object[ name ], name, object[ name ] ) === false )
 742                          break;
 743              } else
 744                  for ( var value = object[0];
 745                      i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
 746          }
 747  
 748          return object;
 749      },
 750  
 751      prop: function( elem, value, type, i, name ) {
 752          // Handle executable functions
 753          if ( jQuery.isFunction( value ) )
 754              value = value.call( elem, i );
 755  
 756          // Handle passing in a number to a CSS property
 757          return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
 758              value + "px" :
 759              value;
 760      },
 761  
 762      className: {
 763          // internal only, use addClass("class")
 764          add: function( elem, classNames ) {
 765              jQuery.each((classNames || "").split(/\s+/), function(i, className){
 766                  if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
 767                      elem.className += (elem.className ? " " : "") + className;
 768              });
 769          },
 770  
 771          // internal only, use removeClass("class")
 772          remove: function( elem, classNames ) {
 773              if (elem.nodeType == 1)
 774                  elem.className = classNames != undefined ?
 775                      jQuery.grep(elem.className.split(/\s+/), function(className){
 776                          return !jQuery.className.has( classNames, className );
 777                      }).join(" ") :
 778                      "";
 779          },
 780  
 781          // internal only, use hasClass("class")
 782          has: function( elem, className ) {
 783              return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
 784          }
 785      },
 786  
 787      // A method for quickly swapping in/out CSS properties to get correct calculations
 788      swap: function( elem, options, callback ) {
 789          var old = {};
 790          // Remember the old values, and insert the new ones
 791          for ( var name in options ) {
 792              old[ name ] = elem.style[ name ];
 793              elem.style[ name ] = options[ name ];
 794          }
 795  
 796          callback.call( elem );
 797  
 798          // Revert the old values
 799          for ( var name in options )
 800              elem.style[ name ] = old[ name ];
 801      },
 802  
 803      css: function( elem, name, force ) {
 804          if ( name == "width" || name == "height" ) {
 805              var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
 806  
 807  			function getWH() {
 808                  val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
 809                  var padding = 0, border = 0;
 810                  jQuery.each( which, function() {
 811                      padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
 812                      border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
 813                  });
 814                  val -= Math.round(padding + border);
 815              }
 816  
 817              if ( jQuery(elem).is(":visible") )
 818                  getWH();
 819              else
 820                  jQuery.swap( elem, props, getWH );
 821  
 822              return Math.max(0, val);
 823          }
 824  
 825          return jQuery.curCSS( elem, name, force );
 826      },
 827  
 828      curCSS: function( elem, name, force ) {
 829          var ret, style = elem.style;
 830  
 831          // A helper method for determining if an element's values are broken
 832  		function color( elem ) {
 833              if ( !jQuery.browser.safari )
 834                  return false;
 835  
 836              // defaultView is cached
 837              var ret = defaultView.getComputedStyle( elem, null );
 838              return !ret || ret.getPropertyValue("color") == "";
 839          }
 840  
 841          // We need to handle opacity special in IE
 842          if ( name == "opacity" && jQuery.browser.msie ) {
 843              ret = jQuery.attr( style, "opacity" );
 844  
 845              return ret == "" ?
 846                  "1" :
 847                  ret;
 848          }
 849          // Opera sometimes will give the wrong display answer, this fixes it, see #2037
 850          if ( jQuery.browser.opera && name == "display" ) {
 851              var save = style.outline;
 852              style.outline = "0 solid black";
 853              style.outline = save;
 854          }
 855  
 856          // Make sure we're using the right name for getting the float value
 857          if ( name.match( /float/i ) )
 858              name = styleFloat;
 859  
 860          if ( !force && style && style[ name ] )
 861              ret = style[ name ];
 862  
 863          else if ( defaultView.getComputedStyle ) {
 864  
 865              // Only "float" is needed here
 866              if ( name.match( /float/i ) )
 867                  name = "float";
 868  
 869              name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
 870  
 871              var computedStyle = defaultView.getComputedStyle( elem, null );
 872  
 873              if ( computedStyle && !color( elem ) )
 874                  ret = computedStyle.getPropertyValue( name );
 875  
 876              // If the element isn't reporting its values properly in Safari
 877              // then some display: none elements are involved
 878              else {
 879                  var swap = [], stack = [], a = elem, i = 0;
 880  
 881                  // Locate all of the parent display: none elements
 882                  for ( ; a && color(a); a = a.parentNode )
 883                      stack.unshift(a);
 884  
 885                  // Go through and make them visible, but in reverse
 886                  // (It would be better if we knew the exact display type that they had)
 887                  for ( ; i < stack.length; i++ )
 888                      if ( color( stack[ i ] ) ) {
 889                          swap[ i ] = stack[ i ].style.display;
 890                          stack[ i ].style.display = "block";
 891                      }
 892  
 893                  // Since we flip the display style, we have to handle that
 894                  // one special, otherwise get the value
 895                  ret = name == "display" && swap[ stack.length - 1 ] != null ?
 896                      "none" :
 897                      ( computedStyle && computedStyle.getPropertyValue( name ) ) || "";
 898  
 899                  // Finally, revert the display styles back
 900                  for ( i = 0; i < swap.length; i++ )
 901                      if ( swap[ i ] != null )
 902                          stack[ i ].style.display = swap[ i ];
 903              }
 904  
 905              // We should always get a number back from opacity
 906              if ( name == "opacity" && ret == "" )
 907                  ret = "1";
 908  
 909          } else if ( elem.currentStyle ) {
 910              var camelCase = name.replace(/\-(\w)/g, function(all, letter){
 911                  return letter.toUpperCase();
 912              });
 913  
 914              ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
 915  
 916              // From the awesome hack by Dean Edwards
 917              // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
 918  
 919              // If we're not dealing with a regular pixel number
 920              // but a number that has a weird ending, we need to convert it to pixels
 921              if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
 922                  // Remember the original values
 923                  var left = style.left, rsLeft = elem.runtimeStyle.left;
 924  
 925                  // Put in the new values to get a computed value out
 926                  elem.runtimeStyle.left = elem.currentStyle.left;
 927                  style.left = ret || 0;
 928                  ret = style.pixelLeft + "px";
 929  
 930                  // Revert the changed values
 931                  style.left = left;
 932                  elem.runtimeStyle.left = rsLeft;
 933              }
 934          }
 935  
 936          return ret;
 937      },
 938  
 939      clean: function( elems, context ) {
 940          var ret = [];
 941          context = context || document;
 942          // !context.createElement fails in IE with an error but returns typeof 'object'
 943          if (typeof context.createElement == 'undefined')
 944              context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
 945  
 946          jQuery.each(elems, function(i, elem){
 947              if ( !elem )
 948                  return;
 949  
 950              if ( elem.constructor == Number )
 951                  elem += '';
 952  
 953              // Convert html string into DOM nodes
 954              if ( typeof elem == "string" ) {
 955                  // Fix "XHTML"-style tags in all browsers
 956                  elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
 957                      return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
 958                          all :
 959                          front + "></" + tag + ">";
 960                  });
 961  
 962                  // Trim whitespace, otherwise indexOf won't work as expected
 963                  var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");
 964  
 965                  var wrap =
 966                      // option or optgroup
 967                      !tags.indexOf("<opt") &&
 968                      [ 1, "<select multiple='multiple'>", "</select>" ] ||
 969  
 970                      !tags.indexOf("<leg") &&
 971                      [ 1, "<fieldset>", "</fieldset>" ] ||
 972  
 973                      tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
 974                      [ 1, "<table>", "</table>" ] ||
 975  
 976                      !tags.indexOf("<tr") &&
 977                      [ 2, "<table><tbody>", "</tbody></table>" ] ||
 978  
 979                       // <thead> matched above
 980                      (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
 981                      [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
 982  
 983                      !tags.indexOf("<col") &&
 984                      [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
 985  
 986                      // IE can't serialize <link> and <script> tags normally
 987                      jQuery.browser.msie &&
 988                      [ 1, "div<div>", "</div>" ] ||
 989  
 990                      [ 0, "", "" ];
 991  
 992                  // Go to html and back, then peel off extra wrappers
 993                  div.innerHTML = wrap[1] + elem + wrap[2];
 994  
 995                  // Move to the right depth
 996                  while ( wrap[0]-- )
 997                      div = div.lastChild;
 998  
 999                  // Remove IE's autoinserted <tbody> from table fragments
1000                  if ( jQuery.browser.msie ) {
1001  
1002                      // String was a <table>, *may* have spurious <tbody>
1003                      var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
1004                          div.firstChild && div.firstChild.childNodes :
1005  
1006                          // String was a bare <thead> or <tfoot>
1007                          wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
1008                              div.childNodes :
1009                              [];
1010  
1011                      for ( var j = tbody.length - 1; j >= 0 ; --j )
1012                          if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
1013                              tbody[ j ].parentNode.removeChild( tbody[ j ] );
1014  
1015                      // IE completely kills leading whitespace when innerHTML is used
1016                      if ( /^\s/.test( elem ) )
1017                          div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
1018  
1019                  }
1020  
1021                  elem = jQuery.makeArray( div.childNodes );
1022              }
1023  
1024              if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
1025                  return;
1026  
1027              if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
1028                  ret.push( elem );
1029  
1030              else
1031                  ret = jQuery.merge( ret, elem );
1032  
1033          });
1034  
1035          return ret;
1036      },
1037  
1038      attr: function( elem, name, value ) {
1039          // don't set attributes on text and comment nodes
1040          if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
1041              return undefined;
1042  
1043          var notxml = !jQuery.isXMLDoc( elem ),
1044              // Whether we are setting (or getting)
1045              set = value !== undefined,
1046              msie = jQuery.browser.msie;
1047  
1048          // Try to normalize/fix the name
1049          name = notxml && jQuery.props[ name ] || name;
1050  
1051          // Only do all the following if this is a node (faster for style)
1052          // IE elem.getAttribute passes even for style
1053          if ( elem.tagName ) {
1054  
1055              // These attributes require special treatment
1056              var special = /href|src|style/.test( name );
1057  
1058              // Safari mis-reports the default selected property of a hidden option
1059              // Accessing the parent's selectedIndex property fixes it
1060              if ( name == "selected" && jQuery.browser.safari )
1061                  elem.parentNode.selectedIndex;
1062  
1063              // If applicable, access the attribute via the DOM 0 way
1064              if ( name in elem && notxml && !special ) {
1065                  if ( set ){
1066                      // We can't allow the type property to be changed (since it causes problems in IE)
1067                      if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
1068                          throw "type property can't be changed";
1069  
1070                      elem[ name ] = value;
1071                  }
1072  
1073                  // browsers index elements by id/name on forms, give priority to attributes.
1074                  if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1075                      return elem.getAttributeNode( name ).nodeValue;
1076  
1077                  return elem[ name ];
1078              }
1079  
1080              if ( msie && notxml &&  name == "style" )
1081                  return jQuery.attr( elem.style, "cssText", value );
1082  
1083              if ( set )
1084                  // convert the value to a string (all browsers do this but IE) see #1070
1085                  elem.setAttribute( name, "" + value );
1086  
1087              var attr = msie && notxml && special
1088                      // Some attributes require a special call on IE
1089                      ? elem.getAttribute( name, 2 )
1090                      : elem.getAttribute( name );
1091  
1092              // Non-existent attributes return null, we normalize to undefined
1093              return attr === null ? undefined : attr;
1094          }
1095  
1096          // elem is actually elem.style ... set the style
1097  
1098          // IE uses filters for opacity
1099          if ( msie && name == "opacity" ) {
1100              if ( set ) {
1101                  // IE has trouble with opacity if it does not have layout
1102                  // Force it by setting the zoom level
1103                  elem.zoom = 1;
1104  
1105                  // Set the alpha filter to set the opacity
1106                  elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1107                      (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1108              }
1109  
1110              return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1111                  (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1112                  "";
1113          }
1114  
1115          name = name.replace(/-([a-z])/ig, function(all, letter){
1116              return letter.toUpperCase();
1117          });
1118  
1119          if ( set )
1120              elem[ name ] = value;
1121  
1122          return elem[ name ];
1123      },
1124  
1125      trim: function( text ) {
1126          return (text || "").replace( /^\s+|\s+$/g, "" );
1127      },
1128  
1129      makeArray: function( array ) {
1130          var ret = [];
1131  
1132          if( array != null ){
1133              var i = array.length;
1134              //the window, strings and functions also have 'length'
1135              if( i == null || array.split || array.setInterval || array.call )
1136                  ret[0] = array;
1137              else
1138                  while( i )
1139                      ret[--i] = array[i];
1140          }
1141  
1142          return ret;
1143      },
1144  
1145      inArray: function( elem, array ) {
1146          for ( var i = 0, length = array.length; i < length; i++ )
1147          // Use === because on IE, window == document
1148              if ( array[ i ] === elem )
1149                  return i;
1150  
1151          return -1;
1152      },
1153  
1154      merge: function( first, second ) {
1155          // We have to loop this way because IE & Opera overwrite the length
1156          // expando of getElementsByTagName
1157          var i = 0, elem, pos = first.length;
1158          // Also, we need to make sure that the correct elements are being returned
1159          // (IE returns comment nodes in a '*' query)
1160          if ( jQuery.browser.msie ) {
1161              while ( elem = second[ i++ ] )
1162                  if ( elem.nodeType != 8 )
1163                      first[ pos++ ] = elem;
1164  
1165          } else
1166              while ( elem = second[ i++ ] )
1167                  first[ pos++ ] = elem;
1168  
1169          return first;
1170      },
1171  
1172      unique: function( array ) {
1173          var ret = [], done = {};
1174  
1175          try {
1176  
1177              for ( var i = 0, length = array.length; i < length; i++ ) {
1178                  var id = jQuery.data( array[ i ] );
1179  
1180                  if ( !done[ id ] ) {
1181                      done[ id ] = true;
1182                      ret.push( array[ i ] );
1183                  }
1184              }
1185  
1186          } catch( e ) {
1187              ret = array;
1188          }
1189  
1190          return ret;
1191      },
1192  
1193      grep: function( elems, callback, inv ) {
1194          var ret = [];
1195  
1196          // Go through the array, only saving the items
1197          // that pass the validator function
1198          for ( var i = 0, length = elems.length; i < length; i++ )
1199              if ( !inv != !callback( elems[ i ], i ) )
1200                  ret.push( elems[ i ] );
1201  
1202          return ret;
1203      },
1204  
1205      map: function( elems, callback ) {
1206          var ret = [];
1207  
1208          // Go through the array, translating each of the items to their
1209          // new value (or values).
1210          for ( var i = 0, length = elems.length; i < length; i++ ) {
1211              var value = callback( elems[ i ], i );
1212  
1213              if ( value != null )
1214                  ret[ ret.length ] = value;
1215          }
1216  
1217          return ret.concat.apply( [], ret );
1218      }
1219  });
1220  
1221  var userAgent = navigator.userAgent.toLowerCase();
1222  
1223  // Figure out what browser is being used
1224  jQuery.browser = {
1225      version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
1226      safari: /webkit/.test( userAgent ),
1227      opera: /opera/.test( userAgent ),
1228      msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1229      mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1230  };
1231  
1232  var styleFloat = jQuery.browser.msie ?
1233      "styleFloat" :
1234      "cssFloat";
1235  
1236  jQuery.extend({
1237      // Check to see if the W3C box model is being used
1238      boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
1239  
1240      props: {
1241          "for": "htmlFor",
1242          "class": "className",
1243          "float": styleFloat,
1244          cssFloat: styleFloat,
1245          styleFloat: styleFloat,
1246          readonly: "readOnly",
1247          maxlength: "maxLength",
1248          cellspacing: "cellSpacing"
1249      }
1250  });
1251  
1252  jQuery.each({
1253      parent: function(elem){return elem.parentNode;},
1254      parents: function(elem){return jQuery.dir(elem,"parentNode");},
1255      next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1256      prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1257      nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1258      prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1259      siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1260      children: function(elem){return jQuery.sibling(elem.firstChild);},
1261      contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1262  }, function(name, fn){
1263      jQuery.fn[ name ] = function( selector ) {
1264          var ret = jQuery.map( this, fn );
1265  
1266          if ( selector && typeof selector == "string" )
1267              ret = jQuery.multiFilter( selector, ret );
1268  
1269          return this.pushStack( jQuery.unique( ret ) );
1270      };
1271  });
1272  
1273  jQuery.each({
1274      appendTo: "append",
1275      prependTo: "prepend",
1276      insertBefore: "before",
1277      insertAfter: "after",
1278      replaceAll: "replaceWith"
1279  }, function(name, original){
1280      jQuery.fn[ name ] = function() {
1281          var args = arguments;
1282  
1283          return this.each(function(){
1284              for ( var i = 0, length = args.length; i < length; i++ )
1285                  jQuery( args[ i ] )[ original ]( this );
1286          });
1287      };
1288  });
1289  
1290  jQuery.each({
1291      removeAttr: function( name ) {
1292          jQuery.attr( this, name, "" );
1293          if (this.nodeType == 1)
1294              this.removeAttribute( name );
1295      },
1296  
1297      addClass: function( classNames ) {
1298          jQuery.className.add( this, classNames );
1299      },
1300  
1301      removeClass: function( classNames ) {
1302          jQuery.className.remove( this, classNames );
1303      },
1304  
1305      toggleClass: function( classNames ) {
1306          jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1307      },
1308  
1309      remove: function( selector ) {
1310          if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
1311              // Prevent memory leaks
1312              jQuery( "*", this ).add(this).each(function(){
1313                  jQuery.event.remove(this);
1314                  jQuery.removeData(this);
1315              });
1316              if (this.parentNode)
1317                  this.parentNode.removeChild( this );
1318          }
1319      },
1320  
1321      empty: function() {
1322          // Remove element nodes and prevent memory leaks
1323          jQuery( ">*", this ).remove();
1324  
1325          // Remove any remaining nodes
1326          while ( this.firstChild )
1327              this.removeChild( this.firstChild );
1328      }
1329  }, function(name, fn){
1330      jQuery.fn[ name ] = function(){
1331          return this.each( fn, arguments );
1332      };
1333  });
1334  
1335  jQuery.each([ "Height", "Width" ], function(i, name){
1336      var type = name.toLowerCase();
1337  
1338      jQuery.fn[ type ] = function( size ) {
1339          // Get window width or height
1340          return this[0] == window ?
1341              // Opera reports document.body.client[Width/Height] properly in both quirks and standards
1342              jQuery.browser.opera && document.body[ "client" + name ] ||
1343  
1344              // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1345              jQuery.browser.safari && window[ "inner" + name ] ||
1346  
1347              // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1348              document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
1349  
1350              // Get document width or height
1351              this[0] == document ?
1352                  // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1353                  Math.max(
1354                      Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
1355                      Math.max(document.body["offset" + name], document.documentElement["offset" + name])
1356                  ) :
1357  
1358                  // Get or set width or height on the element
1359                  size == undefined ?
1360                      // Get width or height on the element
1361                      (this.length ? jQuery.css( this[0], type ) : null) :
1362  
1363                      // Set the width or height on the element (default to pixels if value is unitless)
1364                      this.css( type, size.constructor == String ? size : size + "px" );
1365      };
1366  });
1367  
1368  // Helper function used by the dimensions and offset modules
1369  function num(elem, prop) {
1370      return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1371  }var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
1372          "(?:[\\w*_-]|\\\\.)" :
1373          "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
1374      quickChild = new RegExp("^>\\s*(" + chars + "+)"),
1375      quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
1376      quickClass = new RegExp("^([#.]?)(" + chars + "*)");
1377  
1378  jQuery.extend({
1379      expr: {
1380          "": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
1381          "#": function(a,i,m){return a.getAttribute("id")==m[2];},
1382          ":": {
1383              // Position Checks
1384              lt: function(a,i,m){return i<m[3]-0;},
1385              gt: function(a,i,m){return i>m[3]-0;},
1386              nth: function(a,i,m){return m[3]-0==i;},
1387              eq: function(a,i,m){return m[3]-0==i;},
1388              first: function(a,i){return i==0;},
1389              last: function(a,i,m,r){return i==r.length-1;},
1390              even: function(a,i){return i%2==0;},
1391              odd: function(a,i){return i%2;},
1392  
1393              // Child Checks
1394              "first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
1395              "last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
1396              "only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},
1397  
1398              // Parent Checks
1399              parent: function(a){return a.firstChild;},
1400              empty: function(a){return !a.firstChild;},
1401  
1402              // Text Check
1403              contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},
1404  
1405              // Visibility
1406              visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
1407              hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},
1408  
1409              // Form attributes
1410              enabled: function(a){return !a.disabled;},
1411              disabled: function(a){return a.disabled;},
1412              checked: function(a){return a.checked;},
1413              selected: function(a){return a.selected||jQuery.attr(a,"selected");},
1414  
1415              // Form elements
1416              text: function(a){return "text"==a.type;},
1417              radio: function(a){return "radio"==a.type;},
1418              checkbox: function(a){return "checkbox"==a.type;},
1419              file: function(a){return "file"==a.type;},
1420              password: function(a){return "password"==a.type;},
1421              submit: function(a){return "submit"==a.type;},
1422              image: function(a){return "image"==a.type;},
1423              reset: function(a){return "reset"==a.type;},
1424              button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
1425              input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},
1426  
1427              // :has()
1428              has: function(a,i,m){return jQuery.find(m[3],a).length;},
1429  
1430              // :header
1431              header: function(a){return /h\d/i.test(a.nodeName);},
1432  
1433              // :animated
1434              animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
1435          }
1436      },
1437  
1438      // The regular expressions that power the parsing engine
1439      parse: [
1440          // Match: [@value='test'], [@foo]
1441          /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,
1442  
1443          // Match: :contains('foo')
1444          /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,
1445  
1446          // Match: :even, :last-child, #id, .class
1447          new RegExp("^([:.#]*)(" + chars + "+)")
1448      ],
1449  
1450      multiFilter: function( expr, elems, not ) {
1451          var old, cur = [];
1452  
1453          while ( expr && expr != old ) {
1454              old = expr;
1455              var f = jQuery.filter( expr, elems, not );
1456              expr = f.t.replace(/^\s*,\s*/, "" );
1457              cur = not ? elems = f.r : jQuery.merge( cur, f.r );
1458          }
1459  
1460          return cur;
1461      },
1462  
1463      find: function( t, context ) {
1464          // Quickly handle non-string expressions
1465          if ( typeof t != "string" )
1466              return [ t ];
1467  
1468          // check to make sure context is a DOM element or a document
1469          if ( context && context.nodeType != 1 && context.nodeType != 9)
1470              return [ ];
1471  
1472          // Set the correct context (if none is provided)
1473          context = context || document;
1474  
1475          // Initialize the search
1476          var ret = [context], done = [], last, nodeName;
1477  
1478          // Continue while a selector expression exists, and while
1479          // we're no longer looping upon ourselves
1480          while ( t && last != t ) {
1481              var r = [];
1482              last = t;
1483  
1484              t = jQuery.trim(t);
1485  
1486              var foundToken = false,
1487  
1488              // An attempt at speeding up child selectors that
1489              // point to a specific element tag
1490                  re = quickChild,
1491  
1492                  m = re.exec(t);
1493  
1494              if ( m ) {
1495                  nodeName = m[1].toUpperCase();
1496  
1497                  // Perform our own iteration and filter
1498                  for ( var i = 0; ret[i]; i++ )
1499                      for ( var c = ret[i].firstChild; c; c = c.nextSibling )
1500                          if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
1501                              r.push( c );
1502  
1503                  ret = r;
1504                  t = t.replace( re, "" );
1505                  if ( t.indexOf(" ") == 0 ) continue;
1506                  foundToken = true;
1507              } else {
1508                  re = /^([>+~])\s*(\w*)/i;
1509  
1510                  if ( (m = re.exec(t)) != null ) {
1511                      r = [];
1512  
1513                      var merge = {};
1514                      nodeName = m[2].toUpperCase();
1515                      m = m[1];
1516  
1517                      for ( var j = 0, rl = ret.length; j < rl; j++ ) {
1518                          var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
1519                          for ( ; n; n = n.nextSibling )
1520                              if ( n.nodeType == 1 ) {
1521                                  var id = jQuery.data(n);
1522  
1523                                  if ( m == "~" && merge[id] ) break;
1524  
1525                                  if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
1526                                      if ( m == "~" ) merge[id] = true;
1527                                      r.push( n );
1528                                  }
1529  
1530                                  if ( m == "+" ) break;
1531                              }
1532                      }
1533  
1534                      ret = r;
1535  
1536                      // And remove the token
1537                      t = jQuery.trim( t.replace( re, "" ) );
1538                      foundToken = true;
1539                  }
1540              }
1541  
1542              // See if there's still an expression, and that we haven't already
1543              // matched a token
1544              if ( t && !foundToken ) {
1545                  // Handle multiple expressions
1546                  if ( !t.indexOf(",") ) {
1547                      // Clean the result set
1548                      if ( context == ret[0] ) ret.shift();
1549  
1550                      // Merge the result sets
1551                      done = jQuery.merge( done, ret );
1552  
1553                      // Reset the context
1554                      r = ret = [context];
1555  
1556                      // Touch up the selector string
1557                      t = " " + t.substr(1,t.length);
1558  
1559                  } else {
1560                      // Optimize for the case nodeName#idName
1561                      var re2 = quickID;
1562                      var m = re2.exec(t);
1563  
1564                      // Re-organize the results, so that they're consistent
1565                      if ( m ) {
1566                          m = [ 0, m[2], m[3], m[1] ];
1567  
1568                      } else {
1569                          // Otherwise, do a traditional filter check for
1570                          // ID, class, and element selectors
1571                          re2 = quickClass;
1572                          m = re2.exec(t);
1573                      }
1574  
1575                      m[2] = m[2].replace(/\\/g, "");
1576  
1577                      var elem = ret[ret.length-1];
1578  
1579                      // Try to do a global search by ID, where we can
1580                      if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
1581                          // Optimization for HTML document case
1582                          var oid = elem.getElementById(m[2]);
1583  
1584                          // Do a quick check for the existence of the actual ID attribute
1585                          // to avoid selecting by the name attribute in IE
1586                          // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1587                          if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1588                              oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
1589  
1590                          // Do a quick check for node name (where applicable) so
1591                          // that div#foo searches will be really fast
1592                          ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
1593                      } else {
1594                          // We need to find all descendant elements
1595                          for ( var i = 0; ret[i]; i++ ) {
1596                              // Grab the tag name being searched for
1597                              var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];
1598  
1599                              // Handle IE7 being really dumb about <object>s
1600                              if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
1601                                  tag = "param";
1602  
1603                              r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
1604                          }
1605  
1606                          // It's faster to filter by class and be done with it
1607                          if ( m[1] == "." )
1608                              r = jQuery.classFilter( r, m[2] );
1609  
1610                          // Same with ID filtering
1611                          if ( m[1] == "#" ) {
1612                              var tmp = [];
1613  
1614                              // Try to find the element with the ID
1615                              for ( var i = 0; r[i]; i++ )
1616                                  if ( r[i].getAttribute("id") == m[2] ) {
1617                                      tmp = [ r[i] ];
1618                                      break;
1619                                  }
1620  
1621                              r = tmp;
1622                          }
1623  
1624                          ret = r;
1625                      }
1626  
1627                      t = t.replace( re2, "" );
1628                  }
1629  
1630              }
1631  
1632              // If a selector string still exists
1633              if ( t ) {
1634                  // Attempt to filter it
1635                  var val = jQuery.filter(t,r);
1636                  ret = r = val.r;
1637                  t = jQuery.trim(val.t);
1638              }
1639          }
1640  
1641          // An error occurred with the selector;
1642          // just return an empty set instead
1643          if ( t )
1644              ret = [];
1645  
1646          // Remove the root context
1647          if ( ret && context == ret[0] )
1648              ret.shift();
1649  
1650          // And combine the results
1651          done = jQuery.merge( done, ret );
1652  
1653          return done;
1654      },
1655  
1656      classFilter: function(r,m,not){
1657          m = " " + m + " ";
1658          var tmp = [];
1659          for ( var i = 0; r[i]; i++ ) {
1660              var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
1661              if ( !not && pass || not && !pass )
1662                  tmp.push( r[i] );
1663          }
1664          return tmp;
1665      },
1666  
1667      filter: function(t,r,not) {
1668          var last;
1669  
1670          // Look for common filter expressions
1671          while ( t && t != last ) {
1672              last = t;
1673  
1674              var p = jQuery.parse, m;
1675  
1676              for ( var i = 0; p[i]; i++ ) {
1677                  m = p[i].exec( t );
1678  
1679                  if ( m ) {
1680                      // Remove what we just matched
1681                      t = t.substring( m[0].length );
1682  
1683                      m[2] = m[2].replace(/\\/g, "");
1684                      break;
1685                  }
1686              }
1687  
1688              if ( !m )
1689                  break;
1690  
1691              // :not() is a special case that can be optimized by
1692              // keeping it out of the expression list
1693              if ( m[1] == ":" && m[2] == "not" )
1694                  // optimize if only one selector found (most common case)
1695                  r = isSimple.test( m[3] ) ?
1696                      jQuery.filter(m[3], r, true).r :
1697                      jQuery( r ).not( m[3] );
1698  
1699              // We can get a big speed boost by filtering by class here
1700              else if ( m[1] == "." )
1701                  r = jQuery.classFilter(r, m[2], not);
1702  
1703              else if ( m[1] == "[" ) {
1704                  var tmp = [], type = m[3];
1705  
1706                  for ( var i = 0, rl = r.length; i < rl; i++ ) {
1707                      var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
1708  
1709                      if ( z == null || /href|src|selected/.test(m[2]) )
1710                          z = jQuery.attr(a,m[2]) || '';
1711  
1712                      if ( (type == "" && !!z ||
1713                           type == "=" && z == m[5] ||
1714                           type == "!=" && z != m[5] ||
1715                           type == "^=" && z && !z.indexOf(m[5]) ||
1716                           type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
1717                           (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
1718                              tmp.push( a );
1719                  }
1720  
1721                  r = tmp;
1722  
1723              // We can get a speed boost by handling nth-child here
1724              } else if ( m[1] == ":" && m[2] == "nth-child" ) {
1725                  var merge = {}, tmp = [],
1726                      // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1727                      test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
1728                          m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
1729                          !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
1730                      // calculate the numbers (first)n+(last) including if they are negative
1731                      first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;
1732  
1733                  // loop through all the elements left in the jQuery object
1734                  for ( var i = 0, rl = r.length; i < rl; i++ ) {
1735                      var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);
1736  
1737                      if ( !merge[id] ) {
1738                          var c = 1;
1739  
1740                          for ( var n = parentNode.firstChild; n; n = n.nextSibling )
1741                              if ( n.nodeType == 1 )
1742                                  n.nodeIndex = c++;
1743  
1744                          merge[id] = true;
1745                      }
1746  
1747                      var add = false;
1748  
1749                      if ( first == 0 ) {
1750                          if ( node.nodeIndex == last )
1751                              add = true;
1752                      } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
1753                          add = true;
1754  
1755                      if ( add ^ not )
1756                          tmp.push( node );
1757                  }
1758  
1759                  r = tmp;
1760  
1761              // Otherwise, find the expression to execute
1762              } else {
1763                  var fn = jQuery.expr[ m[1] ];
1764                  if ( typeof fn == "object" )
1765                      fn = fn[ m[2] ];
1766  
1767                  if ( typeof fn == "string" )
1768                      fn = eval("false||function(a,i){return " + fn + ";}");
1769  
1770                  // Execute it against the current filter
1771                  r = jQuery.grep( r, function(elem, i){
1772                      return fn(elem, i, m, r);
1773                  }, not );
1774              }
1775          }
1776  
1777          // Return an array of filtered elements (r)
1778          // and the modified expression string (t)
1779          return { r: r, t: t };
1780      },
1781  
1782      dir: function( elem, dir ){
1783          var matched = [],
1784              cur = elem[dir];
1785          while ( cur && cur != document ) {
1786              if ( cur.nodeType == 1 )
1787                  matched.push( cur );
1788              cur = cur[dir];
1789          }
1790          return matched;
1791      },
1792  
1793      nth: function(cur,result,dir,elem){
1794          result = result || 1;
1795          var num = 0;
1796  
1797          for ( ; cur; cur = cur[dir] )
1798              if ( cur.nodeType == 1 && ++num == result )
1799                  break;
1800  
1801          return cur;
1802      },
1803  
1804      sibling: function( n, elem ) {
1805          var r = [];
1806  
1807          for ( ; n; n = n.nextSibling ) {
1808              if ( n.nodeType == 1 && n != elem )
1809                  r.push( n );
1810          }
1811  
1812          return r;
1813      }
1814  });
1815  /*
1816   * A number of helper functions used for managing events.
1817   * Many of the ideas behind this code orignated from
1818   * Dean Edwards' addEvent library.
1819   */
1820  jQuery.event = {
1821  
1822      // Bind an event to an element
1823      // Original by Dean Edwards
1824      add: function(elem, types, handler, data) {
1825          if ( elem.nodeType == 3 || elem.nodeType == 8 )
1826              return;
1827  
1828          // For whatever reason, IE has trouble passing the window object
1829          // around, causing it to be cloned in the process
1830          if ( jQuery.browser.msie && elem.setInterval )
1831              elem = window;
1832  
1833          // Make sure that the function being executed has a unique ID
1834          if ( !handler.guid )
1835              handler.guid = this.guid++;
1836  
1837          // if data is passed, bind to handler
1838          if( data != undefined ) {
1839              // Create temporary function pointer to original handler
1840              var fn = handler;
1841  
1842              // Create unique handler function, wrapped around original handler
1843              handler = this.proxy( fn, function() {
1844                  // Pass arguments and context to original handler
1845                  return fn.apply(this, arguments);
1846              });
1847  
1848              // Store data in unique handler
1849              handler.data = data;
1850          }
1851  
1852          // Init the element's event structure
1853          var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
1854              handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
1855                  // Handle the second event of a trigger and when
1856                  // an event is called after a page has unloaded
1857                  if ( typeof jQuery != "undefined" && !jQuery.event.triggered )
1858                      return jQuery.event.handle.apply(arguments.callee.elem, arguments);
1859              });
1860          // Add elem as a property of the handle function
1861          // This is to prevent a memory leak with non-native
1862          // event in IE.
1863          handle.elem = elem;
1864  
1865          // Handle multiple events separated by a space
1866          // jQuery(...).bind("mouseover mouseout", fn);
1867          jQuery.each(types.split(/\s+/), function(index, type) {
1868              // Namespaced event handlers
1869              var parts = type.split(".");
1870              type = parts[0];
1871              handler.type = parts[1];
1872  
1873              // Get the current list of functions bound to this event
1874              var handlers = events[type];
1875  
1876              // Init the event handler queue
1877              if (!handlers) {
1878                  handlers = events[type] = {};
1879  
1880                  // Check for a special event handler
1881                  // Only use addEventListener/attachEvent if the special
1882                  // events handler returns false
1883                  if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
1884                      // Bind the global event handler to the element
1885                      if (elem.addEventListener)
1886                          elem.addEventListener(type, handle, false);
1887                      else if (elem.attachEvent)
1888                          elem.attachEvent("on" + type, handle);
1889                  }
1890              }
1891  
1892              // Add the function to the element's handler list
1893              handlers[handler.guid] = handler;
1894  
1895              // Keep track of which events have been used, for global triggering
1896              jQuery.event.global[type] = true;
1897          });
1898  
1899          // Nullify elem to prevent memory leaks in IE
1900          elem = null;
1901      },
1902  
1903      guid: 1,
1904      global: {},
1905  
1906      // Detach an event or set of events from an element
1907      remove: function(elem, types, handler) {
1908          // don't do events on text and comment nodes
1909          if ( elem.nodeType == 3 || elem.nodeType == 8 )
1910              return;
1911  
1912          var events = jQuery.data(elem, "events"), ret, index;
1913  
1914          if ( events ) {
1915              // Unbind all events for the element
1916              if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") )
1917                  for ( var type in events )
1918                      this.remove( elem, type + (types || "") );
1919              else {
1920                  // types is actually an event object here
1921                  if ( types.type ) {
1922                      handler = types.handler;
1923                      types = types.type;
1924                  }
1925  
1926                  // Handle multiple events seperated by a space
1927                  // jQuery(...).unbind("mouseover mouseout", fn);
1928                  jQuery.each(types.split(/\s+/), function(index, type){
1929                      // Namespaced event handlers
1930                      var parts = type.split(".");
1931                      type = parts[0];
1932  
1933                      if ( events[type] ) {
1934                          // remove the given handler for the given type
1935                          if ( handler )
1936                              delete events[type][handler.guid];
1937  
1938                          // remove all handlers for the given type
1939                          else
1940                              for ( handler in events[type] )
1941                                  // Handle the removal of namespaced events
1942                                  if ( !parts[1] || events[type][handler].type == parts[1] )
1943                                      delete events[type][handler];
1944  
1945                          // remove generic event handler if no more handlers exist
1946                          for ( ret in events[type] ) break;
1947                          if ( !ret ) {
1948                              if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
1949                                  if (elem.removeEventListener)
1950                                      elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
1951                                  else if (elem.detachEvent)
1952                                      elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
1953                              }
1954                              ret = null;
1955                              delete events[type];
1956                          }
1957                      }
1958                  });
1959              }
1960  
1961              // Remove the expando if it's no longer used
1962              for ( ret in events ) break;
1963              if ( !ret ) {
1964                  var handle = jQuery.data( elem, "handle" );
1965                  if ( handle ) handle.elem = null;
1966                  jQuery.removeData( elem, "events" );
1967                  jQuery.removeData( elem, "handle" );
1968              }
1969          }
1970      },
1971  
1972      trigger: function(type, data, elem, donative, extra) {
1973          // Clone the incoming data, if any
1974          data = jQuery.makeArray(data);
1975  
1976          if ( type.indexOf("!") >= 0 ) {
1977              type = type.slice(0, -1);
1978              var exclusive = true;
1979          }
1980  
1981          // Handle a global trigger
1982          if ( !elem ) {
1983              // Only trigger if we've ever bound an event for it
1984              if ( this.global[type] )
1985                  jQuery("*").add([window, document]).trigger(type, data);
1986  
1987          // Handle triggering a single element
1988          } else {
1989              // don't do events on text and comment nodes
1990              if ( elem.nodeType == 3 || elem.nodeType == 8 )
1991                  return undefined;
1992  
1993              var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
1994                  // Check to see if we need to provide a fake event, or not
1995                  event = !data[0] || !data[0].preventDefault;
1996  
1997              // Pass along a fake event
1998              if ( event ) {
1999                  data.unshift({
2000                      type: type,
2001                      target: elem,
2002                      preventDefault: function(){},
2003                      stopPropagation: function(){},
2004                      timeStamp: now()
2005                  });
2006                  data[0][expando] = true; // no need to fix fake event
2007              }
2008  
2009              // Enforce the right trigger type
2010              data[0].type = type;
2011              if ( exclusive )
2012                  data[0].exclusive = true;
2013  
2014              // Trigger the event, it is assumed that "handle" is a function
2015              var handle = jQuery.data(elem, "handle");
2016              if ( handle )
2017                  val = handle.apply( elem, data );
2018  
2019              // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2020              if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2021                  val = false;
2022  
2023              // Extra functions don't get the custom event object
2024              if ( event )
2025                  data.shift();
2026  
2027              // Handle triggering of extra function
2028              if ( extra && jQuery.isFunction( extra ) ) {
2029                  // call the extra function and tack the current return value on the end for possible inspection
2030                  ret = extra.apply( elem, val == null ? data : data.concat( val ) );
2031                  // if anything is returned, give it precedence and have it overwrite the previous value
2032                  if (ret !== undefined)
2033                      val = ret;
2034              }
2035  
2036              // Trigger the native events (except for clicks on links)
2037              if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2038                  this.triggered = true;
2039                  try {
2040                      elem[ type ]();
2041                  // prevent IE from throwing an error for some hidden elements
2042                  } catch (e) {}
2043              }
2044  
2045              this.triggered = false;
2046          }
2047  
2048          return val;
2049      },
2050  
2051      handle: function(event) {
2052          // returned undefined or false
2053          var val, ret, namespace, all, handlers;
2054  
2055          event = arguments[0] = jQuery.event.fix( event || window.event );
2056  
2057          // Namespaced event handlers
2058          namespace = event.type.split(".");
2059          event.type = namespace[0];
2060          namespace = namespace[1];
2061          // Cache this now, all = true means, any handler
2062          all = !namespace && !event.exclusive;
2063  
2064          handlers = ( jQuery.data(this, "events") || {} )[event.type];
2065  
2066          for ( var j in handlers ) {
2067              var handler = handlers[j];
2068  
2069              // Filter the functions by class
2070              if ( all || handler.type == namespace ) {
2071                  // Pass in a reference to the handler function itself
2072                  // So that we can later remove it
2073                  event.handler = handler;
2074                  event.data = handler.data;
2075  
2076                  ret = handler.apply( this, arguments );
2077  
2078                  if ( val !== false )
2079                      val = ret;
2080  
2081                  if ( ret === false ) {
2082                      event.preventDefault();
2083                      event.stopPropagation();
2084                  }
2085              }
2086          }
2087  
2088          return val;
2089      },
2090  
2091      fix: function(event) {
2092          if ( event[expando] == true )
2093              return event;
2094  
2095          // store a copy of the original event object
2096          // and "clone" to set read-only properties
2097          var originalEvent = event;
2098          event = { originalEvent: originalEvent };
2099          var 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 timeStamp toElement type view wheelDelta which".split(" ");
2100          for ( var i=props.length; i; i-- )
2101              event[ props[i] ] = originalEvent[ props[i] ];
2102  
2103          // Mark it as fixed
2104          event[expando] = true;
2105  
2106          // add preventDefault and stopPropagation since
2107          // they will not work on the clone
2108          event.preventDefault = function() {
2109              // if preventDefault exists run it on the original event
2110              if (originalEvent.preventDefault)
2111                  originalEvent.preventDefault();
2112              // otherwise set the returnValue property of the original event to false (IE)
2113              originalEvent.returnValue = false;
2114          };
2115          event.stopPropagation = function() {
2116              // if stopPropagation exists run it on the original event
2117              if (originalEvent.stopPropagation)
2118                  originalEvent.stopPropagation();
2119              // otherwise set the cancelBubble property of the original event to true (IE)
2120              originalEvent.cancelBubble = true;
2121          };
2122  
2123          // Fix timeStamp
2124          event.timeStamp = event.timeStamp || now();
2125  
2126          // Fix target property, if necessary
2127          if ( !event.target )
2128              event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2129  
2130          // check if target is a textnode (safari)
2131          if ( event.target.nodeType == 3 )
2132              event.target = event.target.parentNode;
2133  
2134          // Add relatedTarget, if necessary
2135          if ( !event.relatedTarget && event.fromElement )
2136              event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2137  
2138          // Calculate pageX/Y if missing and clientX/Y available
2139          if ( event.pageX == null && event.clientX != null ) {
2140              var doc = document.documentElement, body = document.body;
2141              event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2142              event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2143          }
2144  
2145          // Add which for key events
2146          if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2147              event.which = event.charCode || event.keyCode;
2148  
2149          // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2150          if ( !event.metaKey && event.ctrlKey )
2151              event.metaKey = event.ctrlKey;
2152  
2153          // Add which for click: 1 == left; 2 == middle; 3 == right
2154          // Note: button is not normalized, so don't use it
2155          if ( !event.which && event.button )
2156              event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2157  
2158          return event;
2159      },
2160  
2161      proxy: function( fn, proxy ){
2162          // Set the guid of unique handler to the same of original handler, so it can be removed
2163          proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
2164          // So proxy can be declared as an argument
2165          return proxy;
2166      },
2167  
2168      special: {
2169          ready: {
2170              setup: function() {
2171                  // Make sure the ready event is setup
2172                  bindReady();
2173                  return;
2174              },
2175  
2176              teardown: function() { return; }
2177          },
2178  
2179          mouseenter: {
2180              setup: function() {
2181                  if ( jQuery.browser.msie ) return false;
2182                  jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
2183                  return true;
2184              },
2185  
2186              teardown: function() {
2187                  if ( jQuery.browser.msie ) return false;
2188                  jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
2189                  return true;
2190              },
2191  
2192              handler: function(event) {
2193                  // If we actually just moused on to a sub-element, ignore it
2194                  if ( withinElement(event, this) ) return true;
2195                  // Execute the right handlers by setting the event type to mouseenter
2196                  event.type = "mouseenter";
2197                  return jQuery.event.handle.apply(this, arguments);
2198              }
2199          },
2200  
2201          mouseleave: {
2202              setup: function() {
2203                  if ( jQuery.browser.msie ) return false;
2204                  jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
2205                  return true;
2206              },
2207  
2208              teardown: function() {
2209                  if ( jQuery.browser.msie ) return false;
2210                  jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
2211                  return true;
2212              },
2213  
2214              handler: function(event) {
2215                  // If we actually just moused on to a sub-element, ignore it
2216                  if ( withinElement(event, this) ) return true;
2217                  // Execute the right handlers by setting the event type to mouseleave
2218                  event.type = "mouseleave";
2219                  return jQuery.event.handle.apply(this, arguments);
2220              }
2221          }
2222      }
2223  };
2224  
2225  jQuery.fn.extend({
2226      bind: function( type, data, fn ) {
2227          return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2228              jQuery.event.add( this, type, fn || data, fn && data );
2229          });
2230      },
2231  
2232      one: function( type, data, fn ) {
2233          var one = jQuery.event.proxy( fn || data, function(event) {
2234              jQuery(this).unbind(event, one);
2235              return (fn || data).apply( this, arguments );
2236          });
2237          return this.each(function(){
2238              jQuery.event.add( this, type, one, fn && data);
2239          });
2240      },
2241  
2242      unbind: function( type, fn ) {
2243          return this.each(function(){
2244              jQuery.event.remove( this, type, fn );
2245          });
2246      },
2247  
2248      trigger: function( type, data, fn ) {
2249          return this.each(function(){
2250              jQuery.event.trigger( type, data, this, true, fn );
2251          });
2252      },
2253  
2254      triggerHandler: function( type, data, fn ) {
2255          return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
2256      },
2257  
2258      toggle: function( fn ) {
2259          // Save reference to arguments for access in closure
2260          var args = arguments, i = 1;
2261  
2262          // link all the functions, so any of them can unbind this click handler
2263          while( i < args.length )
2264              jQuery.event.proxy( fn, args[i++] );
2265  
2266          return this.click( jQuery.event.proxy( fn, function(event) {
2267              // Figure out which function to execute
2268              this.lastToggle = ( this.lastToggle || 0 ) % i;
2269  
2270              // Make sure that clicks stop
2271              event.preventDefault();
2272  
2273              // and execute the function
2274              return args[ this.lastToggle++ ].apply( this, arguments ) || false;
2275          }));
2276      },
2277  
2278      hover: function(fnOver, fnOut) {
2279          return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
2280      },
2281  
2282      ready: function(fn) {
2283          // Attach the listeners
2284          bindReady();
2285  
2286          // If the DOM is already ready
2287          if ( jQuery.isReady )
2288              // Execute the function immediately
2289              fn.call( document, jQuery );
2290  
2291          // Otherwise, remember the function for later
2292          else
2293              // Add the function to the wait list
2294              jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
2295  
2296          return this;
2297      }
2298  });
2299  
2300  jQuery.extend({
2301      isReady: false,
2302      readyList: [],
2303      // Handle when the DOM is ready
2304      ready: function() {
2305          // Make sure that the DOM is not already loaded
2306          if ( !jQuery.isReady ) {
2307              // Remember that the DOM is ready
2308              jQuery.isReady = true;
2309  
2310              // If there are functions bound, to execute
2311              if ( jQuery.readyList ) {
2312                  // Execute all of them
2313                  jQuery.each( jQuery.readyList, function(){
2314                      this.call( document );
2315                  });
2316  
2317                  // Reset the list of functions
2318                  jQuery.readyList = null;
2319              }
2320  
2321              // Trigger any bound ready events
2322              jQuery(document).triggerHandler("ready");
2323          }
2324      }
2325  });
2326  
2327  var readyBound = false;
2328  
2329  function bindReady(){
2330      if ( readyBound ) return;
2331      readyBound = true;
2332  
2333      // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
2334      if ( document.addEventListener && !jQuery.browser.opera)
2335          // Use the handy event callback
2336          document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
2337  
2338      // If IE is used and is not in a frame
2339      // Continually check to see if the document is ready
2340      if ( jQuery.browser.msie && window == top ) (function(){
2341          if (jQuery.isReady) return;
2342          try {
2343              // If IE is used, use the trick by Diego Perini
2344              // http://javascript.nwbox.com/IEContentLoaded/
2345              document.documentElement.doScroll("left");
2346          } catch( error ) {
2347              setTimeout( arguments.callee, 0 );
2348              return;
2349          }
2350          // and execute any waiting functions
2351          jQuery.ready();
2352      })();
2353  
2354      if ( jQuery.browser.opera )
2355          document.addEventListener( "DOMContentLoaded", function () {
2356              if (jQuery.isReady) return;
2357              for (var i = 0; i < document.styleSheets.length; i++)
2358                  if (document.styleSheets[i].disabled) {
2359                      setTimeout( arguments.callee, 0 );
2360                      return;
2361                  }
2362              // and execute any waiting functions
2363              jQuery.ready();
2364          }, false);
2365  
2366      if ( jQuery.browser.safari ) {
2367          var numStyles;
2368          (function(){
2369              if (jQuery.isReady) return;
2370              if ( document.readyState != "loaded" && document.readyState != "complete" ) {
2371                  setTimeout( arguments.callee, 0 );
2372                  return;
2373              }
2374              if ( numStyles === undefined )
2375                  numStyles = jQuery("style, link[rel=stylesheet]").length;
2376              if ( document.styleSheets.length != numStyles ) {
2377                  setTimeout( arguments.callee, 0 );
2378                  return;
2379              }
2380              // and execute any waiting functions
2381              jQuery.ready();
2382          })();
2383      }
2384  
2385      // A fallback to window.onload, that will always work
2386      jQuery.event.add( window, "load", jQuery.ready );
2387  }
2388  
2389  jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
2390      "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
2391      "submit,keydown,keypress,keyup,error").split(","), function(i, name){
2392  
2393      // Handle event binding
2394      jQuery.fn[name] = function(fn){
2395          return fn ? this.bind(name, fn) : this.trigger(name);
2396      };
2397  });
2398  
2399  // Checks if an event happened on an element within another element
2400  // Used in jQuery.event.special.mouseenter and mouseleave handlers
2401  var withinElement = function(event, elem) {
2402      // Check if mouse(over|out) are still within the same parent element
2403      var parent = event.relatedTarget;
2404      // Traverse up the tree
2405      while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
2406      // Return true if we actually just moused on to a sub-element
2407      return parent == elem;
2408  };
2409  
2410  // Prevent memory leaks in IE
2411  // And prevent errors on refresh with events like mouseover in other browsers
2412  // Window isn't included so as not to unbind existing unload events
2413  jQuery(window).bind("unload", function() {
2414      jQuery("*").add(document).unbind();
2415  });
2416  jQuery.fn.extend({
2417      // Keep a copy of the old load
2418      _load: jQuery.fn.load,
2419  
2420      load: function( url, params, callback ) {
2421          if ( typeof url != 'string' )
2422              return this._load( url );
2423  
2424          var off = url.indexOf(" ");
2425          if ( off >= 0 ) {
2426              var selector = url.slice(off, url.length);
2427              url = url.slice(0, off);
2428          }
2429  
2430          callback = callback || function(){};
2431  
2432          // Default to a GET request
2433          var type = "GET";
2434  
2435          // If the second parameter was provided
2436          if ( params )
2437              // If it's a function
2438              if ( jQuery.isFunction( params ) ) {
2439                  // We assume that it's the callback
2440                  callback = params;
2441                  params = null;
2442  
2443              // Otherwise, build a param string
2444              } else {
2445                  params = jQuery.param( params );
2446                  type = "POST";
2447              }
2448  
2449          var self = this;
2450  
2451          // Request the remote document
2452          jQuery.ajax({
2453              url: url,
2454              type: type,
2455              dataType: "html",
2456              data: params,
2457              complete: function(res, status){
2458                  // If successful, inject the HTML into all the matched elements
2459                  if ( status == "success" || status == "notmodified" )
2460                      // See if a selector was specified
2461                      self.html( selector ?
2462                          // Create a dummy div to hold the results
2463                          jQuery("<div/>")
2464                              // inject the contents of the document in, removing the scripts
2465                              // to avoid any 'Permission Denied' errors in IE
2466                              .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
2467  
2468                              // Locate the specified elements
2469                              .find(selector) :
2470  
2471                          // If not, just inject the full result
2472                          res.responseText );
2473  
2474                  self.each( callback, [res.responseText, status, res] );
2475              }
2476          });
2477          return this;
2478      },
2479  
2480      serialize: function() {
2481          return jQuery.param(this.serializeArray());
2482      },
2483      serializeArray: function() {
2484          return this.map(function(){
2485              return jQuery.nodeName(this, "form") ?
2486                  jQuery.makeArray(this.elements) : this;
2487          })
2488          .filter(function(){
2489              return this.name && !this.disabled &&
2490                  (this.checked || /select|textarea/i.test(this.nodeName) ||
2491                      /text|hidden|password/i.test(this.type));
2492          })
2493          .map(function(i, elem){
2494              var val = jQuery(this).val();
2495              return val == null ? null :
2496                  val.constructor == Array ?
2497                      jQuery.map( val, function(val, i){
2498                          return {name: elem.name, value: val};
2499                      }) :
2500                      {name: elem.name, value: val};
2501          }).get();
2502      }
2503  });
2504  
2505  // Attach a bunch of functions for handling common AJAX events
2506  jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
2507      jQuery.fn[o] = function(f){
2508          return this.bind(o, f);
2509      };
2510  });
2511  
2512  var jsc = now();
2513  
2514  jQuery.extend({
2515      get: function( url, data, callback, type ) {
2516          // shift arguments if data argument was ommited
2517          if ( jQuery.isFunction( data ) ) {
2518              callback = data;
2519              data = null;
2520          }
2521  
2522          return jQuery.ajax({
2523              type: "GET",
2524              url: url,
2525              data: data,
2526              success: callback,
2527              dataType: type
2528          });
2529      },
2530  
2531      getScript: function( url, callback ) {
2532          return jQuery.get(url, null, callback, "script");
2533      },
2534  
2535      getJSON: function( url, data, callback ) {
2536          return jQuery.get(url, data, callback, "json");
2537      },
2538  
2539      post: function( url, data, callback, type ) {
2540          if ( jQuery.isFunction( data ) ) {
2541              callback = data;
2542              data = {};
2543          }
2544  
2545          return jQuery.ajax({
2546              type: "POST",
2547              url: url,
2548              data: data,
2549              success: callback,
2550              dataType: type
2551          });
2552      },
2553  
2554      ajaxSetup: function( settings ) {
2555          jQuery.extend( jQuery.ajaxSettings, settings );
2556      },
2557  
2558      ajaxSettings: {
2559          url: location.href,
2560          global: true,
2561          type: "GET",
2562          timeout: 0,
2563          contentType: "application/x-www-form-urlencoded",
2564          processData: true,
2565          async: true,
2566          data: null,
2567          username: null,
2568          password: null,
2569          accepts: {
2570              xml: "application/xml, text/xml",
2571              html: "text/html",
2572              script: "text/javascript, application/javascript",
2573              json: "application/json, text/javascript",
2574              text: "text/plain",
2575              _default: "*/*"
2576          }
2577      },
2578  
2579      // Last-Modified header cache for next request
2580      lastModified: {},
2581  
2582      ajax: function( s ) {
2583          // Extend the settings, but re-extend 's' so that it can be
2584          // checked again later (in the test suite, specifically)
2585          s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
2586  
2587          var jsonp, jsre = /=\?(&|$)/g, status, data,
2588              type = s.type.toUpperCase();
2589  
2590          // convert data if not already a string
2591          if ( s.data && s.processData && typeof s.data != "string" )
2592              s.data = jQuery.param(s.data);
2593  
2594          // Handle JSONP Parameter Callbacks
2595          if ( s.dataType == "jsonp" ) {
2596              if ( type == "GET" ) {
2597                  if ( !s.url.match(jsre) )
2598                      s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
2599              } else if ( !s.data || !s.data.match(jsre) )
2600                  s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
2601              s.dataType = "json";
2602          }
2603  
2604          // Build temporary JSONP function
2605          if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
2606              jsonp = "jsonp" + jsc++;
2607  
2608              // Replace the =? sequence both in the query string and the data
2609              if ( s.data )
2610                  s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
2611              s.url = s.url.replace(jsre, "=" + jsonp + "$1");
2612  
2613              // We need to make sure
2614              // that a JSONP style response is executed properly
2615              s.dataType = "script";
2616  
2617              // Handle JSONP-style loading
2618              window[ jsonp ] = function(tmp){
2619                  data = tmp;
2620                  success();
2621                  complete();
2622                  // Garbage collect
2623                  window[ jsonp ] = undefined;
2624                  try{ delete window[ jsonp ]; } catch(e){}
2625                  if ( head )
2626                      head.removeChild( script );
2627              };
2628          }
2629  
2630          if ( s.dataType == "script" && s.cache == null )
2631              s.cache = false;
2632  
2633          if ( s.cache === false && type == "GET" ) {
2634              var ts = now();
2635              // try replacing _= if it is there
2636              var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
2637              // if nothing was replaced, add timestamp to the end
2638              s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
2639          }
2640  
2641          // If data is available, append data to url for get requests
2642          if ( s.data && type == "GET" ) {
2643              s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
2644  
2645              // IE likes to send both get and post data, prevent this
2646              s.data = null;
2647          }
2648  
2649          // Watch for a new set of requests
2650          if ( s.global && ! jQuery.active++ )
2651              jQuery.event.trigger( "ajaxStart" );
2652  
2653          // Matches an absolute URL, and saves the domain
2654          var remote = /^(?:\w+:)?\/\/([^\/?#]+)/;
2655  
2656          // If we're requesting a remote document
2657          // and trying to load JSON or Script with a GET
2658          if ( s.dataType == "script" && type == "GET"
2659                  && remote.test(s.url) && remote.exec(s.url)[1] != location.host ){
2660              var head = document.getElementsByTagName("head")[0];
2661              var script = document.createElement("script");
2662              script.src = s.url;
2663              if (s.scriptCharset)
2664                  script.charset = s.scriptCharset;
2665  
2666              // Handle Script loading
2667              if ( !jsonp ) {
2668                  var done = false;
2669  
2670                  // Attach handlers for all browsers
2671                  script.onload = script.onreadystatechange = function(){
2672                      if ( !done && (!this.readyState ||
2673                              this.readyState == "loaded" || this.readyState == "complete") ) {
2674                          done = true;
2675                          success();
2676                          complete();
2677                          head.removeChild( script );
2678                      }
2679                  };
2680              }
2681  
2682              head.appendChild(script);
2683  
2684              // We handle everything using the script element injection
2685              return undefined;
2686          }
2687  
2688          var requestDone = false;
2689  
2690          // Create the request object; Microsoft failed to properly
2691          // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
2692          var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
2693  
2694          // Open the socket
2695          // Passing null username, generates a login popup on Opera (#2865)
2696          if( s.username )
2697              xhr.open(type, s.url, s.async, s.username, s.password);
2698          else
2699              xhr.open(type, s.url, s.async);
2700  
2701          // Need an extra try/catch for cross domain requests in Firefox 3
2702          try {
2703              // Set the correct header, if data is being sent
2704              if ( s.data )
2705                  xhr.setRequestHeader("Content-Type", s.contentType);
2706  
2707              // Set the If-Modified-Since header, if ifModified mode.
2708              if ( s.ifModified )
2709                  xhr.setRequestHeader("If-Modified-Since",
2710                      jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
2711  
2712              // Set header so the called script knows that it's an XMLHttpRequest
2713              xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
2714  
2715              // Set the Accepts header for the server, depending on the dataType
2716              xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
2717                  s.accepts[ s.dataType ] + ", */*" :
2718                  s.accepts._default );
2719          } catch(e){}
2720  
2721          // Allow custom headers/mimetypes
2722          if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
2723              // cleanup active request counter
2724              s.global && jQuery.active--;
2725              // close opended socket
2726              xhr.abort();
2727              return false;
2728          }
2729  
2730          if ( s.global )
2731              jQuery.event.trigger("ajaxSend", [xhr, s]);
2732  
2733          // Wait for a response to come back
2734          var onreadystatechange = function(isTimeout){
2735              // The transfer is complete and the data is available, or the request timed out
2736              if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
2737                  requestDone = true;
2738  
2739                  // clear poll interval
2740                  if (ival) {
2741                      clearInterval(ival);
2742                      ival = null;
2743                  }
2744  
2745                  status = isTimeout == "timeout" && "timeout" ||
2746                      !jQuery.httpSuccess( xhr ) && "error" ||
2747                      s.ifModified && jQuery.httpNotModified( xhr, s.url ) && "notmodified" ||
2748                      "success";
2749  
2750                  if ( status == "success" ) {
2751                      // Watch for, and catch, XML document parse errors
2752                      try {
2753                          // process the data (runs the xml through httpData regardless of callback)
2754                          data = jQuery.httpData( xhr, s.dataType, s.dataFilter );
2755                      } catch(e) {
2756                          status = "parsererror";
2757                      }
2758                  }
2759  
2760                  // Make sure that the request was successful or notmodified
2761                  if ( status == "success" ) {
2762                      // Cache Last-Modified header, if ifModified mode.
2763                      var modRes;
2764                      try {
2765                          modRes = xhr.getResponseHeader("Last-Modified");
2766                      } catch(e) {} // swallow exception thrown by FF if header is not available
2767  
2768                      if ( s.ifModified && modRes )
2769                          jQuery.lastModified[s.url] = modRes;
2770  
2771                      // JSONP handles its own success callback
2772                      if ( !jsonp )
2773                          success();
2774                  } else
2775                      jQuery.handleError(s, xhr, status);
2776  
2777                  // Fire the complete handlers
2778                  complete();
2779  
2780                  // Stop memory leaks
2781                  if ( s.async )
2782                      xhr = null;
2783              }
2784          };
2785  
2786          if ( s.async ) {
2787              // don't attach the handler to the request, just poll it instead
2788              var ival = setInterval(onreadystatechange, 13);
2789  
2790              // Timeout checker
2791              if ( s.timeout > 0 )
2792                  setTimeout(function(){
2793                      // Check to see if the request is still happening
2794                      if ( xhr ) {
2795                          // Cancel the request
2796                          xhr.abort();
2797  
2798                          if( !requestDone )
2799                              onreadystatechange( "timeout" );
2800                      }
2801                  }, s.timeout);
2802          }
2803  
2804          // Send the data
2805          try {
2806              xhr.send(s.data);
2807          } catch(e) {
2808              jQuery.handleError(s, xhr, null, e);
2809          }
2810  
2811          // firefox 1.5 doesn't fire statechange for sync requests
2812          if ( !s.async )
2813              onreadystatechange();
2814  
2815  		function success(){
2816              // If a local callback was specified, fire it and pass it the data
2817              if ( s.success )
2818                  s.success( data, status );
2819  
2820              // Fire the global callback
2821              if ( s.global )
2822                  jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
2823          }
2824  
2825  		function complete(){
2826              // Process result
2827              if ( s.complete )
2828                  s.complete(xhr, status);
2829  
2830              // The request was completed
2831              if ( s.global )
2832                  jQuery.event.trigger( "ajaxComplete", [xhr, s] );
2833  
2834              // Handle the global AJAX counter
2835              if ( s.global && ! --jQuery.active )
2836                  jQuery.event.trigger( "ajaxStop" );
2837          }
2838  
2839          // return XMLHttpRequest to allow aborting the request etc.
2840          return xhr;
2841      },
2842  
2843      handleError: function( s, xhr, status, e ) {
2844          // If a local callback was specified, fire it
2845          if ( s.error ) s.error( xhr, status, e );
2846  
2847          // Fire the global callback
2848          if ( s.global )
2849              jQuery.event.trigger( "ajaxError", [xhr, s, e] );
2850      },
2851  
2852      // Counter for holding the number of active queries
2853      active: 0,
2854  
2855      // Determines if an XMLHttpRequest was successful or not
2856      httpSuccess: function( xhr ) {
2857          try {
2858              // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
2859              return !xhr.status && location.protocol == "file:" ||
2860                  ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223 ||
2861                  jQuery.browser.safari && xhr.status == undefined;
2862          } catch(e){}
2863          return false;
2864      },
2865  
2866      // Determines if an XMLHttpRequest returns NotModified
2867      httpNotModified: function( xhr, url ) {
2868          try {
2869              var xhrRes = xhr.getResponseHeader("Last-Modified");
2870  
2871              // Firefox always returns 200. check Last-Modified date
2872              return xhr.status == 304 || xhrRes == jQuery.lastModified[url] ||
2873                  jQuery.browser.safari && xhr.status == undefined;
2874          } catch(e){}
2875          return false;
2876      },
2877  
2878      httpData: function( xhr, type, filter ) {
2879          var ct = xhr.getResponseHeader("content-type"),
2880              xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
2881              data = xml ? xhr.responseXML : xhr.responseText;
2882  
2883          if ( xml && data.documentElement.tagName == "parsererror" )
2884              throw "parsererror";
2885              
2886          // Allow a pre-filtering function to sanitize the response
2887          if( filter )
2888              data = filter( data, type );
2889  
2890          // If the type is "script", eval it in global context
2891          if ( type == "script" )
2892              jQuery.globalEval( data );
2893  
2894          // Get the JavaScript object, if JSON is used.
2895          if ( type == "json" )
2896              data = eval("(" + data + ")");
2897  
2898          return data;
2899      },
2900  
2901      // Serialize an array of form elements or a set of
2902      // key/values into a query string
2903      param: function( a ) {
2904          var s = [];
2905  
2906          // If an array was passed in, assume that it is an array
2907          // of form elements
2908          if ( a.constructor == Array || a.jquery )
2909              // Serialize the form elements
2910              jQuery.each( a, function(){
2911                  s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
2912              });
2913  
2914          // Otherwise, assume that it's an object of key/value pairs
2915          else
2916              // Serialize the key/values
2917              for ( var j in a )
2918                  // If the value is an array then the key names need to be repeated
2919                  if ( a[j] && a[j].constructor == Array )
2920                      jQuery.each( a[j], function(){
2921                          s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
2922                      });
2923                  else
2924                      s.push( encodeURIComponent(j) + "=" + encodeURIComponent( jQuery.isFunction(a[j]) ? a[j]() : a[j] ) );
2925  
2926          // Return the resulting serialization
2927          return s.join("&").replace(/%20/g, "+");
2928      }
2929  
2930  });
2931  jQuery.fn.extend({
2932      show: function(speed,callback){
2933          return speed ?
2934              this.animate({
2935                  height: "show", width: "show", opacity: "show"
2936              }, speed, callback) :
2937  
2938              this.filter(":hidden").each(function(){
2939                  this.style.display = this.oldblock || "";
2940                  if ( jQuery.css(this,"display") == "none" ) {
2941                      var elem = jQuery("<" + this.tagName + " />").appendTo("body");
2942                      this.style.display = elem.css("display");
2943                      // handle an edge condition where css is - div { display:none; } or similar
2944                      if (this.style.display == "none")
2945                          this.style.display = "block";
2946                      elem.remove();
2947                  }
2948              }).end();
2949      },
2950  
2951      hide: function(speed,callback){
2952          return speed ?
2953              this.animate({
2954                  height: "hide", width: "hide", opacity: "hide"
2955              }, speed, callback) :
2956  
2957              this.filter(":visible").each(function(){
2958                  this.oldblock = this.oldblock || jQuery.css(this,"display");
2959                  this.style.display = "none";
2960              }).end();
2961      },
2962  
2963      // Save the old toggle function
2964      _toggle: jQuery.fn.toggle,
2965  
2966      toggle: function( fn, fn2 ){
2967          return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
2968              this._toggle.apply( this, arguments ) :
2969              fn ?
2970                  this.animate({
2971                      height: "toggle", width: "toggle", opacity: "toggle"
2972                  }, fn, fn2) :
2973                  this.each(function(){
2974                      jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
2975                  });
2976      },
2977  
2978      slideDown: function(speed,callback){
2979          return this.animate({height: "show"}, speed, callback);
2980      },
2981  
2982      slideUp: function(speed,callback){
2983          return this.animate({height: "hide"}, speed, callback);
2984      },
2985  
2986      slideToggle: function(speed, callback){
2987          return this.animate({height: "toggle"}, speed, callback);
2988      },
2989  
2990      fadeIn: function(speed, callback){
2991          return this.animate({opacity: "show"}, speed, callback);
2992      },
2993  
2994      fadeOut: function(speed, callback){
2995          return this.animate({opacity: "hide"}, speed, callback);
2996      },
2997  
2998      fadeTo: function(speed,to,callback){
2999          return this.animate({opacity: to}, speed, callback);
3000      },
3001  
3002      animate: function( prop, speed, easing, callback ) {
3003          var optall = jQuery.speed(speed, easing, callback);
3004  
3005          return this[ optall.queue === false ? "each" : "queue" ](function(){
3006              if ( this.nodeType != 1)
3007                  return false;
3008  
3009              var opt = jQuery.extend({}, optall), p,
3010                  hidden = jQuery(this).is(":hidden"), self = this;
3011  
3012              for ( p in prop ) {
3013                  if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
3014                      return opt.complete.call(this);
3015  
3016                  if ( p == "height" || p == "width" ) {
3017                      // Store display property
3018                      opt.display = jQuery.css(this, "display");
3019  
3020                      // Make sure that nothing sneaks out
3021                      opt.overflow = this.style.overflow;
3022                  }
3023              }
3024  
3025              if ( opt.overflow != null )
3026                  this.style.overflow = "hidden";
3027  
3028              opt.curAnim = jQuery.extend({}, prop);
3029  
3030              jQuery.each( prop, function(name, val){
3031                  var e = new jQuery.fx( self, opt, name );
3032  
3033                  if ( /toggle|show|hide/.test(val) )
3034                      e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3035                  else {
3036                      var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3037                          start = e.cur(true) || 0;
3038  
3039                      if ( parts ) {
3040                          var end = parseFloat(parts[2]),
3041                              unit = parts[3] || "px";
3042  
3043                          // We need to compute starting value
3044                          if ( unit != "px" ) {
3045                              self.style[ name ] = (end || 1) + unit;
3046                              start = ((end || 1) / e.cur(true)) * start;
3047                              self.style[ name ] = start + unit;
3048                          }
3049  
3050                          // If a +=/-= token was provided, we're doing a relative animation
3051                          if ( parts[1] )
3052                              end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3053  
3054                          e.custom( start, end, unit );
3055                      } else
3056                          e.custom( start, val, "" );
3057                  }
3058              });
3059  
3060              // For JS strict compliance
3061              return true;
3062          });
3063      },
3064  
3065      queue: function(type, fn){
3066          if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
3067              fn = type;
3068              type = "fx";
3069          }
3070  
3071          if ( !type || (typeof type == "string" && !fn) )
3072              return queue( this[0], type );
3073  
3074          return this.each(function(){
3075              if ( fn.constructor == Array )
3076                  queue(this, type, fn);
3077              else {
3078                  queue(this, type).push( fn );
3079  
3080                  if ( queue(this, type).length == 1 )
3081                      fn.call(this);
3082              }
3083          });
3084      },
3085  
3086      stop: function(clearQueue, gotoEnd){
3087          var timers = jQuery.timers;
3088  
3089          if (clearQueue)
3090              this.queue([]);
3091  
3092          this.each(function(){
3093              // go in reverse order so anything added to the queue during the loop is ignored
3094              for ( var i = timers.length - 1; i >= 0; i-- )
3095                  if ( timers[i].elem == this ) {
3096                      if (gotoEnd)
3097                          // force the next step to be the last
3098                          timers[i](true);
3099                      timers.splice(i, 1);
3100                  }
3101          });
3102  
3103          // start the next in the queue if the last step wasn't forced
3104          if (!gotoEnd)
3105              this.dequeue();
3106  
3107          return this;
3108      }
3109  
3110  });
3111  
3112  var queue = function( elem, type, array ) {
3113      if ( elem ){
3114  
3115          type = type || "fx";
3116  
3117          var q = jQuery.data( elem, type + "queue" );
3118  
3119          if ( !q || array )
3120              q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
3121  
3122      }
3123      return q;
3124  };
3125  
3126  jQuery.fn.dequeue = function(type){
3127      type = type || "fx";
3128  
3129      return this.each(function(){
3130          var q = queue(this, type);
3131  
3132          q.shift();
3133  
3134          if ( q.length )
3135              q[0].call( this );
3136      });
3137  };
3138  
3139  jQuery.extend({
3140  
3141      speed: function(speed, easing, fn) {
3142          var opt = speed && speed.constructor == Object ? speed : {
3143              complete: fn || !fn && easing ||
3144                  jQuery.isFunction( speed ) && speed,
3145              duration: speed,
3146              easing: fn && easing || easing && easing.constructor != Function && easing
3147          };
3148  
3149          opt.duration = (opt.duration && opt.duration.constructor == Number ?
3150              opt.duration :
3151              jQuery.fx.speeds[opt.duration]) || jQuery.fx.speeds.def;
3152  
3153          // Queueing
3154          opt.old = opt.complete;
3155          opt.complete = function(){
3156              if ( opt.queue !== false )
3157                  jQuery(this).dequeue();
3158              if ( jQuery.isFunction( opt.old ) )
3159                  opt.old.call( this );
3160          };
3161  
3162          return opt;
3163      },
3164  
3165      easing: {
3166          linear: function( p, n, firstNum, diff ) {
3167              return firstNum + diff * p;
3168          },
3169          swing: function( p, n, firstNum, diff ) {
3170              return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
3171          }
3172      },
3173  
3174      timers: [],
3175      timerId: null,
3176  
3177      fx: function( elem, options, prop ){
3178          this.options = options;
3179          this.elem = elem;
3180          this.prop = prop;
3181  
3182          if ( !options.orig )
3183              options.orig = {};
3184      }
3185  
3186  });
3187  
3188  jQuery.fx.prototype = {
3189  
3190      // Simple function for setting a style value
3191      update: function(){
3192          if ( this.options.step )
3193              this.options.step.call( this.elem, this.now, this );
3194  
3195          (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
3196  
3197          // Set display property to block for height/width animations
3198          if ( this.prop == "height" || this.prop == "width" )
3199              this.elem.style.display = "block";
3200      },
3201  
3202      // Get the current size
3203      cur: function(force){
3204          if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
3205              return this.elem[ this.prop ];
3206  
3207          var r = parseFloat(jQuery.css(this.elem, this.prop, force));
3208          return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
3209      },
3210  
3211      // Start an animation from one number to another
3212      custom: function(from, to, unit){
3213          this.startTime = now();
3214          this.start = from;
3215          this.end = to;
3216          this.unit = unit || this.unit || "px";
3217          this.now = this.start;
3218          this.pos = this.state = 0;
3219          this.update();
3220  
3221          var self = this;
3222          function t(gotoEnd){
3223              return self.step(gotoEnd);
3224          }
3225  
3226          t.elem = this.elem;
3227  
3228          jQuery.timers.push(t);
3229  
3230          if ( jQuery.timerId == null ) {
3231              jQuery.timerId = setInterval(function(){
3232                  var timers = jQuery.timers;
3233  
3234                  for ( var i = 0; i < timers.length; i++ )
3235                      if ( !timers[i]() )
3236                          timers.splice(i--, 1);
3237  
3238                  if ( !timers.length ) {
3239                      clearInterval( jQuery.timerId );
3240                      jQuery.timerId = null;
3241                  }
3242              }, 13);
3243          }
3244      },
3245  
3246      // Simple 'show' function
3247      show: function(){
3248          // Remember where we started, so that we can go back to it later
3249          this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3250          this.options.show = true;
3251  
3252          // Begin the animation
3253          this.custom(0, this.cur());
3254  
3255          // Make sure that we start at a small width/height to avoid any
3256          // flash of content
3257          if ( this.prop == "width" || this.prop == "height" )
3258              this.elem.style[this.prop] = "1px";
3259  
3260          // Start by showing the element
3261          jQuery(this.elem).show();
3262      },
3263  
3264      // Simple 'hide' function
3265      hide: function(){
3266          // Remember where we started, so that we can go back to it later
3267          this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3268          this.options.hide = true;
3269  
3270          // Begin the animation
3271          this.custom(this.cur(), 0);
3272      },
3273  
3274      // Each step of an animation
3275      step: function(gotoEnd){
3276          var t = now();
3277  
3278          if ( gotoEnd || t > this.options.duration + this.startTime ) {
3279              this.now = this.end;
3280              this.pos = this.state = 1;
3281              this.update();
3282  
3283              this.options.curAnim[ this.prop ] = true;
3284  
3285              var done = true;
3286              for ( var i in this.options.curAnim )
3287                  if ( this.options.curAnim[i] !== true )
3288                      done = false;
3289  
3290              if ( done ) {
3291                  if ( this.options.display != null ) {
3292                      // Reset the overflow
3293                      this.elem.style.overflow = this.options.overflow;
3294  
3295                      // Reset the display
3296                      this.elem.style.display = this.options.display;
3297                      if ( jQuery.css(this.elem, "display") == "none" )
3298                          this.elem.style.display = "block";
3299                  }
3300  
3301                  // Hide the element if the "hide" operation was done
3302                  if ( this.options.hide )
3303                      this.elem.style.display = "none";
3304  
3305                  // Reset the properties, if the item has been hidden or shown
3306                  if ( this.options.hide || this.options.show )
3307                      for ( var p in this.options.curAnim )
3308                          jQuery.attr(this.elem.style, p, this.options.orig[p]);
3309              }
3310  
3311              if ( done )
3312                  // Execute the complete function
3313                  this.options.complete.call( this.elem );
3314  
3315              return false;
3316          } else {
3317              var n = t - this.startTime;
3318              this.state = n / this.options.duration;
3319  
3320              // Perform the easing function, defaults to swing
3321              this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
3322              this.now = this.start + ((this.end - this.start) * this.pos);
3323  
3324              // Perform the next step of the animation
3325              this.update();
3326          }
3327  
3328          return true;
3329      }
3330  
3331  };
3332  
3333  jQuery.extend( jQuery.fx, {
3334      speeds:{
3335          slow: 600,
3336           fast: 200,
3337           // Default speed
3338           def: 400
3339      },
3340      step: {
3341          scrollLeft: function(fx){
3342              fx.elem.scrollLeft = fx.now;
3343          },
3344  
3345          scrollTop: function(fx){
3346              fx.elem.scrollTop = fx.now;
3347          },
3348  
3349          opacity: function(fx){
3350              jQuery.attr(fx.elem.style, "opacity", fx.now);
3351          },
3352  
3353          _default: function(fx){
3354              fx.elem.style[ fx.prop ] = fx.now + fx.unit;
3355          }
3356      }
3357  });
3358  // The Offset Method
3359  // Originally By Brandon Aaron, part of the Dimension Plugin
3360  // http://jquery.com/plugins/project/dimensions
3361  jQuery.fn.offset = function() {
3362      var left = 0, top = 0, elem = this[0], results;
3363  
3364      if ( elem ) with ( jQuery.browser ) {
3365          var parent       = elem.parentNode,
3366              offsetChild  = elem,
3367              offsetParent = elem.offsetParent,
3368              doc          = elem.ownerDocument,
3369              safari2      = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
3370              css          = jQuery.curCSS,
3371              fixed        = css(elem, "position") == "fixed";
3372  
3373          // Use getBoundingClientRect if available
3374          if ( elem.getBoundingClientRect ) {
3375              var box = elem.getBoundingClientRect();
3376  
3377              // Add the document scroll offsets
3378              add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3379                  box.top  + Math.max(doc.documentElement.scrollTop,  doc.body.scrollTop));
3380  
3381              // IE adds the HTML element's border, by default it is medium which is 2px
3382              // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
3383              // IE 7 standards mode, the border is always 2px
3384              // This border/offset is typically represented by the clientLeft and clientTop properties
3385              // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
3386              // Therefore this method will be off by 2px in IE while in quirksmode
3387              add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );
3388  
3389          // Otherwise loop through the offsetParents and parentNodes
3390          } else {
3391  
3392              // Initial element offsets
3393              add( elem.offsetLeft, elem.offsetTop );
3394  
3395              // Get parent offsets
3396              while ( offsetParent ) {
3397                  // Add offsetParent offsets
3398                  add( offsetParent.offsetLeft, offsetParent.offsetTop );
3399  
3400                  // Mozilla and Safari > 2 does not include the border on offset parents
3401                  // However Mozilla adds the border for table or table cells
3402                  if ( mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2 )
3403                      border( offsetParent );
3404  
3405                  // Add the document scroll offsets if position is fixed on any offsetParent
3406                  if ( !fixed && css(offsetParent, "position") == "fixed" )
3407                      fixed = true;
3408  
3409                  // Set offsetChild to previous offsetParent unless it is the body element
3410                  offsetChild  = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
3411                  // Get next offsetParent
3412                  offsetParent = offsetParent.offsetParent;
3413              }
3414  
3415              // Get parent scroll offsets
3416              while ( parent && parent.tagName && !/^body|html$/i.test(parent.tagName) ) {
3417                  // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
3418                  if ( !/^inline|table.*$/i.test(css(parent, "display")) )
3419                      // Subtract parent scroll offsets
3420                      add( -parent.scrollLeft, -parent.scrollTop );
3421  
3422                  // Mozilla does not add the border for a parent that has overflow != visible
3423                  if ( mozilla && css(parent, "overflow") != "visible" )
3424                      border( parent );
3425  
3426                  // Get next parent
3427                  parent = parent.parentNode;
3428              }
3429  
3430              // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
3431              // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
3432              if ( (safari2 && (fixed || css(offsetChild, "position") == "absolute")) ||
3433                  (mozilla && css(offsetChild, "position") != "absolute") )
3434                      add( -doc.body.offsetLeft, -doc.body.offsetTop );
3435  
3436              // Add the document scroll offsets if position is fixed
3437              if ( fixed )
3438                  add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3439                      Math.max(doc.documentElement.scrollTop,  doc.body.scrollTop));
3440          }
3441  
3442          // Return an object with top and left properties
3443          results = { top: top, left: left };
3444      }
3445  
3446  	function border(elem) {
3447          add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
3448      }
3449  
3450  	function add(l, t) {
3451          left += parseInt(l, 10) || 0;
3452          top += parseInt(t, 10) || 0;
3453      }
3454  
3455      return results;
3456  };
3457  
3458  
3459  jQuery.fn.extend({
3460      position: function() {
3461          var left = 0, top = 0, results;
3462  
3463          if ( this[0] ) {
3464              // Get *real* offsetParent
3465              var offsetParent = this.offsetParent(),
3466  
3467              // Get correct offsets
3468              offset       = this.offset(),
3469              parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
3470  
3471              // Subtract element margins
3472              // note: when an element has margin: auto the offsetLeft and marginLeft 
3473              // are the same in Safari causing offset.left to incorrectly be 0
3474              offset.top  -= num( this, 'marginTop' );
3475              offset.left -= num( this, 'marginLeft' );
3476  
3477              // Add offsetParent borders
3478              parentOffset.top  += num( offsetParent, 'borderTopWidth' );
3479              parentOffset.left += num( offsetParent, 'borderLeftWidth' );
3480  
3481              // Subtract the two offsets
3482              results = {
3483                  top:  offset.top  - parentOffset.top,
3484                  left: offset.left - parentOffset.left
3485              };
3486          }
3487  
3488          return results;
3489      },
3490  
3491      offsetParent: function() {
3492          var offsetParent = this[0].offsetParent;
3493          while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
3494              offsetParent = offsetParent.offsetParent;
3495          return jQuery(offsetParent);
3496      }
3497  });
3498  
3499  
3500  // Create scrollLeft and scrollTop methods
3501  jQuery.each( ['Left', 'Top'], function(i, name) {
3502      var method = 'scroll' + name;
3503      
3504      jQuery.fn[ method ] = function(val) {
3505          if (!this[0]) return;
3506  
3507          return val != undefined ?
3508  
3509              // Set the scroll offset
3510              this.each(function() {
3511                  this == window || this == document ?
3512                      window.scrollTo(
3513                          !i ? val : jQuery(window).scrollLeft(),
3514                           i ? val : jQuery(window).scrollTop()
3515                      ) :
3516                      this[ method ] = val;
3517              }) :
3518  
3519              // Return the scroll offset
3520              this[0] == window || this[0] == document ?
3521                  self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
3522                      jQuery.boxModel && document.documentElement[ method ] ||
3523                      document.body[ method ] :
3524                  this[0][ method ];
3525      };
3526  });
3527  // Create innerHeight, innerWidth, outerHeight and outerWidth methods
3528  jQuery.each([ "Height", "Width" ], function(i, name){
3529  
3530      var tl = i ? "Left"  : "Top",  // top or left
3531          br = i ? "Right" : "Bottom"; // bottom or right
3532  
3533      // innerHeight and innerWidth
3534      jQuery.fn["inner" + name] = function(){
3535          return this[ name.toLowerCase() ]() +
3536              num(this, "padding" + tl) +
3537              num(this, "padding" + br);
3538      };
3539  
3540      // outerHeight and outerWidth
3541      jQuery.fn["outer" + name] = function(margin) {
3542          return this["inner" + name]() +
3543              num(this, "border" + tl + "Width") +
3544              num(this, "border" + br + "Width") +
3545              (margin ?
3546                  num(this, "margin" + tl) + num(this, "margin" + br) : 0);
3547      };
3548  
3549  });})();