diff --git a/pages/license.md b/pages/license.md
index 4bbf3ab..fcf9049 100644
--- a/pages/license.md
+++ b/pages/license.md
@@ -1,6 +1,8 @@
-
+}
+
**Note:** For the purposes of this document, the term "Project" will refer to any [OpenJS Foundation](https://openjsf.org/projects/) project using the MIT license **AND** referencing this document in the header of the distributed Project code or Project website source code.
@@ -14,7 +16,7 @@ You are free to use the Project in any other project (even commercial projects)
## Sample Code
-All demos and examples, whether in a Project's repository or displayed on a Project site, are released under the terms of the license as specified in the relevant repository. Many Projects choose to release their sample code under the terms of [CC0](https://tldrlegal.com/l/cc0-1.0).
+All demos and examples, whether in a Project's repository or displayed on a Project site, are released under the terms of the license as specified in the relevant repository. Many Projects choose to release their sample code under the terms of [CC0](https://www.tldrlegal.com/license/creative-commons-cc0-1-0-universal).
CC0 is even more permissive than the MIT license, allowing you to use the code in any manner you want, without any copyright headers, notices, or other attribution.
diff --git a/pages/meetups.md b/pages/meetups.md
index acdcbcd..aaaa9a2 100644
--- a/pages/meetups.md
+++ b/pages/meetups.md
@@ -1,6 +1,8 @@
-
+}
+
Meetups are a great way to meet other community members, expand your knowledge,
socialize, and show off what you've been working on.
diff --git a/pages/support.md b/pages/support.md
index ee17e3d..dc083a5 100644
--- a/pages/support.md
+++ b/pages/support.md
@@ -4,6 +4,22 @@
}
+## Supported versions
+
+We support only the latest version of jQuery. The 1.x and 2.x branches are no longer supported.
+
+jQuery 3.x will only receive critical security patches and bug fixes. We encourage all users to upgrade to the latest version of jQuery 4.x.
+
+jQuery 4.x is the current version branch of jQuery.
+
+### Unsupported versions
+
+When using a version earlier than the latest version, there are a few options:
+
+* [Upgrade](/download#upgrade) to the latest version of jQuery. The best solution is to upgrade as it will include all features, bug fixes, security patches, and improvements. The [jQuery Migrate Plugin](https://github.com/jquery/jquery-migrate) and [upgrade guides](/upgrade-guide) are available to assist with upgrading.
+* Continue using an older version of jQuery, but include all security patches through [commercial security support](#commercial-support).
+* Continue using an older version of jQuery without security patches. **However, this can come with multiple risks.**
+
## Community support
The following learning resources are available online and free of charge:
@@ -27,17 +43,11 @@ We are on [Libera Chat IRC](https://libera.chat/) in the `#jquery` channel where
StackOverflow is a great place to ask questions and find support for all jQuery projects. Search or create [questions tagged with "jquery"](https://stackoverflow.com/questions/tagged/jquery), or refer to the ["jquery" tag introduction](https://stackoverflow.com/tags/jquery/info).
-### Archives
-
-* [Freenode IRC chat channels](https://irc.jquery.org/) (2011-2021)
-* [jQuery Forum](https://forum.jquery.com/) (2010-2021): For questions and advice regarding jQuery Core, jQuery UI, Themeroller, QUnit, development of jQuery Plugins, and more.
-* [jQuery Accessibility mailing list](https://groups.google.com/group/jquery-a11y) (2008-2016).
-
## Commercial support
The following companies offer commercial support services for jQuery.
-* **[Bocoup](https://bocoup.com/)** builds complex cross device and cross platform JavaScript software for startups, the Fortune 500, and federally funded education projects. Bocoup offers in-depth JavaScript training on a number of subjects including jQuery. Learn more at
or contact at
.
+[HeroDevs](https://www.herodevs.com/support/jquery-nes?utm_source=jQuery&utm_medium=link&utm_campaign=eol_support_jQuery) offers security and compatibility support for EOL versions of jQuery through the [OpenJS Ecosystem Sustainability Program](https://openjsf.org/ecosystem-sustainability-program) and is an approved commercial support vendor. Find out more about their [Never Ending Support options](https://www.herodevs.com/support/jquery-nes?utm_source=jQuery&utm_medium=link&utm_campaign=eol_support_jQuery).
-------
@@ -72,3 +82,12 @@ For guidance on branding and trademark usage, visit
.
For reporting bugs in libraries, documentation, or content, the project's GitHub issue tracker should be used. All jQuery projects can be found at https://github.com/jquery
Still haven't found what you're looking for? Please feel free to contact: [info@jquery.com](mailto:info@jquery.com)
+
+-------
+
+## Archives
+
+* [Freenode IRC chat channels](https://irc.jquery.org/) (2011-2021)
+* [jQuery Forum](https://forum.jquery.com/) (2010-2021): For questions and advice regarding jQuery Core, jQuery UI, Themeroller, QUnit, development of jQuery Plugins, and more.
+* [jQuery Accessibility mailing list](https://groups.google.com/group/jquery-a11y) (2008-2016).
+
diff --git a/pages/team.html b/pages/team.html
index caa2513..a0ad9c3 100644
--- a/pages/team.html
+++ b/pages/team.html
@@ -1,14 +1,14 @@
@@ -111,7 +111,7 @@ Past Team Members
Corey Quinn
Web
Philippe Rathé
QUnit
John Resig
Creator of the jQuery Library | Emeritus Member (formerly jQuery Foundation)
Alex Schmitz
Mobile Lead | UI | PEP | Chassis | Infrstructure | Standards
Alex Schmitz
Mobile Lead | UI | PEP | Chassis | Infrastructure | Standards
Gabriel Schulhof
Project Representative (formerly jQuery Foundation)
Jason Scott
Mobile
Ghislain Seguin
Mobile
Testing
").appendTo("body")` are unaffected by this change.
+If a string is known to be HTML but may start with arbitrary text that is not an HTML tag, pass it to `jQuery.parseHTML()` which will return an array of DOM nodes representing the markup. A jQuery collection can be created from this, for example: `$( $.parseHTML( htmlString ) )`. This would be considered best practice when processing HTML templates for example. Simple uses of literal strings such as `$( "Testing
" ).appendTo( "body" )` are unaffected by this change.
Bottom line: HTML strings passed to `jQuery()` that start with something other than a less-than character will be interpreted as a selector. Since the string usually cannot be interpreted as a selector, the most likely result will be an "invalid selector syntax" error thrown by the Sizzle selector engine. Use `jQuery.parseHTML()` to parse arbitrary HTML.
@@ -98,7 +102,7 @@ When the jQuery Migrate plugin is used, it will use the old rules for determinin
### Events not fired by the .data() method; names with periods
-The `.data()` method had an undocumented and incredibly non-performant way to monitor setting and getting of values that was removed in 1.9. This has affected the interpretation of data names that contain periods, in a good way. As of 1.9, a call to `.data("abc.def")` retrieves the data for the name "abc.def" _only_, and never just "abc". Note that the lower-level `jQuery.data()` method never supported events and so it has not changed. The jQuery Migrate plugin does _not_ restore the old behavior for this case.
+The `.data()` method had an undocumented and incredibly non-performant way to monitor setting and getting of values that was removed in 1.9. This has affected the interpretation of data names that contain periods, in a good way. As of 1.9, a call to `.data( "abc.def" )` retrieves the data for the name "abc.def" _only_, and never just "abc". Note that the lower-level `jQuery.data()` method never supported events and so it has not changed. The jQuery Migrate plugin does _not_ restore the old behavior for this case.
### Ordering of disconnected nodes within a jQuery set
@@ -124,14 +128,14 @@ Here are some examples of correct usage when setting `checked` on a checkbox; th
```js
// Correct if changing the attribute is desired
-$(elem).attr("checked", "checked");
+$( elem ).attr( "checked", "checked" );
// Correct for checking the checkbox
-$(elem).prop("checked", true);
+$( elem ).prop( "checked", true );
// Correct if removing the attribute is desired (rare)
-$(elem).removeAttr("checked");
+$( elem ).removeAttr( "checked" );
// Correct for clearing the checkbox
-$(elem).prop("checked", false);
+$( elem ).prop( "checked", false );
```
The `value` property versus attribute on `input` elements is another example of this ambiguity. The attribute generally reflects the value that was read from the HTML markup; the property reflects the current value. Since the `.val()` method is the recommended jQuery way to get or set the values of form elements, this confusion usually does not affect users.
@@ -140,7 +144,7 @@ However, when a selector like `"input[value=abc]"` is used, it should always sel
The jQuery Migrate plugin restores the old attribute-vs-property rules.
-### $("input").attr("type", newValue) in oldIE
+### $( "input" ).attr( "type", newValue ) in oldIE
Prior to version 1.9, jQuery would throw an exception in all browsers for any attempt to set the `type` attribute on an input or button element. This was done to accommodate the lowest common denominator; IE 6/7/8 throw an error if you attempt to change the type of an input element. As of jQuery 1.9, we allow you to set the type of an element if the browser allows it. However, your own code will need to be aware that attempting to do this on oldIE will still throw an error. The jQuery Migrate plugin warns when you attempt to set the `type` attribute but does not throw a JavaScript error.
@@ -154,7 +158,7 @@ The remaining purpose of the deprecated `.selector` property on a jQuery object
### jQuery.attr()
-In 1.9 we have removed the undocumented signature jQuery.attr(elem, name, value, pass) using the pass argument. Any code that depended on this should be rewritten, but the jQuery Migrate plugin can provide backward-compatible behavior and will warn if this signature is used.
+In 1.9 we have removed the undocumented signature `jQuery.attr( elem, name, value, pass )` using the pass argument. Any code that depended on this should be rewritten, but the jQuery Migrate plugin can provide backward-compatible behavior and will warn if this signature is used.
### jQuery.ajax returning a JSON result of an empty string
@@ -162,11 +166,11 @@ Prior to 1.9, an ajax call that expected a return data type of JSON or JSONP wou
### jQuery.proxy() context
-New in 1.9, the function returned by calling jQuery.proxy with a falsy context will preserve its `this` object for the provided function. Previously, a falsy value for context would get translated into the global object (window) if null/undefined, or else wrapped in an object (e.g., new Boolean(false)).
+New in 1.9, the function returned by calling jQuery.proxy with a falsy context will preserve its `this` object for the provided function. Previously, a falsy value for context would get translated into the global object (window) if null/undefined, or else wrapped in an object (e.g., `new Boolean( false )`).
-### .data("events")
+### .data( "events" )
-Prior to 1.9, `.data("events")` could be used to retrieve jQuery's undocumented internal event data structure for an element if no other code had defined a data element with the name "events". This special case has been removed in 1.9. There is no public interface to retrieve this internal data structure, and it remains undocumented. However, the jQuery Migrate plugin restores this behavior for code that depends upon it.
+Prior to 1.9, `.data( "events" )` could be used to retrieve jQuery's undocumented internal event data structure for an element if no other code had defined a data element with the name "events". This special case has been removed in 1.9. There is no public interface to retrieve this internal data structure, and it remains undocumented. However, the jQuery Migrate plugin restores this behavior for code that depends upon it.
### Removed properties of the Event object
diff --git a/pages/upgrade-guide/3.0.md b/pages/upgrade-guide/3.0.md
index 3cbdf52..a6a22e2 100644
--- a/pages/upgrade-guide/3.0.md
+++ b/pages/upgrade-guide/3.0.md
@@ -52,7 +52,7 @@ Changes are listed by their component category, and prefixed with a description
Remember that the jQuery Migrate plugin described above can detect and warn about many of these changes so that they can be fixed in your code.
-For a complete and detailed list of all code changes, see the 3.0 milestone in the [jQuery Core issue tracker](https://github.com/jquery/jquery/issues?q=is%3Aopen+is%3Aissue+milestone%3A3.0.0) or the [version diff](https://github.com/jquery/jquery/compare/2.2-stable...master).
+For a complete and detailed list of all code changes, see the 3.0 milestone in the [jQuery Core issue tracker](https://github.com/jquery/jquery/issues?q=is%3Aissue+milestone%3A3.0.0) or the [version diff](https://github.com/jquery/jquery/compare/2.2.4...3.0.0).
### Ajax
#### Breaking change: Special-case Deferred methods removed from jQuery.ajax
@@ -128,10 +128,10 @@ https://bugs.jquery.com/ticket/13335
The document-ready processing in jQuery has been powered by the `jQuery.Deferred` implementation since jQuery 1.6. As part of jQuery 3.0's alignment with the Promises/A+ standard, document-ready handlers are called asynchronously even if the document is currently ready at the point where the handler is added. This provides a consistent code execution order that is independent of whether the document is ready or not. For example, consider this code:
```js
-$(function(){
- console.log("ready");
-});
-console.log("outside ready");
+$( function() {
+ console.log( "ready" );
+} );
+console.log( "outside ready" );
```
In jQuery 3.0 this will always log "outside ready" followed by "ready" regardless of whether the document is ready at the point of execution. Earlier versions may log the messages in either order.
@@ -186,12 +186,12 @@ https://github.com/jquery/jquery/issues/2319
jQuery 3.0 supports the `for...of` loop introduced in ES2015. It allows looping over iterable objects including `Array`, `Map`, and `Set`. When using this loop, the value obtained is a DOM element of the jQuery collection, one at a time. Note that you will need to be using an environment that supports ES2015 or a transpiler such as Babel to use `for...of`. Here is an example:
```js
-var elems = $(".someclass");
+var elems = $( ".someclass" );
// Classic jQuery way
-$.each(function(i, elem) {
+$.each( function( i, elem ) {
// work with elem (or "this" object)
-});
+} );
// Prettier ES2015 way
for ( let elem of elems ) {
@@ -206,11 +206,11 @@ https://github.com/jquery/jquery/issues/1693
`jQuery.ready` has been consumable as a promise-like object ("thenable" in Promise terms) since jQuery version 1.8. As of jQuery 3.0 this object is documented as supported via `jQuery.when` or the native `Promise.resolve()`. No code should make assumptions about whether this object is a jQuery `Deferred` or some other type of promise object such as a native Promise. Typical usage might look like this:
```js
-$.when( $.ready, $.getScript("optional.js") ).then(function() {
+$.when( $.ready, $.getScript( "optional.js" ) ).then( function() {
// the document is ready and optional.js has loaded/run
-}).catch( function() {
+} ).catch( function() {
// an error occurred
-});
+} );
```
https://github.com/jquery/api.jquery.com/pull/530
@@ -226,17 +226,17 @@ Since all the browsers supported by jQuery 3.0 support the native `JSON.parse()`
https://github.com/jquery/jquery/issues/2800
-#### Deprecated: document-ready handlers other than `jQuery(function)`
+#### Deprecated: document-ready handlers other than `jQuery( function )`
Due to historical compatibility issues there are a multitude of ways to set a document ready handler. All of the following are equivalent and call the function `fn` when the document is ready:
```js
-$(fn);
-$().ready(fn);
-$(document).ready(fn);
-$("selector").ready(fn);
+$( fn );
+$().ready( fn );
+$( document ).ready( fn );
+$( "selector" ).ready( fn );
```
-As of jQuery 3.0 the recommended way to add a ready handler is the first method, `$(fn)`. As noted in the Event section, the `$(document).on("ready", fn)` event form has slightly different semantics and was removed in jQuery 3.0.
+As of jQuery 3.0 the recommended way to add a ready handler is the first method, `$(fn)`. As noted in the Event section, the `$( document ).on( "ready", fn )` event form has slightly different semantics and was removed in jQuery 3.0.
### Data
@@ -244,24 +244,24 @@ As of jQuery 3.0 the recommended way to add a ready handler is the first method
As of jQuery 3.0, all data names are stored in jQuery's internal data object in camelCase (e.g., `clickCount`), rather than kebab-case (e.g. `click-count`). This is consistent with the way that standard DOM turns dashed names into camel case for JavaScript names in CSS and data properties.
-In general, kebab case still works in jQuery 3.0 when setting or getting a specific data item, e.g. `.data("right-aligned")`, but if you retrieve the internal data object it will now have the data item in camel case (`rightAligned`). The main difference in 3.0 is when you use kebab case names directly on the data object instead of using the `.data()` API to get or set them.
+In general, kebab case still works in jQuery 3.0 when setting or getting a specific data item, e.g. `.data( "right-aligned" )`, but if you retrieve the internal data object it will now have the data item in camel case (`rightAligned`). The main difference in 3.0 is when you use kebab case names directly on the data object instead of using the `.data()` API to get or set them.
For example:
```js
-var $div = $("");
-$div.data("clickCount", 2);
-$div.data("clickCount"); // 2
-$div.data("click-count", 3);
-$div.data("clickCount"); // 3
-$div.data("click-count"); // 3
+var $div = $( "" );
+$div.data( "clickCount", 2 );
+$div.data( "clickCount" ); // 2
+$div.data( "click-count", 3 );
+$div.data( "clickCount" ); // 3
+$div.data( "click-count" ); // 3
var allData = $div.data();
allData.clickCount; // 3
-allData["click-count"]; // undefined
-allData["click-count"] = 14;
-$div.data("click-count"); // 3, NOT 14 as it would be in jQuery 2.x
+allData[ "click-count" ]; // undefined
+allData[ "click-count" ] = 14;
+$div.data( "click-count" ); // 3, NOT 14 as it would be in jQuery 2.x
allData.clickCount; // 3
-allData["click-count"]; // 14
+allData[ "click-count" ]; // 14
```
https://github.com/jquery/jquery/issues/2070
@@ -292,30 +292,30 @@ In jQuery 1.x and 2.x, an uncaught exception inside a callback function halts co
For example, consider this code using the new standard Promises/A+ behavior:
```js
-$.ajax("/status")
- .then(function(data) {
+$.ajax( "/status" )
+ .then( function( data ) {
whoops();
// console shows "jQuery.Deferred exception: whoops is not a function"
// no further code executes in this function
- })
- .catch(function(arg) {
+ } )
+ .catch( function( arg ) {
// this code executes after the error above
// arg is an Error object, "whoops is not a function"
- });
+ } );
```
Compare that to the old-style Deferred methods:
```js
-$.ajax("/status")
- .done(function(data) {
+$.ajax( "/status" )
+ .done( function( data ) {
whoops();
// console shows: "whoops is not a function"
// no further code executes in this function
- })
- .fail(function(arg) {
+ } )
+ .fail( function( arg ) {
// this code does not execute since the exception was not caught
- });
+ } );
```
Note that jQuery logs a message to the console when it is inside a Deferred and a JavaScript exception occurs. These messages take the form `jQuery.Deferred exception: (error message)`. If you do not want any console output on these exceptions, set `jQuery.Deferred.exceptionHook` to `undefined`. If you need further help in finding errors reported this way, use the [jquery-deferred-reporter plugin](https://github.com/dmethvin/jquery-deferred-reporter) during development to obtain stack traces.
@@ -328,7 +328,7 @@ The Promises/A+ spec says that promises are always resolved with a single va
```js
// Typical old uses of .then() that are not Promises/A+ compatible
-$.ajax("url").then(
+$.ajax( "url" ).then(
// success
function( data, textStatus, jqXHR ) { /* code */ },
// error
@@ -336,11 +336,11 @@ $.ajax("url").then(
);
// Rewrite to this in order to maintain previous behavior
-$.ajax("url")
+$.ajax( "url" )
// success
- .done(function( data, textStatus, jqXHR ) { /* code */ })
+ .done( function( data, textStatus, jqXHR ) { /* code */ } )
// error
- .fail(function( jqXHR, textStatus, errorThrown ) { /* code */ });
+ .fail( function( jqXHR, textStatus, errorThrown ) { /* code */ } );
```
Another behavior change required for Promises/A+ compliance is that Deferred `.then()` callbacks are *always* called asynchronously. Previously, if a `.then()` callback was added to a Deferred that was already resolved or rejected, the callback would run immediately and synchronously.
@@ -370,7 +370,7 @@ https://github.com/jquery/jquery/issues/2710
### Dimensions
-#### Breaking change: .width(), .height(), .css("width"), and .css("height") can return non-integer values
+#### Breaking change: .width(), .height(), .css( "width" ), and .css( "height" ) can return non-integer values
Before version 3.0, jQuery used the DOM `offsetWidth` and `offsetHeight` properties to determine the dimensions of an element, and these properties always return integers. With jQuery 3.0 we get more precise values via the DOM `getBoundingClientRect` API, and these may not be integers. If your code always expects integers for dimensions, it may need to be adjusted to deal with this extra precision.
@@ -410,14 +410,14 @@ The easing functions called by `.animate()` are passed single argument, the perc
Example of an old easing method:
```js
-$.easing.easeInOutSine = function (x, t, b, c, d) {
- return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+$.easing.easeInOutSine = function( x, t, b, c, d ) {
+ return -c / 2 * ( Math.cos( Math.PI * t / d ) - 1 ) + b;
};
```
The same easing method rewritten:
```js
-$.easing.easeInOutSine = function (x) {
- return -0.5*(Math.cos(Math.PI*x) - 1);
+$.easing.easeInOutSine = function( x ) {
+ return -0.5 * ( Math.cos( Math.PI * x ) - 1 );
};
```
@@ -428,11 +428,11 @@ https://github.com/jquery/api.jquery.com/issues/912
#### Breaking change: .load(), .unload(), and .error() removed
-These methods are shortcuts for event operations, but had several API limitations. The event `.load()` method conflicted with the ajax `.load()` method. The `.error()` method could not be used with `window.onerror` because of the way the DOM method is defined. If you need to attach events by these names, use the `.on()` method, e.g. change `$("img").load(fn)` to `$("img").on("load", fn)`.
+These methods are shortcuts for event operations, but had several API limitations. The event `.load()` method conflicted with the ajax `.load()` method. The `.error()` method could not be used with `window.onerror` because of the way the DOM method is defined. If you need to attach events by these names, use the `.on()` method, e.g. change `$( "img" ).load( fn )` to `$( "img" ).on( "load", fn )`.
https://github.com/jquery/jquery/issues/2286
-#### Breaking change: `.on("ready", fn)` removed
+#### Breaking change: `.on( "ready", fn )` removed
jQuery no longer supports a synthetic event named `"ready"` that can be used with the event functions. This event was error-prone and deprecated in jQuery 1.8 because it would only call the callback if it was attached before the document was ready. Replace any uses with `$(fn)` instead, which works reliably.
@@ -464,9 +464,9 @@ Five years ago in jQuery 1.7 we introduced the `.on()` method for attaching even
### Manipulation
-#### Breaking change: `.wrapAll(function)` only calls the function once
+#### Breaking change: `.wrapAll( function )` only calls the function once
-In previous versions, the `.wrapAll()` method acted like `.wrap()` when a function was passed. This has been corrected; now and `.wrapAll(function)` calls its function once, using the string result of the function call to wrap the entire collection.
+In previous versions, the `.wrapAll()` method acted like `.wrap()` when a function was passed. This has been corrected; now and `.wrapAll( function )` calls its function once, using the string result of the function call to wrap the entire collection.
https://github.com/jquery/jquery/issues/1843
@@ -490,9 +490,9 @@ An element is considered now visible if it has a layout box returned from the DO
https://github.com/jquery/jquery/issues/2227
https://github.com/jquery/jquery/issues/2604
-#### Breaking change: `jQuery("#")` and `.find("#")` are invalid syntax
+#### Breaking change: `jQuery( "#" )` and `.find( "#" )` are invalid syntax
-jQuery 3.0 throws a syntax error if a selector string consists of nothing but a hash-mark. In previous versions, `$("#")` returned an empty collection and `.find("#")` threw an error.
+jQuery 3.0 throws a syntax error if a selector string consists of nothing but a hash-mark. In previous versions, `$("#")` returned an empty collection and `.find( "#" )` threw an error.
https://github.com/jquery/jquery/pull/1682
diff --git a/pages/upgrade-guide/4.0.md b/pages/upgrade-guide/4.0.md
new file mode 100644
index 0000000..2983cf1
--- /dev/null
+++ b/pages/upgrade-guide/4.0.md
@@ -0,0 +1,287 @@
+
+
+## Overview
+
+With the major version of 4.0, the jQuery Core team has taken the opportunity to make changes to clean up the API and fix bugs that may prove to be breaking changes for some. This includes the removal of previously deprecated public APIs, changes to or removal of undocumented APIs, and changes to the documented or undocumented behavior of existing APIs for specific inputs.
+
+## Browser Support
+
+As of jQuery 4.0, the following browsers are supported:
+
+* Internet Explorer: 11 only
+* Chrome, Edge, Firefox, Safari: Current and Current - 1
+* Opera: Current
+* Safari Mobile iOS: Current, Current - 1, and Current - 2
+* Android: Current and Current - 1
+
+### Browsers no longer supported
+
+* Edge: Legacy (non-Chromium) versions
+* Internet Explorer: 10 and below
+* Safari Mobile iOS: All versions older than Current - 2
+* Android: All versions older than Current - 1
+
+Browser support will not change until the next major version of jQuery (5.0).
+
+## jQuery Migrate Plugin
+
+A new version of the [jQuery Migrate Plugin](https://github.com/jquery/jquery-migrate/#README) is available to simplify migration of older code to version 4.0. We strongly recommend that you use this plugin as an upgrading tool, it will give specific advice about most of the major changes that may affect your code.
+
+[Version 4.0 of the jQuery Migrate Plugin](https://github.com/jquery/jquery-migrate/#README) *does not* warn about or restore behaviors that were removed in previous major version changes such as jQuery 1.0, 2.0, or 3.0. Use the following steps to upgrade from a version of jQuery older than 1.11.0 or 2.1.0 to this new version 4.0:
+
+### Start here if currently using jQuery 1.x or 2.x
+
+1. Upgrade the version of jQuery on the page to the latest 1.x or 2.x version.
+1. Add the uncompressed [jQuery Migrate 1.x Plugin](https://github.com/jquery/jquery-migrate/tree/1.x-stable) to the page.
+1. (Optional but recommended) Upgrade any plugins in use since later versions are usually the most compatible with recent versions of jQuery.
+1. Test the page and resolve any warnings that appear on the console, using the [JQMIGRATE 1.x warning documentation](https://github.com/jquery/jquery-migrate/tree/1.x-stable/warnings.md) as a guide.
+1. Remove the jQuery Migrate plugin and ensure that the updated jQuery code on the page continues to work properly with only the latest jQuery 1.x/2.x in use.
+
+### Start here if currently using the latest jQuery 1.x or 2.x version
+
+1. Upgrade the version of jQuery on the page to the latest 3.x version.
+1. Add the uncompressed [jQuery Migrate 3.x Plugin](https://github.com/jquery/jquery-migrate/tree/3.x-stable) to the page.
+1. (Optional but recommended) Upgrade any plugins in use since later versions are usually the most compatible with recent versions of jQuery.
+1. Test the page and resolve any warnings that appear on the console, using the [JQMIGRATE 3.x warning documentation](https://github.com/jquery/jquery-migrate/tree/3.x-stable/warnings.md) as a guide.
+1. Remove the jQuery Migrate plugin and ensure that the updated jQuery code on the page continues to work properly with only the latest jQuery 3.x in use.
+
+### Start here if currently using jQuery 3.x
+
+1. Upgrade the version of jQuery on the page to the latest 4.x version.
+1. Add the uncompressed [jQuery Migrate 4.x plugin](https://github.com/jquery/jquery-migrate/) to the page.
+1. (Optional but recommended) Upgrade any plugins in use since later versions are usually the most compatible with recent versions of jQuery.
+1. Test the page and resolve any warnings that appear on the console, using the [JQMIGRATE 4.x warning documentation](https://github.com/jquery/jquery-migrate/blob/master/warnings.md) as a guide. Report any bugs in third-party plugins to the plugin authors.
+1. Remove the jQuery Migrate plugin and ensure that the updated jQuery code on the page continues to work properly with only the latest jQuery 4.x in use.
+
+> [!Note]
+> jQuery Migrate 1.x and 3.x are in maintenance mode and will only receive updates for critical bugs. jQuery Migrate 3.x can be used to migrate to the latest jQuery 3.x if support for older browsers is needed.
+
+**Running multiple version of jQuery Migrate simultaneously is not supported.**
+
+The uncompressed development version of the Migrate plugin includes console log output to warn when specific deprecated and/or removed features are being used. This makes it valuable as a migration debugging tool for finding and remediating issues in existing jQuery code and plugins.
+
+The compressed version of the Migrate plugin does not generate any warnings, although it does issue a solitary console message that it has been included on the page. Migrate can be used on production sites when jQuery 3.0 or higher is desired but older incompatible jQuery code or plugins must also be used. Ideally this is only used as a short-term solution, since restoring old behavior may cause conflicts with new jQuery code that expects the new behavior.
+
+## Summary of Important Changes
+
+With a library as widely used as jQuery, it is often difficult for the team to know which changes may impact developers the most before a release occurs. Despite the length of this list, we believe that the majority are edge cases. Many jQuery projects should be able to run version 4.0 with only minor changes, if any.
+
+Changes are listed by their component category, and prefixed with a description to help you understand its impact:
+
+* **Breaking change:** This change *may* affect existing code, since it changes the API surface in some way. Most of the time the impacts are only for specific edge cases as noted.
+* **Feature:** The change is an API addition and should not affect existing code in most cases. However, there is the possibility that new features can interact negatively with existing code.
+* **Deprecated:** This feature or API is still present in jQuery 4.0, but its use is discouraged. It may be removed in a future major-version update.
+
+Remember that the jQuery Migrate plugin described above can detect and warn about many of these changes so that they can be fixed in your code.
+
+For a complete and detailed list of all code changes, see the milestone in the [jQuery Core issue tracker](https://github.com/jquery/jquery/issues?q=is%3Aissue+milestone%3A4.0.0).
+
+jQuery 4.0.0 is compatible with jQuery UI 1.13.3 or newer.
+
+### Ajax
+
+#### Breaking change: JSON to JSONP auto-promotion removed
+
+Previously, `jQuery.ajax` with `dataType: "json"` with a provided callback was automatically converted to a JSONP request unless one also specified `jsonp: false`. Today, the preferred way of interacting with a cross-domain backend is CORS, which works in all browsers jQuery 4 supports.
+
+Auto-promoting JSON requests to JSONP introduced a security issue. The developer may be unaware they are executing code from a remote domain. The auto-promoting logic has been disabled.
+
+To trigger a JSONP request, it's now required to specify `dataType: "jsonp"`.
+
+#### Breaking change: Scripts are no longer auto-executed without `dataType: "script"`
+
+jQuery 3.0.0 had already stopped auto-executing scripts retrieved with `jQuery.ajax` unless `dataType: "script"` was explicitly set for cross-domain scripts. That change has now been extended to same-domain scripts.
+
+To fetch *and* evaluate a script, pass `dataType: "script"` in `jQuery.ajax` options or use `jQuery.getScript`.
+
+#### Breaking change: Script tags now used for all async requests
+
+Until jQuery 4.0, the AJAX script transport only used a script tag to load scripts for cross-domain requests or ones with `scriptAttrs` set. We now always use a script tag for async requests to avoid any [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) errors.
+
+This change may affect existing code if certain scripts were expected to execute even when CSP headers were set. Either modify the CSP header to allow scripts from the same domain or remove the scripts.
+
+#### Potentially breaking change: `jQuery.ajax` now supports binary data
+
+jQuery 4.0 adds support for binary data in `jQuery.ajax` requests by adding support for `FormData` objects passed to the `data` argument. This change may affect existing code that relies on the previous behavior of `jQuery.ajax` when passing non-serializable data types, especially code that relies on the order of the execution of Ajax prefilters. Before, data was converted to a string before prefilters could be applied. Still, we don't expect this change to affect most users.
+
+### Attributes
+
+#### Breaking change: `toggleClass( Boolean | undefined )` signature removed
+
+This particular signature was deprecated in jQuery 3.0 and is now being removed in jQuery 4.0. After feedback and discussion with the community, it was determined that this signature caused unexpected behavior. For instance, if the argument to `toggleClass` was a variable that turned out to be `undefined` or `false`, it would result in all classes being removed. Also, while the `toggleClass( boolean )` signature was documented (and has been marked deprecated since 3.0), the `toggleClass( undefined )` signature was not.
+
+The recommendation for migration is to be explicit about which classes should be toggled.
+
+### Core
+
+#### Breaking change: Deprecated APIs removed
+
+The following APIs were deprecated in previous versions and have been removed in jQuery 4.0:
+
+* `jQuery.camelCase`
+ This function was never documented and was only used internally. It was deprecated in jQuery 3.0.
+
+* `jQuery.cssProps`
+ This object was used to map CSS properties to their vendor-prefixed versions, which is no longer necessary in jQuery 4.0's supported browsers.
+
+* `jQuery.isArray`
+ Use Array.isArray.
+
+* `jQuery.isFunction`
+ Use typeof value === "function".
+
+* `jQuery.isNumeric`
+ Use Number.isFinite or a custom implementation.
+
+* `jQuery.isWindow`
+ Window detection is generally unreliable and discouraged. If absolutely necessary, use `obj != null && obj === obj.window`.
+
+* `jQuery.fx.interval`
+ The default value was 13 (milliseconds), but has been removed as it does not work well with `requestAnimationFrame`. It should no longer be necessary.
+
+* `jQuery.nodeName`
+ Use `element.nodeName.toLowerCase()`.
+
+* `jQuery.now`
+ Use `Date.now()`.
+
+* `jQuery.parseJSON`
+ Use JSON.parse.
+
+* `jQuery.trim`
+ Use String.prototype.trim.
+
+* `jQuery.type`
+ Use `typeof` for primitive types, `Array.isArray` for arrays, and `instanceof` for objects. Or, use `Object.prototype.toString.call(value)`.
+
+* `jQuery.unique`
+ Use `jQuery.uniqueSort`.
+
+#### Breaking change: Remove undocumented Array methods
+
+jQuery 4.0 removes `push`, `sort`, and `splice` from the jQuery prototype. These methods were copies of the methods of the same names on the native Array prototype, but were never documented and were not intended for public use. Some plugins may have used them, so we are still marking this as a breaking change.
+
+#### Slim build breaking change: Remove `callbacks`, `deferred`, and `queue` modules
+
+The slim build of jQuery 4.0 no longer includes the `callbacks`, `deferred`, and `queue` modules. Use the full build if you need these modules, or use native Promise objects.
+
+#### Breaking change: Remove undocumented `root` parameter of `jQuery.fn.init()`
+
+`root` was the third parameter of `jQuery.fn.init()`, but was never documented and was only used internally. Also, it has not been necessary since jQuery 1.9 when `jQuery.sub()` was removed.
+
+#### Important fix: Add `exports` to package.json
+
+jQuery exports multiple builds that can be used in different environments. This includes the default build as both a universal module (UMD) and an ESM module, the slim build in UMD and ESM, and a factory build for running jQuery with DOM emulators like JSDOM. The `exports` field in `package.json` is used to specify which build is used in different environments. This change should not affect existing code in most cases, but it is an important fix to ensure that jQuery can be used in a wider range of environments.
+
+##### Potentially breaking change: Node.js without a DOM window requires the factory entry point
+
+Wherever jQuery is used, it requires a `window` with a proper `document`, which does not exist by default in Node.js and related environments. Tools like JSDOM can be used to create a fake `window` and `document` in Node.js, but the way jQuery can be imported in these environments has changed in jQuery 4.0.
+
+In jQuery 3.x, `require("jquery")` in a Node.js environment without a global `window` returned a factory function that accepted a `window` argument. In jQuery 4.0, the CommonJS wrapper no longer does this. Instead, use the dedicated factory entry point:
+
+```js
+// jQuery 3.x
+const jQuery = require( "jquery" )( window );
+
+// jQuery 4.0
+const jQuery = require( "jquery/factory" )( window );
+```
+
+A `jquery/factory-slim` entry point is also available.
+
+Alternatively, if you attach the JSDOM `window` to `globalThis` before importing or requiring jQuery, it will work without the factory entry point.
+
+#### Potentially breaking change: jQuery's source is no longer written using AMD modules
+
+jQuery's source code has been converted to use ES modules instead of AMD modules. While this has several advantages, some users may have been importing jQuery's source directly using AMD loaders such as RequireJS. This change may affect those users, but it is expected that most users will be able to continue using jQuery without any issues. The main jQuery file is still built as a UMD module, so it can be used in both AMD and non-AMD environments.
+
+### CSS
+
+#### Breaking change: `px` no longer automatically added to most unitless values
+
+jQuery 4.0 switches strategies when it comes to setting CSS properties that require units. Previously, jQuery would automatically add `px` to unitless values, with some exceptions. The old stragey did not properly handle new CSS properties that had been added to the CSS spec since jQuery's release and the "exceptions" list was growing fast. That behavior has been removed in jQuery 4.0.
+
+Instead, jQuery will now only add `px` to a limited set of properties that are known to require it. This change may affect existing code that relies on the old behavior.
+
+We encourage all users to explicitly specify units for CSS properties that require them, as this is the standard way of working with CSS and will help avoid any issues with future versions of jQuery. If the old behavior is still needed, see [the docs](https://api.jquery.com/css/#css-propertyName-value) for the current list of properties to which jQuery will automatically add `px`.
+
+#### Breaking change: Remove opacity CSS hook
+
+`.css( "opacity" )` will now return an empty string for detached elements in standard-compliant browsers and "1" in IE. That behavior is shared by most other CSS properties, but may affect existing code relying on a return value of "1".
+
+### Data
+
+#### Important fix: `Object.prototype` pollution
+
+jQuery 4.0 includes a fix to ensure event and data keys matching `Object.prototype` properties are supported without overriding the native properties. This may affect code calling `hasOwnProperty` on the data object, which should be rare.
+
+Switch from:
+
+```js
+if ( elem.data().hasOwnProperty( "key" ) ) { /* ... */ }
+```
+
+to:
+
+```js
+if ( "key" in elem.data() ) { /* ... */ }
+if ( Object.hasOwn( elem.data(), "key" ) ) { /* ... */ }
+```
+
+### Deferred
+
+#### Breaking change: Removed `jQuery.Deferred.getStackHook`
+
+[`jQuery.Deferred.getStackHook`](https://api.jquery.com/jQuery.Deferred.getStackHook/) was renamed to [`jQuery.Deferred.getErrorHook`](https://api.jquery.com/jQuery.Deferred.getErrorHook/) in 3.7.0. It is used to pass the original error to [`jQuery.Deferred.exceptionHook`](https://api.jquery.com/jQuery.Deferred.exceptionHook/). Previously, we recommended passing the stack but that didn't play well with source maps. `jQuery.Deferred.exceptionHook` can be used to debug asynchronous errors.
+
+### Event
+
+#### Breaking change: Stop shimming focusin & focusout events
+
+jQuery 4.0 no longer shims the `focusin` and `focusout` events. This only affects code that relies on the order of these events as they relate to `focus` and `blur`. This change is expected to affect very few users. Mostly, the order can be different in IE in that `blur` can come before `focousout` and `focus` before `focusin`. See [#4362](https://github.com/jquery/jquery/pull/4362) for details.
+
+#### Breaking change: `jQuery.event.special` no longer inherits from `Object.prototype`
+
+This may affect code calling `hasOwnProperty` on `jQuery.event.special`, which should be rare.
+
+### Manipulation
+
+#### Important feature: Add support for Trusted Types
+
+jQuery 4.0 adds support for [Trusted Types](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API) for all manipulation methods. This change is not expected to affect existing code, but it is an important feature for security.
+
+#### Potentially breaking change: Avoid concatenating strings in buildFragment
+
+This change was needed in order to add support for [Trusted Types](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API). It's not entirely clear what real use cases might be affected by this change, but we're listing it here just in case.
+
+#### Important fix: Don't remove HTML comments and `CDATA` sections from scripts
+
+Browsers can now handle these without jQuery's help. This change is not expected to affect existing code, but is an important fix because jQuery's logic removing them was not correct in 100% of cases.
+
+### Selector
+
+#### Important fix: Backport jQuery selection context logic to selector-native
+
+jQuery has long had a minimal selector engine that could be used in place of Sizzle. This engine was missing some logic that Sizzle had for handling the context of a selection. This change backports that logic to the native selector engine, which may affect code that relied on the old behavior. For example, `$div.find( "> *" )` will no longer throw an error when using the native selector engine. Also, given the following HTML:
+
+```html
+
+
+
+```
+
+The following returns 0 results in jQuery 4.0:
+
+```js
+const $div = $( "#parent" );
+$div.find( "div span" );
+```
+
+This is generally the expected behavior.
+
+#### Breaking change: Drop support for legacy custom pseudos
+
+References in Sizzle wiki: https://github.com/jquery/sizzle/wiki#-backwards-compatible-plugins-for-pseudos-with-arguments