.ajaxError()

" ).appendTo( document.body ); } -$( "div" ).click(function() { +$( "div" ).on( "click", function() { $( this ).hide( 2000, function() { $( this ).remove(); }); diff --git a/entries/hover.xml b/entries/hover.xml index fcfdd377d..a924d368f 100644 --- a/entries/hover.xml +++ b/entries/hover.xml @@ -1,25 +1,30 @@ Bind one or two handlers to the matched elements, to be executed when the mouse pointer enters and leaves the elements. - + .hover() Bind two handlers to the matched elements, to be executed when the mouse pointer enters and leaves the elements. 1.0 - - A function to execute when the mouse pointer enters the element. + + + A function to execute when the mouse pointer enters the element. - - A function to execute when the mouse pointer leaves the element. + + + A function to execute when the mouse pointer leaves the element. +

This API is deprecated. Use .on( "mouseenter", handlerIn ).on( "mouseleave", handlerOut ) instead.

The .hover() method binds handlers for both mouseenter and mouseleave events. You can use it to simply apply behavior to an element during the time the mouse is within the element.

Calling $( selector ).hover( handlerIn, handlerOut ) is shorthand for:


-$( selector ).mouseenter( handlerIn ).mouseleave( handlerOut );
+$( selector ).on( "mouseenter", handlerIn ).on( "mouseleave", handlerOut );

See the discussions for .mouseenter() and .mouseleave() for more details.

See the discussions for mouseenter and mouseleave for more details.

To add a special style to list items that are being hovered over, try: @@ -28,7 +33,7 @@ $( "li" ).hover( function() { $( this ).append( $( " ***" ) ); }, function() { - $( this ).find( "span:last" ).remove(); + $( this ).find( "span" ).last().remove(); } ); @@ -78,31 +83,37 @@ $( "td" ).off( "mouseenter mouseleave" ); + - + + Bind a single handler to the matched elements, to be executed when the mouse pointer enters or leaves the elements. 1.4 - - A function to execute when the mouse pointer enters or leaves the element. + + + A function to execute when the mouse pointer enters or leaves the element. +

This API is deprecated. Use .on( "mouseenter mouseleave", handlerInOut ) instead.

The .hover() method, when passed a single function, will execute that handler for both mouseenter and mouseleave events. This allows the user to use jQuery's various toggle methods within the handler or to respond differently within the handler depending on the event.type.

Calling $(selector).hover(handlerInOut) is shorthand for:


 $( selector ).on( "mouseenter mouseleave", handlerInOut );

See the discussions for .mouseenter() and .mouseleave() for more details.

See the discussions for mouseenter and mouseleave for more details.

Slide the next sibling LI up or down on hover, and toggle a class. + + + + + + + + + + diff --git a/entries/innerWidth.xml b/entries/innerWidth.xml index 0a438e806..54b6b3588 100644 --- a/entries/innerWidth.xml +++ b/entries/innerWidth.xml @@ -1,22 +1,27 @@ - + + Get the current computed inner width (including padding but not border) for the first element in the set of matched elements or set the inner width of every matched element. + .innerWidth() 1.2.6 - Get the current computed width for the first element in the set of matched elements, including padding but not border. + Get the current computed inner width for the first element in the set of matched elements, including padding but not border. -

This method returns the width of the element, including left and right padding, in pixels.

This method returns the width of the element, including left and right padding, in pixels. If called on an empty set of elements, returns undefined (null before jQuery 3.0).

This method is not applicable to window and document objects; for these, use .width() instead.

Figure 1 - Illustration of the measured width

+ + Get the innerWidth of a paragraph. + + + + + + + + + diff --git a/entries/input-selector.xml b/entries/input-selector.xml index 7f5d8fd9a..ec5c6c23d 100644 --- a/entries/input-selector.xml +++ b/entries/input-selector.xml @@ -18,9 +18,9 @@ var formChildren = $( "form > *" ); $( "#messages" ).text( "Found " + allInputs.length + " inputs and the form has " + formChildren.length + " children." ); -$( "form" ).submit(function( event ) { +$( "form" ).on( "submit", function( event ) { event.preventDefault(); -}); +} ); ]]> + + + + diff --git a/entries/jQuery.Deferred.getErrorHook.xml b/entries/jQuery.Deferred.getErrorHook.xml new file mode 100644 index 000000000..b20f98e8e --- /dev/null +++ b/entries/jQuery.Deferred.getErrorHook.xml @@ -0,0 +1,29 @@ + + + jQuery.Deferred.getErrorHook() + + 3.7 + + Return an Error instance with a defined stack. + +

Note: This API is not defined by default, but jQuery will make use of it when defined.

When jQuery.Deferred.getErrorHook is defined, it extends the jQuery.Deferred features added in jQuery 3.0 to include an error captured before the async barrier whenever a Deferred throws an exception. This makes it easier to find programming errors that occur inside Deferreds. You can find an example implementation you can copy-paste below, or you can use jquery-deferred-reporter plugin.


+jQuery.Deferred.getErrorHook = function() {
+  try {
+    throw new Error( "Exception in jQuery.Deferred" );
+  } catch ( err ) {
+    return err;
+  }
+};
+

When defined, an error returned by this API is passed to jQuery.Deferred.exceptionHook as the second parameter.

Why does this API exist?

Prior to jQuery 3.0, Deferreds would simply terminate and the browser would generate a message on the console if an exception occurred such as attempting to call an undefined method as a function (e.g., myobject.missingFunction()). As of version 3.0, jQuery.Deferred follows the Promise/A+ specification when you use the .then method. The spec requires all errors to be trapped by the Promise, which prevents console errors from being logged. If the user has forgotten to add a handler for rejected promises, this can result in the error being silently swallowed with no notification at all!

The native Promise object as implemented in the browser tracks Promise rejections and reports problems on the console. However, doing the same type of reporting in the JavaScript world is much more difficult. jQuery itself is unable to use the native Promise because jQuery.Deferred implements a superset of Promise that requires additional features for methods like .done or .fail, and because Promise is not implemented on all the platforms that jQuery supports.

+ + + + diff --git a/entries/jQuery.Deferred.getStackHook.xml b/entries/jQuery.Deferred.getStackHook.xml new file mode 100644 index 000000000..87ee61387 --- /dev/null +++ b/entries/jQuery.Deferred.getStackHook.xml @@ -0,0 +1,30 @@ + + + jQuery.Deferred.getStackHook() + + 3.0 + + Return an Error instance with a defined stack. + +

Note: This API has been deprecated in jQuery 3.7; please use the jQuery.Deferred.getErrorHook method instead.

Note: This API is not defined by default, but jQuery will make use of it when defined.

See jQuery.Deferred.getErrorHook for the context why this API was created. Initially, we advised users to assign to it a function returning an error stack:


+jQuery.Deferred.getStackHook = function() {
+  try {
+    throw new Error( "Exception in jQuery.Deferred" );
+  } catch ( err ) {
+    return err.stack; // stack property returned here
+  }
+};
+

However, when such a stack is then logged by jQuery from inside of jQuery.Deferred.exceptionHook, the browser won't apply source maps. Therefore, we changed the recommendation to return the full error object itself. To make it clearer, the API was also renamed.

+ + + + + diff --git a/entries/jQuery.Deferred.xml b/entries/jQuery.Deferred.xml index 5bf4ca60d..2884ad879 100644 --- a/entries/jQuery.Deferred.xml +++ b/entries/jQuery.Deferred.xml @@ -14,10 +14,10 @@ - A constructor function that returns a chainable utility object with methods to register multiple callbacks into callback queues, invoke callback queues, and relay the success or failure state of any synchronous or asynchronous function. + A factory function that returns a chainable utility object with methods to register multiple callbacks into callback queues, invoke callback queues, and relay the success or failure state of any synchronous or asynchronous function. -

The jQuery.Deferred() constructor creates a new Deferred object. The new operator is optional.

The jQuery.Deferred method can be passed an optional function, which is called just before the constructor returns and is passed the constructed deferred object as both the this object and as the first argument to the function. The called function can attach callbacks using deferred.then(), for example.

The jQuery.Deferred() factory creates a new deferred object.

The jQuery.Deferred method can be passed an optional function, which is called just before the method returns and is passed the new deferred object as both the this object and as the first argument to the function. The called function can attach callbacks using deferred.then(), for example.

A Deferred object starts in the pending state. Any callbacks added to the object with deferred.then(), deferred.always(), deferred.done(), or deferred.fail() are queued to be executed later. Calling deferred.resolve() or deferred.resolveWith() transitions the Deferred into the resolved state and immediately executes any doneCallbacks that are set. Calling deferred.reject() or deferred.rejectWith() transitions the Deferred into the rejected state and immediately executes any failCallbacks that are set. Once the object has entered the resolved or rejected state, it stays in that state. Callbacks can still be added to the resolved or rejected Deferred — they will execute immediately.

Enhanced Callbacks with jQuery Deferred @@ -25,7 +25,7 @@

In JavaScript it is common to invoke functions that optionally accept callbacks that are called within that function. For example, in versions prior to jQuery 1.5, asynchronous processes such as jQuery.ajax() accept callbacks to be invoked some time in the near-future upon success, error, and completion of the ajax request.

jQuery.Deferred() introduces several enhancements to the way callbacks are managed and invoked. In particular, jQuery.Deferred() provides flexible ways to provide multiple callbacks, and these callbacks can be invoked regardless of whether the original callback dispatch has already occurred. jQuery Deferred is based on the CommonJS Promises/A design.

One model for understanding Deferred is to think of it as a chain-aware function wrapper. The deferred.then(), deferred.always(), deferred.done(), and deferred.fail() methods specify the functions to be called and the deferred.resolve(args) or deferred.reject(args) methods "call" the functions with the arguments you supply. Once the Deferred has been resolved or rejected it stays in that state; a second call to deferred.resolve(), for example, is ignored. If more functions are added by deferred.then(), for example, after the Deferred is resolved, they are called immediately with the arguments previously provided.

In most cases where a jQuery API call returns a Deferred or Deferred-compatible object, such as jQuery.ajax() or jQuery.when(), you will only want to use the deferred.then(), deferred.done(), and deferred.fail() methods to add callbacks to the Deferred's queues. The internals of the API call or code that created the Deferred will invoke deferred.resolve() or deferred.reject() on the deferred at some point, causing the appropriate callbacks to run.

In most cases where a jQuery API call returns a Deferred or Promise-compatible object, such as jQuery.ajax() or jQuery.when(), you will only want to use the deferred.then(), deferred.done(), and deferred.fail() methods to add callbacks to the Deferred's queues. The internals of the API call or code that created the Deferred will invoke deferred.resolve() or deferred.reject() on the deferred at some point, causing the appropriate callbacks to run.

diff --git a/entries/jQuery.ajax.xml b/entries/jQuery.ajax.xml index a8abca31b..9074388b9 100644 --- a/entries/jQuery.ajax.xml +++ b/entries/jQuery.ajax.xml @@ -8,18 +8,38 @@ A string containing the URL to which the request is sent. - A set of key/value pairs that configure the Ajax request. All settings are optional. A default can be set for any option with $.ajaxSetup(). See jQuery.ajax( settings ) below for a complete list of all settings. + A set of key/value pairs that configure the Ajax request. All settings are optional. A default can be set for any option with $.ajaxSetup(). See jQuery.ajax( settings ) below for a complete list of all settings. 1.0 A set of key/value pairs that configure the Ajax request. All settings are optional. A default can be set for any option with $.ajaxSetup(). - - The content type sent in the request header that tells the server what kind of response it will accept in return. If the accepts setting needs modification, it is recommended to do so once in the $.ajaxSetup() method. + + A set of key/value pairs that map a given dataType to its MIME type, which gets sent in the Accept request header. This header tells the server what kind of response it will accept in return. For example, the following defines a custom type mycustomtype to be sent with the request: +


+$.ajax({
+  accepts: {
+    mycustomtype: 'application/x-some-custom-type'
+  },
+
+  // Instructions for how to deserialize a `mycustomtype`
+  converters: {
+    'text mycustomtype': function(result) {
+      // Do Stuff
+      return newresult;
+    }
+  },
+
+  // Expect a `mycustomtype` back from server
+  dataType: 'mycustomtype'
+});
+

+ Note: You will need to specify a complementary entry for this type in converters for this to work properly. + - By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need synchronous requests, set this option to false. Cross-domain requests and dataType: "jsonp" requests do not support synchronous operation. Note that synchronous requests may temporarily lock the browser, disabling any actions while the request is active. As of jQuery 1.8, the use of async: false with jqXHR ($.Deferred) is deprecated; you must use the success/error/complete callback options instead of the corresponding methods of the jqXHR object such as jqXHR.done() or the deprecated jqXHR.success(). + By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need synchronous requests, set this option to false. Cross-domain requests and dataType: "jsonp" requests do not support synchronous operation. Note that synchronous requests may temporarily lock the browser, disabling any actions while the request is active. As of jQuery 1.8, the use of async: false with jqXHR ($.Deferred) is deprecated; you must use the success/error/complete callback options instead of the corresponding methods of the jqXHR object such as jqXHR.done(). @@ -32,16 +52,18 @@ - A function to be called when the request finishes (after success and error callbacks are executed). The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a string categorizing the status of the request ("success", "notmodified", "error", "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event. + A function to be called when the request finishes (after success and error callbacks are executed). The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a string categorizing the status of the request ("success", "notmodified", "nocontent", "error", "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event. An object of string/regular-expression pairs that determine how jQuery will parse the response, given its content type. - - When sending data to the server, use this content type. Default is "application/x-www-form-urlencoded; charset=UTF-8", which is fine for most cases. If you explicitly pass in a content-type to $.ajax(), then it is always sent to the server (even if no data is sent). The W3C XMLHttpRequest specification dictates that the charset is always UTF-8; specifying another charset will not force the browser to change the encoding. + + + + When sending data to the server, use this content type. Default is "application/x-www-form-urlencoded; charset=UTF-8", which is fine for most cases. If you explicitly pass in a content-type to $.ajax(), then it is always sent to the server (even if no data is sent). As of jQuery 1.6 you can pass false to tell jQuery to not set any content type header. Note: The W3C XMLHttpRequest specification dictates that the charset is always UTF-8; specifying another charset will not force the browser to change the encoding. Note: For cross-domain requests, setting the content type to anything other than application/x-www-form-urlencoded, multipart/form-data, or text/plain will trigger the browser to send a preflight OPTIONS request to the server. - This object will be made the context of all Ajax-related callbacks. By default, the context is an object that represents the ajax settings used in the call ($.ajaxSettings merged with the settings passed to $.ajax). For example, specifying a DOM element as the context will make that the context for the complete callback of a request, like so: + This object will be the context of all Ajax-related callbacks. By default, the context is an object that represents the Ajax settings used in the call ($.ajaxSettings merged with the settings passed to $.ajax). For example, specifying a DOM element as the context will make that the context for the complete callback of a request, like so:


 $.ajax({
   url: "test.html",
@@ -61,25 +83,38 @@ $.ajax({
       
         
         
-        Data to be sent to the server. It is converted to a query string, if not already a string. It's appended to the url for GET-requests. See processData option to prevent this automatic processing. Object must be Key/Value pairs. If value is an Array, jQuery serializes multiple values with same key based on the value of the traditional setting (described below).
+        
+        
+            Data to be sent to the server. If the HTTP method is one that cannot have an entity body, such as GET, the data is appended to the URL.
+            When data is an object, jQuery generates the data string from the object's key/value pairs unless the processData option is set to false. For example, { a: "bc", d: "e,f" } is converted to the string "a=bc&d=e%2Cf". If the value is an array, jQuery serializes multiple values with same key based on the value of the traditional setting (described below). For example, { a: [1,2] } becomes the string "a%5B%5D=1&a%5B%5D=2" with the default traditional: false setting.
+            When data is passed as a string it should already be encoded using the correct encoding for contentType, which by default is application/x-www-form-urlencoded.
+            In requests with dataType: "json" or dataType: "jsonp", if the string contains a double question mark (??) anywhere in the URL or a single question mark (?) in the query string, it is replaced with a value generated by jQuery that is unique for each copy of the library on the page (e.g. jQuery21406515378922229067_1479880736745).
+        
       
       
         
         
-        
-        A function to be used to handle the raw response data of XMLHttpRequest.This is a pre-filtering function to sanitize the response. You should return the sanitized data. The function accepts two arguments: The raw data returned from the server and the 'dataType' parameter.
+        
+        A function to be used to handle the raw response data of XMLHttpRequest. This is a pre-filtering function to sanitize the response. You should return the sanitized data. The function accepts two arguments: The raw data returned from the server and the 'dataType' parameter.
       
       
         The type of data that you're expecting back from the server. If none is specified, jQuery will try to infer it based on the MIME type of the response (an XML MIME type will yield XML, in 1.4 JSON will yield a JavaScript object, in 1.4 script will execute the script, and anything else will be returned as a string). The available types (and the result passed as the first argument to your success callback) are:
-          "xml": Returns a XML document that can be processed via jQuery.
"html": Returns HTML as plain text; included script tags are evaluated when inserted in the DOM.
"script": Evaluates the response as JavaScript and returns it as plain text. Disables caching by appending a query string parameter, "_=[TIMESTAMP]", to the URL unless the cache option is set to true. Note: This will turn POSTs into GETs for remote-domain requests. 
"json": Evaluates the response as JSON and returns a JavaScript object. The JSON data is parsed in a strict manner; any malformed JSON is rejected and a parse error is thrown. As of jQuery 1.9, an empty response is also rejected; the server should return a response of null or {} instead. (See json.org for more information on proper JSON formatting.)
"jsonp": Loads in a JSON block using JSONP. Adds an extra "?callback=?" to the end of your URL to specify the callback. Disables caching by appending a query string parameter, "_=[TIMESTAMP]", to the URL unless the cache option is set to true.
"text": A plain text string.
multiple, space-separated values: As of jQuery 1.5, jQuery can convert a dataType from what it received in the Content-Type header to what you require. For example, if you want a text response to be treated as XML, use "text xml" for the dataType. You can also make a JSONP request, have it received as text, and interpreted by jQuery as XML: "jsonp text xml." Similarly, a shorthand string such as "jsonp xml" will first attempt to convert from jsonp to xml, and, failing that, convert from jsonp to text, and then from text to xml.
-          
+          
+            "xml": Returns a XML document that can be processed via jQuery.
+            "html": Returns HTML as plain text; included script tags are evaluated when inserted in the DOM.
+            "script": Evaluates the response as JavaScript and returns it as plain text. Disables caching by appending a query string parameter, _=[TIMESTAMP], to the URL unless the cache option is set to true. Note: This will turn POSTs into GETs for remote-domain requests. Prior to jQuery 3.5.0, unsuccessful HTTP responses with a script Content-Type were still executed.
+            "json": Evaluates the response as JSON and returns a JavaScript object. Cross-domain "json" requests that have a callback placeholder, e.g. ?callback=?, are performed using JSONP unless the request includes jsonp: false in its request options. The JSON data is parsed in a strict manner; any malformed JSON is rejected and a parse error is thrown. As of jQuery 1.9, an empty response is also rejected; the server should return a response of null or {} instead. (See json.org for more information on proper JSON formatting.)
+            "jsonp": Loads in a JSON block using JSONP. Adds an extra "?callback=?" to the end of your URL to specify the callback. Disables caching by appending a query string parameter, "_=[TIMESTAMP]", to the URL unless the cache option is set to true.
+            "text": A plain text string.
+            multiple, space-separated values: As of jQuery 1.5, jQuery can convert a dataType from what it received in the Content-Type header to what you require. For example, if you want a text response to be treated as XML, use "text xml" for the dataType. You can also make a JSONP request, have it received as text, and interpreted by jQuery as XML: "jsonp text xml". Similarly, a shorthand string such as "jsonp xml" will first attempt to convert from jsonp to xml, and, failing that, convert from jsonp to text, and then from text to xml.
+          
         
       
       
         
         
         
-        A function to be called if the request fails. The function receives three arguments: The jqXHR (in jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null) are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error."  As of jQuery 1.5, the error setting can accept an array of functions. Each function will be called in turn.  Note: This handler is not called for cross-domain script and cross-domain JSONP requests. This is an Ajax Event. 
+        A function to be called if the request fails. The function receives three arguments: The jqXHR (in jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null) are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error." (in HTTP/2 it may instead be an empty string) As of jQuery 1.5, the error setting can accept an array of functions. Each function will be called in turn.  Note: This handler is not called for cross-domain scripts and cross-domain JSONP requests. This is an Ajax Event.
       
       
         Whether to trigger global Ajax event handlers for this request. The default is true. Set to false to prevent the global handlers like ajaxStart or ajaxStop from being triggered. This can be used to control various Ajax Events.
@@ -91,15 +126,20 @@ $.ajax({
         Allow the request to be successful only if the response has changed since the last request. This is done by checking the Last-Modified header. Default value is false, ignoring the header. In jQuery 1.4 this technique also checks the 'etag' specified by the server to catch unmodified data.
       
       
-        Allow the current environment to be recognized as "local," (e.g. the filesystem), even if jQuery does not recognize it as such by default. The following protocols are currently recognized as local: file, *-extension, and widget. If the isLocal setting needs modification, it is recommended to do so once in the $.ajaxSetup() method.  
+        Allow the current environment to be recognized as "local," (e.g. the filesystem), even if jQuery does not recognize it as such by default. The following protocols are currently recognized as local: file, *-extension, and widget. If the isLocal setting needs modification, it is recommended to do so once in the $.ajaxSetup() method.
       
-      
-        Override the callback function name in a jsonp request.  This value will be used instead of 'callback' in the 'callback=?' part of the query string in the url.  So {jsonp:'onJSONPLoad'} would result in 'onJSONPLoad=?' passed to the server. As of jQuery 1.5, setting the jsonp option to false prevents jQuery from adding the "?callback" string to the URL or attempting to use "=?" for transformation. In this case, you should also explicitly set the jsonpCallback setting. For example, { jsonp: false, jsonpCallback: "callbackName" }
+      
+        
+        
+        Override the callback function name in a JSONP request. This value will be used instead of 'callback' in the 'callback=?' part of the query string in the url. So {jsonp:'onJSONPLoad'} would result in 'onJSONPLoad=?' passed to the server. As of jQuery 1.5, setting the jsonp option to false prevents jQuery from adding the "?callback" string to the URL or attempting to use "=?" for transformation. In this case, you should also explicitly set the jsonpCallback setting. For example, { jsonp: false, jsonpCallback: "callbackName" }. If you don't trust the target of your Ajax requests, consider setting the jsonp property to false for security reasons.
       
       
         
         
-        Specify the callback function name for a JSONP request.  This value will be used instead of the random name automatically generated by jQuery. It is preferable to let jQuery generate a unique name as it'll make it easier to manage the requests and provide callbacks and error handling. You may want to specify the callback when you want to enable better browser caching of GET requests. As of jQuery 1.5, you can also use a function for this setting, in which case the value of jsonpCallback is set to the return value of that function. 
+        Specify the callback function name for a JSONP request.  This value will be used instead of the random name automatically generated by jQuery. It is preferable to let jQuery generate a unique name as it'll make it easier to manage the requests and provide callbacks and error handling. You may want to specify the callback when you want to enable better browser caching of GET requests. As of jQuery 1.5, you can also use a function for this setting, in which case the value of jsonpCallback is set to the return value of that function.
+      
+      
+        The HTTP method to use for the request (e.g. "POST", "GET", "PUT").
       
       
         A mime type to override the XHR mime type.
@@ -108,10 +148,13 @@ $.ajax({
         A password to be used with XMLHttpRequest in response to an HTTP access authentication request.
       
       
-        By default, data passed in to the data option as an object (technically, anything other than a string) will be processed and transformed into a query string, fitting to the default content-type "application/x-www-form-urlencoded". If you want to send a DOMDocument, or other non-processed data, set this option to false.
+        By default, data passed in to the data option as an object (technically, anything other than a string) will be processed and transformed into a query string, fitting to the default content-type "application/x-www-form-urlencoded". If you want to send a DOMDocument, or other non-processed data, set this option to false.
+      
+      
+        Defines an object with additional attributes to be used in a "script" or "jsonp" request. The key represents the name of the attribute and the value is the attribute's value. If this object is provided it will force the use of a script-tag transport. For example, this can be used to set nonce, integrity, or crossorigin attributes to satisfy Content Security Policy requirements.
       
       
-        Only applies when the "script" transport is used (e.g., cross-domain requests with "jsonp" or "script" dataType and "GET" type). Sets the charset attribute on the script tag used in the request. Used when the character set on the local page is not the same as the one on the remote script.
+        Only applies when the "script" transport is used. Sets the charset attribute on the script tag used in the request. Used when the character set on the local page is not the same as the one on the remote script. Alternatively, the charset attribute can be specified in scriptAttrs instead, which will also ensure the use of the "script" transport.
       
       
         
@@ -129,19 +172,19 @@ $.ajax({
         
       
       
-        
+        
         
         
-        A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server, formatted according to the dataType parameter; a string describing the status; and the jqXHR (in jQuery 1.4.x, XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
+        A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server, formatted according to the dataType parameter or the dataFilter callback function, if specified; a string describing the status; and the jqXHR (in jQuery 1.4.x, XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event.
       
       
-        Set a timeout (in milliseconds) for the request. This will override any global timeout set with $.ajaxSetup(). The timeout period starts at the point the $.ajax call is made; if several other requests are in progress and the browser has no connections available, it is possible for a request to time out before it can be sent. In jQuery 1.4.x and below, the XMLHttpRequest object will be in an invalid state if the request times out; accessing any object members may throw an exception. In Firefox 3.0+ only, script and JSONP requests cannot be cancelled by a timeout; the script will run even if it arrives after the timeout period.
+        Set a timeout (in milliseconds) for the request. A value of 0 means there will be no timeout. This will override any global timeout set with $.ajaxSetup(). The timeout period starts at the point the $.ajax call is made; if several other requests are in progress and the browser has no connections available, it is possible for a request to time out before it can be sent. In jQuery 1.4.x and below, the XMLHttpRequest object will be in an invalid state if the request times out; accessing any object members may throw an exception. In Firefox 3.0+ only, script and JSONP requests cannot be cancelled by a timeout; the script will run even if it arrives after the timeout period.
       
       
         Set this to true if you wish to use the traditional style of param serialization.
       
       
-        The type of request to make ("POST" or "GET"), default is "GET". Note: Other HTTP request methods, such as PUT and DELETE, can also be used here, but they are not supported by all browsers.
+        An alias for method. You should use type if you're using versions of jQuery prior to 1.9.0.
       
       
          A string containing the URL to which the request is sent.
@@ -182,7 +225,7 @@ $.ajax();
     As of jQuery 1.5.1, the jqXHR object also contains the overrideMimeType() method (it was available in jQuery 1.4.x, as well, but was temporarily removed in jQuery 1.5). The .overrideMimeType() method may be used in the beforeSend() callback function, for example, to modify the response content-type header:
     
 $.ajax({
-  url: "http://fiddle.jshell.net/favicon.png",
+  url: "https://fiddle.jshell.net/favicon.png",
   beforeSend: function( xhr ) {
     xhr.overrideMimeType( "text/plain; charset=x-user-defined" );
   }
@@ -197,7 +240,7 @@ $.ajax({
     
       
         jqXHR.done(function( data, textStatus, jqXHR ) {});
-        An alternative construct to the success callback option, the .done() method replaces the deprecated jqXHR.success() method. Refer to deferred.done() for implementation details.
+        An alternative construct to the success callback option, refer to deferred.done() for implementation details.
       
       
         jqXHR.fail(function( jqXHR, textStatus, errorThrown ) {});
@@ -205,7 +248,7 @@ $.ajax({
         
       
       
-        jqXHR.always(function( data|jqXHR, textStatus, jqXHR|errorThrown ) { });
+        jqXHR.always(function( data|jqXHR, textStatus, jqXHR|errorThrown ) { }); (added in jQuery 1.6)
         An alternative construct to the complete callback option, the .always() method replaces the deprecated .complete() method.
         In response to a successful request, the function's arguments are the same as those of .done(): data, textStatus, and the jqXHR object. For failed requests the arguments are the same as those of .fail(): the jqXHR object, textStatus, and errorThrown. Refer to deferred.always() for implementation details.
       
@@ -216,7 +259,7 @@ $.ajax({
       
     
     
-      Deprecation Notice: The jqXHR.success(), jqXHR.error(), and jqXHR.complete() callbacks are deprecated as of jQuery 1.8. To prepare your code for their eventual removal, use jqXHR.done(), jqXHR.fail(), and jqXHR.always() instead.
+      Deprecation Notice: The jqXHR.success(), jqXHR.error(), and jqXHR.complete() callbacks are removed as of jQuery 3.0. You can use jqXHR.done(), jqXHR.fail(), and jqXHR.always() instead.
     
     
 // Assign handlers immediately after making the request,
@@ -245,25 +288,32 @@ jqxhr.always(function() {
       
         readyState
       
+      
+        responseXML and/or responseText when the underlying request responded with xml and/or text, respectively
+      
       
         status
       
       
-        statusText
+        statusText (may be an empty string in HTTP/2)
+      
+      
+        abort( [ statusText ] )
+      
+      
+        getAllResponseHeaders() as a string
       
-      responseXML and/or responseText when the underlying request responded with xml and/or text, respectively
-      setRequestHeader(name, value) which departs from the standard by replacing the old value with the new one rather than concatenating the new value to the old one
       
-        getAllResponseHeaders()
+        getResponseHeader( name )
       
       
-        getResponseHeader()
+        overrideMimeType( mimeType )
       
       
-        statusCode()
+        setRequestHeader( name, value ) which departs from the standard by replacing the old value with the new one rather than concatenating the new value to the old one
       
       
-        abort()
+        statusCode( callbacksByStatusCode )
       
     
     No onreadystatechange mechanism is provided, however, since done, fail, always, and statusCode cover all conceivable requirements.
@@ -281,20 +331,19 @@ jqxhr.always(function() {
     
 
     Data Types
-    The $.ajax() function relies on the server to provide information about the retrieved data. If the server reports the return data as XML, the result can be traversed using normal XML methods or jQuery's selectors. If another type is detected, such as HTML in the example above, the data is treated as text.
-    Different data handling can be achieved by using the dataType option. Besides plain xml, the dataType can be html, json, jsonp, script, or text.
-    The text and xml types return the data with no processing. The data is simply passed on to the success handler, either through the responseText or responseXML property of the jqXHR object, respectively.
-    Note: We must ensure that the MIME type reported by the web server matches our choice of dataType. In particular, XML must be declared by the server as text/xml or application/xml for consistent results.
-    If html is specified, any embedded JavaScript inside the retrieved data is executed before the HTML is returned as a string. Similarly, script will execute the JavaScript that is pulled back from the server, then return nothing.
-    The json type parses the fetched data file as a JavaScript object and returns the constructed object as the result data. To do so, it uses jQuery.parseJSON() when the browser supports it; otherwise it uses a Function constructor. Malformed JSON data will throw a parse error (see json.org for more information). JSON data is convenient for communicating structured data in a way that is concise and easy for JavaScript to parse. If the fetched data file exists on a remote server, specify the jsonp type instead.
-    The jsonp type appends a query string parameter of callback=? to the URL. The server should prepend the JSON data with the callback name to form a valid JSONP response. We can specify a parameter name other than callback with the jsonp option to $.ajax().
-    Note: JSONP is an extension of the JSON format, requiring some server-side code to detect and handle the query string parameter. More information about it can be found in the original post detailing its use.
-    When data is retrieved from remote servers (which is only possible using the script or jsonp data types), the error callbacks and global events will never be fired.
+    Different types of response to $.ajax() call are subjected to different kinds of pre-processing before being passed to the success handler. The type of pre-processing depends by default upon the Content-Type of the response, but can be set explicitly using the dataType option. If the dataType option is provided, the Content-Type header of the response will be disregarded.
+    The available data types are text, html, xml, json, jsonp, and script.
+    If text or html is specified, no pre-processing occurs. The data is simply passed on to the success handler, and made available through the responseText property of the jqXHR object.
+    If xml is specified, the response is parsed using jQuery.parseXML before being passed, as an XMLDocument, to the success handler. The XML document is made available through the responseXML property of the jqXHR object.
+    If json is specified, the response is parsed using jQuery.parseJSON before being passed, as an object, to the success handler. The parsed JSON object is made available through the responseJSON property of the jqXHR object.
+    If script is specified, $.ajax() will execute the JavaScript that is received from the server before passing it on to the success handler as a string.
+    If jsonp is specified, $.ajax() will automatically append a query string parameter of (by default) callback=? to the URL. The jsonp and jsonpCallback properties of the settings passed to $.ajax() can be used to specify, respectively, the name of the query string parameter and the name of the JSONP callback function. The server should return valid JavaScript that passes the JSON response into the callback function. $.ajax() will execute the returned JavaScript, calling the JSONP callback function, before passing the JSON object contained in the response to the $.ajax() success handler.
+    For more information on JSONP, see the original post detailing its use.
     Sending Data to the Server
     By default, Ajax requests are sent using the GET HTTP method. If the POST method is required, the method can be specified by setting a value for the type option. This option affects how the contents of the data option are sent to the server. POST data will always be transmitted to the server using UTF-8 charset, per the W3C XMLHTTPRequest standard.
     The data option can contain either a query string of the form key1=value1&key2=value2, or an object of the form {key1: 'value1', key2: 'value2'}. If the latter form is used, the data is converted into a query string using jQuery.param() before it is sent. This processing can be circumvented by setting processData to false.  The processing might be undesirable if you wish to send an XML object to the server; in this case, change the contentType option from application/x-www-form-urlencoded to a more appropriate MIME type.
     Advanced Options
-    The global option prevents handlers registered using .ajaxSend(), .ajaxError(), and similar methods from firing when this request would trigger them. This can be useful to, for example, suppress a loading indicator that was implemented with .ajaxSend() if the requests are frequent and brief. With cross-domain script and JSONP requests, the global option is automatically set to false. See the descriptions of these methods below for more details.  See the descriptions of these methods below for more details.
+    The global option prevents handlers registered for the ajaxSend, ajaxError, and similar events from firing when this request would trigger them. This can be useful to, for example, suppress a loading indicator that was implemented with an ajaxSend handler if the requests are frequent and brief. With cross-domain script and JSONP requests, the global option is automatically set to false. See the descriptions of these methods below for more details.
     If the server performs HTTP authentication before providing a response, the user name and password pair can be sent via the username and password options.
     Ajax requests are time-limited, so errors can be caught and handled to provide a better user experience. Request timeouts are usually either left at their default or set as a global default using $.ajaxSetup() rather than being overridden for specific requests with the timeout option.
     By default, requests are always issued, but the browser may serve results out of its cache. To disallow use of the cached results, set cache to false. To cause the request to report failure if the asset has not been modified since the last request, set ifModified to true.
@@ -306,7 +355,7 @@ jqxhr.always(function() {
     As of jQuery 1.5, jQuery's Ajax implementation includes prefilters, transports, and converters that allow you to extend Ajax with a great deal of flexibility.
 
     Using Converters
-    $.ajax() converters support mapping data types to other data types. If, however, you want to map a custom data type to a known type (e.g json), you must add a correspondance between the response Content-Type and the actual data type using the contents option:
+    $.ajax() converters support mapping data types to other data types. If, however, you want to map a custom data type to a known type (e.g json), you must add a correspondence between the response Content-Type and the actual data type using the contents option:
     
 $.ajaxSetup({
   contents: {
@@ -320,7 +369,7 @@ $.ajaxSetup({
   }
 });
     
-    This extra object is necessary because the response Content-Types and data types never have a strict one-to-one correspondance (hence the regular expression).
+    This extra object is necessary because the response Content-Types and data types never have a strict one-to-one correspondence (hence the regular expression).
     To convert from a supported type (e.g text, json) to a custom data type and back again, use another pass-through converter:
     
 $.ajaxSetup({
@@ -344,7 +393,7 @@ $.ajaxSetup({
     Save some data to the server and notify the user once it's complete.
     
-    
-    
-  
-  
-    Returns false if the page is in Quirks Mode in Internet Explorer
-    
-    
-  
+  States if the current page, in the user's browser, is being rendered using the W3C CSS Box Model.
+  
+    
+      Note: This API has been removed in jQuery 3.0; check if .document.compatMode is equal to "CSS1Compat" instead. Or, even better - always specify a DOCTYPE and avoid using quirks mode which jQuery doesn't support.
+    
+  
   
   
   
+  
 
diff --git a/entries/jQuery.browser.xml b/entries/jQuery.browser.xml
index fe0f3add7..11686eaec 100644
--- a/entries/jQuery.browser.xml
+++ b/entries/jQuery.browser.xml
@@ -7,6 +7,9 @@
     
     Contains flags for the useragent, read from navigator.userAgent. This property was removed in jQuery 1.9 and is available only through the jQuery.migrate plugin. Please try to use feature detection instead.
     
+      
+        Note: This API has been removed in jQuery 1.9; please rely on feature detection instead.
+      
       The $.browser property provides information about the web browser that is accessing the page, as reported by the browser itself. It contains flags for each of the four most prevalent browser classes (Internet Explorer, Mozilla, Webkit, and Opera) as well as version information.
       Available flags are:
       
@@ -18,7 +21,7 @@
       
       This property is available immediately. It is therefore safe to use it to determine whether or not to call $(document).ready().
     The $.browser property is deprecated in jQuery 1.3, and its functionality may be moved to a team-supported plugin in a future release of jQuery.
-      Because $.browser uses navigator.userAgent to determine the platform, it is vulnerable to spoofing by the user or misrepresentation by the browser itself. It is always best to avoid browser-specific code entirely where possible. Instead of relying on $.browser it's better to use libraries like Modernizr.
+      Because $.browser uses navigator.userAgent to determine the platform, it is vulnerable to spoofing by the user or misrepresentation by the browser itself. It is always best to avoid browser-specific code entirely where possible. Instead of relying on $.browser it's better to use libraries like Modernizr.
     
     
       Show the browser info.
@@ -48,6 +51,7 @@ $.browser.msie;
     
     
     
+    
   
   
     
@@ -55,6 +59,9 @@ $.browser.msie;
     
     The version number of the rendering engine for the user's browser. This property was removed in jQuery 1.9 and is available only through the jQuery.migrate plugin.
     
+      
+        Note: This API has been removed in jQuery 1.9; please rely on feature detection instead.
+      
       Here are some typical results:
       
         Internet Explorer: 6.0, 7.0, 8.0
diff --git a/entries/jQuery.cssHooks.xml b/entries/jQuery.cssHooks.xml
index 8252bfa5d..ec36ccfe1 100644
--- a/entries/jQuery.cssHooks.xml
+++ b/entries/jQuery.cssHooks.xml
@@ -45,7 +45,7 @@ function styleSupport( prop ) {
 
     // Capitalize first character of the prop to test vendor prefix
     capProp = prop.charAt( 0 ).toUpperCase() + prop.slice( 1 ),
-    prefixes = [ "Moz", "Webkit", "O", "ms" ],
+    prefixes = [ "Moz", "Webkit", "ms" ],
     div = document.createElement( "div" );
 
   if ( prop in div.style ) {
@@ -89,7 +89,7 @@ if ( !$.cssHooks ) {
 function styleSupport( prop ) {
   var vendorProp, supportedProp,
     capProp = prop.charAt( 0 ).toUpperCase() + prop.slice( 1 ),
-    prefixes = [ "Moz", "Webkit", "O", "ms" ],
+    prefixes = [ "Moz", "Webkit", "ms" ],
     div = document.createElement( "div" );
 
   if ( prop in div.style ) {
@@ -163,7 +163,7 @@ if ( $.support.someCSSProp && $.support.someCSSProp !== "someCSSProp" )
 })( jQuery );
     
     Special units
-    By default, jQuery adds a "px" unit to the values passed to the .css() method. This behavior can be prevented by adding the property to the jQuery.cssNumber object
+    By default, jQuery adds a "px" unit to the values passed to the .css() method. This behavior can be prevented by adding the property to the jQuery.cssNumber object
     
 $.cssNumber.someCSSProp = true;
     
diff --git a/entries/jQuery.cssNumber.xml b/entries/jQuery.cssNumber.xml
new file mode 100644
index 000000000..c49b3c785
--- /dev/null
+++ b/entries/jQuery.cssNumber.xml
@@ -0,0 +1,53 @@
+
+
+  jQuery.cssNumber
+  
+    1.4.3
+  
+  An object containing all CSS properties that may be used without a unit. Prior to jQuery 4.0, the .css() method uses this object to see if it may append px to unitless values.
+  
+    
+      Note: This API has been removed in jQuery 4.0; please pass a string value with the desired units instead.
+    
+    You can think about jQuery.cssNumber as a list of all CSS properties you might use without a unit. Prior to jQuery 4.0, it was used by .css() to determine if it needs to add px to unitless values.
+    The keys of the jQuery.cssNumber object are camel-cased and the values are all set to true. If you want to prevent the .css() method from automatically adding the px unit for a specific CSS property and that property is not yet a key of the jQuery.cssNumber object, you can add such an extra property:
+    
+if ( jQuery.cssNumber ) {
+  jQuery.cssNumber.someCSSProp = true;
+}
+    
+    By default the object contains the following properties:
+    
+      animationIterationCount (added in 1.12.0/2.2.0)
+      aspectRatio (added in 3.7.0)
+      borderImageSlice (added in 3.7.0)
+      columnCount (added in 1.9.0)
+      flexGrow (added in 1.11.1/2.1.1)
+      flexShrink (added in 1.11.1/2.1.1)
+      fontWeight (added in 1.4.3)
+      gridArea (added in 3.4.0)
+      gridColumn (added in 3.4.0)
+      gridColumnEnd (added in 3.4.0)
+      gridColumnStart (added in 3.4.0)
+      gridRow (added in 3.4.0)
+      gridRowEnd (added in 3.4.0)
+      gridRowStart (added in 3.4.0)
+      lineHeight (added in 1.4.3)
+      opacity (added in 1.4.3)
+      order (added in 1.10.2/2.0.3)
+      orphans (added in 1.6.0)
+      scale (added in 3.7.0)
+      widows (added in 1.6.0)
+      zIndex (added in 1.4.3)
+      zoom (added in 1.4.3)
+      fillOpacity (SVG-related, added in 1.6.2)
+      floodOpacity (SVG-related, added in 3.7.0)
+      stopOpacity (SVG-related, added in 3.7.0)
+      strokeMiterlimit (SVG-related, added in 3.7.0)
+      strokeOpacity (SVG-related, added in 3.7.0)
+    
+  
+  
+  
+  
+
diff --git a/entries/jQuery.data.xml b/entries/jQuery.data.xml
index dcfc68d74..5207c8b89 100644
--- a/entries/jQuery.data.xml
+++ b/entries/jQuery.data.xml
@@ -11,8 +11,8 @@
       
         A string naming the piece of data to set.
       
-      
-        The new data value.
+      
+        The new data value; this can be any Javascript type except undefined.
       
     
     Store arbitrary data associated with the specified element. Returns the value that was set.
@@ -23,8 +23,9 @@
 jQuery.data( document.body, "foo", 52 );
 jQuery.data( document.body, "bar", "test" );
       
-      Note: this method currently does not provide cross-platform support for setting data on XML documents, as Internet Explorer does not allow data to be attached via expando properties.
     
+    
+    
     
       Store then retrieve a value from the div element.
       
       
       
   
   
diff --git a/entries/jQuery.escapeSelector.xml b/entries/jQuery.escapeSelector.xml
new file mode 100644
index 000000000..9e9a91d1e
--- /dev/null
+++ b/entries/jQuery.escapeSelector.xml
@@ -0,0 +1,29 @@
+
+
+  jQuery.escapeSelector()
+  Escapes any character that has a special meaning in a CSS selector.
+  
+    3.0
+    
+      A string containing a selector expression to escape.
+    
+  
+  
+    This method is useful for situations where a class name or an ID contains characters that have a special meaning in CSS, such as the dot or the semicolon.
+    The method is essentially a shim for the CSS Working Group's CSS.escape() method. The main difference is that $.escapeSelector() can be reliably used in all of jQuery's supported browsers.
+  
+  
+    Escape an ID containing a hash.
+    
+  
+  
+    Select all the elements having a class name of .box inside a div.
+    
+  
+  
+  
+
diff --git a/entries/jQuery.extend.xml b/entries/jQuery.extend.xml
index 594a1b755..472626153 100644
--- a/entries/jQuery.extend.xml
+++ b/entries/jQuery.extend.xml
@@ -4,9 +4,9 @@
   
     1.0
     
-       An object that will receive the new properties if additional objects are passed in or that will extend the jQuery namespace if it is the sole argument.
+       An object that will receive the new properties.
     
-    
+    
       An object containing additional properties to merge in.
     
     
@@ -16,7 +16,7 @@
   
     1.1.4
     
-      If true, the merge becomes recursive (aka. deep copy).
+      If true, the merge becomes recursive (aka. deep copy).  Passing false for this argument is not supported.
     
     
       The object to extend. It will receive the new properties.
@@ -28,6 +28,12 @@
       Additional objects containing properties to merge in.
     
   
+  
+    1.0
+    
+       An object to merge onto the jQuery namespace.
+    
+  
   Merge the contents of two or more objects together into the first object.
   
     When two or more object arguments are supplied to $.extend(), properties from all of the objects are added to the target object. Arguments that are null or undefined are ignored.
@@ -35,10 +41,11 @@
     Keep in mind that the target object (first argument) will be modified, and will also be returned from $.extend(). If, however, you want to preserve both of the original objects, you can do so by passing an empty object as the target:
     var object = $.extend({}, object1, object2);
     The merge performed by $.extend() is not recursive by default; if a property of the first object is itself an object or array, it will be completely overwritten by a property with the same key in the second or subsequent object. The values are not merged. This can be seen in the example below by examining the value of banana. However, by passing true for the first function argument, objects will be recursively merged.
+    Warning: Versions prior to 3.4 had a security issue where calling jQuery.extend(true, {}, object) on an unsanitized object containing a __proto__ property would extend Object.prototype.
     Warning: Passing false for the first argument is not supported.
     Undefined properties are not copied. However, properties inherited from the object's prototype will be copied over. Properties that are an object constructed via new MyCustomObject(args), or built-in JavaScript types such as Date or RegExp, are not re-constructed and will appear as plain Objects in the resulting object or array.
-    On a deep extend, Object and Array are extended, but object wrappers on primitive types such as String, Boolean, and Number are not.
-    For needs that fall outside of this behavior, write a custom extend method instead. 
+    On a deep extend, Object and Array are extended, but object wrappers on primitive types such as String, Boolean, and Number are not. Deep-extending a cyclical data structure will result in an error.
+    For needs that fall outside of this behavior, write a custom extend method instead, or use a library like lodash. 
   
   
     Merge two objects, modifying the first.
@@ -56,17 +63,8 @@ var object2 = {
 // Merge object2 into object1
 $.extend( object1, object2 );
 
-var printObj = typeof JSON !== "undefined" ? JSON.stringify : function( obj ) {
-  var arr = [];
-  $.each( obj, function( key, val ) {
-    var next = key + ": ";
-    next += $.isPlainObject( val ) ? printObj( val ) : val;
-    arr.push( next );
-  });
-  return "{ " +  arr.join( ", " ) + " }";
-};
-
-$( "#log" ).append( printObj( object1 ) );
+// Assuming JSON.stringify - not available in IE<8
+$( "#log" ).append( JSON.stringify( object1 ) );
 ]]>
     
     defaults -- " + printObj( defaults ) + "

", { Binds a function to be executed when the DOM has finished loading. - This function behaves just like $( document ).ready(), in that it should be used to wrap other $() operations on your page that depend on the DOM being ready. While this function is, technically, chainable, there really isn"t much use for chaining against it. + This function behaves just like $( document ).ready(), in that it should be used to wrap other $() operations on your page that depend on the DOM being ready. While this function is, technically, chainable, there really isn't much use for chaining against it. Execute the function when the DOM is ready to be used. diff --git a/entries/keydown-shorthand.xml b/entries/keydown-shorthand.xml new file mode 100644 index 000000000..98b125b34 --- /dev/null +++ b/entries/keydown-shorthand.xml @@ -0,0 +1,36 @@ + + + .keydown() + Bind an event handler to the "keydown" event, or trigger that event on an element. + + 1.0 + + A function to execute each time the event is triggered. + + + + + 1.4.3 + + An object containing data that will be passed to the event handler. + + + A function to execute each time the event is triggered. + + + + + 1.0 + + + + This API is deprecated. + Instead of .keydown( handler ) or .keydown( eventData, handler ), use .on( "keydown", handler ) or .on( "keydown", eventData, handler ), respectively. + Instead of .keydown(), use .trigger( "keydown" ). + + + + + + + diff --git a/entries/keydown.xml b/entries/keydown.xml index b72e0ad75..576a1ad0c 100644 --- a/entries/keydown.xml +++ b/entries/keydown.xml @@ -1,28 +1,28 @@ - - .keydown() + +Bind an event handler to the "keydown" event, or trigger that event on an element. + + + keydown event + Bind an event handler to the "keydown" event. - 1.0 - - A function to execute each time the event is triggered. + 1.7 + + The string "keydown". - - - 1.4.3 - + An object containing data that will be passed to the event handler. - + A function to execute each time the event is triggered. + - - 1.0 - - Bind an event handler to the "keydown" JavaScript event, or trigger that event on an element. - This method is a shortcut for .on( "keydown", handler ) in the first and second variations, and .trigger( "keydown" ) in the third. - The keydown event is sent to an element when the user first presses a key on the keyboard. It can be attached to any element, but the event is only sent to the element that has the focus. Focusable elements can vary between browsers, but form elements can always get focus so are reasonable candidates for this event type. + + This page describes the keydown event. For the deprecated .keydown() method, see .keydown(). + + The keydown event is sent to an element when the user presses a key on the keyboard. If the key is kept pressed, the event is sent every time the operating system repeats the key. It can be attached to any element, but the event is only sent to the element that has the focus. Focusable elements can vary between browsers, but form elements can always get focus so are reasonable candidates for this event type. For example, consider the HTML: <form> @@ -34,19 +34,19 @@ The event handler can be bound to the input field: -$( "#target" ).keydown(function() { - alert( "Handler for .keydown() called." ); -}); +$( "#target" ).on( "keydown", function() { + alert( "Handler for `keydown` called." ); +} ); Now when the insertion point is inside the field, pressing a key displays the alert: - Handler for .keydown() called. + Handler for `keydown` called. - To trigger the event manually, apply .keydown() without an argument: + To trigger the event manually, use .trigger( "keydown" ): -$( "#other" ).click(function() { - $( "#target" ).keydown(); -}); +$( "#other" ).on( "click", function() { + $( "#target" ).trigger( "keydown" ); +} ); After this code executes, clicks on Trigger the handler will also alert the message. If key presses anywhere need to be caught (for example, to implement global shortcut keys on a page), it is useful to attach this behavior to the document object. Because of event bubbling, all key presses will make their way up the DOM to the document object unless explicitly stopped. @@ -56,19 +56,19 @@ $( "#other" ).click(function() { Show the event object for the keydown handler when a key is pressed in the input. - + + + + keypress event + Trigger the "keypress" event on an element. + + 1.0 + + The string "keypress". + + + + See the description for .on( "keypress", ... ). + + + + + + diff --git a/entries/keyup-shorthand.xml b/entries/keyup-shorthand.xml new file mode 100644 index 000000000..965dbeb84 --- /dev/null +++ b/entries/keyup-shorthand.xml @@ -0,0 +1,36 @@ + + + .keyup() + Bind an event handler to the "keyup" event, or trigger that event on an element. + + 1.0 + + A function to execute each time the event is triggered. + + + + + 1.4.3 + + An object containing data that will be passed to the event handler. + + + A function to execute each time the event is triggered. + + + + + 1.0 + + + + This API is deprecated. + Instead of .keyup( handler ) or .keyup( eventData, handler ), use .on( "keyup", handler ) or .on( "keyup", eventData, handler ), respectively. + Instead of .keyup(), use .trigger( "keyup" ). + + + + + + + diff --git a/entries/keyup.xml b/entries/keyup.xml index f65c6a03f..b0d6399f4 100644 --- a/entries/keyup.xml +++ b/entries/keyup.xml @@ -1,27 +1,27 @@ - - .keyup() - Bind an event handler to the "keyup" JavaScript event, or trigger that event on an element. + +Bind an event handler to the "keyup" event, or trigger that event on an element. + + + keyup event + Bind an event handler to the "keyup" event. - 1.0 - - A function to execute each time the event is triggered. + 1.7 + + The string "keyup". - - - 1.4.3 - + An object containing data that will be passed to the event handler. - + A function to execute each time the event is triggered. + - - 1.0 - - This method is a shortcut for .on( "keyup", handler ) in the first two variations, and .trigger( "keyup" ) in the third. + + This page describes the keyup event. For the deprecated .keyup() method, see .keyup(). + The keyup event is sent to an element when the user releases a key on the keyboard. It can be attached to any element, but the event is only sent to the element that has the focus. Focusable elements can vary between browsers, but form elements can always get focus so are reasonable candidates for this event type. For example, consider the HTML: @@ -34,19 +34,19 @@ The event handler can be bound to the input field: -$( "#target" ).keyup(function() { - alert( "Handler for .keyup() called." ); -}); +$( "#target" ).on( "keyup", function() { + alert( "Handler for `keyup` called." ); +} ); Now when the insertion point is inside the field and a key is pressed and released, the alert is displayed: - Handler for .keyup() called. + Handler for `keyup` called. - To trigger the event manually, apply .keyup() without arguments: + To trigger the event manually, use .trigger( "keyup" ): -$( "#other" ).click(function() { - $( "#target" ).keyup(); -}); +$( "#other" ).on( "click", function() { + $( "#target" ).trigger( "keyup" ); +} ); After this code executes, clicks on Trigger the handler will also alert the message. If key presses anywhere need to be caught (for example, to implement global shortcut keys on a page), it is useful to attach this behavior to the document object. Because of event bubbling, all key presses will make their way up the DOM to the document object unless explicitly stopped. @@ -56,20 +56,20 @@ $( "#other" ).click(function() { Show the event object for the keyup handler (using a simple $.print plugin) when a key is released in the input. diff --git a/entries/length.xml b/entries/length.xml index 105f23d84..37a2d54cf 100644 --- a/entries/length.xml +++ b/entries/length.xml @@ -12,12 +12,12 @@ Count the divs. Click to add more. diff --git a/entries/live.xml b/entries/live.xml index 314735641..0943af956 100644 --- a/entries/live.xml +++ b/entries/live.xml @@ -7,8 +7,9 @@ A string containing a JavaScript event type, such as "click" or "keydown." As of jQuery 1.4 the string can contain multiple, space-separated event types or custom event names. - + A function to execute at the time the event is triggered. + @@ -16,11 +17,12 @@ A string containing a JavaScript event type, such as "click" or "keydown." As of jQuery 1.4 the string can contain multiple, space-separated event types or custom event names. - + An object containing data that will be passed to the event handler. - + A function to execute at the time the event is triggered. + @@ -30,8 +32,10 @@ -

As of jQuery 1.7, the .live() method is deprecated. Use .on() to attach event handlers. Users of older versions of jQuery should use .delegate() in preference to .live().

This method provides a means to attach delegated event handlers to the document element of a page, which simplifies the use of event handlers when content is dynamically added to a page. See the discussion of direct versus delegated events in the .on() method for more information.

Note: This API has been removed in jQuery 1.9; please use on() instead.

Rewriting the .live() method in terms of its successors is straightforward; these are templates for equivalent calls for all three event attachment methods:


 $( selector ).live( events, data, handler );                // jQuery 1.3+
@@ -100,7 +104,7 @@ $( "p" ).live( "myCustomEvent", function( event, myName, myValue ) {
     .fadeIn( 30 )
     .fadeOut( 1000 );
   });
-$( "button" ).click(function() {
+$( "button" ).on( "click", function() {
   $( "p" ).trigger( "myCustomEvent" );
 });
 ]]>
diff --git a/entries/load-event.xml b/entries/load-event.xml
index 16ab3180e..f7dbc65a7 100644
--- a/entries/load-event.xml
+++ b/entries/load-event.xml
@@ -1,24 +1,27 @@
 
-
-  .load()
-  Bind an event handler to the "load" JavaScript event.
+
+Bind an event handler to the "load" event, or trigger that event on an element.
+
+
+  load event
+  Bind an event handler to the "load" event.
   
-    1.0
-    
-      A function to execute when the event is triggered.
+    1.7
+    
+      The string "load".
     
-  
-  
-    1.4.3
-    
+    
       An object containing data that will be passed to the event handler.
     
-    
+    
       A function to execute each time the event is triggered.
+      
     
   
   
-    This method is a shortcut for .on( "load", handler ).
+    
+      This page describes the load event. For the .load() method removed in jQuery 3.0, see .load().
+    
     The load event is sent to an element when it and all sub-elements have been completely loaded. This event can be sent to any element associated with a URL: images, scripts, frames, iframes, and the window object.
     For example, consider a page with a simple image:
     
@@ -26,20 +29,17 @@
     
     The event handler can be bound to the image:
     
-$( "#book" ).load(function() {
-  // Handler for .load() called.
-});
+$( "#book" ).on( "load", function() {
+  // Handler for `load` called.
+} );
     
     As soon as the image has been loaded, the handler is called.
     In general, it is not necessary to wait for all images to be fully loaded. If code can be executed earlier, it is usually best to place it in a handler sent to the .ready() method.
     
-    
-      The Ajax module also has a method named .load(). Which one is fired depends on the set of arguments passed.
-    
     
       
         Caveats of the load event when used with images
-        
A common challenge developers attempt to solve using the .load() shortcut is to execute a function when an image (or collection of images) have completely loaded. There are several known caveats with this that should be noted. These are:
+        A common challenge developers attempt to solve using the load shortcut is to execute a function when an image (or collection of images) have completely loaded. There are several known caveats with this that should be noted. These are:
         
           It doesn't work consistently nor reliably cross-browser
           It doesn't fire correctly in WebKit if the image src is set to the same src as before
@@ -55,23 +55,40 @@ $( "#book" ).load(function() {
   
     Run a function when the page is fully loaded including graphics.
     
   
   
-    Add the class bigImg to all images with height greater then 100 upon each image load.
+    Add the class bigImg to all images with height greater than 100 upon each image load.
     
   
   
   
-  
-  
+  
+
+
+
+  load event
+  Trigger the "load" event on an element.
+  
+    1.0
+    
+      The string "load".
+    
+  
+  
+    See the description for .on( "load", ... ).
+  
+  
+  
 
+
+
diff --git a/entries/load-shorthand.xml b/entries/load-shorthand.xml
new file mode 100644
index 000000000..1c5873cb0
--- /dev/null
+++ b/entries/load-shorthand.xml
@@ -0,0 +1,40 @@
+
+
+  .load()
+  Bind an event handler to the "load" event, or trigger that event on an element.
+  
+    1.0
+    
+      A function to execute each time the event is triggered.
+      
+    
+  
+  
+    1.4.3
+    
+      An object containing data that will be passed to the event handler.
+    
+    
+      A function to execute each time the event is triggered.
+      
+    
+  
+  
+    1.0
+  
+  
+    
+      This API has been removed in jQuery 3.0.
+      Instead of .load( handler ) or .load( eventData, handler ), use .on( "load", handler ) or .on( "load", eventData, handler ), respectively.
+      Instead of .load(), use .trigger( "load" ).
+    
+    
+      The Ajax module also has a method named .load(). Which one is fired depends on the set of arguments passed.
+    
+  
+  
+  
+  
+  
+  
+
diff --git a/entries/load.xml b/entries/load.xml
index 7389800c3..c0f6a46fc 100644
--- a/entries/load.xml
+++ b/entries/load.xml
@@ -11,16 +11,19 @@
       
       A plain object or string that is sent to the server with the request.
     
-    
+    
+      
+      
+             
       A callback function that is executed when the request completes.
     
   
-  Load data from the server and place the returned HTML into the matched element.
+  Load data from the server and place the returned HTML into the matched elements.
   
     
-      Note: The event handling suite also has a method named .load(). jQuery determines which method to fire based on the set of arguments passed to it.
+      Note: Prior to jQuery 3.0, the event handling suite also had a method named .load(). Older versions of jQuery determined which method to fire based on the set of arguments passed to it.
     
-    This method is the simplest way to fetch data from the server. It is roughly equivalent to $.get(url, data, success) except that it is a method rather than global function and it has an implicit callback function.  When a successful response is detected (i.e. when textStatus is "success" or "notmodified"), .load() sets the HTML contents of the matched element to the returned data. This means that most uses of the method can be quite simple:
+    This method is the simplest way to fetch data from the server. It is roughly equivalent to $.get(url, data, success) except that it is a method rather than global function and it has an implicit callback function.  When a successful response is detected (i.e. when textStatus is "success" or "notmodified"), .load() sets the HTML contents of the matched elements to the returned data. This means that most uses of the method can be quite simple:
     
 $( "#result" ).load( "ajax/test.html" );
     
@@ -56,9 +59,9 @@ $( "#b" ).load( "article.html #target" );
   
   
   
-    Load the main page's footer navigation into an ordered list.
+    Load another page's list items into an ordered list.
     
     
     
   
   
diff --git a/entries/lt-selector.xml b/entries/lt-selector.xml
index d301f11dc..703c427f1 100644
--- a/entries/lt-selector.xml
+++ b/entries/lt-selector.xml
@@ -1,5 +1,5 @@
 
-
+
   :lt() Selector
   
     :lt(index)
@@ -11,12 +11,15 @@
   
     :lt(-index)
     1.8
-    
+    
       Zero-based index, counting backwards from the last element. 
     
   
   Select all elements at an index less than index within the matched set.
   
+    
+      As of jQuery 3.4, the :lt pseudo-class is deprecated. Remove it from your selectors and filter the results later using .slice(). For example, :lt(3) can be replaced with a call to .slice( 0, 3 ).
+    
     
       index-related selectors
     
@@ -42,4 +45,5 @@ $( "td:lt(-2)" ).css( "color", "red" );
   
   
   
+  
 
diff --git a/entries/map.xml b/entries/map.xml
index 6fbe68d70..101fa001b 100644
--- a/entries/map.xml
+++ b/entries/map.xml
@@ -3,7 +3,10 @@
   .map()
   
     1.2
-    
+    
+        
+        
+        
       A function object that will be invoked for each element in the current set.
     
   
@@ -66,7 +69,7 @@ $( "p" )
 
   
   
-  
+  
 
 ]]>
   
@@ -132,9 +135,9 @@ $.fn.equalizeHeights = function() {
   return this.height( Math.max.apply( this, maxHeight ) );
 };
 
-$( "input" ).click(function() {
+$( "input" ).on( "click", function() {
   $( "div" ).equalizeHeights();
-});
+} );
 ]]>
     
     
     
     
     300
     
     
     
     
     
   
   
-    This is a playground to see how the selector works with different strings.  Notice that this is different from the :even and :odd which have no regard for parent and just filter the list of elements to every other one.  The :nth-child, however, counts the index of the child to its particular parent.  In any case, it's easier to see than explain so...
+    This is a playground to see how the selector works with different strings.  Notice that this is different from the even and odd which have no regard for parent and just filter the list of elements to every other one.  The :nth-child, however, counts the index of the child to its particular parent.  In any case, it's easier to see than explain so...
     
@@ -94,8 +99,8 @@ $( "button" ).click(function() {
 
   
   
-  
-  
+  
+  
 
 
 
diff --git a/entries/nth-last-child-selector.xml b/entries/nth-last-child-selector.xml
index ce21de1fc..def39a3bd 100644
--- a/entries/nth-last-child-selector.xml
+++ b/entries/nth-last-child-selector.xml
@@ -10,8 +10,8 @@
   
   Selects all elements that are the nth-child of their parent, counting from the last element to the first.
   
-    Because jQuery's implementation of :nth- selectors is strictly derived from the CSS specification, the value of n is "1-indexed", meaning that the counting starts at 1. For other selector expressions such as :eq() or :even jQuery follows JavaScript's "0-indexed" counting. Given a single <ul> containing three <li>s, $( "li:nth-last-child(1)" ) selects the third, last, <li>.
-    Further discussion of this usage can be found in the W3C CSS specification.
+    Because jQuery's implementation of :nth- selectors is strictly derived from the CSS specification, the value of n is "1-indexed", meaning that the counting starts at 1. For other selector expressions such as .first() or .eq() jQuery follows JavaScript's "0-indexed" counting. Given a single <ul> containing three <li>s, $( "li:nth-last-child(1)" ) selects the third, last, <li>.
+    Further discussion of this usage can be found in the W3C CSS specification.
   
   
     Find the second to last li in each matched ul and note it.
@@ -51,7 +51,7 @@ $( "ul li:nth-last-child(2)" ).append( " - 2nd to last!" );
   
     This is a playground to see how the selector works with different strings. 
     
+    
+    
+  
+  
+  
+
diff --git a/entries/off.xml b/entries/off.xml
index 78ab983bd..fba3925c0 100644
--- a/entries/off.xml
+++ b/entries/off.xml
@@ -10,8 +10,9 @@
     
       A selector which should match the one originally passed to .on() when attaching event handlers.
     
-    
+    
       A handler function previously attached for the event(s), or the special value false.
+      
     
   
   
@@ -23,6 +24,12 @@
       A selector which should match the one originally passed to .on() when attaching event handlers.
     
   
+  
+    1.7
+    
+      A jQuery.Event object.
+    
+  
   
     1.7
   
@@ -39,13 +46,13 @@
 function flash() {
   $( "div" ).show().fadeOut( "slow" );
 }
-$( "#bind" ).click(function() {
+$( "#bind" ).on( "click", function() {
   $( "body" )
     .on( "click", "#theone", flash )
     .find( "#theone" )
       .text( "Can Click!" );
 });
-$( "#unbind" ).click(function() {
+$( "#unbind" ).on( "click", function() {
   $( "body" )
     .off( "click", "#theone", flash )
     .find( "#theone" )
diff --git a/entries/offset.xml b/entries/offset.xml
index 02e410160..819232879 100644
--- a/entries/offset.xml
+++ b/entries/offset.xml
@@ -8,17 +8,18 @@
     
     Get the current coordinates of the first element in the set of matched elements, relative to the document.
     
-      The .offset() method allows us to retrieve the current position of an element relative to the document. Contrast this with .position(), which retrieves the current position relative to the offset parent. When positioning a new element on top of an existing one for global manipulation (in particular, for implementing drag-and-drop), .offset() is more useful.
+      The .offset() method allows us to retrieve the current position of an element (specifically its border box, which excludes margins) relative to the document. Contrast this with .position(), which retrieves the current position relative to the offset parent. When positioning a new element on top of an existing one for global manipulation (in particular, for implementing drag-and-drop), .offset() is more useful.
       .offset() returns an object containing the properties top and left.
       
-        Note: jQuery does not support getting the offset coordinates of hidden elements or accounting for borders, margins, or padding set on the body element.
+    Note: jQuery does not support getting the offset coordinates of hidden elements or accounting for margins set on the <html> document element.
         While it is possible to get the coordinates of elements with visibility:hidden set, display:none is excluded from the rendering tree and thus has a position that is undefined.
       
     
-    
+  
+     
       Access the offset of the second paragraph:
       
@@ -34,7 +35,7 @@ p.html( "left: " + offset.left + ", top: " + offset.top );
     
       Click to see the offset.
       
       
   
   
-    Cancel only the default action by using .preventDefault().
+    Cancel only the default action by using .preventDefault().
     
   
   
-    Stop submit events from bubbling without preventing form submit, using .stopPropagation().
+    Stop submit events from bubbling without preventing form submit, using .stopPropagation().
     
+  
+  
+    Pass data to the event handler using the second argument to .trigger()
+    
+  
+  
+    Use the second argument of .trigger() to pass an array of data to the event handler
+    
   
   
@@ -195,7 +230,7 @@ $( "div.test" ).on({
 ]]>
   
   
-    Click any paragraph to add another after it. Note that .on() allows a click event on any paragraph--even new ones--since the event is handled by the ever-present body element after it bubbles to there.
+    Click any paragraph to add another after it. Note that .on() allows a click event on any paragraph--even new ones--since the event is handled by the ever-present body element after it bubbles to there.
     
   
   
-    Cancel a link's default action using the preventDefault method.
+    Cancel a link's default action using the .preventDefault() method:
     
+  
+  
+    Attach multiple events—one on mouseenter and one on mouseleave to the same element:
+    
   
   
diff --git a/entries/one.xml b/entries/one.xml
index 8f55d4aa4..4b98e5f91 100644
--- a/entries/one.xml
+++ b/entries/one.xml
@@ -8,10 +8,11 @@
       A string containing one or more JavaScript event types, such as "click" or "submit," or custom event names.
     
     
-      An object containing data that will be passed to the event handler.
+      Data to be passed to the handler in event.data when an event is triggered.
     
-    
+    
       A function to execute at the time the event is triggered.
+      
     
   
   
@@ -25,8 +26,9 @@
     
       Data to be passed to the handler in event.data when an event is triggered.
     
-    
+    
       A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
+      
     
   
   
@@ -42,13 +44,10 @@
     
   
   
-    The first form of this method is identical to .bind(), except that the handler is unbound after its first invocation. The second two forms, introduced in jQuery 1.7, are identical to .on() except that the handler is removed after the first time the event occurs at the delegated element, whether the selector matched anything or not. For example:
+    The .one() method is identical to .on(), except that the handler for a given element and event type is unbound after its first invocation. For example:
     
 $( "#foo" ).one( "click", function() {
   alert( "This will be displayed only once." );
-});
-$( "body" ).one( "click", "#foo", function() {
-  alert( "This displays if #foo is the first thing clicked in the body." );
 });
     
     After the code is executed, a click on the element with ID foo will display the alert. Subsequent clicks will do nothing. This code is equivalent to:
@@ -60,6 +59,12 @@ $( "#foo" ).on( "click", function( event ) {

In other words, explicitly calling .off() from within a regularly-bound handler has exactly the same effect.

If the first argument contains more than one space-separated event types, the event handler is called once for each event type.


+$( "#foo" ).one( "click mouseover", function( event ) {
+  alert( "The " + event.type + " event happened!" );
+});
+

In the example above the alert could be displayed twice due to the two event types (click and mouseover).

Tie a one-time click to each div. diff --git a/entries/outerHeight.xml b/entries/outerHeight.xml index 678166724..dc53bcb38 100644 --- a/entries/outerHeight.xml +++ b/entries/outerHeight.xml @@ -1,25 +1,30 @@ - + + Get the current computed outer height (including padding, border, and optionally margin) for the first element in the set of matched elements or set the outer height of every matched element. + .outerHeight() 1.2.6 - + A Boolean indicating whether to include the element's margin in the calculation. - Get the current computed height for the first element in the set of matched elements, including padding, border, and optionally margin. Returns an integer (without "px") representation of the value or null if called on an empty set of elements. + Get the current computed outer height (including padding, border, and optionally margin) for the first element in the set of matched elements. -

The top and bottom padding and border are always included in the .outerHeight() calculation; if the includeMargin argument is set to true, the margin (top and bottom) is also included.

This method is not applicable to window and document objects; for these, use .height() instead.

Returns the height of the element, including top and bottom padding, border, and optionally margin, in pixels. If called on an empty set of elements, returns undefined (null before jQuery 3.0).

This method is not applicable to window and document objects; for these, use .height() instead. Although .outerHeight() can be used on table elements, it may give unexpected results on tables using the border-collapse: collapse CSS property.

Figure 1 - Illustration of the measured height

+ + Get the outerHeight of a paragraph. @@ -39,3 +44,72 @@ $( "p:last" ).text( + + + + 1.8 + + + + A number representing the number of pixels, or a number along with an optional unit of measure appended (as a string). + + + A Boolean indicating whether to new value should account for the element's margin. + + + + 1.8 + + + + + + + + A function returning the outer height to set. Receives the index position of the element in the set and the old outer height as arguments. Within the function, this refers to the current element in the set. + + + Set the CSS outer height of each element in the set of matched elements. + +

When calling .outerHeight(value), the value can be either a string (number and unit) or a number. If only a number is provided for the value, jQuery assumes a pixel unit. If a string is provided, however, any valid CSS measurement may be used (such as 100px, 50%, or auto).

+ + + + Change the outer height of each div the first time it is clicked (and change its color). + + + + + + + + + + + diff --git a/entries/outerWidth.xml b/entries/outerWidth.xml index 881e66ced..2c5856bea 100644 --- a/entries/outerWidth.xml +++ b/entries/outerWidth.xml @@ -1,26 +1,30 @@ - + + Get the current computed outer width (including padding, border, and optionally margin) for the first element in the set of matched elements or set the outer width of every matched element. + .outerWidth() 1.2.6 - + A Boolean indicating whether to include the element's margin in the calculation. - Get the current computed width for the first element in the set of matched elements, including padding and border. + Get the current computed outer width (including padding, border, and optionally margin) for the first element in the set of matched elements. -

Returns the width of the element, along with left and right padding, border, and optionally margin, in pixels.

If includeMargin is omitted or false, the padding and border are included in the calculation; if true, the margin is also included.

Returns the width of the element, including left and right padding, border, and optionally margin, in pixels. If called on an empty set of elements, returns undefined (null before jQuery 3.0).

This method is not applicable to window and document objects; for these, use .width() instead. Although .outerWidth() can be used on table elements, it may give unexpected results on tables using the border-collapse: collapse CSS property.

+ + Get the outerWidth of a paragraph. @@ -40,3 +44,72 @@ $( "p:last" ).text( + + + + 1.8 + + + + A number representing the number of pixels, or a number along with an optional unit of measure appended (as a string). + + + A Boolean indicating whether to new value should account for the element's margin. + + + + 1.8 + + + + + + + + A function returning the outer width to set. Receives the index position of the element in the set and the old outer width as arguments. Within the function, this refers to the current element in the set. + + + Set the CSS outer width of each element in the set of matched elements. + +

When calling .outerWidth(value), the value can be either a string (number and unit) or a number. If only a number is provided for the value, jQuery assumes a pixel unit. If a string is provided, however, any valid CSS measurement may be used (such as 100px, 50%, or auto).

+ + + + Change the outer width of each div the first time it is clicked (and change its color). + + + + + + + + + + + diff --git a/entries/parent-selector.xml b/entries/parent-selector.xml index 424cd36ea..bd3fd7436 100644 --- a/entries/parent-selector.xml +++ b/entries/parent-selector.xml @@ -9,7 +9,7 @@

This is the inverse of :empty.

One important thing to note regarding the use of :parent (and :empty) is that child nodes include text nodes.

The W3C recommends that the <p> element have at least one child node, even if that child is merely text (see http://www.w3.org/TR/html401/struct/text.html#edef-P). Some other elements, on the other hand, are empty (i.e. have no children) by definition: <input>, <img>, <br>, and <hr>, for example.

The W3C recommends that the <p> element have at least one child node, even if that child is merely text (see https://www.w3.org/TR/html401/struct/text.html#edef-P). Some other elements, on the other hand, are empty (i.e. have no children) by definition: <input>, <img>, <br>, and <hr>, for example.

To obtain the parents or ancestors of an existing jQuery set, see the .parent() and .parents() methods.

diff --git a/entries/parent.xml b/entries/parent.xml index 0fdf5b73c..4c375255d 100644 --- a/entries/parent.xml +++ b/entries/parent.xml @@ -9,8 +9,8 @@ Get the parent of each element in the current set of matched elements, optionally filtered by a selector. -

Given a jQuery object that represents a set of DOM elements, the .parent() method allows us to search through the parents of these elements in the DOM tree and construct a new jQuery object from the matching elements.

The .parents() and .parent() methods are similar, except that the latter only travels a single level up the DOM tree. Also, $( "html" ).parent() method returns a set containing document whereas $( "html" ).parents() returns an empty set.

Given a jQuery object that represents a set of DOM elements, the parent() method traverses to the immediate parent of each of these elements in the DOM tree and constructs a new jQuery object from the matching elements.

This method is similar to .parents(), except .parent() only travels a single level up the DOM tree. Also, $( "html" ).parent() method returns a set containing document whereas $( "html" ).parents() returns an empty set.

The method optionally accepts a selector expression of the same type that we can pass to the $() function. If the selector is supplied, the elements will be filtered by testing whether they match it.

Consider a page with a basic nested list on it:


diff --git a/entries/parents.xml b/entries/parents.xml
index 403b23936..ab51cde99 100644
--- a/entries/parents.xml
+++ b/entries/parents.xml
@@ -82,7 +82,7 @@ function showParents() {
       .length;
   $( "b" ).text( "Unique div parents: " + len );
 }
-$( "span" ).click(function() {
+$( "span" ).on( "click", function() {
   $( this ).toggleClass( "selected" );
   showParents();
 });
diff --git a/entries/parentsUntil.xml b/entries/parentsUntil.xml
index b2aa8eb7e..93e5e1fa5 100644
--- a/entries/parentsUntil.xml
+++ b/entries/parentsUntil.xml
@@ -12,7 +12,9 @@
   
   
     1.6
-    
+    
+      
+      
       A DOM node or jQuery object indicating where to stop matching ancestor elements.
     
     
diff --git a/entries/password-selector.xml b/entries/password-selector.xml
index 8d632b8f6..053e0dc29 100644
--- a/entries/password-selector.xml
+++ b/entries/password-selector.xml
@@ -13,18 +13,18 @@
   
     Finds all password inputs.

Since .prepend() can accept any number of additional arguments, the same result can be achieved by passing in the three <div>s as three separate arguments, like so: $( "body" ).prepend( $newdiv1, newdiv2, existingdiv1 ). The type and number of arguments will largely depend on how you collect the elements in your code.

+ + Prepends some HTML to all paragraphs. + + + Locate all the divs preceding the last item and wrap them with a div with class wrapper - with or without .uniqueSort(). + + + diff --git a/entries/prevUntil.xml b/entries/prevUntil.xml index 14c468ca2..5e6effb01 100644 --- a/entries/prevUntil.xml +++ b/entries/prevUntil.xml @@ -12,7 +12,9 @@ 1.6 - + + + A DOM node or jQuery object indicating where to stop matching preceding sibling elements. diff --git a/entries/prop.xml b/entries/prop.xml index 541f788fc..5506d40b9 100644 --- a/entries/prop.xml +++ b/entries/prop.xml @@ -2,8 +2,7 @@ Get the value of a property for the first element in the set of matched elements or set one or more properties for every matched element. - - + .prop() 1.6 @@ -43,17 +42,10 @@ $( elem ).attr( "checked" ) - (1.6) + (1.6+) "checked" (String) Initial state of the checkbox; does not change - - - $( elem ).attr( "checked" ) - (1.6.1+) - - "checked" (String) Will change with checkbox state - $( elem ).attr( "checked" ) @@ -63,7 +55,7 @@
-

According to the W3C forms specification, the checked attribute is a boolean attribute, which means the corresponding property is true if the attribute is present at all—even if, for example, the attribute has no value or is set to empty string value or even "false". This is true of all boolean attributes.

Nevertheless, the most important concept to remember about the checked attribute is that it does not correspond to the checked property. The attribute actually corresponds to the defaultChecked property and should be used only to set the initial value of the checkbox. The checked attribute value does not change with the state of the checkbox, while the checked property does. Therefore, the cross-browser-compatible way to determine if a checkbox is checked is to use the property:

@@ -82,13 +74,13 @@
Display the checked property and attribute of a checkbox as it changes.
" ) .parent() - .css({ + .css( { background: "yellow", border: "3px red solid" - }); + } ); $( "div" ) .text( "For this type jQuery found " + input.length + "." ) .css( "color", "red" ); // Prevent form submission -$( "form" ).submit(function( event ) { +$( "form" ).on( "submit", function( event ) { event.preventDefault(); -}); +} ); ]]>
diff --git a/entries/remove.xml b/entries/remove.xml index 6c85e9b4e..4a7ab41cb 100644 --- a/entries/remove.xml +++ b/entries/remove.xml @@ -42,9 +42,9 @@ $( "div" ).remove( ".hello" ); Removes all paragraphs from the DOM diff --git a/entries/removeAttr.xml b/entries/removeAttr.xml index 0dd1abea1..6df348209 100644 --- a/entries/removeAttr.xml +++ b/entries/removeAttr.xml @@ -10,18 +10,19 @@ Remove an attribute from each element in the set of matched elements.
The .removeAttr() method uses the JavaScript removeAttribute() function, but it has the advantage of being able to be called directly on a jQuery object and it accounts for different attribute naming across browsers.
-
Note: Removing an inline onclick event handler using .removeAttr() doesn't achieve the desired effect in Internet Explorer 6, 7, or 8. To avoid potential problems, use .prop() instead:
+
Note: Removing an inline onclick event handler using .removeAttr() doesn't achieve the desired effect in Internet Explorer 8, 9 and 11. To avoid potential problems, use .prop() instead:

$element.prop( "onclick", null ); console.log( "onclick property: ", $element[ 0 ].onclick );
+ Clicking the button changes the title of the input next to it. Move the mouse pointer over the text input to see the effect of adding and removing the title attribute. - - - - - Remove the class 'blue' and 'under' from the matched elements. - - - - - - Remove all the classes from the matched elements. - - - - - - - - - - + + .removeClass() + + 1.0 + + One or more space-separated classes to be removed from the class attribute of each matched element. + + + + 3.3 + + An array of classes to be removed from the class attribute of each matched element. + + + + 1.4 + + + + + A function returning one or more space-separated class names to be removed. Receives the index position of the element in the set and the old class value as arguments. + + + + 3.3 + + + + + + A function returning one or more space-separated class names or an array of class names to be removed. Receives the index position of the element in the set and the old class value as arguments. + + + Remove a single class or multiple classes from each element in the set of matched elements. + +
Before jQuery version 1.12/2.2, the .removeClass() method manipulated the className property of the selected elements, not the class attribute. Once the property was changed, it was the browser that updated the attribute accordingly. This means that when the class attribute was updated and the last class name was removed, the browser might have set the attribute's value to an empty string instead of removing the attribute completely. An implication of this behavior was that this method only worked for documents with HTML DOM semantics (e.g., not pure XML documents).
+
As of jQuery 1.12/2.2, this behavior is changed to improve the support for XML documents, including SVG. Starting from this version, the class attribute is used instead. So, .removeClass() can be used on XML or SVG documents.
+
More than one class may be removed at a time, separated by a space, from the set of matched elements, like so:
+
+ $( "p" ).removeClass( "myClass yourClass" ) +
+
This method is often used with .addClass() to switch elements' classes from one to another, like so:
+
+ $( "p" ).removeClass( "myClass noClass" ).addClass( "yourClass" ); +
+
Here, the myClass and noClass classes are removed from all paragraphs, while yourClass is added.
+
To replace all existing classes with another class, we can use .attr( "class", "newClass" ) instead.
+
As of jQuery 1.4, the .removeClass() method allows us to indicate the class to be removed by passing in a function.
+
+ $( "li" ).last().removeClass(function() { + return $( this ).prev().attr( "class" ); + }); +
+
This example removes the class name of the penultimate <li> from the last <li>.
+ + + Remove the class 'blue' from the matched elements. + + + + + + Remove the class 'blue' and 'under' from the matched elements. + + + + + + Remove the class 'blue' and 'under' from the matched elements (3.3+ syntax). + + + + + + + + + + + + + + + + 1.0 + + Remove all classes from each matched element. + +
Before jQuery version 1.12/2.2, the .removeClass() method manipulated the className property of the selected elements, not the class attribute. Once the property was changed, it was the browser that updated the attribute accordingly. This means that when the class attribute was updated and the last class name was removed, the browser might have set the attribute's value to an empty string instead of removing the attribute completely. An implication of this behavior was that this method only worked for documents with HTML DOM semantics (e.g., not pure XML documents).
+
As of jQuery 1.12/2.2, this behavior is changed to improve the support for XML documents, including SVG. Starting from this version, the class attribute is used instead. So, .removeClass() can be used on XML or SVG documents.
+ + + Remove all the classes from the matched elements. + + + + + + + + + + + diff --git a/entries/removeData.xml b/entries/removeData.xml index 7286016dd..e4dd08b1f 100644 --- a/entries/removeData.xml +++ b/entries/removeData.xml @@ -17,21 +17,24 @@ Remove a previously-stored piece of data. -
The .removeData() method allows us to remove values that were previously set using .data(). When called with the name of a key, .removeData() deletes that particular value; when called with no arguments, all values are removed. Removing data from jQuery's internal .data() cache does not effect any HTML5 data- attributes in a document; use .removeAttr() to remove those.
-
When using .removeData("name"), jQuery will attempt to locate a data- attribute on the element if no property by that name is in the internal data cache. To avoid a re-query of the data- attribute, set the name to a value of either null or undefined (e.g. .data("name", undefined)) rather than using .removeData().
+
The .removeData() method allows us to remove values that were previously set using .data(). When called with the name of a key, .removeData() deletes that particular value. When called with no arguments, .removeData() removes all values.
+
+ Note that .removeData() will only remove data from jQuery's internal .data() cache, and any corresponding data- attributes on the element will not be removed. A later call to data() + will therefore re-retrieve the value from the data- attribute. To prevent this, use .removeAttr() alongside .removeData() to remove the data- attribute as well. Prior to jQuery 1.4.3, + as data() did not use data- attributes, this was not an issue. +

As of jQuery 1.7, when called with an array of keys or a string of space-separated keys, .removeData() deletes the value of each key in that array or string.
-
As of jQuery 1.4.3, calling .removeData() will cause the value of the property being removed to revert to the value of the data attribute of the same name in the DOM, rather than being set to undefined.
Set a data store for 2 names then remove one of them. @@ -117,7 +108,7 @@ $( "p" ).replaceWith( "Paragraph. " ); On click, replace each paragraph with a div that is already in the DOM and selected with the $() function. Notice it doesn't clone the object but rather moves it to replace the paragraph. diff --git a/entries/reset-selector.xml b/entries/reset-selector.xml index 301b0e5e2..db5586086 100644 --- a/entries/reset-selector.xml +++ b/entries/reset-selector.xml @@ -13,18 +13,18 @@ Finds all reset inputs. - + + + + + resize event + Trigger the "resize" event on an element. + + 1.0 + + The string "resize". + + + +
See the description for .on( "resize", ... ).
+ + + + + diff --git a/entries/scroll-shorthand.xml b/entries/scroll-shorthand.xml new file mode 100644 index 000000000..67b7997ed --- /dev/null +++ b/entries/scroll-shorthand.xml @@ -0,0 +1,36 @@ + + + .scroll() + Bind an event handler to the "scroll" event, or trigger that event on an element. + + 1.0 + + A function to execute each time the event is triggered. + + + + + 1.4.3 + + An object containing data that will be passed to the event handler. + + + A function to execute each time the event is triggered. + + + + + 1.0 + + +
+
This API is deprecated.
+
Instead of .scroll( handler ) or .scroll( eventData, handler ), use .on( "scroll", handler ) or .on( "scroll", eventData, handler ), respectively.
+
Instead of .scroll(), use .trigger( "scroll" ).
+
+ + + + + + diff --git a/entries/scroll.xml b/entries/scroll.xml index 080ecdc92..5f46ddfe0 100644 --- a/entries/scroll.xml +++ b/entries/scroll.xml @@ -1,27 +1,27 @@ - - .scroll() - Bind an event handler to the "scroll" JavaScript event, or trigger that event on an element. + + +Bind an event handler to the "scroll" event, or trigger that event on an element. + + scroll event + Bind an event handler to the "scroll" event. - 1.0 - - A function to execute each time the event is triggered. + 1.7 + + The string "scroll". - - - 1.4.3 - + An object containing data that will be passed to the event handler. - + A function to execute each time the event is triggered. + - - 1.0 - -
This method is a shortcut for .on( "scroll", handler ) in the first and second variations, and .trigger( "scroll" ) in the third.
+
+
This page describes the scroll event. For the deprecated .scroll() method, see .scroll().
+

The scroll event is sent to an element when the user scrolls to a different place in the element. It applies to window objects, but also to scrollable frames and elements with the overflow CSS property set to scroll (or auto when the element's explicit height or width is less than the height or width of its contents).

For example, consider the HTML:

@@ -39,26 +39,27 @@ Trigger the handler </div> <div id="log"></div> -
+

Animation Properties and Values

Duration

Complete Function

Callback Functions

Basic Usage

Step Function

Easing

Per-property Easing

Additional Arguments

Easing

Callback Function

Why does this API exist?

Data Types

Sending Data to the Server

Advanced Options

Using Converters

Special units

JSONP

The jqXHR Object

Deprecation Notice

Before $.noConflict(true)

The jqXHR Object

Deprecation Notice

Working With Plain Objects

Local Events

Global Events

Global Events

Events

Contents

String

Anything

String

String

Quoting

Quoting

Built-in Methods

Built-in Methods

Built-in Methods

Length Property

Length Property

Boolean Default

Boolean Default

Boolean Default

htmlString

htmlString

htmlString

Number

Number

Number

Boolean Default

Boolean Default

Boolean Default

Math

Math

Parsing Numbers

Parsing Numbers

Parsing Numbers

Numbers to Strings

Numbers to Strings

Numbers to Strings

NaN and Infinity

NaN and Infinity

NaN and Infinity

Integer

Integer

Float

Float

Boolean

Boolean

Object

Object

Object

Dot Notation

Dot Notation

Dot Notation

Array Notation

Array Notation

Array Notation

Iteration

Iteration