DOM4

目标

本规范用于规范DOM平台。其作用如下：

1. 强化《DOM Level 3 Core》[DOM3CORE]、《元素遍历》[ELEMENTTRAVERSAL]、《DOM Level 3 事件》[DOM3EVENTS]的“DOM事件架构”和“基本事件接口”章节、以及《DOM Level 2 遍历和排列》[DOM2TR]，并操作如下：
   • 如果可能，调整ECMAScript的需求。
   • 调整现有的实现。
   • 尽可能地进行简化。
2. 从HTML5移动应为DOM平台一部分的特性，以防止依赖HTML5。[HTML]
3. 定义一个“变化事件”的替代品，为基于DOM的监听器。
   注：我们预计将在适当的时候移除“变化事件”。
4. 定义用于简化常见DOM操作的新特性。

问题

• 变化监听器（并更新变化方法）
• 定义事件处理程序。定义事件处理程序IDL属性列表？定义一个事件处理程序内容属性的概念？
• 将DOMStringMap移至此处？

一致性

依赖关系

使用者代理必须将本规范里的所有 IDL 片段解释为 Web IDL 所说的必要符合 IDL 片段。[WEBIDL]

本规范部份术语由《Web IDL》、《XML》与《Namespaces in XML》定义。[WEBIDL] [XML] [XMLNS]

可扩展性

术语

术语上下文对象指调用正在讨论的方法或属性的对象。若上下文对象是明确的，则可以忽略该术语。

字符编码的首选MIME名称为IANA字符集注册表中的名称或标为“首选MIME名称”的别名（如果存在），或编码的名称（如果没有如此标记的别名）。[IANACHARSET]

树

与大多数编程范式相似，Web平台拥有一个有限分层的树形结构，简单的命名为树。树形结构顺序为先根次序、深度优先遍历。

参与树的对象拥有一个父亲（为其他对象或者空），以及一个零或多个孩子对象的有序列表。

如果一个对象没有父亲，其根为其自身，否则为其父亲的根。

如果一个对象A是另一个对象B的孩子，或者A是作为B的后裔的对象C的孩子，则A被称为B的后裔。

包容性后裔是一个对象或其后裔之一。

当且仅当一个对象B是另一个对象A的后裔时，A被称为B的祖先。

包容性祖先是一个对象或其祖先之一。

当且仅当一个对象B和另一个对象A共享同一个非空的父亲时，A被称为B的兄弟。

如果一个对象A和另一个对象B在同一个树内，且按照树形结构顺序A在B之前，则A在B之前。

如果一个对象A和另一个对象B在同一个树内，且按照树形结构顺序A在B之后，则A在B之后。

一个对象的第一个孩子是其第一个孩子，或者，如果其没有孩子则为空。

一个对象的最后一个孩子是其最后一个孩子，或者，如果其没有孩子则为空。

一个对象的前一个兄弟是其第一个之前的兄弟，或者，如果其没有之前的兄弟则为空。

一个对象的后一个兄弟是其第一个之后的兄弟，或者，如果其没有之后的兄弟则为空。

一个对象的索引是其之前的兄弟的数目。

字符串

以区分大小写方式比较两个字符串，指逐码点地完全比较它们。

以ASCII码下不区分大小写方式比较两个字符串，指逐码点地完全比较它们，除了同样匹配在U+0041至U+005A范围内的字符（拉丁大写字母A至拉丁大写字母Z）及与之对应的U+0061至U+007A范围内的字符（拉丁小些字母A至拉丁小写字母Z）。

将一个字符串转换为ASCII大写形式指将所有U+0061至U+007A（拉丁小写字母A至拉丁小写字母Z）范围内的字符替换为对应的U+0041至U+005A（拉丁大写字母A至拉丁大写字母Z）范围内的字符。

将一个字符串转换为ASCII小些形式指将所有U+0041至U+005A（拉丁大写字母A至拉丁大写字母Z）范围内的字符替换为对应的U+0061至U+007A（拉丁小写字母A至拉丁小写字母Z）范围内的字符。

如果一个字符串模式不长于另一个字符串s，且将s截断为模式的长度会造出两个字符串向匹配，则模式为s的前缀匹配。

按照本规范的目的，空白字符为U+0020空格、U+0009制表符（tab）、U+000A换行（LF）、U+000C换页（FF）以及U+000D回车（CR）。

通用微语法

通用解析器习语

下面描述的一些微解析器遵循以input变量保存正在被解析的字符串、以position变量指出input中下一个被解析的字符的模式。

对于基于此模式的解析器，要求用户代理收集字符序列的步骤指必须执行下列算法，其中characters被设为可以被收集的字符：

1. 设input和position为与调用这些步骤的算法中的同名变量相同。
2. 设result为空字符串。
3. 若position没有指出input的结尾，且position处的字符为characters中的一个，则将该字符追加到result之后并将position推进至input中的下一个字符。
4. 返回result。

跳过空白步骤指用户代理必须收集一个字符序列，其为空白字符。不使用收集到的字符。

空格分隔的标记

一个空格分隔的标记集是一个包含零或多个单词（被认为是标记）、通过一个或多个空白字符分隔的字符串。其中的单词包括任意的一或多个字符的字符串，且其中没有空白字符。

一个包含空格分隔的标记集的字符串可能会拥有前导或尾随的空白字符。

一个无序、唯一、空格分隔的标记集是一个没有重复标记的空格分隔的标记集。

一个有序、唯一、空格分隔的标记集是一个没有重复标记但标记的顺序有意义的空格分隔的标记集。

如果用户代理需要按照空格分隔字符串，其必须使用下列算法：

1. 设input为将要被解析的字符串。
2. 设position为一个到input的指针，初始化时指向字符串的起始。
3. 设tokens为一个标记列表，初始化为空。
4. 跳过空白。
5. 若position没有通过input的结尾：
   1. 收集字符序列，其中不包含空白字符。
   2. 将上一步中收集的字符串加入tokens。
   3. 跳过空白。
6. 返回tokens。

如果用户代理需要从字符串移除一个标记，其必须使用下列算法：

1. 设input为将要被修改的字符串。
2. 设token为将要被移除的标记。其不能包含任意空白字符。
3. 设output为输出的字符串，初始化为空。
4. 设position为一个到input的指针，初始化时指向字符串的起始。
5. LOOP：如果position越过input的结尾，则终止这些步骤。
6. 如果position指向的字符是一个空白字符：
   1. 将position指向的字符追加到output的结尾。
   2. 将position推进至input中的下一个字符。
   3. 返回标为LOOP的步骤。
7. 否则，position指向的字符是一个标记的第一个字符。收集字符序列，其中不包含空白字符，并将其设为s。
8. 如果s完全等于token，则：
   1. 跳过空白（在input中）。
   2. 移除目前output结尾处的任意空白字符。
   3. 如果position没有超过input的结尾，且output不是空字符串，向output的结尾追加一个单独的U+0020空白字符。
9. 否则，向output的结尾追加s。
10. 返回标为LOOP的步骤。

命名空间

HTML命名空间为http://www.w3.org/1999/xhtml。

XML命名空间为http://www.w3.org/XML/1998/namespace。

XMLNS命名空间为http://www.w3.org/2000/xmlns/。

错误

DOMException异常

exception DOMException {
  const unsigned short INDEX_SIZE_ERR = 1;
  const unsigned short DOMSTRING_SIZE_ERR = 2; // 历史
  const unsigned short HIERARCHY_REQUEST_ERR = 3;
  const unsigned short WRONG_DOCUMENT_ERR = 4;
  const unsigned short INVALID_CHARACTER_ERR = 5;
  const unsigned short DO_DATA_ALLOWED_ERR = 6; // 历史
  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; // 历史
  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; // 历史
  const unsigned short TYPE_MISMATCH_ERR = 17;
  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;
};

code异常字段必须返回其初始化的值。在一个异常被创建时，其必须被初始化为零。

为了抛出一个type异常，必须执行下列步骤：

1. 创建一个新的DOMException异常，其类型为type。
2. 设其消息为用户代理定义的值。
3. 如果其类型在下表的第一列中，且在第三列中拥有一个相应的传统code异常字段值，则设其code异常字段为该值。
4. 抛出该异常。

DOMError接口

interface DOMError {
  readonly attribute DOMString name;
};

name属性必须返回其初始化的值。

一个type DOMError指一个name属性被初始化为type的DOMError对象。

事件

Event接口

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

  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;
};

事件允许发生某事的信号。例如，一个图片下载完成。其通过Event接口或继承自Event接口的其他接口表示。

type属性必须其预置的值。当创建一个事件时，该属性必须被预置为空字符串。

eventPhase属性必须返回其预置的值，其必须为下列之一：

• CAPTURING_PHASE（捕获阶段，数值1）
  • 若指派一个事件到一个参加一个树的对象，在其达到target属性的值之前，其处于此阶段。
• AT_TARGET（到达目标，数值2）
  • 若指派一个事件到其target属性的值，其处于此阶段。
• BUBBLING_PHASE（冒泡阶段，数值3）
  • 若指派一个事件到一个参加一个树的对象，在其达到target属性的值之后，其处于此阶段。

该属性必须首先被预置位AT_TARGET。

每个事件都拥有下列最初没有设置的相关标记：

• 停止扩展标记（stop propagation flag）
• 立即停止扩展标记（stop immediate propagation flag）
• 撤销标记（canceled flag）
• 预置标记（initialized flag）
• 指派标记（dispatch flag）

调用stopPropagation()方法时，必须设置停止扩展标记。

调用stopImmediatePropagation()方法时，必须设置停止扩展标记和立即停止扩展标记。

bubbles和cancelable属性必须返回它们各自预置的值。当创建一个事件时，这些属性必须被预置为假。

调用preventDefault()方法时，如果cancelable属性为真，则必须设置撤销标记。

如果设置了撤销标记，则defaultPrevented属性必须返回真，否则必须返回假。

isTrusted属性必须返回其预置的值。当创建一个事件时，该属性必须被预置为假。

timeStamp属性必须返回其预置的值。当创建一个事件时，该属性必须被预置为从1970年1月1日UTC时区下00:00:00至今所经过的毫秒数。

调用initEvent(type, bubbles, cancelable)方法时，必须执行下列步骤：

1. 设置initialized标记。
2. 如果设置了dispatch标记，则终止这些步骤。
3. 删除stop propagation标记、stop immediate propagation标记和canceled标记。
4. 设isTrusted属性为false。
5. 设target属性为null。
6. 设type属性为参数type。
7. 设bubbles属性为参数bubbles。
8. 设cancelable属性为参数cancelable。

CustomEvent接口

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

dictionary CustomEventInit : EventInit {
  any detail;
};

使用CustomEvent接口的事件可以被用于需要携带数据的合成事件。

detail属性必须返回其预置的值。在事件被创建时，该属性必须被预置为空。

构造事件

在调用Event接口或继承自Event接口的其他接口的构造器时，必须执行下列步骤：

1. 使用调用的构造器所属的接口创建一个事件。
2. 设置其预置标记。
3. 将type属性预置为type参数。
4. 如果存在一个eventInitDict参数，对其中定义的每个字典成员，查找事件中其标识符匹配该字典成员的键的属性，并将该属性设为该字典成员的值。
5. 返回该事件。

EventTarget接口

interface EventTarget {
  void addEventListener(DOMString type, EventListener? listener, optional boolean capture);
  void removeEventListener(DOMString type, EventListener? listener, optional boolean capture);
  boolean dispatchEvent(Event event);
};

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

EventTarget是用于在发生事情时指派事件的对象。每个EventTarget都有一个与之相关的事件侦听器列表。

事件侦听器是一个特殊事件的处理机。每个事件侦听器由（事件的）类型（type）、侦听器（listener）和捕获（capture）变量组成。

在调用addEventListener(type, listener, capture)方法时，必须执行下列步骤：

1. 如果listener为空，则终止这些步骤。
2. 如果capture被忽略，则设capture为假。
3. 如果与其相关的事件侦听器列表中没有一个拥有相同类型、侦听器和捕获的事件侦听器，则向其中追加一个事件侦听器，其类型为type、侦听器为listener、捕获为capture。

在调用removeEventListener(type, listener, capture)方法时，必须执行下列步骤：

1. 如果capture被忽略，则设capture为假。
2. 移除与其相关的事件侦听器列表中类型为type、侦听器为listener、捕获为capture的事件侦听器。

在调用dispatchEvent(event)方法时，必须执行下列步骤：

1. 如果event设置了指派标记，或者如果没有设置预置标记，则抛出一个“InvalidStateError”异常并终止这些步骤。
2. 将event的isTrusted属性预置为假。
3. 指派event并返回其所返回的值。

指派事件

为了在一个给出的对象上指派一个事件，需要执行下列步骤：

1. 设event为将要指派的事件。
2. 设置event的指派标记。
3. 将event的target属性预置为指派event的对象。
4. • 如果event的target属性参加一个树
     1. 设event path为event的target属性按照树形结构顺序的所有祖先的静态有序列表。
     2. 将event的eventPhase属性预置为CAPTURING_PHASE。
     3. 只要event没有设置停止扩展标记，则对于event path中的每个对象，使用事件event调用其事件侦听器。
     4. 将event的eventPhase属性预置为AT_TARGET。
     5. 如果event没有设置停止扩展标记，则使用事件event调用event的target属性的值的事件侦听器。
     6. 如果event的bubbles属性为真，则执行下列子步骤：
        1. 倒转event path的顺序。
        2. 将event的eventPhase属性预置为BUBBLING_PHASE。
        3. 只要event没有设置停止扩展标记，则对于event path中的每个对象，使用事件event调用其事件侦听器。
   • 否则
     • 使用事件event调用event的target属性的值的事件侦听器。
5. 移除event的指派标记。
6. 将event的eventPhase属性预置为AT_TARGET。
7. 将event的currentTarget预置为空。
8. 如果event设置了撤销标记，则返回假，否则返回真。

为了使用一个事件调用一个对象的事件侦听器，需要执行下列步骤：

1. 设event为调用事件侦听器的事件。
2. 设listeners为与这些步骤所执行的对象相关的事件侦听器的静态列表。
3. 将event的currentTarget预置为这些步骤所执行的对象。
4. 对于listeners中的每一个事件侦听器执行下列子步骤。
   1. 如果event标记了立即停止扩展标记，终止该调用算法。
   2. 设listener为该事件侦听器。
   3. 如果event的type属性不是listener的类型，终止这些子步骤（并且返回下一个事件侦听器）。
   4. 如果event的eventPhase属性为CAPTURING_PHASE且listener的捕获为假，终止这些子步骤（并且返回下一个事件侦听器）。
   5. 如果event的eventPhase属性为BUBBLING_PHASE且listener的捕获为真，终止这些子步骤（并且返回下一个事件侦听器）。
   6. 如果listener的侦听器为一个Function对象，其回调值为event的currentTarget属性值。
   7. 请求listener的侦听器，并使用本算法传入的事件作为第一个参数。

触发事件

触发名为e的事件指将一个事件指派到给出的对象，该事件使用Event接口、其type属性被预置为e、其isTrusted属性被预置为真。

节点

节点模型

实现了Document、DocumentFragment、DocumentType、Element、Text、ProcessingInstruction或Comment接口的对象（简单的称之为节点）参加一个树。

节点的树约束如下，表示节点的类型和起允许的孩子之间的关系：

• Document
  • 按照树形结构顺序：
    1. 零或多个ProcessingInstruction或Comment节点。
    2. 可选的一个DocumentType节点。
    3. 零或多个ProcessingInstruction或Comment节点。
    4. 可段的一个Element节点。
    5. 零或多个ProcessingInstruction或Comment节点。
• DocumentFragment
• Element
  • 零或多个Element、ProcessingInstruction、Comment或Text节点。
• DocumentType
• Text
• ProcessingInstruction
• Comment
  • 无。

改变

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

callback MutationCallback = void (MutationRecord[] mutations, MutationObserver observer);

dictionary MutationObserverInit {
  // 变化类型
  boolean childList;     // 如果为真，变化将影响节点的childNodes。
  boolean attributes;    // 如果为真，变化将影响元素的属性。
  boolean characterData; // 如果为真，变化将影响CharacterData节点的值
  // [注意：如果指定了未知的变化类型，则抛出一个错误]

  // 子树探测
  boolean subtree;  // 如果为真，则本登记的节点的探测集应包含MutationTarget的后裔（行为将在之后描述）。

  // 旧值
  boolean attributeOldValue;
  // 如果为真，MutationRecords描述的对属性的修改应该包含修改之前该属性的值。
  // 如果为真但没有属性：标记为真，抛出一个错误。

  boolean characterDataOldValue;
  // 如果为真，MutationRecords描述的对CharacterData节点的修改应该包含修改之前该节点的值。
  // 如果为真但没有characterData：为真，抛出一个错误。

  // 过滤器
  DOMString[] attributeFilter;
  // 如果提供了，则只有对那些localName等于提供的字符串之一的属性的修改才会被执行。
  // 如果提供了但没有属性：为真，抛出一个错误。
};

interface MutationRecord {
  // 变化类型：‘childList’、‘attributes’或‘characterData’之一
  readonly attribute DOMString type;

  // 对于childList和属性，target使其所属的被影响的节点。
  // 对于CharacterData，target为被影响的节点。
  readonly attribute Node target;

  // 对于变化类型为‘childList’的，为在此操作中添加或删除的节点的序列。
  readonly attribute NodeList addedNodes;
  readonly attribute NodeList removedNodes;

  // 对于变化类型为‘childList’的，为childNodes中紧跟着添加和/或删除的第一个和最后一个节点的兄弟。
  // and last nodes added and/or removed.
  readonly attribute Node previousSibling;
  readonly attribute Node nextSibling;

  // 对于变化类型为‘attribute’的，为被影响的属性的名称和namespaceURI
  readonly attribute DOMString attributeName;
  readonly attribute DOMString attributeNamespace;

  // 对于变化类型为‘attribute’或‘characterData’的，如果需要，为变化前的值。
  readonly attribute DOMString oldValue;
};

Node接口

interface Node : EventTarget {
  const unsigned short ELEMENT_NODE = 1;
  const unsigned short ATTRIBUTE_NODE = 2; // 历史遗留
  const unsigned short TEXT_NODE = 3;
  const unsigned short CDATA_SECTION_NODE = 4; // 历史遗留
  const unsigned short ENTITY_REFERENCE_NODE = 5; // 历史遗留
  const unsigned short ENTITY_NODE = 6; // 历史遗留
  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; // 历史遗留
  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;

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

           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);
  boolean isEqualNode(Node? node);

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

nodeType属性必须返回节点的类型，其必须为下列值之一：

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

nodeName属性必须根据其上下文对象返回下列值：

• Element
  • 其tagName属性的值。
• Text
  • “#text”。
• ProcessingInstruction
  • 其目标。
• Comment
  • “#comment”。
• Document
  • “#document”。
• DocumentType
  • 其名称。
• DocumentFragment
  • “#document-fragment”。

baseURI属性必须返回与其相关的基础URL。

ownerDocument属性必须执行下列步骤：

1. 如果其上下文对象是一个文档，则返回空并终止这些步骤。
2. 返回其节点文档。

parentNode属性必须返回其父亲。

parentElement属性必须返回其父元素。

hasChildNodes()方法，如果其上下文对象拥有孩子则必须返回真，否则必须返回假。

childNodes属性必须返回一个植根于其上下文对象、仅匹配其孩子的NodeList。

firstChild属性必须返回其第一个孩子。

lastChild属性必须返回其最后一个孩子。

previousSibling属性必须返回其前一个兄弟。

nextSibling属性必须返回其后一个兄弟。

以下为compareDocumentPosition()作为掩码返回的常量：

• DOCUMENT_POSITION_DISCONNECTED （1）；
• DOCUMENT_POSITION_PRECEDING （2）；
• DOCUMENT_POSITION_FOLLOWING （4）；
• DOCUMENT_POSITION_CONTAINS （8）；
• DOCUMENT_POSITION_CONTAINED_BY （16，十六进制中的10）。

compareDocumentPosition(other)方法必须执行下列步骤：

1. 设reference为其上下文对象。
2. 如果other和reference是同一个对象，则返回零，并终止这些步骤。
3. 如果other和reference不在同一个树中，则返回DOCUMENT_POSITION_DISCONNECTED，并终止这些步骤。
4. 如果other是reference的祖先，则返回DOCUMENT_POSITION_PRECEDING加DOCUMENT_POSITION_CONTAINS的结果，并终止这些步骤。
5. 如果other是reference的后裔，则返回DOCUMENT_POSITION_FOLLOWING加DOCUMENT_POSITION_CONTAINS_BY的结果，并终止这些步骤。
6. 如果other在reference的之前，则返回DOCUMENT_POSITION_PRECEDING，并终止这些步骤。
7. 返回DOCUMENT_POSITION_FOLLOWING，并终止这些步骤。

如果other是其上下文对象的一个包容性后裔，则contains(other)方法必须返回真，否则必须返回假。

nodeValue属性必须根据其上下文对象返回如下值：

• Text
• Comment
• ProcessingInstruction
  • 其上下文对象的数据。
• 任意其他节点
  • 空。

在设置nodeValue属性时，必须根据其上下文对象按照下列描述进行：

• Text
• Comment
• ProcessingInstruction
  • 以上下文对象为节点、0为偏移量、length属性的值为计数以及新值为数据，来替换数据。
• 任意其他节点
  • 无操作。

textContent属性必须根据其上下文对象返回如下值：

• DocumentFragment
• Element
  • 按照树形结构顺序连接所有上下文对象的Text节点后裔的数据。
• Text
• ProcessingInstruction
• Comment
  • 其上下文对象的数据。
• 任意其他节点
  • 空。

在设置textContent属性时，如果新值为空，则使用空字符串特带，并且必须根据其上下文对象按照下列描述进行：

• DocumentFragment
• Element
  1. 移除其上下文对象的所有后裔。
  2. 设data为新值。
  3. 如果data不是空字符串，则向其上下文对象追加一个其数据被设为data的Text节点。
• Text
• ProcessingInstruction
• Comment
  • 以上下文对象为节点、0为偏移量、length属性的值为计数以及新值为数据，来替换数据。
• 任意其他节点
  • 无操作。

将一个node预插入到一个parent之中的一个child之前，需要执行这些步骤：

1. 如果child不为空，且其父亲不是parent，则抛出一个“NotFoundError”异常，并终止这些步骤。
2. 如果node为parent或parent的祖先，则抛出一个“HierarchyRequestError”，并终止这些步骤。
3. 如果parent不是一个Document、DocumentFragment或Element节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
4. 如果parent是一个文档，则执行这些子步骤：
   1. 如果node不是一个DocumentFragment、DocumentType、Element、ProcessingInstruction或Comment节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
   2. 如果node是一个DocumentFragment节点，则执行下列内部子步骤：
      1. 如果node拥有超过一个元素作为其孩子或拥有一个Text节点作为其孩子，则抛出一个“HierarchyRequestError”，并终止这些步骤。
      2. 如果node拥有一个元素作为其孩子，并且parent拥有一个元素作为其孩子或者child不为空且有一个DOCTYPE在child之后，则抛出一个“HierarchyRequestError”，并终止这些步骤。
   3. 如果node是一个元素，并且parent拥有一个元素作为其孩子或者child不为空且有一个DOCTYPE在child之后，则抛出一个“HierarchyRequestError”，并终止这些步骤。
   4. 如果node是一个DOCTYPE，并且parent拥有一个DOCTYPE作为其孩子、一个元素在child之前、或者child为空且parent拥有一个元素作为其孩子，则抛出一个“HierarchyRequestError”，并终止这些步骤。
5. 或者，如果parent是一个DocumentFragment或Element节点且node不是一个DocumentFragment、Element、Text、ProcessingInstruction或Comment节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
6. 将node过继到parent的节点文档。
7. 将node插入到parent中child之前。
8. 返回child。

将一个node插入到一个parent之中的一个child之前，需要执行这些步骤：

1. 如果node是一个DocumentFragment节点，则设count为node的孩子的数目，否则设为一。
2. 对于每个起始节点为parent且起始偏移量大于child的索引的排列，将其起始偏移量增加count。
3. 对于每个结尾节点为parent且结尾偏移量大于child的索引的排列，将其结尾偏移量增加count。
4. 如果node是一个DocumentFragment节点，将其孩子（保持树形结构顺序）插入到child之前，或者如果child为空则插入到parent的结尾之前。
5. 否则，将node插入到child之前，或者如果child为空则插入到parent的结尾之前。

insertBefore(node, child)方法必须将node预插入到其上下文对象之中child之前。

将一个node追加到一个parent之中，即将node预插入到parent之中空之前。

appendChild(node)方法必须将node追加到其上下文对象之中。

用node替换一个在parent之中的child，需要执行这些步骤：

1. 如果child的父亲不是parent，则抛出一个“NotFoundError”异常，并终止这些步骤。
2. 如果node为parent或parent的祖先，则抛出一个“HierarchyRequestError”，并终止这些步骤。
3. 如果parent不是一个Document、DocumentFragment或Element节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
4. 如果parent是一个文档，则执行这些子步骤：
   1. 如果node不是一个DocumentFragment、DocumentType、Element、ProcessingInstruction或Comment节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
   2. 如果node是一个DocumentFragment节点，则执行下列内部子步骤：
      1. 如果node拥有超过一个元素作为其孩子或拥有一个Text节点作为其孩子，则抛出一个“HierarchyRequestError”，并终止这些步骤。
      2. 如果node拥有一个元素作为其孩子，并且parent拥有一个并非child的元素作为其孩子或者有一个DOCTYPE在child之后，则抛出一个“HierarchyRequestError”，并终止这些步骤。
   3. 如果node是一个元素，并且parent拥有一个并非child的元素作为其孩子或者有一个DOCTYPE在child之后，则抛出一个“HierarchyRequestError”，并终止这些步骤。
   4. 如果node是一个DOCTYPE，并且parent拥有一个并非child的DOCTYPE作为其孩子或者有一个元素在child之前，则抛出一个“HierarchyRequestError”，并终止这些步骤。
5. 或者，如果parent是一个DocumentFragment或Element节点且node不是一个DocumentFragment、Element、Text、ProcessingInstruction或Comment节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
6. 将node过继到parent的节点文档。
7. 设reference child为child的下一个兄弟。
8. 从parent中移除child。
9. 将node插入到parent中reference child之前。
10. 返回child。

replaceChild(node, child)方法必须用node替换一个在上下文对象中的child。

将一个node从一个parent中预移除，需要执行这些步骤：

1. 如果child的父亲不是parent，则抛出一个“NotFoundError”异常，并终止这些步骤。
2. 从parent中移除child。
3. 返回child。

将一个node从一个parent中移除，需要执行这些步骤：

1. 设index为node的索引。
2. 对于每个起始节点为parent的后裔的排列，将其起始设为(parent, index)。
3. 对于每个结尾节点为parent的后裔的排列，将其结尾设为(parent, index)。
4. 对于每个起始节点为parent且起始偏移量大于index的排列，将其起始偏移量减去一。
5. 对于每个结尾节点为parent且结尾偏移量大于index的排列，将其结尾偏移量减去一。
6. 从parent中移除node。

removeChild(child)方法必须将child从其上下文对象中预移除。

normalize()方法必须执行这些步骤：

1. 对于每个上下文对象的Text节点后裔：
   1. 设node为该Text节点后裔。
   2. 设data为树形结构顺序中node的邻近Text节点（除去其自身）的数据的连接。
   3. 以node为节点、node的langth属性的值为偏移量、0为计数以及data为数据，来替换数据。
   4. 在树形结构顺序中，移除node的邻近Text节点（除去其自身）。

规范可能会为所有或部分节点定义其复制步骤。

为了复制一个node，可选地附加一个document、ownerDocument和一个clone children flag，需要执行这些步骤：

1. 如果没有给出document，则设ownerDocument为node的节点文档。
2. 设copy为一个实现了和node相同的接口的节点。
3. 如果copy是一个对象，则设其节点文档为空，设ownerDocument为copy。

   否则，设copy的节点文档为ownerDocument。

4. 根据node的类型，复制下列内容：
   • Element
     • 其命名空间、命名空间前缀、本地名称及其属性列表。
   • DocumentType
     • 其名称、公开ID和系统ID。
   • ProcessingInstruction
     • 其目标和数据。
   • Text
   • Comment
     • 其数据。
   • 任意其他节点
     • -
5. 执行其他合适的规范中为node定义的任意复制步骤。
6. 如果设置了clone children flag，复制所有node的孩子，并将其追加到copy之中，其中标记了ownerDocument和clone children flag。
7. 返回copy。

cloneNode(deep)方法必须返回一个其上下文对象的副本，其中如果deep为真或被忽略则设置clone children flag。

如果所有下列约束都为真，则isEqualNode(node)方法必须返回真，否则必须返回假：

• node非空。
• node的nodeType属性的值与其上下文对象的nodeType属性的值相同。
• 根据node，下列内容也相同：
  • DocumentType
    • 其名称、公开ID和系统ID。
  • Element
    • 其命名空间、命名空间前缀、本地名称及其属性列表中属性的数目。
  • ProcessingInstruction
    • 其目标和数据。
  • Text
  • Comment
    • 其数据。
  • 任意其他节点
    • -
• 如果node是一个Element，对于其属性列表中的每个属性，在上下文对象的属性列表中都存在一个拥有与其相同的命名空间、本地名称和值的属性。
• node拥有与上下文对象相同的孩子数目。
• 上下文对象中的每个孩子，使用node中拥有相同索引的孩子作为参数调用isEqualNode()均返回真。

使用namespace对一个element查找其命名空间前缀，需要执行这些步骤：

1. 如果element的命名空间为namespace，且其命名空间前缀不为空，则返回其命名空间前缀并终止这些步骤。
2. 如果element拥有一个命名空间前缀为“xmlns”且值为namespace的属性，则返回该属性的本地名称并终止这些步骤。
3. 如果element的父元素不为空，则返回在该元素上使用namespace执行查找其命名空间前缀的结果。否则，返回空。

对用prefix对一个node查找其命名空间，由其node决定：

• Element
  1. 如果其命名空间不为空，且其命名空间前缀为prefix，则返回命名空间并终止这些步骤。
  2. 如果其拥有一个命名空间前缀为“xmlns”且本地名称为prefix的属性，或拥有一个命名空间前缀为空且本地名称为“xmlns”的属性：
     1. 如果其值不是空字符串，则设value为其值，否则为空。
     2. 返回value并终止这些步骤。
  3. 如果其父元素为空，则返回空并终止这些步骤。
  4. 返回使用prefix对其父元素查找其命名空间的结果。
• Document
  1. 如果其文档元素为空，则返回空并终止这些步骤。
  2. 返回使用prefix对其文档元素查找其命名空间的结果。
• DocumentType
• DocumentFragment
  • 返回空
• 任意其他节点
  1. 如果其父元素为空，则返回空并终止这些步骤。
  2. 返回使用prefix对其父节点查找其命名空间的结果。

lookupPrefix(namespace)方法必须执行这些步骤：

1. 如果namespace为空或空字符串，返回空。
2. 否则，取决于其上下文对象：
   • Element
     • 返回使用namespace对该节点查找其命名空间前缀的结果。
   • Document
     • 如果其文档元素不为空，则返回对其查找命名空间前缀的结果，否则返回空。
   • DocumentType
   • DocumentFragment
     • 返回空。
   • 任意其他节点
     • 如果其父元素不为空，则返回对其查找命名空间前缀的结果，否则返回空。

lookupNamespaceURI(prefix)方法必须执行这些步骤：

1. 如果prefix为空字符串，设其为空。
2. 返回使用prefix对其上下文对象执行查找命名空间的结果。

isDefaultNamespace(namespace)方法必须执行这些步骤：

1. 如果namespace为空字符串，设其为空。
2. 设defaultNamespace为使用空对其上下文对象执行查找命名空间的结果。
3. 如果defaultNamespace与namespace相同，则返回真，否则返回假。

一个节点root的本地名称为localName的元素的列表为下列算法返回的NodeList：

1. 如果localName为“*”（U+002A），则返回一个植根于root、过滤器仅匹配元素的NodeList。
2. 否则，如果root的节点文档是一个HTML文档，则返回一个植根于root、过滤器仅匹配下列节点的NodeList：
   • HTML命名空间中，其本地名称为转换成ASCII小写形式的localName的元素。
   • 不再HTML命名空间中，其本地名称为localName的元素。
3. 否则，返回一个植根于root、过滤器仅匹配本地名称为localName的元素的NodeList。

如果使用相同的参数在此调用，则可能会返回与早前调所返回的相同的NodeList对象。

一个节点root的命名空间为namespace且本地名称为localName的元素的列表为下列算法返回的NodeList：

1. 如果namespace为空字符串，设其为空。
2. 如果namespace和localName均为“*”（U+002A），则返回一个植根于root、过滤器仅匹配元素的NodeList。
3. 否则，如果仅namespace为“*”（U+002A），则返回一个植根于root、过滤器仅匹配本地名称为localName的元素的NodeList。
4. 否则，如果仅localName为“*”（U+002A），则返回一个植根于root、过滤器仅匹配命名空间为namespace的元素的NodeList。
5. 否则，返回一个植根于root、过滤器仅匹配本地名称为localName且命名空间为namespace的元素的NodeList。

如果使用相同的参数在此调用，则可能会返回与早前调所返回的相同的NodeList对象。

一个节点root的类名称为classNames的元素的列表为下列算法返回的NodeList：

1. 设classes为用空格分隔classNames所发现的标记集。（忽略重复。）
2. 如果classes为空集，则返回一个空的NodeList并终止这些步骤。
3. 返回一个植根于root、过滤器仅匹配拥有所有classes中类的元素的NodeList。

   如果root的节点文档处于怪癖模式，则对类的比较必须按照ASCII不区分大小写的方式进行，否则，比较必须按照区分大小写的方式进行。

如果使用相同的参数在此调用，则可能会返回与早前调所返回的相同的NodeList对象。

Document接口

interface Document : Node {
  readonly attribute DOMImplementation implementation;
  readonly attribute DOMString URL;
  readonly attribute DOMString documentURI;
  readonly attribute DOMString compatMode;

           attribute DOMString charset;
  readonly attribute DOMString characterSet;
  readonly attribute DOMString defaultCharset;
  readonly attribute DOMString contentType;

  readonly attribute DocumentType? doctype;
  readonly attribute Element? documentElement;
  NodeList getElementsByTagName(DOMString qualifiedName);
  NodeList getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  NodeList 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);
  Node adoptNode(Node node);

  Event createEvent(DOMString eventInterfaceName);

  Range createRange();

  NodeIterator createNodeIterator(Node root, optional unsigned long whatToShow, optional NodeFilter? filter);
  TreeWalker createTreeWalker(Node root, optional unsigned long whatToShow, optional NodeFilter? filter);

  // 新特性
  void prepend(Node | DOMString... nodes);
  void append(Node | DOMString... nodes);
};

interface XMLDocument : Document {};

Document节点简单地被认为是文档。

每个文档都有与其相关的字符编码、媒体类型和URL。

如果在创建一个文档时没有显式地给出，其字符编码为“UTF-8”、其媒体类型为“application/xml”、其URL为“about:blank”。

如果没有将一个文档标记为HTML文档，则假定其为XML文档。一个文档是HTML文档还是XML文档将会影响某些API的行为。

一个文档总会被设为下列三个模式之一：默认的非怪癖模式；用于标记传统文档的怪癖模式；以及被认为“几近标准”的限定怪癖模式。除非其他适用的规范定义，否则，一个文档必须处于非怪癖模式。

implementation属性必须返回与该文档相关的DOMImplementation对象。

URL和documentURI属性必须返回URL。

对于compatMode IDL属性，如果其上下文对象并非处于怪癖模式，则必须返回字符串常量“CSS1Compat”，否则必须返回字符串常量“BackCompat”。

charset属性必须返回其字符编码的首选MIME名称。

设置charset属性时，如果新值是一个用户代理所支持的字符编码的IANA注册的别名，必须将字符编码设为该新值。（否则，不进行操作。）

characterSet属性必须返回其字符编码的首选MIME名称。

defaultCharset属性必须返回其字符编码的首选MIME名称，有可能是用户的默认字符编码、与当前用户地理位置相关的字符编码或者任意字符编码名。

contentType属性必须返回其媒体类型。

doctype属性必须返回文档的一个为DOCTYPE的孩子，否则返回空。

documentElement属性必须返回其文档元素。

getElementsByTagName(localName)方法必须返回上下文对象的本地名称为localName的元素的列表。

getElementsByTagNameNS(namespace, localName)方法必须返回上下文对象的命名空间为namespace且本地名称为localName的元素的列表。

getElementsByClassName(classNames)方法必须返回上下文对象的类名为classNames的元素的列表。

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

getElementById(elementId)方法必须返回按照树形结构顺序上下文对象中第一个ID为elementId的元素，或者如果不存在则返回空。

createElement(localName)方法必须执行这些步骤：

1. 如果localName不匹配产生的Name，则抛出一个“InvalidCharacterError”异常并终止这些步骤。
2. 如果其上下文对象是一个HTML文档，设localName为其转换为ASCII小写形式。
3. 返回一个新的元素，其没有属性、命名空间被设为HTML命名空间、本地名称被设为localName、节点文档被设为上下文对象。

createElementNS(namespace, qualifiedName)方法必须执行这些步骤：

1. 如果namespace为空字符串，设其为空。
2. 如果qualifiedName不匹配产生的Name，则抛出一个“InvalidCharacterError”异常并终止这些步骤。
3. 如果qualifiedName不匹配产生的QName，则抛出一个“NamespaceError”异常并终止这些步骤。
4. 如果qualifiedName包含一个“:”（U+003E），则用其分隔字符串，并设prefix为前一部分、localName为后一部分。否则，设prefix为空、localName为qualifiedName。
5. 如果prefix不为空且namespace为空，则抛出一个“NamespaceError”异常并终止这些步骤。
6. 如果prefix为“xml”且namespace不为XML命名空间，则抛出一个“NamespaceError”异常并终止这些步骤。
7. 如果qualifiedName或prefix为“xmlns”且namespace不为XMLNS命名空间，则抛出一个“NamespaceError”异常并终止这些步骤。
8. 如果namespace为XMLNS命名空间且qualifiedName和prefix均不为“xmlns”，则抛出一个“NamespaceError”异常并终止这些步骤。
9. 返回一个新的元素，其没有属性、命名空间被设为namespace、命名空间前缀被设为prefix、本地名称被设为localName、节点文档被设为上下文对象。

createDocumentFragment()方法必须返回一个新的DocumentFragment节点，其节点文档被设为上下文对象。

createTextNode(data)方法必须返回一个新的Text节点，其数据被设为data、节点文档被设为上下文对象。

createComment(data)方法必须返回一个新的Comment节点，其数据被设为data、节点文档被设为上下文对象。

createProcessingInstruction(target, data)方法必须执行这些步骤：

1. 如果target不匹配产生的Name，则抛出一个“InvalidCharacterError”异常并终止这些步骤。
2. 如果data包含字符串“?>”，则抛出一个“InvalidCharacterError”异常并终止这些步骤。
3. 返回一个新的ProcessingInstruction节点，其目标被设为target、数据被设为data、节点文档被设为上下文对象。

importNode(node, deep)方法必须执行这些步骤：

1. 如果node是一个文档，则抛出一个“NotSupportedError”异常并终止这些步骤。
2. 返回一个node的副本，其中document为上下文对象且如果deep为真或被忽略则标记clone children flag。

过继一个node，附带一个ownerDocument，需要执行这些步骤：

1. 如果node是一个元素，其受到了基本URL修改的影响。
2. 如果node的父亲不为空，则从其父亲处移除node。
3. 设node以及所有其后裔的节点文档为ownerDocument。

adoptNode(node)方法必须执行这些步骤：

1. 如果node是一个文档，则抛出一个“NotSupportedError”异常并终止这些步骤。
2. 过继node，附带上下文对象，并返回其。

当调用createEvent(eventInterfaceName)方法时，必须执行这些步骤：

1. 如果eventInterfaceName能够ASCII不区分大小写地匹配下表中第一列的任意字符串，设eventInterfaceName为与匹配的字符串同行的第二列内的字符串。
2. 如果eventInterfaceName'不能ASCII不区分大小写地匹配“event”或者一个继承自Event接口且被用户代理所支持的接口的名称，则抛出一个“NotSupportedError”并终止这些步骤。
3. 创建一个实现了名称ASCII不区分大小写地匹配eventInterfaceName的接口的事件，并返回该事件。

createRange()方法必须返回一个新的排列，其中(上下文对象, 0)为其起始和结束。

当调用createNodeIterator(root, whatToShow, filtre)方法时，必须执行这些步骤：

1. 创建一个NodeIterator对象。
2. 设置根并预置referenceNode属性为root参数。
3. 设置要展示的内容为whatToShow参数，如果该参数被忽略，则设为SHOW_ALL。
4. 设置过滤器为filter参数，如果该参数被忽略，则设为空。
5. 返回新创建的NodeIterator对象。

当调用createTreeWalker(root, whatToShow, filter)方法时，必须执行这些步骤：

1. 创建一个TreeWalker对象。
2. 设置根并预置currentNode属性为root参数。
3. 设置要展示的内容为whatToShow参数，如果该参数被忽略，则设为SHOW_ALL。
4. 设置过滤器为filter参数，如果该参数被忽略，则设为空。
5. 返回新创建的TreeWalker对象。

DOMImplementation接口

当用户代理创建一个文档时，必须同时创建一个DOMImplementation对象，并将其与该文档向关联。

interface DOMImplementation {
  boolean hasFeature(DOMString feature, [TreatNullAs=EmptyString] DOMString version);

  DocumentType createDocumentType(DOMString qualifiedName, DOMString publicId, DOMString systemId);
  XMLDocument createDocument(DOMString? namespace, DOMString qualifiedName, DocumentType? doctype);
  Document createHTMLDocument(DOMString title);
};

hasFeature(feature, version)方法，如果用户代理支持（feature, version）元素，则必须返回真，否则必须返回假。

createDocumentType(qualifiedName, publicId, systemId)方便必须执行这些步骤：

1. 如果qualifiedName不匹配产生的Name，将抛出一个“InvalidCharacterError”异常并终止这些步骤。
2. 如果qualifiedName不匹配产生的QName，将抛出一个“NamespaceError”异常并终止这些步骤。
3. 返回一个新的DOCTYPE，其名称为qualifiedName、公开ID为publicId、系统ID为systemId，且其节点文档被设为与上下文对象相关联的文档。

createDocument(namespace, qualifiedName, doctype)方法必须执行这些步骤：

1. 设document为一个新的XMLDocument。
   注：该方法创建一个XMLDocument而不是一个普通的文档。它们除了增加了部署内容依赖的load()方法之外是相同的。
2. 设element为空。
3. 如果qualifiedName不是空字符串，则设element为使用参数namespace和qualifiedName在document上调用createElementNS()方法的结果。如果其抛出一个异常，则重新抛出该异常并终止这些步骤。
4. 如果doctype不为空，则将doctype追加到document中。
5. 如果element不为空，则将element追加到document中。
6. 返回document。

createHTMLDocument(title)方法必须执行这些步骤：

1. 设doc为一个新创建的文档。
2. 将doc标为一个HTML文档。
3. 将doc的媒体类型设为“text/html”。
4. 创建一个DOCTYPE，其名称为“html”，其节点文档被设为doc。将新创建的节点追加到doc中。
5. 在HTML命名空间中，创建一个html元素，将其追加到doc中。
6. 在HTML命名空间中，创建一个head元素，将其追加到上一步中创建的html元素中。
7. 在HTML命名空间中，创建一个title元素，将其追加到上一步中创建的head元素中。
8. 创建一个Text节点，将其数据设为title（可能为空字符串），将其追加到上一步中创建的title元素中。
9. 在HTML命名空间中，创建一个body元素，将其追加到更早步骤中创建的html元素中。
10. 返回doc。

DocumentFragment接口

interface DocumentFragment : Node {
  // 新特性
  void prepend(Node | DOMString... nodes);
  void append(Node | DOMString... nodes);
};

DocumentType接口

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

  // 新特性
  void before(Node | DOMString... nodes);
  void after(Node | DOMString... nodes);
  void replace(Node | DOMString... nodes);
  void remove();
};

DocumentType节点被认为是DOCTYPE。

DOCTYPE拥有与其相关联的名称、公开ID、系统ID。

当创建一个DOCTYPE时，总是需要给出其名称。当创建一个DOCTYPE时，如果没有特别给出，其公开ID和系统ID为空字符串。

name属性必须返回名称。

publicId属性必须返回公开ID。

systemId属性必须返回系统ID。

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

  NodeList getElementsByTagName(DOMString qualifiedName);
  NodeList getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  NodeList 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;

  // 新特性
  void prepend(Node | DOMString... nodes);
  void append(Node | DOMString... nodes);
  void before(Node | DOMString... nodes);
  void after(Node | DOMString... nodes);
  void replace(Node | DOMString... nodes);
  void remove();
};

Element节点被认为是元素。

元素拥有与其相关的命名空间、命名空间前缀和本地名称。当创建一个元素时，总是需要给出其本地名称。当创建一个元素时，如果没有特别给出，其命名空间和命名空间前缀为空。

元素还拥有一个有序的属性列表。当创建一个元素时，如果没有特别给出，其属性列表为空。如果一个属性A在一个元素的属性列表中，则称该元素拥有属性A。

元素可以拥有一个与其相关的唯一标识符（ID）和类。

如果一个元素拥有一个其值不为空字符串的id属性，则称该元素拥有一个ID。该ID是该属性的值。

如果一个元素拥有一个将其值进行分割的结果不是空列表的class属性，则称该元素拥有一个类。该类是该属性的值按空格分割。

一个节点的类型为Element的父亲被认为是一个父元素。如果该节点拥有一个不同类型的父亲，则其父元素为空。

一个文档的文档元素为父亲为该文档的元素，如果存在，否则为空。

若一个元素或一个其祖先是文档元素，则其在文档中。

规范可能会定义基本URL更改步骤。

若一个元素受基本URL更改的影响，则用户代理必须执行在其他适用的规范中定义的基本URL更改步骤。

namespaceURI属性必须返回其上下文对象的命名空间。

prefix属性必须返回其上下文对象的命名空间前缀。

localName属性必须返回其上下文对象的本地名称。

tagName属性必须执行这些步骤：

1. 如果上下文对象的命名空间前缀不为空，则设qualified name为其命名空间前缀，其后跟随一个“:”（U+003A）和其本地名称。否则，设qualified name为其本地名称。
2. 如果上下文对象在HTML命名空间下，且其节点文档是一个HTML文档，则将qualified name转换为大写形式。
3. 返回qualified name。

某些IDL属性被定义为反映特定的内容属性。这意味着，在获取时，必须执行下列步骤：

1. 设value为使用内容属性的名字作为参数调用getAttribute()方法所返回的结果。
2. 如果value为空，返回空字符串并终止这些步骤。
3. 返回value。

在设置时，用户代理必须使用内容属性的名称及新值作为参数调用setAttribute()。

id属性必须反映“id”内容属性。

className属性必须反映“class”内容属性。

classList属性必须返回一个基础字符串为其className属性值的DOMTokenList。

attributes属性必须返回一个与其上下文对象相关的属性属性的只读数组。返回的只读数组必须是实时的。例如，需要反映对与其相关的属性的修改。

getAttribute(name)方法必须执行这些步骤：

1. 如果上下文对象在HTML命名空间下且其节点对象是一个HTML文档，则将name转换为ASCII小写形式。
2. 返回其上下文对象的attributes中限定名为name的第一个属性的值，否则返回空。

getAttributeNS(namespace, localName)方法必须执行下列步骤：

1. 如果namespace为空字符，则设其为null。
2. 返回上下文对象的属性列表中，命名空间为namespace且本地名称为localName的属性的值。如果没有这样的属性则返回null。

setAttribute(qualifiedName, value)方法必须执行这些步骤：

1. 如果name不匹配XML产生的Name，则抛出一个"INVALID_CHARACTER_ERR"异常，并终止这些步骤。
2. 如果上下文对象处于HTML命名空间，且其节点文档是一个HTML文档，则将name转换为ASCII小写形式。
3. 设上下文对象的属性列表中第一个名称为name的属性为属性，如果没有这样的属性，则设属性null。
4. 如果属性为null，则创建一个名为name、值为value的属性，并将该属性追加到上下文对象上，并终止这些步骤。
5. 排入一个"attributes"记录，其目标为上下文对象，名称为属性的本地名称，命名空间为属性的命名空间，旧值为属性的值。
6. 设属性的值为value。

setAttributeNS(namespace, qualifiedName, value)方法必须执行这些步骤：

1. 如果namespace为空字符串，则设其为null。
2. 如果name不匹配XML中产生的[[1]]，则抛出一个"InvalidCharacterError"异常并终止这些步骤。
3. 如果name不匹配XML中命名空间产生的[[2]]，则抛出一个"NamespaceError"异常并终止这些步骤。
4. 如果name包含一个U+003E冒号（:）字符，则分隔字符串，并设前缀为前一部分，设本地名称为后一部分。否则设前缀为null，设本地名称为name。
5. 如果前缀不为null，且namespace为null，则抛出一个"NamespaceError"异常并终止这些步骤。
6. 如果前缀为“xml”，且namespace不是XML命名空间，则抛出一个"NamespaceError"异常并终止这些步骤。
7. 如果name或前缀为“xmlns”，且namespace不是XMLNS命名空间，则抛出一个"NamespaceError"异常并终止这些步骤。
8. 如果namespace是XMLNS命名空间，且name和前缀均不为"xmlns"，则抛出一个"NamespaceError"异常并终止这些步骤。
9. 设属性为上下文对象的属性列表中第一个命名空间为namespace且本地名称为本地名称的属性，否则，如果没有这样的属性，则设为null。
10. 如果属性为null，则创建一个属性，其名称为name、命名空间为namespace、命名空间前缀为前缀、本地名称为本地名称、值为value，并将其追加到上下文对象的属性之中，并终止这些步骤。
11. 排入一个"attributes"记录，其目标为上下文对象、名称为本地名称、命名空间为namespace、旧值为属性的值。
12. 设属性的值为value。

removeAttribute(qualifiedName)方法必须执行这些步骤：

1. 如果上下文对象在HTML命名空间下，且其节点文档是一个HTML文档，则将qualifiedName转换为ASCII小写形式。
2. 移除上下文对象的attributes中第一个限定名为qualifiedName的属性。

removeAttributeNS(namespace, localName)方法必须执行这些步骤：

1. 如果namespace为空字符串，设其为空。
2. 移除上下文对象的attributes中命名空间为namespace且本地名称为localName的属性，如果存在。

hasAttribute(qualifiedName)方法必须执行这些步骤：

1. 如果上下文对象在HTML命名空间下，且其节点文档是一个HTML文档，则将qualifiedName转换为ASCII小写形式。
2. 如果上下文对象的attributes中包含一个限定名为qualifiedName的属性则返回真，否则返回假。

hasAttributeNS(namespace, localName)方法必须执行下列步骤：

1. 如果namespace为空字符串，设其为空。
2. 如果上下文对象的attributes中包含一个命名空间为namespace且本地名称为localName的属性则返回真，否则返回假。

当调用getElementsByTagName(qualifiedName)方法时，必须返回一个NodeList，其元素为在上下文对象的节点文档上通过传递相同参数调用getElementsByTagName()方法所返回的，除去任意不是调用该方法的上下文对象的后裔的元素。

当使用相同参数效用时，可能会返回与早前的调用所返回的相同的NodeList对象。

当调用getElementsByTagNameNS(namespace, localName)方法时，必须返回一个NodeList，其元素为在上下文对象的节点文档上通过传递相同参数调用getElementsByTagNameNS()方法所返回的，除去任意不是调用该方法的上下文对象的后裔的元素。

当使用相同参数效用时，可能会返回与早前的调用所返回的相同的NodeList对象。

当调用getElementsByClassName(classNames)方法时，必须返回一个NodeList，其元素为在上下文对象的节点文档上通过传递相同参数调用getElementsByClassName()方法所返回的，除去任意不是调用该方法的上下文对象的后裔的元素。

当使用相同参数效用时，可能会返回与早前的调用所返回的相同的NodeList对象。

children属性必须返回一个植根于上下文对象仅匹配元素孩子的HTMLCollection集合。

firstElementChild属性必须返回第一个是元素的孩子，否则必须返回空。

lastElementChild属性必须返回最后一个是元素的孩子，否则必须返回空。

previousElementSibling属性必须返回第一个是元素的之前的兄弟，否则必须返回空。

nextElementSibling属性必须返回第一个是元素的之后的兄弟，否则必须返回空。

childElementCount属性必须返回上下文对象中是元素的孩子数目。

Attr接口

interface Attr {
  readonly attribute DOMString? namespaceURI;
  readonly attribute DOMString? prefix;
  readonly attribute DOMString localName;
  readonly attribute DOMString name;
           attribute DOMString value;
};

Attr对象被认为是属性。

与元素类似，属性拥有与其相关的命名空间、命名空间前缀、本地名称和限定名。

在一个属性被创建时，总是给出其本地名称。在一个属性被创建时如果没有明确地给出，其命名空间和命名空间前缀为空。

如果一个属性的命名空间前缀不为空，则其限定名被定义为其命名空间前缀，其后跟随一个“:”（U+003A）和且本地名称。

属性还有一个与其相关的值，其总是在创建属性时给出。

namespaceURI属性必须返回其命名空间。

prefix属性必须返回其命名空间前缀。

localName属性必须返回其本地名称。

name属性必须返回其限定名。

value属性必须返回其值。

设置value属性必须将其值设为新值。

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

  // 新特性
  void before(Node | DOMString... nodes);
  void after(Node | DOMString... nodes);
  void replace(Node | DOMString... nodes);
  void remove();
};

每个实现了CharacterData接口的节点都有一个与其相关联的名为数据的可变字符串。

为了对节点node使用偏移量offset、计数count和数据data替换其数据，需要执行这些步骤：

1. 设length为node的length属性值。
2. 如果offset大于length，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
3. 如果offset加上count大于length，则设count为length减去offset。
4. 将data插入到node的数据中第offset个编码单元之后。
5. 设delete offset为offset加上data中的编码单元数的值。
6. 从第delete offset个编码单元开始，从node的数据中移除count个编码单元。
7. 对于每个起始节点为node且起始偏移量大于offset但小于等于offset加上count的排列，设其起始偏移量为offset。
8. 对于每个结束节点为node且结束偏移量大于offset但小于等于offset加上count的排列，设其结束偏移量为offset。
9. 对于每个起始节点为node且起始偏移量大于offset加上count的排列，将其起始偏移量增加data中的编码单元数，之后再减少count。
10. 对于每个结束节点为node且结束偏移量大于offset加上count的排列，将其结束偏移量增加data中的编码单元数，之后再减少count。

为了对节点node使用偏移量offset和计数count取其数据的子串，需要执行这些步骤：

1. 设length为node的length属性值。
2. 如果offset大于length，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
3. 如果offset加上count大于length，则返回一个值为node的数据中从第offset个编码单元到其结尾的编码单元的字符串，并终止这些步骤。
4. 返回一个值为node的数据中从第offset个编码单元到第offset+count个编码单元的编码单元的字符串。

data属性必须返回数据，在设置时，必须使用节点上下文对象、偏移量0、计数length属性值和数据新值替换数据。

length属性必须返回数据中的编码单元数。

substringData(offset, count)方法必须使用节点上下文对象、偏移量offset和计数count取数据的子串。

appendData(data)方法必须使用节点上下文对象、偏移量length属性值、计数0和数据data替换数据。

insertData(offset, data)方法必须使用节点上下文对象、偏移量offset、计数0和数据data替换数据。

deleteData(offset,count)方法必须使用节点上下文对象、偏移量offset、计数count和数据空字符串替换数据。

replaceData(offset, count, data)方法必须使用节点上下文对象、偏移量offset、计数count和数据data替换数据。

Text接口

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

为了使用偏移量offset分离一个Text节点node，需要执行这些步骤：

1. 设length为其length属性值。
2. 如果offset大于length，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
3. 设count为length减去offset。
4. 设new data为使用节点node、偏移量offset和计数count取其数据的子串。
5. 使用节点node、偏移量offset、计数count和数据空字符串替换其数据。
6. 设new node为一个新的Text节点，其节点文档与node相同。设new node的数据为new data。
7. 设parent为node的父亲。
8. 如果parent为空，执行这些子步骤：
   1. 对于每个起始节点为node、起始偏移量大于等于offset且结束偏移量大于offset的排列，将其起始节点和结束节点设为new node并将其起始偏移量和结束偏移量减去offset。
   2. 对于每个结束节点为node且结束偏移量大于offset的排列，设其结束偏移量为offset。
   3. 返回new node并终止这些步骤。
9. 对于每个起始节点为node且起始偏移量大于offset的排列，设其起始偏移量为new node并将其起始偏移量减去offset。
10. 对于每个结束节点为node且结束偏移量大于offset的排列，设其结束节点为new node并将其结束偏移量减去offset。
11. 将new data插入到parent node中node的下一个兄弟之前。
12. 返回new node。

splitText(offset)方法必须使用偏移量offset分离其上下文对象。

一个节点邻近Text节点，在避免重复的情况下，为该节点本身、其前一个兄弟Text节点（如果存在）及邻近Text节点、其后一个兄弟Text节点（如果存在）及邻近Text节点。

wholeText属性必须返回按照树形结构顺序连接其上下文对象的邻近Text节点的数据的结果。

ProcessingInstruction接口

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

ProcessingInstruction节点拥有一个与其相关联的目标。

target属性必须返回其目标。

Comment接口

interface Comment : CharacterData {
};

排列

一个节点node的长度由node决定：

• DocumentType
  • 0。
• Text
• ProcessingInstruction
• Comment
  • 其length属性值。
• 任意其他节点
  • 其孩子的数量。

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(CompareHow how, Range sourceRange);

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

  Range cloneRange();
  void detach();

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

  boolean intersectsNode(Node node);

  stringifier;
};

Range对象被认为是排列。

一个边界点是一个（节点，偏移量）元组，其偏移量是一个非负整数。

如果边界点（节点A，偏移量A）及（节点B，偏移量B）的两个节点拥有相同的根，则前者的位置与后者之间的关系为之前、相同或之后，其由下列算法得出：

1. 如果节点A与节点B相同，则如果偏移量A与偏移量B相同返回相同，如果偏移量A小于偏移量B返回之前，如果偏移量A大于偏移量B返回之后。
2. 如果节点A跟随节点B，则比较（节点B，偏移量B）到（节点A，偏移量A）的位置关系。如果为之前则返回之后。如果之后则返回之后。不管是哪种情况都要终止这些步骤。
3. 如果节点A是节点B的祖先：
   1. 设孩子等于节点B。
   2. 只要孩子不是节点A的孩子，则设孩子为其父亲。
   3. 如果孩子的索引小于偏移量A，则返回之后。
4. 返回之前。

每个排列都拥有两个与其相关联的边界点——起始和结束——一个与其相关的分离标记，它们初始化时没有设置。

为了简便，起始节点是起始的节点、起始偏移量是起始的偏移量、结束节点是结束的节点、结束偏移量是结束的偏移量。

一个排列的根是其起始节点的根，或者如果其设置了分离标记则为空。

如果一个节点node的根与一个排列range的根相同，且（node，0）在range的起始之后，且（node，node的长度）在range的结束之前，则称节点node被包含于排列range之中。

如果一个节点node是一个排列range的起始节点的一个包容性祖先而不是其结束节点的一个包容性祖先，或者相反的情况，则称节点node被部分包含于排列range之中。

如果没有设置分离标记，则startContainer属性必须返回其起始节点，否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记，则startOffset属性必须返回其起始偏移量，否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记，则endContainer属性必须返回其结束节点，否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记，则endOffset属性必须返回其结束偏移量，否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记，如果起始等于结束，则collapsed属性必须返回真，否则必须返回假；否则必须抛出一个INVALID_STATE_ERR异常。

commonAncestorContainer属性必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设容器为起始节点。
3. 只要容器不是结束节点的一个包容性祖先，则设容器为容器的父亲。
4. 返回容器。

为了对一个排列设置其起始或结束为一个边界点（节点，偏移量），需要执行这些步骤：

1. 如果设置了排列的分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果节点是一个DOCTYPE，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
3. 如果偏移量大于节点的长度，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
4. 设边界点为边界点（节点，偏移量）。
5. • 如果这些步骤被作为“设置起始”调用
     1. 如果边界点在排列的结束之后，或者如果排列的根不等于节点的根，则设排列的结束为边界点。
     2. 设排列的起始为边界点。
   • 如果这些步骤被作为“设置结束”调用
     1. 如果边界点在排列的起始之前，或者如果排列的根不等于节点的根，则设排列的起始为边界点。
     2. 设排列的结束为边界点。

setStart(node, offset)方法必须对上下文对象设置其起始为边界点(node, offset)。

setEnd(node, offset)方法必须对上下文对象设置其结束为边界点(node, offset)。

setStartBefore(node)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设父亲为节点的父亲。
3. 如果父亲为空，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 对上下文对象设置其起始为边界点(父亲, 节点的索引)。

setStartAfter(node)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设父亲为节点的父亲。
3. 如果父亲为空，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 对上下文对象设置其起始为边界点(父亲, 节点的索引加上一)。

setEndBefore(node)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设父亲为节点的父亲。
3. 如果父亲为空，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 对上下文对象设置其结束为边界点(父亲, 节点的索引)。

setEndAfter(node)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设父亲为节点的父亲。
3. 如果父亲为空，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 对上下文对象设置其结束为边界点(父亲, 节点的索引加上一)。

collapse(toStart)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果toStart为真，则将结束设为起始。否则，将起始设为结束。

selectNode(node)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设父亲为节点的父亲。
3. 如果父亲为空，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 设索引为节点的索引。
5. 设起始为边界点（父亲，索引）。
6. 设结束为边界点（父亲，索引加上一）。

selectNodeContents(node)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果节点是一个DOCTYPE，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
3. 设长度为节点的长度。
4. 设起始为边界点（节点，0）。
5. 设结束为边界点（节点，长度）。

compareBoundaryPoints(how, sourceRange)方法必须执行这些步骤：

1. 如果上下文对象或sourceRange设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果上下文对象的根与sourceRange的根不相同，则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
3. 如果how是：
   • START_TO_START
     • 设this point为上下文对象的起始。
     • 设other point为sourceRange的起始。
   • START_TO_END
     • 设this point为上下文对象的起始。
     • 设other point为sourceRange的结束。
   • END_TO_END
     • 设this point为上下文对象的结束。
     • 设other point为sourceRange的结束。
   • END_TO_START
     • 设this point为上下文对象的结束。
     • 设other point为sourceRange的起始。
4. 如果this point到other point的位置为：
   • “之前”
     • 返回-1并终止这些算法。
   • “等于”
     • 返回0并终止这些算法。
   • “之后”
     • 返回1并终止这些算法。

deleteContents()方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果起始等于结束，则终止这些步骤。
3. 设原起始节点、原起始偏移量、原结束节点、原结束偏移量分别为上下文对象的起始节点、起始偏移量、结束节点、结束偏移量。
4. 如果原起始节点与原结束节点'相同，且它们均为Text或Comment节点，则使用节点原起始节点、偏移量原起始偏移量、计数原结束偏移量减去原起始偏移量及数据空字符串替换其数据，并终止这些步骤。
5. 设将移除的节点为树形结构顺序下上下文对象中所有被包含的节点的列表，其中忽略上下文对象中其父亲也被包含的节点。
6. 如果原起始节点是原结束节点的一个包容性祖先，则将新节点设为原起始节点，将新偏移量设为原起始偏移量。
7. 否则：
   1. 设参考节点等于原开始节点。
   2. 只要参考节点的父亲不为空，且不是原结束节点的包容性祖先，则设参考节点为其父亲。
   3. 设新节点为参考节点的父亲，设新偏移量为一加上参考节点的索引。
      注：如果参考节点的父亲为空，即其为其上下文对象的根，所以将为原结束节点的一个包容性祖先，并且我们不可能达到该点。
8. 如果原起始节点是一个Text或Comment节点，则使用节点原起始节点、偏移量原起始偏移量、计数原起始节点的长度减去原起始偏移量、数据空字符串替换其数据。
9. 对于将移除的节点中的每个节点，按照顺序从其父亲中移除节点。
10. 如果原结束节点是一个Text或Comment节点，则使用节点原结束节点、偏移量0、计数原结束偏移量、数据空字符串替换其数据。
11. 将起始和结束设为（新节点，新偏移量）。

extractContents()方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设片段为一个新的DocumentFragment，其节点对象与上下文对象的起始节点的节点文档。
3. 如果起始等于结束，返回片段，则终止这些步骤。
4. 设原起始节点、原起始偏移量、原结束节点、原结束偏移量分别为上下文对象的起始节点、起始偏移量、结束节点、结束偏移量。
5. 如果原起始节点与原结束节点'相同，且它们均为Text或Comment节点：
   1. 设副本为原起始节点的一个副本。
   2. 设副本的数据为使用节点原起始节点、偏移量原起始偏移量和计数原结束偏移量减去原起始偏移量取其数据的子串的结果。
   3. 将副本追加到片段之中。
   4. 使用节点原起始节点、偏移量原起始偏移量、计数原结束偏移量减去原其实偏移量、数据空字符串替换其数据。
   5. 返回片段并终止这些步骤。
6. 设普通祖先为原起始节点
7. 只要普通祖先不是原结束节点的包容性祖先，则设普通祖先为其父亲。
8. 如果原起始节点是原结束节点的包容性祖先，则设第一个被部分包含的孩子为空。
9. 否则，设第一个被部分包含的孩子为普通祖先的孩子中第一个被部分包含在上下文对象之中的。
10. 如果原结束节点是原起始节点的一个包容性祖先，则设最后一个被部分包含的孩子为空。
11. 否则，设最后一个被部分包含的孩子为普通祖先的孩子中最后一个被部分包含在上下文对象之中的。
12. 设被包含的孩子为普通祖先的孩子中所有被包含在上下文对象之中的，保持树形结构顺序。
13. 如果被包含的孩子中有成员为一个DocumentType的，则抛出一个HIERARCHY_REQUEST_ERR异常并终止这些步骤。
14. 如果原起始节点是原结束节点的一个包容性祖先，则设新节点为原起始节点、设新偏移量为原起始偏移量。
15. 否则：
    1. 设参考节点等于原起始节点。
    2. 只要参考节点的父亲不为空且不是原结束节点的一个包容性祖先，则设参考节点为其父亲。
    3. 设新节点为参考节点的父亲，设新偏移量为一加上参考节点的索引。
16. 如果第一个被部分包含的孩子是一个Text或Comment节点：
    1. 设副本为原起始节点的一个副本。
    2. 设副本的数据为使用节点原起始节点、偏移量原起始偏移量和计数原起始节点的长度减去原起始偏移量取其数据的子串。
    3. 将副本追加到片段之中。
    4. 使用节点原起始节点、偏移量原起始偏移量、计数原起始节点的长度减去原起始偏移量和数据空字符串替换其数据。
17. 否则，如果第一个被部分包含的孩子不为空：
    1. 设副本为第一个被部分包含的孩子的一个副本。
    2. 将副本追加到片段之中。
    3. 设子排列为一个新的排列，其起始为（原起始节点，原起始偏移量），其结束为（第一个被部分包含的孩子，第一个被部分包含的孩子的长度）。
    4. 设子片段为在子排列上调用extractContents()的结果。
    5. 对于子片段中的每个孩子，按照顺序，将该孩子追加到片段之中。
18. 对于被包含的孩子中的每个孩子，将该孩子追加到片段之中。
19. 如果最后一个被部分包含的孩子是一个Text或Comment节点：
    1. 设副本为原结束节点的一个副本。
    2. 设副本的数据为使用节点原结束节点、偏移量0和计数原结束偏移量取其数据的子串。
    3. 将副本追加到片段之中。
    4. 使用节点原结束节点、偏移量0、计数原结束偏移量和数据空字符串替换其数据。
20. 否则，如果最后一个被部分包含的孩子不为空：
    1. 设副本为最后一个被部分包含的孩子的一个副本。
    2. 将副本追加到片段之中。
    3. 设子排列为一个新的排列，其起始为（最后一个被部分包含的孩子，0），其结束为（原结束节点，原结束偏移量）。
    4. 设子片段为在子排列上调用extractContents()的结果。
    5. 对于子片段中的每个孩子，按照顺序，将该孩子追加到片段之中。
21. 将起始和结束为（新节点，新偏移量）。
22. 返回片段。

cloneContents()方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设片段为一个新的DocumentFragment，其节点对象与上下文对象的起始节点的节点文档。
3. 如果起始等于结束，则返回片段，并终止这些步骤。
4. 设原起始节点、原起始偏移量、原结束节点、原结束偏移量分别为上下文对象的起始节点、起始偏移量、结束节点、结束偏移量。
5. 如果原起始节点与原结束节点'相同，且它们均为Text或Comment节点：
   1. 设副本为原起始节点的一个副本。
   2. 设副本的数据为使用节点原起始节点、偏移量原起始偏移量和计数原结束偏移量减去原起始偏移量取其数据的子串的结果。
   3. 将副本追加到片段之中。
   4. 使用节点原起始节点、偏移量原起始偏移量、计数原结束偏移量减去原其实偏移量、数据空字符串替换其数据。
   5. 返回片段并终止这些步骤。
6. 设普通祖先为原起始节点
7. 只要普通祖先不是原结束节点的包容性祖先，则设普通祖先为其父亲。
8. 如果原起始节点是原结束节点的包容性祖先，则设第一个被部分包含的孩子为空。
9. 否则，设第一个被部分包含的孩子为普通祖先的孩子中第一个被部分包含在上下文对象之中的。
10. 如果原结束节点是原起始节点的一个包容性祖先，则设最后一个被部分包含的孩子为空。
11. 否则，设最后一个被部分包含的孩子为普通祖先的孩子中最后一个被部分包含在上下文对象之中的。
12. 设被包含的孩子为普通祖先的孩子中所有被包含在上下文对象之中的，保持树形结构顺序。
13. 如果被包含的孩子中有成员为一个DocumentType的，则抛出一个HIERARCHY_REQUEST_ERR异常并终止这些步骤。
14. 如果第一个被部分包含的孩子是一个Text或Comment节点：
    1. 设副本为原起始节点的一个副本。
    2. 设副本的数据为使用节点原起始节点、偏移量原起始偏移量和计数原起始节点的长度减去原起始偏移量取其数据的子串。
    3. 将副本追加到片段之中。
15. 否则，如果第一个被部分包含的孩子不为空：
    1. 设副本为第一个被部分包含的孩子的一个副本。
    2. 将副本追加到片段之中。
    3. 设子排列为一个新的排列，其起始为（原起始节点，原起始偏移量），其结束为（第一个被部分包含的孩子，第一个被部分包含的孩子的长度）。
    4. 设子片段为在子排列上调用cloneContents()的结果。
    5. 对于子片段中的每个孩子，按照顺序，将该孩子追加到片段之中。
16. 对于被包含的孩子中的每个孩子：
    1. 设副本为孩子的一个副本。
    2. 将副本追加到片段之中。
17. 如果最后一个被部分包含的孩子是一个Text或Comment节点：
    1. 设副本为最后一个被部分包含的孩子的一个副本。
    2. 设副本的数据为使用节点原结束节点、偏移量0和计数原结束节点取其数据的子串。
    3. 将副本追加到片段之中。
18. 否则，如果最后一个被部分包含的孩子不为空：
    1. 设副本为最后一个被部分包含的孩子的一个副本。
    2. 将副本追加到片段之中。
    3. 设子排列为一个新的排列，其起始为（最后一个被部分包含的孩子，0），其结束为（原结束节点，原结束偏移量）。
    4. 设子片段为在子排列上调用cloneContents()的结果。
    5. 对于子片段中的每个孩子，按照顺序，将该孩子追加到片段之中。
19. 返回片段。

insertNode(newNode)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果起始节点是一个Text或Comment节点，且其父亲为空，则抛出一个HIERARCHY_REQUEST_ERR异常并终止这些步骤。
3. 如果起始节点是一个Text节点，则使用偏移量上下文对象的起始偏移量分离该Text节点，并将参考节点设为返回的结果。
4. 否则，如果起始节点是一个Comment节点，则将参考节点设为起始节点。
5. 否则，将参考节点设为起始节点中索引为起始偏移量的孩子，或者如果不存在这些的孩子则设为空。
6. 如果参考节点为空，则设父节点为起始节点.
7. 否则，设父节点为参考节点的父亲。
8. 将newNode预插入到父节点中参考节点之前。

surroundContents(newParent)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果上下文对象中部分包含了一个非Text节点，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
3. 如果newParent是一个Document、DocumentType或DocumentFragment节点，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 在上下文对象上调用extractContents()方法，并将片段设为返回的结果。
5. 只要newParent拥有孩子，则移除其第一个孩子。
6. 在上下文对象上调用insertNode(newParent)方法。
7. 在newParent上调用appendChild(片段)方法。
8. 在上下文对象上调用selectNode(newParent)方法。

对于cloneRange()方法，如果设置了分离标记，则必须抛出一个INVALID_STATE_ERR异常。否则，必须返回一个新的排列，其起始和结束与其上下文对象中的相同。

detach()方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设置分离标记。

isPointInRange(节点, 偏移量)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果节点不是上下文对象的根的一个包容性后裔，则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
3. 如果节点是一个DOCTYPE，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 如果偏移量大于节点的长度，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
5. 设边界为边界点（节点，偏移量）。
6. 如果边界在起始之前或者在结束之后，则返回假并终止这些步骤。
7. 返回真。

comparePoint(节点, 偏移量)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果节点不是上下文对象的根的一个包容性后裔，则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
3. 如果节点是一个DOCTYPE，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
4. 如果偏移量大于节点的长度，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
5. 设边界为边界点（节点，偏移量）。
6. 如果边界在起始之前，则返回-1并终止这些步骤。
7. 如果边界在结束之后，则返回1并终止这些步骤。
8. 否则，返回0。

intersectsNode(节点)方法必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 如果节点不是一个Element、DocumentType、DocumentFragment、ProcessingInstruction、Comment或Text节点，则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
3. 设父亲为节点的父亲。如果父亲为空，则抛出一个NOT_FOUND_ERR异常并终止这些步骤。
4. 设偏移量为节点的索引。
5. 设前边界为边界点（父亲，偏移量）。
6. 如果前边界在结束之前或者等于结束，则返回假并终止这些步骤。
7. 设后边界为边界点（父亲，偏移量加一）。
8. 如果上下文对象的起始等于后边界或者在后边界之后，则返回假并终止这些步骤。
9. 否则，返回真。

stringifier必须执行这些步骤：

1. 如果设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设s为空字符串。
3. 如果起始节点等于结束节点，且其为一个Text节点，则返回该Text节点的数据中起始自起始偏移量、结束至结束偏移量的子字符串，并终止这些步骤。
4. 如果起始节点为一个Text节点，则向s追加一个该节点的数据中自起始偏移量、至结尾之前的子字符串。
5. 向s追加在上下文对象中被包含的所有Text节点的数据按照树形结构顺序连接的结果。
6. 如果结束节点为一个Text节点，则向s追加一个该节点的数据中自起始、至结束偏移量之前的子字符串。
7. 返回s。

遍历

NodeIterator和TreeWalker对象可以被用于过滤和遍历节点树。

每个NodeIterator和TreeWalker对象都拥有一个与其相关的激活标记以避免递归调用。其初始时未设置。

每个NodeIterator和TreeWalker对象还拥有一个与其相关的根节点、whatToShow掩码和过滤器回调。

为了过滤节点，需要这些这些步骤：

1. 如果设置了激活标记，则抛出一个INVALID_STATE_ERR异常、终止这些步骤、并终止调用此算法的算法的步骤。
2. 设n为节点的nodeType属性值减去1。
3. 如果没有设置whatToShow的第n位（其中0为最后一个有意义的位），返回FILTER_SKIP并终止这些步骤。
4. 如果过滤器为空，则返回FILTER_ACCEPT并终止这些步骤。
5. 设置激活标记。
6. 设结果为调用过滤器的返回值。
7. 撤销激活标记。
8. 如果抛出了异常，则再次抛出该异常、终止这些步骤、并终止调用此算法的算法的步骤。
9. 返回结果。

NodeIterator接口

interface NodeIterator {
  readonly attribute Node root;
  readonly attribute Node? referenceNode;
  readonly attribute boolean pointerBeforeReferenceNode;
  readonly attribute unsigned long whatToShow;
  readonly attribute NodeFilter? filter;

  Node? nextNode();
  Node? previousNode();

  void detach();
};

每个NodeIterator对象都有一个与其相关联的迭代器集合，其为一个植根于根的集合，其过滤器匹配任意节点。

在从迭代器集合中移除一个节点之前，必须执行这些步骤：

1. 如果该节点不是根的一个后裔，而且不是referenceNode属性值的一个祖先或referenceNode属性值本身，则终止这些步骤。
2. 如果pointerBeforeReferenceNode属性值为假，则将referenceNode属性设为该节点之前的被删除的第一个节点，并终止这些步骤。
3. 如果pointerBeforeReferenceNode属性值为真，并且存在在该节点之后的被删除的节点，则将referenceNode属性设为第一个这样的节点，并终止这些步骤。
4. 将referenceNode属性设为该节点之前的被删除的第一个节点，并且设pointerBeforeReferenceNode属性值为假。

每个NodeIterator对象还有一个与其相关联的分离标记，其初始化时没有设置。

root属性必须返回根。

referenceNode属性必须返回其预置的内容。

pointerBeforeReferenceNode属性必须返回其预置的内容。在一个NodeIterator被创建时，必须将其预置为真。

whatToShow属性必须返回shatToShow。

filter属性必须返回过滤器。

为了在方向方向上进行跨越，需要这些这些步骤：

1. 如果标记了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
2. 设节点为其referenceNode属性的值。
3. 设在节点之前为其pointerBeforeReferenceNode属性的值。
4. 执行这些子步骤：
   1. • 如果方向为向后
        • 如果在节点之前为假，则设节点为迭代器集合中节点之后的第一个节点。如果不存在这样的节点，则返回空并终止这些步骤。
        • 如果在节点之前为真，则将其设为假。
      • 如果方向为向前
        • 如果在节点之前为真，则设节点为迭代器集合中节点之前的第一个节点。如果不存在这样的节点，则返回空并终止这些步骤。
        • 如果在节点之前为假，则将其设为真。
   2. 过滤节点并将结果设为返回的值。
   3. 如果标记了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
   4. 如果结果为FILTER_ACCEPT，在上一层中进入下一步。

      否则，再次执行这些子步骤。

5. 设referenceNode属性为节点，设pointerBeforeReferenceNode属性为在节点之前，并返回节点。

nextNode()方法必须向后跨越。

previousNode()方法必须向前跨越。

在调用detach()方法时，将设置分离标记，并设referenceNode属性为空。

TreeWalker接口

interface TreeWalker {
  readonly attribute Node root;
  readonly attribute unsigned long whatToShow;
  readonly attribute NodeFilter? filter;
           attribute Node  currentNode;

  Node? parentNode();
  Node? firstChild();
  Node? lastChild();
  Node? previousSibling();
  Node? nextSibling();
  Node? previousNode();
  Node? nextNode();
};

root属性必须返回根。

whatToShow属性必须返回whatToShow。

filter属性必须返回过滤器。

currentNode属性必须返回其预置的内容。

设置currentNode属性时，必须将其设为新值。

parentNode()方法必须执行这些步骤：

1. 设节点为其currentNode属性的值。
2. 只要节点不为空且不是根，则执行这些子步骤：
   1. 设节点为节点的父亲。
   2. 如果节点不为空且过滤节点返回FILTER_ACCEPT，则将currentNode属性设为节点，返回节点，并终止这些步骤。
3. 返回空。

为了跨越类型为类型的孩子，需要执行这些步骤：

1. 设节点和当前为其currentNode属性的值。
2. 只要节点不为空，则执行这些子步骤：
   1. 过滤节点，并设结果为返回值。
   2. 如果结果为FILTER_ACCEPT，则将currentNode属性设为节点，返回节点，并终止这些步骤。
   3. 如果结果为FILTER_SKIP且节点拥有一个孩子，则按照下面设置节点并在此执行这些子步骤：
      • 如果类型为第一个
        • 设其为第一个孩子。
      • 如果类型为最后一个
        • 设其为最后一个孩子。
   4. 只要节点不为空，则执行这些子子步骤：
      1. • 如果类型为第一个
           • 设兄弟为节点的下一个兄弟。
         • 如果类型为最后一个
           • 设兄弟为节点的上一个兄弟。
      2. 如果兄弟不为空，则设节点为兄弟并终止这些步骤。
      3. 如果节点拥有一个父亲，且其不为根或当前，则设节点为其父亲。

         否则，返回空并终止这些步骤。

firstChild()方法必须跨越类型为第一个的孩子。

lastChild()方法必须跨越类型为最后一个的孩子。

为了跨越类型为类型的兄弟，需要执行这些步骤：

1. 设节点为其currentNode属性的值。
2. 如果节点为根，则返回空并终止这些步骤。
3. 执行这些子步骤：
   1. • 如果类型为之后
        • 设兄弟为节点的下一个兄弟。
      • 如果类型为之前
        • 设兄弟为节点的上一个兄弟。
   2. 只要兄弟不为空，则执行这些子子步骤。
      1. 设节点为兄弟。
      2. 过滤节点并设结果为返回值。
      3. 如果结果为FILTER_ACCEPT，则设currentNode属性为节点，返回节点，并终止这些步骤。
      4. • 如果类型为之后
           • 设兄弟为节点的第一个孩子。
         • 如果类型为之前
           • 设兄弟为节点的最后一个孩子。
      5. 如果结果为FILTER_REJECT或者兄弟为空，则设兄弟为下列：
         • 如果类型为之后
           • 设兄弟为节点的下一个兄弟。
         • 如果类型为之前
           • 设兄弟为节点的上一个兄弟。
   3. 设节点为其父亲。
   4. 如果节点为空或根，则返回空并终止这些步骤。
   5. 过滤节点，如果返回值为FILTER_ACCEPT则返回空并终止这些步骤。
   6. 再次执行这些子步骤。

nextSibling()方法必须跨越类型为之后的兄弟。

previousSibling()方法必须跨越类型为之前的兄弟。

previousNode()方法必须执行这些步骤：

1. 设节点为其currentNode属性的值。
2. 只要节点不为根，则执行这些子步骤：
   1. 设兄弟为节点的上一个兄弟。
   2. 只要兄弟不为空，则执行这些子子步骤：
      1. 设节点为兄弟。
      2. 过滤节点并设结果为返回值。
      3. 只要结果不是FILTER_REJECT且节点拥有一个孩子，则执行这些子子子步骤：
         1. 设节点为其最后一个孩子。
         2. 过滤节点并设结果为返回值。
      4. 如果结果为FILTER_ACCEPT，则设currentNode为节点，返回节点，并终止这些步骤。
   3. 如果节点为根或没有父亲，则返回空并终止这些步骤。
   4. 设节点为其父亲。
   5. 过滤节点，如果返回值为FILTER_ACCEPT，则设currentNode为节点，返回节点，并终止这些步骤。

nextNode()方法必须执行这些步骤：

1. 设节点为其currentNode属性的值。
2. 设结果为FILTER_ACCEPT。
3. 执行这些子步骤：
   1. 只要结果不为FILTER_ACCEPT且节点拥有一个孩子，则执行这些子子步骤。
      1. 设节点为其第一个孩子。
      2. 过滤节点并设结果为返回值。
      3. 如果结果为FILTER_ACCEPT，则设currentNode为节点，返回节点，并终止这些步骤。
   2. 如果一个节点在节点之后，且不在根之后，则设节点为第一个这样的节点。

      否则，再次执行这些子步骤。

   3. 过滤节点，如果返回值为FILTER_ACCEPT，则设currentNode为节点，返回节点，并终止这些步骤。

NodeFilter接口

callback interface NodeFilter {
  // acceptNode()常量
 const unsigned short FILTER_ACCEPT = 1;
 const unsigned short FILTER_REJECT = 2;
 const unsigned short FILTER_SKIP = 3;

  // whatToShow常量
  const unsigned long SHOW_ALL = 0xFFFFFFFF;
  const unsigned long SHOW_ELEMENT = 0x1;
  const unsigned long SHOW_ATTRIBUTE = 0x2; // 历史遗留
  const unsigned long SHOW_TEXT = 0x4;
  const unsigned long SHOW_CDATA_SECTION = 0x8; // 历史遗留
  const unsigned long SHOW_ENTITY_REFERENCE = 0x10; // 历史遗留
  const unsigned long SHOW_ENTITY = 0x20; // 历史遗留
  const unsigned long SHOW_PROCESSING_INSTRUCTION = 0x40;
  const unsigned long SHOW_COMMENT = 0x80;
  const unsigned long SHOW_DOCUMENT = 0x100;
  const unsigned long SHOW_DOCUMENT_TYPE = 0x200;
  const unsigned long SHOW_DOCUMENT_FRAGMENT = 0x400;
  const unsigned long SHOW_NOTATION = 0x800; // 历史遗留

  unsigned short acceptNode(Node node);
};

NodeFilter对象可以被用于过滤器的回调并提供whatToShow掩码常量。

这些产量可以被用于回调返回值：

• FILTER_ACCEPT （1）；
• FILTER_REJECT （2）；
• FILTER_SKIP （3）。

这些常量可以被用于whatToShow掩码：

• SHOW_ALL （4294967295、十六进制FFFFFFFF）；
• SHOW_ELEMENT （1）；
• SHOW_TEXT （4）；
• SHOW_PROCESSING_INSTRUCTION （64、十六进制40）；
• SHOW_COMMENT （128、十六进制80）；
• SHOW_DOCUMENT （256、十六进制100）；
• SHOW_DOCUMENT_TYPE （512、十六进制200）；
• SHOW_DOCUMENT_FRAGMENT （1024、十六进制400）；

集合

一个集合是一个表示一个DOM节点的列表的对象。一个集合可以是动态的或者静态的。除非另作说明，一个集合必须是动态的。

如果一个集合是动态的，则该对象上的属性和方法必须在其当前的基础数据上执行，而不是该数据的一个快照。

在一个集合被创建时，一个过滤器和一个根与其相关联。

集合表示一个植根于集合的根的子树的试图，仅包含匹配指定过滤器的节点。该视图是线性的。在没有明确的反对要求时，集合中的节点必须按照树形结构顺序排列。

对于返回一个动态的集合的属性，每次获取时都必须返回相同的对象。

NodeList接口

一个NodeList对象是集合的一种。

interface NodeList {
  getter Node? item(unsigned long index);
  readonly attribute unsigned long length;
};

该对象的支持的属性索引为零至集合所表示的节点的数目减去一范围内的数字。如果没有这样的元素，则不存在支持的属性索引。

length属性必须返回集合所表示的节点的数目。

item(index)属性必须返回集合中的第index个节点。如果集合中不存在第index个节点，则该方法必须返回空。

HTMLCollection接口

HTMLCollection接口表示一个通用的元素的集合。

interface HTMLCollection {
  readonly attribute unsigned long length;
  getter Element? item(unsigned long index);
  getter object? namedItem(DOMString name); // 仅返回Element。
};

该对象的支持的属性索引为零至集合所表示的节点的数目减去一范围内的数字。如果没有这样的元素，则不存在支持的属性索引。

length属性必须返回集合所表示的节点的数目。

item(index)属性必须返回集合中的第index个节点。如果集合中不存在第index个节点，则该方法必须返回空。

支持的属性名称由HTML命名空间下每个集合所表示的拥有name属性的a、applet、area、embed、form、frame、frameset、iframe、img和object元素的name属性的值加上集合所表示的元素的ID的列表组成。

namedItem(key)方法必须返回集合中的第一个符合下列类别的元素：

• 其为HTML命名空间下的a、applet、area、embed、form、frame、frameset、iframe、img和object元素，且其name属性等于key。或者
• 其为一个元素，且其ID等于key。

如果没有找到这样的元素，则该方法必须返回空。

列表

DOMStringList接口

interface DOMStringList {
  readonly attribute unsigned long length;
  getter DOMString? item(unsigned long index);
  boolean contains(DOMString string);
};

DOMStringList接口表示一个字符串的有序列表。

length属性必须返回列表中字符串的数目。

该对象的支持的属性索引为零至上下文对象的length属性值减去一范围内的数字。如果上下文对象的length属性值为零，则不存在支持的属性索引。

item(index)属性必须返回列表中的第index个字符串。如果index大于等于字符串的数目，则该方法必须返回空。

如果字符串列表中包含string，则contains(string)方法必须返回真，否则必须返回假。

DOMTokenList接口

DOMTokenList接口表示一个基础字符串，其包含一个空格分隔的标记集合。

interface DOMTokenList {
  readonly attribute unsigned long length;
  getter DOMString? item(unsigned long index);
  boolean contains(DOMString token);
  void add(DOMString token);
  void remove(DOMString token);
  boolean toggle(DOMString token);
  stringifier DOMString ();
};

length属性必须返回使用空格分隔上下文对象的基础字符串所返回的标记的数目。

该对象的支持的属性索引为零至上下文对象的length属性值减去一范围内的数字。如果上下文对象的length属性值为零，则不存在支持的属性索引。

item(index)属性必须执行这些步骤：

1. 如果index大于等于上下文对象的length属性，则返回空并终止这些步骤。
2. 使用空格分隔上下文对象的基础字符串，保留在基础字符串中被发现的顺序，以获得标记的列表。
3. 返回该列表中的第index个元素。

举例说明，如果字符串为“a b a c”，则会发现四个标记：索引为0的标记“a”、索引为1的标记“b”、索引为2的标记“a”及索引为3的“c”。

contains(token)方法必须执行这些步骤：

1. 如果token为空字符串，则抛出一个SYNTAX_ERR异常并终止这些步骤。
2. 如果token包含任意空白字符，则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
3. 使用空格分隔上下文对象的基础字符串，以获得标记的列表。
4. 如果token能够区分大小写地匹配上一步中所得到的列表中的一个标记，则返回真，否则返回假。

add(token)方法必须执行这些步骤：

1. 如果token为空字符串，则抛出一个SYNTAX_ERR异常并终止这些步骤。
2. 如果token包含任意空白字符，则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
3. 使用空格分隔上下文对象的基础字符串，以获得标记的列表。
4. 如果token能够区分大小写地匹配上一步中所得到的列表中的一个标记，则终止这些步骤。
5. 如果上下文对象的基础字符串不是空字符串且该字符串的最后一个字符不是一个空白字符，则向该字符串中追加一个U+0020空白字符。
6. 向上下文对象的基础字符串中追加token。

remove(token)方法必须执行这些步骤：

1. 如果token为空字符串，则抛出一个SYNTAX_ERR异常并终止这些步骤。
2. 如果token包含任意空白字符，则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
3. 从上下文对象的基础字符串中移除token。

toggle(token)方法必须执行这些步骤：

1. 如果token为空字符串，则抛出一个SYNTAX_ERR异常并终止这些步骤。
2. 如果token包含任意空白字符，则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
3. 使用空格分隔上下文对象的基础字符串，以获得标记的列表。
4. 如果token能够区分大小写地匹配上一步中所得到的列表中的一个标记，则从上下文对象的基础字符串中移除token、返回假并终止这些步骤。
5. 如果上下文对象的基础字符串不是空字符串且该字符串的最后一个字符不是一个空白字符，则向该字符串中追加一个U+0020空白字符。
6. 向上下文对象的基础字符串中追加token。
7. 返回真。

DOMTokenList对象必须字符串化为上下文对象的基础字符串。

DOMSettableTokenList接口

DOMSettableTokenList接口与DOMTokenList接口相同，除了允许直接修改基础字符串。

interface DOMSettableTokenList : DOMTokenList {
           attribute DOMString value;
};

一个实现DOMSettableTokenList接口的对象的行为必须按照DOMTokenList接口的定义执行，除了这里定义的value。

value属性必须返回基础字符串，在设置时必须使用新值替换基础字符串。

DOM特性

历史

DOM事件

DOM核心

DOM排列

DOM遍历