DOM4

Abstract

DOM defines the event and document model the Web platform uses. The DOM is a language- and platform neutral interface that allows programs and scripts to dynamically access and update the content and structure of documents.

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This is the 6 December 2012 W3C Working Draft of DOM4. The W3C Membership and other interested parties are invited to review the document and send comments to public-webapps@w3.org (public archive) or to www-dom@w3.org (public archive).

Implementors should be aware that this specification is not stable. Implementors who are not taking part in the discussions are likely to find the specification changing out from under them in incompatible ways. Vendors interested in implementing this specification before it eventually reaches the Candidate Recommendation stage should join the aforementioned mailing lists and take part in the discussions.

This document is published by the Web Applications Working Group in co-operation with the Web Hypertext Application Technology Working Group. The Working Group expects to advance this Working Draft to Recommendation Status.

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

Table of Contents

1. Goals
2. 1 Conformance
   1. 1.1 Dependencies
   2. 1.2 Extensibility
3. 2 Terminology
   1. 2.1 Trees
   2. 2.2 Strings
   3. 2.3 Common microsyntaxes
      1. 2.3.1 Common parser idioms
      2. 2.3.2 Space-separated tokens
   4. 2.4 Namespaces
4. 3 Errors
   1. 3.1 Exception DOMException
   2. 3.2 Interface DOMError
   3. 3.3 Error names
5. 4 Events
   1. 4.1 Introduction to "DOM Events"
   2. 4.2 Interface Event
   3. 4.3 Interface CustomEvent
   4. 4.4 Constructing events
   5. 4.5 Interface EventTarget
   6. 4.6 Dispatching events
   7. 4.7 Firing events
6. 5 Nodes
   1. 5.1 Introduction to "The DOM"
   2. 5.2 Node tree
      1. 5.2.1 Mutation algorithms
      2. 5.2.2 Mutation methods
      3. 5.2.3 Legacy mutation methods
   3. 5.3 Mutation observers
      1. 5.3.1 Interface MutationObserver
      2. 5.3.2 Queuing a mutation record
      3. 5.3.3 Interface MutationRecord
      4. 5.3.4 Garbage collection
   4. 5.4 Interface Node
   5. 5.5 Interface Document
      1. 5.5.1 Interface DOMImplementation
   6. 5.6 Interface DocumentFragment
   7. 5.7 Interface DocumentType
   8. 5.8 Interface Element
      1. 5.8.1 Interface Attr
   9. 5.9 Interface CharacterData
   10. 5.10 Interface Text
   11. 5.11 Interface ProcessingInstruction
   12. 5.12 Interface Comment
7. 6 Ranges
   1. 6.1 Interface Range
8. 7 Traversal
   1. 7.1 Interface NodeIterator
   2. 7.2 Interface TreeWalker
   3. 7.3 Interface NodeFilter
9. 8 Collections
   1. 8.1 Interface NodeList
   2. 8.2 Interface HTMLCollection
10. 9 Lists
    1. 9.1 Interface DOMStringList
    2. 9.2 Interface DOMTokenList
    3. 9.3 Interface DOMSettableTokenList
11. 10 Historical
    1. 10.1 DOM Events
    2. 10.2 DOM Core
    3. 10.3 DOM Range
    4. 10.4 DOM Traversal
12. References
13. Acknowledgments

Goals

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

1. By consolidating DOM Level 3 Core [DOM3CORE], Element Traversal [ELEMENTTRAVERSAL], the "DOM Event Architecture" and "Basic Event Interfaces" chapters of DOM Level 3 Events [DOM3EVENTS] (specific type of events do not belong in the base specification), and DOM Level 2 Traversal and Range [DOM2TR], and:

   • Aligning them with the needs of ECMAScript where possible.
   • Aligning them with existing implementations.
   • Simplifying them as much as possible.

2. By moving features from HTML5 that ought to be part of the DOM platform here, while preventing a dependency on HTML5. [HTML]

3. By defining a replacement for the "Mutation Events" and "Mutation Name Event Types" chapters of DOM Level 3 Events [DOM3EVENTS] 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 key words "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 key word ("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 ECMAScript.

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, Web IDL, XML, and Namespaces in XML. [ENCODING] [WEBIDL] [XML] [XMLNS]

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.

If vendor-specific extensions are needed, the members should be prefixed by vendor-specific strings to prevent clashes with future versions of this specification. Extensions must be defined so that the use of extensions neither contradicts nor causes the non-conformance of functionality defined in the specification.

When vendor-neutral extensions to this specification are needed, either this specification can be updated accordingly, or an extension specification can be written that overrides the requirements in this specification. When someone applying this specification to their activities decides that they will recognize the requirements of such an extension specification, it becomes an applicable specification for the purposes of conformance requirements in this specification.

2 Terminology

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

2.1 Trees

Just like most programming paradigms the Web platform has finite hierarchical tree structures, simply named trees. The tree order is preorder, depth-first traversal.

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.

The root of an object is itself, if it has no parent, 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 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 child.

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

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 .. U+005A (i.e. LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z) and the corresponding characters in the range U+0061 .. U+007A (i.e. LATIN SMALL LETTER A to LATIN SMALL LETTER Z) are considered to also match.

Converting a string to ASCII uppercase means replacing all characters in the range U+0061 to U+007A (i.e. LATIN SMALL LETTER A to LATIN SMALL LETTER Z) with the corresponding characters in the range U+0041 to U+005A (i.e. LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z).

Converting a string to ASCII lowercase means replacing all characters in the range U+0041 to U+005A (i.e. LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z) with the corresponding characters in the range U+0061 to U+007A (i.e. LATIN SMALL LETTER A to LATIN SMALL LETTER Z).

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.

The space characters, for the purposes of this specification, are U+0020 SPACE, U+0009 CHARACTER TABULATION (tab), U+000A LINE FEED (LF), U+000C FORM FEED (FF), and U+000D CARRIAGE RETURN (CR).

2.3 Common microsyntaxes

2.3.1 Common parser idioms

Some of the micro-parsers described below follow the pattern of having an input variable that holds the string being parsed, and having a position variable pointing at the next character to parse in input.

For parsers based on this pattern, a step that requires the user agent to collect a sequence of characters means that the following algorithm must be run, with characters being the set of characters that can be collected:

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 character at position is one of the characters, append that character to the end of result and advance position to the next character in input.

4. Return result.

The step skip whitespace means that the user agent must collect a sequence of characters that are space characters. The collected characters are not used.

2.3.2 Space-separated tokens

A set of space-separated tokens is a string containing zero or more words (known as tokens) separated by one or more space characters, where words consist of any string of one or more characters, none of which are space characters.

A string containing a set of space-separated tokens may have leading or trailing space characters.

An unordered set of unique space-separated tokens is a set of space-separated tokens where none of the tokens are duplicated.

An ordered set of unique space-separated tokens is a set of space-separated tokens where none of the tokens are duplicated but where the order of the tokens is meaningful.

Sets of space-separated tokens sometimes have a defined set of allowed values. When a set of allowed values is defined, the tokens must all be from that list of allowed values; other values are non-conforming. If no such set of allowed values is provided, then all values are conforming.

How tokens in a set of space-separated tokens are to be compared (e.g. case-sensitively or not) is defined on a per-set basis.

2.4 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/.

3 Errors

3.1 Exception DOMException

exception DOMException {
  const unsigned short INDEX_SIZE_ERR = 1;
  const unsigned short DOMSTRING_SIZE_ERR = 2; // historical
  const unsigned short HIERARCHY_REQUEST_ERR = 3;
  const unsigned short WRONG_DOCUMENT_ERR = 4;
  const unsigned short INVALID_CHARACTER_ERR = 5;
  const unsigned short NO_DATA_ALLOWED_ERR = 6; // historical
  const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7;
  const unsigned short NOT_FOUND_ERR = 8;
  const unsigned short NOT_SUPPORTED_ERR = 9;
  const unsigned short INUSE_ATTRIBUTE_ERR = 10; // historical
  const unsigned short INVALID_STATE_ERR = 11;
  const unsigned short SYNTAX_ERR = 12;
  const unsigned short INVALID_MODIFICATION_ERR = 13;
  const unsigned short NAMESPACE_ERR = 14;
  const unsigned short INVALID_ACCESS_ERR = 15;
  const unsigned short VALIDATION_ERR = 16; // historical
  const unsigned short TYPE_MISMATCH_ERR = 17; // historical; use TypeError instead
  const unsigned short SECURITY_ERR = 18;
  const unsigned short NETWORK_ERR = 19;
  const unsigned short ABORT_ERR = 20;
  const unsigned short URL_MISMATCH_ERR = 21;
  const unsigned short QUOTA_EXCEEDED_ERR = 22;
  const unsigned short TIMEOUT_ERR = 23;
  const unsigned short INVALID_NODE_TYPE_ERR = 24;
  const unsigned short DATA_CLONE_ERR = 25;
  unsigned short code;
};

The code exception field must return the value it was initialized to. When an exception is created it must be initialized to zero.

To throw a name exception these steps must be run:

1. Create a new DOMException exception whose name is name.

2. Set its message to a user agent-defined value.

3. If its name is in the first column of the error names table and has a corresponding legacy code exception field value in the third column, set its code exception field to that value.

4. Throw the exception.

To throw a "TimeoutError" exception, a user agent would construct a DOMException exception whose name is "TimeoutError" and code exception field value is 23, and actually throw that object as an exception. In JavaScript, this exception will have a name property whose value is "TimeoutError".

3.2 Interface DOMError

This interface is intended for other specifications that want to introduce error handling through other means than exceptions. As with exceptions, the error names table is used.

interface DOMError {
  readonly attribute DOMString name;
};

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

A name DOMError means a DOMError object whose name attribute is initialized to name.

A specification could say that an error attribute must return a "SyntaxError" DOMError.

3.3 Error names

The error names table below lists all the allowed error names, a description, and legacy code exception field values (when the error name is used for throwing an exception).

If an error name is not listed here, please file a bug as indicated at the top of this specification and it will be addressed shortly. Thanks!

4 Events

4.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:

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 on 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 events'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.

4.2 Interface Event

[Constructor(DOMString type, optional EventInit eventInitDict)]
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;

  readonly attribute boolean isTrusted;
  readonly attribute DOMTimeStamp timeStamp;

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

dictionary EventInit {
  boolean bubbles;
  boolean cancelable;
};

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.

var 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 event is dispatched to.

event . currentTarget

Returns the object whose event listener's callback is 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 other objects than the current.

event . stopImmediatePropagation()

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

event . bubbles

Returns true if event's goes through its target attribute value's ancestors in reverse tree order, or 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, or false otherwise.

event . isTrusted

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

event . timeStamp

Returns the creation time of event in 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.

Initially the attribute must be initialized to NONE.

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

When the stopPropagation() method is invoked the stop propagation flag must be set.

When the stopImmediatePropagation() method is invoked both the stop propagation flag and stop immediate propagation flag must be set.

The bubbles and cancelable attributes must return the values they were initialized to. When an event is created the attributes must be initialized to false.

When the preventDefault() method is invoked and the cancelable attribute is true, the canceled flag must be set.

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 has passed since 00:00:00 UTC on 1 January 1970.

When the initEvent(type, bubbles, cancelable) method is invoked these steps must be run:

1. Set the initialized flag.

2. If the dispatch flag is set, terminate these steps.

3. Unset the stop propagation flag, stop immediate propagation flag, and canceled flag.

4. Set the isTrusted attribute to false.

5. Set the target attribute to null.

6. Set the type attribute to the type argument.

7. Set the bubbles attribute to the bubbles argument.

8. Set the cancelable attribute to the cancelable argument.

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

4.3 Interface CustomEvent

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

dictionary CustomEventInit : EventInit {
  any detail;
};

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

var 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.

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. When an event is created the attribute must be initialized to null.

4.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 defined therein 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.

4.5 Interface EventTarget

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 ensures callback is only invoked when the event's eventPhase attribute value is CAPTURING_PHASE.

The event listener is appended to target's list of event listeners and is not appended if it is a duplicate (the event listeners in the list are unique).

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 it's preventDefault() method was not invoked, or false otherwise.

When the addEventListener(type, callback, capture) method is invoked these steps must be run:

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.

When the removeEventListener(type, callback, capture) method is invoked these steps must be run:

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

When the dispatchEvent(event) method is invoked these steps must be run:

1. If event's dispatch flag is set, or if its initialized flag is not set, throw an "InvalidStateError" exception and terminate these steps.

2. Initialize event's isTrusted attribute to false.

3. Dispatch the event and return the value that returns.

4.6 Dispatching events

To dispatch an event to a given object 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 the object to which event is dispatched.

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, or let event path be the empty list otherwise.

5. Initialize event's eventPhase attribute to CAPTURING_PHASE.

6. For each object in the 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 the 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, or 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 static list 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. If listener's callback is a Function object, its callback this value is the event's currentTarget attribute value.

   7. Call listener's callback, with the event passed to this algorithm as the first argument.

4.7 Firing events

To fire an event named e means that an 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 is short for initializing and dispatching an event.

Fire an event is a concept to make initializing and dispatching an event 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".

5 Nodes

5.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 tree of nodes of various types. Some of those nodes can have child nodes, while others are leaves. These restrictions are explained in the Node tree section, and the descriptions of the distinct types of nodes comprise the remaining sections in this chapter.

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 space characters 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.

How much should be explained here? Ideas?

5.2 Node tree

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

A tree of nodes 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.

5.2.1 Mutation algorithms

At certain points in the algorithms below it is said that a node is inserted or a node is removed. These are hooks for other applicable specifications to process the nodes that have been inserted or removed further and ensures that when multiple nodes are inserted or removed this happens atomically.

To pre-insert 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" and terminate these steps.

2. If node is an inclusive ancestor of parent, throw a "HierarchyRequestError" and terminate these steps.

3. If child is not null and its parent is not parent, throw a "NotFoundError" exception and terminate these steps.

4. If parent is a document, run these substeps:

   1. If node is not a DocumentFragment, DocumentType, Element, ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" and terminate these steps.

   2. If node is a DocumentFragment node, run these inner substeps:

      1. If node has more than one element child or has a Text node child, throw a "HierarchyRequestError" and terminate these steps.

      2. If node has one element child, and parent has an element child, child is a doctype, or child is not null and a doctype is following child, throw a "HierarchyRequestError" and terminate these steps.

   3. If node is an element, and parent has an element child, child is a doctype, or child is not null and a doctype is following child, throw a "HierarchyRequestError" and terminate these steps.

   4. If node is a doctype and either parent has a doctype child, an element is preceding child, or child is null and parent has an element child, throw a "HierarchyRequestError" and terminate these steps.

5. Otherwise, parent is a DocumentFragment or Element node. If node is not a DocumentFragment, Element, Text, ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" and terminate these steps.

6. Let reference child be child.

7. If reference child is node, set it to node's next sibling.

8. Adopt node with parent's node document.

9. Insert node into parent before reference child.

10. Return node.

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

1. Let count be the number of children of node if it is a DocumentFragment node, or one otherwise.

2. For each range whose start node is parent and start offset is greater than child's index, increase its start offset by count.

3. For each range whose end node is parent and end offset is greater than child's index, increase its end offset by count.

4. Let nodes be node's children if node is a DocumentFragment node, or a list containing solely node otherwise.

5. If node is a DocumentFragment node, queue a mutation record of "childList" for node with removedNodes nodes.

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

6. If node is a DocumentFragment node, remove its children with the suppress observers flag set.

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.

8. Insert all nodes in nodes before child or at the end of parent if child is null.

9. If suppress observers flag is unset, for each node in nodes, in tree order run node is inserted.

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 child's parent is not parent, throw a "NotFoundError" exception and terminate these steps.

   This implies parent is a Document, DocumentFragment, or Element node.

2. If node is an inclusive ancestor of parent, throw a "HierarchyRequestError" and terminate these steps.

3. If parent is a document, run these substeps:

   1. If node is not a DocumentFragment, DocumentType, Element, ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" and terminate these steps.

   2. If node is a DocumentFragment node, run these inner substeps:

      1. If node has more than one element child or has a Text node child, throw a "HierarchyRequestError" and terminate these steps.

      2. If node has one element child and either parent has an element child that is not child or a doctype is following child, throw a "HierarchyRequestError" and terminate these steps.

   3. If node is an element and either parent has an element child that is not child or a doctype is following child, throw a "HierarchyRequestError" and terminate these steps.

   4. If node is a doctype and either parent has a doctype child that is not child, or an element is preceding child, throw a "HierarchyRequestError" and terminate these steps.

4. Otherwise if parent is a DocumentFragment or Element node and node is not a DocumentFragment, Element, Text, ProcessingInstruction, or Comment node, throw a "HierarchyRequestError" and terminate these steps.

5. Let reference child be child's next sibling.

6. If reference child is node, set it to node's next sibling.

7. Adopt node with parent's node document.

8. Remove child from its parent with the suppress observers flag set.

9. Insert node into parent before reference child with the suppress observers flag set.

10. Let nodes be node's children if node is a DocumentFragment node, or a list containing solely node otherwise.

11. queue a mutation record of "childList" for target parent with addedNodes nodes, removedNodes a list solely containing child, nextSibling reference child, and previousSibling child's previous sibling.

12. Run node is removed for child, and then for each node in nodes, in tree order, run node is inserted.

13. Return child.

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

1. Adopt node with parent's node document.

2. Remove all parent's children, with the suppress observers flag set.

3. If node is not null, insert node into parent before null with the suppress observers flag set.

4. Let nodes be null if node is null, node's children if node is a DocumentFragment node, or a list containing node otherwise.

5. queue a mutation record of "childList" for parent with addedNodes nodes and removedNodes parent's children.

6. Run node is removed for each child of parent, in tree order, and then for each node in nodes, in tree order, run node is inserted.

This algorithm does not make any checks with regards to the node tree. 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 and terminate these steps.

2. Remove child from parent.

3. Return child.

To remove a node from a parent, optionally with suppress observers flag set, run these steps:

1. Let index be node's index.

2. For each range whose start node is a descendant of node, set its start to (parent, index).

3. For each range whose end node is a 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. 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 node's previous sibling.

7. For each ancestor ancestor of node, if ancestor has any registered observers whose options's subtree is true, then for each such registered observer, append a transient registered observer whose observer and options are identical to the registered observer to node's list of registered observers.

8. Remove node from its parent.

9. If suppress observers flag is unset, run node is removed for node.

5.2.2 Mutation methods

The mutation method macro:

1. Let node be null.

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

3. If nodes contains more than one node, set node to a new DocumentFragment and append each node in nodes to it. If this throws an exception, re-throw the exception and terminate these steps.

   Otherwise, set node to the single node nodes contains.

The prepend(nodes) method must run these steps:

1. Run the mutation method macro.

2. Pre-insert node into the context object before the context object's first child.

The append(nodes) method must run these steps:

1. Run the mutation method macro.

2. Append node to the context object.

The before(nodes) method must run these steps:

1. If the context object does not have a parent, terminate these steps.

2. Run the mutation method macro.

3. Pre-insert node into the context object's parent before the context object.

The after(nodes) method must run these steps:

1. If the context object does not have a parent, terminate these steps.

2. Run the mutation method macro.

3. Pre-insert node into the context object's parent before the context object's next sibling.

The replace(nodes) method must run these steps:

1. If the context object does not have a parent, terminate these steps.

2. Run the mutation method macro.

3. Replace the context object with node within the context object's parent.

The remove() method must run these steps:

1. If the context object does not have a parent, terminate these steps.

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

5.2.3 Legacy mutation methods

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.

5.3 Mutation observers

Each scripting environment has an associated list of MutationObserver objects which is initially empty. To invoke MutationObserver objects, run these steps:

1. Let notify list be a copy of scripting environment's list of MutationObserver objects.

2. For each MutationObserver object mo in notify list, run these substeps:

   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, invoke mo's callback with queue as first argument, and mo (itself) as second argument and callback this value.

3. If any MutationObserver object in scripting environment's list of MutationObserver objects has a non-empty record queue at this point, run these steps again (indeed, all of them).

The DOM standard does not define the scripting environment nor its scope. The HTML standard defines how this concept integrates with the rest of the platform as well as when invoke is invoked. This somewhat artificial boundary is made to prevent a dependency from DOM on HTML. [HTML]

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.

5.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 = false;
  boolean characterData = false;
  boolean subtree = false;
  boolean attributeOldValue = false;
  boolean characterDataOldValue = false;
  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.

var 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.

characterData

Set to true if mutations to target's data are to be observed.

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 set to true and target's attribute value before the mutation needs to be recorded.

characterDataOldValue

Set to true if characterData is set to true 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.

observer . disconnect()

Stops the 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 scripting environment's list of MutationObserver objects, and then return it.

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

1. Run these substeps, with options as the context object:

   1. If neither childList, attributes, nor characterData is true, throw a "SyntaxError" and terminate these steps.

   2. If attributeOldValue is true and attributes is not true, throw a "SyntaxError" and terminate these steps.

   3. If attributeFilter is a non-empty array and attributes is not true, throw a "SyntaxError" and terminate these steps.

   4. If characterDataOldValue is true and characterData is not true, throw a "SyntaxError" and terminate these steps.

2. If target's list of registered observers already includes a registered observer associated with the context object, replace that registered observer's options with options.

3. 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.

5.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 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, removedNodes, previousSibling, and nextSibling are given, set record's addedNodes to addedNodes, record's removedNodes to removedNodes, record's previousSibling to previousSibling, and record's nextSibling to nextSibling.

4. Let interested observers be an initially empty set of MutationObserver objects optionally paired with a string.

5. Let nodes be the inclusive ancestors of target.

6. 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's subtree is false, continue.

   2. If type is "attributes" and options's attributes is false, continue.

   3. If type is "attributes", options's attributeFilter is non-empty, and either options's attributeFilter does not contain name or namespace is non-null, continue.

   4. If type is "characterData" and options's characterData is false, continue.

   5. If type is "childList" and options's 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's attributeOldValue is true, or type is "characterData" and options's characterDataOldValue is true, set the paired string of registered observer's observer in interested observers to oldValue.

7. Then, for each observer in interested observers:

   1. If observer has a paired string, set record's oldValue to observer's paired string.

   2. Append record to observer's record queue.

5.3.3 Interface MutationRecord

interface MutationRecord {
  readonly attribute DOMString type;
  readonly attribute Node target;
  readonly attribute NodeList addedNodes;
  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, or null otherwise.

record . attributeName

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

record . attributeNamespace

Returns the namespace of the changed attribute, or 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 be 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.

5.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.

5.4 Interface Node

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();
  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;
  Node insertBefore(Node node, Node? child);
  Node appendChild(Node node);
  Node replaceChild(Node node, Node child);
  Node removeChild(Node child);
  void normalize();

  Node cloneNode(optional boolean deep = true);
  boolean isEqualNode(Node? node);

  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 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.

Each node also has an associated base URL.

Other specifications define the value of the base URL and its observable behavior. This specification solely defines the concept and the baseURI attribute.

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 must return the type of the node, which must be one of the following:

• ELEMENT_NODE (1);
• TEXT_NODE (3);
• PROCESSING_INSTRUCTION_NODE (7);
• COMMENT_NODE (8);
• DOCUMENT_NODE (9);
• DOCUMENT_TYPE_NODE (10);
• DOCUMENT_FRAGMENT_NODE (11).

The nodeName attribute must return the following, depending 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 the base URL.

The baseURI attribute must return the associated 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.

Setting the nodeValue attribute must 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])

Returns a copy of node. If deep is true or omitted, the copy also includes the node children.

node . isEqualNode(other)

Returns whether node and other 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 document.

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, or 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 and terminate these steps.

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 and terminate these steps.

   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 and terminate these steps.

5. If other is a descendant of reference, return the result of adding DOCUMENT_POSITION_CONTAINED_BY to DOCUMENT_POSITION_FOLLOWING and terminate these steps.

6. If other is preceding reference return DOCUMENT_POSITION_PRECEDING and terminate these steps.

7. Return DOCUMENT_POSITION_FOLLOWING.

The contains(other) method must return true if other is an inclusive descendant of the context object, or 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 and terminate these steps.

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 and terminate these steps.

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 the node:

Element

1. If its namespace is not null and its namespace prefix is prefix return namespace and terminate these steps.

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, or null otherwise.

   2. Return value and terminate these steps.

3. If its parent element is null, return null and terminate these steps.

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 and terminate these steps.

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 and terminate these steps.

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, or 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, or false otherwise.

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 only the following 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 only 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 only elements.

3. Otherwise, if just namespace is "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches only elements whose local name is localName.

4. Otherwise, if just localName is "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches only elements whose namespace is namespace.

5. Otherwise, return a HTMLCollection rooted at root, whose filter matches only 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 set of tokens found by splitting classNames on spaces. (Duplicates are ignored.)

2. If classes is the empty set, return an empty HTMLCollection and terminate these steps.

3. Return a HTMLCollection rooted at root, whose filter matches only elements that have all the classes in classes.

   If root's node document is in quirks mode, then the comparisons for the classes must be done in an ASCII case-insensitive manner, or 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.

5.5 Interface Document

[Constructor]
interface Document : Node {
  readonly attribute DOMImplementation implementation;
  readonly attribute DOMString URL;
  readonly attribute DOMString documentURI;
  readonly attribute DOMString compatMode;
  readonly attribute DOMString 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);
  Element? getElementById(DOMString elementId);

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

  Node importNode(Node node, optional boolean deep = true);
  Node adoptNode(Node node);

  Event createEvent(DOMString interface);

  Range createRange();

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

  // NEW
  void prepend((Node or DOMString)... nodes);
  void append((Node or DOMString)... nodes);
};

interface XMLDocument : Document {};

Document nodes are simply known as documents.

Each document has an associated encoding, content type, and URL.

Unless explicitly given when a document is created its encoding is the utf-8 encoding, its content type is "application/xml", and its URL is "about:blank".

A document is assumed to be an XML document unless it is flagged as being an HTML document. Whether a document is an HTML document or an XML document affects the behavior of certain APIs.

A document is always set to one of three modes: no-quirks mode, the default; quirks mode, used typically for legacy documents; and limited-quirks mode. Unless other applicable specifications define otherwise, a document must be in no-quirks mode.

The mode is only ever changed from the default if the document is created by the HTML parser, based on the presence, absence, or value of the DOCTYPE string. [HTML]

No-quirks mode was originally known as "standards mode" and limited-quirks mode was once known as "almost standards mode". They have been renamed because their details are now defined by standards. (And because Ian Hickson vetoed their original names on the basis that they are nonsensical.)

document = new Document()

Returns a new document.

document . implementation

Returns the associated DOMImplementation object.

document . URL

document . documentURI

Returns the URL.

document . compatMode

Returns the string "CSS1Compat" if document is in no-quirks mode or limited-quirks mode, and "BackCompat", if document is in quirks mode.

document . characterSet

Returns the encoding.

document . contentType

Returns the content type.

The Document() constructor must return a new document.

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 compatMode attribute must return "BackCompat" if the context object is in quirks mode, or "CSS1Compat" otherwise.

The characterSet attribute must return the name of the encoding.

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(classes)

collection = element . getElementsByClassName(classes)

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 classes.

The classes argument is interpreted as a space-separated list of classes.

element = document . getElementById(elementId)

Returns the first element in document with the given ID.

The doctype attribute must return the child of the document that is a doctype, or 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>

The getElementById(elementId) method must return the first element, in tree order, within the context object's tree, whose ID is elementId, or null if there is none.

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 createElement(localName) method must run the these steps:

1. If localName does not match the Name production, throw an "InvalidCharacterError" exception and terminate these steps.

2. If the context object is an HTML document, let localName be converted to ASCII lowercase.

3. Return a new element 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. If namespace is the empty string, set it to null.

2. If qualifiedName does not match the Name production, throw an "InvalidCharacterError" exception and terminate these steps.

3. If qualifiedName does not match the QName production, throw a "NamespaceError" exception and terminate these steps.

4. If qualifiedName contains a ":" (U+003E), then split the string on it and let prefix be the part before and localName the part after. Otherwise, let prefix be null and localName be qualifiedName.

5. If prefix is not null and namespace is null, throw a "NamespaceError" exception and terminate these steps.

6. If prefix is "xml" and namespace is not the XML namespace, throw a "NamespaceError" exception and terminate these steps.

7. If qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace, throw a "NamespaceError" exception and terminate these steps.

8. If namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns", throw a "NamespaceError" exception and terminate these steps.

9. Return a new element 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 and terminate these steps.

2. If data contains the string "?>", throw an "InvalidCharacterError" exception and terminate these steps.

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])

Returns a copy of node. If deep is true or omitted, the copy also includes the node children.

If node is a document throws a "NotSupportedError" exception.

node = document . adoptNode(node)

Moves node from another document and returns it.

If node is a document throws a "NotSupportedError" exception.

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

1. If node is a document, throw a "NotSupportedError" exception and terminate these steps.

2. Return a clone of node, with document context object and the clone children flag set if deep is true.

To adopt a node, with an ownerDocument, run these steps:

1. If node is an element, it is affected by a base URL change.

2. If node's parent is not null, remove node from its parent.

3. Set node document for node and all its descendants to ownerDocument.

The adoptNode(node) method must run these steps:

1. If node is a document, throw a "NotSupportedError" exception and terminate these steps.

2. Adopt node with the context object.

3. Return node.

The createEvent(interface) method must run these steps:

1. Let event be null.

2. If interface is an ASCII case-insensitive match for any of the strings in the first column in the following table, let event be the interface in the second column on the same row as the matching string:

   String	Interface
   "event"	Event
   "events"
   "htmlevents"
   "mouseevent"	MouseEvent
   "mouseevents"
   "uievent"	UIEvent
   "uievents"

3. If event is null or an interface that is not supported, throw a "NotSupportedError" and terminate these steps.

   In practice all user agents will support the MouseEvent and UIEvent interface, but this specification is not going to require that to avoid a needless dependency.

4. Create an event implementing the event interface and return it.

This method is pretty much obsolete as events have constructors these days, but needs to be supported for legacy content. Tough.

event = document . createRange()

Returns a new range.

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

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

1. Create a NodeIterator object.

2. Set root and initialize the referenceNode attribute to the root argument.

3. Set whatToShow to the whatToShow argument.

4. Set filter to filter.

5. Return the newly created NodeIterator object.

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

1. Create a TreeWalker object.

2. Set root and initialize the currentNode attribute to the root argument.

3. Set whatToShow to the whatToShow argument.

4. Set filter to filter.

5. Return the newly created TreeWalker object.

5.5.1 Interface DOMImplementation

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

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

  boolean hasFeature(DOMString feature, [TreatNullAs=EmptyString] DOMString version);
};

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 )

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.

document . implementation . hasFeature( feature, version)

If feature is an SVG feature string, returns whether that feature is supported. If feature is not the empty string, only returns true if the feature is supported as defined in the given version of the SVG specification (e.g., "1.1").

If feature is not an SVG feature, but rather some other string like "HTML" or "flibbertigibbet", always returns true. Thus, this method is only useful for testing SVG features.

5.6 Interface DocumentFragment

interface DocumentFragment : Node {
  // NEW
  void prepend((Node or DOMString)... nodes);
  void append((Node or DOMString)... nodes);
};

5.7 Interface DocumentType

interface DocumentType : Node {
  readonly attribute DOMString name;
  readonly attribute DOMString publicId;
  readonly attribute DOMString systemId;

  // NEW
  void before((Node or DOMString)... nodes);
  void after((Node or DOMString)... nodes);
  void replace((Node or DOMString)... nodes);
  void remove();
};

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.

5.8 Interface Element

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;
  readonly attribute DOMTokenList classList;

  readonly attribute Attr[] 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);

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

  readonly attribute HTMLCollection children;
  readonly attribute Element? firstElementChild;
  readonly attribute Element? lastElementChild;
  readonly attribute Element? previousElementSibling;
  readonly attribute Element? nextElementSibling;
  readonly attribute unsigned long childElementCount;

  // NEW
  void prepend((Node or DOMString)... nodes);
  void append((Node or DOMString)... nodes);
  void before((Node or DOMString)... nodes);
  void after((Node or DOMString)... nodes);
  void replace((Node or DOMString)... nodes);
  void remove();
};

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. 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.

Elements can have a unique identifier (ID) and classes associated with them.

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 ID if it has an id attribute whose value is not the empty string. The ID is that attribute's value.

An element has classes if it has a class attribute, and splitting that attribute's value does not return an empty list. The classes are that attribute's value split on spaces.

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.

As explained in the node tree section, there can only be one such element.

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

Specifications may define base URL change steps.

When an element is affected by a base URL change, the user agent must run the base URL change steps, as defined in other applicable specifications.

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 attributes are defined to reflect a particular content attribute. This means that on getting, these steps must be run:

1. Let value be the result of invoking getAttributeNS() with null as first argument and the name of the content attribute as second argument.
2. If value is null, return the empty string and terminate these steps.
3. Return value.

On setting, the setAttributeNS() must be invoked with null as first argument, the name of the content attribute as second argument, and the new value as third argument.

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

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

The classList attribute must return a DOMTokenList whose underlying string is the className attribute value.

The attributes attribute must return a read only array of the context object's attribute list. The returned read only array must be live. I.e. changes to the associated attributes are reflected.

The getAttribute(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 the value of the first attribute in the context object's attribute list whose name is name, or null otherwise.

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

1. If namespace is the empty string, set it to null.

2. Return the value of the attribute in the context object's attribute list whose namespace is namespace and local name is localName, if it has one, or null otherwise.

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

1. If name does not match the Name production in XML, throw an "InvalidCharacterError" exception and terminate these steps.

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 first attribute in the context object's attribute list whose name is name, or null if there is no such attribute.

4. If attribute is null, create an attribute whose name is name and value is value, and then append this attribute to the context object and terminate these steps.

5. Queue a mutation record of "attributes" for context object with name attribute's local name, namespace attribute's namespace, and oldValue attribute's value.

6. Set attribute's value to value.

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

1. If namespace is the empty string, set it to null.

2. If name does not match the Name production in XML, throw an "InvalidCharacterError" exception and terminate these steps.

3. If name does not match the QName production in Namespaces in XML, throw a "NamespaceError" exception and terminate these steps.

4. If name contains a ":" (U+003E), then split the string on it and let prefix be the part before and localName the part after. Otherwise, let prefix be null and localName be name.

5. If prefix is not null and namespace is null, throw a "NamespaceError" exception and terminate these steps.

6. If prefix is "xml" and namespace is not the XML namespace, throw a "NamespaceError" exception and terminate these steps.

7. If name or prefix is "xmlns" and namespace is not the XMLNS namespace, throw a "NamespaceError" exception and terminate these steps.

8. If namespace is the XMLNS namespace and neither name nor prefix is "xmlns", throw a "NamespaceError" exception and terminate these steps.

9. Let attribute be the first attribute in the context object's attribute list whose namespace is namespace and whose local name is localName, or null if there is no such attribute.

10. If attribute is null, create an attribute whose name is name, namespace is namespace, namespace prefix is prefix, local name is localName, and value is value, and then append this attribute to the context object and terminate these steps.

11. Queue a mutation record of "attributes" for context object with name localName, namespace namespace, and oldValue attribute's value.

12. Set attribute's value to value.

The removeAttribute(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. Remove the first attribute from the context object whose name is name, if any.

The removeAttributeNS(namespace, localName) method must return the following steps:

1. If namespace is the empty string, set it to null.

2. Remove the attribute from the context object whose namespace is namespace and local name is localName, if any.

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, or false otherwise.

The hasAttributeNS(namespace, localName) method must return the following 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, or false otherwise.

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

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

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

collection = element . children

Returns the child elements.

element = element . firstElementChild

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

element = element . lastElementChild

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

element = element . previousElementSibling

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

element = element . nextElementSibling

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

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, or null otherwise.

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

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

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

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

5.8.1 Interface Attr

interface Attr {
  readonly attribute DOMString name;
           attribute DOMString value;

  readonly attribute DOMString? namespaceURI;
  readonly attribute DOMString? prefix;
  readonly attribute DOMString localName;
};

Attr objects are simply known as attributes.

Attributes have a name and value.

For legacy reasons, attributes also have an associated namespace, namespace prefix, and local name.

When an attribute is created, its name and value are always given. Unless explicitly given when an attribute is created, its local name is identical to its name, and its namespace and namespace prefix are null.

An A attribute is an attribute whose name is A and whose namespace and namespace prefix are null.

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.

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 the attribute from the element's attribute list.

The name attribute must return the name.

The value attribute must return the value.

Setting the value attribute must set value to the new value.

The namespaceURI attribute must return the namespace.

The prefix attribute must return the namespace prefix.

The localName attribute must return the local name.

5.9 Interface CharacterData

interface CharacterData : Node {
  [TreatNullAs=EmptyString] attribute DOMString data;
  readonly attribute unsigned long length;
  DOMString substringData(unsigned long offset, unsigned long count);
  void appendData(DOMString data);
  void insertData(unsigned long offset, DOMString data);
  void deleteData(unsigned long offset, unsigned long count);
  void replaceData(unsigned long offset, unsigned long count, DOMString data);

  // NEW
  void before((Node or DOMString)... nodes);
  void after((Node or DOMString)... nodes);
  void replace((Node or DOMString)... nodes);
  void remove();
};

CharacterData is an abstract interface and does not exist as node. It is used by Text, Comment, and ProcessingInstruction nodes.

Each node inheriting from the CharacterData interface has an associated mutable string called data.

To replace data of node node with offset offset, count count, and data data, run these steps:

1. Let length be the node's length attribute value.

2. If offset is greater than length, throw an "IndexSizeError" exception and terminate these steps.

3. If offset plus count is greater than length let count be length minus offset.

4. Queue a mutation record of "characterData" for node with oldValue node's data.

5. Insert data into node's data after offset code units.

6. Let delete offset be offset plus the number of code units in data.

7. Starting from delete offset code units, remove count code units from node's data.

8. For each range whose start node is node and start offset is greater than offset but less than or equal to offset plus count, set its start offset to offset.

9. For each range whose end node is node and end offset is greater than offset but less than or equal to offset plus count, set its end offset to offset.

10. For each range whose start node is node and start offset is greater than offset plus count, increase its start offset by the number of code units in data, then decrease it by count.

11. For each range whose end node is node and end offset is greater than offset plus count, increase its end offset by the number of code units in data, then decrease it by count.

To substring data with node node, offset offset, and count count, run these steps:

1. Let length be node's length attribute value.

2. If offset is greater than length, throw an "IndexSizeError" exception and terminate these steps.

3. If offset plus count is greater than length, return a string whose value is the code units from the offset^th code unit to the end of node's data, and then terminate these steps.

4. Return a string whose value is the code units from the offset^th code unit to the offset+count^th code unit in node's data.

The data attribute must return data, and on setting, must replace data with node context object offset 0, count length attribute value, and data new value.

The length attribute must return the number of code units in data.

The substringData(offset, count) method must substring data with node context object, offset offset, and count count.

The appendData(data) method must replace data with node context object, offset length attribute value, count 0, and data data.

The insertData(offset, data) method must replace data with node context object, offset offset, count 0, and data data.

The deleteData(offset, count) method must replace data with node context object, offset offset, count count, and data the empty string.

The replaceData(offset, count, data) method must replace data with node context object, offset offset, count count, and data data.

5.10 Interface Text

interface Text : CharacterData {
  Text splitText(unsigned long offset);
  readonly attribute DOMString wholeText;
};

To split a Text node node with offset offset, run these steps:

1. Let length be the length attribute value.

2. If offset is greater than length, throw an "IndexSizeError" exception and terminate these steps.

3. Let count be length minus offset.

4. Let new data be the result of substringing data with node node, offset offset, and count count.

5. Let new node be a new Text node, with the same node document as node. Set new node's data to new data.

6. Let parent be the node's parent.

7. If parent is not null, run these substeps:

   1. Insert new node into parent before node's next sibling.

   2. For each range whose start node is node and start offset is greater than offset, set its start node to new node and decrease its start offset by offset.

   3. For each range whose end node is node and end offset is greater than offset, set its end node to new node and decrease its end offset by offset.

   4. For each range whose start node is parent and start offset is equal to the index of node + 1, increase its start offset by one.

   5. For each range whose end node is parent and end offset is equal to the index of node + 1, increase its end offset by one.

8. Replace data with node node, offset offset, count count, and data the empty string.

9. If parent is null, run these substeps:

   1. For each range whose start node is node and start offset is greater than offset, set its start offset to offset.

   2. For each range whose end node is node and end offset is greater than offset, set its end offset to offset.

10. Return new node.

The splitText(offset) method must split the context object with offset offset.

The contiguous Text nodes of a node are the node itself, the previous sibling Text node (if any) and its contiguous Text nodes, and the next sibling Text node (if any) and its contiguous Text nodes, avoiding any duplicates.

The wholeText attribute must return a concatenation of the data of the contiguous Text nodes of the context object, in tree order.

5.11 Interface ProcessingInstruction

interface ProcessingInstruction : CharacterData {
  readonly attribute DOMString target;
};

ProcessingInstruction nodes have an associated target.

The target attribute must return the target.

5.12 Interface Comment

interface Comment : CharacterData {
};

6 Ranges

6.1 Interface Range

interface Range {
  readonly attribute Node startContainer;
  readonly attribute unsigned long startOffset;
  readonly attribute Node endContainer;
  readonly attribute unsigned long endOffset;
  readonly attribute boolean collapsed;
  readonly attribute Node commonAncestorContainer;

  void setStart(Node refNode, unsigned long offset);
  void setEnd(Node refNode, unsigned long offset);
  void setStartBefore(Node refNode);
  void setStartAfter(Node refNode);
  void setEndBefore(Node refNode);
  void setEndAfter(Node refNode);
  void collapse(boolean toStart);
  void selectNode(Node refNode);
  void selectNodeContents(Node refNode);

  const unsigned short START_TO_START = 0;
  const unsigned short START_TO_END = 1;
  const unsigned short END_TO_END = 2;
  const unsigned short END_TO_START = 3;
  short compareBoundaryPoints(unsigned short how, Range sourceRange);

  void deleteContents();
  DocumentFragment extractContents();
  DocumentFragment cloneContents();
  void insertNode(Node node);
  void surroundContents(Node newParent);

  Range cloneRange();
  void detach();

  boolean isPointInRange(Node node, unsigned long offset);
  short comparePoint(Node node, unsigned long offset);

  boolean intersectsNode(Node node);

  stringifier;
};

Range objects are simply known as ranges.

Ranges can be created using the createRange() method.

A boundary point is a (node, offset) tuple, where offset is a non-negative integer.

Generally speaking, a boundary point's offset will be between zero and the boundary point's node length, inclusive. Algorithms that modify a tree (in particular the insert, remove, replace data, and split algorithms) also modify ranges associated with that tree.

If the two nodes of boundary points (node A, offset A) and (node B, offset B) have the same root, the position of the first relative to the second is either before, equal, or after, as returned by the following algorithm:

1. If node A is the same as node B, return equal if offset A is the same as offset B, before if offset A is less than offset B, and after if offset A is greater than offset B.

2. If node A is following node B, compute the position of (node B, offset B) relative to (node A, offset A). If it is before, return after. If it is after, return before. In either case terminate these steps.

3. If node A is an ancestor of node B:

   1. Let child equal node B.

   2. While child is not a child of node A, set child to its parent.

   3. If the index of child is less than offset A, return after.

4. Return before.

Each range has two associated boundary points — a start and end — an associated detached flag, which is initially unset.

For convenience, start node is start's node, start offset is start's offset, end node is end's node, and end offset is end's offset.

The root of a range is the root of its start node, or null if its detached flag is set.

A node node is contained in a range range if node's root is the same as range's root, and (node, 0) is after range's start, and (node, length of node) is before range's end.

A node is partially contained in a range if it is an inclusive ancestor of the range's start node but not its end node, or vice versa.

node = range . startContainer

Returns range's start node.

offset = range . startOffset

Returns range's start offset.

node = range . endContainer

Returns range's end node.

offset = range . endOffset

Returns range's end offset.

collapsed = range . collapsed

Returns true if range's start and end are the same, or false otherwise.

container = range . commonAncestorContainer

Returns the node, furthest away from the document, that is an ancestor of both range's start node and end node.

The startContainer attribute must throw an "InvalidStateError" exception if the detached flag is set, or return the start node otherwise.

The startOffset attribute must throw an "InvalidStateError" exception if the detached flag is set, or return the start offset otherwise.

The endContainer attribute must throw an "InvalidStateError" exception if the detached flag is set, or return the end node otherwise.

The endOffset attribute must throw an "InvalidStateError" exception if the detached flag is set, or return the end offset otherwise.

The collapsed attribute must throw an "InvalidStateError" exception if the detached flag is set, return true if start is the same as end, or return false otherwise.

The commonAncestorContainer attribute must run these steps:

1. If the detached flag is set, throw an "InvalidStateError" exception and terminate these steps.

2. Let container be start node.

3. While container is not an inclusive ancestor of end node, let container be container's parent.

4. Return container.

To set the start or end of a range to a boundary point (node, offset), run these steps:

1. If range's detached flag is set, throw an "InvalidStateError" exception and terminate these steps.

2. If node is a doctype, throw an "InvalidNodeTypeError" exception and terminate these steps.

3. If offset is greater than node's length, throw an "IndexSizeError" exception and terminate these steps.

4. Let bp be the boundary point (node, offset).

5. If these steps were invoked as "set the start"

   1. If bp is after the range's end, or if the range's root is not equal to node's root, set range's end to bp.

   2. Set range's start to bp.

   If these steps were invoked as "set the end"

   1. If bp is before the range's start, or if the range's root is not equal to node's root, set range's start to bp.

   2. Set range's end to bp.

The setStart(node, offset) method must set the start of the context object to boundary point (node, offset).

The setEnd(refNode, offset) method must set the end of the context object to boundary point (node, offset).

The setStartBefore(node) method must run these steps:

1. If the detached flag is set, throw an "InvalidStateError" exception and terminate these steps.

2. Let parent be node's parent.

3. If parent is null, throw an "InvalidNodeTypeError" exception and terminate these steps.

4. Set the start of the context object to boundary point (parent, node's index).

The setStartAfter(node) method must run these steps:

1. If the detached flag is set, throw an "InvalidStateError" exception and terminate these steps.

2. Let parent be node's parent.

3. If parent is null, throw an "InvalidNodeTypeError" exception and terminate these steps.

4. Set the start of the context object to boundary point (parent, node's index plus one).