It's important to note that this method does not replace a class. It simply adds the class, appending it to any which may already be assigned to the elements.

Before jQuery version 3.0, the .addClass() 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. 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 3.0 this behavior is changed to improve the support for XML documents, including SVG. Starting from this version, the class attribute is used instead. So, .addClass() can be used on XML or SVG documents.

More than one class may be added at a time, separated by a space, to the set of matched elements, like so:

 $( "p" ).addClass( "myClass yourClass" );
diff --git a/entries/removeClass.xml b/entries/removeClass.xml
index 8bb11196..6a85ea72 100644
--- a/entries/removeClass.xml
+++ b/entries/removeClass.xml
@@ -19,6 +19,8 @@
   Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
   
     
If a class name is included as a parameter, then only that class will be removed from the set of matched elements. If no class names are specified in the parameter, all classes will be removed.
+    
Before jQuery version 3.0, 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 3.0 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" )

From 0e81757e88af8cb820cf294513d0004c63068629 Mon Sep 17 00:00:00 2001
From: Aurelio De Rosa 
Date: Fri, 8 Jan 2016 00:33:39 +0000
Subject: [PATCH 13/16] toggleClass: Document deprecation of a signature

Fixes gh-851
Closes gh-860
---
 entries/toggleClass.xml | 174 +++++++++++++++++++++-------------------
 1 file changed, 90 insertions(+), 84 deletions(-)

diff --git a/entries/toggleClass.xml b/entries/toggleClass.xml
index 1d034d86..5a18aa05 100644
--- a/entries/toggleClass.xml
+++ b/entries/toggleClass.xml
@@ -1,67 +1,62 @@
 
-
-  
-  
-    1.0
-    
-      One or more class names (separated by spaces) to be toggled for each element in the matched set.
-    
-  
-  
-    1.3
-    
-      One or more class names (separated by spaces) to be toggled for each element in the matched set.
-    
-    
-      A Boolean (not just truthy/falsy) value to determine whether the class should be added or removed.
-    
-  
-  
-    1.4
-    
-      A boolean value to determine whether the class should be added or removed.
-    
-  
-  
-    1.4
-    
-      
-      
-      
-        
-      A function that returns class names to be toggled in the class attribute of each element in the matched set. Receives the index position of the element in the set, the old class value, and the state as arguments.
-    
-    
-      A boolean value to determine whether the class should be added or removed.
-    
-  
-  Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the state argument.
-  
-    
This method takes one or more class names as its parameter. In the first version, if an element in the matched set of elements already has the class, then it is removed; if an element does not have the class, then it is added. For example, we can apply .toggleClass() to a simple <div>: 
-    

+
+  
+    
+    
+      1.0
+      
+        One or more class names (separated by spaces) to be toggled for each element in the matched set.
+      
+    
+    
+      1.3
+      
+        One or more class names (separated by spaces) to be toggled for each element in the matched set.
+      
+      
+        A Boolean (not just truthy/falsy) value to determine whether the class should be added or removed.
+      
+    
+    
+      1.4
+      
+        
+        
+        
+        
+        A function that returns class names to be toggled in the class attribute of each element in the matched set. Receives the index position of the element in the set, the old class value, and the state as arguments.
+      
+      
+        A boolean value to determine whether the class should be added or removed.
+      
+    
+    Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the state argument.
+    
+      
This method takes one or more class names as its parameter. In the first version, if an element in the matched set of elements already has the class, then it is removed; if an element does not have the class, then it is added. For example, we can apply .toggleClass() to a simple <div>: 
+      

 <div class="tumble">Some text.</div>
-    
-    
The first time we apply $( "div.tumble" ).toggleClass( "bounce" ), we get the following:
-    

+      
+      
The first time we apply $( "div.tumble" ).toggleClass( "bounce" ), we get the following:
+      

 <div class="tumble bounce">Some text.</div>
-    
-    
The second time we apply $( "div.tumble" ).toggleClass( "bounce" ), the <div> class is returned to the single tumble value:
-    
<div class="tumble">Some text.</div>
-    
Applying .toggleClass( "bounce spin" ) to the same <div> alternates between <div class="tumble bounce spin"> and <div class="tumble">.
-    
The second version of .toggleClass() uses the second parameter for determining whether the class should be added or removed. If this parameter's value is true, then the class is added; if false, the class is removed. In essence, the statement:
-    

+      
+      
The second time we apply $( "div.tumble" ).toggleClass( "bounce" ), the <div> class is returned to the single tumble value:
+      
<div class="tumble">Some text.</div>
+      
Applying .toggleClass( "bounce spin" ) to the same <div> alternates between <div class="tumble bounce spin"> and <div class="tumble">.
+      
The second version of .toggleClass() uses the second parameter for determining whether the class should be added or removed. If this parameter's value is true, then the class is added; if false, the class is removed. In essence, the statement:
+      

 $( "#foo" ).toggleClass( className, addOrRemove );
-    
-    
is equivalent to:
-    

+      
+      
is equivalent to:
+      

 if ( addOrRemove ) {
   $( "#foo" ).addClass( className );
 } else {
   $( "#foo" ).removeClass( className );
 }
-    
-    
As of jQuery 1.4, if no arguments are passed to .toggleClass(), all class names on the element the first time .toggleClass() is called will be toggled. Also as of jQuery 1.4, the class name to be toggled can be determined by passing in a function.
-    

+      
+      
As of jQuery 1.4, if no arguments are passed to .toggleClass(), all class names on the element the first time .toggleClass() is called will be toggled. Also as of jQuery 1.4, the class name to be toggled can be determined by passing in a function.
+      

 $( "div.foo" ).toggleClass(function() {
   if ( $( this ).parent().is( ".bar" ) ) {
     return "happy";
@@ -69,17 +64,17 @@ $( "div.foo" ).toggleClass(function() {
     return "sad";
   }
 });
-
-    
This example will toggle the happy class for <div class="foo"> elements if their parent element has a class of bar; otherwise, it will toggle the sad class.
-  
-  
-    Toggle the class 'highlight' when a paragraph is clicked.
-    
-    
-    
-  
-  
-    Add the "highlight" class to the clicked paragraph on every third click of that paragraph, remove it every first and second click.
-    
-    
-    
-  
-  
-    Toggle the class name(s) indicated on the buttons for each div.
-  
-    
-    
-    
-  
-  
-  
-  
-  
-  
-  
-
+    
+    
+    
+    
+    
+    
+    
+  
+  
+    
+      1.4
+      
+        A boolean value to determine whether the class should be added or removed.
+      
+    
+    
+      
This signature (only!) is deprecated as of jQuery 3.0.
+    
+  
+
\ No newline at end of file

From d3b74ac4c6f5b28bc6535c814c145eb73aa910fb Mon Sep 17 00:00:00 2001
From: Aurelio De Rosa 
Date: Fri, 11 Mar 2016 01:12:46 +0000
Subject: [PATCH 14/16] jQuery.parseJSON: Added deprecation note for jQuery 3

Fixes gh-898
Closes gh-899
---
 entries/jQuery.parseJSON.xml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/entries/jQuery.parseJSON.xml b/entries/jQuery.parseJSON.xml
index bc9dcc78..d0965e41 100644
--- a/entries/jQuery.parseJSON.xml
+++ b/entries/jQuery.parseJSON.xml
@@ -1,5 +1,5 @@
 
-
+
   
   
   
@@ -26,6 +26,7 @@
     
The JSON standard does not permit "control characters" such as a tab or newline. An example like $.parseJSON( '{ "testing":"1\t2\n3" }' ) will throw an error in most implementations because the JavaScript parser converts the string's tab and newline escapes into literal tab and newline; doubling the backslashes like "1\\t2\\n3" yields expected results. This problem is often seen when injecting JSON into a JavaScript file from a server-side language such as PHP.
     
Where the browser provides a native implementation of JSON.parse, jQuery uses it to parse the string. For details on the JSON format, see http://json.org/.
     
Prior to jQuery 1.9, $.parseJSON returned null instead of throwing an error if it was passed an empty string, null, or undefined, even though those are not valid JSON.
+    
As of jQuery 3.0, $.parseJSON is deprecated. To parse JSON objects, use the native JSON.parse method instead.
   
   
     Parse a JSON string.

From 853a06b97d738c406b6fb7267b5040b8674e682d Mon Sep 17 00:00:00 2001
From: Aurelio De Rosa 
Date: Thu, 7 Apr 2016 01:03:27 +0100
Subject: [PATCH 15/16] jQuery.parseHTML: Specified behavior of version 3

Fixes gh-903
Closes gh-907
---
 entries/jQuery.parseHTML.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/entries/jQuery.parseHTML.xml b/entries/jQuery.parseHTML.xml
index 06f59937..9ffcba73 100644
--- a/entries/jQuery.parseHTML.xml
+++ b/entries/jQuery.parseHTML.xml
@@ -17,6 +17,7 @@
   
     
jQuery.parseHTML uses native methods to convert the string to a set of DOM nodes, which can then be inserted into the document. These methods do render all trailing or leading text (even if that's just whitespace). To prevent trailing/leading whitespace from being converted to text nodes you can pass the HTML string through jQuery.trim.
     
By default, the context is the current document if not specified or given as null or undefined. If the HTML was to be used in another document such as an iframe, that frame's document could be used.
+    
As of 3.0 the default behavior is changed. If the context is not specified or given as null or undefined, a new document is used. This can potentially improve security because inline events will not execute when the HTML is parsed. Once the parsed HTML is injected into a document it does execute, but this gives tools a chance to traverse the created DOM and remove anything deemed unsafe. This improvement does not apply to internal uses of jQuery.parseHTML as they usually pass in the current document. Therefore, a statement like $( "#log" ).append( $( htmlString ) ) is still subject to the injection of malicious code.
 	
Security Considerations
 	
Most jQuery APIs that accept HTML strings will run scripts that are included in the HTML. jQuery.parseHTML does not run script in the parsed HTML unless keepScripts is explicitly true. However, it is still possible in most environments to execute script indirectly, for example via the <img onerror> attribute. The caller should be aware of this and guard against it by cleaning or escaping any untrusted inputs from sources such as the URL or cookies. For future compatibility, callers should not depend on the ability to run any script content when keepScripts is unspecified or false.
   

From 4791120eebd71fb0fbd2cbbe29bc8fdf073c8f69 Mon Sep 17 00:00:00 2001
From: Richard Gibson 
Date: Thu, 5 May 2016 18:05:26 -0400
Subject: [PATCH 16/16] jQuery.when: Document changes in 3.0

Ref https://github.com/jquery/jquery/commit/356a3bccb0e7468a2c8ce7d8c9c6cd0c5d436b8b
Fixes gh-921
---
 entries/jQuery.when.xml | 59 ++++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 25 deletions(-)

diff --git a/entries/jQuery.when.xml b/entries/jQuery.when.xml
index 7f053618..5614f998 100644
--- a/entries/jQuery.when.xml
+++ b/entries/jQuery.when.xml
@@ -3,60 +3,69 @@
   
   
     1.5
-    
-      One or more Deferred objects, or plain JavaScript objects.
+    
+      A Promise-like object to resolve a Deferred object, or any value to encapsulate within a Deferred object.
+    
+  
+  
+    1.5
+    
+    Two or values to resolve or encapsulate with Deferred objects for Promise.all-like fulfillment aggregation.
     
   
   Provides a way to execute callback functions based on one or more objects, usually Deferred objects that represent asynchronous events.
   
-    
If a single Deferred is passed to jQuery.when(), its Promise object (a subset of the Deferred methods) is returned by the method. Additional methods of the Promise object can be called to attach callbacks, such as deferred.then. When the Deferred is resolved or rejected, usually by the code that created the Deferred originally, the appropriate callbacks will be called. For example, the jqXHR object returned by jQuery.ajax() is a Promise-compatible object and can be used this way:
+    
If no arguments are provided, jQuery.when() will return a resolved Promise.
+    

+$.when().then(function( x ) {
+  alert( "I fired immediately" );
+});
+    
+    
If a single argument is provided and it is a Promise or has a then method, jQuery.when() will return a Promise that will resolve or reject identically to the argument.
     

 $.when( $.ajax( "test.aspx" ) ).then(function( data, textStatus, jqXHR ) {
   alert( jqXHR.status ); // Alerts 200
 });
     
-    
If a single argument is passed to jQuery.when() and it is not a Deferred or a Promise, it will be treated as a resolved Deferred and any doneCallbacks attached will be executed immediately. The doneCallbacks are passed the original argument. In this case any failCallbacks you might set are never called since the Deferred is never rejected. For example:
+    
If any other single argument is provided, jQuery.when() will return a Promise that is resolved to it.
     

 $.when( { testing: 123 } ).done(function( x ) {
   alert( x.testing ); // Alerts "123"
 });
     
-    
If you don't pass it any arguments at all, jQuery.when() will return a resolved promise.
-    

-$.when().then(function( x ) {
-  alert( "I fired immediately" );
-});
-    
-    
In the case where multiple Deferred objects are passed to jQuery.when(), the method returns the Promise from a new "master" Deferred object that tracks the aggregate state of all the Deferreds it has been passed. The method will resolve its master Deferred as soon as all the Deferreds resolve, or reject the master Deferred as soon as one of the Deferreds is rejected. If the master Deferred is resolved, the doneCallbacks for the master Deferred are executed. The arguments passed to the doneCallbacks provide the resolved values for each of the Deferreds, and matches the order the Deferreds were passed to jQuery.when(). For example:
+    
If more than one argument is provided, jQuery.when() will return the Promise from a new "master" Deferred object that tracks their aggregate state (upgrading each to a Deferred object as in the single-argument case where necessary). The master Deferred will resolve as soon as all subordinates resolve, or reject as soon as one is rejected. If the master Deferred is resolved, the resolution context and values of each subordinate are preserved in its resolution context (an array of all the resolution contexts) and resolution values (the resolution values of each subordinate appear as a single value, with multi-valued resolutions theirselves becoming arrays), each preserving the order in which the subordinate was provided to jQuery.when(). For example:
     

 var d1 = $.Deferred();
 var d2 = $.Deferred();
+var d3 = $.Deferred();
 
-$.when( d1, d2 ).done(function ( v1, v2 ) {
-    console.log( v1 ); // "Fish"
-    console.log( v2 ); // "Pizza"
+$.when( d1, d2 ).done(function ( v1, v2, v3 ) {
+    console.log( v1 );   // "Fish"
+    console.log( v2 );   // ["Pizza", "Pie"]
+    console.log( v3 );   // undefined
+    console.log( this ); // [{ where: "Ocean" }, undefined, undefined]
 });
 
-d1.resolve( "Fish" );
-d2.resolve( "Pizza" );
+d1.resolveWith( { where: "Ocean" }, [ "Fish" ] );
+d2.resolve( "Pizza", "Pie" );
+d3.resolve();
     
-    
In the event a Deferred was resolved with no value, the corresponding doneCallback argument will be undefined. If a Deferred resolved to a single value, the corresponding argument will hold that value. In the case where a Deferred resolved to multiple values, the corresponding argument will be an array of those values. For example:
+    
If more than one argument is provided and one of the arguments is rejected, jQuery.when() immediately rejects with corresponding context and values. Note that some of the subordinates may still be unresolved at that point. For example:
     

 var d1 = $.Deferred();
 var d2 = $.Deferred();
 var d3 = $.Deferred();
 
-$.when( d1, d2, d3 ).done(function ( v1, v2, v3 ) {
-    console.log( v1 ); // v1 is undefined
-    console.log( v2 ); // v2 is "abc"
-    console.log( v3 ); // v3 is an array [ 1, 2, 3, 4, 5 ]
+$.when( d1, d2 ).fail(function ( rejection ) {
+    console.log( rejection ); // "Pie"
+    console.log( this );      // { type: "Pizza" }
 });
 
-d1.resolve();
-d2.resolve( "abc" );
-d3.resolve( 1, 2, 3, 4, 5 );
+d1.resolve( "Fish" );
+d2.rejectWith( { type: "Pizza" }, [ "Pie" ] );
+d3.resolve();
     
-    
In the multiple-Deferreds case where one of the Deferreds is rejected, jQuery.when() immediately fires the failCallbacks for its master Deferred. Note that some of the Deferreds may still be unresolved at that point. The arguments passed to the failCallbacks match the signature of the failCallback for the Deferred that was rejected. If you need to perform additional processing for this case, such as canceling any unfinished ajax requests, you can keep references to the underlying jqXHR objects in a closure and inspect/cancel them in the failCallback.
+    
Regardless of provided arguments, methods of the returned Promise object can be called to attach callbacks, such as deferred.then. When the Deferred is resolved or rejected, usually by the code that created the Deferred originally, the appropriate callbacks will be called.
   
   
     Execute a function after two ajax requests are successful. (See the jQuery.ajax() documentation for a complete description of success and error cases for an ajax request).