Given coordinates for a point relative to the viewport, returns the element that a click event would be dispatched at if the user were to click the point (in other words, the element that hit-testing would find).

A property representing the text within a DOM element and its descendants. As a getter, it approximates the text the user would get if they highlighted the contents of the element with the cursor and then copied to the clipboard.

This test only checks that the property exists and works correctly in a very simple case.This blog post by kangax explains the history of this property, gives much more detailed cross-browser compatibility information, and gives a detailed strawman specification for the property.Node.innerText is similar to, but has some important differences from, the standard Node.textContent property.

Makes the form control non-editable. Unlike the disabled attribute, readonly form controls are still included in form submissions and the user can still select (but not edit) their value text.

Browser-specific notes:
#1: Readonly inputs of type datetime-local, date, month, and week can still be edited by pressing the Up or Down arrow keys on the keyboard while the input is focused.
#2: Text cannot be selected directly, but is possible by first selecting any text around the field.

Method to get the size and position of an element's bounding box, relative to the viewport.

Browser-specific notes:
#1: The returned object lacks width and height properties.
#2: Returns incorrect values for elements which have had CSS transforms applied to them.
#3: The returned object cannot have new properties added to it; it's not extensible.
#4: Existing properties of the returned object are immutable.

CSS pseudo-element that allows styling only the first "letter" of text within an element. Useful for implementing initial caps or drop caps styling.

The spec says that both letters of digraphs which are always capitalized together (such as "IJ" in Dutch) should be matched by ::first-letter, but no browser has ever implemented this.

Browser-specific notes:
#1: Excludes punctuation immediately after the first letter from the match. (The spec says it should be included in the match.).
#2: Acts like the first character is always a letter even when it's not. For example, given "!,X;", "!," is matched instead of the entire string.
#3: Only recognizes the deprecated :first-letter pseudo-class, not the ::first-letter pseudo-element.
#4: Only matches the very first character. The spec says that surrounding punctuation should also match.

Declares an upper bound on the number of characters the user can input. Normally the UI ignores attempts by the user to type in additional characters beyond this limit.

Browser-specific notes:
#1: <textarea>'s' UI does not prevent the user from typing additional characters beyond the maxlength limit.
#2: Does not support the HTMLTextAreaElement.maxLength DOM property.
#3: Does not support ValidityState.tooLong. In some cases, this is because .validity is not supported in the first place.
#4: Does not support ValidityState.tooLong correctly in the (unlikely) case of the value being initially set too long, then changed by the user to a still incorrect state. See Firefox bug and MS Edge bug.
#5: <input>'s UI does not prevent the user from typing additional characters beyond the maxlength limit between two existing characters of the string.
#6: Allows text beyond maxlength to be entered at first, but removes all characters past the maxlength when focus is lost.

Browser-specific notes:
#1: Partial support refers to lacking support for parseFromString on the DOMParser.
#2: Partial support refers to supporting only innerHTML.
#3: Partial support refers to supporting only innerHTML and insertAdjacentHTML.

Browser-specific notes:
#1: Partial support in IE8 is due to being limited to CSS 2.1 selectors and a small subset of CSS 3 selectors (see notes there). Additionally, it will have trouble with selectors including unrecognized tags (for example HTML5 ones).

Method of displaying text or images before or after the given element's contents using the ::before and ::after pseudo-elements. All browsers with support also support the attr() notation in the content property.

For content to appear in pseudo-elements, the content property must be set (but may be an empty string).

Browser-specific notes:
#1: IE8 only supports the single-colon CSS 2.1 syntax (i.e. :pseudo-class). It does not support the double-colon CSS3 syntax (i.e. ::pseudo-element).

The modern standard API for adding DOM event handlers. Introduced in the DOM Level 2 Events spec. Also implies support for the capture phase of DOM event dispatch, as well as the stopPropagation() and preventDefault() event methods.

Browser-specific notes:
#1: IE<=8 instead only supports the proprietary .attachEvent() method. It also does not support the capture phase of DOM event dispatch; it only supports event bubbling.
#2: The useCapture parameter is non-optional and must be provided. Future versions made it optional, with a default value of false.

Different browsers have support for different video formats, see sub-features for details.

Browser-specific notes:
#1: The Android browser (before 2.3) requires specific handling to run the video element.
#2: Old Firefox versions were missing support for some properties: loop was added in v11, played in v15, playbackRate in v20.
#3: Ignores the autoplay attribute by default, though autoplay behavior can be enabled by users.

Events to indicate when the user's connected (online and offline events) and the navigator.onLine property to see current status.

"online" does not always mean connection to the internet, it can also just mean connection to some network.

Early versions of Chrome and Safari always reported "true" for navigator.onLine.

Browser-specific notes:
#0: Safari 7.0 supports only the event listener on window, and not on document.body.
#1: Seems to support navigator.onLine but not online/offline events.
#2: IE8 only supports the online/offline events on document.body, rather than window.
#3: Desktop Firefox responds to the status of its "Work Offline" mode. If not in that mode, navigator.onLine is always true, regardless of the actual network connectivity status. See bug for details.

Method of outputting data to the browser's console, intended for development purposes.

The basic functions that this information refers to include console.log, console.info, console.warn, console.error.

Browser-specific notes:
#1: Only supports console functions when developer tools are open, otherwise the console object is undefined and any calls will throw errors.
#2: Allows console functions to be used without throwing errors, but does not appear to output the data anywhere.
#3: Log output on iOS 6+ Safari can only be seen by connecting to a Mac and using the Safari debugger.
#4: Log output on older Android browsers can be retrieved via Android's logcat command or using Chrome Developer Tools in Android 4.4+/Chrome for Android see details.
#5: Log output on Firefox for Android can be accessed using WebIDE.
#6: See this article for details on how to see console logging in Opera Mini.

Type of unit similar to em, but relative only to the root element, not any parent element. Thus compounding does not occur as it does with em units.

Browser-specific notes:
#1: IE 9 & IE 10 do not support rem units when used in the font shorthand property (the entire declaration is ignored) or when used on pseudo elements.
#2: iOS Safari 5.0-5.1 support rem but not in combination with media queries.

Opera Mini ignores the blur-radius set, so no blur effect is visible. Text-shadow behavior can be somewhat emulated in older IE versions using the non-standard "dropshadow" or "glow" filters.

Browser-specific notes:
#1: IE 10+ supports a fourth length value for the shadow's "spread". This is not (yet) part of the specification.
#2: Partial support in Safari 3.* refers to not supporting multiple shadows.

Browser-specific notes:
#1: Partial support in iOS Safari and older Safari versions refers to failing to support tiling or the background-position property.
#2: Partial support in older Firefox and Opera Mini/Mobile refers to SVG images being blurry when scaled.
#3: Partial support in Edge 15 and older refers to a lack of support for SVG data URIs. see bug.

The input event is fired when the user changes the value of an <input> element, <select> element, or <textarea> element. By contrast, the "change" event usually only fires after the form control has lost focus.

Full support for the ECMAScript 5 specification. Features include Function.prototype.bind, Array methods like indexOf, forEach, map & filter, Object methods like defineProperty, create & keys, the trim method on Strings and many more.

As the specification includes many JavaScript features, un-numbered partial support varies widely and is shown in detail on the ECMAScript 5 compatibilty tables by Kangax.

Browser-specific notes:
#1: Does not support parseInt() ignoring leading zeros.
#2: Does not support Strict mode.
#3: Does not support zero-width chars in identifiers & Immutable undefined.
#4: IE8 has virtually no ES5 support, but does support Object.defineProperty, Object.getOwnPropertyDescriptor, JSON parsing & Property access on strings.

Browser-specific notes:
#1: Does not support CORS for images in <canvas>.
#2: Supported somewhat in IE8 and IE9 using the XDomainRequest object (but has limitations).
#3: Does not support CORS for <video> in <canvas>: https://bugs.webkit.org/show_bug.cgi?id=135379.

A KeyboardEvent property that indicates the location of the key on the input device. Useful when there are more than one physical key for the same logical key (e.g. left or right "Control" key; main or numpad "1" key).

console.time() starts a timer you can use to track how long an operation takes. You give each timer a unique name, and may have up to 10,000 timers running on a given page. When you call console.timeEnd() with the same name, the browser will output the time, in milliseconds, that elapsed since the timer was started. These functions are not always available in workers. For example, in Firefox, they are available from version 38. More on using the console on mobile devices, see here.

Allows CSS background images to be positioned relative to the specified edge using the 3 to 4 value syntax. For example: background-position: right 5px bottom 5px; for positioning 5px from the bottom-right corner.

Support can be somewhat emulated in older versions of IE using the non-standard expression() syntax.

Due to the way browsers handle sub-pixel rounding differently, layouts using calc() expressions may have unexpected results.

Browser-specific notes:
#1: Partial support in Android Browser 4.4 refers to the browser lacking the ability to multiply and divide values.
#2: Partial support in IE9 refers to the browser crashing when used as a background-position value.

Reported to be supported in some Android 4.x browsers, including Sony Xperia S, Sony TX and HTC.

Browser-specific notes:
#1: Partial support in older browsers refers to the websockets implementation using an older version of the protocol and/or the implementation being disabled by default (due to security issues with the older protocol).
#2: Partial support in older browsers refers to lacking support for binary data.

Method for observing and reacting to changes to the DOM. Replaces MutationEvents, which is deprecated.

When changing the innerHTML content of a node containing a single CharacterData node, resulting in a single-but-different CharacterData child node, WebKit browsers consider this a characterData mutation of the child CharacterData node, while other browsers consider it a childList mutation of the parent node.

Compares the relative position of two nodes to each other in the DOM tree.

Browser-specific notes:
#1: The spec requires that comparisons of nodes in different documents, and comparisons where at least one node is not in any document, must arbitrarily (but consistently) set either the DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING bit in the result. These browser versions don't set either bit in some such cases.
#2: Sets neither the DOCUMENT_POSITION_DISCONNECTED bit nor the DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC bit in some cases when comparing nodes in different documents or when comparing a node which is not in any document.

The latest version of the Transport Layer Security (TLS) protocol. Allows for data/message confidentiality, and message authentication codes for message integrity and as a by-product message authentication.

Allows disabling all of the form control descendants of a fieldset via a disabled attribute on the fieldset element itself.

Browser-specific notes:
#1: Text inputs that are descendants of a disabled fieldset appear disabled but the user can still interact with them. See IE bug #962368..
#2: File inputs that are descendants of a disabled fieldset appear disabled but the user can still interact with them. See IE bug #817488..

Property to define whether lines of text are laid out horizontally or vertically and the direction in which blocks progress.

Browser-specific notes:
#1: Internet Explorer supports different values from an earlier version of the spec, which originated from SVG.
#2: Supported in Firefox under the layout.css.vertical-text.enabled flag.

The CSS outline properties draw a border around an element that does not affect layout, making it ideal for highlighting. This covers the outline shorthand, as well as outline-width, outline-style, outline-color and outline-offset.

Firefox also supports the non-standard -moz-outline-radius property that acts similar to border-radius.

Browser-specific notes:
#1: Also supports the value of invert for outline-color. (support of this value is optional for browsers).
#2: Does not support outline-offset.

Method of sending information from a page on one domain to a page on a different one (using postMessage).

Browser-specific notes:
#1: Partial support refers to only working in frames/iframes (not other tabs/windows). Also, objects cannot be sent using postMessage.
#2: Partial support refers to limitations in certain conditions.

Browser-specific notes:
#1: const is recognized, but treated like var (no block scope, can be overwritten).
#2: const does not have block scope.
#3: Only recognized when NOT in strict mode.
#4: Supported correctly in strict mode, otherwise supported without block scope.

Browser-specific notes:
#1: Partial support refers to missing the default styling, as technically the elements are considered "unknown". This is easily taken care of by manually setting the default display value for each tag.
#2: Partial support refers to only the <main> element (added later to the spec) being "unknown", though it can still be used and styled.

Method of easily manipulating classes on elements, using the DOMTokenList object.

Browser-specific notes:
#1: Does not have support for classList on SVG or MathML elements.
#2: Does not support the second parameter for the toggle method.
#3: Does not support multiple parameters for the add() & remove() methods.
#4: Does not support assign to classList.

Method of transforming an element in the third dimension using the transform property. Includes support for the perspective property to set the perspective in z-space and the backface-visibility property to toggle display of the reverse side of a 3D-transformed element.

Browser-specific notes:
#1: Partial support in IE refers to not supporting the transform-style: preserve-3d property. This prevents nesting 3D transformed elements.
#2: Safari 9, 10 & 11 are reported to still require a prefix for the related backface-visibility property.

Browser-specific notes:
#1: While a window.CustomEvent object exists, it cannot be called as a constructor. Instead of new CustomEvent(...), you must use e = document.createEvent('CustomEvent') and then e.initCustomEvent(...).
#2: There is no window.CustomEvent object, but document.createEvent('CustomEvent') still works.

Method of positioning elements in horizontal or vertical stacks. Support includes all properties prefixed with flex, as well as display: flex, display: inline-flex, align-content, align-items, align-self, justify-content and order.

Browser-specific notes:
#1: Only supports the old flexbox specification and does not support wrapping.
#2: Only supports the 2012 syntax.
#3: Does not support flex-wrap, flex-flow or align-content properties.
#4: Partial support is due to large amount of bugs present (see known issues).

Method of embedding images and other files in webpages as a string of text, generally using base64 encoding.

Browser-specific notes:
#1: Support is limited to images and linked resources like CSS files, not HTML or JS files. Max URI length is 32KB.
#2: Support is limited to images and linked resources like CSS or JS, not HTML files. Maximum size limit is 4GB.
#3: SVGs with XML declarations are not displayed when used in data-urls.

Unit representing the width of the character "0" in the current font, of particular use in combination with monospace fonts.

Browser-specific notes:
#1: IE supports the ch unit, but unlike other browsers its width is that specifically of the "0" glyph, not its surrounding space. As a result, 3ch for example is shorter than the width of the string "000" in IE.

Method of applying advanced typographic and language-specific font features to supported OpenType fonts.

Whenever possible, font-variant shorthand property or an associated longhand property, font-variant-ligatures, font-variant-caps, font-variant-east-asian, font-variant-alternates, font-variant-numeric or font-variant-position should be used. This property is a low-level feature designed to handle special cases where no other way to enable or access an OpenType font feature exists. In particular, this CSS property shouldn't be used to enable small caps.

Adds more functionality to XHR (aka AJAX) requests like file uploads, transfer progress information and the ability to send form data. Previously known as XMLHttpRequest Level 2, these features now appear simply in the XMLHttpRequest spec.

Browser-specific notes:
#1: Partial support refers to not supporting json as responseType.
#2: Partial support refers to not supporting .timeout and .ontimeout.
#3: Partial support refers to not supporting blob as responseType.

Method of setting required fields and field types without requiring JavaScript. This includes preventing forms from being submitted when appropriate, the checkValidity() method as well as support for the :invalid, :valid, and :required CSS pseudo-classes.

Browser-specific notes:
#1: Partial support refers to lack of notice when form with required fields is attempted to be submitted. See WebKit bug.
#2: Partial support in IE10 mobile refers to lack of warning when blocking submission.
#3: Partial support in Opera Mini refers to only supporting the CSS pseudo classes.

Length units representing a percentage of the current viewport dimensions: width (vw), height (vh), the smaller of the two (vmin), or the larger of the two (vmax).

Browser-specific notes:
#1: Partial support in IE9 refers to supporting "vm" instead of "vmin".
#2: Partial support refers to not supporting the "vmax" unit.
#3: Partial support in iOS7 is due to buggy behavior of the "vh" unit (see workarounds: 1, 2).

Browser-specific notes:
#1: Support in IE11 is based an older version of the specification.
#2: Supported in Firefox behind the dom.webcrypto.enabled flag.
#3: Supported in Safari using the crypto.webkitSubtle prefix.

Allows validation of an input field based on a given regular expression pattern.

Browser-specific notes:
#1: Partial support refers to not displaying a message for invalid patterns.
#2: Safari browsers support the pattern attribute but will still allow forms to be submitted if the pattern is incorrect. See the form validation data for details.

Allows the browser's Do Not Track setting to be queried via navigator.doNotTrack.

Partial support refers to the doNotTrack field being misnamed, or being attached to an object other than navigator (e.g. window).

Browser-specific notes:
#1: IE 9 and 10 are vendor-prefixed as navigator.msDoNotTrack.
#2: IE 11 and Edge use window.doNotTrack instead of navigator.doNotTrack.
#3: Browsers based on Gecko versions prior to 32 used 'yes' and 'no' rather than '1' and '0'.
#4: Between versions 6.1.1 and 9.1.3, Safari supported an ultimately-rejected amendment to the spec, using window.doNotTrack rather than navigator.doNotTrack.

This @font-face descriptor defines the set of Unicode codepoints that may be supported by the font face for which it is declared. The descriptor value is a comma-delimited list of Unicode range (<urange>) values. The union of these ranges defines the set of codepoints that serves as a hint for user agents when deciding whether or not to download a font resource for a given text run.

Partial support indicates that unnecessary code-ranges are downloaded by the browser - see browser test matrix.

Browser-specific notes:
#1: Can be enabled in Firefox using the layout.css.unicode-range.enabled flag.

Browser-specific notes:
#1: Partial support in IE11 refers to being limited to Windows 10.
#2: Only supports HTTP2 over TLS (https).
#3: Partial support in Safari refers to being limited to OSX 10.11+.
#4: Only supports HTTP2 if servers support protocol negotiation via ALPN.

Browser-specific notes:
#1: Partial support refers to not supporting the break-before, break-after, break-inside properties. WebKit- and Blink-based browsers do have equivalent support for the non-standard -webkit-column-break-* properties to accomplish the same result (but only the auto and always values). Firefox does not support break-* but does support the page-break-* properties to accomplish the same result.
#2: Partial support refers to not supporting the column-fill property.

Browser-specific notes:
#1: Partial support in IE 10 & 11 refers to a number of subfeatures not being supported. Edge does not support IndexedDB inside blob web workers. See issue.
#2: Partial support in Safari & iOS 8 & 9 refers to seriously buggy behavior as well as complete lack of support in WebViews.

Browser-specific notes:
#1: Supports a non-standard version that can only be used in script elements with a type attribute of application/javascript;version=1.7. As other browsers do not support these types of script tags this makes support useless for cross-browser support.
#2: Requires the ‘Experimental JavaScript features’ flag to be enabled.
#3: Only supported in strict mode.
#4: let bindings in for loops are incorrectly treated as function-scoped instead of block scoped.

Scales images with an algorithm that preserves edges and contrast, without smoothing colors or introducing blur. This is intended for images such as pixel art. Official values that accomplish this for the image-rendering property are crisp-edges and pixelated.

Note that prefixes apply to the value (e.g. -moz-crisp-edges), not the image-rendering property.

Browser-specific notes:
#1: Supported using the non-standard value -webkit-optimize-contrast.
#2: Internet Explorer accomplishes support using the non-standard declaration -ms-interpolation-mode: nearest-neighbor.
#3: Supports the crisp-edges value, but not pixelated.
#4: Supports the pixelated value, but not crisp-edges.
#5: Only works on <img>, not CSS backgrounds or <canvas>.
#6: Only works on <img> and CSS backgrounds, _not_ <canvas>.

Extensions to the Number built-in object in ES6, including constant properties EPSILON, MIN_SAFE_INTEGER, and MAX_SAFE_INTEGER, and methods isFinite, isInteger, isSafeInteger, and isNaN.

Browser-specific notes:
#1: Partial refers to only supporting the isFinite, isInteger, and isNaN methods.
#2: Partial refers to supporting the same as #1 and the addition of the EPSILON property.
#3: Partial refers to supporting all new features except the isSafeInteger method.
#4: Partial refers to only supporting the isFinite and isNaN methods.

The srcset and sizes attributes on img (or source) elements allow authors to define various image resources and "hints" that assist a user agent to determine the most appropriate image source to display (e.g. high-resolution displays, small monitors, etc).

Browser-specific notes:
#1: Can be enabled in Firefox by setting the about:config preference dom.image.srcset.enabled to true.
#2: Supports the subset of the syntax for resolution switching (using the x descriptor), but not the full syntax that can be used with sizes (using the w descriptor).
#3: Intermittently displays distorted images due to bug present (see known issues).

Browser-specific notes:
#1: Supported in Firefox under the layout.css.filters.enabled flag.
#2: Supported in MS Edge under the "Enable CSS filter property" flag.
#3: Partial support in Firefox before version 34 only implemented the url() function of the filter property.
#4: Partial support refers to supporting filter functions, but not the url function.

Method of declaring a portion of reusable markup that is parsed but not rendered until cloned.

Browser-specific notes:
#1: Does not support Document.importNode on templates, nested templates or elements that contain templates.
#2: Does not support Node.cloneNode on templates, nested templates or elements that contain templates.
#3: Safari 6.2 has the same partial support as Safari 7.1.

"Unknown" support for mobile browsers is due to lacking a method of tabbing through fields.

Browser-specific notes:
#1: On Mac OS X, unless Full Keyboard Access is enabled, <a> elements are not keyboard-focusable, even if they have tabindex="0".
#2: <a> elements are never keyboard-focusable, even if they have tabindex="0". Unless Full Keyboard Access is enabled, then <button>s, radio buttons, and checkboxes are also not keyboard-focusable, even if they have tabindex="0".
#3: Has "previous" and "next" virtual keyboard buttons that follow tabindex order.

The ::placeholder pseudo-element represents placeholder text in an input field: text that represents the input and provides a hint to the user on how to fill out the form. For example, a date-input field might have the placeholder text YYYY/MM/DD to clarify that numeric dates are to be entered in year-month-day order.

Partial support refers to using alternate names:.::-webkit-input-placeholder for Chrome/Safari/Opera (Chrome issue #623345).:-ms-input-placeholder for IE.::-ms-input-placeholder for Edge (also supports webkit prefix).

Browser-specific notes:
#1: Firefox 18 and below supported the :-moz-placeholder pseudo-class rather than the ::-moz-placeholder pseudo-element.

This attribute makes an ordered list number its items in descending order (large to small), instead of ascending order (small to large; the default). The order that the list items are displayed in is not affected.

Method of specifying how an object (image or video) should fit inside its box. object-fit options include "contain" (fit according to aspect ratio), "fill" (stretches object to fill) and "cover" (overflows box but maintains ratio), where object-position allows the object to be repositioned like background-image does.

Browser-specific notes:
#1: Partial support in Safari refers to support for object-fit but not object-position.
#2: Partial support in Edge refers to object-fit only supporting <img> (see this comment).

There is a library on GitHub that is working toward bringing W3C touch events to IE 10 and 11: https://github.com/CamHenlin/TouchPolyfill.

Removed support in Firefox refers to desktop Firefox only.

Browser-specific notes:
#1: Can be enabled in Firefox using the dom.w3c_touch_events.enabled flag (disabled by default for site compatibility reasons).
#2: Supported on IE11 Mobile for phones with "Windows Phone 8.1 Update".
#3: Can be enabled in Edge using the "Enable touch events" flag under about:flags.

Input elements can sometimes show placeholder text as a hint to the user on what to type in. See, for example, the placeholder attribute in HTML5. The :placeholder-shown pseudo-class matches an input element that is showing such placeholder text.

Browser-specific notes:
#1: Supports window.getSelection() but no selection events.
#2: Supports selection events, but not window.getSelection().
#3: Does not support the selectstart event.
#4: window.getSelection() may fail on tapping buttons, as the selection is lost right before the listener code runs.
#5: Selection events are supported behind the dom.select_events.enabled flag.

Method of using a grid concept to lay out content, providing a mechanism for authors to divide available space for layout into columns and rows using a set of predictable sizing behaviors. Includes support for all grid-* properties and the fr unit.

Browser-specific notes:
#1: Enabled in Chrome through the "experimental Web Platform features" flag in chrome://flags.
#2: Partial support in IE refers to supporting an older version of the specification.
#3: Enabled in Firefox through the layout.css.grid.enabled flag.
#4: There are some bugs with overflow (1356820, 1348857, 1350925).
#5: Enabled in Edge through the "Enable Unprefixed CSS Grid Layout" flag in about:flags.

Event listeners created with the passive: true option cannot cancel (preventDefault()) the events they receive. Primarily intended to be used with touch events and wheel events. Since they cannot prevent scrolls, passive event listeners allow the browser to perform optimizations that result in smoother scrolling.

If a temporal or number <input> has max and/or min attributes, then :in-range matches when the value is within the specified range and :out-of-range matches when the value is outside the specified range. If there are no range constraints, then neither pseudo-class matches.

Note that <input type="range"> can never match :out-of-range because the user cannot input such a value, and if the initial value is outside the range, the browser immediately clamps it to the minimum or maximum (as appropriate) bound of the range.

This CSS module defines a scripting interface to font faces in CSS, allowing font faces to be easily created and loaded from script. It also provides methods to track the loading status of an individual font, or of all the fonts on an entire page.

Browser-specific notes:
#1: Can be enabled in Firefox using the layout.css.font-loading-api.enabled flag. Enabled by default in Firefox 41. See this bug.

jQuery-like methods on DOM nodes to insert nodes around or within a node, or to replace one node with another. These methods accept any number of DOM nodes or HTML strings as arguments. Includes: ChildNode.before, ChildNode.after, ChildNode.replaceWith, ParentNode.prepend, and ParentNode.append.

Browser-specific notes:
#1: Partial support can be enabled in Firefox with the dom.fetch.enabled flag.
#2: Only available in Chrome and Opera within ServiceWorkers.
#3: Available in Chrome and Opera within Window and Workers by enabling the "Experimental Web Platform Features" flag in chrome://flags.
#4: Firefox <40 is not completely conforming to the specs and does not respect the <base> tag for relative URIs in fetch requests. https://bugzilla.mozilla.org/show_bug.cgi?id=1161625.
#5: Appears to exist in Safari Technology Preview but does not work in current build. Should work in next preview build.
#6: Can be enabled in about:flags.

Method of accessing external device data (such as a webcam video stream). Formerly this was envisioned as the <device> element.

As of Chrome 47, the getUserMedia API cannot be called from insecure origins.

Browser-specific notes:
#1: Blink-based (and some other) browsers support an older version of the spec that does not use srcObject. See Chromium issue 387740.
#2: Supports the older spec's navigator.getUserMedia API, not the newer navigator.mediaDevices.getUserMedia one.

Allows a media query to be set based on the presence and accuracy of the user's pointing device, and whether they have the ability to hover over elements on the page. This includes the pointer, any-pointer, hover, and any-hover media features.

WebAssembly or "wasm" is a new portable, size- and load-time-efficient format suitable for compilation to the web.

Browser-specific notes:
#1: Can be enabled via the javascript.options.wasm in about:config.
#2: Can be enabled via the #enable-webassembly flag.
#3: Can be enabled via the Experimental JavaScript Features flag.
#4: Disabled for Firefox 52 ESR.

Allows a media query to be set based on the device pixels used per CSS unit. While the standard uses min/max-resolution for this, some browsers support the older non-standard device-pixel-ratio media query.

Browser-specific notes:
#1: Supports the dpi unit, but does not support dppx or dpcm units.
#2: Firefox before 16 supports only dpi unit, but you can set 2dppx per min--moz-device-pixel-ratio: 2.
#3: Supports the non-standard min/max-device-pixel-ratio.

touch-action is a CSS property that controls filtering of gesture events, providing developers with a declarative mechanism to selectively disable touch scrolling (in one or both axes) or double-tap-zooming.

Browser-specific notes:
#1: Supported in Firefox behind the layout.css.touch_action.enabled flag, Firefox for Windows 8 Touch ('Metro') enabled by default.
#2: IE10+ has already supported these property which are not in standard at present such as double-tap-zoom, cross-slide-x, cross-slide-y.
#3: iOS Safari only supports auto and manipulation.
#4: Not applicable to Firefox platforms that support neither pointer nor touch events.

Samsung Internet for GearVR: In Development, release based on Chromium m53 due Q1/2017.

Browser-specific notes:
#1: Can be enabled in Firefox using the media.webspeech.synth.enabled about:config flag.
#2: Speech Synthesis in Chrome since version 55 stops playback after about 15 seconds on Windows 7 & 10, and Ubuntu 14.04, possibly other platforms.

The autocomplete attribute for input elements indicates to the browser whether a value should or should not be autofilled when appropriate.

This support information does not include support for other autocomplete values.

As described in detail below, many modern browsers ignore the off value on certain fields in certain cases intentionally in order to give the user more control over autofilling fields. One example is the use of password managers.

Browser-specific notes:
#1: Partial support refers to ignoring the off value for password fields. see related blog post.
#2: Partial support in Chrome refers to the browser intentionally ignoring autocomplete="off" when the user uses the browser's autofill functionality. see bug.
#3: Partial support in Firefox refers to ignoring autocomplete="off" for login forms. see bug.
#4: Browser does not display previously submitted values as options with on value.
#5: Safari ignores the off value for username, email and password fields.

Indeterminate checkboxes are displayed in a state which is distinct both from being checked or being unchecked. They are commonly used in hierarchical checkboxes to indicate that only some of the checkbox's descendants are checked.

Indeterminacy does not affect a checkbox's checkedness state. It merely affects how the checkbox is displayed.

Method of defining how a background image is attached to a scrollable element. Values include scroll (default), fixed and local.

Most mobile devices have a delay in updating the background position after scrolling a page with fixed backgrounds.

Browser-specific notes:
#1: Partial support refers to supporting fixed but not local.
#2: Partial support refers to supporting local but not fixed.
#3: Only supports local when -webkit-overflow-scrolling: touch is _not_ used.
#4: Does not support fixed, and due to a bug only supports local if a border-radius is set on the element.

Including an i before the ] in a CSS attribute selector causes the attribute value to be matched in an ASCII-case-insensitive manner. For example, [b="xyz" i] would match both <a b="xyz"> and <a b="XYZ">.

Method of letting the browser pick the most appropriate CSS background image from a given set, primarily for high PPI screens.

Browser-specific notes:
#1: Safari's implementation does not completely match the spec, in that only URLs are accepted for the image value and only 'x' is accepted as a resolution. See https://bugs.webkit.org/show_bug.cgi?id=160934.

On mobile devices, the text-size-adjust CSS property allows Web authors to control if and how the text-inflating algorithm is applied to the textual content of the element it is applied to.

Browser-specific notes:
#1: If the viewport size is set using a <meta> element, the -ms-text-size-adjust property is ignored. See MSDN.
#2: Old versions of WebKit-based desktop browsers (Chrome<27, Safari<6) suffer from a bug where if -webkit-text-size-adjust is explicitly set to none, instead of ignoring the property, the browsers will prevent the user from zooming in or out on the webpage.

Browser-specific notes:
#1: If both ICO and PNG are available, will use ICO over PNG if ICO has better matching sizes set.
#2: If both ICO and PNG are available, will ALWAYS use ICO file, regardless of sizes set.
#3: If multiple formats are available, will use the last one loaded, regardless of sizes (effectively picks at random).
#4: Does not use favicons at all (but may have alternative for bookmarks, etc.).

Proprietary and undocumented CSS property that will contain text to a given amount of lines when used in combination with display: -webkit-box. It will end with ellipsis when text-overflow: ellipsis is included.

As there is no specification and the property is dependent on an outdated implementation of flexbox (hence display: -webkit-box) it is unlikely that other browsers will support the property as-is, although an alternative solution may at some point replace it.

Older (presto-based) versions of the Opera browser have also supported the same effect using the proprietary -o-ellipsis-lastline; value for text-overflow.

A KeyboardEvent property whose value is a string identifying the key that was pressed. Covers character keys, non-character keys (e.g. arrow keys), and dead keys.

Browser-specific notes:
#1: Partial support refers to these versions of Firefox returning "MozPrintableKey" for all character keys.
#2: Has non-standard key identifiers and incorrect behaviour with AltGraph.

The Element.scrollIntoView() method scrolls the current element into the visible area of the browser window. Parameters can be provided to set the position inside the visible area as well as whether scrolling should be instant or smooth.

Attribute for input/textarea fields to enable/disable the browser's spellchecker.

The partial support in mobile browsers results from their OS generally having built-in spell checking instead of using the wavy underline to indicate misspelled words. spellcheck="false" does not seem to have any effect in these browsers.

Browsers have different behavior in how they deal with spellchecking in combination with the the lang attribute. Generally spelling is based on the browser's language, not the language of the document.

Browser-specific notes:
#1: UI widget does not include increment/decrement buttons.
#2: UI widget does not take the "step", "min" or "max" attributes into account.
#3: Firefox doesn't support autocomplete content via datalist elements.
#4: Does not include increment/decrement buttons, but does supports increment/decrement via arrow up & down keys.

If a font has multiple types of variations based on the width of characters, the font-stretch property allows the appropriate one to be selected. The property in itself does not cause the browser to stretch to a font.

Form field widgets to easily allow users to enter a date, time or both, generally by using a calendar/time input widget. Refers to supporting the following input types: date, time, datetime-local, month & week.

Browser-specific notes:
#1: Partial support in Microsoft Edge refers to supporting date, week, and month input types, and not time and datetime-local.
#2: Partial support in iOS Safari refers to not supporting the week input type, nor the min, max or step attributes.
#3: Some modified versions of the Android 4.x browser do have support for date/time fields.
#4: Can be enabled in Firefox using the dom.forms.datetime flag.
#5: Partial support refers to supporting date and time input types, but not datetime-local, month or week.

Allows for the heights and widths to be specified in intrinsic values using the max-content, min-content, fit-content and stretch (formerly fill) properties.

Prefixes are on the values, not the property names (e.g. -webkit-min-content).

Older webkit browsers also support the unofficial intrinsic value which acts the same as max-content.

Browser-specific notes:
#1: Firefox does not support the height/min-height/max-height properties, only width. See test case, Firefox bug.
#2: Firefox currently supports the -moz-available property rather than -moz-stretch.
#3: Does not support the flex-basis property. See specs, Blink bug, Firefox bug.
#4: Chrome does not yet unprefix stretch (aka fill/fill-available), because the CSSWG is not ready for that yet. See Chromium bug.

API allowing media data to be accessed from HTML video and audio elements.

Browser-specific notes:
#1: Requires the media.mediasource.enabled flag to be enabled, support is limited to a whitelist including the YouTube, Netflix, and Dailymotion websites.
#2: Partial support in IE11 refers to only working in Windows 8+.
#3: Due to compatibility issues, MediaSource Extensions are currently disabled by default in Samsung Internet.

This specification integrates various inputs from mice, touchscreens, and pens, making separate implementations no longer necessary and authoring for cross-device pointers easier. Not to be mistaken with the unrelated "pointer-events" CSS property.

Firefox, starting with version 28, provides the 'dom.w3c_pointer_events.enabled' flag to support this specification.

Browser-specific notes:
#1: Partial support in IE10 refers the lack of pointerenter and pointerleave events.
#2: Firefox support is disabled by default and only supports mouse input. On Windows only, touch can be enabled with the layers.async-pan-zoom.enabled and dom.w3c_touch_events.enabled flags.
#3: Can be enabled with the #enable-pointer-events flag.

Method of establishing and maintaining functional boundaries between DOM trees and how these trees interact with each other within a document, thus enabling better functional encapsulation within the DOM & CSS.

Shadow DOM v0 was implemented in Chrome/Opera but other browser vendors are implementing v1.

Browser-specific notes:
#1: Certain CSS selectors do not work (:host > .local-child) and styling slotted content (::slotted) is buggy.
#2: Enabled through the "dom.webcomponents.enabled" preference in about:config.
#3: Enabled through the "dom.webcomponents.shadowdom.enabled" preference in about:config.

Multimedia format designed to provide a royalty-free, high-quality open video compression format for use with HTML5 video. WebM supports the video codec VP8 and VP9.

Will work in IE9+ and Safari/MacOSX provided the user has the WebM codecs installed. Partial support indicates that at least one codec is supported but not all. MS Edge supports VP9 from MSE sources, also progressive sources are not supported by Edge.

Method of controlling when words at the end of lines should be hyphenated using the "hyphens" property.

Chrome < 55 and Android 4.0 Browser support "-webkit-hyphens: none", but not the "auto" property. It is advisable to set the @lang attribute on the HTML element to enable hyphenation support and improve accessibility.

Method of easily dragging and dropping elements on a page, requiring minimal JavaScript.

dataTransfer.items only supported by Chrome.

Currently no browser supports the dropzone attribute.

Firefox supports any kind of DOM elements for .setDragImage. Chrome must have either an HTMLImageElement or any kind of DOM elements attached to the DOM and within the viewport of the browser for .setDragImage.

Browser-specific notes:
#1: Partial support refers to no support for the dataTransfer.files or .types objects.
#2: Partial support refers to not supporting .setDragImage.
#3: Partial support refers to limited supported formats for dataTransfer.setData/getData.

Loading JavaScript module scripts using <script type="module"> Includes support for the nomodule attribute.

Browser-specific notes:
#1: Support can be enabled via about:flags.
#2: Support can be enabled via about:config.
#3: Support can be enabled via the experimental-web-platform-features flag.
#4: Does not support the nomodule attribute.

Allows a filter to be defined for what type of files a user may pick with from an <input type="file"> dialog.

Not supported means any file can be picked as if the accept attribute was not set, unless otherwise noted.

On Windows, files that do not apply are hidden. On OSX they are grayed out and disabled.

Browser-specific notes:
#1: Supports the type format (e.g. image/*) but not the extension format (e.g. .png).
#2: Offers appropriate file locations/input based on format type, but does not prevent other files from being selected.
#3: Does not allow any files to be picked at all.
#4: Supports the type format but does not allow any file to be picked when using the extension format.

Gives a hint to the browser to begin the connection handshake (DNS, TCP, TLS) in the background to improve performance. This is indicated using <link rel="preconnect" href="https://example-domain.com/">.

Browser-specific notes:
#1: Firefox 39 did not support 'crossorigin' attribute and preconnects were not processed by the preload parser. Both of these features were enabled in Firefox 41.
#2: Partial support in Edge 15+ refers to support for only the HTTP header format, not the <link rel> format.

Method of including and reusing HTML documents in other HTML documents.

Browser-specific notes:
#1: Firefox has no plans to support HTML imports though for now it can be enabled through the "dom.webcomponents.enabled" preference in about:config.
#2: Enabled through the "Enable HTML Imports" flag in chrome://flags.
#3: Enabled through the "Experimental Web Platform features" flag in chrome://flags.
#4: Enabled through the "Enable HTML Imports" flag in opera://flags.
#5: Enabled through the "Experimental Web Platform features" flag in opera://flags.

Browser-specific notes:
#1: Only supports the WebKitCSSMatrix version of the interface, not DOMMatrix.
#2: WebKitCSSMatrix#skewX, WebKitCSSMatrix#skewY are not supported.
#3: Only supports the DOMMatrix version of the interface, not WebKitCSSMatrix (support required by spec for legacy reasons).
#4: Only replaces WebkitCSSMatrix and not SVGMatrix.
#5: Does not support fromMatrix(), fromFloat32Array(), fromFloat64Array(), and toJSON() methods.

Method of using small symbols next to each glyph to emphasize a run of text, commonly used in East Asian languages. The text-emphasis shorthand, and its text-emphasis-style and text-emphasis-color longhands, can be used to apply marks to the text. The text-emphasis-position property, which inherits separately, allows setting the emphasis marks' position with respect to the text.

Some old WebKit browsers (like Chrome 24) support -webkit-text-emphasis, but does not support CJK languages and is therefore considered unsupported.

Browser-specific notes:
#1: Partial support refers to incorrect support for -webkit-text-emphasis-position. These browsers support over and under as values, but not the added left and right values required by the spec.
#2: Can be enabled in Firefox using the layout.css.text-emphasis.enabled flag.

API that can be used to understand the visibility and position of DOM elements relative to a containing element or to the top-level viewport. The position is delivered asynchronously and is useful for understanding the visibility of elements and implementing pre-loading and deferred loading of DOM content.

Browser-specific notes:
#1: Enabled in Firefox by setting the about:config preference dom.IntersectionObserver.enabled to true.
#2: "Preliminary" support as feature is still in development.
#3: isIntersecting property of IntersectionObserverEntry was not implemented, returning undefined.

API allowing the execution of JavaScript to be queued to run in idle browser time, either at the end of a frame or when the user is inactive. Also covers support for cancelIdleCallback. The API has similarities with requestAnimationFrame.

Browser-specific notes:
#1: Can be enabled via the dom.requestIdleCallback.enabled flag.

Using <link rel="preload">, browsers can be informed to prefetch resources without having to execute them, allowing fine-grained control over when and how resources are loaded.

Browser-specific notes:
#1: Only cachable resources can be preloaded. This includes the following as values: script, style, image, video, audio, track, fetch, and font (note font/collection is not supported).
#2: Can be enabled via the "Experimental Features" developer menu.
#3: Disabled by default behind the network.preload flag.

API that provides access to raw mouse movement data. This is done by ignoring boundaries resulting from screen edges where the cursor can't go beyond, providing proper control for first person or real time strategy games.

The element generates a block container box, and lays out its contents using flow layout. It always establishes a new block formatting context for its contents. It provides a better solution to the most use cases of the "clearfix" hack.

The :matches() (formerly :any()) pseudo-class checks whether the element at its position in the outer selector matches any of the selectors in its selector list. It's useful syntactic sugar that allows you to avoid writing out all the combinations manually as separate selectors. The effect is similar to nesting in Sass and most other CSS preprocessors.

Most browsers support this spelled as a prefixed :-vendor-any() pseudo-class.

Browser-specific notes:
#1: Only supports the :-webkit-any() pseudo-class, which is deprecated due to handling specificity incorrectly.
#2: Also supports the :-webkit-any() pseudo-class, which is deprecated due to handling specificity incorrectly.
#3: Only supports the :-moz-any() pseudo-class.

Browser-specific notes:
#1: Partial support can be enabled in Firefox with the dom.serviceWorkers.enabled flag.
#2: Available behind the "Enable service workers" flag.
#3: Disabled on Firefox ESR, but can be re-enabled with the dom.serviceWorkers.enabled flag.
#4: Can be enabled via the "Experimental Features" developer menu.

Keeps elements positioned as "fixed" or "relative" depending on how it appears in the viewport. As a result the element is "stuck" when necessary while scrolling.

Browser-specific notes:
#1: Can be enabled in Firefox by setting the about:config preference layout.css.sticky.enabled to true.
#2: Enabled through the "experimental Web Platform features" flag.
#3: Not supported on any table parts - See Firefox bug.
#4: Supported on th elements, but not thead or tr - See Chrome bug.
#5: Do not appear to support sticky table headers.
#6: Supported on th elements, but not thead or tr - See Edge bug.

The unhandledrejection event is fired when a Promise is rejected but there is no rejection handler to deal with the rejection. The rejectionhandled event is fired when a Promise is rejected, and after the rejection is handled by the promise's rejection handling code.

Method of establishing and maintaining functional boundaries between DOM trees and how these trees interact with each other within a document, thus enabling better functional encapsulation within the DOM.

Provides the ability to read the screen orientation state, to be informed when this state changes, and to be able to lock the screen orientation to a specific state.

Partial support refers to an older version of the draft specification, and the spec has undergone significant changes since, for example renaming the screen.lockOrientation method to screen.orientation.lock.

API that provides a programmatic interface to the browser's credential manager. In short, an origin can request a user's credentials to sign them in, or can ask the browser to save credentials on the user's behalf. Both of these requests are user-mediated.

Browser-specific notes:
#1: In Chrome 51 ~ 56, PSL matched credentials are not supported. This means you cannot use credentials set on a.example.com in b.example.com. This is supported since Chrome 57.

Allows web sites to communicate over GATT with nearby user-selected Bluetooth devices in a secure and privacy-preserving way.

Browser-specific notes:
#1: Available by enabling the "Web Bluetooth" experimental flag in about:flags. Currently support varies by OS.
#2: Only in Opera Mobile.
#3: Available in Origin Trials for Chrome OS, Android M, and Mac.
#4: Currently support varies by OS.

Same-site cookies ("First-Party-Only" or "First-Party") allow servers to mitigate the risk of CSRF and information leakage attacks by asserting that a particular cookie should only be sent with requests initiated from the same registrable domain.

This feature is backwards compatible. Browsers not supporting this feature will simply use the cookie as a regular cookie. There is no need to deliver different cookies to clients.

Changes in DOM elements above the visible region of a scrolling box can result in the page moving while the user is in the middle of consuming the content.
By default, the value of overflow-anchor is auto, it can mitigate this jarring user experience by keeping track of the position of an anchor node and adjusting the scroll offset accordingly.

Properties to control the way elements are broken across (printed) pages.

Not all mobile browsers offer print support; support listed for these is based on browser engine capability.

Browser-specific notes:
#1: Supports the page-break-* alias from the CSS 2.1 specification, but not the break-* properties from the latest spec.
#2: Does not support avoid for page-break-before & page-break-after (only page-break-inside).
#3: Treats the left and right values like always.

The text-indent property applies indentation to lines of inline content in a block.

Browser-specific notes:
#1: Partial support refers to supporting a <length> value, but not the each-line or hanging keywords.
#2: Support for each-line & hanging is available behind the Experimental Web Platform features flag.

Browser-specific notes:
#1: Only supports Text and URL data types and uses a non-standard method of interacting with the clipboard.
#2: Only fires copy event on a valid selection and only cut and paste in focused editable fields.
#3: Only supports OS clipboard reading/writing via shortcut keys, not through document.execCommand().
#4: Only supports paste event (on focused editable field).
#5: Does not support the ClipboardEvent constructor.
#6: Supports cut & copy events without a focused editable field, but not paste (presumably for security reasons).
#7: Supports cut & copy events without a focused editable field, but does not fire paste with document.execCommand('paste').

Browser-specific notes:
#1: Partial support refers to no support for the alias, cell, copy, ew-resize, ns-resize, nesw-resize, nwse-resize or context-menu cursors.
#2: Partial support refers to not supporting 'none'.

The MediaRecorder API (MediaStream Recording) aims to provide a really simple mechanism by which developers can record media streams from the user's input devices and instantly use them in web apps, rather than having to perform manual encoding operations on raw PCM data, etc.

Browser-specific notes:
#1: Can be enabled via the experimental Web Platform features flag. Does not support audio recording, only video.

API to allow messages to be pushed from a server to a browser, even when the site isn't focused or even open in the browser.

Browser-specific notes:
#1: Partial support refers to not supporting PushEvent.data and PushMessageData.
#2: Requires full browser to be running to receive messages.
#3: Safari supports a custom implementation https://developer.apple.com/notifications/safari-push-notifications/. WWDC video by apple : https://developer.apple.com/videos/play/wwdc2013/614/.
#4: Disabled on Firefox ESR, but can be re-enabled with the dom.serviceWorkers.enabled and dom.push.enabled flags.

Facilitates user access to a device's media capture mechanism, such as a camera, or microphone, from within a file upload control.

Browser-specific notes:
#1: iOS6-10 do not support the capture attribute used to force capture straight from the device's camera or microphone. Also note that default video dimensions are 480x320 (4:3).
#2: Android 2.2-2.3 do not support the capture attribute.
#3: Supports a "capture" button for any `<input type="file"> field, regardless of the whether the capture attribute is used.

Browser-specific notes:
#1: Can be enabled in Firefox by setting the about:config preference webgl.enable-prototype-webgl2 to true.
#2: WebGL2 context is accessed from "experimental-webgl2" rather than "webgl2".
#3: Can be enabled in Chrome by passing the "--enable-unsafe-es3-apis" flag when starting the browser through the command line.
#4: Can be enabled via the "Experimental Features" developer menu.
#5: Enabled by default for Nightly and Dev Edition.

Method of defining the type, style and color of lines in the text-decoration property. These can be defined as shorthand (e.g. text-decoration: line-through dashed blue) or as single properties (e.g. text-decoration-color: blue).

All browsers support the CSS2 version of text-decoration, which matches only the text-decoration-line values (underline, etc.).

Browser-specific notes:
#1: Enabled in Chrome through the "experimental Web Platform features" flag in chrome://flags.
#2: Partial support refers to not supporting the text-decoration-style property.
#3: Safari 8+ supports -webkit-text-decoration-skip with values none and skip (other values behave like none or skip).
#4: Partial support refers to not supporting the text-decoration-skip property.
#5: Partial support refers to text-decoration-skip only supporting value objects and ink.

Use start/end properties that depend on LTR or RTL writing direction instead of left/right.

Browser-specific notes:
#1: Only supports the *-start, and *-end values for margin, border and padding, not the inline/block type values as defined in the spec.
#2: Like #1 but also supports *-before and *-end for *-block-start and *-block-end properties as well as start and end values for text-align.

Browser-specific notes:
#1: Can be enabled by setting "TLS 1.3" to "Enabled (Draft)" at chrome://flags/tls13-variant.
#2: Can be enabled by setting "Maximum TLS version enabled" to "TLS 1.3"at chrome://flags/. Support is reported to have be currently enabled as of version 56 for 1/10th of all users.

Method of setting a list of options for a user to select in a text field, while leaving the ability to enter a custom value.

While most commonly used on text fields, datalists can also be used on other input types. IE11 supports the element on range fields. Chrome and Opera also support datalists to suggest given values on range, color and date/time fields.

Browser-specific notes:
#1: Partial support refers to a bug where long lists of items are unscrollable resulting in unselectable options.
#2: Partial support in IE refers to significantly buggy behavior (IE11+ does send the input and change events upon selection).
#3: Partial support refers to no support for datalists on non-text fields (e.g. number, range, color).

Method of displaying part of an element, using a selected image as a mask.

Browser-specific notes:
#1: Partial support in WebKit/Blink browsers refers to supporting the mask-image and mask-box-image properties, but lacking support for other parts of the spec.
#2: Partial support in Firefox refers to only support for inline SVG mask elements i.e. mask: url(#foo).
#3: Partial support refers to supporting the mask-box-image shorthand but not the longhand properties.
#4: Partial support refers to supporting mask-image, mask-size, mask-position, and the mask shorthand.

API for detecting orientation and motion events from the device running the browser.

Partial support refers to the lack of compassneedscalibration event. Partial support also refers to the lack of devicemotion event support for Chrome 30- and Opera. Opera Mobile 14 lost the ondevicemotion event support. Firefox 3.6, 4 and 5 support the non-standard MozOrientation event.

OpenType font settings that allows a single font file to behave like multiple fonts: it can contain all the allowed variations in width, weight, slant, optical size, or any other exposed axes of variation as defined by the font designer. Variations can be applied via the font-variation-settings property.

Browser-specific notes:
#1: Works with Experimental Web Platform features enabled.
#2: Requires MacOS 10.12+ and the following about:config flags to be enabled:.layout.css.font-variations.enabled,.gfx.downloadable_fonts.keep_variation_tables.
#3: Requires MacOS 10.13+.
#4: Does not support the font-weight and font-stretch properties.
#5: Does not support format('truetype-variations'), format('woff-variations'), format('woff2-variations').

Method of defining the visible region of an HTML element using SVG or a shape definition.

Support refers to the clip-path CSS property on HTML elements specifically. Support for clip-path in SVG is supported in all browsers with basic SVG support.

Browser-specific notes:
#1: Partial support refers to only supporting the url() syntax.
#2: Partial support refers to supporting shapes and the url(#foo) syntax for inline SVG, but not shapes in external SVGs.
#3: Supports shapes behind the layout.css.clip-path-shapes.enabled flag.

The appearance property defines how elements (particularly form controls) appear by default. By setting the value to none the default appearance can be entirely redefined using other CSS properties.

Browser-specific notes:
#1: The appearance property is supported with the none value, but not auto. WebKit, Blink, and Gecko browsers also support additional vendor specific values.
#2: Microsoft Edge and IE Mobile support this property with the -webkit- prefix, rather than -ms- for interop reasons.
#3: -moz-appearance:none doesn't remove the dropdown arrow in select tag.

Method of creating, composing, and consuming streams of data, that map efficiently to low-level I/O primitives, and allow easy composition with built-in backpressure and queuing.

Browser-specific notes:
#1: IE implements a different API than the one from WHATWG.
#2: Only basic read support.
#3: Disabled by default behind the javascript.options.streams and dom.streams.enabled flags.
#4: No support for BYOB ("bring your own buffer") stream readers.
#5: No support for WritableStream.
#6: No support for the pipeTo or pipeThrough methods.

Method of allowing a webpage to handle a given protocol using navigator.registerProtocolHandler. This allows certain URLs to be opened by a given web application, for example mailto: addresses can be opened by a webmail client.

Lets you create animations that are run in the browser and as well as inspect and manipulate animations created through declarative means like CSS.

Browser-specific notes:
#1: Partial support refers to basic support of element.animate().
#2: Partial support refers to basic support of element.animate() and playback control of AnimationPlayer.
#3: Partial support in Firefox is detailed in Are we animated yet?.
#4: Can be enabled via the "Experimental Features" developer menu.

Browser-specific notes:
#1: Partial support in IE10 refers to support limited to touch screens.
#2: Partial support in IE11 documented here.
#4: Partial support in Safari refers to not supporting the none keyword in scroll-snap-points-x, scroll-snap-points-y and scroll-snap-coordinate, and length keywords (top, right, etc.) in scroll-snap-destination and scroll-snap-coordinate.
#5: Supports properties from an older version of the spec.
#6: Partial support in IE & Edge refers to not supporting scroll-snap-coordinate and scroll-snap-destination.
#7: Available behind the "Experimental Web Platform features" feature flag.

API for allowing content (like a video or canvas element) to take up the entire screen.

Browser-specific notes:
#1: Partial support refers to supporting an earlier draft of the spec.
#2: Partial support refers to not supporting ::backdrop, and supporting the old :full-screen syntax rather than the standard :fullscreen.
#3: Partial support refers to not returning a Promise, as specified in the latest version of the spec.
#4: Unprefixed support is available behind the full-screen-api.unprefix.enabled flag.

CSS property to control the behavior when the scroll position of a scroll container reaches the edge of the scrollport.

Browser-specific notes:
#1: Supports the precursor version of the property: -ms-scroll-chaining, which works similarly. IE support is limited to Windows 8 & above.
#2: Does not support overscroll-behavior: none; on the body element to prevent the overscroll glow and rubberbanding effects.

Browser-specific notes:
#1: Support is limited to using an iframe as a content source with the -ms-flow-into: flow_name; and -ms-flow-from: flow_name; syntax.
#2: Partial support refers to not supporting the region-fragment property.

Not every computer or smartphone could run WebVR appication. For smartphones, you need a gyroscope and for computers must be VR-ready also the needed sotfware (Oculus client or (Steam VR and VivePort)) and drivers must been installed on the computer. In this situations, you've the best experiance to use WebVR applications.

Browser-specific notes:
#1: Available and enabled by default only in Firefox Windows. Enabled in Nightly for iOS.
#2: Enabled behind the WebVR & "Gamepad Extensions" flags under chrome://flags. Currently builds use an older version of the (still changing) specification and supports only the Oculus Rift and the HTC vive on Windows VR-ready computers.
#3: In development in the latest Edge builds and supports only Windows Mixed Reality.
#4: Supports only Samsung Galaxy devices with the Samgung Gear VR.
#5: Supports only Google Daydream on daydream-ready devices and Google Cardboards.

JPEG 2000 (JP2) was created by the Joint Photographic Experts Group committee in 2000 with the intention of superseding their original discrete cosine transform-based JPEG standard (created in 1992) with a newly designed, wavelet-based method. It offers some advantages in image fidelity over standard JPEG.

Selectors Level 4 allows the :not() pseudo-class to accept a list of selectors, which the element must not match any of. Selectors Level 3 only allowed :not() to accept a single simple selector. Thus, :not(a):not(.b):not([c]) can instead be written as :not(a, .b, [c]).

The newest versions of :nth-child() and :nth-last-child() accept an optional of S clause which filters the children to only those which match the selector list S. For example, :nth-child(1 of .foo) selects the first child among the children that have the foo class (ignoring any non-foo children which precede that child). Similar to :nth-of-type, but for arbitrary selectors instead of only type selectors.

A CSS keyword value that resets a property's value to the default specified by the browser in its UA stylesheet, as if the webpage had not included any CSS. For example, display:revert on a <div> would result in display:block. This is in contrast to the initial value, which is simply defined on a per-property basis, and for display would be inline.

Browser-specific notes:
#1: Partial support refers to some attributes missing.
#2: Firefox currently has a media.webspeech.recognition.enable flag in about:config for this, but actual support is waiting for permissions to be sorted out.
#3: Reported to be in development for Samsung Internet for GearVR, due Q1/2017.

Browser-specific notes:
#1: Does not use favicons at all.
#2: Partial support in Firefox before version 41 refers to only loading the SVG favicon the first time, but not on subsequent loads.
#3: Safari 9 has support for "pinned tab" SVG icons, but this requires an unofficial rel="mask-icon" to be set and only works for all-black icons on Pinned Tabs.
#4: Firefox requires the served mime-type to be 'image/svg+xml'.

Though present in early (2002) drafts of CSS3 Fonts, font-smooth has been removed from this specification and is currently not on the standard track.

Browser-specific notes:
#1: WebKit implements something similar with a different name -webkit-font-smoothing and different values: none, antialiased and subpixel-antialiased.
#2: Firefox implements something similar with a different name -moz-osx-font-smoothing and different values: auto, inherit, unset, grayscale.
#3: Works only on Mac OS X platform.

display: contents causes an element's children to appear as if they were direct children of the element's parent, ignoring the element itself. This can be useful when a wrapper element should be ignored when using CSS grid or similar layout techniques.

A way to allow websites to invoke the native sharing capabilities of the host platform.

Browser-specific notes:
#1: Partial support refers to feature only being available for sites opting into the origin trial.
#2: Implemented old Web Intents.
#3: Android intent:// URLs can be used instead.

Defines events that provide information about the ambient light level, as measured by a device's light sensor.

Browser-specific notes:
#1: Partial support in desktop Firefox refers to support being limited to Mac OS X. Support for Windows 7 is in progress.
#2: Available by enabling the "Experimental Web Platform Features" experimental flag in about:flags.

If the run-in box contains a block box, same as block. If a block box follows the run-in box, the run-in box becomes the first inline box of the block box. If an inline box follows, the run-in box becomes a block box.

The :focus-visible pseudo-class applies while an element matches the :focus pseudo-class, and the UA determines via heuristics that the focus should be specially indicated on the element (typically via a “focus ring”).

Provides scripted access to the Input Method Editor (IME). An IME is often used to input characters from East Asian languages by typing roman characters and selecting from the resulting suggestions.

Browser-specific notes:
#1: Prefixed implementation uses msGetInputContext() method from an earlier version of the spec to get the InputMethodContext, rather than the inputMethodContext attribute. Also includes support for getCompositionAlternatives() from the latest Editor'.

The seamless attribute makes an iframe's contents actually part of a page, and adopts the styles from its hosting page. The attribute has been removed from both the WHATWG and the W3C HTML5 specifications.

Chrome 20-26 had partial support behind a flag, though this was later removed.

Browser-specific notes:
#1: Hides the border of seamless iframes and recognizes the 'seamless' DOM property, but does not provide actual support.

While attr() is supported for effectively all browsers for the content property, CSS Values and Units Level 3 adds the ability to use attr() on **any** CSS property, and to use it for non-string values (e.g. numbers, colors).