2.1 Introduction
This section is non-normative.
Custom elements provide a way for authors to build their own fully-featured DOM elements. Although authors could always use non-standard elements in their documents, with application-specific behaviour added after the fact by scripting or similar, such elements have historically been non-conforming and not very functional. By defining a custom element, authors can inform the parser how to properly construct an element and how elements of that class should react to changes.
Custom elements are part of a larger effort to "rationalise the platform", by explaining existing platform features (like the elements of HTML) in terms of lower-level author-exposed extensibility points (like custom element definition). Although today there are many limitations on the capabilities of custom elements—both functionally and semantically—that prevent them from fully explaining the behaviours of HTML's existing elements, we hope to shrink this gap over time.
2.1.1 Creating an autonomous custom element
This section is non-normative.
For the purposes of illustrating how to create an autonomous custom element, let's define a custom element that encapsulates rendering a small icon for a country flag. Our goal is to be able to use it like so:
<flag-icon country="nl"></flag-icon>
To do this, we first declare a class for the custom element, extending HTMLElement:
class FlagIcon extends HTMLElement {
constructor() {
super();
this._countryCode = null;
}
static get observedAttributes() { return ["country"]; }
attributeChangedCallback(name, oldValue, newValue) {
this._countryCode = newValue;
this._updateRendering();
}
connectedCallback() {
this._updateRendering();
}
get country() {
return this._countryCode;
}
set country(v) {
this.setAttribute("country", v);
}
_updateRendering() {
}
}
We then need to use this class to define the element:
customElements.define("flag-icon", FlagIcon);
At this point, our above code will work! The parser, whenever it sees the flag-icon tag, will construct a new instance of our FlagIcon class, and tell our code about its new country attribute, which we then use to set the element's internal state and update its rendering (when appropriate).
You can also create flag-icon elements using the DOM API:
const flagIcon = document.createElement("flag-icon")
flagIcon.country = "jp"
document.body.appendChild(flagIcon)
Finally, we can also use the custom element constructor itself. That is, the above code is equivalent to:
const flagIcon = new FlagIcon()
flagIcon.country = "jp"
document.body.appendChild(flagIcon)
2.1.2 Creating a customized built-in element
This section is non-normative.
Customized built-in elements are a distinct kind of custom element, which are defined slightly differently and used very differently compared to autonomous custom elements. They exist to allow reuse of behaviours from the existing elements of HTML, by extending those elements with new custom functionality. This is important since many of the existing behaviours of HTML elements can unfortunately not be duplicated by using purely autonomous custom elements. Instead, customized built-in elements allow the installation of custom construction behaviour, lifecycle hooks, and prototype chain onto existing elements, essentially "mixing in" these capabilities on top of the already-existing element.
Customized built-in elements require a distinct syntax from autonomous custom elements because user agents and other software key off an element's local name in order to identify the element's semantics and behaviour. That is, the concept of customized built-in elements building on top of existing behaviour depends crucially on the extended elements retaining their original local name.
In this example, we'll be creating a customized built-in element named plastic-button, which behaves like a normal button but gets fancy animation effects added whenever you click on it. We start by defining a class, just like before, although this time we extend HTMLButtonElement instead of HTMLElement:
class PlasticButton extends HTMLButtonElement {
constructor() {
super();
this.addEventListener("click", () => {
});
}
}
When defining our custom element, we have to also specify the extends option:
customElements.define("plastic-button", PlasticButton, { extends: "button" });
In general, the name of the element being extended cannot be determined simply by looking at what element interface it extends, as many elements share the same interface (such as q and blockquote both sharing HTMLQuoteElement).
To use our customized built-in element, we use the is attribute on a button element:
<button is="plastic-button">Click Me!</button>
Trying to use a customized built-in element as an autonomous custom element will not work; that is, <plastic-button>Click me?</plastic-button> will simply create an HTMLElement with no special behaviour.
If you need to create a type-extended element programmatically, you can use the following form of createElement():
const plasticButton = document.createElement("button", { is: "plastic-button" });
plasticButton.textContent = "Click me!";
And as before, the constructor will also work:
const plasticButton2 = new PlasticButton();
console.log(plasticButton2.localName);
console.log(plasticButton2.getAttribute("is"));
Notably, all the of the ways in which button is special apply to such "plastic buttons" as well: their focus behaviour, ability to participate in form submission, the disabled attribute, and so on.
2.1.3 Drawbacks of autonomous custom elements
This section is non-normative.
As specified below, and alluded to above, simply defining and using an element called taco-button does not mean that such elements represent buttons. That is, tools such as Web browsers, search engines, or accessibility technology will not automatically treat the resulting element as a button just based on its defined name.
To convey the desired button semantics to a variety of users, while still using an autonomous custom element, a number of techniques would need to be employed:
-
The addition of the tabindex attribute would make the taco-button interactive content, thus making it focusable. Note that if the taco-button were to become logically disabled, the tabindex attribute would need to be removed.
-
The addition of various ARIA attributes helps convey semantics to accessibility technology. For example, setting the role attribute to "button" will convey the semantics that this is a button, enabling users to successfully interact with the control using usual button-like interactions in their accessibility technology. Setting the aria-label attribute is necessary to give the button an accessible name, instead of having accessibility technology traverse its child text nodes and announce them. And setting aria-disabled to "true" when the button is logically disabled conveys to accessibility technology the button's disabled state.
-
The addition of event handlers to handle commonly-expected button behaviours helps convey the semantics of the button to Web browser users. In this case, the most relevant event handler would be one that proxies appropriate keydown events to become click events, so that you can activate the button both with keyboard and by clicking.
-
In addition to any default visual styling provided for taco-button elements, the visual styling will also need to be updated to reflect changes in logical state, such as becoming disabled; that is, whatever stylesheet has rules for taco-button will also need to have rules for taco-button[disabled].
With these points in mind, a full-featured taco-button that took on the responsibility of conveying button semantics (including the ability to be disabled) might look something like this:
class TacoButton extends HTMLElement {
static get observedAttributes() { return ["disabled"]; }
constructor() {
super();
this.addEventListener("keydown", e => {
if (e.keyCode === 32 || e.keyCode === 13) {
this.dispatchEvent(new MouseEvent("click", {
bubbles: true,
cancelable: true
}));
}
});
this.addEventListener("click", e => {
if (this.disabled) {
e.preventDefault();
e.stopPropagation();
}
});
this._observer = new MutationObserver(() => {
this.setAttribute("aria-label", this.textContent);
});
}
connectedCallback() {
this.setAttribute("role", "button");
this.setAttribute("tabindex", "0");
this._observer.observe(this, {
childList: true,
characterData: true,
subtree: true
});
}
disconnectedCallback() {
this._observer.disconnect();
}
get disabled() {
return this.hasAttribute("disabled");
}
set disabled(v) {
if (v) {
this.setAttribute("disabled", "");
} else {
this.removeAttribute("disabled");
}
}
attributeChangedCallback() {
if (this.disabled) {
this.removeAttribute("tabindex");
this.setAttribute("aria-disabled", "true");
} else {
this.setAttribute("tabindex", "0");
this.setAttribute("aria-disabled", "false");
}
}
}
Even with this rather-complicated element definition, the element is not a pleasure to use for consumers: it will be continually "sprouting" tabindex and aria-* attributes of its own volition. This is because as of now there is no way to specify default accessibility semantics or focus behaviour for custom elements, forcing the use of these attributes to do so (even though they are usually reserved for allowing the consumer to override default behaviour).
In contrast, a simple customized built-in element, as shown in the previous section, would automatically inherit the semantics and behaviour of the button element, with no need to implement these behaviours manually. In general, for any elements with nontrivial behaviour and semantics that build on top of existing elements of HTML, customized built-in elements will be easier to develop, maintain, and consume.
2.1.4 Upgrading elements after their creation
This section is non-normative.
Because element definition can occur at any time, a non-custom element could be created, and then later become a custom element after an appropriate definition is registered. We call this process "upgrading" the element, from a normal element into a custom element.
Upgrades enable scenarios where it may be preferable for custom element definitions to be registered after relevant elements has been initially created, such as by the parser. They allow progressive enhancement of the content in the custom element. For example, in the following HTML document the element definition for img-viewer is loaded asynchronously:
<!DOCTYPE html>
<html lang="en">
<title>Image viewer example</title>
<img-viewer filter="Kelvin">
<img src="images/tree.jpg" alt="A beautiful tree towering over an empty savannah">
</img-viewer>
<script src="js/elements/img-viewer.js" async></script>
The definition for the img-viewer element here is loaded using a script element marked with the async attribute, placed after the <img-viewer> tag in the markup. While the script is loading, the img-viewer element will be treated as an undefined element, similar to a span. Once the script loads, it will define the img-viewer element, and the existing img-viewer element on the page will be upgraded, applying the custom element's definition (which presumably includes applying an image filter identified by the string "Kelvin", enhancing the image's visual appearance).
Note that upgrades only apply to elements in the document tree. (Formally, elements that are connected.) An element that is not inserted into a document will stay un-upgraded. An example illustrates this point:
<!DOCTYPE html>
<html lang="en">
<title>Upgrade edge-cases example</title>
<example-element></example-element>
<script>
"use strict";
const inDocument = document.querySelector("example-element");
const outOfDocument = document.createElement("example-element");
console.assert(inDocument instanceof HTMLElement);
console.assert(outOfDocument instanceof HTMLElement);
class ExampleElement extends HTMLElement {}
customElements.define("example-element", ExampleElement);
console.assert(inDocument instanceof ExampleElement);
console.assert(!(outOfDocument instanceof ExampleElement));
document.body.appendChild(outOfDocument);
console.assert(outOfDocument instanceof ExampleElement);
</script>
2.3 Core concepts
A custom element is an element that is custom. Informally, this means that its constructor and prototype are defined by the author, instead of by the user agent. This author-supplied constructor function is called the custom element constructor.
Two distinct types of custom elements can be defined:
-
An autonomous custom element, which is defined with no extends option. These types of custom elements have a local name equal to their defined name.
-
A customized built-in element, which is defined with an extends option. These types of custom elements have local name equal to the value passed in their extends option, and their defined name is used as the value of the is attribute.
After a custom element is created, changing the value of the is attribute does not change the element's behaviour, as it is saved on the element as its is value.
Autonomous custom elements have the following element definition:
-
Categories:
-
Flow content.
-
Phrasing content.
-
Palpable content.
-
Contexts in which this element can be used:
-
Where phrasing content is expected.
-
Content model:
-
Transparent.
-
Content attributes:
-
Global attributes, except the
is attribute
- Any other attribute that has no namespace (see prose).
-
DOM interface:
- Supplied by the element's author (inherits from
HTMLElement)
An autonomous custom element does not have any special meaning: it represents its children. A customized built-in element inherits the semantics of the element that it extends.
Any namespace-less attribute that is relevant to the element's functioning, as determined by the element's author, may be specified on an autonomous custom element, so long as the attribute name is XML-compatible and contains no uppercase ASCII letters. The exception is the is attribute, which must not be specified on an autonomous custom element (and which will have no effect if it is).
Customized built-in elements follow the normal requirements for attributes, based on the elements they extend. To add custom attribute-based behavior, use data-* attributes.
A valid custom element name is a sequence of characters name that meets all of the following requirements:
-
name must match the PotentialCustomElementName production:
PotentialCustomElementName ::=[a-z] (PCENChar)* '-' (PCENChar)*PCENChar ::="-" | "." | [0-9] | "_" | [a-z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
This uses the EBNF notation from the XML specification. [XML]
-
name must not be any of the following:
annotation-xmlcolor-profilefont-facefont-face-srcfont-face-urifont-face-formatfont-face-namemissing-glyph
Note
These requirements ensure a number of goals for valid custom element names:
-
They start with a lowercase ASCII letter, ensuring that the HTML parser will treat them as tags instead of as text.
-
They do not contain any uppercase ASCII letters, ensuring that the user agent can always treat HTML elements ASCII-case-insensitively.
-
They contain a hyphen, used for namespacing and to ensure forward compatibility (since no elements will be added to HTML, SVG, or MathML with hyphen-containing local names in the future).
-
They can always be created with createElement() and createElementNS(), which have restrictions that go beyond the parser's.
Apart from these restrictions, a large variety of names is allowed, to give maximum flexibility for use cases like <math-α> or <emotion-😍>.
A custom element definition describes a custom element and consists of:
- A name
-
A valid custom element name
- A local name
- A local name
- A constructor
-
A custom element constructor
- A prototype
- A JavaScript object
- A list of observed attributes
- A
sequence<DOMString>
- A collection of lifecycle callbacks
- A map, whose four keys are the strings "
connectedCallback", "disconnectedCallback", "adoptedCallback", and "attributeChangedCallback". The corresponding values are either a Web IDL Function callback function type value, or null. By default the value of each entry is null.
- A construction stack
-
A list, initially empty, that is manipulated by the upgrade an element algorithm and the HTML element constructors. Each entry in the list will be either an element or an already constructed marker.
To look up a custom element definition, given a document, namespace, localName, and is, perform the following steps. They will return either a custom element definition or null:
-
If namespace is not the HTML namespace, return null.
-
If document does not have a browsing context, return null.
-
Let registry be document's browsing context's Window's CustomElementsRegistry object.
-
If there is custom element definition in registry with name and local name both equal to localName, return that custom element definition.
-
If there is a custom element definition in registry with name equal to is and local name equal to localName, return that custom element definition.
-
Return null.
2.4 The CustomElementsRegistry interface
Each Window object is associated with a unique instance of a CustomElementsRegistry object, allocated when the Window object is created.
The customElements attribute of the Window interface must return the CustomElementsRegistry object for that Window object.
interface CustomElementsRegistry {
[CEReactions]
void define(DOMString name,
Function constructor,
optional ElementDefinitionOptions options);
any get(DOMString name);
Promise<void> whenDefined(DOMString name);
};
dictionary ElementDefinitionOptions {
DOMString extends;
};
Every CustomElementsRegistry has a set of custom element definitions, initially empty. In general, algorithms in this specification look up elements in the registry by any of name, local name, or constructor.
Every CustomElementsRegistry also has a set of being-defined names and a set of being-defined constructors, containing valid custom element names and JavaScript function objects, respectively. These are used to ensure that when script executes during element definition, which can reentrantly cause element definition again, the script cannot define another element using the same name or constructor.
Every CustomElementsRegistry also has a when-defined promise map, mapping valid custom element names to promises. It is used to implement the whenDefined() method.
Element definition is a process of adding a custom element definition to the CustomElementsRegistry. This is accomplished by the define() method. When invoked, the define(name, constructor, options) method must run these steps:
-
If IsConstructor(constructor) is false, then throw a TypeError and abort these steps.
-
If constructor is either an interface object or named constructor, whose corresponding interface either is HTMLElement or has HTMLElement in its set of inherited interfaces, throw a TypeError and abort these steps.
-
If name is not a valid custom element name, then throw a "SyntaxError" DOMException and abort these steps.
-
If this CustomElementsRegistry contains an entry with name name, then throw a "NotSupportedError" DOMException and abort these steps.
-
If this CustomElementsRegistry's set of being-defined names contains name, then throw a "NotSupportedError" DOMException and abort these steps.
-
If this CustomElementsRegistry contains an entry with constructor constructor, then throw a "NotSupportedError" DOMException and abort these steps.
-
If this CustomElementsRegistry's set of being-defined constructors contains constructor, then throw a "NotSupportedError" DOMException and abort these steps.
-
Let localName be name.
-
Let extends be the value of the extends member of options, or null if no such member exists.
-
If extends is not null, then:
-
If extends is a valid custom element name, then throw a "NotSupportedError" DOMException.
-
If the element interface for extends and the HTML namespace is HTMLUnknownElement (e.g., if extends does not indicate an element definition in this specification), then throw a "NotSupportedError" DOMException.
-
Set localName to extends.
-
Add name to this CustomElementsRegistry's set of being-defined names.
-
Add constructor to this CustomElementsRegistry's set of being-defined constructors.
-
Run the following substeps while catching any exceptions:
-
Let prototype be Get(constructor, "prototype"). Rethrow any exceptions.
-
If Type(prototype) is not Object, then throw a TypeError exception.
-
Let lifecycleCallbacks be a map with the four keys "connectedCallback", "disconnectedCallback", "adoptedCallback", and "attributeChangedCallback", each of which belongs to an entry whose value is null.
-
For each of the four keys callbackName in lifecycleCallbacks:
-
Let callbackValue be Get(prototype, callbackName). Rethrow any exceptions.
-
If callbackValue is not undefined, then set the value of the entry in lifecycleCallbacks with key callbackName to the result of converting callbackValue to the Web IDL Function callback type. Rethrow any exceptions from the conversion.
-
Let observedAttributes be an empty sequence<DOMString>.
-
If the value of the entry in lifecycleCallbacks with key "attributeChangedCallback" is not null, then:
-
Let observedAttributesIterable be Get(constructor, "observedAttributes"). Rethrow any exceptions.
-
If observedAttributesIterable is not undefined, then set observedAttributes to the result of converting observedAttributesIterable to a sequence<DOMString>. Rethrow any exceptions from the conversion.
Then, perform the following substeps, regardless of whether the above steps threw an exception or not:
-
Remove name from this CustomElementsRegistry's set of being-defined names.
-
Remove constructor from this CustomElementsRegistry's set of being-defined constructors.
Finally, if the first set of steps threw an exception, then rethrow that exception, and terminate this algorithm. Otherwise, continue onward.
-
Let definition be a new custom element definition with name name, local name localName, constructor constructor, prototype prototype, observed attributes observedAttributes, and lifecycle callbacks lifecycleCallbacks.
-
Add definition to this CustomElementsRegistry.
-
Let document be this CustomElementsRegistry's relevant global object's associated Document.
-
Let upgrade candidates be all elements that are shadow-including descendants of document, whose namespace is the HTML namespace and whose local name is localName, in shadow-including tree order. Additionally, if extends is non-null, only include elements whose is value is equal to name.
-
For each element element in upgrade candidates, enqueue a custom element upgrade reaction given element and definition.
-
If this CustomElementsRegistry's when-defined promise map contains an entry with key name:
-
Let promise be the value of that entry.
-
Resolve promise with undefined.
-
Delete the entry with key name from this CustomElementsRegistry's when-defined promise map.
When invoked, the get(name) method must run these steps:
-
If this CustomElementsRegistry contains an entry with name name, then return that entry's constructor.
-
Otherwise, return undefined.
When invoked, the whenDefined(name) method must run these steps:
-
If name is not a valid custom element name, then return a new promise rejected with a "SyntaxError" DOMException and abort these steps.
-
If this CustomElementsRegistry contains an entry with name name, then return a new promise resolved with undefined and abort these steps.
-
Let map be this CustomElementsRegistry's when-defined promise map.
-
If map does not contain an entry with key name, create an entry in map with key name and whose value is a new promise.
-
Let promise be the value of the entry in map with key name.
-
Return promise.
The whenDefined() method can be used to avoid performing an action until all appropriate custom elements are defined. In this example, we combine it with the :defined pseudo-class to hide a dynamically-loaded article's contents until we're sure that all of the autonomous custom elements it uses are defined.
articleContainer.hidden = true;
fetch(articleURL)
.then(response => response.text())
.then(text => {
articleContainer.innerHTML = text;
return Promise.all(
[...articleContainer.querySelectorAll(":not(:defined)")]
.map(el => customElements.whenDefined(el.localName))
);
})
.then(() => {
articleContainer.hidden = false;
});
2.6 Custom element reactions
A custom element possesses the ability to respond to certain occurrences by running author code:
We call these reactions collectively custom element reactions.
The way in which custom element reactions are invoked is done with special care, to avoid running author code during the middle of delicate operations. Effectively, they are delayed until "just before returning to user script". This means that for most purposes they appear to execute synchronously, but in the case of complicated composite operations (like cloning, or range manipulation), they will instead be delayed until after all the relevant user agent processing steps have completed, and then run together as a batch.
Additionally, the precise ordering of these reactions is managed via a somewhat-complicated stack-of-queues system, described below. The intention behind this system is to guarantee that custom element reactions always are invoked in the same order as their triggering actions, at least within the local context of a single custom element. (Because custom element reaction code can perform its own mutations, it is not possible to give a global ordering guarantee across multiple elements.)
Each unit of related similar-origin browsing contexts has a custom element reactions stack, which is initially empty. The current element queue is the element queue at the top of the custom element reactions stack. Each item in the stack is an element queue, which is initially empty as well. Each item in an element queue is an element. (The elements are not necessarily custom yet, since this queue is used for upgrades as well.)
Each custom element reactions stack has an associated backup element queue, which an initially-empty element queue. Elements are pushed onto the backup element queue during operations that affect the DOM without going through an API decorated with [CEReactions], or through the parser's create an element for the token algorithm. An example of this is a user-initiated editing operation which modifies the descendants or attributes of an editable element. To prevent reentrancy when processing the backup element queue, each custom element reactions stack also has a processing the backup element queue flag, initially unset.
All elements have an associated custom element reaction queue, initially empty. Each item in the custom element reaction queue is of one of two types:
-
An upgrade reaction, which will upgrade the custom element and contains a custom element definition; or
-
A callback reaction, which will call a lifecycle callback, and contains a callback function as well as a list of arguments.
This is all summarised in the following schematic diagram:
To enqueue an element on the appropriate element queue, given an element element, run the following steps:
-
If the custom element reactions stack is empty, then:
-
Add element to the backup element queue.
-
If the processing the backup element queue flag is set, abort this algorithm.
-
Set the processing the backup element queue flag.
-
Queue a microtask to perform the following steps:
-
Invoke custom element reactions in the backup element queue.
-
Unset the processing the backup element queue flag.
-
Otherwise, add element to the current element queue.
To enqueue a custom element callback reaction, given a custom element element, a callback name callbackName, and a list of arguments args, run the following steps:
-
Let definition be element's custom element definition.
-
Let callback be the value of the entry in definition's lifecycle callbacks with key callbackName.
-
If callback is null, then abort these steps.
-
If callbackName is "attributeChangedCallback", then:
-
Let attributeName be the first element of args.
-
If definition's observed attributes does not contain attributeName, then abort these steps.
-
Add a new callback reaction to element's custom element reaction queue, with callback function callback and arguments args.
-
Enqueue an element on the appropriate element queue given element.
To enqueue a custom element upgrade reaction, given an element element and custom element definition definition, run the following steps:
-
Add a new upgrade reaction to element's custom element reaction queue, with custom element definition definition.
-
Enqueue an element on the appropriate element queue given element.
To invoke custom element reactions in an element queue queue, run the following steps:
-
For each custom element element in queue:
-
Let reactions be element's custom element reaction queue.
-
Repeat until reactions is empty:
-
Remove the first element of reactions, and let reaction be that element. Switch on reaction's type:
-
upgrade reaction
-
Upgrade element using reaction's custom element definition.
-
callback reaction
-
Invoke reaction's callback function with reaction's arguments, and with element as the callback this value.
If this throws any exception, then report the exception.
To ensure custom element reactions are triggered appropriately, we introduce the [CEReactions] IDL extended attribute. It indicates that the relevant algorithm is to be supplemented with additional steps in order to appropriately track and invoke custom element reactions.
The [CEReactions] extended attribute must take no arguments, and must not appear on anything other than an operation, attribute, setter, or deleter. Additionally, it must not appear on readonly attributes, unless the readonly attribute is also annotated with [PutForwards].
Operations, attributes, setters, or deleters annotated with the [CEReactions] extended attribute must run the following steps surrounding the main algorithm specified for the operation, setter, deleter, or for the attribute's setter:
- Before executing the algorithm's steps
-
Push a new element queue onto the custom element reactions stack.
- After executing the algorithm's steps
-
Pop the element queue from the custom element reactions stack, and invoke custom element reactions in that queue.
Note
The intent behind this extended attribute is somewhat subtle. One way of accomplishing its goals would be to say that every operation, attribute, setter, and deleter on the platform should have these steps inserted, and to allow implementers to optimize away unnecessary cases (where no DOM mutation is possible that could cause custom element reactions to occur).
However, in practice this imprecision could lead to non-interoperable implementations of custom element reactions, as some implementations might forget to invoke these steps in some cases. Instead, we settled on the approach of explicitly annotating all relevant IDL constructs, as a way of ensuring interoperable behavior and helping implementations easily pinpoint all cases where these steps are necessary.
Any nonstandard APIs introduced by the user agent that could modify the DOM in such a way as to cause enqueuing a custom element callback reaction or enqueuing a custom element upgrade reaction, for example by modifying any attributes or child elements, must also be decorated with the [CEReactions] attribute.
Note
As of the time of this writing, the following nonstandard or not-yet-standardized APIs are known to fall into this category: