]> source.dussan.org Git - jquery.git/commitdiff
Lots of documentation overhaul - much more documented, cat output works better now.
authorJohn Resig <jeresig@gmail.com>
Fri, 1 Sep 2006 05:52:26 +0000 (05:52 +0000)
committerJohn Resig <jeresig@gmail.com>
Fri, 1 Sep 2006 05:52:26 +0000 (05:52 +0000)
build/docs/docs.js
build/docs/js/doc.js
build/docs/style/style.css
build/js/parse.js
build/js/xml.js
src/event/event.js
src/jquery/jquery.js

index 6574f6b04be8d9d09f3a6ea37ae00c7b0ac17926..a40f56a237a8dcded5d44f90d5d3792013fada25 100644 (file)
@@ -23,6 +23,6 @@ function output( c, n ) {
 
        writeFile( dir + "/" + ( n == "docs" ? "index" : n ) + ".xml",
                "<?xml version='1.0' encoding='ISO-8859-1'?>\n" +
-               "<?xml-stylesheet type='text/xsl' href='style/docs.xsl'?>\n" + xml
+               "<?xml-stylesheet type='text/xsl' href='style/" + n + ".xsl'?>\n" + xml
        );
 }
index ec52b664d438e0338973ea7d2aaa88433da05c83..e5f7fcb9adab5ddc1ad75bfb344aa8adec55d003 100644 (file)
@@ -17,9 +17,11 @@ $(document).ready(function(){
        }).ToolTipDemo('#fff');
 
        $("a.name").click(function(){
-               $("div.more,div.short",this.parentNode.parentNode).toggle('slow').find("div.desc",function(){
-                       $(this).html( $(this).html().replace(/\n\n/g, "<br/><br/>") );
-               });
+               $("div.more,div.short",this.parentNode.parentNode)
+                       .find("div.desc",function(){
+                               $(this).html( $(this).html().replace(/\n\n/g, "<br/><br/>") );
+                       })
+                       .toggle('slow');
                return false;
        });
 
index f76e87ef9f75e0a3bce97ec558e77c1670a880ff..d64a601d1b09843edc50f4793a4aeda64c7aeeed 100644 (file)
@@ -116,7 +116,6 @@ ul#docs li div.more {
 }
 
 ul#docs li div.example {
-       overflow: auto;
        border-top: 1px solid #DDD;
        margin-top: 15px;
 }
@@ -130,7 +129,6 @@ ul#docs li div.example pre {
        color: #000;
        background: #EEE;
        padding: 5px;
-       overflow: auto;
        font-size: 0.8em;
 }
 
index c9454d173ce1c36ca361ca2224815542e34f834a..498361d71112fd97a6052281689c6b7d8eea7482 100644 (file)
@@ -69,7 +69,7 @@ function parse( f ) {
 }
 
 function categorize( json ) {
-       var obj = { methods: [] };
+       var obj = { cat: [], method: [] };
 
        for ( var i = 0; i < json.length; i++ ) {
                if ( !json[i].cat ) json[i].cat = "";
@@ -79,17 +79,26 @@ function categorize( json ) {
                var pos = obj;
                for ( var j = 0; j < cat.length; j++ ) {
                        var c = cat[j];
+                       var curCat = null;
+
+                       // Locate current category
+                       for ( var n = 0; n < pos.cat.length; n++ )
+                               if ( pos.cat[n].value == c )
+                                       curCat = pos.cat[n];
 
                        // Create current category
-                       if ( !pos[c] ) pos[c] = { methods: [] };
+                       if ( !curCat ) {
+                               curCat = { value: c, cat: [], method: [] };
+                               pos.cat.push( curCat )
+                       }
 
                        // If we're at  the end, add the method
                        if ( j == cat.length - 1 )
-                               pos[c].methods.push( json[i] );
+                               curCat.method.push( json[i] );
 
                        // Otherwise, traverse deeper
                        else
-                               pos = pos[c];
+                               pos = curCat;
                }
        }
 
index b2b09c6089c876628f8e80268aaa19a24eca46d4..1d50558e1c5c8dadbd107711eed00ea2db4f7dd2 100644 (file)
@@ -9,15 +9,13 @@ Object.toXML = function( obj, tag ) {
     var p = "", child = "";
 
     for ( var i in obj )
-      if ( obj[i].constructor != String || /</.test(obj[i] + "") || Object.toXML.force[i] )
+      if ( ( obj[i].constructor != String && obj[i].constructor != Number ) || /</.test(obj[i] + "") || Object.toXML.force[i] )
         child += Object.toXML( obj[i], i );
       else
         p += " " + i + "='" + (obj[i] + "").replace(/'/g, "&apos;") + "'";
 
     return "<" + tag + p + ( child ?  ">\n" + child + "</" + tag + ">\n" : "/>\n" );
-  } else if ( obj.constructor == String ) {
-    //obj = obj.replace(/&lt;/g,"<").replace(/&gt;/g,">");
-    //return "<" + tag + "><![CDATA[" + obj + "]]></" + tag + ">";
+  } else if ( obj.constructor == String || obj.constructor == Number ) {
     return "<" + tag + ">" + obj + "</" + tag + ">\n";
   }
 
index 051ba00a904c6688212f9822159428cd8b3da592..bbf52a9e3b1be1d7c9dbc1c30d99bb08789a908d 100644 (file)
@@ -153,71 +153,139 @@ jQuery.extend({
 new function(){
 
                /**
-                * Bind a function to the blur event of each matched element.
+                * Bind a function to the scroll event of each matched element.
                 *
-                * @example $("p").blur( function() { alert("Hello"); } );
+                * @example $("p").scroll( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onblur="alert('Hello');">Hello</p>
+                * @result <p onscroll="alert('Hello');">Hello</p>
                 *
-                * @name blur
+                * @name scroll
                 * @type jQuery
-                * @param Function fn A function to bind to the blur event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the scroll event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Trigger the blur event of each matched element. This causes all of the functions
-                * that have been bound to thet blur event to be executed.
+                * Trigger the scroll event of each matched element. This causes all of the functions
+                * that have been bound to thet scroll event to be executed.
                 *
-                * @example $("p").blur();
-                * @before <p onblur="alert('Hello');">Hello</p>
+                * @example $("p").scroll();
+                * @before <p onscroll="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name blur
+                * @name scroll
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the blur event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .blur() method, calling .oneblur() causes the bound function to be
+                * Bind a function to the scroll event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .scroll() method, calling .onescroll() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneblur( function() { alert("Hello"); } );
-                * @before <p onblur="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first blur
+                * @example $("p").onescroll( function() { alert("Hello"); } );
+                * @before <p onscroll="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first scroll
                 *
-                * @name oneblur
+                * @name onescroll
                 * @type jQuery
-                * @param Function fn A function to bind to the blur event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the scroll event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes a bound blur event from each of the matched
+                * Removes a bound scroll event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unblur( myFunction );
-                * @before <p onblur="myFunction">Hello</p>
+                * @example $("p").unscroll( myFunction );
+                * @before <p onscroll="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unblur
+                * @name unscroll
                 * @type jQuery
-                * @param Function fn A function to unbind from the blur event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the scroll event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes all bound blur events from each of the matched elements.
+                * Removes all bound scroll events from each of the matched elements.
                 *
-                * @example $("p").unblur();
-                * @before <p onblur="alert('Hello');">Hello</p>
+                * @example $("p").unscroll();
+                * @before <p onscroll="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unblur
+                * @name unscroll
+                * @type jQuery
+                * @cat Events/Browser
+                */
+
+               /**
+                * Bind a function to the submit event of each matched element.
+                *
+                * @example $("p").submit( function() { alert("Hello"); } );
+                * @before <p>Hello</p>
+                * @result <p onsubmit="alert('Hello');">Hello</p>
+                *
+                * @name submit
+                * @type jQuery
+                * @param Function fn A function to bind to the submit event on each of the matched elements.
+                * @cat Events/Form
+                */
+
+               /**
+                * Trigger the submit event of each matched element. This causes all of the functions
+                * that have been bound to thet submit event to be executed.
+                *
+                * @example $("p").submit();
+                * @before <p onsubmit="alert('Hello');">Hello</p>
+                * @result alert('Hello');
+                *
+                * @name submit
+                * @type jQuery
+                * @cat Events/Form
+                */
+
+               /**
+                * Bind a function to the submit event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .submit() method, calling .onesubmit() causes the bound function to be
+                * only executed the first time it is triggered, and never again (unless it is re-bound).
+                *
+                * @example $("p").onesubmit( function() { alert("Hello"); } );
+                * @before <p onsubmit="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first submit
+                *
+                * @name onesubmit
+                * @type jQuery
+                * @param Function fn A function to bind to the submit event on each of the matched elements.
+                * @cat Events/Form
+                */
+
+               /**
+                * Removes a bound submit event from each of the matched
+                * elements. You must pass the identical function that was used in the original 
+                * bind method.
+                *
+                * @example $("p").unsubmit( myFunction );
+                * @before <p onsubmit="myFunction">Hello</p>
+                * @result <p>Hello</p>
+                *
+                * @name unsubmit
+                * @type jQuery
+                * @param Function fn A function to unbind from the submit event on each of the matched elements.
+                * @cat Events/Form
+                */
+
+               /**
+                * Removes all bound submit events from each of the matched elements.
+                *
+                * @example $("p").unsubmit();
+                * @before <p onsubmit="alert('Hello');">Hello</p>
+                * @result <p>Hello</p>
+                *
+                * @name unsubmit
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
@@ -230,7 +298,7 @@ new function(){
                 * @name focus
                 * @type jQuery
                 * @param Function fn A function to bind to the focus event on each of the matched elements.
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
@@ -243,7 +311,7 @@ new function(){
                 *
                 * @name focus
                 * @type jQuery
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
@@ -258,7 +326,7 @@ new function(){
                 * @name onefocus
                 * @type jQuery
                 * @param Function fn A function to bind to the focus event on each of the matched elements.
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
@@ -273,7 +341,7 @@ new function(){
                 * @name unfocus
                 * @type jQuery
                 * @param Function fn A function to unbind from the focus event on each of the matched elements.
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
@@ -285,483 +353,483 @@ new function(){
                 *
                 * @name unfocus
                 * @type jQuery
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
-                * Bind a function to the load event of each matched element.
+                * Bind a function to the keydown event of each matched element.
                 *
-                * @example $("p").load( function() { alert("Hello"); } );
+                * @example $("p").keydown( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onload="alert('Hello');">Hello</p>
+                * @result <p onkeydown="alert('Hello');">Hello</p>
                 *
-                * @name load
+                * @name keydown
                 * @type jQuery
-                * @param Function fn A function to bind to the load event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the keydown event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Trigger the load event of each matched element. This causes all of the functions
-                * that have been bound to thet load event to be executed.
+                * Trigger the keydown event of each matched element. This causes all of the functions
+                * that have been bound to thet keydown event to be executed.
                 *
-                * @example $("p").load();
-                * @before <p onload="alert('Hello');">Hello</p>
+                * @example $("p").keydown();
+                * @before <p onkeydown="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name load
+                * @name keydown
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Bind a function to the load event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .load() method, calling .oneload() causes the bound function to be
+                * Bind a function to the keydown event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .keydown() method, calling .onekeydown() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneload( function() { alert("Hello"); } );
-                * @before <p onload="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first load
+                * @example $("p").onekeydown( function() { alert("Hello"); } );
+                * @before <p onkeydown="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first keydown
                 *
-                * @name oneload
+                * @name onekeydown
                 * @type jQuery
-                * @param Function fn A function to bind to the load event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the keydown event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Removes a bound load event from each of the matched
+                * Removes a bound keydown event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unload( myFunction );
-                * @before <p onload="myFunction">Hello</p>
+                * @example $("p").unkeydown( myFunction );
+                * @before <p onkeydown="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unload
+                * @name unkeydown
                 * @type jQuery
-                * @param Function fn A function to unbind from the load event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the keydown event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Removes all bound load events from each of the matched elements.
+                * Removes all bound keydown events from each of the matched elements.
                 *
-                * @example $("p").unload();
-                * @before <p onload="alert('Hello');">Hello</p>
+                * @example $("p").unkeydown();
+                * @before <p onkeydown="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unload
+                * @name unkeydown
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Bind a function to the resize event of each matched element.
+                * Bind a function to the dblclick event of each matched element.
                 *
-                * @example $("p").resize( function() { alert("Hello"); } );
+                * @example $("p").dblclick( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onresize="alert('Hello');">Hello</p>
+                * @result <p ondblclick="alert('Hello');">Hello</p>
                 *
-                * @name resize
+                * @name dblclick
                 * @type jQuery
-                * @param Function fn A function to bind to the resize event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the dblclick event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Trigger the resize event of each matched element. This causes all of the functions
-                * that have been bound to thet resize event to be executed.
+                * Trigger the dblclick event of each matched element. This causes all of the functions
+                * that have been bound to thet dblclick event to be executed.
                 *
-                * @example $("p").resize();
-                * @before <p onresize="alert('Hello');">Hello</p>
+                * @example $("p").dblclick();
+                * @before <p ondblclick="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name resize
+                * @name dblclick
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the resize event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .resize() method, calling .oneresize() causes the bound function to be
+                * Bind a function to the dblclick event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .dblclick() method, calling .onedblclick() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneresize( function() { alert("Hello"); } );
-                * @before <p onresize="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first resize
+                * @example $("p").onedblclick( function() { alert("Hello"); } );
+                * @before <p ondblclick="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first dblclick
                 *
-                * @name oneresize
+                * @name onedblclick
                 * @type jQuery
-                * @param Function fn A function to bind to the resize event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the dblclick event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes a bound resize event from each of the matched
+                * Removes a bound dblclick event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unresize( myFunction );
-                * @before <p onresize="myFunction">Hello</p>
+                * @example $("p").undblclick( myFunction );
+                * @before <p ondblclick="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unresize
+                * @name undblclick
                 * @type jQuery
-                * @param Function fn A function to unbind from the resize event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the dblclick event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes all bound resize events from each of the matched elements.
+                * Removes all bound dblclick events from each of the matched elements.
                 *
-                * @example $("p").unresize();
-                * @before <p onresize="alert('Hello');">Hello</p>
+                * @example $("p").undblclick();
+                * @before <p ondblclick="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unresize
+                * @name undblclick
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the scroll event of each matched element.
+                * Bind a function to the keypress event of each matched element.
                 *
-                * @example $("p").scroll( function() { alert("Hello"); } );
+                * @example $("p").keypress( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onscroll="alert('Hello');">Hello</p>
+                * @result <p onkeypress="alert('Hello');">Hello</p>
                 *
-                * @name scroll
+                * @name keypress
                 * @type jQuery
-                * @param Function fn A function to bind to the scroll event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the keypress event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Trigger the scroll event of each matched element. This causes all of the functions
-                * that have been bound to thet scroll event to be executed.
+                * Trigger the keypress event of each matched element. This causes all of the functions
+                * that have been bound to thet keypress event to be executed.
                 *
-                * @example $("p").scroll();
-                * @before <p onscroll="alert('Hello');">Hello</p>
+                * @example $("p").keypress();
+                * @before <p onkeypress="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name scroll
+                * @name keypress
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Bind a function to the scroll event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .scroll() method, calling .onescroll() causes the bound function to be
+                * Bind a function to the keypress event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .keypress() method, calling .onekeypress() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onescroll( function() { alert("Hello"); } );
-                * @before <p onscroll="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first scroll
+                * @example $("p").onekeypress( function() { alert("Hello"); } );
+                * @before <p onkeypress="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first keypress
                 *
-                * @name onescroll
+                * @name onekeypress
                 * @type jQuery
-                * @param Function fn A function to bind to the scroll event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the keypress event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Removes a bound scroll event from each of the matched
+                * Removes a bound keypress event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unscroll( myFunction );
-                * @before <p onscroll="myFunction">Hello</p>
+                * @example $("p").unkeypress( myFunction );
+                * @before <p onkeypress="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unscroll
+                * @name unkeypress
                 * @type jQuery
-                * @param Function fn A function to unbind from the scroll event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the keypress event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Removes all bound scroll events from each of the matched elements.
+                * Removes all bound keypress events from each of the matched elements.
                 *
-                * @example $("p").unscroll();
-                * @before <p onscroll="alert('Hello');">Hello</p>
+                * @example $("p").unkeypress();
+                * @before <p onkeypress="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unscroll
+                * @name unkeypress
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Bind a function to the unload event of each matched element.
+                * Bind a function to the error event of each matched element.
                 *
-                * @example $("p").unload( function() { alert("Hello"); } );
+                * @example $("p").error( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onunload="alert('Hello');">Hello</p>
+                * @result <p onerror="alert('Hello');">Hello</p>
                 *
-                * @name unload
+                * @name error
                 * @type jQuery
-                * @param Function fn A function to bind to the unload event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the error event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Trigger the unload event of each matched element. This causes all of the functions
-                * that have been bound to thet unload event to be executed.
+                * Trigger the error event of each matched element. This causes all of the functions
+                * that have been bound to thet error event to be executed.
                 *
-                * @example $("p").unload();
-                * @before <p onunload="alert('Hello');">Hello</p>
+                * @example $("p").error();
+                * @before <p onerror="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name unload
+                * @name error
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the unload event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .unload() method, calling .oneunload() causes the bound function to be
+                * Bind a function to the error event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .error() method, calling .oneerror() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneunload( function() { alert("Hello"); } );
-                * @before <p onunload="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first unload
+                * @example $("p").oneerror( function() { alert("Hello"); } );
+                * @before <p onerror="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first error
                 *
-                * @name oneunload
+                * @name oneerror
                 * @type jQuery
-                * @param Function fn A function to bind to the unload event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the error event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes a bound unload event from each of the matched
+                * Removes a bound error event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").ununload( myFunction );
-                * @before <p onunload="myFunction">Hello</p>
+                * @example $("p").unerror( myFunction );
+                * @before <p onerror="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name ununload
+                * @name unerror
                 * @type jQuery
-                * @param Function fn A function to unbind from the unload event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the error event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes all bound unload events from each of the matched elements.
+                * Removes all bound error events from each of the matched elements.
                 *
-                * @example $("p").ununload();
-                * @before <p onunload="alert('Hello');">Hello</p>
+                * @example $("p").unerror();
+                * @before <p onerror="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name ununload
+                * @name unerror
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the click event of each matched element.
+                * Bind a function to the blur event of each matched element.
                 *
-                * @example $("p").click( function() { alert("Hello"); } );
+                * @example $("p").blur( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onclick="alert('Hello');">Hello</p>
+                * @result <p onblur="alert('Hello');">Hello</p>
                 *
-                * @name click
+                * @name blur
                 * @type jQuery
-                * @param Function fn A function to bind to the click event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the blur event on each of the matched elements.
+                * @cat Events/UI
                 */
 
                /**
-                * Trigger the click event of each matched element. This causes all of the functions
-                * that have been bound to thet click event to be executed.
+                * Trigger the blur event of each matched element. This causes all of the functions
+                * that have been bound to thet blur event to be executed.
                 *
-                * @example $("p").click();
-                * @before <p onclick="alert('Hello');">Hello</p>
+                * @example $("p").blur();
+                * @before <p onblur="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name click
+                * @name blur
                 * @type jQuery
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
-                * Bind a function to the click event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .click() method, calling .oneclick() causes the bound function to be
+                * Bind a function to the blur event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .blur() method, calling .oneblur() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneclick( function() { alert("Hello"); } );
-                * @before <p onclick="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first click
+                * @example $("p").oneblur( function() { alert("Hello"); } );
+                * @before <p onblur="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first blur
                 *
-                * @name oneclick
+                * @name oneblur
                 * @type jQuery
-                * @param Function fn A function to bind to the click event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the blur event on each of the matched elements.
+                * @cat Events/UI
                 */
 
                /**
-                * Removes a bound click event from each of the matched
+                * Removes a bound blur event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unclick( myFunction );
-                * @before <p onclick="myFunction">Hello</p>
+                * @example $("p").unblur( myFunction );
+                * @before <p onblur="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unclick
+                * @name unblur
                 * @type jQuery
-                * @param Function fn A function to unbind from the click event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the blur event on each of the matched elements.
+                * @cat Events/UI
                 */
 
                /**
-                * Removes all bound click events from each of the matched elements.
+                * Removes all bound blur events from each of the matched elements.
                 *
-                * @example $("p").unclick();
-                * @before <p onclick="alert('Hello');">Hello</p>
+                * @example $("p").unblur();
+                * @before <p onblur="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unclick
+                * @name unblur
                 * @type jQuery
-                * @cat Events
+                * @cat Events/UI
                 */
 
                /**
-                * Bind a function to the dblclick event of each matched element.
+                * Bind a function to the load event of each matched element.
                 *
-                * @example $("p").dblclick( function() { alert("Hello"); } );
+                * @example $("p").load( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p ondblclick="alert('Hello');">Hello</p>
+                * @result <p onload="alert('Hello');">Hello</p>
                 *
-                * @name dblclick
+                * @name load
                 * @type jQuery
-                * @param Function fn A function to bind to the dblclick event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the load event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Trigger the dblclick event of each matched element. This causes all of the functions
-                * that have been bound to thet dblclick event to be executed.
+                * Trigger the load event of each matched element. This causes all of the functions
+                * that have been bound to thet load event to be executed.
                 *
-                * @example $("p").dblclick();
-                * @before <p ondblclick="alert('Hello');">Hello</p>
+                * @example $("p").load();
+                * @before <p onload="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name dblclick
+                * @name load
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the dblclick event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .dblclick() method, calling .onedblclick() causes the bound function to be
+                * Bind a function to the load event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .load() method, calling .oneload() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onedblclick( function() { alert("Hello"); } );
-                * @before <p ondblclick="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first dblclick
+                * @example $("p").oneload( function() { alert("Hello"); } );
+                * @before <p onload="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first load
                 *
-                * @name onedblclick
+                * @name oneload
                 * @type jQuery
-                * @param Function fn A function to bind to the dblclick event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the load event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes a bound dblclick event from each of the matched
+                * Removes a bound load event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").undblclick( myFunction );
-                * @before <p ondblclick="myFunction">Hello</p>
+                * @example $("p").unload( myFunction );
+                * @before <p onload="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name undblclick
+                * @name unload
                 * @type jQuery
-                * @param Function fn A function to unbind from the dblclick event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the load event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes all bound dblclick events from each of the matched elements.
+                * Removes all bound load events from each of the matched elements.
                 *
-                * @example $("p").undblclick();
-                * @before <p ondblclick="alert('Hello');">Hello</p>
+                * @example $("p").unload();
+                * @before <p onload="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name undblclick
+                * @name unload
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the mousedown event of each matched element.
+                * Bind a function to the select event of each matched element.
                 *
-                * @example $("p").mousedown( function() { alert("Hello"); } );
+                * @example $("p").select( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onmousedown="alert('Hello');">Hello</p>
+                * @result <p onselect="alert('Hello');">Hello</p>
                 *
-                * @name mousedown
+                * @name select
                 * @type jQuery
-                * @param Function fn A function to bind to the mousedown event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the select event on each of the matched elements.
+                * @cat Events/Form
                 */
 
                /**
-                * Trigger the mousedown event of each matched element. This causes all of the functions
-                * that have been bound to thet mousedown event to be executed.
+                * Trigger the select event of each matched element. This causes all of the functions
+                * that have been bound to thet select event to be executed.
                 *
-                * @example $("p").mousedown();
-                * @before <p onmousedown="alert('Hello');">Hello</p>
+                * @example $("p").select();
+                * @before <p onselect="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name mousedown
+                * @name select
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
-                * Bind a function to the mousedown event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .mousedown() method, calling .onemousedown() causes the bound function to be
+                * Bind a function to the select event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .select() method, calling .oneselect() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onemousedown( function() { alert("Hello"); } );
-                * @before <p onmousedown="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first mousedown
+                * @example $("p").oneselect( function() { alert("Hello"); } );
+                * @before <p onselect="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first select
                 *
-                * @name onemousedown
+                * @name oneselect
                 * @type jQuery
-                * @param Function fn A function to bind to the mousedown event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the select event on each of the matched elements.
+                * @cat Events/Form
                 */
 
                /**
-                * Removes a bound mousedown event from each of the matched
+                * Removes a bound select event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unmousedown( myFunction );
-                * @before <p onmousedown="myFunction">Hello</p>
+                * @example $("p").unselect( myFunction );
+                * @before <p onselect="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unmousedown
+                * @name unselect
                 * @type jQuery
-                * @param Function fn A function to unbind from the mousedown event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the select event on each of the matched elements.
+                * @cat Events/Form
                 */
 
                /**
-                * Removes all bound mousedown events from each of the matched elements.
+                * Removes all bound select events from each of the matched elements.
                 *
-                * @example $("p").unmousedown();
-                * @before <p onmousedown="alert('Hello');">Hello</p>
+                * @example $("p").unselect();
+                * @before <p onselect="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unmousedown
+                * @name unselect
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
@@ -774,7 +842,7 @@ new function(){
                 * @name mouseup
                 * @type jQuery
                 * @param Function fn A function to bind to the mouseup event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
@@ -787,7 +855,7 @@ new function(){
                 *
                 * @name mouseup
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
@@ -802,7 +870,7 @@ new function(){
                 * @name onemouseup
                 * @type jQuery
                 * @param Function fn A function to bind to the mouseup event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
@@ -817,7 +885,7 @@ new function(){
                 * @name unmouseup
                 * @type jQuery
                 * @param Function fn A function to unbind from the mouseup event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
@@ -829,211 +897,75 @@ new function(){
                 *
                 * @name unmouseup
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the mousemove event of each matched element.
+                * Bind a function to the unload event of each matched element.
                 *
-                * @example $("p").mousemove( function() { alert("Hello"); } );
+                * @example $("p").unload( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onmousemove="alert('Hello');">Hello</p>
+                * @result <p onunload="alert('Hello');">Hello</p>
                 *
-                * @name mousemove
+                * @name unload
                 * @type jQuery
-                * @param Function fn A function to bind to the mousemove event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the unload event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Trigger the mousemove event of each matched element. This causes all of the functions
-                * that have been bound to thet mousemove event to be executed.
+                * Trigger the unload event of each matched element. This causes all of the functions
+                * that have been bound to thet unload event to be executed.
                 *
-                * @example $("p").mousemove();
-                * @before <p onmousemove="alert('Hello');">Hello</p>
+                * @example $("p").unload();
+                * @before <p onunload="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name mousemove
+                * @name unload
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the mousemove event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .mousemove() method, calling .onemousemove() causes the bound function to be
+                * Bind a function to the unload event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .unload() method, calling .oneunload() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onemousemove( function() { alert("Hello"); } );
-                * @before <p onmousemove="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first mousemove
+                * @example $("p").oneunload( function() { alert("Hello"); } );
+                * @before <p onunload="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first unload
                 *
-                * @name onemousemove
+                * @name oneunload
                 * @type jQuery
-                * @param Function fn A function to bind to the mousemove event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Removes a bound mousemove event from each of the matched
-                * elements. You must pass the identical function that was used in the original 
-                * bind method.
-                *
-                * @example $("p").unmousemove( myFunction );
-                * @before <p onmousemove="myFunction">Hello</p>
-                * @result <p>Hello</p>
-                *
-                * @name unmousemove
-                * @type jQuery
-                * @param Function fn A function to unbind from the mousemove event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Removes all bound mousemove events from each of the matched elements.
-                *
-                * @example $("p").unmousemove();
-                * @before <p onmousemove="alert('Hello');">Hello</p>
-                * @result <p>Hello</p>
-                *
-                * @name unmousemove
-                * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the mouseover event of each matched element.
-                *
-                * @example $("p").mouseover( function() { alert("Hello"); } );
-                * @before <p>Hello</p>
-                * @result <p onmouseover="alert('Hello');">Hello</p>
-                *
-                * @name mouseover
-                * @type jQuery
-                * @param Function fn A function to bind to the mouseover event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Trigger the mouseover event of each matched element. This causes all of the functions
-                * that have been bound to thet mouseover event to be executed.
-                *
-                * @example $("p").mouseover();
-                * @before <p onmouseover="alert('Hello');">Hello</p>
-                * @result alert('Hello');
-                *
-                * @name mouseover
-                * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the mouseover event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .mouseover() method, calling .onemouseover() causes the bound function to be
-                * only executed the first time it is triggered, and never again (unless it is re-bound).
-                *
-                * @example $("p").onemouseover( function() { alert("Hello"); } );
-                * @before <p onmouseover="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first mouseover
-                *
-                * @name onemouseover
-                * @type jQuery
-                * @param Function fn A function to bind to the mouseover event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Removes a bound mouseover event from each of the matched
-                * elements. You must pass the identical function that was used in the original 
-                * bind method.
-                *
-                * @example $("p").unmouseover( myFunction );
-                * @before <p onmouseover="myFunction">Hello</p>
-                * @result <p>Hello</p>
-                *
-                * @name unmouseover
-                * @type jQuery
-                * @param Function fn A function to unbind from the mouseover event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Removes all bound mouseover events from each of the matched elements.
-                *
-                * @example $("p").unmouseover();
-                * @before <p onmouseover="alert('Hello');">Hello</p>
-                * @result <p>Hello</p>
-                *
-                * @name unmouseover
-                * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the mouseout event of each matched element.
-                *
-                * @example $("p").mouseout( function() { alert("Hello"); } );
-                * @before <p>Hello</p>
-                * @result <p onmouseout="alert('Hello');">Hello</p>
-                *
-                * @name mouseout
-                * @type jQuery
-                * @param Function fn A function to bind to the mouseout event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Trigger the mouseout event of each matched element. This causes all of the functions
-                * that have been bound to thet mouseout event to be executed.
-                *
-                * @example $("p").mouseout();
-                * @before <p onmouseout="alert('Hello');">Hello</p>
-                * @result alert('Hello');
-                *
-                * @name mouseout
-                * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the mouseout event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .mouseout() method, calling .onemouseout() causes the bound function to be
-                * only executed the first time it is triggered, and never again (unless it is re-bound).
-                *
-                * @example $("p").onemouseout( function() { alert("Hello"); } );
-                * @before <p onmouseout="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first mouseout
-                *
-                * @name onemouseout
-                * @type jQuery
-                * @param Function fn A function to bind to the mouseout event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the unload event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes a bound mouseout event from each of the matched
+                * Removes a bound unload event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unmouseout( myFunction );
-                * @before <p onmouseout="myFunction">Hello</p>
+                * @example $("p").ununload( myFunction );
+                * @before <p onunload="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unmouseout
+                * @name ununload
                 * @type jQuery
-                * @param Function fn A function to unbind from the mouseout event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the unload event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes all bound mouseout events from each of the matched elements.
+                * Removes all bound unload events from each of the matched elements.
                 *
-                * @example $("p").unmouseout();
-                * @before <p onmouseout="alert('Hello');">Hello</p>
+                * @example $("p").ununload();
+                * @before <p onunload="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unmouseout
+                * @name ununload
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
@@ -1046,7 +978,7 @@ new function(){
                 * @name change
                 * @type jQuery
                 * @param Function fn A function to bind to the change event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
@@ -1059,7 +991,7 @@ new function(){
                 *
                 * @name change
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
@@ -1074,7 +1006,7 @@ new function(){
                 * @name onechange
                 * @type jQuery
                 * @param Function fn A function to bind to the change event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
@@ -1089,7 +1021,7 @@ new function(){
                 * @name unchange
                 * @type jQuery
                 * @param Function fn A function to unbind from the change event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
@@ -1101,483 +1033,415 @@ new function(){
                 *
                 * @name unchange
                 * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the reset event of each matched element.
-                *
-                * @example $("p").reset( function() { alert("Hello"); } );
-                * @before <p>Hello</p>
-                * @result <p onreset="alert('Hello');">Hello</p>
-                *
-                * @name reset
-                * @type jQuery
-                * @param Function fn A function to bind to the reset event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Trigger the reset event of each matched element. This causes all of the functions
-                * that have been bound to thet reset event to be executed.
-                *
-                * @example $("p").reset();
-                * @before <p onreset="alert('Hello');">Hello</p>
-                * @result alert('Hello');
-                *
-                * @name reset
-                * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the reset event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .reset() method, calling .onereset() causes the bound function to be
-                * only executed the first time it is triggered, and never again (unless it is re-bound).
-                *
-                * @example $("p").onereset( function() { alert("Hello"); } );
-                * @before <p onreset="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first reset
-                *
-                * @name onereset
-                * @type jQuery
-                * @param Function fn A function to bind to the reset event on each of the matched elements.
-                * @cat Events
+                * @cat Events/Form
                 */
 
                /**
-                * Removes a bound reset event from each of the matched
-                * elements. You must pass the identical function that was used in the original 
-                * bind method.
-                *
-                * @example $("p").unreset( myFunction );
-                * @before <p onreset="myFunction">Hello</p>
-                * @result <p>Hello</p>
-                *
-                * @name unreset
-                * @type jQuery
-                * @param Function fn A function to unbind from the reset event on each of the matched elements.
-                * @cat Events
-                */
-
-               /**
-                * Removes all bound reset events from each of the matched elements.
-                *
-                * @example $("p").unreset();
-                * @before <p onreset="alert('Hello');">Hello</p>
-                * @result <p>Hello</p>
-                *
-                * @name unreset
-                * @type jQuery
-                * @cat Events
-                */
-
-               /**
-                * Bind a function to the select event of each matched element.
+                * Bind a function to the mouseout event of each matched element.
                 *
-                * @example $("p").select( function() { alert("Hello"); } );
+                * @example $("p").mouseout( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onselect="alert('Hello');">Hello</p>
+                * @result <p onmouseout="alert('Hello');">Hello</p>
                 *
-                * @name select
+                * @name mouseout
                 * @type jQuery
-                * @param Function fn A function to bind to the select event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the mouseout event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Trigger the select event of each matched element. This causes all of the functions
-                * that have been bound to thet select event to be executed.
+                * Trigger the mouseout event of each matched element. This causes all of the functions
+                * that have been bound to thet mouseout event to be executed.
                 *
-                * @example $("p").select();
-                * @before <p onselect="alert('Hello');">Hello</p>
+                * @example $("p").mouseout();
+                * @before <p onmouseout="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name select
+                * @name mouseout
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the select event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .select() method, calling .oneselect() causes the bound function to be
+                * Bind a function to the mouseout event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .mouseout() method, calling .onemouseout() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneselect( function() { alert("Hello"); } );
-                * @before <p onselect="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first select
+                * @example $("p").onemouseout( function() { alert("Hello"); } );
+                * @before <p onmouseout="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first mouseout
                 *
-                * @name oneselect
+                * @name onemouseout
                 * @type jQuery
-                * @param Function fn A function to bind to the select event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the mouseout event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes a bound select event from each of the matched
+                * Removes a bound mouseout event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unselect( myFunction );
-                * @before <p onselect="myFunction">Hello</p>
+                * @example $("p").unmouseout( myFunction );
+                * @before <p onmouseout="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unselect
+                * @name unmouseout
                 * @type jQuery
-                * @param Function fn A function to unbind from the select event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the mouseout event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes all bound select events from each of the matched elements.
+                * Removes all bound mouseout events from each of the matched elements.
                 *
-                * @example $("p").unselect();
-                * @before <p onselect="alert('Hello');">Hello</p>
+                * @example $("p").unmouseout();
+                * @before <p onmouseout="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unselect
+                * @name unmouseout
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the submit event of each matched element.
+                * Bind a function to the keyup event of each matched element.
                 *
-                * @example $("p").submit( function() { alert("Hello"); } );
+                * @example $("p").keyup( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onsubmit="alert('Hello');">Hello</p>
+                * @result <p onkeyup="alert('Hello');">Hello</p>
                 *
-                * @name submit
+                * @name keyup
                 * @type jQuery
-                * @param Function fn A function to bind to the submit event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the keyup event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Trigger the submit event of each matched element. This causes all of the functions
-                * that have been bound to thet submit event to be executed.
+                * Trigger the keyup event of each matched element. This causes all of the functions
+                * that have been bound to thet keyup event to be executed.
                 *
-                * @example $("p").submit();
-                * @before <p onsubmit="alert('Hello');">Hello</p>
+                * @example $("p").keyup();
+                * @before <p onkeyup="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name submit
+                * @name keyup
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Bind a function to the submit event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .submit() method, calling .onesubmit() causes the bound function to be
+                * Bind a function to the keyup event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .keyup() method, calling .onekeyup() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onesubmit( function() { alert("Hello"); } );
-                * @before <p onsubmit="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first submit
+                * @example $("p").onekeyup( function() { alert("Hello"); } );
+                * @before <p onkeyup="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first keyup
                 *
-                * @name onesubmit
+                * @name onekeyup
                 * @type jQuery
-                * @param Function fn A function to bind to the submit event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the keyup event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Removes a bound submit event from each of the matched
+                * Removes a bound keyup event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unsubmit( myFunction );
-                * @before <p onsubmit="myFunction">Hello</p>
+                * @example $("p").unkeyup( myFunction );
+                * @before <p onkeyup="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unsubmit
+                * @name unkeyup
                 * @type jQuery
-                * @param Function fn A function to unbind from the submit event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the keyup event on each of the matched elements.
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Removes all bound submit events from each of the matched elements.
+                * Removes all bound keyup events from each of the matched elements.
                 *
-                * @example $("p").unsubmit();
-                * @before <p onsubmit="alert('Hello');">Hello</p>
+                * @example $("p").unkeyup();
+                * @before <p onkeyup="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unsubmit
+                * @name unkeyup
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Keyboard
                 */
 
                /**
-                * Bind a function to the keydown event of each matched element.
+                * Bind a function to the click event of each matched element.
                 *
-                * @example $("p").keydown( function() { alert("Hello"); } );
+                * @example $("p").click( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onkeydown="alert('Hello');">Hello</p>
+                * @result <p onclick="alert('Hello');">Hello</p>
                 *
-                * @name keydown
+                * @name click
                 * @type jQuery
-                * @param Function fn A function to bind to the keydown event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the click event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Trigger the keydown event of each matched element. This causes all of the functions
-                * that have been bound to thet keydown event to be executed.
+                * Trigger the click event of each matched element. This causes all of the functions
+                * that have been bound to thet click event to be executed.
                 *
-                * @example $("p").keydown();
-                * @before <p onkeydown="alert('Hello');">Hello</p>
+                * @example $("p").click();
+                * @before <p onclick="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name keydown
+                * @name click
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the keydown event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .keydown() method, calling .onekeydown() causes the bound function to be
+                * Bind a function to the click event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .click() method, calling .oneclick() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onekeydown( function() { alert("Hello"); } );
-                * @before <p onkeydown="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first keydown
+                * @example $("p").oneclick( function() { alert("Hello"); } );
+                * @before <p onclick="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first click
                 *
-                * @name onekeydown
+                * @name oneclick
                 * @type jQuery
-                * @param Function fn A function to bind to the keydown event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the click event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes a bound keydown event from each of the matched
+                * Removes a bound click event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unkeydown( myFunction );
-                * @before <p onkeydown="myFunction">Hello</p>
+                * @example $("p").unclick( myFunction );
+                * @before <p onclick="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unkeydown
+                * @name unclick
                 * @type jQuery
-                * @param Function fn A function to unbind from the keydown event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the click event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes all bound keydown events from each of the matched elements.
+                * Removes all bound click events from each of the matched elements.
                 *
-                * @example $("p").unkeydown();
-                * @before <p onkeydown="alert('Hello');">Hello</p>
+                * @example $("p").unclick();
+                * @before <p onclick="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unkeydown
+                * @name unclick
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the keypress event of each matched element.
+                * Bind a function to the resize event of each matched element.
                 *
-                * @example $("p").keypress( function() { alert("Hello"); } );
+                * @example $("p").resize( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onkeypress="alert('Hello');">Hello</p>
+                * @result <p onresize="alert('Hello');">Hello</p>
                 *
-                * @name keypress
+                * @name resize
                 * @type jQuery
-                * @param Function fn A function to bind to the keypress event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the resize event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Trigger the keypress event of each matched element. This causes all of the functions
-                * that have been bound to thet keypress event to be executed.
+                * Trigger the resize event of each matched element. This causes all of the functions
+                * that have been bound to thet resize event to be executed.
                 *
-                * @example $("p").keypress();
-                * @before <p onkeypress="alert('Hello');">Hello</p>
+                * @example $("p").resize();
+                * @before <p onresize="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name keypress
+                * @name resize
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the keypress event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .keypress() method, calling .onekeypress() causes the bound function to be
+                * Bind a function to the resize event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .resize() method, calling .oneresize() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onekeypress( function() { alert("Hello"); } );
-                * @before <p onkeypress="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first keypress
+                * @example $("p").oneresize( function() { alert("Hello"); } );
+                * @before <p onresize="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first resize
                 *
-                * @name onekeypress
+                * @name oneresize
                 * @type jQuery
-                * @param Function fn A function to bind to the keypress event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the resize event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes a bound keypress event from each of the matched
+                * Removes a bound resize event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unkeypress( myFunction );
-                * @before <p onkeypress="myFunction">Hello</p>
+                * @example $("p").unresize( myFunction );
+                * @before <p onresize="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unkeypress
+                * @name unresize
                 * @type jQuery
-                * @param Function fn A function to unbind from the keypress event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the resize event on each of the matched elements.
+                * @cat Events/Browser
                 */
 
                /**
-                * Removes all bound keypress events from each of the matched elements.
+                * Removes all bound resize events from each of the matched elements.
                 *
-                * @example $("p").unkeypress();
-                * @before <p onkeypress="alert('Hello');">Hello</p>
+                * @example $("p").unresize();
+                * @before <p onresize="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unkeypress
+                * @name unresize
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Browser
                 */
 
                /**
-                * Bind a function to the keyup event of each matched element.
+                * Bind a function to the mousemove event of each matched element.
                 *
-                * @example $("p").keyup( function() { alert("Hello"); } );
+                * @example $("p").mousemove( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onkeyup="alert('Hello');">Hello</p>
+                * @result <p onmousemove="alert('Hello');">Hello</p>
                 *
-                * @name keyup
+                * @name mousemove
                 * @type jQuery
-                * @param Function fn A function to bind to the keyup event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the mousemove event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Trigger the keyup event of each matched element. This causes all of the functions
-                * that have been bound to thet keyup event to be executed.
+                * Trigger the mousemove event of each matched element. This causes all of the functions
+                * that have been bound to thet mousemove event to be executed.
                 *
-                * @example $("p").keyup();
-                * @before <p onkeyup="alert('Hello');">Hello</p>
+                * @example $("p").mousemove();
+                * @before <p onmousemove="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name keyup
+                * @name mousemove
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the keyup event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .keyup() method, calling .onekeyup() causes the bound function to be
+                * Bind a function to the mousemove event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .mousemove() method, calling .onemousemove() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").onekeyup( function() { alert("Hello"); } );
-                * @before <p onkeyup="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first keyup
+                * @example $("p").onemousemove( function() { alert("Hello"); } );
+                * @before <p onmousemove="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first mousemove
                 *
-                * @name onekeyup
+                * @name onemousemove
                 * @type jQuery
-                * @param Function fn A function to bind to the keyup event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the mousemove event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes a bound keyup event from each of the matched
+                * Removes a bound mousemove event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unkeyup( myFunction );
-                * @before <p onkeyup="myFunction">Hello</p>
+                * @example $("p").unmousemove( myFunction );
+                * @before <p onmousemove="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unkeyup
+                * @name unmousemove
                 * @type jQuery
-                * @param Function fn A function to unbind from the keyup event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the mousemove event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes all bound keyup events from each of the matched elements.
+                * Removes all bound mousemove events from each of the matched elements.
                 *
-                * @example $("p").unkeyup();
-                * @before <p onkeyup="alert('Hello');">Hello</p>
+                * @example $("p").unmousemove();
+                * @before <p onmousemove="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unkeyup
+                * @name unmousemove
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the error event of each matched element.
+                * Bind a function to the mousedown event of each matched element.
                 *
-                * @example $("p").error( function() { alert("Hello"); } );
+                * @example $("p").mousedown( function() { alert("Hello"); } );
                 * @before <p>Hello</p>
-                * @result <p onerror="alert('Hello');">Hello</p>
+                * @result <p onmousedown="alert('Hello');">Hello</p>
                 *
-                * @name error
+                * @name mousedown
                 * @type jQuery
-                * @param Function fn A function to bind to the error event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the mousedown event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Trigger the error event of each matched element. This causes all of the functions
-                * that have been bound to thet error event to be executed.
+                * Trigger the mousedown event of each matched element. This causes all of the functions
+                * that have been bound to thet mousedown event to be executed.
                 *
-                * @example $("p").error();
-                * @before <p onerror="alert('Hello');">Hello</p>
+                * @example $("p").mousedown();
+                * @before <p onmousedown="alert('Hello');">Hello</p>
                 * @result alert('Hello');
                 *
-                * @name error
+                * @name mousedown
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
                /**
-                * Bind a function to the error event of each matched element, which will only be executed once.
-                * Unlike a call to the normal .error() method, calling .oneerror() causes the bound function to be
+                * Bind a function to the mousedown event of each matched element, which will only be executed once.
+                * Unlike a call to the normal .mousedown() method, calling .onemousedown() causes the bound function to be
                 * only executed the first time it is triggered, and never again (unless it is re-bound).
                 *
-                * @example $("p").oneerror( function() { alert("Hello"); } );
-                * @before <p onerror="alert('Hello');">Hello</p>
-                * @result alert('Hello'); // Only executed for the first error
+                * @example $("p").onemousedown( function() { alert("Hello"); } );
+                * @before <p onmousedown="alert('Hello');">Hello</p>
+                * @result alert('Hello'); // Only executed for the first mousedown
                 *
-                * @name oneerror
+                * @name onemousedown
                 * @type jQuery
-                * @param Function fn A function to bind to the error event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to bind to the mousedown event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes a bound error event from each of the matched
+                * Removes a bound mousedown event from each of the matched
                 * elements. You must pass the identical function that was used in the original 
                 * bind method.
                 *
-                * @example $("p").unerror( myFunction );
-                * @before <p onerror="myFunction">Hello</p>
+                * @example $("p").unmousedown( myFunction );
+                * @before <p onmousedown="myFunction">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unerror
+                * @name unmousedown
                 * @type jQuery
-                * @param Function fn A function to unbind from the error event on each of the matched elements.
-                * @cat Events
+                * @param Function fn A function to unbind from the mousedown event on each of the matched elements.
+                * @cat Events/Mouse
                 */
 
                /**
-                * Removes all bound error events from each of the matched elements.
+                * Removes all bound mousedown events from each of the matched elements.
                 *
-                * @example $("p").unerror();
-                * @before <p onerror="alert('Hello');">Hello</p>
+                * @example $("p").unmousedown();
+                * @before <p onmousedown="alert('Hello');">Hello</p>
                 * @result <p>Hello</p>
                 *
-                * @name unerror
+                * @name unmousedown
                 * @type jQuery
-                * @cat Events
+                * @cat Events/Mouse
                 */
 
        var e = ("blur,focus,load,resize,scroll,unload,click,dblclick," +
index c3975e3023fe6ead726c856e864dd39617b59ecc..467c0748168d18f5daa439c587007e1404b83d8e 100644 (file)
@@ -26,6 +26,7 @@ window.undefined = window.undefined;
  * @constructor
  * @private
  * @name jQuery
+ * @cat Core
  */
 function jQuery(a,c) {
 
@@ -112,7 +113,7 @@ if ( typeof $ != "undefined" )
  *
  * @name $
  * @param String expr An expression to search with.
- * @param DOMElement context A DOM Element, or Document, representing the base context.
+ * @param Element context A DOM Element, or Document, representing the base context.
  * @cat Core
  * @type jQuery
  */
@@ -131,7 +132,7 @@ if ( typeof $ != "undefined" )
  * be manipulated.
  *
  * @name $
- * @param DOMElement elem A DOM element to be encapsulated by a jQuery object.
+ * @param Element elem A DOM element to be encapsulated by a jQuery object.
  * @cat Core
  * @type jQuery
  */
@@ -143,7 +144,7 @@ if ( typeof $ != "undefined" )
  * @desc Hides all the input elements within a form
  *
  * @name $
- * @param Array<DOMElement> elems An array of DOM elements to be encapsulated by a jQuery object.
+ * @param Array<Element> elems An array of DOM elements to be encapsulated by a jQuery object.
  * @cat Core
  * @type jQuery
  */
@@ -493,9 +494,10 @@ jQuery.fn = jQuery.prototype = {
         * stucture into a document, without ruining the original semantic
         * qualities of a document.
         *
-        * The way that is works is that it goes through the first element argument
-        * provided and finds the deepest element within the structure - it is that
-        * element that will en-wrap everything else.
+        * This works by going through the first element 
+        * provided (which is generated, on the fly, from the provided HTML)
+        * and finds the deepest ancestor element within its 
+        * structure - it is that element that will en-wrap everything else.
         *
         * @example $("p").wrap("<div class='wrap'></div>");
         * @before <p>Test Paragraph.</p>
@@ -503,10 +505,27 @@ jQuery.fn = jQuery.prototype = {
         *
         * @name wrap
         * @type jQuery
-        * @any String html A string of HTML, that will be created on the fly and wrapped around the target.
-        * @any Element elem A DOM element that will be wrapped.
-        * @any Array<Element> elems An array of elements, the first of which will be wrapped.
-        * @any Object obj Any object, converted to a string, then a text node.
+        * @param String html A string of HTML, that will be created on the fly and wrapped around the target.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Wrap all matched elements with a structure of other elements.
+        * This wrapping process is most useful for injecting additional
+        * stucture into a document, without ruining the original semantic
+        * qualities of a document.
+        *
+        * This works by going through the first element 
+        * provided and finding the deepest ancestor element within its 
+        * structure - it is that element that will en-wrap everything else.
+        *
+        * @example $("p").wrap("<div class='wrap'></div>");
+        * @before <p>Test Paragraph.</p>
+        * @result <div class='wrap'><p>Test Paragraph.</p></div>
+        *
+        * @name wrap
+        * @type jQuery
+        * @param Element elem A DOM element that will be wrapped.
         * @cat DOM/Manipulation
         */
        wrap: function() {
@@ -531,7 +550,8 @@ jQuery.fn = jQuery.prototype = {
        },
        
        /**
-        * Append any number of elements to the inside of all matched elements.
+        * Append any number of elements to the inside of every matched elements,
+        * generated from the provided HTML.
         * This operation is similar to doing an appendChild to all the 
         * specified elements, adding them into the document.
         * 
@@ -541,10 +561,37 @@ jQuery.fn = jQuery.prototype = {
         *
         * @name append
         * @type jQuery
-        * @any String html A string of HTML, that will be created on the fly and appended to the target.
-        * @any Element elem A DOM element that will be appended.
-        * @any Array<Element> elems An array of elements, all of which will be appended.
-        * @any Object obj Any object, converted to a string, then a text node.
+        * @param String html A string of HTML, that will be created on the fly and appended to the target.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Append an element to the inside of all matched elements.
+        * This operation is similar to doing an appendChild to all the 
+        * specified elements, adding them into the document.
+        * 
+        * @example $("p").append( $("#foo")[0] );
+        * @before <p>I would like to say: </p><b id="foo">Hello</b>
+        * @result <p>I would like to say: <b id="foo">Hello</b></p>
+        *
+        * @name append
+        * @type jQuery
+        * @param Element elem A DOM element that will be appended.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Append any number of elements to the inside of all matched elements.
+        * This operation is similar to doing an appendChild to all the 
+        * specified elements, adding them into the document.
+        * 
+        * @example $("p").append( $("b") );
+        * @before <p>I would like to say: </p><b>Hello</b>
+        * @result <p>I would like to say: <b>Hello</b></p>
+        *
+        * @name append
+        * @type jQuery
+        * @param Array<Element> elems An array of elements, all of which will be appended.
         * @cat DOM/Manipulation
         */
        append: function() {
@@ -554,20 +601,48 @@ jQuery.fn = jQuery.prototype = {
        },
        
        /**
-        * Prepend any number of elements to the inside of all matched elements.
+        * Prepend any number of elements to the inside of every matched elements,
+        * generated from the provided HTML.
+        * This operation is the best way to insert dynamically created elements 
+        * inside, at the beginning, of all the matched element.
+        * 
+        * @example $("p").prepend("<b>Hello</b>");
+        * @before <p>I would like to say: </p>
+        * @result <p><b>Hello</b>I would like to say: </p>
+        *
+        * @name prepend
+        * @type jQuery
+        * @param String html A string of HTML, that will be created on the fly and appended to the target.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Append an element to the inside of all matched elements.
+        * This operation is the best way to insert an element inside, at the 
+        * beginning, of all the matched element.
+        * 
+        * @example $("p").prepend( $("#foo")[0] );
+        * @before <p>I would like to say: </p><b id="foo">Hello</b>
+        * @result <p><b id="foo">Hello</b>I would like to say: </p>
+        *
+        * @name prepend
+        * @type jQuery
+        * @param Element elem A DOM element that will be appended.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Append any number of elements to the inside of all matched elements.
         * This operation is the best way to insert a set of elements inside, at the 
         * beginning, of all the matched element.
         * 
-        * @example $("p").prepend("<b>Hello</b>");
-        * @before <p>, how are you?</p>
-        * @result <p><b>Hello</b>, how are you?</p>
+        * @example $("p").prepend( $("b") );
+        * @before <p>I would like to say: </p><b>Hello</b>
+        * @result <p><b>Hello</b>I would like to say: </p>
         *
         * @name prepend
         * @type jQuery
-        * @any String html A string of HTML, that will be created on the fly and prepended to the target.
-        * @any Element elem A DOM element that will be prepended.
-        * @any Array<Element> elems An array of elements, all of which will be prepended.
-        * @any Object obj Any object, converted to a string, then a text node.
+        * @param Array<Element> elems An array of elements, all of which will be appended.
         * @cat DOM/Manipulation
         */
        prepend: function() {
@@ -577,18 +652,42 @@ jQuery.fn = jQuery.prototype = {
        },
        
        /**
-        * Insert any number of elements before each of the matched elements.
+        * Insert any number of dynamically generated elements before each of the 
+        * matched elements.
         * 
         * @example $("p").before("<b>Hello</b>");
-        * @before <p>how are you?</p>
-        * @result <b>Hello</b><p>how are you?</p>
+        * @before <p>I would like to say: </p>
+        * @result <b>Hello</b><p>I would like to say: </p>
+        *
+        * @name before
+        * @type jQuery
+        * @param String html A string of HTML, that will be created on the fly and appended to the target.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Insert an element before each of the matched elements.
+        * 
+        * @example $("p").before( $("#foo")[0] );
+        * @before <p>I would like to say: </p><b id="foo">Hello</b>
+        * @result <b id="foo">Hello</b><p>I would like to say: </p>
         *
         * @name before
         * @type jQuery
-        * @any String html A string of HTML, that will be created on the fly and inserted.
-        * @any Element elem A DOM element that will beinserted.
-        * @any Array<Element> elems An array of elements, all of which will be inserted.
-        * @any Object obj Any object, converted to a string, then a text node.
+        * @param Element elem A DOM element that will be appended.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Insert any number of elements before each of the matched elements.
+        * 
+        * @example $("p").before( $("b") );
+        * @before <p>I would like to say: </p><b>Hello</b>
+        * @result <b>Hello</b><p>I would like to say: </p>
+        *
+        * @name before
+        * @type jQuery
+        * @param Array<Element> elems An array of elements, all of which will be appended.
         * @cat DOM/Manipulation
         */
        before: function() {
@@ -597,19 +696,43 @@ jQuery.fn = jQuery.prototype = {
                });
        },
        
+       /**
+        * Insert any number of dynamically generated elements after each of the 
+        * matched elements.
+        * 
+        * @example $("p").after("<b>Hello</b>");
+        * @before <p>I would like to say: </p>
+        * @result <p>I would like to say: </p><b>Hello</b>
+        *
+        * @name after
+        * @type jQuery
+        * @param String html A string of HTML, that will be created on the fly and appended to the target.
+        * @cat DOM/Manipulation
+        */
+        
+       /**
+        * Insert an element after each of the matched elements.
+        * 
+        * @example $("p").after( $("#foo")[0] );
+        * @before <b id="foo">Hello</b><p>I would like to say: </p>
+        * @result <p>I would like to say: </p><b id="foo">Hello</b>
+        *
+        * @name after
+        * @type jQuery
+        * @param Element elem A DOM element that will be appended.
+        * @cat DOM/Manipulation
+        */
+        
        /**
         * Insert any number of elements after each of the matched elements.
         * 
-        * @example $("p").after("<p>I'm doing fine.</p>");
-        * @before <p>How are you?</p>
-        * @result <p>How are you?</p><p>I'm doing fine.</p>
+        * @example $("p").after( $("b") );
+        * @before <b>Hello</b><p>I would like to say: </p>
+        * @result <p>I would like to say: </p><b>Hello</b>
         *
         * @name after
         * @type jQuery
-        * @any String html A string of HTML, that will be created on the fly and inserted.
-        * @any Element elem A DOM element that will beinserted.
-        * @any Array<Element> elems An array of elements, all of which will be inserted.
-        * @any Object obj Any object, converted to a string, then a text node.
+        * @param Array<Element> elems An array of elements, all of which will be appended.
         * @cat DOM/Manipulation
         */
        after: function() {
@@ -823,6 +946,7 @@ jQuery.fn = jQuery.prototype = {
         * @param Number int
         * @param Function fn The function doing the DOM manipulation.
         * @type jQuery
+        * @cat Core
         */
        domManip: function(args, table, dir, fn){
                var clone = this.size() > 1;
@@ -856,6 +980,7 @@ jQuery.fn = jQuery.prototype = {
         * @param Array a
         * @param Array args
         * @type jQuery
+        * @cat Core
         */
        pushStack: function(a,args) {
                var fn = args && args[args.length-1];
@@ -882,15 +1007,15 @@ jQuery.fn = jQuery.prototype = {
  * @private
  * @name extend
  * @param Object obj
- * @param Object prop
  * @type Object
+ * @cat Core
  */
  
 /**
  * Extend one object with another, returning the original,
  * modified, object. This is a great utility for simple inheritance.
  *
- * @name jQuery.extend
+ * @name $.extend
  * @param Object obj The object to extend
  * @param Object prop The object that will be merged into the first.
  * @type Object
@@ -907,6 +1032,7 @@ jQuery.extend({
         * @private
         * @name init
         * @type undefined
+        * @cat Core
         */
        init: function(){
                jQuery.initDone = true;
@@ -965,7 +1091,7 @@ jQuery.extend({
         * A generic iterator function, which can be used to seemlessly
         * iterate over both objects and arrays.
         *
-        * @name jQuery.each
+        * @name $.each
         * @param Object obj The object, or array, to iterate over.
         * @param Object fn The function that will be executed on every object.
         * @type Object
@@ -1264,8 +1390,10 @@ jQuery.extend({
         * @test t( "Is Visible", "input:visible", ["text1","text2","radio1","radio2","check1","check2"] );
         * @test t( "Is Hidden", "input:hidden", ["hidden1","hidden2"] );
         *
-        * @name jQuery.find
+        * @name $.find
+        * @type Array<Element>
         * @private
+        * @cat Core
         */
        find: function( t, context ) {
                // Make sure that the context is a DOM Element
@@ -1466,10 +1594,10 @@ jQuery.extend({
        /**
         * Remove the whitespace from the beginning and end of a string.
         *
-        * @private
-        * @name jQuery.trim
+        * @name $.trim
         * @type String
         * @param String str The string to trim.
+        * @cat Javascript
         */
        trim: function(t){
                return t.replace(/^\s+|\s+$/g, "");
@@ -1479,9 +1607,10 @@ jQuery.extend({
         * All ancestors of a given element.
         *
         * @private
-        * @name jQuery.parents
+        * @name $.parents
         * @type Array<Element>
         * @param Element elem The element to find the ancestors of.
+        * @cat DOM/Traversing
         */
        parents: function( elem ){
                var matched = [];
@@ -1497,9 +1626,10 @@ jQuery.extend({
         * All elements on a specified axis.
         *
         * @private
-        * @name jQuery.sibling
+        * @name $.sibling
         * @type Array
         * @param Element elem The element to find all the siblings of (including itself).
+        * @cat DOM/Traversing
         */
        sibling: function(elem, pos, not) {
                var elems = [];
@@ -1525,11 +1655,11 @@ jQuery.extend({
        /**
         * Merge two arrays together, removing all duplicates.
         *
-        * @private
-        * @name jQuery.merge
+        * @name $.merge
         * @type Array
         * @param Array a The first array to merge.
         * @param Array b The second array to merge.
+        * @cat Javascript
         */
        merge: function(first, second) {
                var result = [];
@@ -1562,12 +1692,12 @@ jQuery.extend({
         * in to this method will be passed two arguments: 'a' (which is the
         * array item) and 'i' (which is the index of the item in the array).
         *
-        * @private
-        * @name jQuery.grep
+        * @name $.grep
         * @type Array
         * @param Array array The Array to find items in.
         * @param Function fn The function to process each item against.
         * @param Boolean inv Invert the selection - select the opposite of the function.
+        * @cat Javascript
         */
        grep: function(elems, fn, inv) {
                // If a string is passed in for the function, make a function
@@ -1594,11 +1724,11 @@ jQuery.extend({
         * from the array. Both of these changes imply that the size of the array may not
         * be the same size upon completion, as it was when it started.
         *
-        * @private
-        * @name jQuery.map
+        * @name $.map
         * @type Array
         * @param Array array The Array to translate.
         * @param Function fn The function to process each item against.
+        * @cat Javascript
         */
        map: function(elems, fn) {
                // If a string is passed in for the function, make a function