DOM4/impl

English

目标

English

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

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

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

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

空格分隔的标记

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

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

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

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

有时会对空格分隔的标记集定义一个允许的值的集合。若定义了允许值的集合，则所有标记必须来自于该允许值的列表；不允许其他的值。如果没有提供这样的允许值的集合，则允许所有的值。

注：空格分隔的标记集中的标记要如果比较（例如大小写敏感与否）将在在基于预设定义。

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

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

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

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

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

为了抛出一个“TimeoutError”异常，用户代理将创建一个类型为“TimeoutError”且code异常字段值为23的DOMException异常，并且在实际上将该对象作为一个异常抛出。

类型	描述	传统code异常字段值（如果存在）
“IndexSizeError”	索引不再允许的范围内。	INDEX_SIZE_ERR（1）
“HierarchyRequestError”	操作将产生一个不正确的节点模型。	HIERARCHY_REQUEST_ERR（3）
“WrongDocumentError”	对象在一个错误的文档中。	WRONG_DOCUMENT_ERR（4）
“InvalidCharacterError”	字符串包含无效字符。	INVALID_CHARACTER_ERR（5）
“NoModificationAllowedError”	对象不能被修改。	NO_MODIFICATION_ALLOWED_ERR（7）
“NotFoundError”	找不到对象。	NOT_FOUND_ERR（8）
“NotSupportedError”	不支持该操作。	NOT_SUPPORTED_ERR（9）
“InvalidStateError”	对象处于无效状态。	INVALID_STATE_ERR（11）
“SyntaxError”	字符串不匹配预计的模式。	SYNTAX_ERR（12）
“InvalidModificationError”	对象不能通过该方式修改。	INVALID_MODIFICATION_ERR（13）
“NamespaceError”	XML下的命名空间不支持该操作。[XMLNS]	NAMESPACE_ERR（14）
“InvalidAccessError”	对象不支持该操作或参数。	INVALID_ACCESS_ERR（15）
“TypeMismatchError”	对象的类型不匹配预计的类型。	TYPE_MISMATCH_ERR（17）
“SecurityError”	操作不安全。	SECURITY_ERR（18）
“NetworkError”	发生网络错误。	NETWORK_ERR（19）
“AbortError”	操作被终止。	ABORT_ERR（20）
“URLMismatchError”	给出的URL不匹配另一个URL。	URL_MISMATCH_ERR（21）
“QuotaExceededError”	以超出配额。	QUOTA_EXCEEDED_ERR（22）
“TimeoutError”	操作超时。	TIMEOUT_ERR（23）
“InvalidNodeTypeError”	该操作提供的节点不正确或存在一个不正确的祖先。	INVALID_NODE_TYPE_ERR（24）
“DataCloneError”	对象不能被复制。	DATA_CLONE_ERR（25）

DOMError接口

English

注：此接口的目的是允许其他规范介绍通过异常之外的手段进行的错误处理方法。其为预期的被重用的异常类型。

interface DOMError {
  readonly attribute DOMString name;
};

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

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

一个规范可以声称一个error属性必须返回一个“SyntaxError”DOMError。

事件

Event接口

English

[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属性必须其预置的值。当创建一个事件时，该属性必须被预置为空字符串。

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

注：在指派事件时，target和currentTarget属性将被预置位不同的值。

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)方法时，必须执行下列步骤：

设置预置标记。
如果设置了指派标记，则终止这些步骤。
删除停止扩展标记、立即停止扩展标记和撤销标记。
设isTrusted属性为假。
设target属性为空。
设type属性为type参数。
设bubbles属性为bubbles参数。
设cancelable属性为cancelable参数。

注：由于事件拥有构造器，initEvent()是多余的。但是，其不得不为老式内容而支持该方法。

CustomEvent接口

English

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

dictionary CustomEventInit : EventInit {
  any detail;
};

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

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

构造事件

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

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

EventTarget接口

English

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)方法时，必须执行下列步骤：

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

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

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

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

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

指派事件

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

设event为将要指派的事件。
设置event的指派标记。
将event的target属性预置为指派event的对象。
- 如果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属性的值的事件侦听器。
移除event的指派标记。
将event的eventPhase属性预置为AT_TARGET。
将event的currentTarget预置为空。
如果event设置了撤销标记，则返回假，否则返回真。

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

设event为调用事件侦听器的事件。
设listeners为与这些步骤所执行的对象相关的事件侦听器的静态列表。
将event的currentTarget预置为这些步骤所执行的对象。
对于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属性被预置为真。

注：触发较预置和指派一个事件要短。

注：触发一个事件是一个为了使预置和指派一个事件更易被记录的概念。如果事件需要预置其bubbles或cancelable属性，则我们可以记录“触发一个名为submit的事件，其cancelable属性被预置为真”。

节点

节点模型

English

实现了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
- 无。

注：如果预插入和替换算法违反了上述约束，将会抛出一个“HierarchyRequestError”。这些算法用于那些修改节点的树的方法。

改变

English

问题：本节将为平台定义一个“变化事件”功能的替代。现在其保护了供应商已经实现的接口。

[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接口

English

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

注：Node是一个抽象接口，不作为节点而存在。它被用于所有的节点（Document、DocumentFragment、DocumentType、Element、Text、ProcessingInstruction和Comment）。

每个节点都有一个与其相关的节点文档，在该节点创建时设置，其为一个文档。

注：一个节点的节点文档可以通过“过继”算法改变。

每个节点都有一个与其相关的基础URL。

注：其他规范定义了基础URL的值和其常见行为。本规范只定义这个概念以及baseURI属性。

此区块中不是标准描述，实现要求在下面给出。

node . nodeType

返回node的类型。表示为以下列表中的数字：

节点 . ELEMENT_NODE (1)
- node是一个元素。
节点 . TEXT_NODE (3)
- node是一个Text 节点。
节点 . PROCESSING_INSTRUCTION_NODE (7)
- node是一个ProcessingInstruction 节点。
节点 . COMMENT_NODE (8)
- node是一个Comment 节点。
节点 . DOCUMENT_NODE (9)
- node是一个文档。
节点 . DOCUMENT_TYPE_NODE (10)
- node是一个DOCTYPE。
节点 . DOCUMENT_FRAGMENT_NODE (11)
- node是一个DocumentFragment 节点。

node . nodeName

返回一个能恰当地表示node类型的字符串，其值如下：

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

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”。

此区块中不是标准描述，实现要求在下面给出。

node . baseURI

返回基础URL。

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

此区块中不是标准描述，实现要求在下面给出。

doc = node . ownerDocument

返回其节点文档。

对于文档来说，则返回空。

parent = node . parentNode

返回其父亲。

parent = node . parentElement

返回其父元素。

haschildren = node . hasChildNodes

返回node是否拥有孩子。

children = node . childNodes

返回其孩子。

child = node . firstChild

返回其第一个孩子。

child = node . lastChild

返回其最后一个孩子。

child = node . previousSibling

返回其前一个兄弟。

child = node . nextSibling

返回其后一个兄弟。

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

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

注：一个文档的节点文档是该文档自身。

注：不论何时，所有节点都拥有一个文档。

parentNode属性必须返回其父亲。

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

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

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

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

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

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

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

此区块中不是标准描述，实现要求在下面给出。

node . compareDocumentPosition(other)

返回一个指出other到node之间的位掩码。其可以设置的位包括：

Node . DOCUMENT_POSITION_DISCONNECTED (1)
- 若node和other不在同一个文档中。
DOCUMENT_POSITION_PRECEDING (2)
- 若other在node之前。
DOCUMENT_POSITION_FOLLOWING (4)
- 若other在node之后。
DOCUMENT_POSITION_CONTAINS (8)
- 若other是node的祖先。
DOCUMENT_POSITION_CONTAINED_BY (16，十六进制中的10)
- 若other是node的后裔。

contains = node . contains(other)

如果other是node的包容性后裔，则返回真，否则返回假。

以下为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)方法必须执行下列步骤：

设reference为其上下文对象。
如果other和reference是同一个对象，则返回零，并终止这些步骤。
如果other和reference不在同一个树中，则返回DOCUMENT_POSITION_DISCONNECTED，并终止这些步骤。
如果other是reference的祖先，则返回DOCUMENT_POSITION_PRECEDING加DOCUMENT_POSITION_CONTAINS的结果，并终止这些步骤。
如果other是reference的后裔，则返回DOCUMENT_POSITION_FOLLOWING加DOCUMENT_POSITION_CONTAINS_BY的结果，并终止这些步骤。
如果other在reference的之前，则返回DOCUMENT_POSITION_PRECEDING，并终止这些步骤。
返回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 . normalize()

将邻近的Text节点连接为一个单独的Text 节点。

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

如果child不为空，且其父亲不是parent，则抛出一个“NotFoundError”异常，并终止这些步骤。
如果node为parent或parent的祖先，则抛出一个“HierarchyRequestError”，并终止这些步骤。
如果parent不是一个Document、DocumentFragment或Element 节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
如果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”，并终止这些步骤。
或者，如果parent是一个DocumentFragment或Element 节点且node不是一个DocumentFragment、Element、Text、ProcessingInstruction或Comment 节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
将node过继到parent的节点文档。
将node插入到parent中child之前。
返回child。

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

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

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

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

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

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

如果child的父亲不是parent，则抛出一个“NotFoundError”异常，并终止这些步骤。
如果node为parent或parent的祖先，则抛出一个“HierarchyRequestError”，并终止这些步骤。
如果parent不是一个Document、DocumentFragment或Element 节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
如果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”，并终止这些步骤。
或者，如果parent是一个DocumentFragment或Element 节点且node不是一个DocumentFragment、Element、Text、ProcessingInstruction或Comment 节点，则抛出一个“HierarchyRequestError”，并终止这些步骤。
将node过继到parent的节点文档。
设reference child为child的下一个兄弟。
从parent中移除child。
将node插入到parent中reference child之前。
返回child。

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

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

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

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

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

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

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

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

此区块中不是标准描述，实现要求在下面给出。

clone = node . cloneNode([deep])

返回node的副本。如果deep为真或被忽略，其副本还要包含node的孩子。

similar = node . isEqualNode([other])

返回node和other是否拥有相同的属性。

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

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

如果没有给出document，则设ownerDocument为node的节点文档。
设copy为一个实现了和node相同的接口的节点。
如果copy是一个对象，则设其节点文档为空，设ownerDocument为copy。
否则，设copy的节点文档为ownerDocument。
根据node的类型，复制下列内容：
- Element
  - 其命名空间、命名空间前缀、本地名称及其属性列表。
- DocumentType
  - 其名称、公开ID和系统ID。
- ProcessingInstruction
  - 其目标和数据。
- Text
- Comment
  - 其数据。
- 任意其他节点
  - -
执行其他合适的规范中为node定义的任意复制步骤。
如果设置了clone children flag，复制所有node的孩子，并将其追加到copy之中，其中标记了ownerDocument和clone children flag。
返回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查找其命名空间前缀，需要执行这些步骤：

如果element的命名空间为namespace，且其命名空间前缀不为空，则返回其命名空间前缀并终止这些步骤。
如果element拥有一个命名空间前缀为“xmlns”且值为namespace的属性，则返回该属性的本地名称并终止这些步骤。
如果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)方法必须执行这些步骤：

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

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

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

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

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

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

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

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

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

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

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

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

设classes为用空格分隔classNames所发现的标记集。（忽略重复。）
如果classes为空集，则返回一个空的NodeList并终止这些步骤。
返回一个植根于root、过滤器仅匹配拥有所有classes中类的元素的NodeList。
如果root的节点文档处于怪癖模式，则对类的比较必须按照ASCII不区分大小写的方式进行，否则，比较必须按照区分大小写的方式进行。

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

Document接口

English

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的行为。

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

注：如果文档是通过HTML解析器创建的，则其模式从默认状态的改变只取决于是否存在DOCTYPE字符串及其值。[HTML]

此区块中不是标准描述，实现要求在下面给出。

document . implementation

返回与其相关的DOMImplementation对象。

document . URL

document . documentURI

返回其URL。

document . compatMode

如果document处于非怪癖模式或限定怪癖模式，则返回字符串“CSS1Compat”；如果document处于怪癖模式，则返回字符串“BackCompat”。

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

URL和documentURI属性必须返回URL。

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

此区块中不是标准描述，实现要求在下面给出。

document . charset [ = value ]

返回字符编码。

可以被设置，用于修改字符编码。

并非用户代理所支持的在IANA注册的别名的新值，将被忽略。

document . characterSet

返回字符编码。

document . defaultCharset

返回可能是用户代理默认的字符编码。（用户代理可能会返回其他的字符编码算法，例如为了保护用户隐私或者如果用户代理并非使用一个单一的默认编码。）

document . contentType

返回媒体类型。

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

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

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

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

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

此区块中不是标准描述，实现要求在下面给出。

document . doctype

返回DOCTYPE，或者如果不存在则返回空。

document . documentElement

返回文档元素。

collection = document . getElementsByTagName(localName)

如果localName为“*”，则返回其所有后裔元素的NodeList。

否则，返回其所有后裔元素中本地名称为localName的NodeList。（对于HTML文档中HTML命名空间下的元素，执行不区分大小写匹配。）

collection = document . getElementsByTagNameNS(namespace, localName)

如果namespace和localName均为“*”，则返回其所有后裔元素的NodeList。

如果仅namespace为“*”，则返回其所有后裔元素中本地名称为localName的NodeList。

如果仅localName为“*”，则返回其所有后裔元素中命名空间为namespace的NodeList。

否则，返回其所有后裔元素中命名空间为namespace且本地名称为localName的NodeList。

collection = document . getElementsByClassName(classes)

collection = element . getElementsByClassName(classes)

返回处于调用该方法的对象（文档或元素）中拥有classes中给出的所有类的元素的NodeList。

classes参数将按照一个空格分隔的类的列表进行解释。

element = document . getElementById(elementId)

返回document中第一个拥有给出的ID的元素。

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

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

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

注：因此，在HTML文档中，document.getElementsByTagName("FOO")将匹配不处于HTML命名空间内的FOO元素，以及处于HTML命名空间内的foo元素，但不匹配处于HTML命名空间内的FOO元素。

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

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

给出下列XHTML片段：

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

调用document.getElementById('example').getElementsByClassName('aaa')将返回一个包含两个段落p1和p2的NodeList。

调用getElementsByClassName('ccc bbb')将返回一个名为p3的阶段。调用document.getElementById('example').getElementsByClassName('bbb ccc ')将返回同样的内容。

调用getElementsByClassName('aaa,bbb')将不返回阶段；上述片段中没有元素处于aaa,bbb类。

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

此区块中不是标准描述，实现要求在下面给出。

element = document . createElement(localName)

返回HTML命名空间下的一个元素，其本地名称为localName。（在一个HTML文档中，localName是小写的。）

如果localName不匹配产生的Name，将抛出一个“InvalidCharacterError”异常。

element = document . createElementNS(namespace, qualifiedName)

返回一个命名空间为namespace的元素。其命名空间前缀为qualifiedName中所有“:”（U+003E）之前的内容或空。其本地名称为qualifiedName中所有“:”（U+003E）之后的内容或qualifiedName。

如果localName不匹配产生的Name，将抛出一个“InvalidCharacterError”异常。

如果下列约束之一为真，将抛出一个“NamespaceError”异常：

localName不匹配产生的QName。
命名空间前缀不为空且namespace为空字符串。
命名空间前缀为“xml”且namespace不为XML命名空间。
qualifiedName或命名空间前缀为“xmlns”且namespace不为XMLNS命名空间。
namspace为XMLNS命名空间且qualifiedName和命名空间前缀均不为“xmlns”。

documentFragment = document . createDocumentFragment()

返回一个DocumentFragment 节点。

text = document . createTextNode(data)

返回一个数据为data的Text 节点。

processingInstruction = document . createProcessingInstruction(target, data)

返回一个目标为target且数据为data的ProcessingInstruction 节点。

如果target不匹配产生的Name，将抛出一个“InvalidCharacterError”异常。

如果data包含“?>”，将抛出一个“InvalidCharacterError”异常。

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

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

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

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

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

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

注：没有执行判断数据包含匹配产生的Char的字符的检查。

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

注：没有执行判断数据包含匹配产生的Char的字符、包含两个连续的连字符或以连字符结束的检查。

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

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

注：没有执行判断目标包含“xml”或“:”、数据包含匹配产生的Char的字符的检查。

此区块中不是标准描述，实现要求在下面给出。

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

返回一个node的副本。如否deep为真或者被忽略，则该副本还要包含node的孩子。

如果node是一个文档，则抛出一个“NotSupportedError”异常。

node = document . adoptNode(node)

将node从其他文档移来，并返回该节点。

如果node是一个文档，则抛出一个“NotSupportedError”异常。

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

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

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

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

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

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

此区块中不是标准描述，实现要求在下面给出。

event = document . createEvent(eventInterfaceName)

返回一个事件，其使用的是名字不区分大小写地匹配eventInterfaceName的接口。

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

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

输入的接口	替代的接口
“htmlevents”	“event”
“mouseevents”	“mouseevent”
“mutationevents”	“mutationevent”
“uievents”	“uievent”

注：该方法是极端落后的，现在事件拥有其构造器，但是需要向传统内容提供支持。

此区块中不是标准描述，实现要求在下面给出。

event = document . createRange()

返回一个新的排列。

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

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

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

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

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

DOMImplementation接口

English

当用户代理创建一个文档时，必须同时创建一个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);
};

此区块中不是标准描述，实现要求在下面给出。

hasSupport = document . implementation . hasFeature( feature, version )

返回用户代理是否支持版本为version的feature。空字符串表示任意版本。

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

此区块中不是标准描述，实现要求在下面给出。

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

返回一个DOCTYPE，其中给出qualifiedName、publicId和systemId。如果qualifiedName不匹配产生的Name，将抛出一个“InvalidCharacterError”异常，如果其不匹配产生的QName，将抛出一个“NamespaceError”异常。

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

返回一个XMLDocument，其中给出本地名称为qualifiedName命名空间为namespace的文档元素（如果qualifiedName不为空字符串）和作为其DOCTYPE的doctype（如果给出）。

该方法将抛出与使用相同参数调用createElementNS方法相同的异常。

doc = document . implementation . createHTMLDocument( title )

返回一个文档，其基本的树中已经包含了一个title元素。

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

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

注：没有执行判断publicId匹配PublicChar或者systemId不包含“"”和“'”的检查。

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

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

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

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

DocumentFragment接口

English

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接口

English

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）和类。

注：在历史上，元素可以拥有多个标识符，例如，通过使用HTML id属性和一个DTD。本标准使ID为DOM的一个概念，且仅允许通过id属性为每个元素给出一个ID。

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

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

注：对于本规范定义的用户代理处理任意元素的id和class属性的处理需求，我们不对是否使用它们进行强制要求。

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

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

注：正如节点模型章节中所说的，仅能拥有一个这样的元素。

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

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

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

此区块中不是标准描述，实现要求在下面给出。

namespace = element . namespaceURI

返回其命名空间。

prefix = element . prefix

返回其命名空间前缀。

localName = element . localName

返回其本地名称。

qualifiedName = element . tagName

如果命名空间前缀不为空，则返回由命名空间前缀、“:”和本地名称组成的字符串。反则返回本地名称。（在HTML文档中返回值为大写形式。）

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

如果qualifiedName不匹配XML中产生的Name，则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
如果其上下文对象在HTML命名空间下且其节点对象是一个HTML文档，则将qualifiedName转换为ASCII小写形式。
如果qualifiedName的前缀匹配“xmlns”，则抛出一个NAMESPACE_ERR并终止这些步骤。
如果上下文对象没有限定名为qualifiedName的属性，则创建一个属性，其本地名称为qualifiedName、值为value，将该属性追加到上下文对象的attributes中。
否则，设上下文对象的attributes中第一个限定名为qualifiedName的属性的值为value。

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

如果namespace为空字符串，设其为空。
如果qualifiedName不匹配XML中产生的Name，则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
如果qualifiedName不匹配XML中产生的QName，则抛出一个NAMESPACE_ERR异常并终止这些步骤。
如果qualifiedName包含一个“:”（U+003A），则在该字符串分离该字符串，设prefix为前半部分、localName为后半部分。否则设prefix为空、localName为qualifiedName。
如果prefix为空且namespace为空，则抛出一个NAMESPACE_ERR异常并终止这些步骤。
如果prefix为“xml”且namespac不为XML命名空间，则抛出一个NAMESPACE_ERR异常并终止这些步骤。
如果qualifiedName或prefix为“xmlns”且namespace不为XMLNS命名空间，则抛出一个NAMESPACE_ERR异常并终止这些步骤。
如果namespace为XMLNS命名空间且qualifiedName和prefix均不为“xmlns”，则抛出一个NAMESPACE_ERR异常并终止这些步骤。
如果上下文对象的attributes不包含命名空间为namespace且本地名称为localName的属性，则创建一个属性，其命名空间为namespace、命名空间前缀为prefix、本地名称为localName、值为value，将该属性追加到上下文对象的attributes中。
否则，设上下文对象的attributes中第一个命名空间为namespace、本地名称为localName的属性的值为value，并设其命名空间前缀为prefix。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

此区块中不是标准描述，实现要求在下面给出。

collection = element . children

返回其孩子元素。

element = element . firstElementChild

返回第一个是元素的孩子，否则返回空。

element = element . lastElementChild

返回最后一个是元素的孩子，否则返回空。

element = element . previousElementSibling

返回第一个是元素的之前的兄弟，否则返回空。

element = element . nextElementSibling

返回第一个是元素的之后的兄弟，否则返回空。

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

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

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

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

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

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

Attr接口

English

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接口

English

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是一个抽象接口，不作为节点而存在。其被Text、Comment和ProcessingInstruction 节点使用。

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

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

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

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

设length为node的length属性值。
如果offset大于length，则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
如果offset加上count大于length，则返回一个值为node的数据中从第offset个编码单元到其结尾的编码单元的字符串，并终止这些步骤。
返回一个值为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接口

English

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

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

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

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

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

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

ProcessingInstruction接口

English

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

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

target属性必须返回其目标。

Comment接口

interface Comment : CharacterData {
};

排列

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

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

Range接口

English

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对象被认为是排列。

注：排列可以使用createRange()方法创建。

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

注：通常来说，一个边界点的偏移量应当介于零到该边界点的节点长度之间（含）。对一个树进行修改的算法（特别是插入、移除、替换数据及分离算法）同时也要修改与该树相关联的排列。

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

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

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

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

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

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

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

注：

为了更好地理解这些定义，我们例举了下列实例：

一个内容将被认为包含一个由所有被包含节点组成的排列，如果起始节点和结束节点是Text或Comment 节点还可以加上它们的内容。
被包含在一个排列中的节点通常不是连续的，因为被包含的节点的父亲并非总是被包含的。
不管怎样，一个被包含的节点的后裔都是被包含的，且如果两个兄弟是被包含的，则它们之间的所有兄弟都是被包含的。
第一个被包含的节点（如果存在）总是在起始节点之后，且最后一个被包含的节点总是等于或者在结束节点的最后一个后裔之前。
一个排列的起始节点和结束节点不会被包含在其中。
当且仅当起始节点和结束节点不同时，才会存在一些部分包含的节点。
commonAncestorContainer属性的值是被包含的或被部分包含的之一。
如果起始节点是一个结束节点的祖先，则普通包容性祖先将成为起始节点。其孩子中的一个是被部分包含的，且只有在被部分包含的孩子之前的孩子是被包含的。如果结束节点是一个起始节点的祖先，则执行相反的操作。
如果起始节点不是一个结束节点的包容性祖先，或者相反，则普通包容性祖先将区分它们。其孩子中的两个是被部分包含的，且只有在其两者之间的孩子是被包含的。

此区块中不是标准描述，实现要求在下面给出。

node = range . startContainer

返回range的起始节点。

offset = range . startOffset

返回range的起始偏移量。

node = range . endContainer

返回range的结束节点。

offset = range . endOffset

返回range的结束偏移量。

collapsed = range . #dom-range-collapsed

如果range的起始和结束相同，则返回真，否则返回假。

container = range . commonAncestorContainer

返回一个节点，其尽可能的远离文档，且必须同时是range起始节点和结束节点的祖先。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

如果上下文对象或sourceRange设置了分离标记，则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
如果上下文对象的根与sourceRange的根不相同，则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
如果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的起始。
如果this point到other point的位置为：
- “之前”
  - 返回-1并终止这些算法。
- “等于”
  - 返回0并终止这些算法。
- “之后”
  - 返回1并终止这些算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

此区块中不是标准描述，实现要求在下面给出。

position = range . comparePoint ( parent, offset )

如果该点在排列之前，则返回-1；如果该点在排列之中，则返回0；如果该点在排列之后，则返回1。

intersects = range . intersectsNode ( node )

返回range和node是否交叉。

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

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

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

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

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

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

stringifier必须执行这些步骤：

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

遍历

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

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

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

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

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

NodeIterator接口

English

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对象可以通过createNodeIterator()方法创建。

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

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

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

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

root属性必须返回根。

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

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

whatToShow属性必须返回shatToShow。

filter属性必须返回过滤器。

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

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

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

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

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

TreeWalker接口

English

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

注：TreeWalker对象可以通过createTreeWalker()方法创建。

root属性必须返回根。

whatToShow属性必须返回whatToShow。

filter属性必须返回过滤器。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

NodeFilter接口

English

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接口

English

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

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

此区块中不是标准描述，实现要求在下面给出。

collection . length

返回集合中元素的数目。

element = collection . item(item)

element = collection[item]

返回集合中索引为index的元素。这些元素按照树形结构顺序排列。

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

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

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

HTMLCollection接口

English

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

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

此区块中不是标准描述，实现要求在下面给出。

collection . length

返回集合中元素的数目。

element = collection . item(index)

element = collection[index]

返回集合中索引为index的元素。这些元素按照树形结构顺序排列。

element = collection . namedItem(name)

element = collection[name]

返回集合中第一个ID或名称为name的元素。

HTML命名空间下仅有a、applet、area、embed、form、frame、frameset、iframe、img和object元素可以拥有支持此方法的名称；它们的名称通过它们的name属性的值给出。

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

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接口

English

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

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

此区块中不是标准描述，实现要求在下面给出。

stringlist . length

返回字符串中的标记数目。

string = stringlist . item(index)

stringlist[index]

返回索引为index的字符串。

hasstring = stringlist . contains(string)

如果string存在则返回真，否则返回假。

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

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

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

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

DOMTokenList接口

English

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

此区块中不是标准描述，实现要求在下面给出。

tokenlist . length

返回字符串中的标记数目。

element = tokenlist . item(index)

tokenlist[index]

返回索引为index的标记。标记按照其在基础字符串中被发现的顺序返回。

hastoken = tokenlist . contains(token)

如果token存在则返回真，否则返回假。

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

tokenlist . add(token)

如果token尚未存在，添加token。

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

tokenlist . remove(token)

如果token存在，移除token。

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

hastoken = tokenlist . toggle(token)

如果token不存在，添加token，如果token存在，移除token。如果当前token存在（被添加）则返回真；如果当前token不存在（被移除）则返回假。

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

DOMSettableTokenList接口

English

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

interface DOMSettableTokenList : DOMTokenList {
           attribute DOMString value;
};

此区块中不是标准描述，实现要求在下面给出。

tokenlist . value

返回基础字符串。

可以被设置，以改变基础字符串。

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

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

DOM4/impl

Contents

目标

问题

一致性

依赖关系

可扩展性

术语

树

字符串

通用微语法

通用解析器习语

空格分隔的标记

命名空间

错误

DOMException异常

DOMError接口

事件

Event接口

CustomEvent接口

构造事件

EventTarget接口

指派事件

触发事件

节点

节点模型

改变

Node接口

Document接口

DOMImplementation接口

DocumentFragment接口

DocumentType接口

Element接口

Attr接口

CharacterData接口

Text接口

ProcessingInstruction接口

Comment接口

排列

Range接口

遍历

NodeIterator接口

TreeWalker接口

NodeFilter接口

集合

NodeList接口

HTMLCollection接口

列表

DOMStringList接口

DOMTokenList接口

DOMSettableTokenList接口

DOM特性

历史

DOM事件

DOM核心

DOM排列

DOM遍历

Navigation menu

Search