DOM

Goals

This specification standardizes the DOM. It does so as follows:

1. By consolidating DOM Level 3 Core [DOM-Level-3-Core], Element Traversal [ELEMENTTRAVERSAL], Selectors API Level 2 [SELECTORS-API2], the "DOM Event Architecture" and "Basic Event Interfaces" chapters of DOM Level 3 Events [uievents-20031107] (specific types of events do not belong in the DOM Standard), and DOM Level 2 Traversal and Range [DOM-Level-2-Traversal-Range], and:

   • Aligning them with the JavaScript ecosystem where possible.
   • Aligning them with existing implementations.
   • Simplifying them as much as possible.

2. By moving features from the HTML Standard [HTML] that make more sense to be specified as part of the DOM Standard.

3. By defining a replacement for the "Mutation Events" and "Mutation Name Event Types" chapters of DOM Level 3 Events [uievents-20031107] as the old model was problematic.

   The old model is expected to be removed from implementations in due course.

4. By defining new features that simplify common DOM operations.

1. Conformance

All diagrams, examples, and notes in this specification are non-normative, as are all sections explicitly marked non-normative. Everything else in this specification is normative.

The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119. For readability, these words do not appear in all uppercase letters in this specification. [RFC2119]

Requirements phrased in the imperative as part of algorithms (such as "strip any leading space characters" or "return false and terminate these steps") are to be interpreted with the meaning of the keyword ("must", "should", "may", etc.) used in introducing the algorithm.

Conformance requirements phrased as algorithms or specific steps may be implemented in any manner, so long as the end result is equivalent. (In particular, the algorithms defined in this specification are intended to be easy to follow, and not intended to be performant.)

User agents may impose implementation-specific limits on otherwise unconstrained inputs, e.g. to prevent denial of service attacks, to guard against running out of memory, or to work around platform-specific limitations.

When a method or an attribute is said to call another method or attribute, the user agent must invoke its internal API for that attribute or method so that e.g. the author can’t change the behavior by overriding attributes or methods with custom properties or functions in JavaScript.

Unless otherwise stated, string comparisons are done in a case-sensitive manner.

1.1. Dependencies

The IDL fragments in this specification must be interpreted as required for conforming IDL fragments, as described in the Web IDL specification. [WEBIDL]

Some of the terms used in this specification are defined in Encoding, Selectors, Web IDL, XML, and Namespaces in XML. [ENCODING] [SELECTORS4] [WEBIDL] [XML] [XML-NAMES]

1.2. Extensibility

Vendor-specific proprietary extensions to this specification are strongly discouraged. Authors must not use such extensions, as doing so reduces interoperability and fragments the user base, allowing only users of specific user agents to access the content in question.

When extensions are needed, the DOM Standard can be updated accordingly, or a new standard can be written that hooks into the provided extensibility hooks for applicable specifications.

2. Terminology

The term context object means the object on which the algorithm, attribute getter, attribute setter, or method being discussed was called. When the context object is unambiguous, the term can be omitted.

2.1. Trees

A tree is a finite hierarchical tree structure. In tree order is preorder, depth-first traversal of a tree.

An object that participates in a tree has a parent, which is either another object or null, and an ordered list of zero or more child objects. An object A whose parent is object B is a child of B.

The root of an object is itself, if its parent is null, or else it is the root of its parent.

An object A is called a descendant of an object B, if either A is a child of B or A is a child of an object C that is a descendant of B.

An inclusive descendant is an object or one of its descendants.

An object A is called an ancestor of an object B if and only if B is a descendant of A.

An inclusive ancestor is an object or one of its ancestors.

An object A is called a sibling of an object B, if and only if B and A share the same non-null parent.

An inclusive sibling is an object or one of its siblings.

An object A is preceding an object B if A and B are in the same tree and A comes before B in tree order.

An object A is following an object B if A and B are in the same tree and A comes after B in tree order.

The first child of an object is its first child or null if it has no children.

The last child of an object is its last child or null if it has no children.

The previous sibling of an object is its first preceding sibling or null if it has no preceding sibling.

The next sibling of an object is its first following sibling or null if it has no following sibling.

The index of an object is its number of preceding siblings.

2.2. Strings

Comparing two strings in a case-sensitive manner means comparing them exactly, code point for code point.

Comparing two strings in a ASCII case-insensitive manner means comparing them exactly, code point for code point, except that the characters in the range U+0041 to U+005A (i.e. LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z), inclusive, and the corresponding characters in the range U+0061 to U+007A (i.e. LATIN SMALL LETTER A to LATIN SMALL LETTER Z), inclusive, are considered to also match.

Converting a string to ASCII uppercase means replacing all characters in the range U+0061 to U+007A, inclusive, with the corresponding characters in the range U+0041 to U+005A, inclusive.

Converting a string to ASCII lowercase means replacing all characters in the range U+0041 to U+005A, inclusive, with the corresponding characters in the range U+0061 to U+007A, inclusive.

A string pattern is a prefix match for a string s when pattern is not longer than s and truncating s to pattern’s length leaves the two strings as matches of each other.

2.3. Ordered sets

The ordered set parser takes a string input and then runs these steps:

1. Let position be a pointer into input, initially pointing at the start of the string.
2. Let tokens be an ordered set of tokens, initially empty.
3. Skip ASCII whitespace.
4. While position is not past the end of input:
   1. Collect a code point sequence of code points that are not ASCII whitespace.
   2. If the collected string is not in tokens, append the collected string to tokens.
   3. Skip ASCII whitespace.
5. Return tokens.

To collect a code point sequence of code points, run these steps:

1. Let input and position be the same variables as those of the same name in the algorithm that invoked these steps.
2. Let result be the empty string.
3. While position does not point past the end of input and the code point at position is one of code points, append that code point to the end of result and advance position to the next code point in input.
4. Return result.

To skip ASCII whitespace means to collect a code point sequence of ASCII whitespace and discard the return value.

The ordered set serializer takes a set and returns the concatenation of the strings in set, separated from each other by U+0020.

2.4. Selectors

To match a relative selectors string relativeSelectors against a set, run these steps:

1. Let s be the result of parse a relative selector from relativeSelectors against set. [SELECTORS4]
2. If s is failure, throw a SyntaxError.
3. Return the result of evaluate a selector s using :scope elements set. [SELECTORS4]

To scope-match a selectors string selectors against a node, run these steps:

1. Let s be the result of parse a selector selectors. [SELECTORS4]
2. If s is failure, throw a SyntaxError.
3. Return the result of evaluate a selector s against node’s root using scoping root node and scoping method scope-filtered. [SELECTORS4].

Support for namespaces within selectors is not planned and will not be added.

2.5. Namespaces

The HTML namespace is http://www.w3.org/1999/xhtml.

The XML namespace is http://www.w3.org/XML/1998/namespace.

The XMLNS namespace is http://www.w3.org/2000/xmlns/.

To validate a qualifiedName, run these steps:

1. If qualifiedName does not match the Name production, throw an InvalidCharacterError exception.
2. If qualifiedName does not match the QName production, throw a NamespaceError exception.

To validate and extract a namespace and qualifiedName, run these steps:

1. If namespace is the empty string, set it to null.
2. Validate qualifiedName. Rethrow any exceptions.
3. Let prefix be null.
4. Let localName be qualifiedName.
5. If qualifiedName contains a ":" (U+003E), then split the string on it and set prefix to the part before and localName to the part after.
6. If prefix is non-null and namespace is null, throw a NamespaceError exception.
7. If prefix is "xml" and namespace is not the XML namespace, throw a NamespaceError exception.
8. If either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace, throw a NamespaceError exception.
9. If namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns", throw a NamespaceError exception.
10. Return namespace, prefix, localName, and qualifiedName.

3. Events

3.1. Introduction to "DOM Events"

Throughout the web platform events are dispatched to objects to signal an occurrence, such as network activity or user interaction. These objects implement the EventTarget interface and can therefore add event listeners to observe events by calling addEventListener():

obj.addEventListener("load", imgFetched)

function imgFetched(ev) {
  // great success
  …
}

Event listeners can be removed by utilizing the removeEventListener() method, passing the same arguments.

Events are objects too and implement the Event interface (or a derived interface). In the example above ev is the event. It is passed as argument to event listener’s callback (typically a JavaScript Function as shown above). Event listeners key off the event’s type attribute value ("load" in the above example). The event’s target attribute value returns the object to which the event was dispatched (obj above).

Now while typically events are dispatched by the user agent as the result of user interaction or the completion of some task, applications can dispatch events themselves, commonly known as synthetic events:

// add an appropriate event listener
obj.addEventListener("cat", function(e) { process(e.detail) })

// create and dispatch the event
var event = new CustomEvent("cat", {"detail":{"hazcheeseburger":true}})
obj.dispatchEvent(event)

Apart from signaling, events are sometimes also used to let an application control what happens next in an operation. For instance as part of form submission an event whose type attribute value is "submit" is dispatched. If this event’s preventDefault() method is invoked, form submission will be terminated. Applications who wish to make use of this functionality through events dispatched by the application (synthetic events) can make use of the return value of the dispatchEvent() method:

if(obj.dispatchEvent(event)) {
  // event was not canceled, time for some magic
  …
}

When an event is dispatched to an object that participates in a tree (e.g. an element), it can reach event listeners on that object’s ancestors too. First all object’s ancestor event listeners whose capture variable is set to true are invoked, in tree order. Second, object’s own event listeners are invoked. And finally, and only if event’s bubbles attribute value is true, object’s ancestor event listeners are invoked again, but now in reverse tree order.

Lets look at an example of how events work in a tree:

<!doctype html>
<html>
 <head>
  <title>Boring example</title>
 </head>
 <body>
  <p>Hello <span id=x>world</span>!</p>
  <script>
   function test(e) {
     debug(e.target, e.currentTarget, e.eventPhase)
   }
   document.addEventListener("hey", test, true)
   document.body.addEventListener("hey", test)
   var ev = new Event("hey", {bubbles:true})
   document.getElementById("x").dispatchEvent(ev)
  </script>
 </body>
</html>

The debug function will be invoked twice. Each time the event’s target attribute value will be the span element. The first time currentTarget attribute’s value will be the document, the second time the body element. eventPhase attribute’s value switches from CAPTURING_PHASE to BUBBLING_PHASE. If an event listener was registered for the span element, eventPhase attribute’s value would have been AT_TARGET.

3.2. Interface Event

[Constructor(DOMString type, optional EventInit eventInitDict),
 Exposed=(Window,Worker)]
interface Event {
  readonly attribute DOMString type;
  readonly attribute EventTarget? target;
  readonly attribute EventTarget? currentTarget;

  const unsigned short NONE = 0;
  const unsigned short CAPTURING_PHASE = 1;
  const unsigned short AT_TARGET = 2;
  const unsigned short BUBBLING_PHASE = 3;
  readonly attribute unsigned short eventPhase;

  void stopPropagation();
  void stopImmediatePropagation();

  readonly attribute boolean bubbles;
  readonly attribute boolean cancelable;
  void preventDefault();
  readonly attribute boolean defaultPrevented;

  [Unforgeable] readonly attribute boolean isTrusted;
  readonly attribute DOMTimeStamp timeStamp;

  void initEvent(DOMString type, boolean bubbles, boolean cancelable);
};

dictionary EventInit {
  boolean bubbles = false;
  boolean cancelable = false;
};

An event allows for signaling that something has occurred, e.g. that an image has completed downloading. It is represented by the Event interface or an interface that inherits from the Event interface.

event = new Event(type [, eventInitDict])

Returns a new event whose type attribute value is set to type. The optional eventInitDict argument allows for setting the bubbles and cancelable attributes via object members of the same name.

event . type

Returns the type of event, e.g. "click", "hashchange", or "submit".

event . target

Returns the object to which event is dispatched.

event . currentTarget

Returns the object whose event listener’s callback is currently being invoked.

event . eventPhase

Returns the event’s phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.

event . stopPropagation()

When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.

event . stopImmediatePropagation()

Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.

event . bubbles

Returns true or false depending on how event was initialized. True if event goes through its target attribute value’s ancestors in reverse tree order, and false otherwise.

event . cancelable

Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method.

event . preventDefault()

If invoked when the cancelable attribute value is true, signals to the operation that caused event to be dispatched that it needs to be canceled.

event . defaultPrevented

Returns true if preventDefault() was invoked while the cancelable attribute value is true, and false otherwise.

event . isTrusted

Returns true if event was dispatched by the user agent, and false otherwise.

event . timeStamp

Returns the creation time of event as the number of milliseconds that passed since 00:00:00 UTC on 1 January 1970.

The type attribute must return the value it was initialized to. When an event is created the attribute must be initialized to the empty string.

The target and currentTarget attributes must return the values they were initialized to. When an event is created the attributes must be initialized to null.

The eventPhase attribute must return the value it was initialized to, which must be one of the following:

NONE (numeric value 0)

Events not currently dispatched are in this phase.

CAPTURING_PHASE (numeric value 1)

When an event is dispatched to an object that participates in a tree it will be in this phase before it reaches its target attribute value.

AT_TARGET (numeric value 2)

When an event is dispatched it will be in this phase on its target attribute value.

BUBBLING_PHASE (numeric value 3)

When an event is dispatched to an object that participates in a tree it will be in this phase after it reaches its target attribute value.

Each event has the following associated flags that are all initially unset:

• stop propagation flag
• stop immediate propagation flag
• canceled flag
• initialized flag
• dispatch flag

The stopPropagation() method must set the stop propagation flag.

The stopImmediatePropagation() method must set both the stop propagation flag and stop immediate propagation flag.

The bubbles and cancelable attributes must return the values they were initialized to.

The preventDefault() method must set the canceled flag if the cancelable attribute value is true.

The defaultPrevented attribute must return true if the canceled flag is set and false otherwise.

The isTrusted attribute must return the value it was initialized to. When an event is created the attribute must be initialized to false.

The timeStamp attribute must return the value it was initialized to. When an event is created the attribute must be initialized to the number of milliseconds that have passed since 00:00:00 UTC on 1 January 1970, ignoring leap seconds.

To initialize an event, with type, bubbles, and cancelable, run these steps:

1. Set the initialized flag.
2. Unset the stop propagation flag, stop immediate propagation flag, and canceled flag.
3. Set the isTrusted attribute to false.
4. Set the target attribute to null.
5. Set the type attribute to type.
6. Set the bubbles attribute to bubbles.
7. Set the cancelable attribute to cancelable.

The initEvent(type, bubbles, cancelable) method, when invoked, must run these steps:

1. If context object’s dispatch flag is set, terminate these steps.
2. Initialize the context object with type, bubbles, and cancelable.

As events have constructors initEvent() is superfluous. However, it has to be supported for legacy content.

3.3. Interface CustomEvent

[Constructor(DOMString type, optional CustomEventInit eventInitDict),
 Exposed=(Window,Worker)]
interface CustomEvent : Event {
  readonly attribute any detail;

  void initCustomEvent(DOMString type, boolean bubbles, boolean cancelable, any detail);
};

dictionary CustomEventInit : EventInit {
  any detail = null;
};

Events using the CustomEvent interface can be used to carry custom data.

event = new CustomEvent(type [, eventInitDict])

Works analogously to the constructor for Event except that the optional eventInitDict argument now allows for setting the detail attribute too.IDL

event . detail

Returns any custom data event was created with. Typically used for synthetic events.

The detail attribute must return the value it was initialized to.

The initCustomEvent(type, bubbles, cancelable, detail) method must, when invoked, run these steps:

1. If context object’s dispatch flag is set, terminate these steps.
2. Initialize the context object with type, bubbles, and cancelable.
3. Set context object’s detail attribute to detail.

3.4. Constructing events

When a constructor of the Event interface, or of an interface that inherits from the Event interface, is invoked, these steps must be run:

1. Create an event that uses the interface the constructor was invoked upon.

2. Set its initialized flag.

3. Initialize the type attribute to the type argument.

4. If there is an eventInitDict argument, then for each dictionary member present, find the attribute on event whose identifier matches the key of the dictionary member and then set the attribute to the value of that dictionary member.

5. Return the event.

3.5. Defining event interfaces

In general, when defining a new interface that inherits from Event please always ask feedback from the WHATWG or the W3C WebApps WG community.

The CustomEvent interface can be used as starting point. However, do not introduce any init*Event() methods as they are redundant with constructors. Interfaces that inherit from the Event interface that have such a method only have it for historical reasons.

3.6. Interface EventTarget

[Exposed=(Window,Worker)]
interface EventTarget {
  void addEventListener(DOMString type, EventListener? callback, optional boolean capture = false);
  void removeEventListener(DOMString type, EventListener? callback, optional boolean capture = false);
  boolean dispatchEvent(Event event);
};

callback interface EventListener {
  void handleEvent(Event event);
};

EventTarget is an object to which an event is dispatched when something has occurred. Each EventTarget has an associated list of event listeners.

An event listener associates a callback with a specific event. Each event listener consists of a type (of the event), callback, and capture variable.

The callback is named EventListener for historical reasons. As can be seen from the definition above, an event listener is a more broad concept.

target . addEventListener(type, callback [, capture = false])

Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched. When set to true, the capture argument prevents callback from being invoked when the event’s eventPhase attribute value is BUBBLING_PHASE. When false, callback will not be invoked when event’s eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event’s eventPhase attribute value is AT_TARGET.

The event listener is appended to target’s list of event listeners and is not appended if it is a duplicate, i.e. having the same type, callback, and capture values.

target . removeEventListener(type, callback [, capture = false])

Remove the event listener in target’s list of event listeners with the same type, callback, and capture.

target . dispatchEvent(event)

Dispatches a synthetic event event to target and returns true if either event’s cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.

The addEventListener(type, callback, capture) method must run these steps:

1. If callback is null, terminate these steps.
2. Append an event listener to the associated list of event listeners with type set to type, callback set to callback, and capture set to capture, unless there already is an event listener in that list with the same type, callback, and capture.

The removeEventListener(type, callback, capture) method must run these steps:

1. Remove an event listener from the associated list of event listeners, whose type is name, callback is callback, and capture is capture.

The dispatchEvent(event) method must run these steps:

1. If event’s dispatch flag is set, or if its initialized flag is not set, throw an InvalidStateError exception.
2. Initialize event’s isTrusted attribute to false.
3. Dispatch the event and return the value that returns.

3.7. Dispatching events

To dispatch an event to a given object, with an optional target override, run these steps:

1. Let event be the event that is dispatched.
2. Set event’s dispatch flag.
3. Initialize event’s target attribute to target override, if it is given, and the object to which event is dispatched otherwise.
4. If event’s target attribute value is participating in a tree, let event path be a static ordered list of all its ancestors in tree order, and let event path be the empty list otherwise.
5. Initialize event’s eventPhase attribute to CAPTURING_PHASE.
6. For each object in event path, invoke its event listeners with event event, as long as event’s stop propagation flag is unset.
7. Initialize event’s eventPhase attribute to AT_TARGET.
8. Invoke the event listeners of event’s target attribute value with event, if event’s stop propagation flag is unset.
9. If event’s bubbles attribute value is true, run these substeps:
   1. Reverse the order of event path.
   2. Initialize event’s eventPhase attribute to BUBBLING_PHASE.
   3. For each object in event path, invoke its event listeners, with event event as long as event’s stop propagation flag is unset.
10. Unset event’s dispatch flag.
11. Initialize event’s eventPhase attribute to NONE.
12. Initialize event’s currentTarget attribute to null.
13. Return false if event’s canceled flag is set, and true otherwise.

To invoke the event listeners for an object with an event run these steps:

1. Let event be the event for which the event listeners are invoked.
2. Let listeners be a copy of the event listeners associated with the object for which these steps are run.
3. Initialize event’s currentTarget attribute to the object for which these steps are run.
4. Then run these substeps for each event listener in listeners:
   1. If event’s stop immediate propagation flag is set, terminate the invoke algorithm.
   2. Let listener be the event listener.
   3. If event’s type attribute value is not listener’s type, terminate these substeps (and run them for the next event listener).
   4. If event’s eventPhase attribute value is CAPTURING_PHASE and listener’s capture is false, terminate these substeps (and run them for the next event listener).
   5. If event’s eventPhase attribute value is BUBBLING_PHASE and listener’s capture is true, terminate these substeps (and run them for the next event listener).
   6. Call listener’s callback’s handleEvent(), with the event passed to this algorithm as the first argument and event’s currentTarget attribute value as callback this value. If this throws any exception, report the exception.

3.8. Firing events

To fire an event named e means that a new event using the Event interface, with its type attribute initialized to e, and its isTrusted attribute initialized to true, is to be dispatched to the given object.

Fire in the context of DOM is short for creating, initializing, and dispatching an event. Fire an event makes that process easier to write down. If the event needs its bubbles or cancelable attribute initialized, one could write "fire an event named submit with its cancelable attribute initialized to true".

3.9. Action versus occurrence

An event signifies an occurrence, not an action. Phrased differently, it represents a notification from an algorithm and can be used to influence the future course of that algorithm (e.g., through invoking preventDefault()). Events must not be used as actions or initiators that cause some algorithm to start running. That is not what they are for.

This is called out here specifically because previous iterations of the DOM had a concept of "default actions" associated with events that gave folks all the wrong ideas. Events do not represent or cause actions, they can only be used to influence an ongoing one.

4. Nodes

4.1. Introduction to "The DOM"

In its original sense, "The DOM" is an API for accessing and manipulating documents (in particular, HTML and XML documents). In this specification, the term "document" is used for any markup-based resource, ranging from short static documents to long essays or reports with rich multimedia, as well as to fully-fledged interactive applications.

These documents are presented as a node tree. Some of the nodes in the tree can have children, while others are always leaves.

To illustrate, consider this HTML document:

<!DOCTYPE html>
<html class=e>
 <head><title>Aliens?</title></head>
 <body>Why yes.</body>
</html>

It is represented as follows:

• Document
  • Doctype: html
  • Element: html class="e"
    • Element: head
      • Element: title
        • Text: Aliens?
    • Text: ⏎␣
    • Element: body
      • Text: Why yes.⏎

Note that, due to the magic that is HTML parsing, not all ASCII whitespace were turned into Text nodes, but the general concept is clear. Markup goes in, a tree of nodes comes out.

The most excellent Live DOM Viewer can be used to explore this matter in more detail.

4.2. Node tree

Objects implementing the Document, DocumentFragment, DocumentType, Element, Text, ProcessingInstruction, or Comment interface (simply called nodes) participate in a tree, simply named the node tree.

A node tree is constrained as follows, expressed as a relationship between the type of node and its allowed children:

Document

In tree order:

1. Zero or more nodes each of which is either ProcessingInstruction or Comment.
2. Optionally one DocumentType node.
3. Zero or more nodes each of which is either ProcessingInstruction or Comment.
4. Optionally one Element node.
5. Zero or more nodes each of which is either ProcessingInstruction or Comment.

DocumentFragment

Element

Zero or more nodes each of which is one of Element, ProcessingInstruction, Comment, or Text.

DocumentType

Text

ProcessingInstruction

Comment

None.

The length of a node node depends on node:

DocumentType

Zero.

Text

ProcessingInstruction

Comment

Its length attribute value.

Any other node

Its number of children.

A node is considered empty if its length is zero.

4.2.1. Mutation algorithms

To ensure pre-insertion validity of a node into a parent before a child, run these steps:

1. If parent is not a Document, DocumentFragment, or Element node, throw a HierarchyRequestError.
2. If node is a host-including inclusive ancestor of parent, throw a HierarchyRequestError.
3. If child is not null and its parent is not parent, throw a NotFoundError exception.
4. If node is not a DocumentFragment, DocumentType, Element, Text, ProcessingInstruction, or Comment node, throw a HierarchyRequestError.
5. If either node is a Text node and parent is a document, or node is a doctype and parent is not a document, throw a HierarchyRequestError.
6. If parent is a document, and any of the statements below, switched on node, are true, throw a HierarchyRequestError.

   DocumentFragment node

   If node has more than one element child or has a Text node child.

   Otherwise, if node has one element child and either parent has an element child, child is a doctype, or child is not null and a doctype is following child.

   element

   parent has an element child, child is a doctype, or child is not null and a doctype is following child.

   doctype

   parent has a doctype child, an element is preceding child, or child is null and parent has an element child.

To pre-insert a node into a parent before a child, run these steps:

1. Ensure pre-insertion validity of node into parent before child.
2. Let reference child be child.
3. If reference child is node, set it to node’s next sibling.
4. Adopt node into parent’s node document.
5. Insert node into parent before reference child.
6. Return node.

Specifications may define insertion steps for all or some nodes. The algorithm is passed newNode as indicated in the insert algorithm below.

To insert a node into a parent before a child, with an optional suppress observers flag, run these steps:

1. Let count be the number of children of node if it is a DocumentFragment node, and one otherwise.
2. If child is non-null, run these substeps:
   1. For each range whose start node is parent and start offset is greater than child’s index, increase its start offset by count.
   2. For each range whose end node is parent and end offset is greater than child’s index, increase its end offset by count.
3. Let nodes be node’s children if node is a DocumentFragment node, and a list containing solely node otherwise.
4. If node is a DocumentFragment node, remove its children with the suppress observers flag set.
5. If node is a DocumentFragment node, queue a mutation record of "childList" for node with removedNodes nodes.

   This step intentionally does not pay attention to the suppress observers flag.

6. For each newNode in nodes, in tree order, run these substeps:
   1. Insert newNode into parent before child or at the end of parent if child is null.
   2. Run the insertion steps with newNode.
7. If suppress observers flag is unset, queue a mutation record of "childList" for parent with addedNodes nodes, nextSibling child, and previousSibling child’s previous sibling or parent’s last child if child is null.

To append a node to a parent, pre-insert node into parent before null.

To replace a child with node within a parent, run these steps:

1. If parent is not a Document, DocumentFragment, or Element node, throw a HierarchyRequestError.
2. If node is a host-including inclusive ancestor of parent, throw a HierarchyRequestError.
3. If child’s parent is not parent, throw a NotFoundError exception.
4. If node is not a DocumentFragment, DocumentType, Element, Text, ProcessingInstruction, or Comment node, throw a HierarchyRequestError.
5. If either node is a Text node and parent is a document, or node is a doctype and parent is not a document, throw a HierarchyRequestError.
6. If parent is a document, and any of the statements below, switched on node, are true, throw a HierarchyRequestError.

   DocumentFragment node

   If node has more than one element child or has a Text node child.

   Otherwise, if node has one element child and either parent has an element child that is not child or a doctype is following child.

   element

   parent has an element child that is not child or a doctype is following child.

   doctype

   parent has a doctype child that is not child, or an element is preceding child.

   The above statements differ from the pre-insert algorithm.

7. Let reference child be child’s next sibling.
8. If reference child is node, set it to node’s next sibling.

9. Let previousSibling be child’s previous sibling.

10. Adopt node into parent’s node document.
11. Remove child from its parent with the suppress observers flag set.
12. Let nodes be node’s children if node is a DocumentFragment node, and a list containing solely node otherwise.
13. Insert node into parent before reference child with the suppress observers flag set.
14. Queue a mutation record of "childList" for target parent with addedNodes nodes, removedNodes a list solely containing child, nextSibling reference child, and previousSibling previousSibling.
15. Return child.

To replace all with a node within a parent, run these steps:

1. If node is not null, adopt node into parent’s node document.
2. Let removedNodes be parent’s children.
3. Let addedNodes be the empty list if node is null, node’s children if node is a DocumentFragment node, and a list containing node otherwise.
4. Remove all parent’s children, in tree order, with the suppress observers flag set.
5. If node is not null, insert node into parent before null with the suppress observers flag set.
6. Queue a mutation record of "childList" for parent with addedNodes addedNodes and removedNodes removedNodes.

This algorithm does not make any checks with regards to the node tree constraints. Specification authors need to use it wisely.

To pre-remove a child from a parent, run these steps:

1. If child’s parent is not parent, throw a NotFoundError exception.
2. Remove child from parent.
3. Return child.

Specifications may define removing steps for all or some nodes. The algorithm is passed removedNode, oldParent, and oldPreviousSibling, as indicated in the remove algorithm below.

To remove a node from a parent, with an optional suppress observers flag, run these steps:

1. Let index be node’s index.
2. For each range whose start node is an inclusive descendant of node, set its start to (parent, index).
3. For each range whose end node is an inclusive descendant of node, set its end to (parent, index).
4. For each range whose start node is parent and start offset is greater than index, decrease its start offset by one.
5. For each range whose end node is parent and end offset is greater than index, decrease its end offset by one.

6. For each NodeIterator object iterator whose root’s node document is node’s node document, run the NodeIterator pre-removing steps given node and iterator.

7. Let oldPreviousSibling be node’s previous sibling
8. Remove node from its parent.
9. Run the removing steps with node, parent, and oldPreviousSibling.
10. For each inclusive ancestor ancestor of parent, if ancestor has any registered observers whose options' subtree is true, then for each such registered observer registered, append a transient registered observer whose observer and options are identical to those of registered and source which is registered to node’s list of registered observers.
11. If suppress observers flag is unset, queue a mutation record of "childList" for parent with removedNodes a list solely containing node, nextSibling node’s next sibling, and previousSibling oldPreviousSibling.

4.2.2. Interface NonElementParentNode

The getElementById() method is not on elements for compatibility with older versions of jQuery. If a time comes where that version of jQuery has disappeared, we might be able to support it.

[NoInterfaceObject,
 Exposed=Window]
interface NonElementParentNode {
  Element? getElementById(DOMString elementId);
};
Document implements NonElementParentNode;
DocumentFragment implements NonElementParentNode;

node . getElementById(elementId)

Returns the first element within node’s descendants whose ID is elementId.

The getElementById(elementId) method must return the first element, in tree order, within context object’s descendants, whose ID is elementId, and null if there is no such element otherwise.

4.2.3. Interface ParentNode

To convert nodes into a node, run these steps:

1. Let node be null.

2. Replace each string in nodes with a Text node whose data is the string.

3. If nodes contains one node, set node to that node.

4. Otherwise, set node to a new DocumentFragment, and then append each node in nodes, if any, to it. Rethrow any exceptions.

5. Return node.

[NoInterfaceObject,
 Exposed=Window]
interface ParentNode {
  [SameObject] readonly attribute HTMLCollection children;
  readonly attribute Element? firstElementChild;
  readonly attribute Element? lastElementChild;
  readonly attribute unsigned long childElementCount;

  [Unscopeable] void prepend((Node or DOMString)... nodes);
  [Unscopeable] void append((Node or DOMString)... nodes);

  [Unscopeable] Element? query(DOMString relativeSelectors);
  [NewObject, Unscopeable] Elements queryAll(DOMString relativeSelectors);
  Element? querySelector(DOMString selectors);
  [NewObject] NodeList querySelectorAll(DOMString selectors);
};
Document implements ParentNode;
DocumentFragment implements ParentNode;
Element implements ParentNode;

collection = node . children

Returns the child elements.

element = node . firstElementChild

Returns the first child that is an element, and null otherwise.

element = node . lastElementChild

Returns the last child that is an element, and null otherwise.

node . prepend(nodes)

Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.

Throws a HierarchyRequestError if the constraints of the node tree are violated.

node . append(nodes)

Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.

Throws a HierarchyRequestError if the constraints of the node tree are violated.

node . query(relativeSelectors)

Returns the first element that is a descendant of node that matches relativeSelectors.

node . queryAll(relativeSelectors)

Returns all element descendants of node that match relativeSelectors.

node . querySelector(selectors)

Returns the first element that is a descendant of node that matches selectors.

node . querySelectorAll(selectors)

Returns all element descendants of node that match selectors.

The children attribute must return an HTMLCollection collection rooted at the context object matching only element children.

The firstElementChild attribute must return the first child that is an element, and null otherwise.

The lastElementChild attribute must return the last child that is an element, and null otherwise.

The childElementCount attribute must return the number of children of the context object that are elements.

The prepend(nodes) method must run these steps:

1. Let node be the result of converting nodes into a node.
2. Pre-insert node into the context object before the context object’s first child.

The append(nodes) method must run these steps:

1. Let node be the result of converting nodes into a node.
2. Append node to the context object.

The query(relativeSelectors) method, when invoked, must return the first result of running match a relative selectors string relativeSelectors against a set consisting of context object, and null if the result is an empty list.

The queryAll(relativeSelectors) method, when invoked, must return an Elements array initialized with the result of running match a relative selectors string relativeSelectors against a set consisting of context object.

The querySelector(selectors) method, when invoked, must return the first result of running scope-match a selectors string selectors against the context object, and null if the result is an empty list otherwise.

The querySelectorAll(selectors) method, when invoked, must return the static result of running scope-match a selectors string selectors against the context object.

4.2.4. Interface NonDocumentTypeChildNode

The previousElementSibling and nextElementSibling attributes have been removed from DocumentType nodes for compatibility reasons. If these additions are deemed compatible enough in the future, they could be reinstated.

[NoInterfaceObject,
 Exposed=Window]
interface NonDocumentTypeChildNode {
  readonly attribute Element? previousElementSibling;
  readonly attribute Element? nextElementSibling;
};
Element implements NonDocumentTypeChildNode;
CharacterData implements NonDocumentTypeChildNode;

element = node . previousElementSibling

Returns the first preceding sibling that is an element, and null otherwise.

element = node . nextElementSibling

Returns the first following sibling that is an element, and null otherwise.

The previousElementSibling attribute must return the first preceding sibling that is an element, and null otherwise.

The nextElementSibling attribute must return the first following sibling that is an element, and null otherwise.

4.2.5. Interface ChildNode

[NoInterfaceObject,
 Exposed=Window]
interface ChildNode {
  [Unscopeable] void before((Node or DOMString)... nodes);
  [Unscopeable] void after((Node or DOMString)... nodes);
  [Unscopeable] void replaceWith((Node or DOMString)... nodes);
  [Unscopeable] void remove();
};
DocumentType implements ChildNode;
Element implements ChildNode;
CharacterData implements ChildNode;

node . before(nodes)

Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.

Throws a HierarchyRequestError if the constraints of the node tree are violated.

node . after(nodes)

Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.

Throws a HierarchyRequestError if the constraints of the node tree are violated.

node . replaceWith(nodes)

Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.

Throws a HierarchyRequestError if the constraints of the node tree are violated.

node . remove()

Removes node.

The before(nodes) method, when invoked, must run these steps:

1. Let parent be context object’s parent.

2. If parent is null, terminate these steps.

3. Let viablePreviousSibling be context object’s first preceding sibling not in nodes, and null otherwise.

4. Let node be the result of converting nodes into a node.

5. If viablePreviousSibling is non-null, set it to viablePreviousSibling’s next sibling, and to parent’s first child otherwise.

6. Pre-insert node into parent before viablePreviousSibling.

The after(nodes) method, when invoked, must run these steps:

1. Let parent be context object’s parent.

2. If parent is null, terminate these steps.

3. Let viableNextSibling be context object’s first following sibling not in nodes, and null otherwise.

4. Let node be the result of converting nodes into a node.

5. Pre-insert node into parent before viableNextSibling.

The replaceWith(nodes) method, when invoked, must run these steps:

1. Let parent be context object’s parent.

2. If parent is null, terminate these steps.

3. Let viableNextSibling be context object’s first following sibling not in nodes, and null otherwise.

4. Let node be the result of converting nodes into a node.

5. If context object’s parent is parent, replace the context object with node within parent.

   Context object could have been inserted into node.

6. Otherwise, pre-insert node into parent before viableNextSibling.

The remove() method, when invoked, must run these steps:

1. If context object’s parent is null, terminate these steps.

2. Remove the context object from context object’s parent.

4.2.6. Collections: Elements

class Elements extends Array {
  Element? query(DOMString relativeSelectors);
  Elements queryAll(DOMString relativeSelectors);
};

elements . query(relativeSelectors)

Returns the first element that is a descendant of elements that matches relativeSelectors.

elements . queryAll(relativeSelectors)

Returns all element descendants of elements that match relativeSelectors.

The query(relativeSelectors) method, when invoked, must return the first result of running match a relative selectors string relativeSelectors against the context object, and null if the result is an empty list.

The queryAll(relativeSelectors) method, when invoked, must return the result of running this.constructor with the result of running match a relative selectors string relativeSelectors against the context object.

4.2.7. Old-style collections: NodeList and HTMLCollection

A collection is an object that represents a lists of DOM nodes. A collection can be either live or static. Unless otherwise stated, a collection must be live.

If a collection is live, then the attributes and methods on that object must operate on the actual underlying data, not a snapshot of the data.

When a collection is created, a filter and a root are associated with it.

The collection then represents a view of the subtree rooted at the collection’s root, containing only nodes that match the given filter. The view is linear. In the absence of specific requirements to the contrary, the nodes within the collection must be sorted in tree order.

4.2.7.1. Interface NodeList

A NodeList object is a collection of nodes.

[Exposed=Window]
interface NodeList {
  getter Node? item(unsigned long index);
  readonly attribute unsigned long length;
  iterable<Node>;
};

collection . length

Returns the number of nodes in the collection.

element = collection . item(index)

element = collection[index]

Returns the node with index index from the collection. The nodes are sorted in tree order.

4.2.7.2. Interface HTMLCollection

[Exposed=Window]
interface HTMLCollection {
  readonly attribute unsigned long length;
  getter Element? item(unsigned long index);
  getter Element? namedItem(DOMString name);
};

An HTMLCollection object is a collection of elements.

Elements is the better solution for representing a collection of elements. HTMLCollection is an historical artifact we cannot rid the web of.

collection . length

Returns the number of elements in the collection.

element = collection . item(index)

element = collection[index]

Returns the element with index index from the collection. The elements are sorted in tree order.

element = collection . namedItem(name)

element = collection[name]

Returns the first element with ID or name name from the collection.

4.3. Mutation observers

Each unit of related similar-origin browsing contexts has a mutation observer compound microtask queued flag and an associated list of MutationObserver objects which is initially empty. [HTML]

To queue a mutation observer compound microtask, run these steps:

1. If mutation observer compound microtask queued flag is set, terminate these steps.
2. Set mutation observer compound microtask queued flag.
3. Queue a compound microtask to notify mutation observers.

To notify mutation observers, run these steps:

1. Unset mutation observer compound microtask queued flag.
2. Let notify list be a copy of unit of related similar-origin browsing contexts' list of MutationObserver objects.
3. For each MutationObserver object mo in notify list, execute a compound microtask subtask to run these steps: [HTML]
   1. Let queue be a copy of mo’s record queue.
   2. Empty mo’s record queue.
   3. Remove all transient registered observers whose observer is mo.
   4. If queue is non-empty, call mo’s callback with queue as first argument, and mo (itself) as second argument and callback this value. If this throws an exception, report the exception.

Each node has an associated list of registered observers.

A registered observer consists of an observer (a MutationObserver object) and options (a MutationObserverInit dictionary). A transient registered observer is a specific type of registered observer that has a source which is a registered observer.

Transient registered observers are used to track mutations within a given node’s descendants after node has been removed so they do not get lost when subtree is set to true on node’s parent.

4.3.1. Interface MutationObserver

[Constructor(MutationCallback callback)]
interface MutationObserver {
  void observe(Node target, MutationObserverInit options);
  void disconnect();
  sequence<MutationRecord> takeRecords();
};

callback MutationCallback = void (sequence<MutationRecord> mutations, MutationObserver observer);

dictionary MutationObserverInit {
  boolean childList = false;
  boolean attributes;
  boolean characterData;
  boolean subtree = false;
  boolean attributeOldValue;
  boolean characterDataOldValue;
  sequence<DOMString> attributeFilter;
};

A MutationObserver object can be used to observe mutations to the tree of nodes.

Each MutationObserver object has these associated concepts:

• A callback set on creation.
• A list of nodes on which it is a registered observer’s observer that is initially empty.
• A list of MutationRecord objects called the record queue that is initially empty.

observer = new MutationObserver(callback)

Constructs a MutationObserver object and sets its callback to callback. The callback is invoked with a list of MutationRecord objects as first argument and the constructed MutationObserver object as second argument. It is invoked after nodes registered with the observe() method, are mutated.

observer . observe(target, options)

Instructs the user agent to observe a given target (a node) and report any mutations based on the criteria given by options (an object).

The options argument allows for setting mutation observation options via object members. These are the object members that can be used:

childList

Set to true if mutations to target’s children are to be observed.

attributes

Set to true if mutations to target’s attributes are to be observed. Can be omitted if attributeOldValue and/or attributeFilter is specified.

characterData

Set to true if mutations to target’s data are to be observed. Can be omitted if characterDataOldValue is specified.

subtree

Set to true if mutations to not just target, but also target’s descendants are to be observed.

attributeOldValue

Set to true if attributes is true or omitted and target’s attribute value before the mutation needs to be recorded.

characterDataOldValue

Set to true if characterData is set to true or omitted and target’s data before the mutation needs to be recorded.

attributeFilter

Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted.

observer . disconnect()

Stops observer from observing any mutations. Until the observe() method is used again, observer’s callback will not be invoked.

observer . takeRecords()

Empties the record queue and returns what was in there.

The MutationObserver(callback) constructor must create a new MutationObserver object with callback set to callback, append it to the unit of related similar-origin browsing contexts' list of MutationObserver objects, and then return it.

The observe(target, options) method, when invoked, must run these steps:

1. If either options' attributeOldValue or attributeFilter is present and options' attributes is omitted, set options' attributes to true.
2. If options' characterDataOldValue is present and options' characterData is omitted, set options' characterData to true.
3. If none of options' childList attributes, and characterData is true, throw a TypeError.
4. If options' attributeOldValue is true and options' attributes is false, throw a TypeError.
5. If options' attributeFilter is present and options' attributes is false, throw a TypeError.
6. If options' characterDataOldValue is true and options' characterData is false, throw a TypeError.
7. For each registered observer registered in target’s list of registered observers whose observer is the context object:
   1. Remove all transient registered observers whose source is registered.
   2. Replace registered’s options with options.
8. Otherwise, add a new registered observer to target’s list of registered observers with the context object as the observer and options as the options, and add target to context object’s list of nodes on which it is registered.

The disconnect() method must, for each node node in the context object’s list of nodes, remove any registered observer on node for which the context object is the observer, and also empty context object’s record queue.

The takeRecords() method must return a copy of the record queue and then empty the record queue.

4.3.2. Queuing a mutation record

To queue a mutation record of type for target with one or more of (depends on type) name name, namespace namespace, oldValue oldValue, addedNodes addedNodes, removedNodes removedNodes, previousSibling previousSibling, and nextSibling nextSibling, run these steps:

1. Let interested observers be an initially empty set of MutationObserver objects optionally paired with a string.
2. Let nodes be the inclusive ancestors of target.
3. Then, for each node in nodes, and then for each registered observer (with registered observer’s options as options) in node’s list of registered observers:
   1. If node is not target and options' subtree is false, continue.
   2. If type is "attributes" and options' attributes is not true, continue.
   3. If type is "attributes", options' attributeFilter is present, and either options' attributeFilter does not contain name or namespace is non-null, continue.
   4. If type is "characterData" and options' characterData is not true, continue.
   5. If type is "childList" and options' childList is false, continue.
   6. If registered observer’s observer is not in interested observers, append registered observer’s observer to interested observers.
   7. If either type is "attributes" and options' attributeOldValue is true, or type is "characterData" and options' characterDataOldValue is true, set the paired string of registered observer’s observer in interested observers to oldValue.
4. Then, for each observer in interested observers:
   1. Let record be a new MutationRecord object with its type set to type and target set to target.
   2. If name and namespace are given, set record’s attributeName to name, and record’s attributeNamespace to namespace.
   3. If addedNodes is given, set record’s addedNodes to addedNodes.
   4. If removedNodes is given, set record’s removedNodes to removedNodes,
   5. If previousSibling is given, set record’s previousSibling to previousSibling.
   6. If nextSibling is given, set record’s nextSibling to nextSibling.
   7. If observer has a paired string, set record’s oldValue to observer’s paired string.
   8. Append record to observer’s record queue.
5. Queue a mutation observer compound microtask.

4.3.3. Interface MutationRecord

[Exposed=Window]
interface MutationRecord {
  readonly attribute DOMString type;
  readonly attribute Node target;
  [SameObject] readonly attribute NodeList addedNodes;
  [SameObject] readonly attribute NodeList removedNodes;
  readonly attribute Node? previousSibling;
  readonly attribute Node? nextSibling;
  readonly attribute DOMString? attributeName;
  readonly attribute DOMString? attributeNamespace;
  readonly attribute DOMString? oldValue;
};

record . type

Returns "attributes" if it was an attribute mutation. "characterData" if it was a mutation to a CharacterData node. And "childList" if it was a mutation to the tree of nodes.

record . target

Returns the node the mutation affected, depending on the type. For "attributes", it is the element whose attribute changed. For "characterData", it is the CharacterData node. For "childList", it is the node whose children changed.

record . addedNodes

record . removedNodes

Return the nodes added and removed respectively.

record . previousSibling

record . nextSibling

Return the previous and next sibling respectively of the added or removed nodes, and null otherwise.

record . attributeName

Returns the local name of the changed attribute, and null otherwise.

record . attributeNamespace

Returns the namespace of the changed attribute, and null otherwise.

record . oldValue

The return value depends on type. For "attributes", it is the value of the changed attribute before the change. For "characterData", it is the data of the changed node before the change. For "childList", it is null.

The type and target attributes must return the values they were initialized to.

The addedNodes and removedNodes attributes must return the values they were initialized to. Unless stated otherwise, when a MutationRecord object is created, they must both be initialized to an empty NodeList.

The previousSibling, nextSibling, attributeName, attributeNamespace, and oldValue attributes must return the values they were initialized to. Unless stated otherwise, when a MutationRecord object is created, they must be initialized to null.

4.3.4. Garbage collection

Nodes have a strong reference to registered observers in their list of registered observers.

Registered observers in a node’s list of registered observers have a weak reference to the node.

4.4. Interface Node

[Exposed=Window]
interface Node : EventTarget {
  const unsigned short ELEMENT_NODE = 1;
  const unsigned short ATTRIBUTE_NODE = 2; // historical
  const unsigned short TEXT_NODE = 3;
  const unsigned short CDATA_SECTION_NODE = 4; // historical
  const unsigned short ENTITY_REFERENCE_NODE = 5; // historical
  const unsigned short ENTITY_NODE = 6; // historical
  const unsigned short PROCESSING_INSTRUCTION_NODE = 7;
  const unsigned short COMMENT_NODE = 8;
  const unsigned short DOCUMENT_NODE = 9;
  const unsigned short DOCUMENT_TYPE_NODE = 10;
  const unsigned short DOCUMENT_FRAGMENT_NODE = 11;
  const unsigned short NOTATION_NODE = 12; // historical
  readonly attribute unsigned short nodeType;
  readonly attribute DOMString nodeName;

  readonly attribute DOMString? baseURI;

  readonly attribute Document? ownerDocument;
  readonly attribute Node? parentNode;
  readonly attribute Element? parentElement;
  boolean hasChildNodes();
  [SameObject] readonly attribute NodeList childNodes;
  readonly attribute Node? firstChild;
  readonly attribute Node? lastChild;
  readonly attribute Node? previousSibling;
  readonly attribute Node? nextSibling;

           attribute DOMString? nodeValue;
           attribute DOMString? textContent;
  void normalize();

  [NewObject] Node cloneNode(optional boolean deep = false);
  boolean isEqualNode(Node? otherNode);

  const unsigned short DOCUMENT_POSITION_DISCONNECTED = 0x01;
  const unsigned short DOCUMENT_POSITION_PRECEDING = 0x02;
  const unsigned short DOCUMENT_POSITION_FOLLOWING = 0x04;
  const unsigned short DOCUMENT_POSITION_CONTAINS = 0x08;
  const unsigned short DOCUMENT_POSITION_CONTAINED_BY = 0x10;
  const unsigned short DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
  unsigned short compareDocumentPosition(Node other);
  boolean contains(Node? other);

  DOMString? lookupPrefix(DOMString? namespace);
  DOMString? lookupNamespaceURI(DOMString? prefix);
  boolean isDefaultNamespace(DOMString? namespace);

  Node insertBefore(Node node, Node? child);
  Node appendChild(Node node);
  Node replaceChild(Node node, Node child);
  Node removeChild(Node child);
};

Node is an abstract interface and does not exist as node. It is used by all nodes (Document, DocumentFragment, DocumentType, Element, Text, ProcessingInstruction, and Comment).

Each node has an associated node document, set upon creation, that is a document.

A node’s node document can be changed by the adopt algorithm.

node . nodeType

Returns the type of node, represented by a number from the following list:

Node . ELEMENT_NODE (1)

node is an element.

Node . TEXT_NODE (3)

node is a Text node.

Node . PROCESSING_INSTRUCTION_NODE (7)

node is a ProcessingInstruction node.

Node . COMMENT_NODE (8)

node is a Comment node.

Node . DOCUMENT_NODE (9)

node is a document.

Node . DOCUMENT_TYPE_NODE (10)

node is a doctype.

Node . DOCUMENT_FRAGMENT_NODE (11)

node is a DocumentFragment node.

node . nodeName

Returns a string appropriate for the type of node, as follows:

Element

Its tagName attribute value.

Text

"#text".

ProcessingInstruction

Its target.

Comment

"#comment".

Document

"#document".

DocumentType

Its name.

DocumentFragment

"#document-fragment".

The nodeType attribute’s getter, when invoked, must return the first matching statement, switching on the context object:

Element

ELEMENT_NODE (1)

Text

TEXT_NODE (3);

ProcessingInstruction

PROCESSING_INSTRUCTION_NODE (7);

Comment

COMMENT_NODE (8);

Document

DOCUMENT_NODE (9);

DocumentType

DOCUMENT_TYPE_NODE (10);

DocumentFragment

DOCUMENT_FRAGMENT_NODE (11).

The nodeName attribute’s getter, when invoked, must return the first matching statement, switching on the context object:

Element

Its tagName attribute value.

Text

"#text".

ProcessingInstruction

Its target.

Comment

"#comment".

Document

"#document".

DocumentType

Its name.

DocumentFragment

"#document-fragment".

node . baseURI

Returns node’s node document’s base URL.

The baseURI attribute’s getter must return node document’s base URL.

node . ownerDocument

Returns the node document. Returns null for documents.

node . parentNode

Returns the parent.

node . parentElement

Returns the parent element.

node . hasChildNodes()

Returns whether node has children.

node . childNodes

Returns the children.

node . firstChild

Returns the first child.

node . lastChild

Returns the last child.

node . previousSibling

Returns the previous sibling.

node . nextSibling

Returns the next sibling.

The nodeValue attribute must return the following, depending on the context object:

Text

Comment

ProcessingInstruction

The context object’s data.

Any other node

Null.

The nodeValue attribute must, on setting, if the new value is null, act as if it was the empty string instead, and then do as described below, depending on the context object:

Text

Comment

ProcessingInstruction

Replace data with node context object, offset 0, count length attribute value, and data new value.

Any other node

Do nothing.

The textContent attribute must return the following, depending on the context object:

DocumentFragment

Element

The concatenation of data of all the Text node descendants of the context object, in tree order.

Text

ProcessingInstruction

Comment

The context object’s data.

Any other node

Null.

The textContent attribute must, on setting, if the new value is null, act as if it was the empty string instead, and then do as described below, depending on the context object:

DocumentFragment

Element

1. Let node be null.
2. If new value is not the empty string, set node to a new Text node whose data is new value.
3. Replace all with node within the context object.

Text

ProcessingInstruction

Comment

Replace data with node context object, offset 0, count length attribute value, and data new value.

Any other node

Do nothing.

node . normalize()()

Removes empty Text nodes and concatenates the data of remaining contiguous Text nodes into the first of their nodes.

The normalize() method must run these steps:

For each Text node descendant of the context object:

1. Let node be the Text node descendant.
2. Let length be node’s length attribute value.
3. If length is zero, remove node and continue with the next Text node, if any.
4. Let data be the concatenation of the data of node’s contiguous Text nodes (excluding itself), in tree order.
5. Replace data with node node, offset length, count 0, and data data.
6. Let current node be node’s next sibling.
7. While current node is a Text node:
   1. For each range whose start node is current node, add length to its start offset and set its start node to node.
   2. For each range whose end node is current node, add length to its end offset and set its end node to node.
   3. For each range whose start node is current node’s parent and start offset is current node’s index, set its start node to node and its start offset to length.
   4. For each range whose end node is current node’s parent and end offset is current node’s index, set its end node to node and its end offset to length.
   5. Add current node’s length attribute value to length.
   6. Set current node to its next sibling.
8. Remove node’s contiguous Text nodes (excluding itself), in tree order.

node . cloneNode([deep = false])

Returns a copy of node. If deep is true, the copy also includes the node’s descendants.

node . isEqualNode(otherNode)

Returns whether node and otherNode have the same properties.

node . compareDocumentPosition(other)

Returns a bitmask indicating the position of other relative to node. These are the bits that can be set:

Node . DOCUMENT_POSITION_DISCONNECTED (1)

Set when node and other are not in the same tree.

Node . DOCUMENT_POSITION_PRECEDING (2)

Set when other is preceding node.

Node . DOCUMENT_POSITION_FOLLOWING (4)

Set when other is following node.

Node . DOCUMENT_POSITION_CONTAINS (8)

Set when other is an ancestor of node.

Node . DOCUMENT_POSITION_CONTAINED_BY (16, 10 in hexadecimal)

Set when other is a descendant of node.

node . contains(other)

Returns true if other is an inclusive descendant of node, and false otherwise.

These are the constants compareDocumentPosition() returns as mask:

• DOCUMENT_POSITION_DISCONNECTED (1);
• DOCUMENT_POSITION_PRECEDING (2);
• DOCUMENT_POSITION_FOLLOWING (4);
• DOCUMENT_POSITION_CONTAINS (8);
• DOCUMENT_POSITION_CONTAINED_BY (16, 10 in hexadecimal);
• DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC (32, 20 in hexadecimal).

The compareDocumentPosition(other) method must run these steps:

1. Let reference be the context object.
2. If other and reference are the same object, return zero.
3. If other and reference are not in the same tree, return the result of adding DOCUMENT_POSITION_DISCONNECTED, DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, and either DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING, with the constraint that this is to be consistent, together.

   Whether to return DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING is typically implemented via pointer comparison. In JavaScript implementations Math.random() can be used.

4. If other is an ancestor of reference, return the result of adding DOCUMENT_POSITION_CONTAINS to DOCUMENT_POSITION_PRECEDING.
5. If other is a descendant of reference, return the result of adding DOCUMENT_POSITION_CONTAINED_BY to DOCUMENT_POSITION_FOLLOWING.
6. If other is preceding reference return DOCUMENT_POSITION_PRECEDING.
7. Return DOCUMENT_POSITION_FOLLOWING.

The contains(other) method must return true if other is an inclusive descendant of the context object, and false otherwise (including when other is null).

To locate a namespace prefix for an element using namespace run these steps:

1. If element’s namespace is namespace and its namespace prefix is not null, return its namespace prefix.
2. If element has an attribute whose namespace prefix is "xmlns" and value is namespace, then return element’s first such attribute’s local name.
3. If element’s parent element is not null, return the result of running locate a namespace prefix on that element using namespace. Otherwise, return null.

To locate a namespace for a node using prefix depends on node:

Element

1. If its namespace is not null and its namespace prefix is prefix, return namespace.
2. If it has an attribute whose namespace is the XMLNS namespace, namespace prefix is "xmlns" and local name is prefix, or if prefix is null and it has an attribute whose namespace is the XMLNS namespace, namespace prefix is null and local name is "xmlns":
   1. Let value be its value if it is not the empty string, and null otherwise.
   2. Return value.
3. If its parent element is null, return null.
4. Return the result of running locate a namespace on its parent element using prefix.

Document

1. If its document element is null, return null.
2. Return the result of running locate a namespace on its document element using prefix.

DocumentType

DocumentFragment

Return null.

Any other node

1. If its parent element is null, return null.
2. Return the result of running locate a namespace on its parent element using prefix.

The lookupPrefix(namespace) method must run these steps:

1. If namespace is null or the empty string, return null.
2. Otherwise it depends on the context object:

   Element

   Return the result of locating a namespace prefix for the node using namespace.

   Document

   Return the result of locating a namespace prefix for its document element, if that is not null, and null otherwise.

   DocumentType

   DocumentFragment

   Return null.

   Any other node

   Return the result of locating a namespace prefix for its parent element, or if that is null, null.

The lookupNamespaceURI(prefix) method must run these steps:

1. If prefix is the empty string, set it to null.
2. Return the result of running locate a namespace for the context object using prefix.

The isDefaultNamespace(namespace) method must run these steps:

1. If namespace is the empty string, set it to null.
2. Let defaultNamespace be the result of running locate a namespace for the context object using null.
3. Return true if defaultNamespace is the same as namespace, and false otherwise.

The insertBefore(node, child) method must return the result of pre-inserting node into the context object before child.

The appendChild(node) method must return the result of appending node to the context object.

The replaceChild(node, child) method must return the result of replacing child with node within the context object.

The removeChild(child) method must return the result of pre-removing child from the context object.

The list of elements with local name localName for a node root is the HTMLCollection returned by the following algorithm:

1. If localName is "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches only elements.
2. Otherwise, if root’s node document is an HTML document, return a HTMLCollection rooted at root, whose filter matches the following descendant elements:
   • Whose namespace is the HTML namespace and whose local name is localName converted to ASCII lowercase.
   • Whose namespace is not the HTML namespace and whose local name is localName.
3. Otherwise, return a HTMLCollection rooted at root, whose filter matches descendant elements whose local name is localName.

When invoked with the same argument, the same HTMLCollection object may be returned as returned by an earlier call.

The list of elements with namespace namespace and local name localName for a node root is the HTMLCollection returned by the following algorithm:

1. If namespace is the empty string, set it to null.
2. If both namespace and localName are "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches descendant elements.
3. Otherwise, if namespace is "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches descendant elements whose local name is localName.
4. Otherwise, if localName is "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches descendant elements whose namespace is namespace.
5. Otherwise, return a HTMLCollection rooted at root, whose filter matches descendant elements whose namespace is namespace and local name is localName.

When invoked with the same arguments, the same HTMLCollection object may be returned as returned by an earlier call.

The list of elements with class names classNames for a node root is the HTMLCollection returned by the following algorithm:

1. Let classes be the result of running the ordered set parser on classNames.
2. If classes is the empty set, return an empty HTMLCollection.
3. Return a HTMLCollection rooted at root, whose filter matches descendant elements that have all their classes in classes.

   The comparisons for the classes must be done in an ASCII case-insensitive manner if root’s node document’s mode is "quirks", and in a case-sensitive manner otherwise.

When invoked with the same argument, the same HTMLCollection object may be returned as returned by an earlier call.

4.5. Interface Document

[Constructor,
 Exposed=Window]
interface Document : Node {
  [SameObject] readonly attribute DOMImplementation implementation;
  readonly attribute DOMString URL;
  readonly attribute DOMString documentURI;
  readonly attribute DOMString origin;
  readonly attribute DOMString compatMode;
  readonly attribute DOMString characterSet;
  readonly attribute DOMString inputEncoding; // legacy alias of .characterSet
  readonly attribute DOMString contentType;

  readonly attribute DocumentType? doctype;
  readonly attribute Element? documentElement;
  HTMLCollection getElementsByTagName(DOMString localName);
  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  HTMLCollection getElementsByClassName(DOMString classNames);

  [NewObject] Element createElement(DOMString localName);
  [NewObject] Element createElementNS(DOMString? namespace, DOMString qualifiedName);
  [NewObject] DocumentFragment createDocumentFragment();
  [NewObject] Text createTextNode(DOMString data);
  [NewObject] Comment createComment(DOMString data);
  [NewObject] ProcessingInstruction createProcessingInstruction(DOMString target, DOMString data);

  [NewObject] Node importNode(Node node, optional boolean deep = false);
  Node adoptNode(Node node);

  [NewObject] Attr createAttribute(DOMString localName);
  [NewObject] Attr createAttributeNS(DOMString? namespace, DOMString name);

  [NewObject] Event createEvent(DOMString interface);

  [NewObject] Range createRange();

  // NodeFilter.SHOW_ALL = 0xFFFFFFFF
  [NewObject] NodeIterator createNodeIterator(Node root, optional unsigned long whatToShow = 0xFFFFFFFF, optional NodeFilter? filter = null);
  [NewObject] TreeWalker createTreeWalker(Node root, optional unsigned long whatToShow = 0xFFFFFFFF, optional NodeFilter? filter = null);
};

[Exposed=Window]
interface XMLDocument : Document {};

Document nodes are simply known as documents.

Each document has an associated base URL (a URL), encoding (an encoding), content type (a string), URL (a URL), type ("xml" or "html"), and mode ("no-quirks", "quirks", or "limited-quirks"). [ENCODING] [URL]

Unless stated otherwise, a document’s base URL is "about:blank", encoding is the utf-8 encoding, content type is "application/xml", URL is "about:blank", type is "xml", and its mode is "no-quirks".

Unless stated otherwise, a document’s origin is a globally unique identifier and its effective script origin is an alias of that origin. [HTML]

A document is said to be an XML document if its type is "xml", and an HTML document otherwise. Whether a document is an HTML document or an XML document affects the behavior of certain APIs.

A document is said to be in no-quirks mode if its mode is "no-quirks", quirks mode if its mode is "quirks", and limited-quirks mode if its mode is "limited-quirks".

document = new Document()

Returns a new document.

document . implementation

Returns document’s DOMImplementation object.

document . URL

document . documentURI

Returns document’s URL.

document . origin

Returns document’s origin.

document . compatMode

Returns the string "BackCompat" if document’s mode is "quirks", and "CSS1Compat" otherwise.

document . characterSet

Returns document’s encoding.

document . contentType

Returns document’s content type.

The Document() constructor must return a new document whose origin is an alias to the origin of the global object’s associated document, and effective script origin is an alias to the effective script origin of the global object’s associated document. [HTML]

Unlike createDocument() this constructor does not return an XMLDocument object, but a document (Document object).

The implementation attribute must return the DOMImplementation object that is associated with the document.

The URL and documentURI attributes must return the URL.

The origin attribute must return the Unicode serialization of context object’s origin.

The compatMode attribute’s getter must return "BackCompat" if context object’s mode is "quirks", and "CSS1Compat" otherwise.

The characterSet attribute’s getter and inputEncoding attribute’s getter must run these steps:

1. Let name be encoding’s name.
2. If name is in the first column in the table below, set name to the value of the second column on the same row:

   Name	Compatibility name
   utf-8	"UTF-8"
   ibm866	"IBM866"
   iso-8859-2	"ISO-8859-2"
   iso-8859-3	"ISO-8859-3"
   iso-8859-4	"ISO-8859-4"
   iso-8859-5	"ISO-8859-5"
   iso-8859-6	"ISO-8859-6"
   iso-8859-7	"ISO-8859-7"
   iso-8859-8	"ISO-8859-8"
   iso-8859-8-i	"ISO-8859-8-I"
   iso-8859-10	"ISO-8859-10"
   iso-8859-13	"ISO-8859-13"
   iso-8859-14	"ISO-8859-14"
   iso-8859-15	"ISO-8859-15"
   iso-8859-16	"ISO-8859-16"
   koi8-r	"KOI8-R"
   koi8-u	"KOI8-U"
   gbk	"GBK"
   big5	"Big5"
   euc-jp	"EUC-JP"
   iso-2022-jp	"ISO-2022-JP"
   shift_jis	"Shift_JIS"
   euc-kr	"EUC-KR"
   utf-16be	"UTF-16BE"
   utf-16le	"UTF-16LE"

3. Return name.

The contentType attribute must return the content type.

document . doctype

Returns the doctype or null if there is none.

document . documentElement

Returns the document element.

collection = document . getElementsByTagName(localName)

If localName is "*" returns a HTMLCollection of all descendant elements.

Otherwise, returns a HTMLCollection of all descendant elements whose local name is localName. (Matches case-insensitively against elements in the HTML namespace within an HTML document.)

collection = document . getElementsByTagNameNS(namespace, localName)

If namespace and localName are "*" returns a HTMLCollection of all descendant elements.

If only namespace is "*" returns a HTMLCollection of all descendant elements whose local name is localName.

If only localName is "*" returns a HTMLCollection of all descendant elements whose namespace is namespace.

Otherwise, returns a HTMLCollection of all descendant elements whose namespace is namespace and local name is localName.

collection = document . getElementsByClassName(classNames)

collection = element . getElementsByClassName(classNames)

Returns a HTMLCollection of the elements in the object on which the method was invoked (a document or an element) that have all the classes given by classNames. The classNames argument is interpreted as a space-separated list of classes.

The doctype attribute must return the child of the document that is a doctype, and null otherwise.

The documentElement attribute must return the document element.

The getElementsByTagName(localName) method must return the list of elements with local name localName for the context object.

Thus, in an HTML document, document.getElementsByTagName("FOO") will match <FOO> elements that are not in the HTML namespace, and <foo> elements that are in the HTML namespace, but not <FOO> elements that are in the HTML namespace.

The getElementsByTagNameNS(namespace, localName) method must return the list of elements with namespace namespace and local name localName for the context object.

The getElementsByClassName(classNames) method must return the list of elements with class names classNames for the context object.

<div id="example">
  <p id="p1" class="aaa bbb"/>
  <p id="p2" class="aaa ccc"/>
  <p id="p3" class="bbb ccc"/>
</div>

element = document . createElement(localName)

Returns an element in the HTML namespace with localName as local name. (In an HTML document localName is lowercased.)

If localName does not match the Name production an InvalidCharacterError exception will be thrown.

element = document . createElementNS(namespace, qualifiedName)

Returns an element with namespace namespace. Its namespace prefix will be everything before ":" (U+003E) in qualifiedName or null. Its local name will be everything after ":" (U+003E) in qualifiedName or qualifiedName.

If localName does not match the Name production an InvalidCharacterError exception will be thrown.

If one of the following conditions is true a NamespaceError exception will be thrown:

• localName does not match the QName production.
• Namespace prefix is not null and namespace is the empty string.
• Namespace prefix is "xml" and namespace is not the XML namespace.
• qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
• namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".

documentFragment = document . createDocumentFragment()

Returns a DocumentFragment node.

text = document . createTextNode(data)

Returns a Text node whose data is data.

comment = document . createComment(data)

Returns a Comment node whose data is data.

processingInstruction = document . createProcessingInstruction(target, data)

Returns a ProcessingInstruction node whose target is target and data is data. If target does not match the Name production an InvalidCharacterError exception will be thrown. If data contains "?>" an InvalidCharacterError exception will be thrown.

The element interface for any name and namespace is Element, unless stated otherwise.

The HTML Standard will e.g. define that for html and the HTML namespace, the HTMLHtmlElement interface is used. [HTML]

The createElement(localName) method must run the these steps:

1. If localName does not match the Name production, throw an InvalidCharacterError exception.
2. If the context object is an HTML document, let localName be converted to ASCII lowercase.
3. Let interface be the element interface for localName and the HTML namespace.
4. Return a new element that implements interface, with no attributes, namespace set to the HTML namespace, local name set to localName, and node document set to the context object.

The createElementNS(namespace, qualifiedName) method must run these steps:

1. Let namespace, prefix, localName, and qualifiedName be the result of passing namespace and qualifiedName to validate and extract. Rethrow any exceptions.
2. Let interface be the element interface for localName and namespace.
3. Return a new element that implements interface, with no attributes, namespace set to namespace, namespace prefix set to prefix, local name set to localName, and node document set to the context object.

The createDocumentFragment() method must return a new DocumentFragment node with its node document set to the context object.

The createTextNode(data) method must return a new Text node with its data set to data and node document set to the context object.

No check is performed that data consists of characters that match the Char production.

The createComment(data) method must return a new Comment node with its data set to data and node document set to the context object.

No check is performed that data consists of characters that match the Char production or that it contains two adjacent hyphens or ends with a hyphen.

The createProcessingInstruction(target, data) method must run these steps:

1. If target does not match the Name production, throw an InvalidCharacterError exception.
2. If data contains the string "?>", throw an InvalidCharacterError exception.
3. Return a new ProcessingInstruction node, with target set to target, data set to data, and node document set to the context object.

No check is performed that target contains "xml" or ":", or that data contains characters that match the Char production.

clone = document . importNode(node [, deep = false])

Returns a copy of node. If deep is true, the copy also includes the node’s descendants.

If node is a document or a shadow root, throws a NotSupportedError exception.

node = document . adoptNode(node)

Moves node from another document and returns it.

If node is a document, throws a NotSupportedError or, if node is a shadow root, throws a HierarchyRequestError exception.

The importNode(node, deep) method must run these steps:

1. If node is a document or shadow root, throw a NotSupportedError exception.
2. Return a clone of node, with context object and the clone children flag set if deep is true.

Specifications may define adopting steps for all or some nodes. The algorithm is passed node and oldDocument, as indicated in the adopt algorithm.

To adopt a node into a document, run these steps:

1. Let oldDocument be node’s node document.
2. If node’s parent is not null, remove node from its parent.
3. Set node’s inclusive descendants’s node document to document.
4. Run any adopting steps defined for node in other applicable specifications and pass node and oldDocument as parameters.

The adoptNode(node) method must run these steps:

1. If node is a document, throw a NotSupportedError exception.
2. If node is a shadow root, throw a HierarchyRequestError exception.
3. Adopt node into the context object.
4. Return node.

The createAttribute(localName) method, when invoked, must run these steps:

1. If localName does not match the Name production in XML, throw an InvalidCharacterError exception.
2. Return a new attribute whose local name is localName.

This method does not have its input converted to ASCII lowercase.

The createAttributeNS(namespace, name) method, when invoked, must run these steps:

1. Let namespace, prefix, localName, and name be the result of passing namespace and name to validate and extract. Rethrow any exceptions.
2. Return a new attribute whose namespace is namespace, namespace prefix is prefix, local name is localName, and name is name.

The createEvent(interface) method must run these steps:

1. Let constructor be null.
2. If interface is an ASCII case-insensitive match for any of the strings in the first column in the following table, set constructor to the interface in the second column on the same row as the matching string:

   String	Interface	Notes
   "customevent"	CustomEvent
   "event	Event
   "events"
   "htmlevents"
   "keyboardevent"	KeyboardEvent	[UIEVENTS]
   "keyevents"
   "messageevent"	MessageEvent	[HTML]
   "mouseevent"	MouseEvent	[UIEVENTS]
   "mouseevents"
   "touchevent"	TouchEvent
   "uievent"	UIEvent	[UIEVENTS]
   "uievents"

3. If constructor is null, throw a NotSupportedError.
4. Let event be the result of invoking the initial value of constructor with the empty string as argument.
5. Unset event’s initialized flag.
6. Return event.

Event constructors ought to be used instead.

The createRange() method must return a new range with (context object, 0) as its start and end.

The Range() constructor ought to be used instead.

The createNodeIterator(root, whatToShow, filter) method must run these steps:

1. Create a NodeIterator object.
2. Set root to root and initialize the referenceNode attribute to root.
3. Initialize the pointerBeforeReferenceNode attribute to true.
4. Set whatToShow to whatToShow.
5. Set filter to filter.
6. Return the newly created NodeIterator object.

The createTreeWalker(root, whatToShow, filter) method must run these steps:

1. Create a TreeWalker object.
2. Set root to root and initialize the currentNode attribute to root.
3. Set whatToShow to whatToShow.
4. Set filter to filter.
5. Return the newly created TreeWalker object.

4.5.1. Interface DOMImplementation

User agents must create a DOMImplementation object whenever a document is created and associate it with that document.

[Exposed=Window]
interface DOMImplementation {
  [NewObject] DocumentType createDocumentType(DOMString qualifiedName, DOMString publicId, DOMString systemId);
  [NewObject] XMLDocument createDocument(DOMString? namespace, [TreatNullAs=EmptyString] DOMString qualifiedName, optional DocumentType? doctype = null);
  [NewObject] Document createHTMLDocument(optional DOMString title);

  boolean hasFeature(); // useless; always returns true
};

doctype = document . implementation . createDocumentType(qualifiedName, publicId, systemId)

Returns a doctype, with the given qualifiedName, publicId, and systemId. If qualifiedName does not match the Name production, an InvalidCharacterError exception is thrown, and if it does not match the QName production, a NamespaceError exception is thrown.

doc = document . implementation . createDocument(namespace, qualifiedName [, doctype = null])

Returns an XMLDocument, with a document element whose local name is qualifiedName and whose namespace is namespace (unless qualifiedName is the empty string), and with doctype, if it is given, as its doctype.

This method throws the same exceptions as the createElementNS() method, when invoked with the same arguments.

doc = document . implementation . createHTMLDocument([title])

Returns a document, with a basic tree already constructed including a title element, unless the title argument is omitted.

4.6. Interface DocumentFragment

[Constructor,
 Exposed=Window]
interface DocumentFragment : Node {
};

A DocumentFragment node can have an associated element named host.

An object A is a host-including inclusive ancestor of an object B, if either A is an inclusive ancestor of B, or if B’s root has an associated host and A is a host-including inclusive ancestor of B’s root’s host.

The DocumentFragment node’s host concept is useful for HTML’s template element and the ShadowRoot object and impacts the pre-insert and replace algorithms.

tree = new DocumentFragment()

Returns a new DocumentFragment node.

The DocumentFragment() constructor must return a new DocumentFragment node whose node document is the global object’s associated document.

4.7. Interface DocumentType

[Exposed=Window]
interface DocumentType : Node {
  readonly attribute DOMString name;
  readonly attribute DOMString publicId;
  readonly attribute DOMString systemId;
};

DocumentType nodes are simply known as doctypes.

Doctypes have an associated name, public ID, and system ID.

When a doctype is created, its name is always given. Unless explicitly given when a doctype is created, its public ID and system ID are the empty string.

The name attribute must return the name.

The publicId attribute must return the public ID.

The systemId attribute must return the system ID.

4.8. Interface Element

[Exposed=Window]
interface Element : Node {
  readonly attribute DOMString? namespaceURI;
  readonly attribute DOMString? prefix;
  readonly attribute DOMString localName;
  readonly attribute DOMString tagName;

           attribute DOMString id;
           attribute DOMString className;
  [SameObject] readonly attribute DOMTokenList classList;

  boolean hasAttributes();
  [SameObject] readonly attribute NamedNodeMap attributes;
  DOMString? getAttribute(DOMString name);
  DOMString? getAttributeNS(DOMString? namespace, DOMString localName);
  void setAttribute(DOMString name, DOMString value);
  void setAttributeNS(DOMString? namespace, DOMString name, DOMString value);
  void removeAttribute(DOMString name);
  void removeAttributeNS(DOMString? namespace, DOMString localName);
  boolean hasAttribute(DOMString name);
  boolean hasAttributeNS(DOMString? namespace, DOMString localName);

  Attr? getAttributeNode(DOMString name);
  Attr? getAttributeNodeNS(DOMString? namespace, DOMString localName);
  Attr? setAttributeNode(Attr attr);
  Attr? setAttributeNodeNS(Attr attr);
  Attr removeAttributeNode(Attr attr);

  Element? closest(DOMString selectors);
  boolean matches(DOMString selectors);

  HTMLCollection getElementsByTagName(DOMString localName);
  HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  HTMLCollection getElementsByClassName(DOMString classNames);
};

Element nodes are simply known as elements.

Elements have an associated namespace, namespace prefix, and local name. When an element is created, its local name is always given. Unless explicitly given when an element is created, its namespace and namespace prefix are null.

Elements also have an ordered attribute list exposed through a NamedNodeMap. Unless explicitly given when an element is created, its attribute list is empty. An element has an attribute A if A is in its attribute list.

This specification uses and applicable specifications can use the hooks an attribute is set, an attribute is changed, an attribute is added, and an attribute is removed, for further processing of the attribute’s value.

To change an attribute attribute from an element element to value, run these steps:

1. Queue a mutation record of "attributes" for element with name attribute’s local name, namespace attribute’s namespace, and oldValue attribute’s value.
2. Set attribute’s value to value.
3. An attribute is set and an attribute is changed.

To append an attribute attribute to an element element, run these steps:

1. Queue a mutation record of "attributes" for element with name attribute’s local name, namespace attribute’s namespace, and oldValue null.
2. Append the attribute to the element’s attribute list.
3. Set attribute’s element to element.
4. An attribute is set and an attribute is added.

To remove an attribute attribute from an element element, run these steps:

1. Queue a mutation record of "attributes" for element with name attribute’s local name, namespace attribute’s namespace, and oldValue attribute’s value.
2. Remove attribute from the element’s attribute list.
3. Set attribute’s element to null.
4. An attribute is removed.

To get an attribute by name given a name and element element, run these steps:

1. If element is in the HTML namespace and its node document is an HTML document, let name be converted to ASCII lowercase.
2. Return the first attribute in element’s attribute list whose name is name, and null otherwise.

To get an attribute by namespace and local name given a namespace, localName, and element element, run these steps:

1. If namespace is the empty string, set it to null.
2. Return the attribute in element’s attribute list whose namespace is namespace and local name is localName, if any, and null otherwise.

To set an attribute given an attribute attr, element element, and an optional namespace and local name flag, run these steps:

1. If attr’s element is neither null nor element, throw an InUseAttributeError.
2. Let oldAttr be null.
3. If the namespace and local name flag is set, set oldAttr to the result of getting an attribute given attr’s namespace, attr’s local name, and element.
4. Otherwise, set oldAttr to the result of getting an attribute given attr’s name and element.

   The result of this is that an attribute on an element with an HTML namespace in an HTML document can be replaced with another attribute whose name is only an ASCII case-insensitive match. We do not care, because nobody ought to be working with attributes in this way.

5. If oldAttr is attr, return attr.
6. If oldAttr is non-null, remove it from element.
7. Append attr to element.
8. Return oldAttr.

To set an attribute value for an element element using a localName and value, and an optional name, prefix, and namespace, run these steps:

1. If name is not given, set it to localName.
2. If prefix is not given, set it to null.
3. If namespace is not given, set it to null.
4. Let attribute be the result of getting an attribute given namespace, localName, and element.
5. If attribute is null, create an attribute whose namespace is namespace, namespace prefix is prefix, local name is localName, name is name, and value is value, and then append this attribute to element and terminate these steps.
6. Change attribute from element to value.

To remove an attribute by name given a name and element element, run these steps:

1. Let attr be the result of getting an attribute given name and element.
2. If attr is non-null, remove it from element.
3. Return attr.

To remove an attribute by namespace and local name given a namespace, localName, and element element, run these steps:

1. Let attr be the result of getting an attribute given namespace, localName, and element.
2. If attr is non-null, remove it from element.
3. Return attr.

An element can have an associated unique identifier (ID)

Historically elements could have multiple identifiers e.g. by using the HTML id attribute and a DTD. This specification makes ID a concept of the DOM and allows for only one per element, given by an id attribute.

An element has an associated DOMTokenList object. The DOMTokenList object’s associated attribute’s local name is class and its associated ordered set of tokens is called the element’s classes.

When an element is created that has an id attribute whose value is not the empty string or when an element’s id attribute is set to a value other than the empty string, set the element’s ID to the new value.

When an element’s id attribute is removed or set to the empty string, unset the element’s ID.

When an element is created that has a class attribute or when an element’s class attribute is set, set the element’s classes to the new value, parsed.

When an element’s class attribute is removed, set the element’s classes to the empty set.

While this specification defines user agent processing requirements for id and class attributes on any element, it makes no claims as to whether using them is conforming or not.

A node’s parent of type Element is known as a parent element. If the node has a parent of a different type, its parent element is null.

The document element of a document is the element whose parent is that document, if it exists, and null otherwise.

Per the node tree constraints, there can only be one such element.

When an element or one of its ancestors is the document element, it is in a document.

namespace = element . namespaceURI

Returns the namespace.

prefix = element . prefix

Returns the namespace prefix.

localName = element . localName

Returns the local name.

qualifiedName = element . tagName

If namespace prefix is not null, returns the concatenation of namespace prefix, ":", and local name. Otherwise it returns the local name. (The return value is uppercased in an HTML document.)

The namespaceURI attribute must return the context object’s namespace.

The prefix attribute must return the context object’s namespace prefix.

The localName attribute must return the context object’s local name.

The tagName attribute must run these steps:

1. If context object’s namespace prefix is not null, let qualified name be its namespace prefix, followed by a ":" (U+003A), followed by its local name. Otherwise, let qualified name be its local name.
2. If the context object is in the HTML namespace and its node document is an HTML document, let qualified name be converted to ASCII uppercase.
3. Return qualified name.

Some IDL attributes are defined to reflect a content attribute of a given name. This means that on getting, these steps must be run:

1. Let attr be the result of getting an attribute given null, name, and the context object.
2. If attr is null, return the empty string.
3. Return attr’s value.

On setting, set an attribute value for the context object using name and the given value.

The id attribute must reflect the "id" content attribute.

The className attribute must reflect the "class" content attribute.

The classList attribute must return the associated DOMTokenList object representing the context object’s classes.

The hasAttributes() method, when invoked, must return false if context object’s attribute list is empty, and true otherwise.

The attributes attribute must return the associated NamedNodeMap.

The getAttribute(name) method must run these steps:

1. Let attr be the result of getting an attribute given name and the context object.
2. If attr is null, return null.
3. Return attr’s value.

The getAttributeNS(namespace, localName) method must run the following steps:

1. Let attr be the result of getting an attribute given namespace, localName, and the context object.
2. If attr is null, return null.
3. Return attr’s value.

The setAttribute(name, value) method must run these steps:

1. If name does not match the Name production in XML, throw an InvalidCharacterError exception.
2. If the context object is in the HTML namespace and its node document is an HTML document, let name be converted to ASCII lowercase.
3. Let attribute be the result of getting an attribute given name and the context object.
4. If attribute is null, create an attribute whose local name is name and value is value, append this attribute to the context object’s attribute list, and then terminate these steps.
5. Change attribute from context object to value.

The setAttributeNS(namespace, name, value) method must run these steps:

1. Let namespace, prefix, localName, and name be the result of passing namespace and name to validate and extract. Rethrow any exceptions.
2. Set an attribute value for the context object using localName, value, and also name, prefix, and namespace.

The removeAttribute(name) method must remove an attribute given name and the context object, and then return undefined.

The removeAttributeNS(namespace, localName) method must remove an attribute given namespace, localName, and the context object, and then return undefined.

The hasAttribute(name) method must run these steps:

1. If the context object is in the HTML namespace and its node document is an HTML document, let name be converted to ASCII lowercase.
2. Return true if the context object has an attribute whose name is name, and false otherwise.

The hasAttributeNS(namespace, localName) method must run these steps:

1. If namespace is the empty string, set it to null.
2. Return true if the context object has an attribute whose namespace is namespace and local name is localName, and false otherwise.

The getAttributeNode(name) method, when invoked, must return the result of getting an attribute given name and the context object.

The getAttributeNodeNS(namespace, localName) method, when invoked, must return the result of getting an attribute given namespace, localName, and the context object.

The setAttributeNode(attr) method, when invoked, must return the result of setting an attribute given attr and the context object. Rethrow any exceptions.

The setAttributeNodeNS(attr) method, when invoked, must return the result of setting an attribute given attr, the context object, and namespace and local name flag set. Rethrow any exceptions.

The removeAttributeNode(attr) method, when invoked, must run these steps:

1. If attr is not in context object’s attribute list, throw a NotFoundError exception.
2. Remove attr from context object.
3. Return attr.

element . closest(selectors)

Returns the first (starting at element) inclusive ancestor that matches selectors, and null otherwise.

element . matches(selectors)

Returns true if matching selectors against element’s root yields element, and false otherwise.

The closest(selectors) method, when invoked, must run these steps:

1. Let s be the result of parse a selector from selectors. [SELECTORS4]
2. If s is failure, throw a SyntaxError.
3. Let elements be context object’s inclusive ancestors that are elements, in reverse tree order.
4. For each element in elements, if match a selector against an element, using s, element, and :scope element context object, returns success, return element. [SELECTORS4]
5. Return null.

The matches(selectors) method, when invoked, must run these steps:

1. Let s be the result of parse a selector from selectors. [SELECTORS4]
2. If s is failure, throw a SyntaxError.
3. Return true if the result of match a selector against an element, using s, element, and :scope element context object, returns success, and false otherwise. [SELECTORS4]

The getElementsByTagName(localName) method must return the list of elements with local name localName for the context object.

The getElementsByTagNameNS(namespace, localName) method must return the list of elements with namespace namespace and local name localName for the context object.

The getElementsByClassName(classNames) method must return the list of elements with class names classNames for the context object.

4.8.1. Interface NamedNodeMap

[Exposed=Window]
interface NamedNodeMap {
  readonly attribute unsigned long length;
  getter Attr? item(unsigned long index);
  getter Attr? getNamedItem(DOMString name);
  Attr? getNamedItemNS(DOMString? namespace, DOMString localName);
  Attr? setNamedItem(Attr attr);
  Attr? setNamedItemNS(Attr attr);
  Attr removeNamedItem(DOMString name);
  Attr removeNamedItemNS(DOMString? namespace, DOMString localName);
};

A NamedNodeMap has an associated element (an element).

A NamedNodeMap object’s attribute list is its element’s attribute list.

A NamedNodeMap object’s supported property indices are the numbers in the range zero to the number of attributes in its attribute list map minus one, unless the attribute list is empty, in which case there are no supported property indices.

The length attribute’s getter must return the number of attributes in the attribute list.

The item(index) method, when invoked, must run these steps:

1. If index is equal to or greater than the number of attributes in the attribute list, return null.
2. Otherwise, return the indexth attribute in the attribute list.

A NamedNodeMap object’s supported property names, all unenumerable, are the names of the attributes in the attribute list, in order.