Forum

Div folder an der Seite "mitsliden"

Erstellt von Mac08, 11.04.2011.



  1. Mac08

    Mac08 Noch nicht viel geschrieben

    Dabei seit:
    11.04.2011
    Beiträge:
    4
    Geschlecht:
    männlich
    Div folder an der Seite "mitsliden"
    Hey Community,

    ich habe in diesem Forum zu meiner gestellten Frage schon 2 hilfreiche Seiten gefunden. Da ich allerdings ein ziemlicher Neuling bin, was HTML, JAVA und CSS angeht habe ich noch eine Frage und wäre sehr froh über Hilfe! :)

    Thread:
    http://www.psd-tutorials.de/forum/4...iv-soll-beim-herunterscrollen-mitwandern.html

    PDF-Tutorial:
    Tutorial Mitscrollende Navigation mit jQuery - PSD-Tutorials.de

    Hier mein bisheriger Quelltext:
    HTML:
    1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    2. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" lang="de">
    3.  
    4.     <title>MaCX - Computer Hardware</title>
    5.  
    6.     <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" />
    7.     <meta name="Auf dieser Seite finden sie die aktuellsten und neusten Hardwareinformationen und Testberichte." content="" />
    8.     <meta name="Marc Hoffmann, Max Hofmann" content="" />
    9.     <meta name="Computer Beratung Hardware Empfehlungen Testberichte Gaming Multimedia PC Konfiguration" content="" />
    10.  
    11.     <link href="css/struktur.css" rel="stylesheet" type="text/css" />
    12.     <link href="css/layout.css" rel="stylesheet" type="text/css" />
    13.  
    14.     <link rel="shortcut icon" href="favicon_index.ico" type="image/x-icon"/>
    15. </head>
    16.  
    17. <div id="mother">
    18.     <div id="header">
    19.         <h1>
    20.         <strong>
    21.                 Computer Hardware Empfehlungen
    22.             <br/>
    23.             <br/>
    24.                 -  HOME  -
    25.         </strong>
    26.         </h1>
    27.  
    28.     </div>
    29.             <hr/>
    30.     <div id="menu">
    31.     <ul>
    32.         <li><span id="high">Sie sind hier: <br/> · Home</span></li>
    33.     </ul>
    34.     <ul>
    35.         <li><a href="konfigurationstipps.html">→ Konfiguration&nbsp;</a></li>
    36.         <li><a href="grundlagen.html">→ Grundlagen&nbsp;</a></li>
    37.         <li><a href="grafikkarten.html">→ Grafikkarten&nbsp;</a></li>
    38.         <li><a href="sonstiges.html">→ Sonstiges&nbsp;</a></li>
    39.         <li><a href="kontakt.html">→ Kontakt&nbsp;</a></li>
    40.         <li><a href="impressum.html">→ Impressum&nbsp;</a></li>
    41.     </ul>
    42.     </div>
    43.     <div id="main">
    44.  
    45.  
    46.  
    47.         <h4>
    48.  
    49.         </h4>
    50.  
    51.  
    52.  
    53.     </div>
    54.     <div id="footer">
    55.  
    56.     </div>
    57.  
    58. </div>
    59. </body>
    60. </html>
    61.  
    CSS-Struktur von meinem "menu"-div
    Code (Text):
    1. #menu {
    2.   position: fixed;
    3.   float: left;
    4.   width: 190px;
    5.   background-color: #808080;
    6.   padding: 42px 0px;
    7.   text-decoration: blink;
    8. }
    9.  
    CSS-Layout von meinem "menu"-div
    Code (Text):
    1. #menu a {
    2.   font: 100%;
    3.   text-decoration: none;
    4.   font-weight: bold;
    5.   color: black;
    6.   display: block;
    7.   padding: 3px;
    8. }
    9.  
    10. #menu a:hover {
    11.   color: yellow;
    12.   text-decoration: underline;
    13.   text-align: right;
    14.   background-color: #FF0000;
    15. }
    16.  
    17. #menu li {
    18.   border: 1px solid black;
    19. }
    20.  
    21. #menu #high {
    22.   font-weight: bold;
    23.   color: yellow;
    24.   background-color: gray;
    25.   display: block;
    26.   padding: 3px;
    27. }
    28.  
    29. #menu ul {
    30.   line-height: 1.6;
    31.   list-style-type: none;
    32. }
    33.  
    34. #menu ul ul {
    35.   line-height: 1.4;
    36.   padding-left: 20px;
    37. }
    Der div folder "menu" soll in meinem Beispiel links an der Seite mitsliden.
    Die im PDF angesprochene jquery.js - Datei habe ich gedownloaded und in meinem Ordner abgelegt.
    Meine Frage ist nun, wo ich den im PDF-Tutorial angesprochenen Script Teil in meinem Quelltext einfügen soll.
    Muss in der CSS-Datei auch etwas verändert werden?

    Ich würde mich über Hilfe sehr freuen!

    Danke im Vorraus und lg

    Mac:D

    PS: Hier der im PDF angegebene Beispiel-Quelltext:

     
    #1      
  2. 2High2Die

    2High2Die Noch nicht viel geschrieben

    Dabei seit:
    11.04.2011
    Beiträge:
    2
    Geschlecht:
    männlich
    Div folder an der Seite "mitsliden"
    AW: Div folder an der Seite "mitsliden"

    Die 2 <script> Blöcke musst du in deinen <head> Bereich kopieren....
    Das Script aus dem PDF spricht den DIV mit dem Namen "navigation" an... also solltest du, wenn möglich dein <div id="menu"> in <div id="navigation"> umbenennen bzw. im jQuery-Script den Namen anpassen (z.B.: $('#navigation').animate({top: targetPosition}, 1000); zu $('#menu').animate({top: targetPosition}, 1000);)
     
    #2      
  3. Mac08

    Mac08 Noch nicht viel geschrieben

    Dabei seit:
    11.04.2011
    Beiträge:
    4
    Geschlecht:
    männlich
    Div folder an der Seite "mitsliden"
    AW: Div folder an der Seite "mitsliden"

    It works! :D Danke 2High!

    Dann noch eine Frage:

    Ist es möglich eine Position festzulegen, über die der <div="navigation> sich nicht bewegen darf? Immoment rutscht er beim runter- und anschließendem hochscrollen immer in den <div="header">.
     
    #3      
  4. 2High2Die

    2High2Die Noch nicht viel geschrieben

    Dabei seit:
    11.04.2011
    Beiträge:
    2
    Geschlecht:
    männlich
    Div folder an der Seite "mitsliden"
    AW: Div folder an der Seite "mitsliden"

    puhh... da gibts mehrere Lösungsansätze... dafür müsst ich aber die komplette Seite mal sehen...
     
    #4      
  5. Mac08

    Mac08 Noch nicht viel geschrieben

    Dabei seit:
    11.04.2011
    Beiträge:
    4
    Geschlecht:
    männlich
    Div folder an der Seite "mitsliden"
    AW: Div folder an der Seite "mitsliden"

    index.html Quelltext:

    HTML:
    1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    2. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" lang="de">
    3.  
    4.     <title>MaCX - Computer Hardware</title>
    5.  
    6.     <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" />
    7.     <meta name="Auf dieser Seite finden sie die aktuellsten und neusten Hardwareinformationen und Testberichte." content="" />
    8.     <meta name="Marc Hoffmann, Max Hofmann" content="" />
    9.     <meta name="Computer Beratung Hardware Empfehlungen Testberichte Gaming Multimedia PC Konfiguration" content="" />
    10.  
    11.     <link href="css/struktur.css" rel="stylesheet" type="text/css" />
    12.     <link href="css/layout.css" rel="stylesheet" type="text/css" />
    13.  
    14.     <link rel="shortcut icon" href="favicon_index.ico" type="image/x-icon"/>
    15.  
    16.     <script type="text/javascript" src="http://code.jquery.com/jquery-1.4.2.js"></script>
    17.     <script type="text/javascript">
    18.     try {
    19.     window.onscroll = setNavPosition;
    20.     }
    21.     catch(e) {
    22.     document.documentElement.onscroll = setNavPosition;
    23.     }
    24.     function setNavPosition(){
    25.     $('#navigation').stop();
    26.     try {
    27.     if (document.body.scrollTop > document.documentElement.scrollTop) {
    28.     var targetPosition = document.body.scrollTop;
    29.     }
    30.     else {
    31.     var targetPosition = document.documentElement.scrollTop;
    32.     }}
    33.     catch(e) {
    34.     var targetPosition = document.documentElement.scrollTop;
    35.     }
    36.     $('#navigation').animate({top: targetPosition}, 1000);
    37.     }</script>
    38. </head>
    39.  
    40. <div id="mother">
    41.     <div id="header">
    42.         <h1>
    43.         <strong>
    44.                 Computer Hardware Empfehlungen
    45.             <br/>
    46.             <br/>
    47.                 -  HOME  -
    48.         </strong>
    49.         </h1>
    50.  
    51.     </div>
    52.             <hr/>
    53.     <div id="navigation">
    54.     <ul>
    55.         <li><span id="high">Sie sind hier: <br/> · Home</span></li>
    56.     </ul>
    57.    <ul>
    58.         <li><a href="konfigurationstipps.html">→ Konfiguration&nbsp;</a></li>
    59.         <li><a href="grundlagen.html">→ Grundlagen&nbsp;</a></li>
    60.         <li><a href="grafikkarten.html">→ Grafikkarten&nbsp;</a></li>
    61.         <li><a href="sonstiges.html">→ Sonstiges&nbsp;</a></li>
    62.         <li><a href="kontakt.html">→ Kontakt&nbsp;</a></li>
    63.         <li><a href="impressum.html">→ Impressum&nbsp;</a></li>
    64.     </ul>
    65.     </div>
    66.     <div id="main">
    67. </div>
    68.     <div id="footer">
    69.         <h5>
    70. © 2011 MaCX Computer Hardware. Alle Rechte vorbehalten. Created by Marc Hoffmann and Max Hofmann.
    71.         <br/>
    72.         <br/>
    73. <img src="css-logo.jpg" align="middle" alt="CSS" width="80" height="80" border="0"/>
    74.         </h5>
    75.     </div>
    76. </div>
    77. </body>
    78. </html>
    79.  


    layout.css Quelltext:

    HTML:
    1. #header h1 {
    2.   font: 194% LuggageRound Regular;
    3.   color: black;
    4.   padding: 4px;
    5.   background: #808080;
    6.   text-align: center;
    7. }
    8.  
    9. #navigation a {
    10.   font: 100%;
    11.   text-decoration: none;
    12.   font-weight: bold;
    13.   color: black;
    14.   display: block;
    15.   padding: 3px;
    16. }
    17.  
    18. #navigation a:hover {
    19.   color: yellow;
    20.   text-decoration: underline;
    21.   text-align: right;
    22.   background-color: #FF0000;
    23. }
    24.  
    25. #navigation li {
    26.   border: 1px solid black;
    27. }
    28.  
    29. #navigation #high {
    30.   font-weight: bold;
    31.   color: yellow;
    32.   background-color: gray;
    33.   display: block;
    34.   padding: 3px;
    35. }
    36.  
    37. #navigation ul {
    38.   line-height: 1.6;
    39.   list-style-type: none;
    40. }
    41.  
    42. #navigation ul ul {
    43.   line-height: 1.4;
    44.   padding-left: 20px;
    45. }
    46.  
    47. #main h1 {
    48.   font-size: 1.3em;
    49.   font-weight: bold;
    50.   color: #333399;
    51.   padding-bottom: 14px
    52. }
    53.  
    54. #main h2 {
    55.   font-size: 1em;
    56.   line-height: 1.4;
    57.   margin-bottom: 6px
    58. }
    59.  
    60. #main p {
    61.   margin-bottom: 12px;
    62.   line-height: 1.3;
    63. }
    64.  
    65. #main .kasten {
    66.   text-align: center;
    67.   padding: 5px;
    68.   background-color: #ffff99;
    69.   border: solid 1px black;
    70.   width: 500px;
    71. }
    72.  
    73. #main .floatR130 {
    74.   float: right;
    75.   margin-left: 5px;
    76.   margin-right: 130px;
    77. }
    78.  
    79. #main ul {
    80.   margin-left: 30px;
    81.   margin-bottom: 10px;
    82.   line-height: 1.5;
    83. }
    84.  
    85. #main strong {
    86.   font-family: "Century Gothic", Verdana, Arial, Helvetica, sans-serif;
    87.   color: #000000;
    88. }
    89.  
    90. #footer h5 {
    91.   font-family: Vrinda, cursive, serif;
    92.   color: #82BBD8;
    93.   text-align: center;
    94. }
    95.  
    96. #footer {
    97.   font-family: Times;
    98.   color: #000000
    99. }
    100. #footer a:hover {
    101.   color: yellow;
    102.   text-decoration: underline;
    103.   text-align: right;
    104.   background-color: #FF0000;

    struktur.css Quelltext:

    HTML:
    1. * {
    2.   padding: 0;
    3.   margin: 0;
    4. }
    5.  
    6. body  {
    7.   font: 100% Verdana, Tahoma, Helvetica;
    8.   background-color: #00FFFF;
    9.   margin-top: 10px;
    10.   text-align: center;
    11. }
    12.  
    13. #mother {
    14.   width: 800px;
    15.   text-align: left;
    16.   background-color: #808080;
    17.   margin: 0 auto;
    18.   border: 5px solid yellow;
    19. }
    20.  
    21. #header {
    22.   height: 120px;
    23.   background-color: #808080;
    24.   text-align: center;
    25.   text-decoration: underline;
    26. }
    27.  
    28. #navigation {
    29.   position: fixed;
    30.   float: left;
    31.   width: 190px;
    32.   background-color: #808080;
    33.   padding: 42px 0px;
    34.   text-decoration: blink;
    35. }
    36.  
    37. #main {
    38.   background-color: #808080;
    39.   padding: 40px 10px;
    40.   margin: 0 0 0 200px;
    41.   text-align: left;
    42. }
    43.  
    44. #footer {
    45.   clear: both;
    46.   height: 120px;
    47.   padding: 20px 10px;
    48.   background-color: #000000;
    49.   margin: 0 auto;
    50. }

    jquery-1.3.1.js Quelltext:

    HTML:
    1. /*!
    2.  * jQuery JavaScript Library v1.3.1
    3.  * http://jquery.com/
    4.  *
    5.  * Copyright (c) 2009 John Resig
    6.  * Dual licensed under the MIT and GPL licenses.
    7.  * http://docs.jquery.com/License
    8.  *
    9.  * Date: 2009-01-21 20:42:16 -0500 (Wed, 21 Jan 2009)
    10.  * Revision: 6158
    11.  */
    12. (function(){
    13.  
    14. var
    15.     // Will speed up references to window, and allows munging its name.
    16.     window = this,
    17.     // Will speed up references to undefined, and allows munging its name.
    18.     undefined,
    19.     // Map over jQuery in case of overwrite
    20.     _jQuery = window.jQuery,
    21.     // Map over the $ in case of overwrite
    22.     _$ = window.$,
    23.  
    24.     jQuery = window.jQuery = window.$ = function( selector, context ) {
    25.         // The jQuery object is actually just the init constructor 'enhanced'
    26.         return new jQuery.fn.init( selector, context );
    27.     },
    28.  
    29.     // A simple way to check for HTML strings or ID strings
    30.     // (both of which we optimize for)
    31.     quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
    32.     // Is it a simple selector
    33.     isSimple = /^.[^:#\[\.,]*$/;
    34.  
    35. jQuery.fn = jQuery.prototype = {
    36.     init: function( selector, context ) {
    37.         // Make sure that a selection was provided
    38.         selector = selector || document;
    39.  
    40.         // Handle $(DOMElement)
    41.         if ( selector.nodeType ) {
    42.             this[0] = selector;
    43.             this.length = 1;
    44.             this.context = selector;
    45.             return this;
    46.         }
    47.         // Handle HTML strings
    48.         if ( typeof selector === "string" ) {
    49.             // Are we dealing with HTML string or an ID?
    50.             var match = quickExpr.exec( selector );
    51.  
    52.             // Verify a match, and that no context was specified for #id
    53.             if ( match && (match[1] || !context) ) {
    54.  
    55.                 // HANDLE: $(html) -> $(array)
    56.                 if ( match[1] )
    57.                     selector = jQuery.clean( [ match[1] ], context );
    58.  
    59.                 // HANDLE: $("#id")
    60.                 else {
    61.                     var elem = document.getElementById( match[3] );
    62.  
    63.                     // Handle the case where IE and Opera return items
    64.                     // by name instead of ID
    65.                     if ( elem && elem.id != match[3] )
    66.                         return jQuery().find( selector );
    67.  
    68.                     // Otherwise, we inject the element directly into the jQuery object
    69.                     var ret = jQuery( elem || [] );
    70.                     ret.context = document;
    71.                     ret.selector = selector;
    72.                     return ret;
    73.                 }
    74.  
    75.             // HANDLE: $(expr, [context])
    76.             // (which is just equivalent to: $(content).find(expr)
    77.             } else
    78.                 return jQuery( context ).find( selector );
    79.  
    80.         // HANDLE: $(function)
    81.         // Shortcut for document ready
    82.         } else if ( jQuery.isFunction( selector ) )
    83.             return jQuery( document ).ready( selector );
    84.  
    85.         // Make sure that old selector state is passed along
    86.         if ( selector.selector && selector.context ) {
    87.             this.selector = selector.selector;
    88.             this.context = selector.context;
    89.         }
    90.  
    91.         return this.setArray(jQuery.makeArray(selector));
    92.     },
    93.  
    94.     // Start with an empty selector
    95.     selector: "",
    96.  
    97.     // The current version of jQuery being used
    98.     jquery: "1.3.1",
    99.  
    100.     // The number of elements contained in the matched element set
    101.     size: function() {
    102.         return this.length;
    103.     },
    104.  
    105.     // Get the Nth element in the matched element set OR
    106.     // Get the whole matched element set as a clean array
    107.     get: function( num ) {
    108.         return num === undefined ?
    109.  
    110.             // Return a 'clean' array
    111.             jQuery.makeArray( this ) :
    112.  
    113.             // Return just the object
    114.             this[ num ];
    115.     },
    116.  
    117.     // Take an array of elements and push it onto the stack
    118.     // (returning the new matched element set)
    119.     pushStack: function( elems, name, selector ) {
    120.         // Build a new jQuery matched element set
    121.         var ret = jQuery( elems );
    122.  
    123.         // Add the old object onto the stack (as a reference)
    124.         ret.prevObject = this;
    125.  
    126.         ret.context = this.context;
    127.  
    128.         if ( name === "find" )
    129.             ret.selector = this.selector + (this.selector ? " " : "") + selector;
    130.         else if ( name )
    131.             ret.selector = this.selector + "." + name + "(" + selector + ")";
    132.  
    133.         // Return the newly-formed element set
    134.         return ret;
    135.     },
    136.  
    137.     // Force the current matched set of elements to become
    138.     // the specified array of elements (destroying the stack in the process)
    139.     // You should use pushStack() in order to do this, but maintain the stack
    140.     setArray: function( elems ) {
    141.         // Resetting the length to 0, then using the native Array push
    142.         // is a super-fast way to populate an object with array-like properties
    143.         this.length = 0;
    144.         Array.prototype.push.apply( this, elems );
    145.  
    146.         return this;
    147.     },
    148.  
    149.     // Execute a callback for every element in the matched set.
    150.     // (You can seed the arguments with an array of args, but this is
    151.     // only used internally.)
    152.     each: function( callback, args ) {
    153.         return jQuery.each( this, callback, args );
    154.     },
    155.  
    156.     // Determine the position of an element within
    157.     // the matched set of elements
    158.     index: function( elem ) {
    159.         // Locate the position of the desired element
    160.         return jQuery.inArray(
    161.             // If it receives a jQuery object, the first element is used
    162.             elem && elem.jquery ? elem[0] : elem
    163.         , this );
    164.     },
    165.  
    166.     attr: function( name, value, type ) {
    167.         var options = name;
    168.  
    169.         // Look for the case where we're accessing a style value
    170.         if ( typeof name === "string" )
    171.             if ( value === undefined )
    172.                 return this[0] && jQuery[ type || "attr" ]( this[0], name );
    173.  
    174.             else {
    175.                 options = {};
    176.                 options[ name ] = value;
    177.             }
    178.  
    179.         // Check to see if we're setting style values
    180.         return this.each(function(i){
    181.             // Set all the styles
    182.             for ( name in options )
    183.                 jQuery.attr(
    184.                     type ?
    185.                         this.style :
    186.                         this,
    187.                     name, jQuery.prop( this, options[ name ], type, i, name )
    188.                 );
    189.         });
    190.     },
    191.  
    192.     css: function( key, value ) {
    193.         // ignore negative width and height values
    194.         if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
    195.             value = undefined;
    196.         return this.attr( key, value, "curCSS" );
    197.     },
    198.  
    199.     text: function( text ) {
    200.         if ( typeof text !== "object" && text != null )
    201.             return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
    202.  
    203.         var ret = "";
    204.  
    205.         jQuery.each( text || this, function(){
    206.             jQuery.each( this.childNodes, function(){
    207.                 if ( this.nodeType != 8 )
    208.                     ret += this.nodeType != 1 ?
    209.                         this.nodeValue :
    210.                         jQuery.fn.text( [ this ] );
    211.             });
    212.         });
    213.  
    214.         return ret;
    215.     },
    216.  
    217.     wrapAll: function( html ) {
    218.         if ( this[0] ) {
    219.             // The elements to wrap the target around
    220.             var wrap = jQuery( html, this[0].ownerDocument ).*****();
    221.  
    222.             if ( this[0].parentNode )
    223.                 wrap.insertBefore( this[0] );
    224.  
    225.             wrap.map(function(){
    226.                 var elem = this;
    227.  
    228.                 while ( elem.firstChild )
    229.                     elem = elem.firstChild;
    230.  
    231.                 return elem;
    232.             }).append(this);
    233.         }
    234.  
    235.         return this;
    236.     },
    237.  
    238.     wrapInner: function( html ) {
    239.         return this.each(function(){
    240.             jQuery( this ).contents().wrapAll( html );
    241.         });
    242.     },
    243.  
    244.     wrap: function( html ) {
    245.         return this.each(function(){
    246.             jQuery( this ).wrapAll( html );
    247.         });
    248.     },
    249.  
    250.     append: function() {
    251.         return this.domManip(arguments, true, function(elem){
    252.             if (this.nodeType == 1)
    253.                 this.appendChild( elem );
    254.         });
    255.     },
    256.  
    257.     prepend: function() {
    258.         return this.domManip(arguments, true, function(elem){
    259.             if (this.nodeType == 1)
    260.                 this.insertBefore( elem, this.firstChild );
    261.         });
    262.     },
    263.  
    264.     before: function() {
    265.         return this.domManip(arguments, false, function(elem){
    266.             this.parentNode.insertBefore( elem, this );
    267.         });
    268.     },
    269.  
    270.     after: function() {
    271.         return this.domManip(arguments, false, function(elem){
    272.             this.parentNode.insertBefore( elem, this.nextSibling );
    273.         });
    274.     },
    275.  
    276.     end: function() {
    277.         return this.prevObject || jQuery( [] );
    278.     },
    279.  
    280.     // For internal use only.
    281.     // Behaves like an Array's .push method, not like a jQuery method.
    282.     push: [].push,
    283.  
    284.     find: function( selector ) {
    285.         if ( this.length === 1 && !/,/.test(selector) ) {
    286.             var ret = this.pushStack( [], "find", selector );
    287.             ret.length = 0;
    288.             jQuery.find( selector, this[0], ret );
    289.             return ret;
    290.         } else {
    291.             var elems = jQuery.map(this, function(elem){
    292.                 return jQuery.find( selector, elem );
    293.             });
    294.  
    295.             return this.pushStack( /[^+>] [^+>]/.test( selector ) ?
    296.                 jQuery.unique( elems ) :
    297.                 elems, "find", selector );
    298.         }
    299.     },
    300.  
    301.     *****: function( events ) {
    302.         // Do the *****
    303.         var ret = this.map(function(){
    304.             if ( !jQuery.support.no*****Event && !jQuery.isXMLDoc(this) ) {
    305.                 // IE copies events bound via attachEvent when
    306.                 // using *****Node. Calling detachEvent on the
    307.                 // ***** will also remove the events from the orignal
    308.                 // In order to get around this, we use innerHTML.
    309.                 // Unfortunately, this means some modifications to
    310.                 // attributes in IE that are actually only stored
    311.                 // as properties will not be copied (such as the
    312.                 // the name attribute on an input).
    313.                 var ***** = this.*****Node(true),
    314.                     container = document.createElement("div");
    315.                 container.appendChild(*****);
    316.                 return jQuery.clean([container.innerHTML])[0];
    317.             } else
    318.                 return this.*****Node(true);
    319.         });
    320.  
    321.         // Need to set the expando to null on the *****d set if it exists
    322.         // removeData doesn't work here, IE removes it from the original as well
    323.         // this is primarily for IE but the data expando shouldn't be copied over in any browser
    324.         var ***** = ret.find("*").andSelf().each(function(){
    325.             if ( this[ expando ] !== undefined )
    326.                 this[ expando ] = null;
    327.         });
    328.  
    329.         // Copy the events from the original to the *****
    330.         if ( events === true )
    331.             this.find("*").andSelf().each(function(i){
    332.                 if (this.nodeType == 3)
    333.                     return;
    334.                 var events = jQuery.data( this, "events" );
    335.  
    336.                 for ( var type in events )
    337.                     for ( var handler in events[ type ] )
    338.                         jQuery.event.add( *****[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
    339.             });
    340.  
    341.         // Return the *****d set
    342.         return ret;
    343.     },
    344.  
    345.     filter: function( selector ) {
    346.         return this.pushStack(
    347.             jQuery.isFunction( selector ) &&
    348.             jQuery.grep(this, function(elem, i){
    349.                 return selector.call( elem, i );
    350.             }) ||
    351.  
    352.             jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
    353.                 return elem.nodeType === 1;
    354.             }) ), "filter", selector );
    355.     },
    356.  
    357.     closest: function( selector ) {
    358.         var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null;
    359.  
    360.         return this.map(function(){
    361.             var cur = this;
    362.             while ( cur && cur.ownerDocument ) {
    363.                 if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) )
    364.                     return cur;
    365.                 cur = cur.parentNode;
    366.             }
    367.         });
    368.     },
    369.  
    370.     not: function( selector ) {
    371.         if ( typeof selector === "string" )
    372.             // test special case where just one selector is passed in
    373.             if ( isSimple.test( selector ) )
    374.                 return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
    375.             else
    376.                 selector = jQuery.multiFilter( selector, this );
    377.  
    378.         var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
    379.         return this.filter(function() {
    380.             return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
    381.         });
    382.     },
    383.  
    384.     add: function( selector ) {
    385.         return this.pushStack( jQuery.unique( jQuery.merge(
    386.             this.get(),
    387.             typeof selector === "string" ?
    388.                 jQuery( selector ) :
    389.                 jQuery.makeArray( selector )
    390.         )));
    391.     },
    392.  
    393.     is: function( selector ) {
    394.         return !!selector && jQuery.multiFilter( selector, this ).length > 0;
    395.     },
    396.  
    397.     hasClass: function( selector ) {
    398.         return !!selector && this.is( "." + selector );
    399.     },
    400.  
    401.     val: function( value ) {
    402.         if ( value === undefined ) {
    403.             var elem = this[0];
    404.  
    405.             if ( elem ) {
    406.                 if( jQuery.nodeName( elem, 'option' ) )
    407.                     return (elem.attributes.value || {}).specified ? elem.value : elem.text;
    408.  
    409.                 // We need to handle select boxes special
    410.                 if ( jQuery.nodeName( elem, "select" ) ) {
    411.                     var index = elem.selectedIndex,
    412.                         values = [],
    413.                         options = elem.options,
    414.                         one = elem.type == "select-one";
    415.  
    416.                     // Nothing was selected
    417.                     if ( index < 0 )
    418.                         return null;
    419.  
    420.                     // Loop through all the selected options
    421.                     for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
    422.                         var option = options[ i ];
    423.  
    424.                         if ( option.selected ) {
    425.                             // Get the specifc value for the option
    426.                             value = jQuery(option).val();
    427.  
    428.                             // We don't need an array for one selects
    429.                             if ( one )
    430.                                 return value;
    431.                             // Multi-Selects return an array
    432.                             values.push( value );
    433.                         }
    434.                     }
    435.                     return values;
    436.                 }
    437.                 // Everything else, we just grab the value
    438.                 return (elem.value || "").replace(/\r/g, "");
    439.             }
    440.             return undefined;
    441.         }
    442.         if ( typeof value === "number" )
    443.             value += '';
    444.         return this.each(function(){
    445.             if ( this.nodeType != 1 )
    446.                 return;
    447.             if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
    448.                 this.checked = (jQuery.inArray(this.value, value) >= 0 ||
    449.                     jQuery.inArray(this.name, value) >= 0);
    450.  
    451.             else if ( jQuery.nodeName( this, "select" ) ) {
    452.                 var values = jQuery.makeArray(value);
    453.  
    454.                 jQuery( "option", this ).each(function(){
    455.                     this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
    456.                         jQuery.inArray( this.text, values ) >= 0);
    457.                 });
    458.  
    459.                 if ( !values.length )
    460.                     this.selectedIndex = -1;
    461.  
    462.             } else
    463.                 this.value = value;
    464.         });
    465.     },
    466.  
    467.     html: function( value ) {
    468.         return value === undefined ?
    469.             (this[0] ?
    470.                 this[0].innerHTML :
    471.                 null) :
    472.             this.empty().append( value );
    473.     },
    474.  
    475.     replaceWith: function( value ) {
    476.         return this.after( value ).remove();
    477.     },
    478.  
    479.     eq: function( i ) {
    480.         return this.slice( i, +i + 1 );
    481.     },
    482.  
    483.     slice: function() {
    484.         return this.pushStack( Array.prototype.slice.apply( this, arguments ),
    485.             "slice", Array.prototype.slice.call(arguments).join(",") );
    486.     },
    487.  
    488.     map: function( callback ) {
    489.         return this.pushStack( jQuery.map(this, function(elem, i){
    490.             return callback.call( elem, i, elem );
    491.         }));
    492.     },
    493.  
    494.     andSelf: function() {
    495.         return this.add( this.prevObject );
    496.     },
    497.  
    498.     domManip: function( args, table, callback ) {
    499.         if ( this[0] ) {
    500.             var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
    501.                 scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
    502.                 first = fragment.firstChild,
    503.                 extra = this.length > 1 ? fragment.*****Node(true) : fragment;
    504.  
    505.             if ( first )
    506.                 for ( var i = 0, l = this.length; i < l; i++ )
    507.                     callback.call( root(this[i], first), i > 0 ? extra.*****Node(true) : fragment );
    508.  
    509.             if ( scripts )
    510.                 jQuery.each( scripts, evalScript );
    511.         }
    512.  
    513.         return this;
    514.  
    515.         function root( elem, cur ) {
    516.             return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
    517.                 (elem.getElementsByTagName("tbody")[0] ||
    518.                 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
    519.                 elem;
    520.         }
    521.     }
    522. };
    523.  
    524. // Give the init function the jQuery prototype for later instantiation
    525. jQuery.fn.init.prototype = jQuery.fn;
    526.  
    527. function evalScript( i, elem ) {
    528.     if ( elem.src )
    529.         jQuery.ajax({
    530.             url: elem.src,
    531.             async: false,
    532.             dataType: "script"
    533.         });
    534.  
    535.     else
    536.         jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
    537.  
    538.     if ( elem.parentNode )
    539.         elem.parentNode.removeChild( elem );
    540. }
    541.  
    542. function now(){
    543.     return +new Date;
    544. }
    545.  
    546. jQuery.extend = jQuery.fn.extend = function() {
    547.     // copy reference to target object
    548.     var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
    549.  
    550.     // Handle a deep copy situation
    551.     if ( typeof target === "boolean" ) {
    552.         deep = target;
    553.         target = arguments[1] || {};
    554.         // skip the boolean and the target
    555.         i = 2;
    556.     }
    557.  
    558.     // Handle case when target is a string or something (possible in deep copy)
    559.     if ( typeof target !== "object" && !jQuery.isFunction(target) )
    560.         target = {};
    561.  
    562.     // extend jQuery itself if only one argument is passed
    563.     if ( length == i ) {
    564.         target = this;
    565.         --i;
    566.     }
    567.  
    568.     for ( ; i < length; i++ )
    569.         // Only deal with non-null/undefined values
    570.         if ( (options = arguments[ i ]) != null )
    571.             // Extend the base object
    572.             for ( var name in options ) {
    573.                 var src = target[ name ], copy = options[ name ];
    574.  
    575.                 // Prevent never-ending loop
    576.                 if ( target === copy )
    577.                     continue;
    578.  
    579.                 // Recurse if we're merging object values
    580.                 if ( deep && copy && typeof copy === "object" && !copy.nodeType )
    581.                     target[ name ] = jQuery.extend( deep,
    582.                         // Never move original objects, ***** them
    583.                         src || ( copy.length != null ? [ ] : { } )
    584.                     , copy );
    585.                 // Don't bring in undefined values
    586.                 else if ( copy !== undefined )
    587.                     target[ name ] = copy;
    588.  
    589.             }
    590.  
    591.     // Return the modified object
    592.     return target;
    593. };
    594.  
    595. // exclude the following css properties to add px
    596. var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
    597.     // cache defaultView
    598.     defaultView = document.defaultView || {},
    599.     toString = Object.prototype.toString;
    600.  
    601. jQuery.extend({
    602.     noConflict: function( deep ) {
    603.         window.$ = _$;
    604.  
    605.         if ( deep )
    606.             window.jQuery = _jQuery;
    607.  
    608.         return jQuery;
    609.     },
    610.  
    611.     // See test/unit/core.js for details concerning isFunction.
    612.     // Since version 1.3, DOM methods and functions like alert
    613.     // aren't supported. They return false on IE (#2968).
    614.     isFunction: function( obj ) {
    615.         return toString.call(obj) === "[object Function]";
    616.     },
    617.     isArray: function( obj ) {
    618.         return toString.call(obj) === "[object Array]";
    619.     },
    620.     // check if an element is in a (or is an) XML document
    621.     isXMLDoc: function( elem ) {
    622.         return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
    623.             !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
    624.     },
    625.     // Evalulates a script in a global context
    626.     globalEval: function( data ) {
    627.         data = jQuery.trim( data );
    628.         if ( data ) {
    629.             // Inspired by code by Andrea Giammarchi
    630.             // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
    631.             var head = document.getElementsByTagName("head")[0] || document.documentElement,
    632.                 script = document.createElement("script");
    633.             script.type = "text/javascript";
    634.             if ( jQuery.support.scriptEval )
    635.                 script.appendChild( document.createTextNode( data ) );
    636.             else
    637.                 script.text = data;
    638.             // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
    639.             // This arises when a base node is used (#2709).
    640.             head.insertBefore( script, head.firstChild );
    641.             head.removeChild( script );
    642.         }
    643.     },
    644.     nodeName: function( elem, name ) {
    645.         return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
    646.     },
    647.     // args is for internal usage only
    648.     each: function( object, callback, args ) {
    649.         var name, i = 0, length = object.length;
    650.         if ( args ) {
    651.             if ( length === undefined ) {
    652.                 for ( name in object )
    653.                     if ( callback.apply( object[ name ], args ) === false )
    654.                         break;
    655.             } else
    656.                 for ( ; i < length; )
    657.                     if ( callback.apply( object[ i++ ], args ) === false )
    658.                         break;
    659.         // A special, fast, case for the most common use of each
    660.         } else {
    661.             if ( length === undefined ) {
    662.                 for ( name in object )
    663.                     if ( callback.call( object[ name ], name, object[ name ] ) === false )
    664.                         break;
    665.             } else
    666.                 for ( var value = object[0];
    667.                     i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
    668.         }
    669.         return object;
    670.     },
    671.     prop: function( elem, value, type, i, name ) {
    672.         // Handle executable functions
    673.         if ( jQuery.isFunction( value ) )
    674.             value = value.call( elem, i );
    675.         // Handle passing in a number to a CSS property
    676.         return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
    677.             value + "px" :
    678.             value;
    679.     },
    680.     className: {
    681.         // internal only, use addClass("class")
    682.         add: function( elem, classNames ) {
    683.             jQuery.each((classNames || "").split(/\s+/), function(i, className){
    684.                 if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
    685.                     elem.className += (elem.className ? " " : "") + className;
    686.             });
    687.         },
    688.         // internal only, use removeClass("class")
    689.         remove: function( elem, classNames ) {
    690.             if (elem.nodeType == 1)
    691.                 elem.className = classNames !== undefined ?
    692.                     jQuery.grep(elem.className.split(/\s+/), function(className){
    693.                         return !jQuery.className.has( classNames, className );
    694.                     }).join(" ") :
    695.                     "";
    696.         },
    697.         // internal only, use hasClass("class")
    698.         has: function( elem, className ) {
    699.             return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
    700.         }
    701.     },
    702.  
    703.     // A method for quickly swapping in/out CSS properties to get correct calculations
    704.     swap: function( elem, options, callback ) {
    705.         var old = {};
    706.         // Remember the old values, and insert the new ones
    707.         for ( var name in options ) {
    708.             old[ name ] = elem.style[ name ];
    709.             elem.style[ name ] = options[ name ];
    710.         }
    711.  
    712.         callback.call( elem );
    713.  
    714.         // Revert the old values
    715.         for ( var name in options )
    716.             elem.style[ name ] = old[ name ];
    717.     },
    718.  
    719.     css: function( elem, name, force ) {
    720.         if ( name == "width" || name == "height" ) {
    721.             var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
    722.  
    723.             function getWH() {
    724.                 val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
    725.                 var padding = 0, border = 0;
    726.                 jQuery.each( which, function() {
    727.                     padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
    728.                     border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
    729.                 });
    730.                 val -= Math.round(padding + border);
    731.             }
    732.  
    733.             if ( jQuery(elem).is(":visible") )
    734.                 getWH();
    735.             else
    736.                 jQuery.swap( elem, props, getWH );
    737.  
    738.             return Math.max(0, val);
    739.         }
    740.  
    741.         return jQuery.curCSS( elem, name, force );
    742.     },
    743.  
    744.     curCSS: function( elem, name, force ) {
    745.         var ret, style = elem.style;
    746.  
    747.         // We need to handle opacity special in IE
    748.         if ( name == "opacity" && !jQuery.support.opacity ) {
    749.             ret = jQuery.attr( style, "opacity" );
    750.  
    751.             return ret == "" ?
    752.                 "1" :
    753.                 ret;
    754.         }
    755.  
    756.         // Make sure we're using the right name for getting the float value
    757.         if ( name.match( /float/i ) )
    758.             name = styleFloat;
    759.  
    760.         if ( !force && style && style[ name ] )
    761.             ret = style[ name ];
    762.  
    763.         else if ( defaultView.getComputedStyle ) {
    764.  
    765.             // Only "float" is needed here
    766.             if ( name.match( /float/i ) )
    767.                 name = "float";
    768.  
    769.             name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
    770.  
    771.             var computedStyle = defaultView.getComputedStyle( elem, null );
    772.  
    773.             if ( computedStyle )
    774.                 ret = computedStyle.getPropertyValue( name );
    775.  
    776.             // We should always get a number back from opacity
    777.             if ( name == "opacity" && ret == "" )
    778.                 ret = "1";
    779.  
    780.         } else if ( elem.currentStyle ) {
    781.             var camelCase = name.replace(/\-(\w)/g, function(all, letter){
    782.                 return letter.toUpperCase();
    783.             });
    784.  
    785.             ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
    786.  
    787.             // From the awesome hack by Dean Edwards
    788.             // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
    789.  
    790.             // If we're not dealing with a regular pixel number
    791.             // but a number that has a weird ending, we need to convert it to pixels
    792.             if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
    793.                 // Remember the original values
    794.                 var left = style.left, rsLeft = elem.runtimeStyle.left;
    795.  
    796.                 // Put in the new values to get a computed value out
    797.                 elem.runtimeStyle.left = elem.currentStyle.left;
    798.                 style.left = ret || 0;
    799.                 ret = style.pixelLeft + "px";
    800.  
    801.                 // Revert the changed values
    802.                 style.left = left;
    803.                 elem.runtimeStyle.left = rsLeft;
    804.             }
    805.         }
    806.  
    807.         return ret;
    808.     },
    809.  
    810.     clean: function( elems, context, fragment ) {
    811.         context = context || document;
    812.  
    813.         // !context.createElement fails in IE with an error but returns typeof 'object'
    814.         if ( typeof context.createElement === "undefined" )
    815.             context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
    816.  
    817.         // If a single string is passed in and it's a single tag
    818.         // just do a createElement and skip the rest
    819.         if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
    820.             var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
    821.             if ( match )
    822.                 return [ context.createElement( match[1] ) ];
    823.         }
    824.  
    825.         var ret = [], scripts = [], div = context.createElement("div");
    826.  
    827.         jQuery.each(elems, function(i, elem){
    828.             if ( typeof elem === "number" )
    829.                 elem += '';
    830.  
    831.             if ( !elem )
    832.                 return;
    833.  
    834.             // Convert html string into DOM nodes
    835.             if ( typeof elem === "string" ) {
    836.                 // Fix "XHTML"-style tags in all browsers
    837.                 elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
    838.                     return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
    839.                         all :
    840.                         front + "></" + tag + ">";
    841.                 });
    842.  
    843.                 // Trim whitespace, otherwise indexOf won't work as expected
    844.                 var tags = jQuery.trim( elem ).toLowerCase();
    845.  
    846.                 var wrap =
    847.                     // option or optgroup
    848.                     !tags.indexOf("<opt") &&
    849.                     [ 1, "<select multiple='multiple'>", "</select>" ] ||
    850.  
    851.                     !tags.indexOf("<leg") &&
    852.                     [ 1, "<fieldset>", "</fieldset>" ] ||
    853.  
    854.                     tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
    855.                     [ 1, "<table>", "</table>" ] ||
    856.  
    857.                     !tags.indexOf("<tr") &&
    858.                     [ 2, "<table><tbody>", "</tbody></table>" ] ||
    859.  
    860.                     // <thead> matched above
    861.                     (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
    862.                     [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
    863.  
    864.                     !tags.indexOf("<col") &&
    865.                     [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
    866.  
    867.                     // IE can't serialize <link> and <script> tags normally
    868.                     !jQuery.support.htmlSerialize &&
    869.                     [ 1, "div<div>", "</div>" ] ||
    870.  
    871.                     [ 0, "", "" ];
    872.  
    873.                 // Go to html and back, then peel off extra wrappers
    874.                 div.innerHTML = wrap[1] + elem + wrap[2];
    875.  
    876.                 // Move to the right depth
    877.                 while ( wrap[0]-- )
    878.                     div = div.lastChild;
    879.  
    880.                 // Remove IE's autoinserted <tbody> from table fragments
    881.                 if ( !jQuery.support.tbody ) {
    882.  
    883.                     // String was a <table>, *may* have spurious <tbody>
    884.                     var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
    885.                         div.firstChild && div.firstChild.childNodes :
    886.                         // String was a bare <thead> or <tfoot>
    887.                         wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
    888.                             div.childNodes :
    889.                             [];
    890.  
    891.                     for ( var j = tbody.length - 1; j >= 0 ; --j )
    892.                         if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
    893.                             tbody[ j ].parentNode.removeChild( tbody[ j ] );
    894.  
    895.                     }
    896.  
    897.                 // IE completely kills leading whitespace when innerHTML is used
    898.                 if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
    899.                     div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
    900.  
    901.                 elem = jQuery.makeArray( div.childNodes );
    902.             }
    903.  
    904.             if ( elem.nodeType )
    905.                 ret.push( elem );
    906.             else
    907.                 ret = jQuery.merge( ret, elem );
    908.  
    909.         });
    910.  
    911.         if ( fragment ) {
    912.             for ( var i = 0; ret[i]; i++ ) {
    913.                 if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
    914.                     scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
    915.                 } else {
    916.                     if ( ret[i].nodeType === 1 )
    917.                         ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
    918.                     fragment.appendChild( ret[i] );
    919.                 }
    920.             }
    921.  
    922.             return scripts;
    923.         }
    924.  
    925.         return ret;
    926.     },
    927.  
    928.     attr: function( elem, name, value ) {
    929.         // don't set attributes on text and comment nodes
    930.         if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
    931.             return undefined;
    932.  
    933.         var notxml = !jQuery.isXMLDoc( elem ),
    934.             // Whether we are setting (or getting)
    935.             set = value !== undefined;
    936.  
    937.         // Try to normalize/fix the name
    938.         name = notxml && jQuery.props[ name ] || name;
    939.  
    940.         // Only do all the following if this is a node (faster for style)
    941.         // IE elem.getAttribute passes even for style
    942.         if ( elem.tagName ) {
    943.  
    944.             // These attributes require special treatment
    945.             var special = /href|src|style/.test( name );
    946.  
    947.             // Safari mis-reports the default selected property of a hidden option
    948.             // Accessing the parent's selectedIndex property fixes it
    949.             if ( name == "selected" && elem.parentNode )
    950.                 elem.parentNode.selectedIndex;
    951.  
    952.             // If applicable, access the attribute via the DOM 0 way
    953.             if ( name in elem && notxml && !special ) {
    954.                 if ( set ){
    955.                     // We can't allow the type property to be changed (since it causes problems in IE)
    956.                     if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
    957.                         throw "type property can't be changed";
    958.  
    959.                     elem[ name ] = value;
    960.                 }
    961.  
    962.                 // browsers index elements by id/name on forms, give priority to attributes.
    963.                 if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
    964.                     return elem.getAttributeNode( name ).nodeValue;
    965.  
    966.                 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
    967.                 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
    968.                 if ( name == "tabIndex" ) {
    969.                     var attributeNode = elem.getAttributeNode( "tabIndex" );
    970.                     return attributeNode && attributeNode.specified
    971.                         ? attributeNode.value
    972.                         : elem.nodeName.match(/(button|input|object|select|textarea)/i)
    973.                             ? 0
    974.                             : elem.nodeName.match(/^(a|area)$/i) && elem.href
    975.                                 ? 0
    976.                                 : undefined;
    977.                 }
    978.  
    979.                 return elem[ name ];
    980.             }
    981.  
    982.             if ( !jQuery.support.style && notxml &&  name == "style" )
    983.                 return jQuery.attr( elem.style, "cssText", value );
    984.  
    985.             if ( set )
    986.                 // convert the value to a string (all browsers do this but IE) see #1070
    987.                 elem.setAttribute( name, "" + value );
    988.  
    989.             var attr = !jQuery.support.hrefNormalized && notxml && special
    990.                     // Some attributes require a special call on IE
    991.                     ? elem.getAttribute( name, 2 )
    992.                     : elem.getAttribute( name );
    993.  
    994.             // Non-existent attributes return null, we normalize to undefined
    995.             return attr === null ? undefined : attr;
    996.         }
    997.  
    998.         // elem is actually elem.style ... set the style
    999.  
    1000.         // IE uses filters for opacity
    1001.         if ( !jQuery.support.opacity && name == "opacity" ) {
    1002.             if ( set ) {
    1003.                 // IE has trouble with opacity if it does not have layout
    1004.                 // Force it by setting the zoom level
    1005.                 elem.zoom = 1;
    1006.  
    1007.                 // Set the alpha filter to set the opacity
    1008.                 elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
    1009.                     (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
    1010.             }
    1011.  
    1012.             return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
    1013.                 (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
    1014.                 "";
    1015.         }
    1016.  
    1017.         name = name.replace(/-([a-z])/ig, function(all, letter){
    1018.             return letter.toUpperCase();
    1019.         });
    1020.  
    1021.         if ( set )
    1022.             elem[ name ] = value;
    1023.  
    1024.         return elem[ name ];
    1025.     },
    1026.  
    1027.     trim: function( text ) {
    1028.         return (text || "").replace( /^\s+|\s+$/g, "" );
    1029.     },
    1030.  
    1031.     makeArray: function( array ) {
    1032.         var ret = [];
    1033.  
    1034.         if( array != null ){
    1035.             var i = array.length;
    1036.             // The window, strings (and functions) also have 'length'
    1037.             if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
    1038.                 ret[0] = array;
    1039.             else
    1040.                 while( i )
    1041.                     ret[--i] = array[i];
    1042.         }
    1043.  
    1044.         return ret;
    1045.     },
    1046.  
    1047.     inArray: function( elem, array ) {
    1048.         for ( var i = 0, length = array.length; i < length; i++ )
    1049.         // Use === because on IE, window == document
    1050.             if ( array[ i ] === elem )
    1051.                 return i;
    1052.  
    1053.         return -1;
    1054.     },
    1055.  
    1056.     merge: function( first, second ) {
    1057.         // We have to loop this way because IE & Opera overwrite the length
    1058.         // expando of getElementsByTagName
    1059.         var i = 0, elem, pos = first.length;
    1060.         // Also, we need to make sure that the correct elements are being returned
    1061.         // (IE returns comment nodes in a '*' query)
    1062.         if ( !jQuery.support.getAll ) {
    1063.             while ( (elem = second[ i++ ]) != null )
    1064.                 if ( elem.nodeType != 8 )
    1065.                     first[ pos++ ] = elem;
    1066.  
    1067.         } else
    1068.             while ( (elem = second[ i++ ]) != null )
    1069.                 first[ pos++ ] = elem;
    1070.  
    1071.         return first;
    1072.     },
    1073.  
    1074.     unique: function( array ) {
    1075.         var ret = [], done = {};
    1076.  
    1077.         try {
    1078.  
    1079.             for ( var i = 0, length = array.length; i < length; i++ ) {
    1080.                 var id = jQuery.data( array[ i ] );
    1081.  
    1082.                 if ( !done[ id ] ) {
    1083.                     done[ id ] = true;
    1084.                     ret.push( array[ i ] );
    1085.                 }
    1086.             }
    1087.  
    1088.         } catch( e ) {
    1089.             ret = array;
    1090.         }
    1091.  
    1092.         return ret;
    1093.     },
    1094.  
    1095.     grep: function( elems, callback, inv ) {
    1096.         var ret = [];
    1097.  
    1098.         // Go through the array, only saving the items
    1099.         // that pass the validator function
    1100.         for ( var i = 0, length = elems.length; i < length; i++ )
    1101.             if ( !inv != !callback( elems[ i ], i ) )
    1102.                 ret.push( elems[ i ] );
    1103.  
    1104.         return ret;
    1105.     },
    1106.  
    1107.     map: function( elems, callback ) {
    1108.         var ret = [];
    1109.  
    1110.         // Go through the array, translating each of the items to their
    1111.         // new value (or values).
    1112.         for ( var i = 0, length = elems.length; i < length; i++ ) {
    1113.             var value = callback( elems[ i ], i );
    1114.  
    1115.             if ( value != null )
    1116.                 ret[ ret.length ] = value;
    1117.         }
    1118.  
    1119.         return ret.concat.apply( [], ret );
    1120.     }
    1121. });
    1122.  
    1123. // Use of jQuery.browser is deprecated.
    1124. // It's included for backwards compatibility and plugins,
    1125. // although they should work to migrate away.
    1126. var userAgent = navigator.userAgent.toLowerCase();
    1127. // Figure out what browser is being used
    1128. jQuery.browser = {
    1129.     version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
    1130.     safari: /webkit/.test( userAgent ),
    1131.     opera: /opera/.test( userAgent ),
    1132.     msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
    1133.     mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
    1134. };
    1135. jQuery.each({
    1136.     parent: function(elem){return elem.parentNode;},
    1137.     parents: function(elem){return jQuery.dir(elem,"parentNode");},
    1138.     next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
    1139.     prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
    1140.     nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
    1141.     prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
    1142.     siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
    1143.     children: function(elem){return jQuery.sibling(elem.firstChild);},
    1144.     contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
    1145. }, function(name, fn){
    1146.     jQuery.fn[ name ] = function( selector ) {
    1147.         var ret = jQuery.map( this, fn );
    1148.         if ( selector && typeof selector == "string" )
    1149.             ret = jQuery.multiFilter( selector, ret );
    1150.         return this.pushStack( jQuery.unique( ret ), name, selector );
    1151.     };
    1152. });
    1153. jQuery.each({
    1154.     appendTo: "append",
    1155.     prependTo: "prepend",
    1156.     insertBefore: "before",
    1157.     insertAfter: "after",
    1158.     replaceAll: "replaceWith"
    1159. }, function(name, original){
    1160.     jQuery.fn[ name ] = function() {
    1161.         var args = arguments;
    1162.         return this.each(function(){
    1163.             for ( var i = 0, length = args.length; i < length; i++ )
    1164.                 jQuery( args[ i ] )[ original ]( this );
    1165.         });
    1166.     };
    1167. });
    1168. jQuery.each({
    1169.     removeAttr: function( name ) {
    1170.         jQuery.attr( this, name, "" );
    1171.         if (this.nodeType == 1)
    1172.             this.removeAttribute( name );
    1173.     },
    1174.     addClass: function( classNames ) {
    1175.         jQuery.className.add( this, classNames );
    1176.     },
    1177.     removeClass: function( classNames ) {
    1178.         jQuery.className.remove( this, classNames );
    1179.     },
    1180.     toggleClass: function( classNames, state ) {
    1181.         if( typeof state !== "boolean" )
    1182.             state = !jQuery.className.has( this, classNames );
    1183.         jQuery.className[ state ? "add" : "remove" ]( this, classNames );
    1184.     },
    1185.     remove: function( selector ) {
    1186.         if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
    1187.             // Prevent memory leaks
    1188.             jQuery( "*", this ).add([this]).each(function(){
    1189.                 jQuery.event.remove(this);
    1190.                 jQuery.removeData(this);
    1191.             });
    1192.             if (this.parentNode)
    1193.                 this.parentNode.removeChild( this );
    1194.         }
    1195.     },
    1196.     empty: function() {
    1197.         // Remove element nodes and prevent memory leaks
    1198.         jQuery( ">*", this ).remove();
    1199.  
    1200.         // Remove any remaining nodes
    1201.         while ( this.firstChild )
    1202.             this.removeChild( this.firstChild );
    1203.     }
    1204. }, function(name, fn){
    1205.     jQuery.fn[ name ] = function(){
    1206.         return this.each( fn, arguments );
    1207.     };
    1208. });
    1209.  
    1210. // Helper function used by the dimensions and offset modules
    1211. function num(elem, prop) {
    1212.     return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
    1213. }
    1214. var expando = "jQuery" + now(), uuid = 0, windowData = {};
    1215.  
    1216. jQuery.extend({
    1217.     cache: {},
    1218.  
    1219.     data: function( elem, name, data ) {
    1220.         elem = elem == window ?
    1221.             windowData :
    1222.             elem;
    1223.  
    1224.         var id = elem[ expando ];
    1225.  
    1226.         // Compute a unique ID for the element
    1227.         if ( !id )
    1228.             id = elem[ expando ] = ++uuid;
    1229.  
    1230.         // Only generate the data cache if we're
    1231.         // trying to access or manipulate it
    1232.         if ( name && !jQuery.cache[ id ] )
    1233.             jQuery.cache[ id ] = {};
    1234.  
    1235.         // Prevent overriding the named cache with undefined values
    1236.         if ( data !== undefined )
    1237.             jQuery.cache[ id ][ name ] = data;
    1238.  
    1239.         // Return the named cache data, or the ID for the element
    1240.         return name ?
    1241.             jQuery.cache[ id ][ name ] :
    1242.             id;
    1243.     },
    1244.  
    1245.     removeData: function( elem, name ) {
    1246.         elem = elem == window ?
    1247.             windowData :
    1248.             elem;
    1249.  
    1250.         var id = elem[ expando ];
    1251.  
    1252.         // If we want to remove a specific section of the element's data
    1253.         if ( name ) {
    1254.             if ( jQuery.cache[ id ] ) {
    1255.                 // Remove the section of cache data
    1256.                 delete jQuery.cache[ id ][ name ];
    1257.  
    1258.                 // If we've removed all the data, remove the element's cache
    1259.                 name = "";
    1260.  
    1261.                 for ( name in jQuery.cache[ id ] )
    1262.                     break;
    1263.  
    1264.                 if ( !name )
    1265.                     jQuery.removeData( elem );
    1266.             }
    1267.  
    1268.         // Otherwise, we want to remove all of the element's data
    1269.         } else {
    1270.             // Clean up the element expando
    1271.             try {
    1272.                 delete elem[ expando ];
    1273.             } catch(e){
    1274.                 // IE has trouble directly removing the expando
    1275.                 // but it's ok with using removeAttribute
    1276.                 if ( elem.removeAttribute )
    1277.                     elem.removeAttribute( expando );
    1278.             }
    1279.  
    1280.             // Completely remove the data cache
    1281.             delete jQuery.cache[ id ];
    1282.         }
    1283.     },
    1284.     queue: function( elem, type, data ) {
    1285.         if ( elem ){
    1286.  
    1287.             type = (type || "fx") + "queue";
    1288.  
    1289.             var q = jQuery.data( elem, type );
    1290.  
    1291.             if ( !q || jQuery.isArray(data) )
    1292.                 q = jQuery.data( elem, type, jQuery.makeArray(data) );
    1293.             else if( data )
    1294.                 q.push( data );
    1295.  
    1296.         }
    1297.         return q;
    1298.     },
    1299.  
    1300.     dequeue: function( elem, type ){
    1301.         var queue = jQuery.queue( elem, type ),
    1302.             fn = queue.shift();
    1303.  
    1304.         if( !type || type === "fx" )
    1305.             fn = queue[0];
    1306.  
    1307.         if( fn !== undefined )
    1308.             fn.call(elem);
    1309.     }
    1310. });
    1311.  
    1312. jQuery.fn.extend({
    1313.     data: function( key, value ){
    1314.         var parts = key.split(".");
    1315.         parts[1] = parts[1] ? "." + parts[1] : "";
    1316.  
    1317.         if ( value === undefined ) {
    1318.             var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
    1319.  
    1320.             if ( data === undefined && this.length )
    1321.                 data = jQuery.data( this[0], key );
    1322.  
    1323.             return data === undefined && parts[1] ?
    1324.                 this.data( parts[0] ) :
    1325.                 data;
    1326.         } else
    1327.             return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
    1328.                 jQuery.data( this, key, value );
    1329.             });
    1330.     },
    1331.  
    1332.     removeData: function( key ){
    1333.         return this.each(function(){
    1334.             jQuery.removeData( this, key );
    1335.         });
    1336.     },
    1337.     queue: function(type, data){
    1338.         if ( typeof type !== "string" ) {
    1339.             data = type;
    1340.             type = "fx";
    1341.         }
    1342.  
    1343.         if ( data === undefined )
    1344.             return jQuery.queue( this[0], type );
    1345.  
    1346.         return this.each(function(){
    1347.             var queue = jQuery.queue( this, type, data );
    1348.  
    1349.              if( type == "fx" && queue.length == 1 )
    1350.                 queue[0].call(this);
    1351.         });
    1352.     },
    1353.     dequeue: function(type){
    1354.         return this.each(function(){
    1355.             jQuery.dequeue( this, type );
    1356.         });
    1357.     }
    1358. });/*!
    1359.  * Sizzle CSS Selector Engine - v0.9.3
    1360.  *  Copyright 2009, The Dojo Foundation
    1361.  *  Released under the MIT, BSD, and GPL Licenses.
    1362.  *  More information: http://sizzlejs.com/
    1363.  */
    1364. (function(){
    1365.  
    1366. var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]+['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[]+)+|[>+~])(\s*,\s*)?/g,
    1367.     done = 0,
    1368.     toString = Object.prototype.toString;
    1369.  
    1370. var Sizzle = function(selector, context, results, seed) {
    1371.     results = results || [];
    1372.     context = context || document;
    1373.  
    1374.     if ( context.nodeType !== 1 && context.nodeType !== 9 )
    1375.         return [];
    1376.  
    1377.     if ( !selector || typeof selector !== "string" ) {
    1378.         return results;
    1379.     }
    1380.  
    1381.     var parts = [], m, set, checkSet, check, mode, extra, prune = true;
    1382.  
    1383.     // Reset the position of the chunker regexp (start from head)
    1384.     chunker.lastIndex = 0;
    1385.  
    1386.     while ( (m = chunker.exec(selector)) !== null ) {
    1387.         parts.push( m[1] );
    1388.  
    1389.         if ( m[2] ) {
    1390.             extra = RegExp.rightContext;
    1391.             break;
    1392.         }
    1393.     }
    1394.  
    1395.     if ( parts.length > 1 && origPOS.exec( selector ) ) {
    1396.         if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
    1397.             set = posProcess( parts[0] + parts[1], context );
    1398.         } else {
    1399.             set = Expr.relative[ parts[0] ] ?
    1400.                 [ context ] :
    1401.                 Sizzle( parts.shift(), context );
    1402.  
    1403.             while ( parts.length ) {
    1404.                 selector = parts.shift();
    1405.  
    1406.                 if ( Expr.relative[ selector ] )
    1407.                     selector += parts.shift();
    1408.  
    1409.                 set = posProcess( selector, set );
    1410.             }
    1411.         }
    1412.     } else {
    1413.         var ret = seed ?
    1414.             { expr: parts.pop(), set: makeArray(seed) } :
    1415.             Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
    1416.         set = Sizzle.filter( ret.expr, ret.set );
    1417.  
    1418.         if ( parts.length > 0 ) {
    1419.             checkSet = makeArray(set);
    1420.         } else {
    1421.             prune = false;
    1422.         }
    1423.  
    1424.         while ( parts.length ) {
    1425.             var cur = parts.pop(), pop = cur;
    1426.  
    1427.             if ( !Expr.relative[ cur ] ) {
    1428.                 cur = "";
    1429.             } else {
    1430.                 pop = parts.pop();
    1431.             }
    1432.  
    1433.             if ( pop == null ) {
    1434.                 pop = context;
    1435.             }
    1436.  
    1437.             Expr.relative[ cur ]( checkSet, pop, isXML(context) );
    1438.         }
    1439.     }
    1440.  
    1441.     if ( !checkSet ) {
    1442.         checkSet = set;
    1443.     }
    1444.  
    1445.     if ( !checkSet ) {
    1446.         throw "Syntax error, unrecognized expression: " + (cur || selector);
    1447.     }
    1448.  
    1449.     if ( toString.call(checkSet) === "[object Array]" ) {
    1450.         if ( !prune ) {
    1451.             results.push.apply( results, checkSet );
    1452.         } else if ( context.nodeType === 1 ) {
    1453.             for ( var i = 0; checkSet[i] != null; i++ ) {
    1454.                 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
    1455.                     results.push( set[i] );
    1456.                 }
    1457.             }
    1458.         } else {
    1459.             for ( var i = 0; checkSet[i] != null; i++ ) {
    1460.                 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
    1461.                     results.push( set[i] );
    1462.                 }
    1463.             }
    1464.         }
    1465.     } else {
    1466.         makeArray( checkSet, results );
    1467.     }
    1468.  
    1469.     if ( extra ) {
    1470.         Sizzle( extra, context, results, seed );
    1471.     }
    1472.  
    1473.     return results;
    1474. };
    1475.  
    1476. Sizzle.matches = function(expr, set){
    1477.     return Sizzle(expr, null, null, set);
    1478. };
    1479.  
    1480. Sizzle.find = function(expr, context, isXML){
    1481.     var set, match;
    1482.  
    1483.     if ( !expr ) {
    1484.         return [];
    1485.     }
    1486.  
    1487.     for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
    1488.         var type = Expr.order[i], match;
    1489.  
    1490.         if ( (match = Expr.match[ type ].exec( expr )) ) {
    1491.             var left = RegExp.leftContext;
    1492.  
    1493.             if ( left.substr( left.length - 1 ) !== "\\" ) {
    1494.                 match[1] = (match[1] || "").replace(/\\/g, "");
    1495.                 set = Expr.find[ type ]( match, context, isXML );
    1496.                 if ( set != null ) {
    1497.                     expr = expr.replace( Expr.match[ type ], "" );
    1498.                     break;
    1499.                 }
    1500.             }
    1501.         }
    1502.     }
    1503.  
    1504.     if ( !set ) {
    1505.         set = context.getElementsByTagName("*");
    1506.     }
    1507.  
    1508.     return {set: set, expr: expr};
    1509. };
    1510.  
    1511. Sizzle.filter = function(expr, set, inplace, not){
    1512.     var old = expr, result = [], curLoop = set, match, anyFound;
    1513.  
    1514.     while ( expr && set.length ) {
    1515.         for ( var type in Expr.filter ) {
    1516.             if ( (match = Expr.match[ type ].exec( expr )) != null ) {
    1517.                 var filter = Expr.filter[ type ], found, item;
    1518.                 anyFound = false;
    1519.  
    1520.                 if ( curLoop == result ) {
    1521.                     result = [];
    1522.                 }
    1523.  
    1524.                 if ( Expr.preFilter[ type ] ) {
    1525.                     match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not );
    1526.  
    1527.                     if ( !match ) {
    1528.                         anyFound = found = true;
    1529.                     } else if ( match === true ) {
    1530.                         continue;
    1531.                     }
    1532.                 }
    1533.  
    1534.                 if ( match ) {
    1535.                     for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
    1536.                         if ( item ) {
    1537.                             found = filter( item, match, i, curLoop );
    1538.                             var pass = not ^ !!found;
    1539.  
    1540.                             if ( inplace && found != null ) {
    1541.                                 if ( pass ) {
    1542.                                     anyFound = true;
    1543.                                 } else {
    1544.                                     curLoop[i] = false;
    1545.                                 }
    1546.                             } else if ( pass ) {
    1547.                                 result.push( item );
    1548.                                 anyFound = true;
    1549.                             }
    1550.                         }
    1551.                     }
    1552.                 }
    1553.  
    1554.                 if ( found !== undefined ) {
    1555.                     if ( !inplace ) {
    1556.                         curLoop = result;
    1557.                     }
    1558.  
    1559.                     expr = expr.replace( Expr.match[ type ], "" );
    1560.  
    1561.                     if ( !anyFound ) {
    1562.                         return [];
    1563.                     }
    1564.  
    1565.                     break;
    1566.                 }
    1567.             }
    1568.         }
    1569.  
    1570.         expr = expr.replace(/\s*,\s*/, "");
    1571.  
    1572.         // Improper expression
    1573.         if ( expr == old ) {
    1574.             if ( anyFound == null ) {
    1575.                 throw "Syntax error, unrecognized expression: " + expr;
    1576.             } else {
    1577.                 break;
    1578.             }
    1579.         }
    1580.  
    1581.         old = expr;
    1582.     }
    1583.  
    1584.     return curLoop;
    1585. };
    1586.  
    1587. var Expr = Sizzle.selectors = {
    1588.     order: [ "ID", "NAME", "TAG" ],
    1589.     match: {
    1590.         ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
    1591.         CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
    1592.         NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
    1593.         ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
    1594.         TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
    1595.         CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
    1596.         POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
    1597.         PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
    1598.     },
    1599.     attrMap: {
    1600.         "class": "className",
    1601.         "for": "htmlFor"
    1602.     },
    1603.     attrHandle: {
    1604.         href: function(elem){
    1605.             return elem.getAttribute("href");
    1606.         }
    1607.     },
    1608.     relative: {
    1609.         "+": function(checkSet, part){
    1610.             for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    1611.                 var elem = checkSet[i];
    1612.                 if ( elem ) {
    1613.                     var cur = elem.previousSibling;
    1614.                     while ( cur && cur.nodeType !== 1 ) {
    1615.                         cur = cur.previousSibling;
    1616.                     }
    1617.                     checkSet[i] = typeof part === "string" ?
    1618.                         cur || false :
    1619.                         cur === part;
    1620.                 }
    1621.             }
    1622.             if ( typeof part === "string" ) {
    1623.                 Sizzle.filter( part, checkSet, true );
    1624.             }
    1625.         },
    1626.         ">": function(checkSet, part, isXML){
    1627.             if ( typeof part === "string" && !/\W/.test(part) ) {
    1628.                 part = isXML ? part : part.toUpperCase();
    1629.  
    1630.                 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    1631.                     var elem = checkSet[i];
    1632.                     if ( elem ) {
    1633.                         var parent = elem.parentNode;
    1634.                         checkSet[i] = parent.nodeName === part ? parent : false;
    1635.                     }
    1636.                 }
    1637.             } else {
    1638.                 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    1639.                     var elem = checkSet[i];
    1640.                     if ( elem ) {
    1641.                         checkSet[i] = typeof part === "string" ?
    1642.                             elem.parentNode :
    1643.                             elem.parentNode === part;
    1644.                     }
    1645.                 }
    1646.  
    1647.                 if ( typeof part === "string" ) {
    1648.                     Sizzle.filter( part, checkSet, true );
    1649.                 }
    1650.             }
    1651.         },
    1652.         "": function(checkSet, part, isXML){
    1653.             var doneName = "done" + (done++), checkFn = dirCheck;
    1654.  
    1655.             if ( !part.match(/\W/) ) {
    1656.                 var nodeCheck = part = isXML ? part : part.toUpperCase();
    1657.                 checkFn = dirNodeCheck;
    1658.             }
    1659.  
    1660.             checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
    1661.         },
    1662.         "~": function(checkSet, part, isXML){
    1663.             var doneName = "done" + (done++), checkFn = dirCheck;
    1664.  
    1665.             if ( typeof part === "string" && !part.match(/\W/) ) {
    1666.                 var nodeCheck = part = isXML ? part : part.toUpperCase();
    1667.                 checkFn = dirNodeCheck;
    1668.             }
    1669.  
    1670.             checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
    1671.         }
    1672.     },
    1673.     find: {
    1674.         ID: function(match, context, isXML){
    1675.             if ( typeof context.getElementById !== "undefined" && !isXML ) {
    1676.                 var m = context.getElementById(match[1]);
    1677.                 return m ? [m] : [];
    1678.             }
    1679.         },
    1680.         NAME: function(match, context, isXML){
    1681.             if ( typeof context.getElementsByName !== "undefined" && !isXML ) {
    1682.                 return context.getElementsByName(match[1]);
    1683.             }
    1684.         },
    1685.         TAG: function(match, context){
    1686.             return context.getElementsByTagName(match[1]);
    1687.         }
    1688.     },
    1689.     preFilter: {
    1690.         CLASS: function(match, curLoop, inplace, result, not){
    1691.             match = " " + match[1].replace(/\\/g, "") + " ";
    1692.  
    1693.             var elem;
    1694.             for ( var i = 0; (elem = curLoop[i]) != null; i++ ) {
    1695.                 if ( elem ) {
    1696.                     if ( not ^ (" " + elem.className + " ").indexOf(match) >= 0 ) {
    1697.                         if ( !inplace )
    1698.                             result.push( elem );
    1699.                     } else if ( inplace ) {
    1700.                         curLoop[i] = false;
    1701.                     }
    1702.                 }
    1703.             }
    1704.  
    1705.             return false;
    1706.         },
    1707.         ID: function(match){
    1708.             return match[1].replace(/\\/g, "");
    1709.         },
    1710.         TAG: function(match, curLoop){
    1711.             for ( var i = 0; curLoop[i] === false; i++ ){}
    1712.             return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
    1713.         },
    1714.         CHILD: function(match){
    1715.             if ( match[1] == "nth" ) {
    1716.                 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
    1717.                 var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
    1718.                     match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
    1719.                     !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
    1720.  
    1721.                 // calculate the numbers (first)n+(last) including if they are negative
    1722.                 match[2] = (test[1] + (test[2] || 1)) - 0;
    1723.                 match[3] = test[3] - 0;
    1724.             }
    1725.  
    1726.             // TODO: Move to normal caching system
    1727.             match[0] = "done" + (done++);
    1728.  
    1729.             return match;
    1730.         },
    1731.         ATTR: function(match){
    1732.             var name = match[1].replace(/\\/g, "");
    1733.  
    1734.             if ( Expr.attrMap[name] ) {
    1735.                 match[1] = Expr.attrMap[name];
    1736.             }
    1737.  
    1738.             if ( match[2] === "~=" ) {
    1739.                 match[4] = " " + match[4] + " ";
    1740.             }
    1741.  
    1742.             return match;
    1743.         },
    1744.         PSEUDO: function(match, curLoop, inplace, result, not){
    1745.             if ( match[1] === "not" ) {
    1746.                 // If we're dealing with a complex expression, or a simple one
    1747.                 if ( match[3].match(chunker).length > 1 ) {
    1748.                     match[3] = Sizzle(match[3], null, null, curLoop);
    1749.                 } else {
    1750.                     var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
    1751.                     if ( !inplace ) {
    1752.                         result.push.apply( result, ret );
    1753.                     }
    1754.                     return false;
    1755.                 }
    1756.             } else if ( Expr.match.POS.test( match[0] ) ) {
    1757.                 return true;
    1758.             }
    1759.  
    1760.             return match;
    1761.         },
    1762.         POS: function(match){
    1763.             match.unshift( true );
    1764.             return match;
    1765.         }
    1766.     },
    1767.     filters: {
    1768.         enabled: function(elem){
    1769.             return elem.disabled === false && elem.type !== "hidden";
    1770.         },
    1771.         disabled: function(elem){
    1772.             return elem.disabled === true;
    1773.         },
    1774.         checked: function(elem){
    1775.             return elem.checked === true;
    1776.         },
    1777.         selected: function(elem){
    1778.             // Accessing this property makes selected-by-default
    1779.             // options in Safari work properly
    1780.             elem.parentNode.selectedIndex;
    1781.             return elem.selected === true;
    1782.         },
    1783.         parent: function(elem){
    1784.             return !!elem.firstChild;
    1785.         },
    1786.         empty: function(elem){
    1787.             return !elem.firstChild;
    1788.         },
    1789.         has: function(elem, i, match){
    1790.             return !!Sizzle( match[3], elem ).length;
    1791.         },
    1792.         header: function(elem){
    1793.             return /h\d/i.test( elem.nodeName );
    1794.         },
    1795.         text: function(elem){
    1796.             return "text" === elem.type;
    1797.         },
    1798.         radio: function(elem){
    1799.             return "radio" === elem.type;
    1800.         },
    1801.         checkbox: function(elem){
    1802.             return "checkbox" === elem.type;
    1803.         },
    1804.         file: function(elem){
    1805.             return "file" === elem.type;
    1806.         },
    1807.         password: function(elem){
    1808.             return "password" === elem.type;
    1809.         },
    1810.         submit: function(elem){
    1811.             return "submit" === elem.type;
    1812.         },
    1813.         image: function(elem){
    1814.             return "image" === elem.type;
    1815.         },
    1816.         reset: function(elem){
    1817.             return "reset" === elem.type;
    1818.         },
    1819.         button: function(elem){
    1820.             return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
    1821.         },
    1822.         input: function(elem){
    1823.             return /input|select|textarea|button/i.test(elem.nodeName);
    1824.         }
    1825.     },
    1826.     setFilters: {
    1827.         first: function(elem, i){
    1828.             return i === 0;
    1829.         },
    1830.         last: function(elem, i, match, array){
    1831.             return i === array.length - 1;
    1832.         },
    1833.         even: function(elem, i){
    1834.             return i % 2 === 0;
    1835.         },
    1836.         odd: function(elem, i){
    1837.             return i % 2 === 1;
    1838.         },
    1839.         lt: function(elem, i, match){
    1840.             return i < match[3] - 0;
    1841.         },
    1842.         gt: function(elem, i, match){
    1843.             return i > match[3] - 0;
    1844.         },
    1845.         nth: function(elem, i, match){
    1846.             return match[3] - 0 == i;
    1847.         },
    1848.         eq: function(elem, i, match){
    1849.             return match[3] - 0 == i;
    1850.         }
    1851.     },
    1852.     filter: {
    1853.         CHILD: function(elem, match){
    1854.             var type = match[1], parent = elem.parentNode;
    1855.  
    1856.             var doneName = match[0];
    1857.  
    1858.             if ( parent && (!parent[ doneName ] || !elem.nodeIndex) ) {
    1859.                 var count = 1;
    1860.  
    1861.                 for ( var node = parent.firstChild; node; node = node.nextSibling ) {
    1862.                     if ( node.nodeType == 1 ) {
    1863.                         node.nodeIndex = count++;
    1864.                     }
    1865.                 }
    1866.  
    1867.                 parent[ doneName ] = count - 1;
    1868.             }
    1869.  
    1870.             if ( type == "first" ) {
    1871.                 return elem.nodeIndex == 1;
    1872.             } else if ( type == "last" ) {
    1873.                 return elem.nodeIndex == parent[ doneName ];
    1874.             } else if ( type == "only" ) {
    1875.                 return parent[ doneName ] == 1;
    1876.             } else if ( type == "nth" ) {
    1877.                 var add = false, first = match[2], last = match[3];
    1878.  
    1879.                 if ( first == 1 && last == 0 ) {
    1880.                     return true;
    1881.                 }
    1882.  
    1883.                 if ( first == 0 ) {
    1884.                     if ( elem.nodeIndex == last ) {
    1885.                         add = true;
    1886.                     }
    1887.                 } else if ( (elem.nodeIndex - last) % first == 0 && (elem.nodeIndex - last) / first >= 0 ) {
    1888.                     add = true;
    1889.                 }
    1890.  
    1891.                 return add;
    1892.             }
    1893.         },
    1894.         PSEUDO: function(elem, match, i, array){
    1895.             var name = match[1], filter = Expr.filters[ name ];
    1896.  
    1897.             if ( filter ) {
    1898.                 return filter( elem, i, match, array );
    1899.             } else if ( name === "contains" ) {
    1900.                 return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
    1901.             } else if ( name === "not" ) {
    1902.                 var not = match[3];
    1903.  
    1904.                 for ( var i = 0, l = not.length; i < l; i++ ) {
    1905.                     if ( not[i] === elem ) {
    1906.                         return false;
    1907.                     }
    1908.                 }
    1909.  
    1910.                 return true;
    1911.             }
    1912.         },
    1913.         ID: function(elem, match){
    1914.             return elem.nodeType === 1 && elem.getAttribute("id") === match;
    1915.         },
    1916.         TAG: function(elem, match){
    1917.             return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
    1918.         },
    1919.         CLASS: function(elem, match){
    1920.             return match.test( elem.className );
    1921.         },
    1922.         ATTR: function(elem, match){
    1923.             var result = Expr.attrHandle[ match[1] ] ? Expr.attrHandle[ match[1] ]( elem ) : elem[ match[1] ] || elem.getAttribute( match[1] ), value = result + "", type = match[2], check = match[4];
    1924.             return result == null ?
    1925.                 type === "!=" :
    1926.                 type === "=" ?
    1927.                 value === check :
    1928.                 type === "*=" ?
    1929.                 value.indexOf(check) >= 0 :
    1930.                 type === "~=" ?
    1931.                 (" " + value + " ").indexOf(check) >= 0 :
    1932.                 !match[4] ?
    1933.                 result :
    1934.                 type === "!=" ?
    1935.                 value != check :
    1936.                 type === "^=" ?
    1937.                 value.indexOf(check) === 0 :
    1938.                 type === "$=" ?
    1939.                 value.substr(value.length - check.length) === check :
    1940.                 type === "|=" ?
    1941.                 value === check || value.substr(0, check.length + 1) === check + "-" :
    1942.                 false;
    1943.         },
    1944.         POS: function(elem, match, i, array){
    1945.             var name = match[2], filter = Expr.setFilters[ name ];
    1946.  
    1947.             if ( filter ) {
    1948.                 return filter( elem, i, match, array );
    1949.             }
    1950.         }
    1951.     }
    1952. };
    1953.  
    1954. var origPOS = Expr.match.POS;
    1955.  
    1956. for ( var type in Expr.match ) {
    1957.     Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
    1958. }
    1959.  
    1960. var makeArray = function(array, results) {
    1961.     array = Array.prototype.slice.call( array );
    1962.  
    1963.     if ( results ) {
    1964.         results.push.apply( results, array );
    1965.         return results;
    1966.     }
    1967.  
    1968.     return array;
    1969. };
    1970.  
    1971. // Perform a simple check to determine if the browser is capable of
    1972. // converting a NodeList to an array using builtin methods.
    1973. try {
    1974.     Array.prototype.slice.call( document.documentElement.childNodes );
    1975.  
    1976. // Provide a fallback method if it does not work
    1977. } catch(e){
    1978.     makeArray = function(array, results) {
    1979.         var ret = results || [];
    1980.  
    1981.         if ( toString.call(array) === "[object Array]" ) {
    1982.             Array.prototype.push.apply( ret, array );
    1983.         } else {
    1984.             if ( typeof array.length === "number" ) {
    1985.                 for ( var i = 0, l = array.length; i < l; i++ ) {
    1986.                     ret.push( array[i] );
    1987.                 }
    1988.             } else {
    1989.                 for ( var i = 0; array[i]; i++ ) {
    1990.                     ret.push( array[i] );
    1991.                 }
    1992.             }
    1993.         }
    1994.  
    1995.         return ret;
    1996.     };
    1997. }
    1998.  
    1999. // Check to see if the browser returns elements by name when
    2000. // querying by getElementById (and provide a workaround)
    2001. (function(){
    2002.     // We're going to inject a fake input element with a specified name
    2003.     var form = document.createElement("form"),
    2004.         id = "script" + (new Date).getTime();
    2005.     form.innerHTML = "<input name='" + id + "'/>";
    2006.  
    2007.     // Inject it into the root element, check its status, and remove it quickly
    2008.     var root = document.documentElement;
    2009.     root.insertBefore( form, root.firstChild );
    2010.  
    2011.     // The workaround has to do additional checks after a getElementById
    2012.     // Which slows things down for other browsers (hence the branching)
    2013.     if ( !!document.getElementById( id ) ) {
    2014.         Expr.find.ID = function(match, context, isXML){
    2015.             if ( typeof context.getElementById !== "undefined" && !isXML ) {
    2016.                 var m = context.getElementById(match[1]);
    2017.                 return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
    2018.             }
    2019.         };
    2020.  
    2021.         Expr.filter.ID = function(elem, match){
    2022.             var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
    2023.             return elem.nodeType === 1 && node && node.nodeValue === match;
    2024.         };
    2025.     }
    2026.  
    2027.     root.removeChild( form );
    2028. })();
    2029.  
    2030. (function(){
    2031.     // Check to see if the browser returns only elements
    2032.     // when doing getElementsByTagName("*")
    2033.  
    2034.     // Create a fake element
    2035.     var div = document.createElement("div");
    2036.     div.appendChild( document.createComment("") );
    2037.  
    2038.     // Make sure no comments are found
    2039.     if ( div.getElementsByTagName("*").length > 0 ) {
    2040.         Expr.find.TAG = function(match, context){
    2041.             var results = context.getElementsByTagName(match[1]);
    2042.  
    2043.             // Filter out possible comments
    2044.             if ( match[1] === "*" ) {
    2045.                 var tmp = [];
    2046.  
    2047.                 for ( var i = 0; results[i]; i++ ) {
    2048.                     if ( results[i].nodeType === 1 ) {
    2049.                         tmp.push( results[i] );
    2050.                     }
    2051.                 }
    2052.  
    2053.                 results = tmp;
    2054.             }
    2055.  
    2056.             return results;
    2057.         };
    2058.     }
    2059.  
    2060.     // Check to see if an attribute returns normalized href attributes
    2061.     div.innerHTML = "<a href='#'></a>";
    2062.     if ( div.firstChild && div.firstChild.getAttribute("href") !== "#" ) {
    2063.         Expr.attrHandle.href = function(elem){
    2064.             return elem.getAttribute("href", 2);
    2065.         };
    2066.     }
    2067. })();
    2068.  
    2069. if ( document.querySelectorAll ) (function(){
    2070.     var oldSizzle = Sizzle, div = document.createElement("div");
    2071.     div.innerHTML = "<p class='TEST'></p>";
    2072.  
    2073.     // Safari can't handle uppercase or unicode characters when
    2074.     // in quirks mode.
    2075.     if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
    2076.         return;
    2077.     }
    2078.  
    2079.     Sizzle = function(query, context, extra, seed){
    2080.         context = context || document;
    2081.  
    2082.         // Only use querySelectorAll on non-XML documents
    2083.         // (ID selectors don't work in non-HTML documents)
    2084.         if ( !seed && context.nodeType === 9 && !isXML(context) ) {
    2085.             try {
    2086.                 return makeArray( context.querySelectorAll(query), extra );
    2087.             } catch(e){}
    2088.         }
    2089.  
    2090.         return oldSizzle(query, context, extra, seed);
    2091.     };
    2092.  
    2093.     Sizzle.find = oldSizzle.find;
    2094.     Sizzle.filter = oldSizzle.filter;
    2095.     Sizzle.selectors = oldSizzle.selectors;
    2096.     Sizzle.matches = oldSizzle.matches;
    2097. })();
    2098.  
    2099. if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) {
    2100.     Expr.order.splice(1, 0, "CLASS");
    2101.     Expr.find.CLASS = function(match, context) {
    2102.         return context.getElementsByClassName(match[1]);
    2103.     };
    2104. }
    2105.  
    2106. function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
    2107.     for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    2108.         var elem = checkSet[i];
    2109.         if ( elem ) {
    2110.             elem = elem[dir];
    2111.             var match = false;
    2112.  
    2113.             while ( elem && elem.nodeType ) {
    2114.                 var done = elem[doneName];
    2115.                 if ( done ) {
    2116.                     match = checkSet[ done ];
    2117.                     break;
    2118.                 }
    2119.  
    2120.                 if ( elem.nodeType === 1 && !isXML )
    2121.                     elem[doneName] = i;
    2122.  
    2123.                 if ( elem.nodeName === cur ) {
    2124.                     match = elem;
    2125.                     break;
    2126.                 }
    2127.  
    2128.                 elem = elem[dir];
    2129.             }
    2130.  
    2131.             checkSet[i] = match;
    2132.         }
    2133.     }
    2134. }
    2135.  
    2136. function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
    2137.     for ( var i = 0, l = checkSet.length; i < l; i++ ) {
    2138.         var elem = checkSet[i];
    2139.         if ( elem ) {
    2140.             elem = elem[dir];
    2141.             var match = false;
    2142.  
    2143.             while ( elem && elem.nodeType ) {
    2144.                 if ( elem[doneName] ) {
    2145.                     match = checkSet[ elem[doneName] ];
    2146.                     break;
    2147.                 }
    2148.  
    2149.                 if ( elem.nodeType === 1 ) {
    2150.                     if ( !isXML )
    2151.                         elem[doneName] = i;
    2152.  
    2153.                     if ( typeof cur !== "string" ) {
    2154.                         if ( elem === cur ) {
    2155.                             match = true;
    2156.                             break;
    2157.                         }
    2158.  
    2159.                     } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
    2160.                         match = elem;
    2161.                         break;
    2162.                     }
    2163.                 }
    2164.  
    2165.                 elem = elem[dir];
    2166.             }
    2167.  
    2168.             checkSet[i] = match;
    2169.         }
    2170.     }
    2171. }
    2172.  
    2173. var contains = document.compareDocumentPosition ?  function(a, b){
    2174.     return a.compareDocumentPosition(b) & 16;
    2175. } : function(a, b){
    2176.     return a !== b && (a.contains ? a.contains(b) : true);
    2177. };
    2178.  
    2179. var isXML = function(elem){
    2180.     return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
    2181.         !!elem.ownerDocument && isXML( elem.ownerDocument );
    2182. };
    2183.  
    2184. var posProcess = function(selector, context){
    2185.     var tmpSet = [], later = "", match,
    2186.         root = context.nodeType ? [context] : context;
    2187.  
    2188.     // Position selectors must be done after the filter
    2189.     // And so must :not(positional) so we move all PSEUDOs to the end
    2190.     while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
    2191.         later += match[0];
    2192.         selector = selector.replace( Expr.match.PSEUDO, "" );
    2193.     }
    2194.  
    2195.     selector = Expr.relative[selector] ? selector + "*" : selector;
    2196.  
    2197.     for ( var i = 0, l = root.length; i < l; i++ ) {
    2198.         Sizzle( selector, root[i], tmpSet );
    2199.     }
    2200.  
    2201.     return Sizzle.filter( later, tmpSet );
    2202. };
    2203.  
    2204. // EXPOSE
    2205. jQuery.find = Sizzle;
    2206. jQuery.filter = Sizzle.filter;
    2207. jQuery.expr = Sizzle.selectors;
    2208. jQuery.expr[":"] = jQuery.expr.filters;
    2209.  
    2210. Sizzle.selectors.filters.hidden = function(elem){
    2211.     return "hidden" === elem.type ||
    2212.         jQuery.css(elem, "display") === "none" ||
    2213.         jQuery.css(elem, "visibility") === "hidden";
    2214. };
    2215.  
    2216. Sizzle.selectors.filters.visible = function(elem){
    2217.     return "hidden" !== elem.type &&
    2218.         jQuery.css(elem, "display") !== "none" &&
    2219.         jQuery.css(elem, "visibility") !== "hidden";
    2220. };
    2221.  
    2222. Sizzle.selectors.filters.animated = function(elem){
    2223.     return jQuery.grep(jQuery.timers, function(fn){
    2224.         return elem === fn.elem;
    2225.     }).length;
    2226. };
    2227.  
    2228. jQuery.multiFilter = function( expr, elems, not ) {
    2229.     if ( not ) {
    2230.         expr = ":not(" + expr + ")";
    2231.     }
    2232.  
    2233.     return Sizzle.matches(expr, elems);
    2234. };
    2235.  
    2236. jQuery.dir = function( elem, dir ){
    2237.     var matched = [], cur = elem[dir];
    2238.     while ( cur && cur != document ) {
    2239.         if ( cur.nodeType == 1 )
    2240.             matched.push( cur );
    2241.         cur = cur[dir];
    2242.     }
    2243.     return matched;
    2244. };
    2245.  
    2246. jQuery.nth = function(cur, result, dir, elem){
    2247.     result = result || 1;
    2248.     var num = 0;
    2249.  
    2250.     for ( ; cur; cur = cur[dir] )
    2251.         if ( cur.nodeType == 1 && ++num == result )
    2252.             break;
    2253.  
    2254.     return cur;
    2255. };
    2256.  
    2257. jQuery.sibling = function(n, elem){
    2258.     var r = [];
    2259.  
    2260.     for ( ; n; n = n.nextSibling ) {
    2261.         if ( n.nodeType == 1 && n != elem )
    2262.             r.push( n );
    2263.     }
    2264.  
    2265.     return r;
    2266. };
    2267.  
    2268. return;
    2269.  
    2270. window.Sizzle = Sizzle;
    2271.  
    2272. })();
    2273. /*
    2274. * A number of helper functions used for managing events.
    2275. * Many of the ideas behind this code originated from
    2276. * Dean Edwards' addEvent library.
    2277. */
    2278. jQuery.event = {
    2279.     // Bind an event to an element
    2280.     // Original by Dean Edwards
    2281.     add: function(elem, types, handler, data) {
    2282.         if ( elem.nodeType == 3 || elem.nodeType == 8 )
    2283.             return;
    2284.         // For whatever reason, IE has trouble passing the window object
    2285.         // around, causing it to be *****d in the process
    2286.         if ( elem.setInterval && elem != window )
    2287.             elem = window;
    2288.         // Make sure that the function being executed has a unique ID
    2289.         if ( !handler.guid )
    2290.             handler.guid = this.guid++;
    2291.         // if data is passed, bind to handler
    2292.         if ( data !== undefined ) {
    2293.             // Create temporary function pointer to original handler
    2294.             var fn = handler;
    2295.             // Create unique handler function, wrapped around original handler
    2296.             handler = this.proxy( fn );
    2297.             // Store data in unique handler
    2298.             handler.data = data;
    2299.         }
    2300.         // Init the element's event structure
    2301.         var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
    2302.             handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
    2303.                 // Handle the second event of a trigger and when
    2304.                 // an event is called after a page has unloaded
    2305.                 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
    2306.                     jQuery.event.handle.apply(arguments.callee.elem, arguments) :
    2307.                     undefined;
    2308.             });
    2309.         // Add elem as a property of the handle function
    2310.         // This is to prevent a memory leak with non-native
    2311.         // event in IE.
    2312.         handle.elem = elem;
    2313.  
    2314.         // Handle multiple events separated by a space
    2315.         // jQuery(...).bind("mouseover mouseout", fn);
    2316.         jQuery.each(types.split(/\s+/), function(index, type) {
    2317.             // Namespaced event handlers
    2318.             var namespaces = type.split(".");
    2319.             type = namespaces.shift();
    2320.             handler.type = namespaces.slice().sort().join(".");
    2321.  
    2322.             // Get the current list of functions bound to this event
    2323.             var handlers = events[type];
    2324.  
    2325.             if ( jQuery.event.specialAll[type] )
    2326.                 jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
    2327.  
    2328.             // Init the event handler queue
    2329.             if (!handlers) {
    2330.                 handlers = events[type] = {};
    2331.  
    2332.                 // Check for a special event handler
    2333.                 // Only use addEventListener/attachEvent if the special
    2334.                 // events handler returns false
    2335.                 if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
    2336.                     // Bind the global event handler to the element
    2337.                     if (elem.addEventListener)
    2338.                         elem.addEventListener(type, handle, false);
    2339.                     else if (elem.attachEvent)
    2340.                         elem.attachEvent("on" + type, handle);
    2341.                 }
    2342.             }
    2343.  
    2344.             // Add the function to the element's handler list
    2345.             handlers[handler.guid] = handler;
    2346.             // Keep track of which events have been used, for global triggering
    2347.             jQuery.event.global[type] = true;
    2348.         });
    2349.         // Nullify elem to prevent memory leaks in IE
    2350.         elem = null;
    2351.     },
    2352.     guid: 1,
    2353.     global: {},
    2354.     // Detach an event or set of events from an element
    2355.     remove: function(elem, types, handler) {
    2356.         // don't do events on text and comment nodes
    2357.         if ( elem.nodeType == 3 || elem.nodeType == 8 )
    2358.             return;
    2359.  
    2360.         var events = jQuery.data(elem, "events"), ret, index;
    2361.  
    2362.         if ( events ) {
    2363.             // Unbind all events for the element
    2364.             if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
    2365.                 for ( var type in events )
    2366.                     this.remove( elem, type + (types || "") );
    2367.             else {
    2368.                 // types is actually an event object here
    2369.                 if ( types.type ) {
    2370.                     handler = types.handler;
    2371.                     types = types.type;
    2372.                 }
    2373.  
    2374.                 // Handle multiple events seperated by a space
    2375.                 // jQuery(...).unbind("mouseover mouseout", fn);
    2376.                 jQuery.each(types.split(/\s+/), function(index, type){
    2377.                     // Namespaced event handlers
    2378.                     var namespaces = type.split(".");
    2379.                     type = namespaces.shift();
    2380.                     var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
    2381.  
    2382.                     if ( events[type] ) {
    2383.                         // remove the given handler for the given type
    2384.                         if ( handler )
    2385.                             delete events[type][handler.guid];
    2386.  
    2387.                         // remove all handlers for the given type
    2388.                         else
    2389.                             for ( var handle in events[type] )
    2390.                                 // Handle the removal of namespaced events
    2391.                                 if ( namespace.test(events[type][handle].type) )
    2392.                                     delete events[type][handle];
    2393.  
    2394.                         if ( jQuery.event.specialAll[type] )
    2395.                             jQuery.event.specialAll[type].teardown.call(elem, namespaces);
    2396.  
    2397.                         // remove generic event handler if no more handlers exist
    2398.                         for ( ret in events[type] ) break;
    2399.                         if ( !ret ) {
    2400.                             if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
    2401.                                 if (elem.removeEventListener)
    2402.                                     elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
    2403.                                 else if (elem.detachEvent)
    2404.                                     elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
    2405.                             }
    2406.                             ret = null;
    2407.                             delete events[type];
    2408.                         }
    2409.                     }
    2410.                 });
    2411.             }
    2412.  
    2413.             // Remove the expando if it's no longer used
    2414.             for ( ret in events ) break;
    2415.             if ( !ret ) {
    2416.                 var handle = jQuery.data( elem, "handle" );
    2417.                 if ( handle ) handle.elem = null;
    2418.                 jQuery.removeData( elem, "events" );
    2419.                 jQuery.removeData( elem, "handle" );
    2420.             }
    2421.         }
    2422.     },
    2423.     // bubbling is internal
    2424.     trigger: function( event, data, elem, bubbling ) {
    2425.         // Event object or event type
    2426.         var type = event.type || event;
    2427.         if( !bubbling ){
    2428.             event = typeof event === "object" ?
    2429.                 // jQuery.Event object
    2430.                 event[expando] ? event :
    2431.                 // Object literal
    2432.                 jQuery.extend( jQuery.Event(type), event ) :
    2433.                 // Just the event type (string)
    2434.                 jQuery.Event(type);
    2435.             if ( type.indexOf("!") >= 0 ) {
    2436.                 event.type = type = type.slice(0, -1);
    2437.                 event.exclusive = true;
    2438.             }
    2439.  
    2440.             // Handle a global trigger
    2441.             if ( !elem ) {
    2442.                 // Don't bubble custom events when global (to avoid too much overhead)
    2443.                 event.stopPropagation();
    2444.                 // Only trigger if we've ever bound an event for it
    2445.                 if ( this.global[type] )
    2446.                     jQuery.each( jQuery.cache, function(){
    2447.                         if ( this.events && this.events[type] )
    2448.                             jQuery.event.trigger( event, data, this.handle.elem );
    2449.                     });
    2450.             }
    2451.  
    2452.             // Handle triggering a single element
    2453.  
    2454.             // don't do events on text and comment nodes
    2455.             if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 )
    2456.                 return undefined;
    2457.  
    2458.             // Clean up in case it is reused
    2459.             event.result = undefined;
    2460.             event.target = elem;
    2461.  
    2462.             // ***** the incoming data, if any
    2463.             data = jQuery.makeArray(data);
    2464.             data.unshift( event );
    2465.         }
    2466.  
    2467.         event.currentTarget = elem;
    2468.  
    2469.         // Trigger the event, it is assumed that "handle" is a function
    2470.         var handle = jQuery.data(elem, "handle");
    2471.         if ( handle )
    2472.             handle.apply( elem, data );
    2473.  
    2474.         // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
    2475.         if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
    2476.             event.result = false;
    2477.  
    2478.         // Trigger the native events (except for clicks on links)
    2479.         if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
    2480.             this.triggered = true;
    2481.             try {
    2482.                 elem[ type ]();
    2483.             // prevent IE from throwing an error for some hidden elements
    2484.             } catch (e) {}
    2485.         }
    2486.  
    2487.         this.triggered = false;
    2488.  
    2489.         if ( !event.isPropagationStopped() ) {
    2490.             var parent = elem.parentNode || elem.ownerDocument;
    2491.             if ( parent )
    2492.                 jQuery.event.trigger(event, data, parent, true);
    2493.         }
    2494.     },
    2495.  
    2496.     handle: function(event) {
    2497.         // returned undefined or false
    2498.         var all, handlers;
    2499.  
    2500.         event = arguments[0] = jQuery.event.fix( event || window.event );
    2501.  
    2502.         // Namespaced event handlers
    2503.         var namespaces = event.type.split(".");
    2504.         event.type = namespaces.shift();
    2505.  
    2506.         // Cache this now, all = true means, any handler
    2507.         all = !namespaces.length && !event.exclusive;
    2508.  
    2509.         var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
    2510.  
    2511.         handlers = ( jQuery.data(this, "events") || {} )[event.type];
    2512.  
    2513.         for ( var j in handlers ) {
    2514.             var handler = handlers[j];
    2515.  
    2516.             // Filter the functions by class
    2517.             if ( all || namespace.test(handler.type) ) {
    2518.                 // Pass in a reference to the handler function itself
    2519.                 // So that we can later remove it
    2520.                 event.handler = handler;
    2521.                 event.data = handler.data;
    2522.  
    2523.                 var ret = handler.apply(this, arguments);
    2524.  
    2525.                 if( ret !== undefined ){
    2526.                     event.result = ret;
    2527.                     if ( ret === false ) {
    2528.                         event.preventDefault();
    2529.                         event.stopPropagation();
    2530.                     }
    2531.                 }
    2532.  
    2533.                 if( event.isImmediatePropagationStopped() )
    2534.                     break;
    2535.  
    2536.             }
    2537.         }
    2538.     },
    2539.  
    2540.     props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
    2541.  
    2542.     fix: function(event) {
    2543.         if ( event[expando] )
    2544.             return event;
    2545.  
    2546.         // store a copy of the original event object
    2547.         // and "*****" to set read-only properties
    2548.         var originalEvent = event;
    2549.         event = jQuery.Event( originalEvent );
    2550.  
    2551.         for ( var i = this.props.length, prop; i; ){
    2552.             prop = this.props[ --i ];
    2553.             event[ prop ] = originalEvent[ prop ];
    2554.         }
    2555.  
    2556.         // Fix target property, if necessary
    2557.         if ( !event.target )
    2558.             event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
    2559.  
    2560.         // check if target is a textnode (safari)
    2561.         if ( event.target.nodeType == 3 )
    2562.             event.target = event.target.parentNode;
    2563.  
    2564.         // Add relatedTarget, if necessary
    2565.         if ( !event.relatedTarget && event.fromElement )
    2566.             event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
    2567.  
    2568.         // Calculate pageX/Y if missing and clientX/Y available
    2569.         if ( event.pageX == null && event.clientX != null ) {
    2570.             var doc = document.documentElement, body = document.body;
    2571.             event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
    2572.             event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
    2573.         }
    2574.  
    2575.         // Add which for key events
    2576.         if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
    2577.             event.which = event.charCode || event.keyCode;
    2578.  
    2579.         // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
    2580.         if ( !event.metaKey && event.ctrlKey )
    2581.             event.metaKey = event.ctrlKey;
    2582.  
    2583.         // Add which for click: 1 == left; 2 == middle; 3 == right
    2584.         // Note: button is not normalized, so don't use it
    2585.         if ( !event.which && event.button )
    2586.             event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
    2587.  
    2588.         return event;
    2589.     },
    2590.  
    2591.     proxy: function( fn, proxy ){
    2592.         proxy = proxy || function(){ return fn.apply(this, arguments); };
    2593.         // Set the guid of unique handler to the same of original handler, so it can be removed
    2594.         proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
    2595.         // So proxy can be declared as an argument
    2596.         return proxy;
    2597.     },
    2598.  
    2599.     special: {
    2600.         ready: {
    2601.             // Make sure the ready event is setup
    2602.             setup: bindReady,
    2603.             teardown: function() {}
    2604.         }
    2605.     },
    2606.  
    2607.     specialAll: {
    2608.         live: {
    2609.             setup: function( selector, namespaces ){
    2610.                 jQuery.event.add( this, namespaces[0], liveHandler );
    2611.             },
    2612.             teardown:  function( namespaces ){
    2613.                 if ( namespaces.length ) {
    2614.                     var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
    2615.  
    2616.                     jQuery.each( (jQuery.data(this, "events").live || {}), function(){
    2617.                         if ( name.test(this.type) )
    2618.                             remove++;
    2619.                     });
    2620.  
    2621.                     if ( remove < 1 )
    2622.                         jQuery.event.remove( this, namespaces[0], liveHandler );
    2623.                 }
    2624.             }
    2625.         }
    2626.     }
    2627. };
    2628.  
    2629. jQuery.Event = function( src ){
    2630.     // Allow instantiation without the 'new' keyword
    2631.     if( !this.preventDefault )
    2632.         return new jQuery.Event(src);
    2633.  
    2634.     // Event object
    2635.     if( src && src.type ){
    2636.         this.originalEvent = src;
    2637.         this.type = src.type;
    2638.     // Event type
    2639.     }else
    2640.         this.type = src;
    2641.  
    2642.     // timeStamp is buggy for some events on Firefox(#3843)
    2643.     // So we won't rely on the native value
    2644.     this.timeStamp = now();
    2645.     // Mark it as fixed
    2646.     this[expando] = true;
    2647. };
    2648. function returnFalse(){
    2649.     return false;
    2650. }
    2651. function returnTrue(){
    2652.     return true;
    2653. }
    2654. // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
    2655. // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
    2656. jQuery.Event.prototype = {
    2657.     preventDefault: function() {
    2658.         this.isDefaultPrevented = returnTrue;
    2659.         var e = this.originalEvent;
    2660.         if( !e )
    2661.             return;
    2662.         // if preventDefault exists run it on the original event
    2663.         if (e.preventDefault)
    2664.             e.preventDefault();
    2665.         // otherwise set the returnValue property of the original event to false (IE)
    2666.         e.returnValue = false;
    2667.     },
    2668.     stopPropagation: function() {
    2669.         this.isPropagationStopped = returnTrue;
    2670.         var e = this.originalEvent;
    2671.         if( !e )
    2672.             return;
    2673.         // if stopPropagation exists run it on the original event
    2674.         if (e.stopPropagation)
    2675.             e.stopPropagation();
    2676.         // otherwise set the cancelBubble property of the original event to true (IE)
    2677.         e.cancelBubble = true;
    2678.     },
    2679.     stopImmediatePropagation:function(){
    2680.         this.isImmediatePropagationStopped = returnTrue;
    2681.         this.stopPropagation();
    2682.     },
    2683.     isDefaultPrevented: returnFalse,
    2684.     isPropagationStopped: returnFalse,
    2685.     isImmediatePropagationStopped: returnFalse
    2686. };
    2687. // Checks if an event happened on an element within another element
    2688. // Used in jQuery.event.special.mouseenter and mouseleave handlers
    2689. var withinElement = function(event) {
    2690.     // Check if mouse(over|out) are still within the same parent element
    2691.     var parent = event.relatedTarget;
    2692.     // Traverse up the tree
    2693.     while ( parent && parent != this )
    2694.         try { parent = parent.parentNode; }
    2695.         catch(e) { parent = this; }
    2696.     if( parent != this ){
    2697.         // set the correct event type
    2698.         event.type = event.data;
    2699.         // handle event if we actually just moused on to a non sub-element
    2700.         jQuery.event.handle.apply( this, arguments );
    2701.     }
    2702. };
    2703. jQuery.each({
    2704.     mouseover: 'mouseenter',
    2705.     mouseout: 'mouseleave'
    2706. }, function( orig, fix ){
    2707.     jQuery.event.special[ fix ] = {
    2708.         setup: function(){
    2709.             jQuery.event.add( this, orig, withinElement, fix );
    2710.         },
    2711.         teardown: function(){
    2712.             jQuery.event.remove( this, orig, withinElement );
    2713.         }
    2714.     };
    2715. });
    2716. jQuery.fn.extend({
    2717.     bind: function( type, data, fn ) {
    2718.         return type == "unload" ? this.one(type, data, fn) : this.each(function(){
    2719.             jQuery.event.add( this, type, fn || data, fn && data );
    2720.         });
    2721.     },
    2722.     one: function( type, data, fn ) {
    2723.         var one = jQuery.event.proxy( fn || data, function(event) {
    2724.             jQuery(this).unbind(event, one);
    2725.             return (fn || data).apply( this, arguments );
    2726.         });
    2727.         return this.each(function(){
    2728.             jQuery.event.add( this, type, one, fn && data);
    2729.         });
    2730.     },
    2731.     unbind: function( type, fn ) {
    2732.         return this.each(function(){
    2733.             jQuery.event.remove( this, type, fn );
    2734.         });
    2735.     },
    2736.     trigger: function( type, data ) {
    2737.         return this.each(function(){
    2738.             jQuery.event.trigger( type, data, this );
    2739.         });
    2740.     },
    2741.     triggerHandler: function( type, data ) {
    2742.         if( this[0] ){
    2743.             var event = jQuery.Event(type);
    2744.             event.preventDefault();
    2745.             event.stopPropagation();
    2746.             jQuery.event.trigger( event, data, this[0] );
    2747.             return event.result;
    2748.         }
    2749.     },
    2750.     toggle: function( fn ) {
    2751.         // Save reference to arguments for access in closure
    2752.         var args = arguments, i = 1;
    2753.         // link all the functions, so any of them can unbind this click handler
    2754.         while( i < args.length )
    2755.             jQuery.event.proxy( fn, args[i++] );
    2756.         return this.click( jQuery.event.proxy( fn, function(event) {
    2757.             // Figure out which function to execute
    2758.             this.lastToggle = ( this.lastToggle || 0 ) % i;
    2759.             // Make sure that clicks stop
    2760.             event.preventDefault();
    2761.             // and execute the function
    2762.             return args[ this.lastToggle++ ].apply( this, arguments ) || false;
    2763.         }));
    2764.     },
    2765.     hover: function(fnOver, fnOut) {
    2766.         return this.mouseenter(fnOver).mouseleave(fnOut);
    2767.     },
    2768.     ready: function(fn) {
    2769.         // Attach the listeners
    2770.         bindReady();
    2771.         // If the DOM is already ready
    2772.         if ( jQuery.isReady )
    2773.             // Execute the function immediately
    2774.             fn.call( document, jQuery );
    2775.         // Otherwise, remember the function for later
    2776.         else
    2777.             // Add the function to the wait list
    2778.             jQuery.readyList.push( fn );
    2779.         return this;
    2780.     },
    2781.     live: function( type, fn ){
    2782.         var proxy = jQuery.event.proxy( fn );
    2783.         proxy.guid += this.selector + type;
    2784.         jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
    2785.         return this;
    2786.     },
    2787.     die: function( type, fn ){
    2788.         jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
    2789.         return this;
    2790.     }
    2791. });
    2792. function liveHandler( event ){
    2793.     var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"),
    2794.         stop = true,
    2795.         elems = [];
    2796.     jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
    2797.         if ( check.test(fn.type) ) {
    2798.             var elem = jQuery(event.target).closest(fn.data)[0];
    2799.             if ( elem )
    2800.                 elems.push({ elem: elem, fn: fn });
    2801.         }
    2802.     });
    2803.     jQuery.each(elems, function(){
    2804.         if ( this.fn.call(this.elem, event, this.fn.data) === false )
    2805.             stop = false;
    2806.     });
    2807.     return stop;
    2808. }
    2809. function liveConvert(type, selector){
    2810.     return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].join(".");
    2811. }
    2812. jQuery.extend({
    2813.     isReady: false,
    2814.     readyList: [],
    2815.     // Handle when the DOM is ready
    2816.     ready: function() {
    2817.         // Make sure that the DOM is not already loaded
    2818.         if ( !jQuery.isReady ) {
    2819.             // Remember that the DOM is ready
    2820.             jQuery.isReady = true;
    2821.             // If there are functions bound, to execute
    2822.             if ( jQuery.readyList ) {
    2823.                 // Execute all of them
    2824.                 jQuery.each( jQuery.readyList, function(){
    2825.                     this.call( document, jQuery );
    2826.                 });
    2827.                 // Reset the list of functions
    2828.                 jQuery.readyList = null;
    2829.             }