DOM 标准

1. 基础设施

本规范依赖于现行标准的基础设施标准。[INFRA]

本规范中使用的一些术语定义在编码、选择器、Web IDL、XML和XML中的命名空间中。[ENCODING][SELECTORS4][WEBIDL][XML][XML-NAMES]

当需要扩展时，可以相应地更新 DOM 标准，或者可以编写一个新标准，该标准可以利用为适用的规范提供的可扩展性钩子。

1.1. 树

树是一个有限的层次树结构。树的顺序是对树的先序、深度优先遍历。

参与树的对象有一个父节点，它要么是 null，要么是一个对象，并且有子节点，它是一个对象的有序集合。对象A的父节点是对象B，则A是B的子节点。

对象的根是它自己，如果它的父为null，否则它的根是它的父的根。树的根是参与该树的任意对象，而该对象的父为null。

如果对象A是对象B的子，或者对象A是对象C的子，而C是B的后代，则对象A被称为对象B的后代。

包含后代是指一个对象或其后代之一。

当且仅当B是A的后代时，称对象A为对象B的祖先。

包含祖先是指一个对象或其祖先之一。

当且仅当B和A共享相同的非空父节点时，称对象A为对象B的同胞。

包含同胞是指一个对象或其同胞之一。

如果A和B在同一个树中，并且A在树的顺序中位于B之前，则称对象A先于对象B。

如果A和B在同一个树中，并且A在树的顺序中位于B之后，则称对象A继于对象B。

一个对象的第一个子节点是其第一个子节点，如果它没有子节点，则为 null。

一个对象的最后一个子节点是其最后一个子节点，如果它没有子节点，则为 null。

一个对象的前一个同胞是指其第一个先于的同胞，如果没有，则为 null。

一个对象的下一个同胞是指其第一个继于的同胞，如果没有，则为 null。

一个对象的索引是其先于的同胞的数量，如果没有，则为 0。

1.2. 有序集合

有序集合解析器接受一个字符串input，然后执行以下步骤：

令inputTokens为在 ASCII 空白字符处分割input的结果。
令tokens为一个新的有序集合。
对于 inputTokens 中的每个 token，将 token 追加到 tokens。
返回tokens。

有序集合序列化器接受一个set，并返回使用U+0020 SPACE连接的set的串联结果。

1.3. 选择器

要范围匹配选择器字符串selectors与一个node，请执行以下步骤：

令s为解析选择器selectors的结果。[SELECTORS4]
如果s失败，则抛出一个"SyntaxError"DOMException。
返回将选择器与树匹配的结果，其中s与node的根使用范围根node。[SELECTORS4]。

选择器中的命名空间不计划支持，也不会添加。

1.4. 命名空间

要验证qualifiedName，如果qualifiedName不符合QName生成规则，则抛出一个"InvalidCharacterError"DOMException。

要验证并提取namespace和qualifiedName，请执行以下步骤：

如果namespace是空字符串，则将其设置为null。
验证qualifiedName。
将prefix设为null。
将localName设为qualifiedName。
如果qualifiedName包含U+003A (:)：
1. 将splitResult设为运行严格分割后得到的结果，参数为qualifiedName和U+003A (:)。
2. 将prefix设置为splitResult[0]。
3. 将localName设置为splitResult[1]。
如果prefix非null且namespace为null，则抛出一个"NamespaceError"DOMException。
如果prefix是"xml"且namespace不是XML命名空间，则抛出一个"NamespaceError"DOMException。
如果qualifiedName或prefix是"xmlns"且namespace不是XMLNS命名空间，则抛出一个"NamespaceError"DOMException。
如果namespace是XMLNS命名空间，且qualifiedName或prefix都不是"xmlns"，则抛出一个"NamespaceError"DOMException。
返回namespace、prefix和localName。

2. 事件

2.1. “DOM 事件”简介

在整个 Web 平台中，事件被派发到对象，以标识发生的事件，例如网络活动或用户交互。这些对象实现了EventTarget接口，因此可以通过调用addEventListener()来添加事件监听器以观察事件：

obj.addEventListener("load", imgFetched)

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

事件监听器可以通过使用removeEventListener()方法删除，传递相同的参数。

或者，也可以通过将AbortSignal传递给addEventListener()，然后调用控制器上持有信号的abort()来删除事件监听器。

事件也是对象，并实现了Event接口（或派生接口）。在上面的例子中，ev是事件。ev作为参数传递给事件监听器的回调（通常是如上所示的JavaScript函数）。事件监听器通过事件的type属性值（上例中的"load"）来区分事件。事件的target属性值返回事件被派发到的对象（如上例中的obj）。

虽然事件通常由用户代理在用户交互或某些任务完成时派发，但应用程序可以通过使用通常称为合成事件的方式派发事件。

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

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

除了用于传递信号外，事件有时也用于让应用程序控制操作中的后续步骤。例如，作为表单提交的一部分，type属性值为"submit"的事件被派发。如果调用了该事件的preventDefault()方法，则表单提交将被终止。希望通过应用程序事件（合成事件）派发该功能的应用程序，可以使用dispatchEvent()方法的返回值。

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

当一个事件被派发到一个参与树（例如，一个元素）的对象时，它也可以到达该对象的祖先上的事件监听器。实际上，该对象的所有包含祖先中捕获为true的事件监听器都将按照树的顺序被调用。然后，如果事件的bubbles为true，则该对象的所有包含祖先中捕获为false的事件监听器将按照相反的树的顺序被调用。

让我们看一个事件在树中如何工作的例子：

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

debug函数将被调用两次。每次事件的target属性值将是span元素。第一次currentTarget属性值将是document，第二次将是body元素。eventPhase属性值将从CAPTURING_PHASE切换到BUBBLING_PHASE。如果为span元素注册了一个事件监听器，eventPhase属性值将是AT_TARGET。

2.2. 接口 `Event`

[Exposed=*]
interface Event {
  constructor(DOMString type, optional EventInit eventInitDict = {});

  readonly attribute DOMString type;
  readonly attribute EventTarget? target;
  readonly attribute EventTarget? srcElement; // legacy
  readonly attribute EventTarget? currentTarget;
  sequence<EventTarget> composedPath();

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

  undefined stopPropagation();
           attribute boolean cancelBubble; // legacy alias of .stopPropagation()
  undefined stopImmediatePropagation();

  readonly attribute boolean bubbles;
  readonly attribute boolean cancelable;
           attribute boolean returnValue;  // legacy
  undefined preventDefault();
  readonly attribute boolean defaultPrevented;
  readonly attribute boolean composed;

  [LegacyUnforgeable] readonly attribute boolean isTrusted;
  readonly attribute DOMHighResTimeStamp timeStamp;

  undefined initEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false); // legacy
};

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

一个Event对象通常被称为一个事件。它用于标识某些事情已经发生，例如，一个图像已经完成下载。

一个潜在事件目标是 null 或一个EventTarget对象。

一个事件有一个关联的目标（一个潜在事件目标）。除非另有说明，否则它为 null。

一个事件有一个关联的相关目标（一个潜在事件目标）。除非另有说明，否则它为 null。

其他规范使用相关目标来定义一个relatedTarget属性。[UIEVENTS]

一个事件有一个关联的触摸目标列表（一个列表，包含零个或多个潜在事件目标）。除非另有说明，否则它为空列表。

触摸目标列表专门用于定义TouchEvent接口和相关接口。[TOUCH-EVENTS]

一个事件有一个关联的路径。一个路径是一个列表，包含结构体。每个结构体由一个调用目标（一个EventTarget对象）、一个在 shadow 树中的调用目标（一个布尔值）、一个shadow 调整后的目标（一个潜在事件目标）、一个相关目标（一个潜在事件目标）、一个触摸目标列表（一个列表，包含潜在事件目标）、一个关闭树的根（一个布尔值）和一个关闭树中的插槽（一个布尔值）。一个路径最初为空列表。

event = new Event(type [, eventInitDict]): 返回一个新的event，其type属性值设置为type。eventInitDict参数允许通过同名对象成员设置bubbles和cancelable属性。
event . type: 返回event的类型，例如"click"、"hashchange"或"submit"。
event . target: 返回event被分派的对象（其目标）。
event . currentTarget: 返回当前正在调用其事件侦听器的回调函数的对象。
event . composedPath(): 返回event的调用目标对象（将在其上调用侦听器的对象），但不包括任何节点，这些节点在shadow 树中，其shadow root的模式为"closed"且无法从event的currentTarget到达。
event . eventPhase: 返回事件的阶段，它是以下之一：NONE、CAPTURING_PHASE、AT_TARGET和BUBBLING_PHASE。
event . stopPropagation(): 当在树中分派时，调用此方法会阻止event到达当前对象以外的任何对象。
event . stopImmediatePropagation(): 调用此方法会阻止event在当前侦听器运行结束后到达任何注册的事件侦听器，并且当在树中分派时，也会阻止event到达任何其他对象。
event . bubbles: 根据event的初始化方式返回 true 或 false。如果event通过其目标的祖先按相反的树顺序传播，则为 true；否则为 false。
event . cancelable: 根据event的初始化方式返回 true 或 false。其返回值并不总是有意义，但 true 可以表示在分派event的过程中，部分操作可以通过调用preventDefault()方法来取消。
event . preventDefault(): 如果在cancelable属性值为 true 时调用，并且在执行带有passive设置为 false 的侦听器时，通知导致分派event的操作需要取消。
event . defaultPrevented: 如果成功调用preventDefault()表示取消，则返回 true；否则返回 false。
event . composed: 根据event的初始化情况返回 true 或 false。如果event调用了超过作为其目标的根的ShadowRoot节点的监听器，则返回 true；否则返回 false。
event . isTrusted: 如果event由用户代理分派，则返回 true，否则返回 false。
event . timeStamp: 以毫秒为单位返回event的时间戳，相对于发生时间。

type属性必须返回初始化时的值。当创建一个事件时，必须将该属性初始化为空字符串。

target获取步骤是返回this的目标。

srcElement获取步骤是返回this的目标。

currentTarget属性必须返回初始化时的值。当创建一个事件时，必须将该属性初始化为 null。

composedPath()方法的步骤为：

让composedPath成为一个空的列表。
让path成为this的路径。
如果path为空，则返回composedPath。
让currentTarget成为this的currentTarget属性值。
断言：currentTarget 是一个 EventTarget 对象。
追加currentTarget到composedPath。
将currentTargetIndex设为 0。
将currentTargetHiddenSubtreeLevel设为 0。
将index设为path的大小 - 1。
当index大于或等于 0 时：
1. 如果path[index]的关闭树的根为 true，则将currentTargetHiddenSubtreeLevel增加 1。
2. 如果path[index]的调用目标是currentTarget，则将currentTargetIndex设置为index，并中断。
3. 如果path[index]的关闭树中的插槽为 true，则将currentTargetHiddenSubtreeLevel减少 1。
4. 减少index的值 1。
将currentHiddenLevel和maxHiddenLevel设为currentTargetHiddenSubtreeLevel。
将index设为currentTargetIndex - 1。
当index大于或等于 0 时：
1. 如果path[index]的关闭树的根为 true，则将currentHiddenLevel增加 1。
2. 如果currentHiddenLevel小于或等于maxHiddenLevel，则前置path[index]的调用目标到composedPath。
3. 如果 path[index] 的 slot-in-closed-tree 为 true：
  1. 将currentHiddenLevel减少 1。
  2. 如果currentHiddenLevel小于maxHiddenLevel，则将maxHiddenLevel设为currentHiddenLevel。
4. 减少index的值 1。
将currentHiddenLevel和maxHiddenLevel设为currentTargetHiddenSubtreeLevel。
将index设为currentTargetIndex + 1。
当index小于path的大小时：
1. 如果path[index]的关闭树中的插槽为 true，则将currentHiddenLevel增加 1。
2. 如果currentHiddenLevel小于或等于maxHiddenLevel，则追加path[index]的调用目标到composedPath。
3. 如果 path[index] 的 root-of-closed-tree 为 true：
  1. 将currentHiddenLevel减少 1。
  2. 如果currentHiddenLevel小于maxHiddenLevel，则将maxHiddenLevel设为currentHiddenLevel。
4. 增加index的值 1。
返回composedPath。

eventPhase属性必须返回初始化时的值，该值必须是以下之一：

NONE（数值 0）: 事件当前未被分派时处于此阶段。
CAPTURING_PHASE（数值 1）: 当一个事件被分派到一个参与树的对象时，它将在到达其目标之前处于此阶段。
AT_TARGET（数值 2）: 当一个事件被分派时，它将在其目标上处于此阶段。
BUBBLING_PHASE（数值 3）: 当一个事件被分派到一个参与树的对象时，它将在到达其目标后处于此阶段。

最初该属性必须初始化为NONE。

每个事件都具有以下关联标志，最初都未设置：

停止传播标志
立即停止传播标志
取消标志
在被动侦听器中的标志
合成标志
初始化标志
分派标志

stopPropagation()方法的步骤是设置this的停止传播标志。

cancelBubble获取步骤是如果this的停止传播标志已设置，则返回 true；否则返回 false。

cancelBubble设置步骤是如果给定值为 true，则设置this的停止传播标志；否则不执行任何操作。

stopImmediatePropagation()方法的步骤是设置this的停止传播标志和this的立即停止传播标志。

bubbles和cancelable属性必须返回初始化时的值。

要设置取消标志，给定一个事件event，如果event的cancelable属性值为 true 并且event的在被动侦听器中的标志未设置，则设置event的取消标志，否则不执行任何操作。

returnValue获取步骤是如果this的取消标志已设置，则返回 false；否则返回 true。

returnValue设置步骤是如果给定值为 false，则设置取消标志，并将this作为参数；否则不执行任何操作。

preventDefault()方法的步骤是将取消标志设置为this。

在某些情况下，调用preventDefault()无效。建议用户代理在开发者控制台中记录具体原因，以帮助调试。

defaultPrevented获取步骤是如果this的取消标志已设置，则返回 true；否则返回 false。

composed获取步骤是如果this的合成标志已设置，则返回 true；否则返回 false。

isTrusted属性必须返回初始化时的值。当创建一个事件时，必须将该属性初始化为 false。

isTrusted是一个方便的属性，指示一个事件是否由用户代理分派（而不是使用dispatchEvent()）。唯一的传统例外是click()，它导致用户代理分派一个isTrusted属性初始化为 false 的事件。

timeStamp属性必须返回初始化时的值。

要初始化一个event，使用type、bubbles和cancelable，运行以下步骤：

设置event的初始化标志。
取消设置event的停止传播标志、立即停止传播标志和取消标志。
设置event的isTrusted属性为 false。
设置event的目标为 null。
将event的type属性设置为type。
将event的bubbles属性设置为bubbles。
将event的cancelable属性设置为cancelable。

initEvent(type, bubbles, cancelable)方法的步骤为：

如果this的分派标志已设置，则返回。
初始化 this，使用type、bubbles和cancelable。

initEvent()与事件构造函数是多余的，并且无法设置composed。它必须为了遗留内容而支持。

2.3. 对 `Window` 接口的传统扩展

partial interface Window {
  [Replaceable] readonly attribute (Event or undefined) event; // legacy
};

每个 Window 对象都有一个关联的当前事件（未定义或一个 Event 对象）。除非另有说明，否则它是未定义的。

event 的 getter 步骤是返回 this 的当前事件。

强烈建议 Web 开发者依赖传递给事件监听器的 Event 对象，因为这将产生更具可移植性的代码。此属性在 workers 或 worklets 中不可用，并且对于在 shadow trees 中分派的事件是不准确的。

2.4. 接口 `CustomEvent`

[Exposed=*]
interface CustomEvent : Event {
  constructor(DOMString type, optional CustomEventInit eventInitDict = {});

  readonly attribute any detail;

  undefined initCustomEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional any detail = null); // legacy
};

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

事件使用 CustomEvent 接口可以用于携带自定义数据。

event = new CustomEvent(type [, eventInitDict]): 其工作方式类似于 Event 的构造函数，但 eventInitDict 参数现在还允许设置 detail 属性。
event . detail: 返回创建 event 时的任何自定义数据。通常用于合成事件。

detail 属性必须返回它初始化时的值。

initCustomEvent(type, bubbles, cancelable, detail) 方法的步骤如下：

如果 this 的 dispatch flag 已设置，则返回。
初始化 this ，包括 type、bubbles 和 cancelable。
将 this 的 detail 属性设置为 detail。

2.5. 构造事件

规范可能会为所有或某些事件定义事件构造步骤。该算法接收一个事件event和一个EventIniteventInitDict，如内部事件创建步骤中所示。

这个构造方式可用于Event子类，它们具有比简单的初始化字典成员和IDL属性之间一对一映射更复杂的结构。

当构造函数的Event接口，或继承自Event接口的接口被调用时，必须运行以下步骤，给定参数type和eventInitDict：

运行内部事件创建步骤，以获得event，使用此接口、null、当前时间和eventInitDict。
将event的type属性初始化为type。
返回event。

要使用eventInterface 创建事件，该接口必须是Event或继承自它的接口，并且可选地提供realm realm，运行以下步骤：

如果未提供realm，则将其设置为null。
将dictionary设置为将JavaScript值undefined转换为eventInterface构造函数所接受的字典类型的结果。（此字典类型将是EventInit或继承自它的字典类型。）

如果需要成员，这种方法不起作用；请参见whatwg/dom#600。
运行内部事件创建步骤，以eventInterface、realm、该事件信号发生的时间和dictionary为参数，得到event。

在macOS中，输入操作的发生时间可以通过NSEvent对象的timestamp属性获得。
将event的isTrusted属性初始化为true。
返回event。

创建事件用于需要分别创建和分发事件的其他规范，而不是简单地触发事件。它确保事件的属性初始化为正确的默认值。

内部事件创建步骤，给定eventInterface、realm、time和dictionary，如下所示：

使用eventInterface创建一个新对象作为event的结果。如果realm非空，则使用该realm；否则，使用Web IDL中定义的默认行为。

截至本文撰写时，Web IDL 尚未定义任何默认行为；请参见whatwg/webidl#135。
设置event的初始化标志。
将event的timeStamp属性初始化为给定time和event的相关全局对象的相对高分辨率粗略时间。
对于 dictionary 中的每个 member → value，如果 event 具有标识符为 member 的属性，则将该属性初始化为 value。
运行事件构造步骤，参数为event和dictionary。
返回event。

2.6. 定义事件接口

通常，在定义一个继承自Event的新接口时，请务必征求WHATWG或W3C WebApps WG社区的反馈。

CustomEvent接口可以作为起点。然而，不要引入任何init*Event()方法，因为它们与构造函数是冗余的。继承自Event接口的接口中如果包含此类方法，也只是出于历史原因。

2.7. 接口 `EventTarget`

[Exposed=*]
interface EventTarget {
  constructor();

  undefined addEventListener(DOMString type, EventListener? callback, optional (AddEventListenerOptions or boolean) options = {});
  undefined removeEventListener(DOMString type, EventListener? callback, optional (EventListenerOptions or boolean) options = {});
  boolean dispatchEvent(Event event);
};

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

dictionary EventListenerOptions {
  boolean capture = false;
};

dictionary AddEventListenerOptions : EventListenerOptions {
  boolean passive;
  boolean once = false;
  AbortSignal signal;
};

一个 EventTarget 对象表示一个目标，当某些事情发生时，一个事件可以被派发到该目标。

每个 EventTarget 对象都有一个相关的事件监听器列表（一个由零个或多个事件监听器组成的列表）。它最初是空的列表。

一个事件监听器可以用于观察特定的事件，它由以下部分组成：

类型（一个字符串）
回调（null或一个 EventListener 对象）
捕获（一个布尔值，初始值为false）
被动（null或一个布尔值，初始值为null）
一次性（一个布尔值，初始值为false）
信号（null或一个AbortSignal 对象）
已移除（用于记录的布尔值，初始值为false）

虽然回调是一个 EventListener 对象，事件监听器是一个更广泛的概念，如上所述。

每个 EventTarget 对象还有一个相关的获取父级算法，该算法接收一个事件 event，并返回一个EventTarget 对象。除非另有说明，它返回null。

节点、影子根节点和文档会重写获取父级算法。

每个 EventTarget 对象可以有一个相关的激活行为算法。该激活行为算法接收一个事件，如派发算法中所示。

这是因为用户代理在某些EventTarget 对象上执行某些操作，例如 area 元素，以响应其MouseEvent 的type 属性为click的合成事件。由于Web兼容性问题，它未能被移除，并且现在成为定义激活某些内容的固定方式。[HTML]

每个 EventTarget 对象如果具有激活行为，还可以同时（而非单独）具有遗留预激活行为算法和遗留取消激活行为算法。

这些算法仅存在于复选框和单选框的 input 元素中，不适用于其他任何内容。[HTML]

target = new EventTarget();

创建一个新的EventTarget 对象，开发者可以使用它来派发并监听事件。

target . addEventListener(type, callback [, options])

为type属性值为type的事件附加一个事件侦听器。callback参数设置将在事件分派时调用的回调函数。

当options为true时，监听器在捕获阶段触发；当为false或未设置时，监听器在冒泡阶段触发。无论设置如何，若事件处于目标阶段，监听器均会被触发。

当options设置为true时，表示监听器为被动模式，不会调用preventDefault()来取消事件。

当options设置为true时，表示监听器仅触发一次，触发后将被移除。

若为options指定了AbortSignal，当信号被中止时，监听器将被移除。

若已存在相同type、callback和capture的事件监听器，则不会再次添加。

target . removeEventListener(type, callback [, options])

移除target中与type、callback和options匹配的事件监听器。

target . dispatchEvent(event)

派发event事件，并返回true，若事件的cancelable属性为false或未调用preventDefault()，否则返回false。

要展开 options，请执行以下步骤：

如果options是布尔值，则返回options。
返回options["capture"]。

要进一步展开 options，请执行以下步骤：

令capture为options展开的结果。
令once为false。
令passive和signal为null。
如果options是一个字典，则：
1. 将once设置为options["once"]。
2. 如果options["passive"] 存在，则将passive设置为options["passive"]。
3. 如果options["signal"] 存在，则将signal设置为options["signal"]。
返回capture、passive、once和signal。

new EventTarget()构造函数步骤不执行任何操作。

由于其他地方声明的默认值，返回的EventTarget的获取父级算法将返回null，并且它没有激活行为、遗留预激活行为，或遗留取消激活行为。

将来我们可能会允许自定义获取父级算法。请告诉我们这对您的程序是否有用。目前，所有作者创建的EventTarget 不参与树结构。

默认被动值，给定一个事件类型type和一个EventTarget eventTarget，由下列步骤决定：

若下列条件全部满足，则返回true：
- type是“touchstart”、“touchmove”、“wheel”或“mousewheel”。[TOUCH-EVENTS] [UIEVENTS]
- eventTarget是一个Window 对象，或是一个节点，其节点文档是eventTarget，或是一个节点，其节点文档的文档元素是eventTarget，或是一个节点，其节点文档的主体元素是eventTarget。[HTML]
返回false。

要添加事件监听器，给定一个EventTarget 对象eventTarget和一个事件监听器listener，请执行以下步骤：

若eventTarget是一个ServiceWorkerGlobalScope 对象，其service worker的脚本资源的曾经评估过的标志被设置，且listener的类型与任何service worker 事件的类型属性值匹配，则向控制台报告一个警告，提示这可能不会产生预期结果。[SERVICE-WORKERS]
若listener的信号不为null且已中止，则返回。
若listener的回调为null，则返回。
若listener的被动为null，则将其设置为listener的默认被动值，根据listener的类型和eventTarget。
若eventTarget的事件监听器列表不包含一个事件监听器，其类型是listener的类型，回调是listener的回调，且捕获是listener的捕获，则追加 listener到eventTarget的事件监听器列表中。
若listener的信号不为null，则添加以下中止步骤：
1. 移除事件监听器，使用eventTarget和listener。

添加事件监听器的概念是为了确保事件处理器使用相同的代码路径。[HTML]

addEventListener(type, callback, options) 方法步骤为：

令capture、passive、once和signal为进一步展开 options的结果。
添加事件监听器，使用this和一个事件监听器，其类型是type，回调是callback，捕获是capture，被动是passive，一次性是once，信号是signal。

要移除事件监听器，给定一个EventTarget 对象eventTarget和一个事件监听器 listener，请执行以下步骤：

如果eventTarget是ServiceWorkerGlobalScope对象，并且它的服务工作者的要处理的事件类型集合包含listener的类型，那么报告一个警告到控制台，表明这可能不会产生预期的结果。[SERVICE-WORKERS]
将listener的removed设置为true，并且从eventTarget的事件侦听器列表中移除listener。

HTML 需要这个来定义事件处理器。[HTML]

要移除所有事件监听器，给定一个EventTarget 对象eventTarget，对其每个 listener的事件监听器列表项，移除事件监听器，使用eventTarget和listener。

HTML 需要这个来定义document.open()。[HTML]

removeEventListener(type, callback, options) 方法步骤为：

令capture为展开options的结果。
如果this的事件监听器列表包含一个事件监听器，其类型是type，回调是 callback，且捕获是capture，则移除事件监听器，使用this和该事件监听器。

事件侦听器列表不会包含具有相同type、callback和capture的多个事件侦听器，因为添加事件侦听器会防止这种情况发生。

dispatchEvent(event)方法步骤为：

若event的派发标志已设置，或其初始化标志未设置，则抛出一个“InvalidStateError”DOMException。
将event的isTrusted属性初始化为false。
返回派发 event给this的结果。

2.8. 观察事件监听器

一般来说，开发者不会期望事件监听器的存在是可观察的。事件监听器的影响由其回调决定。也就是说，开发者添加一个无操作的事件监听器时不会期望它有任何副作用。

不幸的是，一些事件API的设计使得要高效实现它们就需要观察事件侦听器。这使得侦听器的存在是可观察的，即使是空的侦听器也可能对应用程序的行为产生显著的性能影响。例如，可以用于阻止异步滚动的触摸和滚轮事件。在某些情况下，可以通过仅在存在至少一个非被动侦听器时将事件指定为可取消来缓解这一问题。例如，非被动触摸事件侦听器必须阻止滚动，但如果所有侦听器都是被动的，则可以通过使触摸事件不可取消（从而忽略对preventDefault()的调用）来允许滚动并行开始。因此，分派事件的代码能够观察到非被动侦听器的缺失，并使用该信息来清除正在分派的事件的可取消属性。

理想情况下，任何新的事件API都应定义为不需要此属性。（请使用whatwg/dom进行讨论。）

要获取遗留的服务工作者获取事件侦听器回调，给定一个ServiceWorkerGlobalScopeglobal，请运行以下步骤。这些步骤将返回一个EventListener对象的列表。

令callbacks为« »。
对于每个 listener的global的事件监听器列表：
1. 如果listener的类型为"fetch"，且 listener的回调不为null，则追加 listener的回调到callbacks。
返回callbacks。

2.9. 分发事件

要将一个事件分发给一个目标，可选带有legacy target override flag和legacyOutputDidListenersThrowFlag，请按以下步骤操作：

设置event的分发标志。
如果未给出legacy target override flag，则将targetOverride设置为目标，否则设置为目标的关联的文档。[HTML]

legacy target override flag仅由HTML使用，且仅当目标是一个窗口对象时使用。
将activationTarget设置为null。
将relatedTarget设置为针对目标重新定位event的relatedTarget的结果。
设 clearTargets 为 false。
如果 target 不是 relatedTarget 或者 target 是 event 的 relatedTarget：
1. 将touchTargets设置为一个新的列表。
2. 对于每个touchTarget，它在event的触摸目标列表中，追加针对目标重新定位touchTarget的结果到touchTargets中。
3. 通过event、目标、targetOverride、relatedTarget、touchTargets，并设置为false，附加到事件路径。
4. 如果event是一个鼠标事件对象，且event的类型属性为"click"，则isActivationEvent为true；否则为false。
5. 如果isActivationEvent为true且目标具有激活行为，则将activationTarget设置为目标。
6. 如果目标是一个slottable且已分配，则将slottable设置为目标，否则为null。
7. 将slot-in-closed-tree设置为false。
8. 将parent设置为调用目标的获取父项结果的event。
9. 当parent非空时：
  1. 如果slottable非空：
    1. 断言：parent是一个插槽。
    2. 将slottable设置为null。
    3. 如果parent的根是一个影子根，且它的模式是"closed"，则将slot-in-closed-tree设置为true。
  2. 如果parent是一个slottable且已分配，则将slottable设置为parent。
  3. 将relatedTarget设置为针对parent重新定位event的relatedTarget的结果。
  4. 将touchTargets设置为一个新的列表。
  5. 对于每个touchTarget，它在event的触摸目标列表中，追加针对parent重新定位touchTarget的结果到touchTargets中。
  6. 如果parent是一个窗口对象，或parent是一个节点且目标的根是parent的包括影子在内的包容性祖先，则：
    1. 如果isActivationEvent为true，event的冒泡属性为true，activationTarget为null，且parent具有激活行为，则将activationTarget设置为parent。
    2. 附加到事件路径通过event、parent、null、relatedTarget、touchTargets，并设置slot-in-closed-tree。
  7. 否则，如果parent是relatedTarget，则将parent设置为null。
  8. 否则：
    1. 将目标设置为parent
    2. 如果isActivationEvent为true，activationTarget为null，且目标具有激活行为，则将activationTarget设置为目标。
    3. 附加到事件路径通过event、parent、目标、relatedTarget、touchTargets，并设置slot-in-closed-tree。
  9. 如果parent非空，则将parent设置为调用parent的获取父项结果的event。
  10. 将slot-in-closed-tree设置为false。
10. 将clearTargetsStruct设置为event的路径中的最后一个结构，其影子调整目标非空。
11. 如果 clearTargetsStruct 的 shadow-adjusted target、clearTargetsStruct 的 relatedTarget，或 clearTargetsStruct 的 touch target list 中的 EventTarget 对象是一个节点，其根是一个影子根：则将 clearTargets 设置为 true。
12. 如果activationTarget非空且activationTarget具有旧式预激活行为，则运行activationTarget的旧式预激活行为。
13. 对于 event 的 path 中的每个 struct，按相反顺序：
  1. 如果struct的影子调整目标非空，则将event的事件阶段属性设置为AT_TARGET。
  2. 否则，将event的事件阶段属性设置为CAPTURING_PHASE。
  3. 调用通过struct、event、"捕获"，以及如果给出的话legacyOutputDidListenersThrowFlag。
14. 对于 event 的 path 中的每个 struct：
  1. 如果struct的影子调整目标非空，则将event的事件阶段属性设置为AT_TARGET。
  2. 否则：
    1. 如果event的冒泡属性为false，则继续。
    2. 将event的事件阶段属性设置为BUBBLING_PHASE。
  3. 调用通过struct、event、"冒泡"，以及如果给出的话legacyOutputDidListenersThrowFlag。
将event的事件阶段属性设置为NONE。
将event的当前目标属性设置为null。
将event的路径设置为空列表。
取消设置event的分发标志、停止传播标志，以及立即停止传播标志。
如果 clearTargets 为 true：
1. 将event的目标设置为null。
2. 将event的relatedTarget设置为null。
3. 将event的触摸目标列表设置为空列表。
如果activationTarget非空：
1. 如果event的取消标志未设置，则使用event运行activationTarget的激活行为。
2. 否则，如果activationTarget具有旧式取消激活行为，则运行activationTarget的旧式取消激活行为。
如果event的取消标志已设置，则返回false；否则返回true。

要附加到事件路径，给定一个event、invocationTarget、shadowAdjustedTarget、relatedTarget、touchTargets，以及slot-in-closed-tree，请运行这些步骤：

将invocationTargetInShadowTree设置为false。
如果invocationTarget是一个节点，且其根是一个影子根，则将invocationTargetInShadowTree设置为true。
将root-of-closed-tree设置为false。
如果invocationTarget是一个影子根，且其模式是"closed"，则将root-of-closed-tree设置为true。
追加一个新的结构到event的路径，其调用目标是invocationTarget，调用目标在影子树中是invocationTargetInShadowTree，影子调整目标是shadowAdjustedTarget，relatedTarget是relatedTarget，触摸目标列表是touchTargets，关闭树的根是root-of-closed-tree，以及slot-in-closed-tree是slot-in-closed-tree。

要调用，给定一个struct、event、阶段，以及可选的legacyOutputDidListenersThrowFlag，请运行这些步骤：

将event的目标设置为event的路径中的最后一个结构，其影子调整目标非空，且为struct或struct之前的结构。
将event的relatedTarget设置为struct的relatedTarget。
将event的触摸目标列表设置为struct的触摸目标列表。
如果event的停止传播标志已设置，则返回。
初始化event的当前目标属性为struct的调用目标。
将listeners设置为event的当前目标属性值的事件侦听器列表的克隆。

这避免了在此点之后添加的事件侦听器被运行。请注意，由于已删除字段，移除仍然有影响。
将invocationTargetInShadowTree设置为struct的调用目标在影子树中。
将found设置为运行内部调用通过event、listeners、阶段、invocationTargetInShadowTree，以及如果给出的话legacyOutputDidListenersThrowFlag的结果。

如果 found 为 false 且 event 的 isTrusted 属性为 true：

将originalEventType设置为event的类型属性值。

如果event的类型属性值匹配下表中的任意字符串，将event的类型属性值设置为同一行匹配字符串旁的字符串，否则返回。

事件类型	旧式事件类型
"`animationend`"	"`webkitAnimationEnd`"
"`animationiteration`"	"`webkitAnimationIteration`"
"`animationstart`"	"`webkitAnimationStart`"
"`transitionend`"	"`webkitTransitionEnd`"

内部调用通过event、listeners、阶段、invocationTargetInShadowTree，以及如果给出的话legacyOutputDidListenersThrowFlag。
将event的类型属性值设置为originalEventType。

要内部调用，给定一个event、listeners、阶段、invocationTargetInShadowTree，以及可选的legacyOutputDidListenersThrowFlag，请运行这些步骤：

让 found 为 false。
对于 listeners 中的每个 listener，其 removed 为 false：
1. 如果 event 的 type 属性值不是 listener 的类型，则继续。
2. 将 found 设为 true。
3. 如果 phase 是 "capturing" 并且 listener 的 capture 为 false，则继续。
4. 如果 phase 是 "bubbling" 并且 listener 的 capture 为 true，则继续。
5. 如果 listener 的 once 为 true，则根据 event 的 currentTarget 属性值和 listener 移除一个事件侦听器。
6. 让 global 成为 listener 的回调的关联的领域的全局对象。
7. 让 currentEvent 为 undefined。
8. 如果 global 是一个 Window 对象：
  1. 将 currentEvent 设为 global 的当前事件。
  2. 如果 invocationTargetInShadowTree 为 false，则将 global 的当前事件设为 event。
9. 如果 listener 的 passive 为 true，则设定 event 的被动监听器标志。
10. 如果 global 是一个 Window 对象，则记录事件监听器的计时信息，使用 event 和 listener。
11. 调用用户对象的操作，使用 listener 的回调，"handleEvent"，«event»，以及 event 的 currentTarget 属性值。如果这会抛出一个异常 exception：
  1. 报告 exception，用于 listener 的回调的相应 JavaScript 对象的关联领域的全局对象。
  2. 设置 legacyOutputDidListenersThrowFlag（如果提供）。
    
    legacyOutputDidListenersThrowFlag 仅被 Indexed Database API 使用。[INDEXEDDB]
12. 取消设定 event 的被动监听器标志。
13. 如果 global 是一个 Window 对象，则将 global 的当前事件设为 currentEvent。
14. 如果 event 的停止立即传播标志已设置，则中断。
返回 found。

2.10. 触发事件

要在target上触发事件，事件名为e，可选地使用eventConstructor，并描述如何初始化IDL属性，以及legacy target override flag，请执行以下步骤：

如果未给出eventConstructor，则令eventConstructor为Event。
令event为根据eventConstructor 创建事件的结果，且在target的相关领域中。
将event的type属性初始化为e。
按照此算法调用时描述的内容初始化event的其他IDL属性。

这也允许将isTrusted属性设置为false。
返回调度event到target的结果，并在设置时设置legacy target override flag。

在 DOM 的上下文中，"Fire" 是创建、初始化和分派一个事件的缩写。Fire an event 使得这个过程更容易表达。

如果事件需要其 bubbles 或cancelable 属性初始化，可以这样写：“fire an event named submit at target with its cancelable attribute initialized to true”。

或者，当需要自定义构造函数时，可以这样写：“fire an event named click at target using MouseEvent with its detail attribute initialized to 1”。

有时返回值很重要：

让 doAction 成为 firing an event named like at target 的结果。
如果 doAction 为真，那么……

2.11. 行为与发生

一个事件表示一次发生，而不是一个行为。换句话说，它代表来自算法的通知，并可用于影响该算法的未来进程（例如，通过调用 preventDefault()）。事件不得用作导致某些算法开始运行的行为或发起者。那不是它们的用途。

在此特别指出这一点，是因为 DOM 的先前迭代具有与事件关联的“默认行为”概念，这给人们带来了所有错误的想法。事件不代表或导致行为，它们只能用于影响正在进行的行为。

3. 中止正在进行的活动

尽管 promise 没有内置的中止机制，但许多使用它们的 API 都需要中止语义。AbortController 旨在通过提供一个 abort() 方法来支持这些要求，该方法可以切换相应 AbortSignal 对象的状态。希望支持中止的 API 可以接受一个 AbortSignal 对象，并使用其状态来确定如何继续。

鼓励依赖 AbortController 的 API 通过使用 AbortSignal 的中止原因来拒绝任何未解决的 promise，从而响应 abort()。

一个假设的doAmazingness({ ... })方法可以通过接受AbortSignal对象来支持中止，类似如下：

const controller = new AbortController();
const signal = controller.signal;

startSpinner();

doAmazingness({ ..., signal })
  .then(result => ...)
  .catch(err => {
    if (err.name == 'AbortError') return;
    showUserErrorMessage();
  })
  .then(() => stopSpinner());

// …

controller.abort();

doAmazingness could be implemented as follows:

function doAmazingness({signal}) {
  return new Promise((resolve, reject) => {
    signal.throwIfAborted();

    // Begin doing amazingness, and call resolve(result) when done.
    // But also, watch for signals:
    signal.addEventListener('abort', () => {
      // Stop doing amazingness, and:
      reject(signal.reason);
    });
  });
}

不返回promise的API可以选择以类似的方式做出反应，或者选择完全不展示AbortSignal的中止原因。addEventListener()就是一个适合后者的API例子。

需要更精细控制的API可以根据需要扩展AbortController和AbortSignal对象。

3.1. 接口 `AbortController`

[Exposed=*]
interface AbortController {
  constructor();

  [SameObject] readonly attribute AbortSignal signal;

  undefined abort(optional any reason);
};

controller = new AbortController(): 返回一个新的controller，其signal被设置为新创建的AbortSignal对象。
controller . signal: 返回与此对象关联的AbortSignal对象。
controller . abort(reason): 调用此方法将把reason存储在此对象的AbortSignal的中止原因中，并向任何观察者发出信号，表示相关活动将被中止。如果reason未定义，则会存储一个"AbortError"DOMException。

一个AbortController对象有一个关联的信号（一个AbortSignal对象）。

new AbortController()构造函数步骤如下：

让signal成为一个新的AbortSignal对象。
设置this的signal为signal。

signal的getter步骤是返回this的signal。

abort(reason)方法步骤是在signal abort上执行，带有reason如果给定。

在AbortController的controller上带有可选的reason执行signal abort，如果reason被提供。

3.2. 接口`AbortSignal`

[Exposed=*]
interface AbortSignal : EventTarget {
  [NewObject] static AbortSignal abort(optional any reason);
  [Exposed=(Window,Worker), NewObject] static AbortSignal timeout([EnforceRange] unsigned long long milliseconds);
  [NewObject] static AbortSignal _any(sequence<AbortSignal> signals);

  readonly attribute boolean aborted;
  readonly attribute any reason;
  undefined throwIfAborted();

  attribute EventHandler onabort;
};

AbortSignal . abort(reason): 返回一个AbortSignal实例，其中止原因设置为reason（如果未定义则为"AbortError"DOMException）。
AbortSignal . any(signals): 返回一个AbortSignal实例，该实例将在任一signals中止时中止。其中止原因将被设置为导致中止的signals中的某一个。
AbortSignal . timeout(milliseconds): 返回一个AbortSignal实例，该实例将在milliseconds毫秒后中止。其中止原因将被设置为"TimeoutError"DOMException。
signal . aborted: 如果signal的AbortController已发出中止信号，则返回true；否则返回false。
signal . reason: 返回signal的中止原因。
signal . throwIfAborted(): 如果signal的AbortController已发出中止信号，则抛出signal的中止原因；否则不执行任何操作。

一个AbortSignal对象有一个关联的中止原因（一个JavaScript值），其初始状态为未定义。

一个AbortSignal对象有一个关联的中止算法（一组将在中止时执行的算法），其初始状态为空。

中止算法使得具有复杂要求的API能够合理地响应abort()。例如，给定API的中止原因可能需要传播到跨线程环境，例如service worker。

一个AbortSignal对象有一个依赖项（一个布尔值），其初始状态为false。

一个AbortSignal对象有一个关联的源信号（一组AbortSignal对象），其初始状态为空。

一个AbortSignal对象有一个关联的依赖信号（一组依赖于对象的AbortSignal对象），其初始状态为空。

静态方法abort(reason)的步骤如下：

让signal成为一个新的AbortSignal对象。
将signal的中止原因设置为reason，如果给定；否则设置为新的"AbortError"DOMException。
返回signal。

静态方法timeout(milliseconds)的步骤如下：

让signal成为一个新的AbortSignal对象。
让global成为signal的相关全局对象。
在超时后运行步骤，给定global、"AbortSignal-timeout"、milliseconds，以及以下步骤：
1. 在全局任务队列中排队，在global上，基于signal和新的"TimeoutError"DOMException执行signal abort。
在此超时时间内，如果signal已为其abort事件注册了任何事件监听器，则必须从global到signal保持一个强引用。
返回signal。

静态方法any(signals)的步骤是返回创建一个依赖的中止信号的结果，使用signals、AbortSignal和当前领域。

abortedgetter步骤是返回true如果this已中止；否则返回false。

reasongetter步骤是返回this的中止原因。

throwIfAborted()方法步骤是抛出this的中止原因，如果this已中止。

此方法主要用于当接受AbortSignal的函数希望在特定检查点抛出（或返回一个被拒绝的promise），而不是将AbortSignal传递给其他方法时。例如，以下函数允许在每次尝试轮询条件之间中止。这为中止轮询过程提供了机会，即使实际的异步操作（即await func()）不接受AbortSignal。

async function waitForCondition(func, targetValue, { signal } = {}) {
  while (true) {
    signal?.throwIfAborted();

    const result = await func();
    if (result === targetValue) {
      return;
    }
  }
}

属性 onabort 是一个事件处理程序 IDL 属性，用于 onabort 事件处理程序，其事件处理程序事件类型是 abort。

对 AbortSignal 对象的更改代表了相应的 AbortController 对象的意图，但观察 AbortSignal 对象的 API 可以选择忽略这些更改。例如，如果操作已经完成。

当 AbortSignal 对象的中止原因不为未定义时，该对象被认为是已中止。

要向 AbortSignal 对象 signal 中添加一个算法 algorithm：

如果 signal 已中止，则返回。
将 algorithm 追加到 signal 的中止算法中。

要从 AbortSignal signal 中移除一个算法 algorithm，请从 signal 的中止算法中移除 algorithm。

要发出中止信号，给定一个 AbortSignal 对象 signal 和一个可选的 reason：

如果 signal 已经中止，则返回。
将 signal 的中止原因设为 reason（如果提供）；否则设为一个新的 "AbortError" DOMException。
将 dependentSignalsToAbort 设为一个新的列表。
对于每个 dependentSignal 在 signal 的依赖信号中：
1. 如果 dependentSignal 尚未中止：
  1. 将 dependentSignal 的中止原因设为 signal 的中止原因。
  2. 附加 dependentSignal 到 dependentSignalsToAbort。
运行中止步骤对于 signal。
对于每个 dependentSignal 在 dependentSignalsToAbort 中，运行中止步骤对于 dependentSignal。

要运行中止步骤对于一个 AbortSignal signal：

对于每个 algorithm 在 signal 的中止算法中：运行 algorithm。
清空 signal 的中止算法。
触发事件，名为 abort，在 signal 上。

要从 AbortSignal 对象列表 signals 创建一个依赖中止信号，使用 signalInterface（它必须是 AbortSignal 或继承自它的接口）和一个 realm：

令 resultSignal 为一个使用 realm 实现 signalInterface 的新对象。
对于 signals 中的每个 signal：如果 signal 已中止，则将 resultSignal 的中止原因设置为 signal 的中止原因并返回 resultSignal。
将 resultSignal 的依赖属性设置为 true。
对于 signals 中的每个 signal：
1. 如果 signal 的依赖属性为 false：
  1. 将 signal 追加到 resultSignal 的源信号列表中。
  2. 将 resultSignal 追加到 signal 的依赖信号列表中。
2. 否则，对于 signal 的源信号列表中的每个 sourceSignal：
  1. 断言：sourceSignal 未中止且其依赖属性不为 true。
  2. 将 sourceSignal 追加到 resultSignal 的源信号列表中。
  3. 将 resultSignal 追加到 sourceSignal 的依赖信号列表中。
返回 resultSignal。

3.2.1. 垃圾回收

一个未中止的依赖的 AbortSignal 对象，当其源信号列表非空并且它已为其 abort 事件注册了事件监听器或者其中止算法列表非空时，不能被垃圾回收。

3.3. 在 API 中使用 `AbortController` 和 `AbortSignal` 对象

任何使用 promises 表示可以中止操作的 Web 平台 API 必须遵循以下规则：

通过 signal 字典成员接受 AbortSignal 对象。
通过使用 AbortSignal 对象的中止原因来拒绝 promise，从而传达操作已中止。
如果 AbortSignal 已经中止，则立即拒绝，否则：
使用中止算法机制来观察 AbortSignal 对象的更改，并以不导致与其他观察者冲突的方式执行此操作。

返回 promise 的方法 doAmazingness(options) 的方法步骤可能如下：

让 global成为此的相关全局对象。
让 p成为一个新的 promise。
如果 options["signal"] 存在：
1. 让 signal成为options["signal"]。
2. 如果 signal已中止，则拒绝p，使用signal的中止原因，并返回 p。
3. 添加以下中止步骤到signal：
  1. 停止做令人惊叹的事情。
  2. 拒绝p，使用signal的中止原因。
并行运行这些步骤：
1. 让 amazingResult成为做一些令人惊叹的事情的结果。
2. 在全局任务队列中添加一个任务，任务源为global，以解决p，并将amazingResult作为参数。
返回 p。

不使用 promises 的 API 仍应尽可能遵循上述规则。

4. 节点

4.1. “DOM”简介

在其原始意义上，“DOM”是一个用于访问和操作文档（特别是HTML和XML文档）的API。在本规范中，术语“文档”用于任何基于标记的资源，从简短的静态文档到包含丰富多媒体的长篇文章或报告，以及功能齐全的交互式应用程序。

每个这样的文档都表示为一个节点树。树中的一些节点可以有子节点，而其他的总是叶子节点。

为了说明这一点，考虑以下HTML文档：

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

它表示如下：

文档
- 文档类型：html
- 元素： html class="e"
  - 元素： head
    - 元素： title
      - 文本： Aliens?
  - 文本： ⏎␣
  - 元素： body
    - 文本： Why yes.⏎

请注意，由于HTML解析的神奇之处，并非所有ASCII空白字符都被转化为文本节点，但总体概念是清晰的。标记进入，树形节点输出。

可以使用非常棒的Live DOM Viewer来更详细地探索这个问题。

4.2. 节点树

节点是实现了实现Node的对象。节点参与一个称为节点树的树。

实际上，你处理的是更具体的对象。

实现了实现Node的对象也实现了一个继承的接口：Document、DocumentType、DocumentFragment、Element、CharacterData或Attr。

实现了DocumentFragment的对象有时会实现ShadowRoot。

实现了Element的对象通常也会实现一个继承的接口，例如HTMLAnchorElement。

实现了CharacterData的对象也会实现一个继承的接口：Text、ProcessingInstruction或Comment。

实现了Text的对象有时会实现CDATASection。

因此，每个节点的主要接口是以下之一：Document、DocumentType、DocumentFragment、ShadowRoot、Element或Element的一个继承接口，Attr、Text、CDATASection、ProcessingInstruction或Comment。

为简洁起见，本规范将实现了Node和继承接口NodeInterface的对象称为NodeInterface节点。

节点树的限制如下，表示为节点及其潜在子节点之间的关系：

Document

按树顺序：

零个或多个ProcessingInstruction或Comment节点。
可选地包含一个DocumentType节点。
零个或多个ProcessingInstruction或 Comment节点。
可选地包含一个Element节点。
零个或多个ProcessingInstruction或Comment节点。

DocumentFragment

Element

零个或多个Element或CharacterData节点。

DocumentType

CharacterData

Attr

没有子节点。

Attr节点参与一个树的历史原因；它们从不具有（非空）父节点或任何子节点，因此在一个树中是孤立的。

要确定节点node的长度，请执行以下步骤：

如果node是DocumentType或Attr节点，则返回0。
如果node是CharacterData节点，则返回node的数据的长度。
返回node的子节点的数量。

如果节点的长度为0，则该节点被视为空的。

4.2.1. 文档树

文档树是一个节点树，其根是一个文档。

文档元素是一个文档中其父节点是该文档的元素；如果不存在，则为 null。

根据节点树的限制，这样的元素只能有一个。

当一个节点的根是文档时，该节点被认为是在文档树中。

当一个节点被认为在文档中，它在文档树中。术语在文档中不再被使用。它表明使用它的标准尚未更新，以考虑到影子树。

4.2.2. 影子树

影子树是一个节点树，其根是一个影子根。

影子根总是通过其宿主附加到另一个节点树。因此，影子树永远不会是孤立的。影子根的宿主的节点树有时被称为光树。

一个影子树的相应光树本身可以是一个影子树。

当一个节点的包含影子的根是一个文档时，该节点被认为是已连接的。

4.2.2.1. 插槽

一个影子树包含零个或多个元素，它们是插槽。

一个插槽只能通过HTML的slot元素创建。

一个插槽有一个关联的名称（一个字符串）。除非另有说明，否则它是空字符串。

使用这些属性更改步骤来更新一个插槽的名称：

如果element是一个插槽，localName是name，且namespace为空：
1. 如果value是oldValue，则返回。
2. 如果value为null且oldValue为空字符串，则返回。
3. 如果value为空字符串且oldValue为null，则返回。
4. 如果value为null或空字符串，则将element的名称设置为空字符串。
5. 否则，将element的名称设置为value。
6. 使用element的根运行为树分配可插槽对象。

一个插槽是一个影子树中的第一个，在树顺序中，其名称为空字符串的插槽，有时被称为“默认插槽”。

一个插槽有一个关联的分配的节点（一个可插槽对象的列表）。除非另有说明，否则它是空的。

4.2.2.2. 可插槽对象

元素和文本节点是可插槽对象。

插槽可以是一个可插槽对象。

一个可插槽对象有一个关联的名称（一个字符串）。除非另有说明，否则它是空字符串。

使用这些属性更改步骤来更新可插槽对象的名称：

如果localName是slot且namespace为空：
1. 如果value是oldValue，则返回。
2. 如果value为null且oldValue为空字符串，则返回。
3. 如果value为空字符串且oldValue为null，则返回。
4. 如果value为null或空字符串，则将element的名称设置为空字符串。
5. 否则，将element的名称设置为value。
6. 如果element是已分配，则为element的已分配插槽运行分配可插槽对象。
7. 为element运行分配插槽。

字母A 可插槽元素有一个关联的已分配插槽（null或插槽）。除非另有说明，否则它为null。字母A 可插槽元素是已分配的，如果它的已分配插槽非null。

一个可插槽对象有一个关联的手动插槽分配（null或插槽）。除非另有说明，否则它是null。

一个可插槽对象的手动插槽分配可以使用对插槽的弱引用来实现，因为这个变量不能直接从脚本访问。

4.2.2.3. 查找插槽和可插槽对象

要查找插槽，对于给定的可插入对象 slottable 和一个可选的布尔值 open（默认为 false）：

如果 slottable 的父节点为 null，则返回 null。
设 shadow 为 slottable 的父节点的影子根。
如果 shadow 为 null，则返回 null。
如果 open 为 true 且 shadow 的模式不为“open”，则返回 null。
如果 shadow 的插槽分配为“manual”，则返回 shadow 的后代中其手动分配的节点包含 slottable 的插槽（如果存在）；否则返回 null。
返回 shadow 的后代中按树顺序排列的第一个其名称为 slottable 的名称的插槽（如果存在）；否则返回 null。

要查找可插入对象，对于给定的插槽 slot：

设 result 为 « »。
设 root 为 slot 的根。
如果 root 不是影子根，则返回 result。
设 host 为 root 的宿主。
如果 root 的插槽分配为“manual”：
1. 对于 slot 的手动分配的节点中的每个可插入对象 slottable，如果 slottable 的父节点是 host，则将 slottable 追加到 result。
否则，对于 host 的每个可插入对象子节点 slottable，按树顺序：
1. 设 foundSlot 为给定 slottable 查找插槽的结果。
2. 如果 foundSlot 是 slot，则将 slottable 追加到 result。
返回 result。

要查找扁平化可插入对象，对于给定的插槽 slot：

设 result 为 « »。
如果 slot 的根不是影子根，则返回 result。
设 slottables 为给定 slot 查找可插入对象的结果。
如果 slottables 是空列表，则将 slot 的每个可插入对象子节点按树顺序追加到 slottables。
对于 slottables 中的每个 node：
1. 如果 node 是一个插槽，其根是一个影子根：
  1. 设 temporaryResult 为给定 node 查找扁平化可插入对象的结果。
  2. 将 temporaryResult 中的每个可插入对象按顺序追加到 result。
2. 否则，将 node 追加到 result。
返回 result。

4.2.2.4. 分配可插槽对象和插槽

要为插槽 slot 分配可插入对象：

设 slottables 为为 slot 查找可插入对象的结果。
如果 slottables 和 slot 的已分配节点不相同，则为 slot 运行发出插槽更改信号。
将 slot 的已分配节点设置为 slottables。
对于 slottables 中的每个 slottable，将 slottable 的已分配插槽设置为 slot。

要为树分配可插入对象，给定一个节点 root，按树顺序为 root 的包含后代中的每个插槽运行分配可插入对象。

要分配插槽，给定一个可插入对象 slottable：

设 slot 为使用 slottable 查找插槽的结果。
如果 slot 非空，则为 slot 运行分配可插入对象。

4.2.2.5. 发出插槽变更信号

每个相同来源窗口代理都有一个信号插槽（集合中的一部分插槽），其初始值为空。[HTML]

要为一个插槽 slot 发出插槽更改信号：

将 slot 追加到 slot 的相关代理的信号插槽列表。
将突变观察者微任务排入队列。

4.2.3. 变异算法

要确保预插入有效性，即将节点 node 插入到节点 parent 中，位于节点 child 之前：

如果 parent 不是 Document、DocumentFragment 或 Element 节点，则抛出一个“HierarchyRequestError”DOMException。
如果 node 是 parent 的宿主包含的祖先节点，则抛出一个“HierarchyRequestError”DOMException。
如果 child 非空且其父节点不是 parent，则抛出一个“NotFoundError”DOMException。
如果 node 不是 DocumentFragment、DocumentType、Element 或 CharacterData 节点，则抛出一个“HierarchyRequestError”DOMException。
如果 node 是一个 Text 节点且 parent 是一个文档，或者 node 是一个文档类型且 parent 不是一个文档，则抛出一个“HierarchyRequestError”DOMException。
如果 parent 是一个文档，并且以下根据 node 实现的接口切换的任何语句为真，则抛出一个“HierarchyRequestError”DOMException。

DocumentFragment

如果 node 有多个元素子节点或有一个 Text 节点子节点。

否则，如果 node 有一个元素子节点，并且 parent 有一个元素子节点，或者 child 是一个文档类型，或者 child 非空且一个文档类型跟随 child。

Element

parent 有一个元素子节点，child 是一个文档类型，或者 child 非空且一个文档类型跟随 child。

DocumentType

parent 有一个文档类型子节点，child 非空且一个元素位于 child 之前，或者 child 为空且 parent 有一个元素子节点。

要将一个 node 预插入到 parent 中，位于 child 之前，请执行以下步骤：

确保预插入有效性，即将 node 插入到 parent 中，位于 child 之前。
设 referenceChild 为 child。
如果 referenceChild 是 node，则将 referenceChild 设置为 node 的下一个兄弟节点。
将 node 插入到 parent 中，位于 referenceChild 之前。
返回 node。

规范可以为所有或部分节点定义插入步骤。如下面的插入算法所示，该算法传递了 insertedNode。这些步骤不得修改 insertedNode 参与的节点树，创建浏览上下文，触发事件，或以其他方式执行 JavaScript。但是，这些步骤可以将任务排入队列以异步执行这些操作。

虽然插入步骤不能执行JavaScript（以及其他事情），但它们确实会产生脚本可观察到的后果。请考虑以下示例：

const h1 = document.querySelector('h1');

const fragment = new DocumentFragment();
const script = fragment.appendChild(document.createElement('script'));
const style = fragment.appendChild(document.createElement('style'));

script.innerText= 'console.log(getComputedStyle(h1).color)'; // Logs 'rgb(255, 0, 0)'
style.innerText = 'h1 {color: rgb(255, 0, 0);}';

document.body.append(fragment);

上例中的脚本记录了'rgb(255, 0, 0)'，因为以下事件按顺序发生：

运行了插入算法，该算法会按顺序插入script和style元素。
1. HTML 标准的插入步骤为script元素运行；它们什么都不做。[HTML]
2. HTML 标准的插入步骤为style元素运行；它们立即将其样式规则应用于文档。[HTML]
3. HTML 标准的连接后步骤为script元素运行；它们运行脚本，该脚本立即观察到上一步中应用的样式规则。[HTML]

规范还可以为所有或部分节点定义连接后步骤。如下面的插入算法所示，该算法传递了 connectedNode。

连接后步骤的目的是为节点提供一个机会来执行任何与连接相关的操作，这些操作会修改 connectedNode 参与的节点树，创建浏览上下文，或以其他方式执行 JavaScript。这些步骤允许一批节点相对于脚本原子地插入，所有主要的副作用都发生在批量插入到节点树完成之后。这确保了所有待处理的节点树插入在更多插入发生之前完全完成。

规范可以为所有或部分节点定义子节点更改步骤。该算法不传递任何参数，并从插入、移除和替换数据中调用。

要将节点插入到父节点中的子节点之前，并带有一个可选的抑制观察者标志，请运行以下步骤：

设 nodes 为 node 的子节点（如果 node 是一个 DocumentFragment 节点）；否则为 « node »。
设 count 为 nodes 的大小。
如果 count 为 0，则返回。
如果 node 是一个 DocumentFragment 节点：
1. 设置抑制观察者标志并移除其子节点。
2. 为 node 排队一个树突变记录，其中包含 « »、nodes、null 和 null。
  
  此步骤有意不关注抑制观察者标志。
如果 child 非空：
1. 对于每个活动范围，其起始节点为 parent 且起始偏移量大于 child 的索引，将其起始偏移量增加 count。
2. 对于每个活动范围，其结束节点为 parent 且结束偏移量大于 child 的索引，将其结束偏移量增加 count。
设 previousSibling 为 child 的前一个兄弟节点，如果 child 为 null，则为 parent 的最后一个子节点。
对于 nodes 中的每个 node，按树顺序：
1. 将 node 采纳到 parent 的节点文档中。
2. 如果 child 为 null，则将 node 追加到 parent 的子节点。
3. 否则，在 parent 的子节点中，在 child 的索引之前插入 node。
4. 如果 parent 是一个影子宿主，其影子根的插槽分配为“named”且 node 是一个可插入对象，则为 node 分配一个插槽。
5. 如果 parent 的根是一个影子根，并且 parent 是一个插槽，其已分配节点为空列表，则为 parent 运行发出插槽更改信号。
6. 使用 node 的根运行为树分配可插入对象。
7. 对于 node 的每个包含影子的包含后代 inclusiveDescendant，按包含影子的树顺序：
  1. 使用 inclusiveDescendant 运行插入步骤。
  2. 如果 inclusiveDescendant 未连接，则继续。
  3. 如果 inclusiveDescendant 是一个元素：
    1. 如果 inclusiveDescendant 的自定义元素注册表为 null，则将 inclusiveDescendant 的自定义元素注册表设置为查找自定义元素注册表的结果，给定 inclusiveDescendant 的父节点。
    2. 否则，如果 inclusiveDescendant 的自定义元素注册表的作用域为 true，则将 inclusiveDescendant 的节点文档追加到 inclusiveDescendant 的自定义元素注册表的作用域文档集。
    3. 如果 inclusiveDescendant 是自定义的，则使用 inclusiveDescendant、回调名称“connectedCallback”和 « » 将自定义元素回调反应排入队列。
    4. 否则，尝试升级 inclusiveDescendant。
      
      如果此操作成功升级了 inclusiveDescendant，则其 connectedCallback 将在升级元素算法期间自动排队。
  4. 否则，如果 inclusiveDescendant 是一个影子根：
    1. 如果 inclusiveDescendant 的自定义元素注册表为 null 且 inclusiveDescendant 的保持自定义元素注册表为 null 为 false，则将 inclusiveDescendant 的自定义元素注册表设置为查找自定义元素注册表的结果，给定 inclusiveDescendant 的宿主。
    2. 否则，如果 inclusiveDescendant 的自定义元素注册表非 null 且 inclusiveDescendant 的自定义元素注册表的作用域为 true，则将 inclusiveDescendant 的节点文档追加到 inclusiveDescendant 的自定义元素注册表的作用域文档集。
如果抑制观察者标志未设置，则为 parent 排队一个树突变记录，其中包含 nodes、« »、previousSibling 和 child。
为 parent 运行子节点更改步骤。
设 staticNodeList 为一个列表，其中包含节点，初始值为 « »。

我们在对任何一个节点调用连接后步骤之前收集所有节点，而不是在遍历节点树时调用连接后步骤。这是因为连接后步骤可以修改树的结构，从而使实时遍历不安全，并可能导致在同一个节点上多次调用连接后步骤。
对于 nodes 中的每个 node，按树顺序：
1. 对于 node 的每个包含影子的包含后代 inclusiveDescendant，按包含影子的树顺序，将 inclusiveDescendant 追加到 staticNodeList。
对于 staticNodeList 中的每个 node，如果 node 已连接，则使用 node 运行连接后步骤。

规范可以为所有或部分节点定义移动步骤。如下面的移动算法所示，该算法传递了一个节点 movedNode 和一个节点或 null 的 oldParent。与插入步骤类似，这些步骤不得修改 movedNode 参与的节点树，不得创建浏览上下文、触发事件或以其他方式执行 JavaScript。但是，这些步骤可以将任务排入队列以异步执行这些操作。

要移动一个节点 node 到一个节点 newParent 中，位于一个节点或 null 的 child 之前：

如果 newParent 的包含影子的根与 node 的包含影子的根不同，则抛出一个 “HierarchyRequestError” DOMException。

这具有确保仅当 newParent 的已连接状态与 node 的已连接状态相同时才执行移动的副作用。
如果 node 是 newParent 的宿主包含的祖先节点，则抛出一个“HierarchyRequestError” DOMException。
如果 child 非空且其父节点不是 newParent，则抛出一个“NotFoundError” DOMException。
如果 node 不是一个 Element 或一个 CharacterData 节点，则抛出一个“HierarchyRequestError” DOMException。
如果 node 是一个 Text 节点且 newParent 是一个文档，则抛出一个“HierarchyRequestError” DOMException。
如果 newParent 是一个文档，node 是一个 Element 节点，并且或者 newParent 有一个元素子节点，child 是一个文档类型，或者 child 非空且一个文档类型跟随 child，则抛出一个 “HierarchyRequestError” DOMException。
设 oldParent 为 node 的父节点。
断言： oldParent 非空。
运行活动范围预移除步骤，给定 node。
对于每个其根的节点文档是 node 的节点文档的 NodeIterator 对象 iterator，运行给定 node 和 iterator 的NodeIterator 预移除步骤。
设 oldPreviousSibling 为 node 的前一个兄弟节点。
设 oldNextSibling 为 node 的下一个兄弟节点。
从 oldParent 的子节点中移除 node。
如果 node 已分配，则为 node 的已分配插槽运行分配可插入对象。
如果 oldParent 的根是一个影子根，并且 oldParent 是一个插槽，其已分配节点为空，则为 oldParent 运行发出插槽更改信号。
如果 node 有一个作为插槽的包含后代：
1. 使用 oldParent 的根运行为树分配可插入对象。
2. 使用 node 运行为树分配可插入对象。
如果 child 非空：
1. 对于每个活动范围，其起始节点为 newParent 且起始偏移量大于 child 的索引，将其起始偏移量增加 1。
2. 对于每个活动范围，其结束节点为 newParent 且结束偏移量大于 child 的索引，将其结束偏移量增加 1。
设 newPreviousSibling 为 child 的前一个兄弟节点（如果 child 非空），否则为 newParent 的最后一个子节点。
如果 child 为 null，则将 node 追加到 newParent 的子节点。
否则，在 newParent 的子节点中，在 child 的索引之前插入 node。
如果 newParent 是一个影子宿主，其影子根的插槽分配为“named”且 node 是一个可插入对象，则为 node 分配一个插槽。
如果 newParent 的根是一个影子根，并且 newParent 是一个插槽，其已分配节点为空，则为 newParent 运行发出插槽更改信号。
使用 node 的根运行为树分配可插入对象。
对于 node 的每个包含影子的包含后代 inclusiveDescendant，按包含影子的树顺序：
1. 如果 inclusiveDescendant 是 node，则使用 inclusiveDescendant 和 oldParent 运行移动步骤。否则，使用 inclusiveDescendant 和 null 运行移动步骤。
  
  因为移动算法是独立于插入和移除的原语，所以它不会为 inclusiveDescendant 调用传统的插入步骤或移除步骤。
2. 如果 inclusiveDescendant 是自定义的且 newParent 已连接，则使用 inclusiveDescendant、回调名称 “connectedMoveCallback” 和 « » 将自定义元素回调反应排入队列。
为 oldParent 排队一个树突变记录，其中包含 « »、« node »、oldPreviousSibling 和 oldNextSibling。
为 newParent 排队一个树突变记录，其中包含 « node »、« »、newPreviousSibling 和 child。

要将节点追加到父节点，请将节点预插入到父节点的空之前。

要用节点替换父节点内的子节点，请运行以下步骤：

如果 parent 不是 Document、DocumentFragment 或 Element 节点，则抛出一个“HierarchyRequestError”DOMException。
如果 node 是 parent 的宿主包含的祖先节点，则抛出一个“HierarchyRequestError”DOMException。
如果 child 的父节点不是 parent，则抛出一个 “NotFoundError” DOMException。
如果 node 不是 DocumentFragment、DocumentType、Element 或 CharacterData 节点，则抛出一个 “HierarchyRequestError” DOMException。
如果 node 是一个 Text 节点且 parent 是一个文档，或者 node 是一个文档类型且 parent 不是一个文档，则抛出一个“HierarchyRequestError”DOMException。
如果 parent 是一个文档，并且以下根据 node 实现的接口切换的任何语句为真，则抛出一个 “HierarchyRequestError” DOMException。

DocumentFragment

如果 node 有多个元素子节点或有一个 Text 节点子节点。

否则，如果 node 有一个元素子节点，并且或者 parent 有一个不是 child 的元素子节点，或者一个文档类型跟随 child。

Element

parent 有一个不是 child 的元素子节点，或者一个文档类型跟随 child。

DocumentType

parent 有一个不是 child 的文档类型子节点，或者一个元素位于 child 之前。

以上语句与预插入算法不同。
设 referenceChild 为 child 的下一个兄弟节点。
如果 referenceChild 是 node，则将 referenceChild 设置为 node 的下一个兄弟节点。
设 previousSibling 为 child 的前一个兄弟节点。
设 removedNodes 为空集。
如果 child 的父节点非空：
1. 将 removedNodes 设置为 « child »。
2. 设置抑制观察者标志并移除 child。
仅当 child 是 node 时，以上才可能为 false。
设 nodes 为 node 的子节点（如果 node 是一个 DocumentFragment 节点）；否则为 « node »。
设置抑制观察者标志并将 node 插入到 parent 中，位于 referenceChild 之前。
为 parent 排队一个树突变记录，其中包含 nodes、removedNodes、previousSibling 和 referenceChild。
返回 child。

要在父节点内用节点替换全部，请运行以下步骤：

设 removedNodes 为 parent 的子节点。
设 addedNodes 为空集。
如果 node 是一个 DocumentFragment 节点，则将 addedNodes 设置为 node 的子节点。
否则，如果 node 非空，则将 addedNodes 设置为 « node »。
设置抑制观察者标志，按树顺序移除 parent 的所有子节点。
如果 node 非空，则设置抑制观察者标志，在 null 之前将 node 插入到 parent 中。
如果 addedNodes 或 removedNodes 不为空，则为 parent 排队一个树突变记录，其中包含 addedNodes、removedNodes、null 和 null。

此算法不对节点树约束进行任何检查。规范作者需要明智地使用它。

要从 parent 中预移除一个 child，请执行以下步骤：

如果 child 的父节点不是 parent，则抛出一个 “NotFoundError” DOMException。
移除 child。
返回 child。

规范可以为所有或部分节点定义移除步骤。如下面的移除算法所示，该算法传递了一个节点 removedNode 和一个节点或 null 的 oldParent。

要移除一个节点 node（可选抑制观察者标志），请执行以下步骤：

设 parent 为 node 的父节点。
断言：parent 非空。
运行活动范围预移除步骤，给定 node。
对于每个其根的节点文档是 node 的节点文档的 NodeIterator 对象 iterator，运行给定 node 和 iterator 的NodeIterator 预移除步骤。
设 oldPreviousSibling 为 node 的前一个兄弟节点。
设 oldNextSibling 为 node 的下一个兄弟节点。
从其 parent 的子节点中移除 node。
如果 node 已分配，则为 node 的已分配插槽运行分配可插入对象。
如果 parent 的根是一个影子根，并且 parent 是一个插槽，其已分配节点为空列表，则为 parent 运行发出插槽更改信号。
如果 node 有一个作为插槽的包含后代：
1. 使用 parent 的根运行为树分配可插入对象。
2. 使用 node 运行为树分配可插入对象。
使用 node 和 parent 运行移除步骤。
设 isParentConnected 为 parent 的已连接状态。
如果 node 是自定义的且 isParentConnected 为 true，则使用 node、回调名称 “disconnectedCallback” 和 « » 将自定义元素回调反应排入队列。

目前有意让自定义元素不传递 parent。如果将来有需要，这可能会改变。
对于 node 的每个包含影子的后代 descendant，按包含影子的树顺序：
1. 使用 descendant 和 null 运行移除步骤。
2. 如果 descendant 是自定义的且 isParentConnected 为 true，则使用 descendant、回调名称 “disconnectedCallback” 和 « » 将自定义元素回调反应排入队列。
对于 parent 的每个包含祖先 inclusiveAncestor，然后对于 inclusiveAncestor 的已注册观察者列表中的每个 registered，如果 registered 的选项["subtree"] 为 true，则将一个新的瞬态已注册观察者（其观察者是 registered 的观察者，选项是 registered 的选项，并且来源是 registered）追加到 node 的已注册观察者列表。
如果抑制观察者标志未设置，则为 parent 排队一个树突变记录，其中包含 « »、« node »、 oldPreviousSibling 和 oldNextSibling。
为 parent 运行子节点更改步骤。

4.2.4. 混入 `NonElementParentNode`

Web 兼容性阻止了 getElementById() 方法在元素上公开（因此也在 ParentNode 上公开）。

interface mixin NonElementParentNode {
  Element? getElementById(DOMString elementId);
};
Document includes NonElementParentNode;
DocumentFragment includes NonElementParentNode;

node . getElementById(elementId): 返回 node 的后代中ID 为 elementId 的第一个元素。

getElementById(elementId) 方法的步骤是：返回此对象的后代中，按树顺序，ID 为 elementId 的第一个元素；否则，如果没有这样的元素，则返回 null。

4.2.5. Mixin `DocumentOrShadowRoot`

interface mixin DocumentOrShadowRoot {
  readonly attribute CustomElementRegistry? customElementRegistry;
};
Document includes DocumentOrShadowRoot;
ShadowRoot includes DocumentOrShadowRoot;

registry = documentOrShadowRoot . customElementRegistry: 返回 documentOrShadowRoot 的 CustomElementRegistry 对象（如果存在）；否则返回 null。

customElementRegistry getter 的步骤是：

如果此对象是一个文档，则返回此对象的自定义元素注册表。
断言：此对象是一个 ShadowRoot 节点。
返回此对象的自定义元素注册表。

DocumentOrShadowRoot mixin 也期望被其他想要定义文档和影子根之间共享 API 的标准使用。

4.2.6. Mixin `ParentNode`

要将节点转换为单个节点，给定 nodes 和 document，请执行以下步骤：

设 node 为 null。
将 nodes 中的每个字符串替换为一个新的 Text 节点，其数据为该字符串，节点文档为 document。
如果 nodes 包含一个节点，则将 node 设置为 nodes[0]。
否则，将 node 设置为一个新的 DocumentFragment 节点，其节点文档为 document，然后将 nodes 中的每个节点（如果存在）追加到其中。
返回 node。

interface mixin ParentNode {
  [SameObject] readonly attribute HTMLCollection children;
  readonly attribute Element? firstElementChild;
  readonly attribute Element? lastElementChild;
  readonly attribute unsigned long childElementCount;

  [CEReactions, Unscopable] undefined prepend((Node or DOMString)... nodes);
  [CEReactions, Unscopable] undefined append((Node or DOMString)... nodes);
  [CEReactions, Unscopable] undefined replaceChildren((Node or DOMString)... nodes);

  [CEReactions] undefined moveBefore(Node node, Node? child);

  Element? querySelector(DOMString selectors);
  [NewObject] NodeList querySelectorAll(DOMString selectors);
};
Document includes ParentNode;
DocumentFragment includes ParentNode;
Element includes ParentNode;

collection = node . children

返回子元素。

element = node . firstElementChild

返回作为元素的第一个子节点；否则返回 null。

element = node . lastElementChild

返回作为元素的最后一个子节点；否则返回 null。

node . prepend(nodes)

在 node 的第一个子节点之前插入 nodes，同时将 nodes 中的字符串替换为等效的 Text 节点。

如果违反了节点树的约束，则抛出“HierarchyRequestError”DOMException。

node . append(nodes)

在 node 的最后一个子节点之后插入 nodes，同时将 nodes 中的字符串替换为等效的 Text 节点。

如果违反了节点树的约束，则抛出“HierarchyRequestError”DOMException。

node . replaceChildren(nodes)

将 node 的所有子节点替换为 nodes，同时将 nodes 中的字符串替换为等效的 Text 节点。

如果违反了节点树的约束，则抛出“HierarchyRequestError”DOMException。

node . moveBefore(movedNode, child)

如果 child 非空，则将 movedNode 移动（不先移除）到 node 中 child 之后；否则移动到 node 的最后一个子节点之后。此方法保留与 movedNode 关联的状态。

如果违反了节点树的约束，或者无法保留与移动节点关联的状态，则抛出“HierarchyRequestError”DOMException。

node . querySelector(selectors)

返回 node 的后代中与 selectors 匹配的第一个元素。

node . querySelectorAll(selectors)

返回 node 的所有与 selectors 匹配的元素后代。

children getter 的步骤是返回一个以此对象为根的 HTMLCollection 集合，仅匹配元素子节点。

firstElementChild getter 的步骤是返回第一个作为元素的子节点；否则返回 null。

lastElementChild getter 的步骤是返回最后一个作为元素的子节点；否则返回 null。

childElementCount getter 的步骤是返回此对象的作为元素的子节点的数量。

prepend(nodes) 方法的步骤是：

设 node 为给定 nodes 和此对象的节点文档，将节点转换为单个节点的结果。
在此对象的第一个子节点之前，将 node 预插入到此对象中。

append(nodes) 方法的步骤是：

设 node 为给定 nodes 和此对象的节点文档，将节点转换为单个节点的结果。
将 node 追加到此对象。

replaceChildren(nodes) 方法的步骤是：

设 node 为给定 nodes 和此对象的节点文档，将节点转换为单个节点的结果。
在 null 之前，确保将 node 预插入到此对象的有效性。
在此对象内，用 node 替换所有内容。

moveBefore(node, child) 方法的步骤是：

设 referenceChild 为 child。
如果 referenceChild 是 node，则将 referenceChild 设置为 node 的下一个兄弟节点。
在 referenceChild 之前，将 node 移动到此对象中。

querySelector(selectors) 方法的步骤是：如果结果不是空列表，则返回对此对象运行作用域匹配选择器字符串 selectors 的第一个结果；否则返回 null。

querySelectorAll(selectors) 方法的步骤是返回对此对象运行作用域匹配选择器字符串 selectors 的静态结果。

4.2.7. 混入 `NonDocumentTypeChildNode`

Web 兼容性阻止了 previousElementSibling 和 nextElementSibling 特性在文档类型上公开（因此也在 ChildNode 上公开）。

interface mixin NonDocumentTypeChildNode {
  readonly attribute Element? previousElementSibling;
  readonly attribute Element? nextElementSibling;
};
Element includes NonDocumentTypeChildNode;
CharacterData includes NonDocumentTypeChildNode;

element = node . previousElementSibling: 返回作为元素的第一个前置兄弟节点；否则返回 null。
element = node . nextElementSibling: 返回作为元素的第一个后续兄弟节点；否则返回 null。

previousElementSibling getter 的步骤是返回作为元素的第一个前置兄弟节点；否则返回 null。

nextElementSibling getter 的步骤是返回作为元素的第一个后续兄弟节点；否则返回 null。

4.2.8. 混入 `ChildNode`

interface mixin ChildNode {
  [CEReactions, Unscopable] undefined before((Node or DOMString)... nodes);
  [CEReactions, Unscopable] undefined after((Node or DOMString)... nodes);
  [CEReactions, Unscopable] undefined replaceWith((Node or DOMString)... nodes);
  [CEReactions, Unscopable] undefined remove();
};
DocumentType includes ChildNode;
Element includes ChildNode;
CharacterData includes ChildNode;

node . before(...nodes)

在 node 之前插入 nodes，同时将 nodes 中的字符串替换为等效的 Text 节点。

如果违反了节点树的约束，则抛出“HierarchyRequestError”DOMException。

node . after(...nodes)

在 node 之后插入 nodes，同时将 nodes 中的字符串替换为等效的 Text 节点。

如果违反了节点树的约束，则抛出“HierarchyRequestError”DOMException。

node . replaceWith(...nodes)

用 nodes 替换 node，同时将 nodes 中的字符串替换为等效的 Text 节点。

如果违反了节点树的约束，则抛出“HierarchyRequestError”DOMException。

node . remove()

移除 node。

before(nodes) 方法的步骤为：

设 parent 为此对象的父节点。
如果 parent 为 null，则返回。
设 viablePreviousSibling 为此对象的第一个不在 nodes 中的前置兄弟节点；否则为 null。
设 node 为给定 nodes 和此对象的节点文档，将节点转换为单个节点的结果。
如果 viablePreviousSibling 为 null，则将其设置为 parent 的第一个子节点；否则将其设置为 viablePreviousSibling 的下一个兄弟节点。
在 viablePreviousSibling 之前，将 node 预插入到 parent 中。

after(nodes) 方法的步骤为：

设 parent 为此对象的父节点。
如果 parent 为 null，则返回。
设 viableNextSibling 为此对象的第一个不在 nodes 中的后续兄弟节点；否则为 null。
设 node 为给定 nodes 和此对象的节点文档，将节点转换为单个节点的结果。
在 viableNextSibling 之前，将 node 预插入到 parent 中。

replaceWith(nodes) 方法的步骤是：

设 parent 为此对象的父节点。
如果 parent 为 null，则返回。
设 viableNextSibling 为此对象的第一个不在 nodes 中的后续兄弟节点；否则为 null。
设 node 为给定 nodes 和此对象的节点文档，将节点转换为单个节点的结果。
如果此对象的父节点是 parent，则在 parent 中用 node 替换此对象。

此对象可能已被插入到 node 中。
否则，在 viableNextSibling 之前，将 node 预插入到 parent 中。

remove() 方法的步骤是：

如果此对象的父节点为 null，则返回。
移除此对象。

4.2.9. 混入 `Slottable`

interface mixin Slottable {
  readonly attribute HTMLSlotElement? assignedSlot;
};
Element includes Slottable;
Text includes Slottable;

assignedSlot getter 的步骤是返回给定此对象和 true 的查找插槽的结果。

4.2.10. 旧式集合：`NodeList` 和 `HTMLCollection`

集合是一个表示节点列表的对象。一个集合可以是动态的，也可以是静态的。除非另有说明，否则集合必须是动态的。

如果集合是实时集合，那么该对象上的属性和方法必须操作实际的底层数据，而不是数据的快照。

当集合创建时，会与其关联一个过滤器和根。

然后，集合表示以集合的根为根的子树的视图，仅包含符合给定过滤器的节点。该视图是线性的。在没有特定要求的情况下，集合中的节点必须按树顺序排序。

4.2.10.1. 接口 `NodeList`

一个 NodeList 对象是一个节点的集合。

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

collection . length: 返回集合中节点的数量。
element = collection . item(index)
element = collection[index]: 从集合中返回索引为 index 的节点。节点按树顺序排序。

对象的支持的属性索引是从零到比集合表示的节点数少一的范围内的数字。如果没有这样的元素，则没有支持的属性索引。

length 特性必须返回集合表示的节点数。

item(index) 方法必须返回集合中的第 index 个节点。如果集合中没有第 index 个节点，则该方法必须返回 null。

4.2.10.2. 接口`HTMLCollection`

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

一个 HTMLCollection 对象是一个元素的集合。

HTMLCollection 是一个我们无法从 Web 中摆脱的历史产物。虽然当然欢迎开发人员继续使用它，但新的 API 标准设计者不应该使用它（而应在 IDL 中使用 sequence<T>）。

collection . length: 返回集合中元素的数量。
element = collection . item(index)
element = collection[index]: 从集合中返回索引为 index 的元素。元素按树顺序排序。
element = collection . namedItem(name)
element = collection[name]: 从集合中返回ID 或名称为 name 的第一个元素。

对象的支持的属性索引是从零到元素数量减一的范围内的数字由集合表示。如果没有这样的元素，那么就没有支持的属性索引。

length获取器步骤应返回由集合表示的节点数量。

item(index) 方法的步骤是：返回集合中的第 index 个元素。如果集合中没有第 index 个元素，则该方法必须返回 null。

支持的属性名称是通过以下步骤返回的列表中的值：

令result为一个空列表。
对于集合中由集合表示的每个element，按树顺序处理：
1. 如果element具有一个不在result中的ID，则将element的ID添加到result中。
2. 如果element位于HTML命名空间中，并且具有一个name属性，且其值既不是空字符串也不在result中，则将element的name属性的值添加到result中。
返回result。

namedItem(key)方法步骤是：

如果 key 是空字符串，则返回 null。
返回集合中满足以下至少一个条件的第一个元素：
- 它有一个ID 为 key；
- 它位于HTML 命名空间中，并且具有一个name 特性，其值为 key；
如果没有这样的元素，则返回 null。

4.3. Mutation observers

每个相同来源窗口代理都有一个突变观察者微任务排队（布尔值），其初始值为false。[HTML]

每个相同来源窗口代理还具有待处理的突变观察者（一个包含零个或多个MutationObserver对象的集合），其初始状态为空。

要排队一个突变观察者微任务，请执行以下步骤：

如果周围代理的突变观察者微任务排队为true，则返回。
将周围代理的突变观察者微任务排队设置为true。
排队一个微任务以通知突变观察者。

要通知突变观察者，请执行以下步骤：

将周围代理的突变观察者微任务排队设置为false。
令notifySet为周围代理的待处理的突变观察者的克隆。
清空周围代理的待处理的突变观察者。
令signalSet为周围代理的信号槽列表的克隆。
清空周围代理的信号槽列表。
对于notifySet中的每个mo：
1. 令records为mo的记录队列的克隆。
2. 清空mo的记录队列。
3. 对于mo的节点列表中的每个node，移除所有其观察者为mo的瞬态注册观察者，从node的注册观察者列表中。
4. 如果 records 不为空，则使用 « records, mo » 和 "report" 调用 mo 的回调，并将回调 this 值设为 mo。
对于 signalSet 中的每个 slot，在 slot 上触发一个名为 slotchange 的事件，并将其 bubbles 属性设置为 true。

每个节点都有一个注册观察者列表（一个包含零个或多个注册观察者的列表），初始为空。

一个注册观察者由一个观察者（一个MutationObserver对象）和选项（一个MutationObserverInit字典）组成。

一个瞬态注册观察者是一个注册观察者，它还包括一个源（一个注册观察者）。

瞬态注册观察者用于在节点被移除后跟踪给定节点的后代中的突变，这样当节点的父节点上的 subtree 设置为 true 时，它们不会丢失。

4.3.1. 接口 `MutationObserver`

[Exposed=Window]
interface MutationObserver {
  constructor(MutationCallback callback);

  undefined observe(Node target, optional MutationObserverInit options = {});
  undefined disconnect();
  sequence<MutationRecord> takeRecords();
};

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

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

一个 MutationObserver 对象可用于观察节点树的突变。

每个 MutationObserver 对象都有这些关联的概念：

创建时设置的回调。
一个节点列表（一个对节点的弱引用列表），初始为空。
一个记录队列（一个包含零个或多个 MutationRecord 对象的队列），初始为空。

observer = new MutationObserver(callback)

构造一个 MutationObserver 对象并将其回调设置为 callback。该回调函数被调用时，第一个参数是一个 MutationRecord 对象列表，第二个参数是构造的 MutationObserver 对象。它在通过 observe() 方法注册的节点发生突变后被调用。

observer . observe(target, options)

指示用户代理观察给定的 target（一个节点）并根据 options（一个对象）给出的标准报告任何突变。

options 参数允许通过对象成员设置突变观察选项。以下是可以使用的对象成员：

childList: 如果要观察 target 的子节点的突变，则设置为 true。
attributes: 如果要观察 target 的特性的突变，则设置为 true。如果指定了 attributeOldValue 或 attributeFilter，则可以省略。
characterData: 如果要观察 target 的数据的突变，则设置为 true。如果指定了 characterDataOldValue，则可以省略。
subtree: 如果不仅要观察 target，还要观察 target 的后代的突变，则设置为 true。
attributeOldValue: 如果 attributes 为 true 或省略，并且需要记录 target 的特性在突变前的值，则设置为 true。
characterDataOldValue: 如果 characterData 设置为 true 或省略，并且需要记录 target 的数据在突变前的值，则设置为 true。
attributeFilter: 如果不需要观察所有特性突变，并且 attributes 为 true 或省略，则设置为特性本地名称（不含命名空间）的列表。

observer . disconnect()

停止 observer 观察任何突变。直到再次使用 observe() 方法，否则不会调用 observer 的回调。

observer . takeRecords()

清空记录队列并返回其中的内容。

new MutationObserver(callback) 构造函数的步骤是：将此对象的回调设置为 callback。

observe(target, options) 方法的步骤是：

如果 options["attributeOldValue"] 或 options["attributeFilter"] 存在，并且 options["attributes"] 不存在，则将 options["attributes"] 设置为 true。
如果 options["characterDataOldValue"] 存在并且 options["characterData"] 不存在，则将 options["characterData"] 设置为 true。
如果 options["childList"]、 options["attributes"] 和 options["characterData"] 均不为 true，则抛出 TypeError。
如果 options["attributeOldValue"] 为 true 且 options["attributes"] 为 false，则抛出 TypeError。
如果 options["attributeFilter"] 存在且 options["attributes"] 为 false，则抛出 TypeError。
如果 options["characterDataOldValue"] 为 true 且 options["characterData"] 为 false，则抛出 TypeError。
对于 target 的注册观察者列表中的每个 registered，如果 registered 的观察者是此对象：
1. 对于此对象的节点列表中的每个 node，从 node 的注册观察者列表中移除所有其来源为 registered 的瞬态注册观察者。
2. 将 registered 的选项设置为 options。
否则：
1. 将一个新的注册观察者（其观察者是此对象，选项是 options）追加到 target 的注册观察者列表。
2. 将对 target 的弱引用追加到此对象的节点列表。

disconnect() 方法的步骤是：

对于此对象的节点列表中的每个 node，从 node 的注册观察者列表中移除任何注册观察者，其中此对象是其观察者。
清空此对象的记录队列。

takeRecords() 方法的步骤是：

设 records 为此对象的记录队列的克隆。
清空此对象的记录队列。
返回 records。

4.3.2. 排队突变记录

要为 type、target、name、namespace、oldValue、addedNodes、removedNodes、previousSibling 和 nextSibling 排队一个突变记录，请执行以下步骤：

设 interestedObservers 为一个空的有序映射。
设 nodes 为 target 的包含祖先。
对于 nodes 中的每个 node，然后对于 node 的注册观察者列表中的每个 registered：
1. 设 options 为 registered 的选项。
2. 如果以下条件均不为真：
  - node 不是 target 且 options["subtree"] 为 false
  - type 是 "attributes" 且 options["attributes"] 或者不存在或者为 false
  - type 是 "attributes"，options["attributeFilter"] 存在，并且 options["attributeFilter"] 不包含 name 或者 namespace 非空
  - type 是 "characterData" 且 options["characterData"] 或者不存在或者为 false
  - type 是 "childList" 且 options["childList"] 为 false
  则：
  1. 设 mo 为 registered 的观察者。
  2. 如果 interestedObservers[mo] 不存在，则将 interestedObservers[mo] 设置为 null。
  3. 如果 type 是 "attributes" 且 options["attributeOldValue"] 为 true，或者 type 是 "characterData" 且 options["characterDataOldValue"] 为 true，则将 interestedObservers[mo] 设置为 oldValue。
对于 interestedObservers 中的每个 observer → mappedOldValue：
1. 设 record 为一个新的 MutationRecord 对象，其 type 设为 type，target 设为 target，attributeName 设为 name，attributeNamespace 设为 namespace，oldValue 设为 mappedOldValue，addedNodes 设为 addedNodes，removedNodes 设为 removedNodes，previousSibling 设为 previousSibling，且 nextSibling 设为 nextSibling。
2. 将 record 加入队列到 observer 的记录队列。
3. 将 observer 追加到周围代理的待处理突变观察者。
将突变观察者微任务排队。

要为 target 以及 addedNodes、removedNodes、previousSibling 和 nextSibling 排队一个树突变记录，请执行以下步骤：

断言：addedNodes 或 removedNodes 不为空。
为 target 将一个 "childList" 类型的突变记录排队，附带 null、null、null、addedNodes、removedNodes、previousSibling 和 nextSibling。

4.3.3. 接口 `MutationRecord`

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

record . type: 如果是特性突变，则返回 "attributes"。如果是 CharacterData 节点的突变，则返回 "characterData"。如果是节点树的突变，则返回 "childList"。
record . target: 根据 type 返回受突变影响的节点。对于 "attributes"，它是其特性已更改的元素。对于 "characterData"，它是 CharacterData 节点。对于 "childList"，它是其子节点已更改的节点。
record . addedNodes
record . removedNodes: 分别返回已添加和已移除的节点。
record . previousSibling
record . nextSibling: 分别返回已添加或已移除节点的前一个和下一个兄弟节点；否则返回 null。
record . attributeName: 返回已更改特性的本地名称；否则返回 null。
record . attributeNamespace: 返回已更改特性的命名空间；否则返回 null。
record . oldValue: 返回值取决于 type。对于 "attributes"，它是更改前已更改特性的值。对于 "characterData"，它是更改前已更改节点的数据。对于 "childList"，它是 null。

type，target，addedNodes，removedNodes，previousSibling，nextSibling，attributeName，attributeNamespace 和 oldValue 属性必须返回其初始化时的值。

4.4. 接口 `Node`

[Exposed=Window]
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; // legacy
  const unsigned short ENTITY_NODE = 6; // legacy
  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; // legacy
  readonly attribute unsigned short nodeType;
  readonly attribute DOMString nodeName;

  readonly attribute USVString baseURI;

  readonly attribute boolean isConnected;
  readonly attribute Document? ownerDocument;
  Node getRootNode(optional GetRootNodeOptions options = {});
  readonly attribute Node? parentNode;
  readonly attribute Element? parentElement;
  boolean hasChildNodes();
  [SameObject] readonly attribute NodeList childNodes;
  readonly attribute Node? firstChild;
  readonly attribute Node? lastChild;
  readonly attribute Node? previousSibling;
  readonly attribute Node? nextSibling;

  [CEReactions] attribute DOMString? nodeValue;
  [CEReactions] attribute DOMString? textContent;
  [CEReactions] undefined normalize();

  [CEReactions, NewObject] Node cloneNode(optional boolean subtree = false);
  boolean isEqualNode(Node? otherNode);
  boolean isSameNode(Node? otherNode); // legacy alias of ===

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

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

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

dictionary GetRootNodeOptions {
  boolean composed = false;
};

Node 是一个抽象接口，所有节点都会使用它。你无法获取它的直接实例。

每个节点都有一个关联的节点文档，在创建时设置，它是一个文档。

一个节点的节点文档可以通过采纳算法来更改。

一个节点的获取父节点算法，在给定一个 event 的情况下，如果节点是已分配的，则返回该节点的已分配插槽；否则返回该节点的父节点。

每个节点还有一个注册观察者列表。

node . nodeType

返回一个适合 node 类型的数字，如下所示：

Element: Node . ELEMENT_NODE (1)。
Attr: Node . ATTRIBUTE_NODE (2)。
一个排他的 Text 节点: Node . TEXT_NODE (3)。
CDATASection: Node . CDATA_SECTION_NODE (4)。
ProcessingInstruction: Node . PROCESSING_INSTRUCTION_NODE (7)。
Comment: Node . COMMENT_NODE (8)。
Document: Node . DOCUMENT_NODE (9)。
DocumentType: Node . DOCUMENT_TYPE_NODE (10)。
DocumentFragment: Node . DOCUMENT_FRAGMENT_NODE (11)。

node . nodeName

返回一个适合 node 类型的字符串，如下所示：

Element: 其HTML 大写限定名。
Attr: 其限定名。
一个排他的 Text 节点: "#text"。
CDATASection: "#cdata-section"。
ProcessingInstruction: 其目标。
Comment: "#comment"。
Document: "#document"。
DocumentType: 其名称。
DocumentFragment: "#document-fragment"。

nodeType getter 的步骤是返回第一个匹配的语句，具体取决于此对象实现的接口：

Element: ELEMENT_NODE (1)
Attr: ATTRIBUTE_NODE (2);
一个排他的 Text 节点: TEXT_NODE (3);
CDATASection: CDATA_SECTION_NODE (4);
ProcessingInstruction: PROCESSING_INSTRUCTION_NODE (7);
Comment: COMMENT_NODE (8);
Document: DOCUMENT_NODE (9);
DocumentType: DOCUMENT_TYPE_NODE (10);
DocumentFragment: DOCUMENT_FRAGMENT_NODE (11).

nodeName getter 的步骤是返回第一个匹配的语句，具体取决于此对象实现的接口：

Element: 其HTML 大写限定名。
Attr: 其限定名。
一个排他的 Text 节点: "#text"。
CDATASection: "#cdata-section"。
ProcessingInstruction: 其目标。
Comment: "#comment"。
Document: "#document"。
DocumentType: 其名称。
DocumentFragment: "#document-fragment"。

node . baseURI: 返回 node 的节点文档的文档基本 URL。

baseURI getter 的步骤是返回此对象的节点文档的文档基本 URL，并进行序列化。

node . isConnected: 如果 node 是已连接的，则返回 true；否则返回 false。
node . ownerDocument: 返回节点文档。对于文档，返回 null。
node . getRootNode(): 返回 node 的根节点。
node . getRootNode({ composed:true }): 返回 node 的包含阴影的根节点。
node . parentNode: 返回父节点。
node . parentElement: 返回父元素。
node . hasChildNodes(): 返回 node 是否有子节点。
node . childNodes: 返回子节点。
node . firstChild: 返回第一个子节点。
node . lastChild: 返回最后一个子节点。
node . previousSibling: 返回前一个兄弟节点。
node . nextSibling: 返回下一个兄弟节点。

isConnected getter 的步骤是：如果此对象是已连接的，则返回 true；否则返回 false。

ownerDocument getter 的步骤是：如果此对象是一个文档，则返回 null；否则返回此对象的节点文档。

一个文档的节点文档就是该文档本身。所有节点始终都有一个节点文档。

getRootNode(options) 方法的步骤是：如果 options["composed"] 为 true，则返回此对象的包含阴影的根节点；否则返回此对象的根节点。

parentNode getter 的步骤是返回此对象的父节点。

parentElement getter 的步骤是返回此对象的父元素。

hasChildNodes() 方法的步骤是：如果此对象有子节点，则返回 true；否则返回 false。

childNodes getter 的步骤是返回一个以此对象为根且仅匹配子节点的 NodeList。

firstChild getter 的步骤是返回此对象的第一个子节点。

lastChild getter 的步骤是返回此对象的最后一个子节点。

previousSibling getter 的步骤是返回此对象的前一个兄弟节点。

nextSibling getter 的步骤是返回此对象的下一个兄弟节点。

nodeValue getter 的步骤是返回以下内容，具体取决于此对象实现的接口：

Attr: 此对象的值。
CharacterData: 此对象的数据。
其他情况: Null。

nodeValue setter 的步骤是，如果给定值为 null，则视为空字符串，然后执行以下描述的操作，具体取决于此对象实现的接口：

Attr: 使用此对象和给定值设置现有特性值。
CharacterData: 使用节点此对象、偏移量 0、计数此对象的长度以及给定值作为数据，替换数据。
其他情况: 不执行任何操作。

使用节点 node 获取文本内容的步骤是返回以下内容，具体取决于 node 实现的接口：

DocumentFragment
Element: node 的后代文本内容。
Attr: node 的值。
CharacterData: node 的数据。
其他情况: Null。

textContent getter 的步骤是返回使用此对象运行获取文本内容的结果。

在节点 parent 内使用字符串 string 字符串替换所有内容的步骤如下：

设 node 为 null。
如果 string 不是空字符串，则将 node 设置为一个新的 Text 节点，其数据为 string，节点文档为 parent 的节点文档。
在 parent 内使用 node 替换所有内容。

使用节点 node 和字符串 value 设置文本内容的步骤如下，具体取决于 node 实现的接口：

DocumentFragment
Element: 在 node 内使用 value 字符串替换所有内容。
Attr: 使用 node 和 value 设置现有特性值。
CharacterData: 使用节点 node、偏移量 0、计数 node 的长度以及数据 value 替换数据。
其他情况: 不执行任何操作。

textContent setter 的步骤是，如果给定值为 null，则视为空字符串，然后使用此对象和给定值运行设置文本内容。

node . normalize(): 移除空的专属 Text 节点，并将剩余的连续专属 Text 节点的数据连接到它们节点中的第一个。

normalize() 方法的步骤是为此对象的每个后代专属 Text 节点 node 执行以下步骤：

设 length 为 node 的长度。
如果 length 为零，则移除 node 并继续处理下一个专属 Text 节点（如果存在）。
设 data 为 node 的连续专属 Text 节点（不包括其自身）的数据按树顺序连接的结果。
使用节点 node、偏移量 length、计数 0 和数据 data 替换数据。
设 currentNode 为 node 的下一个兄弟节点。
当 currentNode 是一个专属 Text 节点时：
1. 对于每个起始节点为 currentNode 的活动范围，将其起始偏移量增加 length，并将其起始节点设置为 node。
2. 对于每个结束节点为 currentNode 的活动范围，将其结束偏移量增加 length，并将其结束节点设置为 node。
3. 对于每个起始节点为 currentNode 的父节点且起始偏移量为 currentNode 的索引的活动范围，将其起始节点设置为 node，并将其起始偏移量设置为 length。
4. 对于每个结束节点为 currentNode 的父节点且结束偏移量为 currentNode 的索引的活动范围，将其结束节点设置为 node，并将其结束偏移量设置为 length。
5. 将 currentNode 的长度加到 length 上。
6. 将 currentNode 设置为其下一个兄弟节点。
按树顺序移除 node 的连续专属 Text 节点（不包括其自身）。

node . cloneNode([subtree = false]): 返回 node 的一个副本。如果 subtree 为 true，则副本还包括 node 的后代。
node . isEqualNode(otherNode): 返回 node 和 otherNode 是否具有相同的属性。

规范可以为所有或部分节点定义克隆步骤。该算法会传入 node、copy 和 subtree，如克隆节点算法所示。

HTML 为多个元素定义了克隆步骤，例如 input、 script 和 template。 SVG 也应该为其 script 元素执行相同的操作，但实际上没有。

要克隆一个节点，给定一个节点 node 和一个可选的文档 document（默认为 node 的节点文档），布尔值 subtree（默认为 false），节点或 null parent（默认为 null），以及 null 或一个 CustomElementRegistry 对象 fallbackRegistry（默认为 null）：

断言：node 不是一个文档，或者 node 是 document。
设 copy 为给定 node、document 和 fallbackRegistry 克隆单个节点的结果。
运行其他适用规范中为 node 定义的任何克隆步骤，并将 node、copy 和 subtree 作为参数传递。
如果 parent 不为 null，则将 copy 追加到 parent。
如果 subtree 为 true，则对于 node 的子节点中的每个 child，按树顺序：克隆一个节点，给定 child，并将 document 设置为 document，将 subtree 设置为 subtree，将 parent 设置为 copy，并将 fallbackRegistry 设置为 fallbackRegistry。
如果 node 是一个元素，node 是一个影子宿主，并且 node 的影子根的可克隆性为 true：
1. 断言：copy 不是一个影子宿主。
2. 设 shadowRootRegistry 为 node 的影子根的自定义元素注册表。
3. 使用 copy、node 的影子根的模式、true、node 的影子根的可序列化性、node 的影子根的焦点委托、node 的影子根的插槽分配和 shadowRootRegistry 附加一个影子根。
4. 将 copy 的影子根的声明性设置为 node 的影子根的声明性。
5. 对于 node 的影子根的子节点中的每个 child，按树顺序：克隆一个节点，给定 child，并将 document 设置为 document，将 subtree 设置为 subtree，并将 parent 设置为 copy 的影子根。
  
  这有意不传递 fallbackRegistry 参数。
返回 copy。

要克隆单个节点，给定一个节点 node，一个文档 document，以及 null 或一个 CustomElementRegistry 对象 fallbackRegistry：

设 copy 为 null。
如果 node 是一个元素：
1. 设 registry 为 node 的自定义元素注册表。
2. 如果 registry 为 null，则将 registry 设置为 fallbackRegistry。
3. 将 copy 设置为创建元素的结果，给定 document、node 的本地名称、node 的命名空间、node 的命名空间前缀、node 的is 值、false 和 registry。
4. 对于 node 的特性列表中的每个 attribute：
  1. 设 copyAttribute 为给定 attribute、document 和 null 克隆单个节点的结果。
  2. 将 copyAttribute 追加到 copy。
否则，将 copy 设置为一个节点，该节点实现与 node 相同的接口，并满足以下附加要求，具体取决于 node 实现的接口：

Document

将 copy 的编码、内容类型、URL、源、类型、模式和自定义元素注册表设置为 node 的相应值。

DocumentType

将 copy 的名称、公共 ID 和系统 ID 设置为 node 的相应值。

Attr

将 copy 的命名空间、命名空间前缀、本地名称和值设置为 node 的相应值。

Text

Comment

将 copy 的数据设置为 node 的数据。

ProcessingInstruction

将 copy 的目标和数据设置为 node 的相应值。

其他情况

不执行任何操作。
断言：copy 是一个节点。
如果 node 是一个文档，则将 document 设置为 copy。
将 copy 的节点文档设置为 document。
返回 copy。

cloneNode(subtree) 方法的步骤如下：

如果此对象是一个影子根，则抛出一个 "NotSupportedError" DOMException。
返回给定此对象并将 subtree 设置为 subtree 的克隆节点的结果。

一个节点 A 等于一个节点 B，如果以下所有条件都为真：

A 和 B 实现相同的接口。
以下各项相等，具体取决于 A 实现的接口：

DocumentType

其名称、公共 ID 和系统 ID。

Element

其命名空间、命名空间前缀、本地名称及其特性列表的大小。

Attr

其命名空间、本地名称和值。

ProcessingInstruction

其目标和数据。

Text

Comment

其数据。

其他情况

—
如果 A 是一个元素，则其特性列表中的每个特性都有一个特性等于 B 的特性列表中的一个特性。
A 和 B 具有相同数量的子节点。
A 的每个子节点等于 B 在相同索引处的子节点。

isEqualNode(otherNode) 方法的步骤是：如果 otherNode 不为 null 且此对象等于 otherNode，则返回 true；否则返回 false。

isSameNode(otherNode) 方法的步骤是：如果 otherNode 是此对象，则返回 true；否则返回 false。

node . compareDocumentPosition(other)

返回一个位掩码，指示 other 相对于 node 的位置。可以设置以下这些位：

Node . DOCUMENT_POSITION_DISCONNECTED (1): 当 node 和 other 不在同一树中时设置。
Node . DOCUMENT_POSITION_PRECEDING (2): 当 other 先于 node 时设置。
Node . DOCUMENT_POSITION_FOLLOWING (4): 当 other 后于 node 时设置。
Node . DOCUMENT_POSITION_CONTAINS (8): 当 other 是 node 的祖先时设置。
Node . DOCUMENT_POSITION_CONTAINED_BY (16，十六进制下为 10): 当 other 是 node 的后代时设置。

node . contains(other)

如果 other 是 node 的包含后代，则返回 true；否则返回 false。

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

DOCUMENT_POSITION_DISCONNECTED (1);
DOCUMENT_POSITION_PRECEDING (2);
DOCUMENT_POSITION_FOLLOWING (4);
DOCUMENT_POSITION_CONTAINS (8);
DOCUMENT_POSITION_CONTAINED_BY (16, 16 的十六进制表示为 10);
DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC (32, 32 的十六进制表示为 20)。

方法compareDocumentPosition(other)的步骤如下：

如果此对象是 other，则返回零。
设 node1 为 other，node2 为此对象。
设 attr1 和 attr2 为 null。
如果 node1 是一个特性，则将 attr1 设置为 node1，并将 node1 设置为 attr1 的元素。
如果 node2 是一个特性：
1. 将 attr2 设置为 node2，并将 node2 设置为 attr2 的元素。
2. 如果 attr1 和 node1 非 null，并且 node2 是 node1：
  1. 对于 node2 的特性列表中的每个 attr：
    1. 如果 attr 等于 attr1，则返回 DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC 和 DOCUMENT_POSITION_PRECEDING 相加的结果。
    2. 如果 attr 等于 attr2，则返回 DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC 和 DOCUMENT_POSITION_FOLLOWING 相加的结果。
如果 node1 或 node2 为 null，或者 node1 的根不是 node2 的根，则返回 DOCUMENT_POSITION_DISCONNECTED、 DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC 以及 DOCUMENT_POSITION_PRECEDING 或 DOCUMENT_POSITION_FOLLOWING 相加的结果，约束条件是这些结果必须保持一致。

返回 DOCUMENT_POSITION_PRECEDING 还是 DOCUMENT_POSITION_FOLLOWING 通常通过指针比较来实现。在 JavaScript 实现中，可以使用缓存的 Math.random() 值。
如果 node1 是 node2 的祖先且 attr1 为 null，或者 node1 是 node2 且 attr2 非 null，则返回 DOCUMENT_POSITION_CONTAINS 与 DOCUMENT_POSITION_PRECEDING 相加的结果。
如果 node1 是 node2 的后代且 attr2 为 null，或者 node1 是 node2 且 attr1 非 null，则返回 DOCUMENT_POSITION_CONTAINED_BY 与 DOCUMENT_POSITION_FOLLOWING 相加的结果。
如果 node1 先于 node2，则返回 DOCUMENT_POSITION_PRECEDING。

由于此算法中处理特性的方式，这会导致一个节点的特性被视为先于该节点的子节点，尽管特性不参与同一树。
返回 DOCUMENT_POSITION_FOLLOWING。

contains(other) 方法的步骤是：如果 other 是此对象的包含后代，则返回 true；否则返回 false（包括当 other 为 null 时）。

要为一个使用namespace的element 定位命名空间前缀，请执行以下步骤：

如果element的命名空间是namespace，且其命名空间前缀非空，则返回其命名空间前缀。
如果element具有一个属性，其命名空间前缀是"xmlns"且值为namespace，则返回element的第一个此类属性的本地名称。
如果 element 的父元素不为 null，则返回在该元素上使用 namespace 运行定位命名空间前缀的结果。
返回 null。

要为一个node使用prefix 定位命名空间，请根据node 实现的接口进行切换：

Element

如果prefix是"xml"，则返回XML 命名空间。
如果prefix是"xmlns"，则返回XMLNS 命名空间。
如果其命名空间非空，且其命名空间前缀为prefix，则返回命名空间。
如果它具有一个属性，该属性的命名空间为XMLNS 命名空间，命名空间前缀为"xmlns"，且本地名称为prefix，或者如果prefix为 null，且它具有一个属性，其命名空间为XMLNS 命名空间，命名空间前缀为 null，且本地名称为"xmlns"，则返回其值（如果值不是空字符串），否则返回 null。
如果其父元素为 null，则返回 null。
返回在其父元素上使用prefix运行定位命名空间的结果。

Document

如果其文档元素为 null，则返回 null。
返回在其文档元素上使用prefix运行定位命名空间的结果。

DocumentType

DocumentFragment

返回 null。

Attr

如果其元素为 null，则返回 null。
返回在其元素上使用prefix运行定位命名空间的结果。

否则

如果其父元素为 null，则返回 null。
返回在其父元素上使用prefix运行定位命名空间的结果。

方法lookupPrefix(namespace)的步骤如下：

如果 namespace 为 null 或空字符串，则返回 null。
根据此对象实现的接口进行切换：
Element

返回为此对象使用 namespace 定位命名空间前缀的结果。

Document
1. 如果此对象的文档元素为 null，则返回 null。
2. 返回为此对象的文档元素使用 namespace 定位命名空间前缀的结果。
DocumentType

DocumentFragment

返回 null。

Attr
1. 如果此对象的元素为 null，则返回 null。
2. 返回为此对象的元素使用 namespace 定位命名空间前缀的结果。
其他情况
1. 如果此对象的父元素为 null，则返回 null。
2. 返回为此对象的父元素使用 namespace 定位命名空间前缀的结果。

方法lookupNamespaceURI(prefix)的步骤如下：

如果 prefix 是空字符串，则将其设置为 null。
返回使用 prefix 为此对象定位命名空间的结果。

方法isDefaultNamespace(namespace)的步骤如下：

如果 namespace 是空字符串，则将其设置为 null。
设 defaultNamespace 为对此对象使用 null 定位命名空间的结果。
如果 defaultNamespace 与 namespace 相同，则返回 true；否则返回 false。

insertBefore(node, child) 方法的步骤是返回将 node 预插入到此对象中 child 之前的结果。

appendChild(node) 方法的步骤是返回将 node 追加到此对象的结果。

replaceChild(node, child) 方法的步骤是返回在此对象内用 node 替换 child 的结果。

removeChild(child) 方法的步骤是返回从此对象中预移除 child 的结果。

对于节点 root，具有限定名 qualifiedName 的元素列表是由以下算法返回的 HTMLCollection：

如果 qualifiedName 是 U+002A (*)，则返回一个以 root 为根的 HTMLCollection，其过滤器仅匹配后代元素。
否则，如果 root 的节点文档是HTML 文档，则返回一个以 root 为根的 HTMLCollection，其过滤器匹配以下后代元素：
- 其命名空间是HTML 命名空间，且其限定名是 qualifiedName（ASCII 小写）。
- 其命名空间不是HTML 命名空间，且其限定名是 qualifiedName。
否则，返回一个以 root 为根的 HTMLCollection，其过滤器匹配后代元素，这些元素的限定名是 qualifiedName。

当使用相同参数调用时，并且只要 root 的节点文档的类型没有改变，就可以返回与先前调用返回的相同的 HTMLCollection 对象。

对于节点 root，具有命名空间 namespace 和本地名称 localName 的元素列表是由以下算法返回的 HTMLCollection：

如果 namespace 是空字符串，则将其设置为 null。
如果 namespace 和 localName 都是 U+002A (*)，则返回一个以 root 为根的 HTMLCollection，其过滤器匹配后代元素。
如果 namespace 是 U+002A (*)，则返回一个以 root 为根的 HTMLCollection，其过滤器匹配后代元素，这些元素的本地名称是 localName。
如果 localName 是 U+002A (*)，则返回一个以 root 为根的 HTMLCollection，其过滤器匹配后代元素，这些元素的命名空间是 namespace。
返回一个以 root 为根的 HTMLCollection，其过滤器匹配后代元素，这些元素的命名空间是 namespace 且本地名称是 localName。

当使用相同参数调用时，可以返回与先前调用返回的相同的 HTMLCollection 对象。

对于节点 root，具有类名 classNames 的元素列表是由以下算法返回的 HTMLCollection：

设 classes 为对 classNames 运行有序集合解析器的结果。
如果 classes 是空集，则返回一个空的 HTMLCollection。
返回一个以 root 为根的 HTMLCollection，其过滤器匹配后代元素，这些元素在 classes 中拥有其所有的类。

如果 root 的节点文档的模式是“quirks”，则类的比较必须以ASCII 不区分大小写的方式进行；否则以完全相同的方式进行。

当使用相同参数调用时，可以返回与先前调用返回的相同的 HTMLCollection 对象。

4.5. 接口 `Document`

[Exposed=Window]
interface Document : Node {
  constructor();

  [SameObject] readonly attribute DOMImplementation implementation;
  readonly attribute USVString URL;
  readonly attribute USVString documentURI;
  readonly attribute DOMString compatMode;
  readonly attribute DOMString characterSet;
  readonly attribute DOMString charset; // legacy alias of .characterSet
  readonly attribute DOMString inputEncoding; // legacy alias of .characterSet
  readonly attribute DOMString contentType;

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

  [CEReactions, NewObject] Element createElement(DOMString localName, optional (DOMString or ElementCreationOptions) options = {});
  [CEReactions, NewObject] Element createElementNS(DOMString? namespace, DOMString qualifiedName, optional (DOMString or ElementCreationOptions) options = {});
  [NewObject] DocumentFragment createDocumentFragment();
  [NewObject] Text createTextNode(DOMString data);
  [NewObject] CDATASection createCDATASection(DOMString data);
  [NewObject] Comment createComment(DOMString data);
  [NewObject] ProcessingInstruction createProcessingInstruction(DOMString target, DOMString data);

  [CEReactions, NewObject] Node importNode(Node node, optional (boolean or ImportNodeOptions) options = false);
  [CEReactions] Node adoptNode(Node node);

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

  [NewObject] Event createEvent(DOMString interface); // legacy

  [NewObject] Range createRange();

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

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

dictionary ElementCreationOptions {
  CustomElementRegistry customElementRegistry;
  DOMString is;
};

dictionary ImportNodeOptions {
  CustomElementRegistry customElementRegistry;
  boolean selfOnly = false;
};

Document 节点简称为文档。

一个文档的节点文档是其自身。

每个文档都有一个关联的编码（一个编码）、内容类型（一个字符串）、URL（一个 URL）、源（一个源）、类型（“xml”或“html”）、模式（“no-quirks”、“quirks”或“limited-quirks”）、允许声明式影子根（一个布尔值）和自定义元素注册表（null 或一个 CustomElementRegistry 对象）。[ENCODING] [URL] [HTML]

除非另有说明，文档的编码是 utf-8 编码，内容类型是“application/xml”，URL 是“about:blank”，源是一个不透明源，类型是“xml”，模式是“no-quirks”，允许声明式影子根是 false，并且自定义元素注册表是 null。

如果文档的类型是“xml”，则称其为 XML 文档；否则称为 HTML 文档。文档是 HTML 文档还是 XML 文档会影响某些 API 的行为。

如果文档的模式是“no-quirks”，则称其处于无怪异模式；如果其模式是“quirks”，则称其处于怪异模式；如果其模式是“limited-quirks”，则称其处于有限怪异模式。

模式仅在由 HTML 解析器根据 DOCTYPE 字符串的存在、缺失或值创建的文档以及新的浏览上下文（初始“about:blank”）的情况下才会从默认值更改。[HTML]

无怪异模式最初称为“标准模式”，而有限怪异模式曾称为“准标准模式”。它们已被重命名，因为它们的细节现在由标准定义。（并且因为 Ian Hickson 以它们无意义为由否决了它们最初的名称。）

给定一个event，文档的获取父级算法，如果 event 的 type 属性值为“load”或者文档没有浏览上下文，则返回 null；否则返回文档的相关全局对象。

document = new Document(): 返回一个新的文档。
document . implementation: 返回 document 的 DOMImplementation 对象。
document . URL
document . documentURI: 返回 document 的URL。
document . compatMode: 如果 document 的模式是“quirks”，则返回字符串“BackCompat”；否则返回“CSS1Compat”。
document . characterSet: 返回 document 的编码。
document . contentType: 返回 document 的内容类型。

new Document() 构造函数的步骤是将此对象的源设置为当前全局对象的关联 Document 的源。[HTML]

与 createDocument() 不同，此构造函数不返回 XMLDocument 对象，而是返回一个文档（Document 对象）。

implementation getter 的步骤是返回与此对象关联的 DOMImplementation 对象。

URL 和 documentURI getter 的步骤是返回此对象的URL（序列化后）。

compatMode getter 的步骤是：如果此对象的模式是“quirks”，则返回“BackCompat”；否则返回“CSS1Compat”。

characterSet、charset 和 inputEncoding getter 的步骤是返回此对象的编码的名称。

contentType getter 的步骤是返回此对象的内容类型。

document . doctype

返回文档类型，如果没有则返回 null。

document . documentElement

返回文档元素。

collection = document . getElementsByTagName(qualifiedName)

如果 qualifiedName 是“*”，则返回所有后代元素的 HTMLCollection。

否则，返回所有后代元素中限定名为 qualifiedName 的元素的 HTMLCollection。（在 HTML 文档中，针对HTML 命名空间中的元素进行不区分大小写的匹配。）

collection = document . getElementsByTagNameNS(namespace, localName)

如果 namespace 和 localName 都是“*”，则返回所有后代元素的 HTMLCollection。

如果只有 namespace 是“*”，则返回所有后代元素中本地名为 localName 的元素的 HTMLCollection。

如果只有 localName 是“*”，则返回所有后代元素中命名空间为 namespace 的元素的 HTMLCollection。

否则，返回所有后代元素中命名空间为 namespace 且本地名为 localName 的元素的 HTMLCollection。

collection = document . getElementsByClassName(classNames)

collection = element . getElementsByClassName(classNames)

返回调用该方法的对象（一个文档或一个元素）中所有具有 classNames 给定类的元素的 HTMLCollection。classNames 参数被解释为空格分隔的类列表。

doctype getter 的步骤是返回此对象中作为文档类型的子节点；否则返回 null。

documentElement getter 的步骤是返回此对象的文档元素。

getElementsByTagName(qualifiedName) 方法的步骤是返回此对象的具有限定名 qualifiedName 的元素列表。

因此，在 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的HTMLCollection。

调用getElementsByClassName("ccc bbb")将只返回一个节点，即p3。调用document.getElementById("example").getElementsByClassName("bbb ccc ")将返回相同的内容。

调用getElementsByClassName("aaa,bbb")将不会返回任何节点；上面的元素中没有一个属于aaa,bbb类。

element = document . createElement(localName [, options])

返回一个元素，其本地名称为 localName（如果 document 是一个HTML 文档，localName 会被转换为小写）。当 document 是一个HTML 文档或 document 的内容类型是“application/xhtml+xml”时，该元素的命名空间是HTML 命名空间；否则为 null。

如果提供了 options，其 customElementRegistry 可用于设置 CustomElementRegistry。

如果提供了 options，其 is 可用于创建一个自定义的内置元素。

如果 localName 与 Name 产生式不匹配，则会抛出“InvalidCharacterError” DOMException。

当同时提供 options 的 customElementRegistry 和 options 的 is 时，将抛出“NotSupportedError” DOMException。

element = document . createElementNS(namespace, qualifiedName [, options])

返回一个元素，其命名空间为 namespace。其命名空间前缀将是 qualifiedName 中 U+003A (:) 之前的所有内容，或者为 null。其本地名称将是 qualifiedName 中 U+003A (:) 之后的所有内容，或者就是 qualifiedName。

如果提供了 options，其 customElementRegistry 可用于设置 CustomElementRegistry。

如果提供了 options，其 is 可用于创建一个自定义的内置元素。

如果 qualifiedName 与 QName 产生式不匹配，则会抛出“InvalidCharacterError” DOMException。

如果以下任一条件为真，则会抛出“NamespaceError” DOMException：

命名空间前缀不为 null 且 namespace 为空字符串。
命名空间前缀为“xml”且 namespace 不是XML 命名空间。
qualifiedName 或命名空间前缀为“xmlns”且 namespace 不是XMLNS 命名空间。
namespace 是XMLNS 命名空间且 qualifiedName 和命名空间前缀都不是“xmlns”。

当同时提供 options 的 customElementRegistry 和 options 的 is 时，将抛出“NotSupportedError” DOMException。

documentFragment = document . createDocumentFragment()

返回一个 DocumentFragment 节点。

text = document . createTextNode(data)

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

text = document . createCDATASection(data)

返回一个 CDATASection 节点，其数据为 data。

comment = document . createComment(data)

返回一个 Comment 节点，其数据为 data。

processingInstruction = document . createProcessingInstruction(target, data)

返回一个 ProcessingInstruction 节点，其目标为 target，数据为 data。如果 target 与 Name 产生式不匹配，则会抛出“InvalidCharacterError” DOMException。如果 data 包含“?>”，则会抛出“InvalidCharacterError” DOMException。

任何 name 和 namespace 的元素接口都是 Element，除非另有说明。

例如，HTML 标准将定义对于 html 和HTML 命名空间，使用 HTMLHtmlElement 接口。[HTML]

createElement(localName, options) 方法的步骤如下：

如果 localName 与 Name 产生式不匹配，则抛出一个“InvalidCharacterError” DOMException。
如果此对象是一个HTML 文档，则将 localName 设置为 localName 的ASCII 小写形式。
设 registry 和 is 为给定 options 和此对象扁平化元素创建选项的结果。
如果此对象是一个HTML 文档或者此对象的内容类型是“application/xhtml+xml”，则设 namespace 为HTML 命名空间；否则为 null。
返回给定此对象、localName、namespace、null、is、true 和 registry 创建元素的结果。

内部 createElementNS 步骤，给定 document、namespace、qualifiedName 和 options，如下所示：

设 namespace、prefix 和 localName 为将 namespace 和 qualifiedName 传递给验证和提取的结果。
设 registry 和 is 为给定 options 和此对象扁平化元素创建选项的结果。
返回给定 document、localName、namespace、prefix、is、true 和 registry 创建元素的结果。

createElementNS(namespace, qualifiedName, options) 方法的步骤是返回运行内部 createElementNS 步骤的结果，给定此对象、namespace、qualifiedName 和 options。

要扁平化元素创建选项，给定一个字符串或 ElementCreationOptions 字典 options 和一个文档 document：

设 registry 为 null。
设 is 为 null。
如果 options 是一个字典：
1. 如果 options["customElementRegistry"] 存在，则将 registry 设置为其值。
2. 如果 options["is"] 存在，则将 is 设置为其值。
3. 如果 registry 非 null 且 is 非 null，则抛出一个 “NotSupportedError” DOMException。
如果 registry 为 null，则将 registry 设置为给定 document 查找自定义元素注册表的结果。
返回 registry 和 is。

createElement() 和 createElementNS() 的 options 参数允许为字符串以实现 Web 兼容性。

createDocumentFragment() 方法的步骤是返回一个新的 DocumentFragment 节点，其节点文档是此对象。

createTextNode(data) 方法的步骤是返回一个新的 Text 节点，其数据为 data，节点文档为此对象。

不检查 data 是否由与 Char 产生式匹配的字符组成。

createCDATASection(data) 方法的步骤如下：

如果此对象是一个HTML 文档，则抛出一个 “NotSupportedError” DOMException。
如果 data 包含字符串“]]>”，则抛出一个 “InvalidCharacterError” DOMException。
返回一个新的 CDATASection 节点，其数据设置为 data，节点文档设置为此对象。

createComment(data) 方法的步骤是返回一个新的 Comment 节点，其数据为 data，节点文档为此对象。

不检查 data 是否由与 Char 产生式匹配的字符组成，也不检查其是否包含两个相邻的连字符或以连字符结尾。

createProcessingInstruction(target, data) 方法的步骤如下：

如果 target 与 Name 产生式不匹配，则抛出一个“InvalidCharacterError” DOMException。
如果 data 包含字符串 “?>”，则抛出一个 “InvalidCharacterError” DOMException。
返回一个新的 ProcessingInstruction 节点，其目标设置为 target，数据设置为 data，节点文档设置为此对象。

不检查 target 是否包含 “xml”或“:”，也不检查 data 是否包含与 Char 产生式匹配的字符。

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

返回 node 的一个副本。如果 options 为 true 或者 options 是一个字典且其 selfOnly 为 false，则副本还包括 node 的后代。

options 的 customElementRegistry 可用于为没有 CustomElementRegistry 的元素设置它。

如果 node 是一个文档或一个影子根，则抛出“NotSupportedError” DOMException。

node = document . adoptNode(node)

将 node 从另一个文档移动并返回它。

如果 node 是一个文档，则抛出“NotSupportedError” DOMException，或者，如果 node 是一个影子根，则抛出“HierarchyRequestError” DOMException。

importNode(node, options) 方法的步骤如下：

如果 node 是一个文档或影子根，则抛出一个“NotSupportedError” DOMException。
设 subtree 为 false。
设 registry 为 null。
如果 options 是一个布尔值，则将 subtree 设置为 options。
否则：
1. 将 subtree 设置为 options["selfOnly"] 的否定值。
2. 如果 options["customElementRegistry"] 存在，则将 registry 设置为其值。
如果 registry 为 null，则将 registry 设置为给定此对象查找自定义元素注册表的结果。
返回给定 node 克隆节点的结果，其中文档设置为此对象，子树设置为 subtree，回退注册表设置为 registry。

规范可以为所有或部分节点定义采纳步骤。如采纳算法中所示，该算法传递 node 和 oldDocument。

要将一个 node 采纳到一个 document 中，请执行以下步骤：

设 oldDocument 为 node 的节点文档。
如果 node 的父节点非 null，则移除 node。
如果 document 不是 oldDocument：
1. 对于 node 的包含阴影的包含性后代中的每个 inclusiveDescendant：
  1. 将 inclusiveDescendant 的节点文档设置为 document。
  2. 如果 inclusiveDescendant 是一个元素，则将 inclusiveDescendant 的属性列表中每个属性的节点文档设置为 document。
2. 对于 node 的包含阴影的包含性后代中每个自定义的 inclusiveDescendant，将自定义元素回调反应入队，其中 inclusiveDescendant，回调名称为“adoptedCallback”，参数为 « oldDocument, document »。
3. 对于 node 的包含阴影的包含性后代中的每个 inclusiveDescendant（按包含阴影的树顺序），使用 inclusiveDescendant 和 oldDocument 运行采纳步骤。

adoptNode(node) 方法的步骤如下：

如果 node 是一个文档，则抛出一个 “NotSupportedError” DOMException。
如果 node 是一个影子根，则抛出一个 “HierarchyRequestError” DOMException。
如果 node 是一个 DocumentFragment 节点且其宿主非 null，则返回。
将 node 采纳到此对象中。
返回 node。

createAttribute(localName)方法步骤如下：

如果 localName 与 XML 中的 Name 产生式不匹配，则抛出一个“InvalidCharacterError” DOMException。
如果此对象是一个HTML 文档，则将 localName 设置为 localName 的ASCII 小写形式。
返回一个新的属性，其本地名称是 localName，节点文档是此对象。

createAttributeNS(namespace, qualifiedName) 方法的步骤是：

设 namespace、prefix 和 localName 为将 namespace 和 qualifiedName 传递给验证和提取的结果。
返回一个新的属性，其命名空间是 namespace，命名空间前缀是 prefix，本地名称是 localName，且节点文档是此对象。

createEvent(interface)方法步骤如下：

将constructor设为null。

如果interface是与下表第一列中的任何字符串的ASCII不区分大小写匹配，则将constructor设置为同一行第二列中的接口：

字符串	接口	注释
"`beforeunloadevent`"	`BeforeUnloadEvent`	[HTML]
"`compositionevent`"	`CompositionEvent`	[UIEVENTS]
"`customevent`"	`CustomEvent`
"`devicemotionevent`"	`DeviceMotionEvent`	[DEVICE-ORIENTATION]
"`deviceorientationevent`"	`DeviceOrientationEvent`	[DEVICE-ORIENTATION]
"`dragevent`"	`DragEvent`	[HTML]
"`event`"	`Event`
"`events`"	`Event`
"`focusevent`"	`FocusEvent`	[UIEVENTS]
"`hashchangeevent`"	`HashChangeEvent`	[HTML]
"`htmlevents`"	`Event`
"`keyboardevent`"	`KeyboardEvent`	[UIEVENTS]
"`messageevent`"	`MessageEvent`	[HTML]
"`mouseevent`"	`MouseEvent`	[UIEVENTS]
"`mouseevents`"	`MouseEvent`	[UIEVENTS]
"`storageevent`"	`StorageEvent`	[HTML]
"`svgevents`"	`Event`
"`textevent`"	`TextEvent`	[UIEVENTS]
"`touchevent`"	`TouchEvent`	[TOUCH-EVENTS]
"`uievent`"	`UIEvent`	[UIEVENTS]
"`uievents`"	`UIEvent`	[UIEVENTS]

如果 constructor 为 null，则抛出一个“NotSupportedError” DOMException。
如果 constructor 指示的接口未在此对象的相关全局对象上公开，则抛出一个 “NotSupportedError” DOMException。

通常用户代理会在某些配置中禁用对触摸事件的支持，在这种情况下，对于接口 TouchEvent，将触发此子句。
令 event 为给定 constructor 创建事件的结果。
将 event 的 type 属性初始化为空字符串。
将 event 的 timeStamp 属性初始化为使用此对象的相关全局对象调用当前高精度时间的结果。
将 event 的 isTrusted 属性初始化为 false。
取消设置 event 的初始化标志。
返回 event。

Event构造器应该被使用。

createRange() 方法的步骤是返回一个新的动态范围，以 (this, 0) 作为其起始点和结束点。

Range()构造器可以被使用。

createNodeIterator(root, whatToShow, filter)方法步骤如下：

设 iterator 为一个新的 NodeIterator 对象。
将 iterator 的根节点和 iterator 的引用节点设置为 root。
将 iterator 的引用前指针设置为 true。
将 iterator 的whatToShow 设置为 whatToShow。
将 iterator 的过滤器设置为 filter。
返回 iterator。

createTreeWalker(root, whatToShow, filter) 方法的步骤是：

设 walker 为一个新的 TreeWalker 对象。
将 walker 的根节点和 walker 的当前节点设置为 root。
将 walker 的whatToShow 设置为 whatToShow。
将 walker 的过滤器设置为 filter。
返回 walker。

4.5.1.接口 `DOMImplementation`

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

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

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

doctype = document . implementation . createDocumentType(qualifiedName, publicId, systemId): 返回一个文档类型，具有给定的 qualifiedName、publicId 和 systemId。如果 qualifiedName 与 Name 产生式不匹配，则抛出“InvalidCharacterError”DOMException；如果与 QName 产生式不匹配，则抛出“NamespaceError”DOMException。
doc = document . implementation . createDocument(namespace, qualifiedName [, doctype = null]): 返回一个 XMLDocument，其文档元素的本地名称为 qualifiedName，命名空间为 namespace（除非 qualifiedName 为空字符串），并且如果给定了 doctype，则将其作为其文档类型。
当使用 namespace 和 qualifiedName 调用时，此方法会抛出与 createElementNS() 方法相同的异常。
doc = document . implementation . createHTMLDocument([title]): 返回一个文档，其中已构建了一个基本的树，包括一个 title 元素，除非省略了 title 参数。

createDocumentType(qualifiedName, publicId, systemId) 方法的步骤是：

验证 qualifiedName。
返回一个新的文档类型，其名称为 qualifiedName，公共 ID 为 publicId，系统 ID 为 systemId，并且其节点文档设置为此对象的关联文档。

不检查 publicId 的代码点是否匹配 PubidChar 产生式，也不检查 systemId 是否同时包含 '"' 和 "'"。

createDocument(namespace, qualifiedName, doctype) 方法的步骤是：

设 document 为一个新的 XMLDocument。
设 element 为 null。
如果 qualifiedName 不是空字符串，则将 element 设置为运行内部 createElementNS 步骤的结果，给定 document、namespace、qualifiedName 和一个空字典。
如果 doctype 非 null，则将 doctype 追加到 document。
如果 element 非 null，则将 element 追加到 document。
document 的源是此对象的关联文档的源。
document 的内容类型由 namespace 决定：

HTML 命名空间

application/xhtml+xml

SVG 命名空间

image/svg+xml

任何其他命名空间

application/xml
返回 document。

createHTMLDocument(title) 方法的步骤是：

设 doc 为一个新的文档，它是一个HTML 文档。
将 doc 的内容类型设置为“text/html”。
将一个新的文档类型（其名称为“html”，其节点文档设置为 doc）追加到 doc。
将给定 doc、“html”和HTML 命名空间创建元素的结果追加到 doc。
将给定 doc、“head”和HTML 命名空间创建元素的结果追加到先前创建的 html 元素。
如果给定了 title：
1. 将给定 doc、“title”和HTML 命名空间创建元素的结果追加到先前创建的 head 元素。
2. 将一个新的 Text 节点（其数据设置为 title（可能为空字符串），其节点文档设置为 doc）追加到先前创建的 title 元素。
将给定 doc、“body”和HTML 命名空间创建元素的结果追加到先前创建的 html 元素。
doc 的源是此对象的关联文档的源。
返回 doc。

hasFeature() 方法的步骤是返回 true。

hasFeature() 最初用于报告用户代理是否声称支持给定的 DOM 功能，但经验证明，它远不如简单地检查所需的对象、属性或方法是否存在那样可靠或精细。因此，不再使用它，但它仍然存在（并简单地返回 true），以使旧页面不会停止工作。

4.6. 接口`DocumentType`

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

DocumentType 节点通常称为文档类型。

文档类型具有关联的名称、公共 ID 和系统 ID。

创建文档类型时，总是会给出其名称。除非在创建文档类型时明确指定，否则其公共 ID 和系统 ID 均为空字符串。

name getter 的步骤是返回此对象的名称。

publicId getter 的步骤是返回此对象的公共 ID。

systemId getter 的步骤是返回此对象的系统 ID。

4.7. 接口`DocumentFragment`

[Exposed=Window]
interface DocumentFragment : Node {
  constructor();
};

DocumentFragment 节点有一个关联的宿主（null 或不同节点树中的元素）。除非另有说明，否则它为 null。

如果对象 A 是对象 B 的包含性祖先，或者如果 B 的根节点具有非 null 的宿主并且 A 是 B 的根节点的宿主的包含宿主的包含性祖先，则对象 A 是对象 B 的包含宿主的包含性祖先。

DocumentFragment 节点的宿主概念对于 HTML 的 template 元素和影子根很有用，并且会影响预插入和替换算法。

tree = new DocumentFragment(): 返回一个新的 DocumentFragment 节点。

new DocumentFragment() 构造函数的步骤是将此对象的节点文档设置为当前全局对象的关联的 Document。

4.8. 接口 `ShadowRoot`

[Exposed=Window]
interface ShadowRoot : DocumentFragment {
  readonly attribute ShadowRootMode mode;
  readonly attribute boolean delegatesFocus;
  readonly attribute SlotAssignmentMode slotAssignment;
  readonly attribute boolean clonable;
  readonly attribute boolean serializable;
  readonly attribute Element host;

  attribute EventHandler onslotchange;
};

enum ShadowRootMode { "open", "closed" };
enum SlotAssignmentMode { "manual", "named" };

ShadowRoot 节点通常称为影子根。

影子根的关联宿主永远不为 null。

影子根有一个关联的模式（“open”或“closed”）。

影子根有一个关联的委托焦点（一个布尔值）。它最初设置为 false。

影子根有一个关联的可用于元素内部（一个布尔值）。它最初设置为 false。

影子根有一个关联的声明性（一个布尔值）。它最初设置为 false。

影子根有一个关联的插槽分配（“manual”或“named”）。

影子根有一个关联的可克隆（一个布尔值）。它最初设置为 false。

影子根有一个关联的可序列化（一个布尔值）。它最初设置为 false。

影子根有一个关联的自定义元素注册表（null 或一个 CustomElementRegistry 对象）。它最初为 null。

影子根有一个关联的保持自定义元素注册表为 null（一个布尔值）。它最初为 false。

这只能在与声明性影子根结合使用时为 true。并且仅当影子根的自定义元素注册表为 null 时才有意义。

一个影子根的获取父节点算法，给定一个event，如果event的组合标志未设置并且影子根是event的路径的第一个结构的调用目标的根，则返回 null；否则返回影子根的宿主。

mode getter 的步骤是返回此对象的模式。

delegatesFocus getter 的步骤是返回此对象的委托焦点。

slotAssignment getter 的步骤是返回此对象的插槽分配。

clonable getter 的步骤是返回此对象的可克隆。

serializable getter 的步骤是返回此对象的可序列化。

host getter 的步骤是返回此对象的宿主。

onslotchange 属性是一个事件处理程序 IDL 属性，用于onslotchange 事件处理程序，其事件处理程序事件类型是 slotchange。

包含影子的树顺序是节点树的包含影子的先序深度优先遍历。节点树 tree 的包含影子的先序深度优先遍历是 tree 的先序深度优先遍历，对于在 tree 中遇到的每个影子宿主，在其遇到之后立即对该元素的影子根的节点树进行包含影子的先序深度优先遍历。

一个对象的包含影子的根是其根的宿主的包含影子的根（如果该对象的根是一个影子根）；否则是其根。

如果对象 A 是对象 B 的后代，或者 A 的根是一个影子根并且 A 的根的宿主是 B 的包含影子的包含性后代，则对象 A 是对象 B 的包含影子的后代。

包含影子的包含性后代是一个对象或其包含影子的后代之一。

当且仅当 B 是 A 的包含影子的后代时，对象 A 是对象 B 的包含影子的祖先。

包含影子的包含性祖先是一个对象或其包含影子的祖先之一。

如果以下所有条件都为真，则节点 A 对于节点 B 是闭合影子隐藏的：

A 的根是一个影子根。
A 的根不是 B 的包含影子的包含性祖先。
A 的根是一个影子根，其模式是“closed”，或者 A 的根的宿主对于 B 是闭合影子隐藏的。

要针对对象 B 重定向对象 A，请重复这些步骤，直到它们返回一个对象：

如果以下情况之一为真：
- A 不是一个节点
- A 的根不是一个影子根
- B 是一个节点，并且 A 的根是 B 的包含影子的包含性祖先
则返回 A。
将 A 设置为 A 的根的宿主。

重定向算法被事件分派以及其他规范（例如 Fullscreen）使用。[FULLSCREEN]

4.9. 接口 `Element`

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

  [CEReactions] attribute DOMString id;
  [CEReactions] attribute DOMString className;
  [SameObject, PutForwards=value] readonly attribute DOMTokenList classList;
  [CEReactions, Unscopable] attribute DOMString slot;

  boolean hasAttributes();
  [SameObject] readonly attribute NamedNodeMap attributes;
  sequence<DOMString> getAttributeNames();
  DOMString? getAttribute(DOMString qualifiedName);
  DOMString? getAttributeNS(DOMString? namespace, DOMString localName);
  [CEReactions] undefined setAttribute(DOMString qualifiedName, DOMString value);
  [CEReactions] undefined setAttributeNS(DOMString? namespace, DOMString qualifiedName, DOMString value);
  [CEReactions] undefined removeAttribute(DOMString qualifiedName);
  [CEReactions] undefined removeAttributeNS(DOMString? namespace, DOMString localName);
  [CEReactions] boolean toggleAttribute(DOMString qualifiedName, optional boolean force);
  boolean hasAttribute(DOMString qualifiedName);
  boolean hasAttributeNS(DOMString? namespace, DOMString localName);

  Attr? getAttributeNode(DOMString qualifiedName);
  Attr? getAttributeNodeNS(DOMString? namespace, DOMString localName);
  [CEReactions] Attr? setAttributeNode(Attr attr);
  [CEReactions] Attr? setAttributeNodeNS(Attr attr);
  [CEReactions] Attr removeAttributeNode(Attr attr);

  ShadowRoot attachShadow(ShadowRootInit init);
  readonly attribute ShadowRoot? shadowRoot;

  readonly attribute CustomElementRegistry? customElementRegistry;

  Element? closest(DOMString selectors);
  boolean matches(DOMString selectors);
  boolean webkitMatchesSelector(DOMString selectors); // legacy alias of .matches

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

  [CEReactions] Element? insertAdjacentElement(DOMString where, Element element); // legacy
  undefined insertAdjacentText(DOMString where, DOMString data); // legacy
};

dictionary ShadowRootInit {
  required ShadowRootMode mode;
  boolean delegatesFocus = false;
  SlotAssignmentMode slotAssignment = "named";
  boolean clonable = false;
  boolean serializable = false;
  CustomElementRegistry customElementRegistry;
};

Element 节点通常称为元素。

元素具有关联的：

命名空间: Null 或非空字符串。
命名空间前缀: Null 或非空字符串。
本地名称: 一个非空字符串。
自定义元素注册表: Null 或一个 CustomElementRegistry 对象。
自定义元素状态: "undefined"、"failed"、"uncustomized"、"precustomized" 或 "custom"。
自定义元素定义: Null 或一个自定义元素定义。
is 值: Null 或一个有效的自定义元素名称。

当元素被创建时，所有这些值都会被初始化。

一个元素，其自定义元素状态为 "uncustomized" 或 "custom" 时，被称为已定义。一个元素，其自定义元素状态为 "custom" 时，被称为自定义。

元素是否已定义用于确定 :defined 伪类的行为。元素是否自定义用于确定突变算法的行为。"failed" 和 "precustomized" 状态用于确保如果自定义元素构造函数第一次未能正确执行，则不会通过升级再次执行。

以下代码展示了处于这四种状态中的元素：

<!DOCTYPE html>
<script>
  window.customElements.define("sw-rey", class extends HTMLElement {})
  window.customElements.define("sw-finn", class extends HTMLElement {}, { extends: "p" })
  window.customElements.define("sw-kylo", class extends HTMLElement {
    constructor() {
      // super() intentionally omitted for this example
    }
  })
</script>

<!-- "undefined" (not defined, not custom) -->
<sw-han></sw-han>
<p is="sw-luke"></p>
<p is="asdf"></p>

<!-- "failed" (not defined, not custom) -->
<sw-kylo></sw-kylo>

<!-- "uncustomized" (defined, not custom) -->
<p></p>
<asdf></asdf>

<!-- "custom" (defined, custom) -->
<sw-rey></sw-rey>
<p is="sw-finn"></p>

元素还有一个关联的影子根（null 或一个影子根）。除非另有说明，否则它为 null。如果一个元素的影子根非 null，则该元素是一个影子宿主。

一个元素的限定名是其本地名称（如果其命名空间前缀为 null）；否则是其命名空间前缀，后跟“:”，再后跟其本地名称。

一个元素的HTML 大写限定名是以下步骤的返回值：

设 qualifiedName 为此对象的限定名。
如果此对象在HTML 命名空间中，并且其节点文档是一个HTML 文档，则将 qualifiedName 设置为 qualifiedName 的ASCII 大写形式。
返回 qualifiedName。

用户代理可以通过将限定名和HTML 大写限定名存储在内部槽中来优化它们。

要创建一个元素，给定一个文档 document、字符串 localName、字符串或 null namespace，以及可选的字符串或 null prefix（默认为 null）、字符串或 null is（默认为 null）、布尔值 synchronousCustomElements（默认为 false）和 "default"、null 或一个 CustomElementRegistry 对象 registry（默认为 "default"）：

设 result 为 null。
如果 registry 是 "default"，则将 registry 设置为给定 document 查找自定义元素注册表的结果。
设 definition 为给定 registry、namespace、localName 和 is 查找自定义元素定义的结果。
如果 definition 非 null，并且 definition 的名称不等于其本地名称（即 definition 表示一个自定义的内置元素）：
1. 设 interface 为 localName 和HTML 命名空间的元素接口。
2. 将 result 设置为给定 document、interface、localName、HTML 命名空间、prefix、"undefined"、is 和 registry 创建元素内部的结果。
3. 如果 synchronousCustomElements 为 true，则在捕获任何异常的同时运行此步骤：
  1. 使用 definition 升级 result。
  如果此步骤抛出异常 exception：
  1. 为 definition 的构造函数的相应 JavaScript 对象的关联领域的全局对象报告 exception。
  2. 将 result 的自定义元素状态设置为 "failed"。
4. 否则，给定 result 和 definition 将自定义元素升级反应加入队列。
否则，如果 definition 非 null：
1. 如果 synchronousCustomElements 为 true：
  1. 设 C 为 definition 的构造函数。
  2. 设置周围代理的活动自定义元素构造函数映射[C] 为 registry。
  3. 在捕获任何异常的同时运行这些步骤：
    1. 将 result 设置为构造 C（无参数）的结果。
    2. 断言：result 的自定义元素状态和自定义元素定义已初始化。
    3. 断言：result 的命名空间是HTML 命名空间。
      
      IDL 强制 result 是一个 HTMLElement 对象，所有这些对象都使用HTML 命名空间。
    4. 如果 result 的属性列表不为空，则抛出一个“NotSupportedError”DOMException。
    5. 如果 result 有子节点，则抛出一个“NotSupportedError”DOMException。
    6. 如果 result 的父节点不为 null，则抛出一个“NotSupportedError”DOMException。
    7. 如果 result 的节点文档不是 document，则抛出一个“NotSupportedError”DOMException。
    8. 如果 result 的本地名称不等于 localName，则抛出一个“NotSupportedError”DOMException。
    9. 将 result 的命名空间前缀设置为 prefix。
    10. 将 result 的is 值设置为 null。
    11. 将 result 的自定义元素注册表设置为 registry。
    如果这些步骤中的任何一个抛出异常 exception：
    1. 为 definition 的构造函数的相应 JavaScript 对象的关联领域的全局对象报告 exception。
    2. 将 result 设置为给定 document、HTMLUnknownElement、localName、HTML 命名空间、prefix、"failed"、null 和 registry 创建元素内部的结果。
  4. 移除周围代理的活动自定义元素构造函数映射[C]。
    
    在正常情况下，此时它已经被移除了。
2. 否则：
  1. 将 result 设置为给定 document、HTMLElement、localName、HTML 命名空间、prefix、"undefined"、null 和 registry 创建元素内部的结果。
  2. 给定 result 和 definition 将自定义元素升级反应加入队列。
否则：
1. 设 interface 为 localName 和 namespace 的元素接口。
2. 将 result 设置为给定 document、interface、localName、namespace、prefix、"uncustomized"、is 和 registry 创建元素内部的结果。
3. 如果 namespace 是HTML 命名空间，并且 localName 是一个有效的自定义元素名称或 is 非 null，则将 result 的自定义元素状态设置为 "undefined"。
返回 result。

要创建元素内部，给定一个文档 document、一个接口 interface、一个字符串 localName、一个字符串或 null namespace、一个字符串或 null prefix、一个字符串 state、一个字符串或 null is，以及 null 或一个 CustomElementRegistry 对象 registry：

设 element 为一个实现 interface 的新元素，其命名空间设置为 namespace，命名空间前缀设置为 prefix，本地名称设置为 localName，自定义元素注册表设置为 registry，自定义元素状态设置为 state，自定义元素定义设置为 null，is 值设置为 is，节点文档设置为 document。
断言：element 的属性列表为空。
返回 element。

元素还有一个属性列表，它是一个通过 NamedNodeMap 公开的列表。除非在创建元素时明确指定，否则其属性列表为空。

如果一个元素的属性列表包含属性 A，则该元素拥有属性 A。

本规范和其他适用规范可以为元素定义属性更改步骤。该算法传递 element、localName、oldValue、value 和 namespace。

要为一个属性 attribute（具有 element、oldValue 和 newValue）处理属性更改，请运行以下步骤：

为 element 将一个突变记录加入队列，类型为 "attributes"，具有 attribute 的本地名称、attribute 的命名空间、oldValue、« »、« »、null 和 null。
如果 element 是自定义的，则将一个自定义元素回调反应加入队列，其中包含 element，回调名称为 "attributeChangedCallback"，参数为 « attribute 的本地名称、oldValue、newValue、attribute 的命名空间 »。
使用 element、attribute 的本地名称、oldValue、newValue 和 attribute 的命名空间运行属性更改步骤。

要将一个属性 attribute 更改为 value，请运行以下步骤：

设 oldValue 为 attribute 的值。
将 attribute 的值设置为 value。
为 attribute（具有 attribute 的元素、oldValue 和 value）处理属性更改。

要将一个属性 attribute 追加到一个元素 element，请运行以下步骤：

将 attribute 追加到 element 的属性列表。
将 attribute 的元素设置为 element。
将 attribute 的节点文档设置为 element 的节点文档。
为 attribute（具有 element、null 和 attribute 的值）处理属性更改。

要移除一个属性 attribute，请运行以下步骤：

设 element 为 attribute 的元素。
从 element 的属性列表中移除 attribute。
将 attribute 的元素设置为 null。
为 attribute（具有 element、attribute 的值和 null）处理属性更改。

要用一个属性 newAttribute 替换一个属性 oldAttribute：

设 element 为 oldAttribute 的元素。
在 element 的属性列表中用 newAttribute 替换 oldAttribute。
将 newAttribute 的元素设置为 element。
将 newAttribute 的节点文档设置为 element 的节点文档。
将 oldAttribute 的元素设置为 null。
为 oldAttribute（具有 element、oldAttribute 的值和 newAttribute 的值）处理属性更改。

要通过给定字符串 qualifiedName 和一个元素 element 按名称获取特性：

如果 element 位于HTML 命名空间中，并且其节点文档是一个HTML 文档，则将 qualifiedName 设置为 qualifiedName 的ASCII 小写形式。
返回 element 的特性列表中第一个特性，其限定名为 qualifiedName；否则返回 null。

要通过给定 null 或字符串 namespace、字符串 localName 和一个元素 element 按命名空间和本地名称获取特性：

如果 namespace 是空字符串，则将其设置为 null。
返回 element 的特性列表中特性，其命名空间为 namespace 且本地名称为 localName（如果存在）；否则返回 null。

要通过给定一个元素 element、一个字符串 localName 以及一个可选的 null 或字符串 namespace（默认为 null）获取特性值：

设 attr 为通过给定 namespace、localName 和 element 获取特性的结果。
如果 attr 为 null，则返回空字符串。
返回 attr 的值。

要通过给定一个特性 attr 和一个元素 element 设置特性：

如果 attr 的元素既不为 null 也不为 element，则抛出一个“InUseAttributeError”DOMException。
设 oldAttr 为通过给定 attr 的命名空间、attr 的本地名称和 element 获取特性的结果。
如果 oldAttr 是 attr，则返回 attr。
如果 oldAttr 非 null，则用 attr 替换 oldAttr。
否则，将 attr 追加到 element。
返回 oldAttr。

要通过给定一个元素 element、一个字符串 localName、一个字符串 value、一个可选的 null 或字符串 prefix（默认为 null）以及一个可选的 null 或字符串 namespace（默认为 null）设置特性值：

设 attribute 为通过给定 namespace、localName 和 element 获取特性的结果。
如果 attribute 为 null，则创建一个特性，其命名空间为 namespace，命名空间前缀为 prefix，本地名称为 localName，值为 value，并且节点文档为 element 的节点文档，然后将此特性追加到 element，然后返回。
将 attribute 更改为 value。

要通过给定字符串 qualifiedName 和一个元素 element 按名称移除特性：

设 attr 为通过给定 qualifiedName 和 element 获取特性的结果。
如果 attr 非 null，则移除 attr。
返回 attr。

要通过给定 null 或字符串 namespace、字符串 localName 和一个元素 element 按命名空间和本地名称移除特性：

设 attr 为通过给定 namespace、localName 和 element 获取特性的结果。
如果 attr 非 null，则移除 attr。
返回 attr。

一个元素可以有一个关联的唯一标识符 (ID)

历史上，元素可以有多个标识符，例如，通过使用 HTML id 特性和 DTD。本规范将ID作为 DOM 的一个概念，并允许每个元素只有一个 ID，由一个id 特性给出。

使用这些特性更改步骤来更新元素的ID：

如果 localName 是 id，namespace 是 null，并且 value 是 null 或空字符串，则取消设置 element 的ID。
否则，如果 localName 是 id，namespace 是 null，则将 element 的ID设置为 value。

虽然本规范定义了任何元素上 class、id 和 slot 特性的要求，但它并未声明使用它们是否符合规范。

一个节点的类型为 Element 的父节点被称为其父元素。如果节点具有不同类型的父节点，则其父元素为 null。

namespace = element . namespaceURI: 返回命名空间。
prefix = element . prefix: 返回命名空间前缀。
localName = element . localName: 返回本地名称。
qualifiedName = element . tagName: 返回HTML 大写限定名。

namespaceURI getter 的步骤是返回此对象的命名空间。

prefix getter 的步骤是返回此对象的命名空间前缀。

localName getter 的步骤是返回此对象的本地名称。

tagName getter 的步骤是返回此对象的HTML 大写限定名。

element . id [ = value ]: 返回 element 的 id 内容特性的值。可以设置以更改它。
element . className [ = value ]: 返回 element 的 class 内容特性的值。可以设置以更改它。
element . classList: 允许通过 DOMTokenList 对象将 element 的 class 内容特性作为一组以空格分隔的标记进行操作。
element . slot [ = value ]: 返回 element 的 slot 内容特性的值。可以设置以更改它。

定义为反映字符串 name 的 IDL 特性必须具有以下 getter 和 setter 步骤：

getter 步骤: 返回运行获取特性值（给定此对象和 name）的结果。
setter 步骤: 为此对象设置属性值，使用 name 和给定值。

id 特性必须反映 "id"。

className 特性必须反映 "class"。

classList getter 的步骤是返回一个 DOMTokenList 对象，其关联的元素是此对象，并且其关联的特性的本地名称是 class。这个特定的 DOMTokenList 对象的标记集也称为元素的类。

slot 特性必须反映 "slot"。

id、class 和 slot 实际上是超全局特性，因为它们可以出现在任何元素上，无论该元素的命名空间如何。

element . hasAttributes()

如果 element 有特性，则返回 true；否则返回 false。

element . getAttributeNames()

返回 element 所有特性的限定名。可能包含重复项。

element . getAttribute(qualifiedName)

返回 element 的第一个特性，其限定名为 qualifiedName；如果不存在这样的特性，则返回 null。

element . getAttributeNS(namespace, localName)

返回 element 的特性，其命名空间为 namespace 且本地名称为 localName；如果不存在这样的特性，则返回 null。

element . setAttribute(qualifiedName, value)

将 element 的第一个特性（其限定名为 qualifiedName）的值设置为 value。

element . setAttributeNS(namespace, localName, value)

将 element 的特性（其命名空间为 namespace 且本地名称为 localName）的值设置为 value。

element . removeAttribute(qualifiedName)

移除 element 的第一个特性，其限定名为 qualifiedName。

element . removeAttributeNS(namespace, localName)

移除 element 的特性，其命名空间为 namespace 且本地名称为 localName。

element . toggleAttribute(qualifiedName [, force])

如果未给出 force，则“切换”qualifiedName，如果存在则移除它，如果不存在则添加它。如果 force 为 true，则添加 qualifiedName。如果 force 为 false，则移除 qualifiedName。

如果 qualifiedName 现在存在，则返回 true；否则返回 false。

element . hasAttribute(qualifiedName)

如果 element 具有一个特性，其限定名为 qualifiedName，则返回 true；否则返回 false。

element . hasAttributeNS(namespace, localName)

如果 element 具有一个特性，其命名空间为 namespace 且本地名称为 localName，则返回 true。

hasAttributes() 方法的步骤是：如果此对象的特性列表为空，则返回 false；否则返回 true。

attributes getter 的步骤是返回关联的 NamedNodeMap。

getAttributeNames() 方法的步骤是按顺序返回此对象的特性列表中特性的限定名；否则返回一个新的列表。

这些不保证是唯一的。

getAttribute(qualifiedName) 方法的步骤是：

设 attr 为通过给定 qualifiedName 和此对象获取特性的结果。
如果 attr 为 null，则返回 null。
返回 attr 的值。

getAttributeNS(namespace, localName) 方法的步骤是：

设 attr 为通过给定 namespace、localName 和此对象获取特性的结果。
如果 attr 为 null，则返回 null。
返回 attr 的值。

setAttribute(qualifiedName, value) 方法的步骤是：

如果 qualifiedName 与 XML 中的 Name产生式不匹配，则抛出一个“InvalidCharacterError”DOMException。
如果此对象位于HTML 命名空间中，并且其节点文档是一个HTML 文档，则将 qualifiedName 设置为 qualifiedName 的ASCII 小写形式。
设 attribute 为此对象的特性列表中第一个特性，其限定名为 qualifiedName；否则为 null。
如果 attribute 为 null，则创建一个特性，其本地名称为 qualifiedName，值为 value，并且节点文档为此对象的节点文档，然后将此特性追加到此对象，然后返回。
将 attribute 更改为 value。

setAttributeNS(namespace, qualifiedName, value) 方法的步骤是：

设 namespace、prefix 和 localName 为将 namespace 和 qualifiedName 传递给验证和提取的结果。
为此对象设置属性值，使用 localName、value，以及 prefix 和 namespace。

removeAttribute(qualifiedName) 方法的步骤是：通过给定 qualifiedName 和此对象移除特性，然后返回 undefined。

removeAttributeNS(namespace, localName) 方法的步骤是：通过给定 namespace、localName 和此对象移除特性，然后返回 undefined。

hasAttribute(qualifiedName) 方法的步骤是：

如果此对象位于HTML 命名空间中，并且其节点文档是一个HTML 文档，则将 qualifiedName 设置为 qualifiedName 的ASCII 小写形式。
如果此对象具有一个特性，其限定名为 qualifiedName，则返回 true；否则返回 false。

toggleAttribute(qualifiedName, force) 方法的步骤是：

如果 qualifiedName 与 XML 中的 Name产生式不匹配，则抛出一个“InvalidCharacterError”DOMException。
如果此对象位于HTML 命名空间中，并且其节点文档是一个HTML 文档，则将 qualifiedName 设置为 qualifiedName 的ASCII 小写形式。
设 attribute 为此对象的特性列表中第一个特性，其限定名为 qualifiedName；否则为 null。
如果 attribute 为 null：
1. 如果未给出 force 或 force 为 true，则创建一个特性，其本地名称为 qualifiedName，值为空字符串，并且节点文档为此对象的节点文档，然后将此特性追加到此对象，然后返回 true。
2. 返回 false。
否则，如果未给出 force 或 force 为 false，则通过给定 qualifiedName 和此对象移除特性，然后返回 false。
返回 true。

hasAttributeNS(namespace, localName) 方法的步骤是：

如果 namespace 是空字符串，则将其设置为 null。
如果此对象具有一个特性，其命名空间为 namespace 且本地名称为 localName，则返回 true；否则返回 false。

getAttributeNode(qualifiedName) 方法的步骤是返回通过给定 qualifiedName 和此对象获取特性的结果。

getAttributeNodeNS(namespace, localName) 方法的步骤是返回通过给定 namespace、localName 和此对象获取特性的结果。

setAttributeNode(attr) 和 setAttributeNodeNS(attr) 方法的步骤是返回通过给定 attr 和此对象设置特性的结果。

removeAttributeNode(attr) 方法的步骤是：

如果此对象的特性列表不包含 attr，则抛出一个“NotFoundError”DOMException。
移除 attr。
返回 attr。

shadow = element . attachShadow(init): 为 element 创建一个影子根并返回它。
shadow = element . shadowRoot: 返回 element 的影子根（如果存在），并且如果影子根的模式是 "open"；否则返回 null。

一个有效的影子宿主名称是：

一个有效的自定义元素名称
"article"、 "aside"、 "blockquote"、 "body"、 "div"、 "footer"、 "h1"、 "h2"、 "h3"、 "h4"、 "h5"、 "h6"、 "header"、 "main"、 "nav"、 "p"、 "section" 或 "span"

attachShadow(init) 方法的步骤是：

设 registry 为此对象的自定义元素注册表。
如果 init["customElementRegistry"] 存在，则将 registry 设置为它。
使用此对象、init["mode"]、init["clonable"]、init["serializable"]、init["delegatesFocus"]、init["slotAssignment"] 和 registry 运行附加影子根。
返回此对象的影子根。

要附加影子根，给定一个元素 element、一个字符串 mode、一个布尔值 clonable、一个布尔值 serializable、一个布尔值 delegatesFocus、一个字符串 slotAssignment，以及 null 或一个 CustomElementRegistry 对象 registry：

如果 element 的命名空间不是HTML 命名空间，则抛出一个“NotSupportedError”DOMException。
如果 element 的本地名称不是一个有效的影子宿主名称，则抛出一个“NotSupportedError”DOMException。
如果 element 的本地名称是一个有效的自定义元素名称，或者 element 的is 值非 null：
1. 设 definition 为通过给定 element 的自定义元素注册表、其命名空间、其本地名称和其is 值查找自定义元素定义的结果。
2. 如果 definition 非 null 且 definition 的禁用影子为 true，则抛出一个“NotSupportedError”DOMException。
如果 element 是一个影子宿主：
1. 设 currentShadowRoot 为 element 的影子根。
2. 如果以下任一情况为真：
  - currentShadowRoot 的声明性为 false；或
  - currentShadowRoot 的模式不是 mode，
  则抛出一个“NotSupportedError”DOMException。
3. 否则：
  1. 按树顺序移除 currentShadowRoot 的所有子节点。
  2. 将 currentShadowRoot 的声明性设置为 false。
  3. 返回。
设 shadow 为一个新的影子根，其节点文档为 element 的节点文档，宿主为 element，模式为 mode。
将 shadow 的委托焦点设置为 delegatesFocus。
如果 element 的自定义元素状态是 "precustomized" 或 "custom"，则将 shadow 的对元素内部可用设置为 true。
将 shadow 的插槽分配设置为 slotAssignment。
将 shadow 的声明性设置为 false。
将 shadow 的可克隆性设置为 clonable。
将 shadow 的可序列化性设置为 serializable。
将 shadow 的自定义元素注册表设置为 registry。
将 element 的影子根设置为 shadow。

shadowRoot getter 的步骤是：

设 shadow 为此对象的影子根。
如果 shadow 为 null 或其模式为 "closed"，则返回 null。
返回 shadow。

registry = element . customElementRegistry: 返回 element 的 CustomElementRegistry 对象（如果存在）；否则返回 null。

customElementRegistry getter 的步骤是返回此对象的自定义元素注册表。

element . closest(selectors): 返回第一个（从 element 开始）匹配 selectors 的包含祖先；否则返回 null。
element . matches(selectors): 如果针对 element 的根匹配 selectors 得到 element，则返回 true；否则返回 false。

closest(selectors) 方法的步骤是：

设 s 为从 selectors 解析选择器的结果。[SELECTORS4]
如果 s 失败，则抛出一个“SyntaxError”DOMException。
设 elements 为此对象的包含祖先中属于元素的部分，按反向树顺序排列。
对于 elements 中的每个 element，如果使用 s、element 和作用域根此对象针对元素匹配选择器返回成功，则返回 element。[SELECTORS4]
返回 null。

matches(selectors) 和 webkitMatchesSelector(selectors) 方法的步骤是：

设 s 为从 selectors 解析选择器的结果。[SELECTORS4]
如果 s 失败，则抛出一个“SyntaxError”DOMException。
如果使用 s、此对象和作用域根此对象针对元素匹配选择器的结果返回成功，则返回 true；否则返回 false。[SELECTORS4]

getElementsByTagName(qualifiedName) 方法的步骤是返回此对象的具有限定名 qualifiedName 的元素列表。

getElementsByTagNameNS(namespace, localName) 方法的步骤是返回此对象的具有命名空间 namespace 和本地名称 localName 的元素列表。

getElementsByClassName(classNames) 方法的步骤是返回此对象的具有类名 classNames 的元素列表。

要插入相邻内容，给定一个元素 element、字符串 where 和一个节点 node，运行与 where 的第一个ASCII 不区分大小写匹配关联的步骤：

"beforebegin"

如果 element 的父节点为 null，则返回 null。

返回将 node 预插入到 element 的父节点中 element 之前的结果。

"afterbegin"

返回将 node 预插入到 element 中 element 的第一个子节点之前的结果。

"beforeend"

返回将 node 预插入到 element 中 null 之前的结果。

"afterend"

如果 element 的父节点为 null，则返回 null。

返回将 node 预插入到 element 的父节点中 element 的下一个兄弟节点之前的结果。

否则

抛出一个“SyntaxError”DOMException。

insertAdjacentElement(where, element) 方法的步骤是返回运行插入相邻（给定此对象、where 和 element）的结果。

insertAdjacentText(where, data) 方法的步骤是：

设 text 为一个新的 Text 节点，其数据为 data，节点文档为此对象的节点文档。
运行插入相邻（给定此对象、where 和 text）。

此方法不返回任何内容，因为在我们有机会设计它之前它就已经存在了。

4.9.1. 接口 `NamedNodeMap`

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

一个 NamedNodeMap 有一个关联的元素（一个元素）。

一个 NamedNodeMap 对象的属性列表是其元素的属性列表。

一个 NamedNodeMap 对象的支持的属性索引是指从零到其属性列表的大小减一范围内的数字，除非该属性列表为空，在这种情况下，没有支持的属性索引。

length getter 的步骤是返回该属性列表的大小。

item(index) 方法的步骤是：

如果 index 等于或大于此对象的属性列表的大小，则返回 null。
否则，返回此对象的属性列表[index]。

一个 NamedNodeMap 对象的支持的属性名称是运行以下步骤的返回值：

设 names 为此 NamedNodeMap 对象的属性列表中属性的限定名称，按顺序排列，并省略重复项。
如果此 NamedNodeMap 对象的元素位于HTML 命名空间中，并且其节点文档是一个HTML 文档，则对于 names 中的每个 name：
1. 设 lowercaseName 为 name 的ASCII 小写形式。
2. 如果 lowercaseName 不等于 name，则从 names 中移除 name。
返回 names。

getNamedItem(qualifiedName) 方法的步骤是返回给定 qualifiedName 和元素获取属性的结果。

getNamedItemNS(namespace, localName) 方法的步骤是返回给定 namespace、localName 和元素获取属性的结果。

setNamedItem(attr) 和 setNamedItemNS(attr) 方法的步骤是返回给定 attr 和元素设置属性的结果。

removeNamedItem(qualifiedName) 方法的步骤是：

设 attr 为给定 qualifiedName 和元素移除属性的结果。
如果 attr 为 null，则抛出一个“NotFoundError”DOMException。
返回 attr。

removeNamedItemNS(namespace, localName) 方法的步骤是：

设 attr 为给定 namespace、localName 和元素移除属性的结果。
如果 attr 为 null，则抛出一个“NotFoundError”DOMException。
返回 attr。

4.9.2. 接口 `Attr`

[Exposed=Window]
interface Attr : Node {
  readonly attribute DOMString? namespaceURI;
  readonly attribute DOMString? prefix;
  readonly attribute DOMString localName;
  readonly attribute DOMString name;
  [CEReactions] attribute DOMString value;

  readonly attribute Element? ownerElement;

  readonly attribute boolean specified; // useless; always returns true
};

Attr 节点通常被称为属性。它们有时被称为内容属性，以避免与 IDL 属性混淆。

属性具有命名空间（null 或非空字符串）、命名空间前缀（null 或非空字符串）、本地名称（非空字符串）、值（一个字符串）和元素（null 或一个元素）。

如果今天设计，它们将只具有名称和值。☹

一个属性的限定名称是其本地名称（如果其命名空间前缀为 null），否则是其命名空间前缀，后跟“:”，再后跟其本地名称。

用户代理可以将此作为内部槽以进行优化。

当创建属性时，会给出其本地名称。除非在创建属性时明确给出，否则其命名空间、命名空间前缀和元素将设置为空，并且其值将设置为空字符串。

一个A 属性是一个属性，其本地名称为 A，并且其命名空间和命名空间前缀为空。

namespaceURI getter 的步骤是返回此对象的命名空间。

prefix getter 的步骤是返回此对象的命名空间前缀。

localName getter 的步骤是返回此对象的本地名称。

name getter 的步骤是返回此对象的限定名称。

value getter 的步骤是返回此对象的值。

要设置现有属性值，给定一个属性 attribute 和字符串 value，请运行以下步骤：

如果 attribute 的元素为 null，则将 attribute 的值设置为 value。
否则，将 attribute 更改为 value。

value setter 的步骤是使用此对象和给定值设置现有属性值。

ownerElement getter 的步骤是返回此对象的元素。

specified getter 的步骤是返回 true。

4.10. 接口 `CharacterData`

[Exposed=Window]
interface CharacterData : Node {
  attribute [LegacyNullToEmptyString] DOMString data;
  readonly attribute unsigned long length;
  DOMString substringData(unsigned long offset, unsigned long count);
  undefined appendData(DOMString data);
  undefined insertData(unsigned long offset, DOMString data);
  undefined deleteData(unsigned long offset, unsigned long count);
  undefined replaceData(unsigned long offset, unsigned long count, DOMString data);
};

CharacterData 是一个抽象接口。你无法直接获取其实例。它被 Text、ProcessingInstruction 和 Comment 节点使用。

每个继承自 CharacterData 接口的节点都有一个关联的可变字符串，称为data。

要替换数据（节点 node，偏移量 offset，计数 count，数据 data），请执行以下步骤：

令 length 为 node 的长度。
如果 offset 大于 length，则抛出一个“IndexSizeError”DOMException。
如果 offset 加上 count 大于 length，则将 count 设置为 length 减去 offset。
为 node 加入一个突变记录队列，类型为“characterData”，属性为 null、null、node 的data、« »、« »、null 和 null。
在 node 的data 中，在 offset 个代码单元之后插入 data。
令 delete offset 为 offset + data 的长度。
从 delete offset 个代码单元开始，从 node 的data 中移除 count 个代码单元。
对于每个活动范围，如果其起始节点是 node 并且其起始偏移量大于 offset 但小于或等于 offset 加上 count，则将其起始偏移量设置为 offset。
对于每个活动范围，如果其结束节点是 node 并且其结束偏移量大于 offset 但小于或等于 offset 加上 count，则将其结束偏移量设置为 offset。
对于每个活动范围，如果其起始节点是 node 并且其起始偏移量大于 offset 加上 count，则将其起始偏移量增加 data 的长度并减少 count。
对于每个活动范围，如果其结束节点是 node 并且其结束偏移量大于 offset 加上 count，则将其结束偏移量增加 data 的长度并减少 count。
如果 node 的父节点非空，则为 node 的父节点运行子节点更改步骤。

要获取子字符串数据（节点 node，偏移量 offset，计数 count），请执行以下步骤：

令 length 为 node 的长度。
如果 offset 大于 length，则抛出一个“IndexSizeError”DOMException。
如果 offset 加上 count 大于 length，则返回一个字符串，其值为从 node 的data 中第 offset 个代码单元到末尾的代码单元，然后返回。
返回一个字符串，其值为 node 的data 中从第 offset 个代码单元到第 offset+count 个代码单元的代码单元。

data getter 的步骤是返回此对象的data。其 setter 必须使用节点此对象、偏移量 0、计数此对象的长度和数据新值来替换数据。

length getter 的步骤是返回此对象的长度。

substringData(offset, count) 方法的步骤是返回运行获取子字符串数据（节点此对象，偏移量 offset，计数 count）的结果。

appendData(data) 方法的步骤是使用节点此对象、偏移量此对象的长度、计数 0 和数据 data 来替换数据。

insertData(offset, data) 方法的步骤是使用节点此对象、偏移量 offset、计数 0 和数据 data 来替换数据。

deleteData(offset, count) 方法的步骤是使用节点此对象、偏移量 offset、计数 count 和数据空字符串来替换数据。

replaceData(offset, count, data) 方法的步骤是使用节点此对象、偏移量 offset、计数 count 和数据 data 来替换数据。

4.11. 接口 `Text`

[Exposed=Window]
interface Text : CharacterData {
  constructor(optional DOMString data = "");

  [NewObject] Text splitText(unsigned long offset);
  readonly attribute DOMString wholeText;
};

text = new Text([data = ""]): 返回一个新的 Text 节点，其 data 为 data。
text . splitText(offset): 在给定的 offset 处分割 data，并将余下部分作为 Text 节点返回。
text . wholeText: 返回所有直接 Text 节点兄弟节点的组合 data。

一个排他的 Text 节点是一个Text 节点，它不是一个 CDATASection 节点。

一个节点 node 的连续 Text 节点包括 node 本身，node 的前一个兄弟 Text 节点（如果存在）及其连续的 Text 节点，以及 node 的后一个兄弟 Text 节点（如果存在）及其连续的 Text 节点，并避免任何重复。

一个节点 node 的连续排他的 Text 节点包括 node 本身，node 的前一个兄弟排他的 Text 节点（如果存在）及其连续排他的 Text 节点，以及 node 的后一个兄弟排他的 Text 节点（如果存在）及其连续排他的 Text 节点，并避免任何重复。

一个节点 node 的子文本内容是 node 的所有 Text 节点子节点的 data 按照树顺序连接的结果。

一个节点 node 的后代文本内容是 node 的所有 Text 节点后代节点的 data 按照树顺序连接的结果。

new Text(data) 构造函数的步骤是将此对象的 data 设置为 data，并将此对象的节点文档设置为当前全局对象的关联的 Document。

要分割一个 Text 节点 node（偏移量为 offset），请执行以下步骤：

令 length 为 node 的长度。
如果 offset 大于 length，则抛出一个“IndexSizeError”DOMException。
令 count 为 length 减去 offset。
令 new data 为使用节点 node、偏移量 offset 和计数 count 获取子字符串数据的结果。
令 new node 为一个新的 Text 节点，其节点文档与 node 相同。将 new node 的 data 设置为 new data。
令 parent 为 node 的父节点。
如果 parent 不为 null：
1. 在 node 的后一个兄弟节点之前，将 new node 插入到 parent 中。
2. 对于每个活动范围，如果其起始节点是 node 并且其起始偏移量大于 offset，则将其起始节点设置为 new node，并将其起始偏移量减去 offset。
3. 对于每个活动范围，如果其结束节点是 node 并且其结束偏移量大于 offset，则将其结束节点设置为 new node，并将其结束偏移量减去 offset。
4. 对于每个活动范围，如果其起始节点是 parent 并且其起始偏移量等于 node 的索引加 1，则将其起始偏移量增加 1。
5. 对于每个活动范围，如果其结束节点是 parent 并且其结束偏移量等于 node 的索引加 1，则将其结束偏移量增加 1。
使用节点 node、偏移量 offset、计数 count 和数据空字符串替换数据。
返回 new node。

splitText(offset) 方法的步骤是使用偏移量 offset 分割此对象。

wholeText getter 的步骤是返回此对象的连续 Text 节点的 data 按照树顺序连接的结果。

4.12. 接口 `CDATASection`

[Exposed=Window]
interface CDATASection : Text {
};

4.13. 接口 `ProcessingInstruction`

[Exposed=Window]
interface ProcessingInstruction : CharacterData {
  readonly attribute DOMString target;
};

ProcessingInstruction 节点有一个关联的目标。

target getter 的步骤是返回此对象的目标。

4.14. 接口 `注释`

[Exposed=Window]
interface Comment : CharacterData {
  constructor(optional DOMString data = "");
};

comment = new Comment([data = ""]): 返回一个新的 Comment 节点，其 data 为 data。

new Comment(data) 构造函数的步骤是将此对象的 data 设置为 data，并将此对象的节点文档设置为当前全局对象的关联的 Document。

5. Ranges

5.1. Introduction to "DOM Ranges"

StaticRange 和 Range 对象（范围）表示节点树中的一个内容序列。每个范围都有一个开始点和一个结束点，它们都是边界点。一个边界点是一个由节点和偏移量组成的元组。换句话说，一个范围表示节点树中两个边界点之间的一段内容。

范围经常用于编辑中选择和复制内容。

Element: p
- Element: <img src="insanity-wolf" alt="Little-endian BOM; decode as big-endian!">
- Text: CSS 2.1 syndata 是
- Element: <em>
  - Text: 棒极了
- Text: ！

在上面的节点树中，一个范围可以用来表示序列“syndata is awes”。假设 p 分配给 p 元素，em 分配给 em 元素，则可以如下操作：

var range = new Range(),
    firstText = p.childNodes[1],
    secondText = em.firstChild
range.setStart(firstText, 9) // do not forget the leading space
range.setEnd(secondText, 4)
// range now stringifies to the aforementioned quote

像上面节点树中的 src 和 alt 这样的属性不能用范围来表示。范围仅对节点有用。

Range 对象与 StaticRange 对象不同，它会受到节点树突变的影响。因此它们也被称为活动范围。此类突变不会使其失效，并将尝试确保它仍然表示相同的内容片段。必要时，当例如它所表示的部分内容发生突变时，活动范围本身可能会作为节点树突变的一部分而被修改。

有关详细信息，请参阅插入和移除算法、normalize() 方法以及替换数据和分割算法。

响应节点树突变来更新活动范围的成本可能很高。对于节点树的每次更改，所有受影响的 Range 对象都需要更新。即使应用程序对某些活动范围不感兴趣，当发生突变时，它仍然必须支付保持它们最新的成本。

一个 StaticRange 对象是一个轻量级的范围，当节点树发生突变时它不会更新。因此，它不像活动范围那样需要相同的维护成本。

5.2. Boundary points

一个边界点是一个由节点（一个节点）和一个偏移量（一个非负整数）组成的元组。

一个正确的边界点的偏移量将在 0 和该边界点的节点的长度之间（包含边界）。

一个边界点 (nodeA, offsetA) 相对于另一个边界点 (nodeB, offsetB) 的位置是之前、相等或之后，具体由以下步骤返回：

断言：nodeA 和 nodeB 具有相同的根。
如果 nodeA 与 nodeB 相同，则如果 offsetA 与 offsetB 相同，则返回相等；如果 offsetA 小于 offsetB，则返回之前；如果 offsetA 大于 offsetB，则返回之后。
如果 nodeA 在 nodeB 之后，则如果 (nodeB, offsetB) 相对于 (nodeA, offsetA) 的位置是之前，则返回之后；如果它是之后，则返回之前。
如果 nodeA 是 nodeB 的一个祖先：
1. 令 child 为 nodeB。
2. 当 child 不是 nodeA 的一个子节点时，将 child 设置为其父节点。
3. 如果 child 的索引小于 offsetA，则返回之后。
返回之前。

5.3. 接口 `AbstractRange`

[Exposed=Window]
interface AbstractRange {
  readonly attribute Node startContainer;
  readonly attribute unsigned long startOffset;
  readonly attribute Node endContainer;
  readonly attribute unsigned long endOffset;
  readonly attribute boolean collapsed;
};

实现 AbstractRange 接口的对象被称为范围。

一个范围具有两个关联的边界点——起点和终点。

为方便起见，一个范围的起始节点是其起始点的节点，其起始偏移量是其起始点的偏移量，其结束节点是其结束点的节点，其结束偏移量是其结束点的偏移量。

如果一个范围的起始节点与其结束节点相同，并且其起始偏移量与其结束偏移量相同，则该范围是折叠的。

node = range . startContainer: 返回 range 的起始节点。
offset = range . startOffset: 返回 range 的起始偏移量。
node = range . endContainer: 返回 range 的结束节点。
offset = range . endOffset: 返回 range 的结束偏移量。
collapsed = range . collapsed: 如果 range 是折叠的，则返回 true；否则返回 false。

startContainer getter 的步骤是返回此对象的起始节点。

startOffset getter 的步骤是返回此对象的起始偏移量。

endContainer getter 的步骤是返回此对象的结束节点。

endOffset getter 的步骤是返回此对象的结束偏移量。

collapsed getter 的步骤是：如果此对象是折叠的，则返回 true；否则返回 false。

5.4. 接口 `StaticRange`

dictionary StaticRangeInit {
  required Node startContainer;
  required unsigned long startOffset;
  required Node endContainer;
  required unsigned long endOffset;
};

[Exposed=Window]
interface StaticRange : AbstractRange {
  constructor(StaticRangeInit init);
};

staticRange = new StaticRange(init): 返回一个新的范围对象，该对象在节点树发生突变时不会更新。

new StaticRange(init) 构造函数的步骤如下：

如果 init["startContainer"] 或 init["endContainer"] 是一个 DocumentType 或 Attr 节点，则抛出一个“InvalidNodeTypeError”DOMException。
将此对象的起始点设置为 (init["startContainer"], init["startOffset"])，并将结束点设置为 (init["endContainer"], init["endOffset"])。

如果以下所有条件均为真，则 StaticRange 是有效的：

其起始点和结束点在同一个节点树中。
其起始偏移量介于 0 和其起始节点的长度之间（包含边界）。
其结束偏移量介于 0 和其结束节点的长度之间（包含边界）。
其起始点在其结束点之前或与之相等。

5.5. 接口 `Range`

[Exposed=Window]
interface Range : AbstractRange {
  constructor();

  readonly attribute Node commonAncestorContainer;

  undefined setStart(Node node, unsigned long offset);
  undefined setEnd(Node node, unsigned long offset);
  undefined setStartBefore(Node node);
  undefined setStartAfter(Node node);
  undefined setEndBefore(Node node);
  undefined setEndAfter(Node node);
  undefined collapse(optional boolean toStart = false);
  undefined selectNode(Node node);
  undefined selectNodeContents(Node node);

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

  [CEReactions] undefined deleteContents();
  [CEReactions, NewObject] DocumentFragment extractContents();
  [CEReactions, NewObject] DocumentFragment cloneContents();
  [CEReactions] undefined insertNode(Node node);
  [CEReactions] undefined surroundContents(Node newParent);

  [NewObject] Range cloneRange();
  undefined detach();

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

  boolean intersectsNode(Node node);

  stringifier;
};

实现 Range 接口的对象被称为活动范围。

修改树的算法（特别是插入、移除、移动、替换数据和分割算法）会修改与该树关联的活动范围。

活动范围的根是其起始节点的根。

如果一个节点 node 的根与活动范围 range 的根相同，并且 (node, 0) 在 range 的起始点之后，并且 (node, node的长度) 在 range 的结束点之前，则该节点 node 包含在活动范围 range 中。

如果一个节点是活动范围的起始节点的包含祖先但不是其结束节点的包含祖先，反之亦然，则该节点部分包含在该活动范围中。

一些有助于更好理解这些定义的事实：

人们通常认为在活动范围内的内容包括所有包含的节点，如果起始节点和结束节点是CharacterData 节点，则可能还包括这些节点的部分内容。
活动范围中包含的节点通常不是连续的，因为包含的节点的父节点并不总是被包含。
然而，包含的节点的后代节点是包含的，并且如果两个兄弟节点是包含的，那么它们之间的任何兄弟节点也是包含的。
活动范围的起始节点和结束节点从不包含在其中。
第一个包含的节点（如果存在）将始终在起始节点之后，而最后一个包含的节点将始终等于或在结束节点的最后一个后代节点之前。
当且仅当起始节点和结束节点不同时，才存在部分包含的节点。
commonAncestorContainer 属性值既不包含也不部分包含。
如果起始节点是结束节点的祖先，则共同的包含祖先将是起始节点。其子节点中恰好有一个是部分包含的，并且一个子节点当且仅当它在部分包含的子节点之前时才是包含的。如果结束节点是起始节点的祖先，则情况相反。
如果起始节点不是结束节点的包含祖先，反之亦然，则共同的包含祖先将与它们两者都不同。其子节点中恰好有两个是部分包含的，并且一个子节点当且仅当它位于这两个子节点之间时才是包含的。

给定一个节点 node，活动范围预移除步骤如下：

令 parent 为 node 的父节点。
断言：parent 不为 null。
令 index 为 node 的索引。
对于每个活动范围，如果其起始节点是 node 的包含后代，则将其起始点设置为 (parent, index)。
对于每个活动范围，如果其结束节点是 node 的包含后代，则将其结束点设置为 (parent, index)。
对于每个活动范围，如果其起始节点是 parent 并且起始偏移量大于 index，则将其起始偏移量减 1。
对于每个活动范围，如果其结束节点是 parent 并且结束偏移量大于 index，则将其结束偏移量减 1。

range = new Range(): 返回一个新的活动范围。

new Range() 构造函数的步骤是将此对象的起始点和结束点设置为 (当前全局对象的关联的 Document, 0)。

container = range . commonAncestorContainer: 返回距离文档最远，并且是 range 的起始节点和结束节点的祖先的节点。

commonAncestorContainer getter 的步骤是：

令 container 为起始节点。
当 container 不是结束节点的包含祖先时，令 container 为 container 的父节点。
返回 container。

要将range的起始点或结束点设置为一个边界点 (node, offset)，请执行以下步骤：

如果 node 是一个文档类型节点，则抛出一个“InvalidNodeTypeError”DOMException。
如果 offset 大于 node 的长度，则抛出一个“IndexSizeError”DOMException。
令 bp 为边界点 (node, offset)。
如果这些步骤是作为“设置起始点”调用的
1. 如果 range 的根不等于 node 的根，或者如果 bp 在 range 的结束点之后，则将 range 的结束点设置为 bp。
2. 将 range 的起始点设置为 bp。
如果这些步骤是作为“设置结束点”调用的
1. 如果 range 的根不等于 node 的根，或者如果 bp 在 range 的起始点之前，则将 range 的起始点设置为 bp。
2. 将 range 的结束点设置为 bp。

setStart(node, offset) 方法的步骤是将此对象的起始点设置为边界点 (node, offset)。

setEnd(node, offset) 方法的步骤是将此对象的结束点设置为边界点 (node, offset)。

setStartBefore(node) 方法的步骤是：

令 parent 为 node 的父节点。
如果 parent 为 null，则抛出一个“InvalidNodeTypeError”DOMException。
将此对象的起始点设置为边界点 (parent, node的索引)。

setStartAfter(node) 方法的步骤是：

令 parent 为 node 的父节点。
如果 parent 为 null，则抛出一个“InvalidNodeTypeError”DOMException。
将此对象的起始点设置为边界点 (parent, node的索引加 1)。

setEndBefore(node) 方法的步骤是：

令 parent 为 node 的父节点。
如果 parent 为 null，则抛出一个“InvalidNodeTypeError”DOMException。
将此对象的结束点设置为边界点 (parent, node的索引)。

setEndAfter(node) 方法的步骤是：

令 parent 为 node 的父节点。
如果 parent 为 null，则抛出一个“InvalidNodeTypeError”DOMException。
将此对象的结束点设置为边界点 (parent, node的索引加 1)。

collapse(toStart) 方法的步骤是：如果 toStart 为 true，则将结束点设置为起始点；否则将起始点设置为结束点。

要在范围 range 内选择一个节点 node，请执行以下步骤：

令 parent 为 node 的父节点。
如果 parent 为 null，则抛出一个“InvalidNodeTypeError”DOMException。
令 index 为 node 的索引。
将 range 的起始点设置为边界点 (parent, index)。
将 range 的结束点设置为边界点 (parent, index 加 1)。

selectNode(node) 方法的步骤是在此对象内选择 node。

selectNodeContents(node) 方法的步骤是：

如果 node 是一个文档类型节点，则抛出一个“InvalidNodeTypeError”DOMException。
令 length 为 node 的长度。
将起始点设置为边界点 (node, 0)。
将结束点设置为边界点 (node, length)。

compareBoundaryPoints(how, sourceRange) 方法的步骤是：

如果 how 不是以下之一：
- START_TO_START,
- START_TO_END,
- END_TO_END, 以及
- END_TO_START,
则抛出一个“NotSupportedError”DOMException。
如果此对象的根与 sourceRange 的根不同，则抛出一个“WrongDocumentError”DOMException。
如果 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() 方法的步骤是：

如果此对象是折叠的，则返回。
令 original start node、original start offset、original end node 和 original end offset 分别为此对象的起始节点、起始偏移量、结束节点和结束偏移量。
如果 original start node 与 original end node 相同且它是一个 CharacterData 节点，则使用节点 original start node、偏移量 original start offset、计数 original end offset 减去 original start offset 以及数据空字符串替换数据，然后返回。
令 nodes to remove 为一个列表，其中包含所有包含在此对象中的节点，按树顺序排列，并省略任何其父节点也包含在此对象中的节点。
如果 original start node 是 original end node 的包含祖先，则将 new node 设置为 original start node，并将 new offset 设置为 original start offset。
否则：
1. 令 reference node 等于 original start node。
2. 当 reference node 的父节点不为 null 且不是 original end node 的包含祖先时，将 reference node 设置为其父节点。
3. 将 new node 设置为 reference node 的父节点，并将 new offset 设置为 reference node 的索引加 1。
  如果 reference node 的父节点为 null，则它将是此对象的根，因此将是 original end node 的包含祖先，我们无法到达此点。
如果 original start node 是一个 CharacterData 节点，则使用节点 original start node、偏移量 original start offset、计数 original start node 的长度 − original start offset 以及数据空字符串替换数据。
对于 nodes to remove 中的每个 node，按树顺序移除 node。
如果 original end node 是一个 CharacterData 节点，则使用节点 original end node、偏移量 0、计数 original end offset 以及数据空字符串替换数据。
将起始点和结束点设置为 (new node, new offset)。

要提取一个活动范围 range，请执行以下步骤：

令 fragment 为一个新的 DocumentFragment 节点，其节点文档是 range 的起始节点的节点文档。
如果 range 是折叠的，则返回 fragment。
令 original start node、original start offset、original end node 和 original end offset 分别为 range 的起始节点、起始偏移量、结束节点和结束偏移量。
如果 original start node 与 original end node 相同且它是一个 CharacterData 节点：
1. 令 clone 为 original start node 的一个克隆。
2. 将 clone 的数据设置为使用节点 original start node、偏移量 original start offset 以及计数 original end offset 减去 original start offset 获取子字符串数据的结果。
3. 将 clone 追加到 fragment。
4. 使用节点 original start node、偏移量 original start offset、计数 original end offset 减去 original start offset 以及数据空字符串替换数据。
5. 返回 fragment。
令 common ancestor 为 original start node。
当 common ancestor 不是 original end node 的包含祖先时，将 common ancestor 设置为其自身的父节点。
令 first partially contained child 为 null。
如果 original start node 不是 original end node 的包含祖先，则将 first partially contained child 设置为 common ancestor 的第一个部分包含在 range 中的子节点。
令 last partially contained child 为 null。
如果 original end node 不是 original start node 的包含祖先，则将 last partially contained child 设置为 common ancestor 的最后一个部分包含在 range 中的子节点。
这些变量赋值实际上总是合理的。例如，如果 original start node 不是 original end node 的包含祖先，则 original start node 本身部分包含在 range 中，其所有祖先直到 common ancestor 的一个子节点也是如此。common ancestor 不能是 original start node，因为它必须是 original end node 的包含祖先。另一种情况类似。另外，请注意，如果两个子节点都已定义，则它们永远不会相等。
令 contained children 为一个列表，其中包含 common ancestor 的所有包含在 range 中的子节点，按树顺序排列。
如果 contained children 中的任何成员是文档类型节点，则抛出一个“HierarchyRequestError”DOMException。

我们不必担心第一个或最后一个部分包含的节点，因为文档类型节点永远不能部分包含。它不能是范围的边界点，也不能是任何东西的祖先。
如果 original start node 是 original end node 的包含祖先，则将 new node 设置为 original start node，并将 new offset 设置为 original start offset。
否则：
1. 令 reference node 等于 original start node。
2. 当 reference node 的父节点不为 null 且不是 original end node 的包含祖先时，将 reference node 设置为其父节点。
3. 将 new node 设置为 reference node 的父节点，并将 new offset 设置为 reference node 的索引加 1。
  如果 reference node 的父节点为 null，则它将是 range 的根，因此将是 original end node 的包含祖先，我们无法到达此点。
如果 first partially contained child 是一个 CharacterData 节点：

在这种情况下，first partially contained child 是 original start node。
1. 令 clone 为 original start node 的一个克隆。
2. 将 clone 的数据设置为使用节点 original start node、偏移量 original start offset 以及计数 original start node 的长度 − original start offset 获取子字符串数据的结果。
3. 将 clone 追加到 fragment。
4. 使用节点 original start node、偏移量 original start offset、计数 original start node 的长度 − original start offset 以及数据空字符串替换数据。
否则，如果 first partially contained child 不为 null：
1. 令 clone 为 first partially contained child 的一个克隆。
2. 将 clone 追加到 fragment。
3. 令 subrange 为一个新的活动范围，其起始点为 (original start node, original start offset)，其结束点为 (first partially contained child, first partially contained child的长度)。
4. 令 subfragment 为提取 subrange 的结果。
5. 将 subfragment 追加到 clone。
对于 contained children 中的每个 contained child，将 contained child 追加到 fragment。
如果 last partially contained child 是一个 CharacterData 节点：

在这种情况下，last partially contained child 是 original end node。
1. 令 clone 为 original end node 的一个克隆。
2. 将 clone 的数据设置为使用节点 original end node、偏移量 0 以及计数 original end offset 获取子字符串数据的结果。
3. 将 clone 追加到 fragment。
4. 使用节点 original end node、偏移量 0、计数 original end offset 以及数据空字符串替换数据。
否则，如果 last partially contained child 不为 null：
1. 令 clone 为 last partially contained child 的一个克隆。
2. 将 clone 追加到 fragment。
3. 令 subrange 为一个新的活动范围，其起始点为 (last partially contained child, 0)，其结束点为 (original end node, original end offset)。
4. 令 subfragment 为提取 subrange 的结果。
5. 将 subfragment 追加到 clone。
将 range 的起始点和结束点设置为 (new node, new offset)。
返回 fragment。

extractContents() 方法的步骤是返回提取此对象的结果。

要克隆内容一个活动范围 range，请执行以下步骤：

令 fragment 为一个新的 DocumentFragment 节点，其节点文档是 range 的起始节点的节点文档。
如果 range 是折叠的，则返回 fragment。
令 original start node、original start offset、original end node 和 original end offset 分别为 range 的起始节点、起始偏移量、结束节点和结束偏移量。
如果 original start node 与 original end node 相同且它是一个 CharacterData 节点：
1. 令 clone 为 original start node 的一个克隆。
2. 将 clone 的数据设置为使用节点 original start node、偏移量 original start offset 以及计数 original end offset 减去 original start offset 获取子字符串数据的结果。
3. 将 clone 追加到 fragment。
4. 返回 fragment。
令 common ancestor 为 original start node。
当 common ancestor 不是 original end node 的包含祖先时，将 common ancestor 设置为其自身的父节点。
令 first partially contained child 为 null。
如果 original start node 不是 original end node 的包含祖先，则将 first partially contained child 设置为 common ancestor 的第一个部分包含在 range 中的子节点。
令 last partially contained child 为 null。
如果 original end node 不是 original start node 的包含祖先，则将 last partially contained child 设置为 common ancestor 的最后一个部分包含在 range 中的子节点。
这些变量赋值实际上总是合理的。例如，如果 original start node 不是 original end node 的包含祖先，则 original start node 本身部分包含在 range 中，其所有祖先直到 common ancestor 的一个子节点也是如此。common ancestor 不能是 original start node，因为它必须是 original end node 的包含祖先。另一种情况类似。另外，请注意，如果两个子节点都已定义，则它们永远不会相等。
令 contained children 为一个列表，其中包含 common ancestor 的所有包含在 range 中的子节点，按树顺序排列。
如果 contained children 中的任何成员是文档类型节点，则抛出一个“HierarchyRequestError”DOMException。

我们不必担心第一个或最后一个部分包含的节点，因为文档类型节点永远不能部分包含。它不能是范围的边界点，也不能是任何东西的祖先。
如果 first partially contained child 是一个 CharacterData 节点：

在这种情况下，first partially contained child 是 original start node。
1. 令 clone 为 original start node 的一个克隆。
2. 将 clone 的数据设置为使用节点 original start node、偏移量 original start offset 以及计数 original start node 的长度 − original start offset 获取子字符串数据的结果。
3. 将 clone 追加到 fragment。
否则，如果 first partially contained child 不为 null：
1. 令 clone 为 first partially contained child 的一个克隆。
2. 将 clone 追加到 fragment。
3. 令 subrange 为一个新的活动范围，其起始点为 (original start node, original start offset)，其结束点为 (first partially contained child, first partially contained child的长度)。
4. 令 subfragment 为克隆内容 subrange 的结果。
5. 将 subfragment 追加到 clone。
对于 contained children 中的每个 contained child：
1. 令 clone 为 contained child 的一个克隆，并设置克隆子节点标志。
2. 将 clone 追加到 fragment。
如果 last partially contained child 是一个 CharacterData 节点：

在这种情况下，last partially contained child 是 original end node。
1. 令 clone 为 original end node 的一个克隆。
2. 将 clone 的数据设置为使用节点 original end node、偏移量 0 以及计数 original end offset 获取子字符串数据的结果。
3. 将 clone 追加到 fragment。
否则，如果 last partially contained child 不为 null：
1. 令 clone 为 last partially contained child 的一个克隆。
2. 将 clone 追加到 fragment。
3. 令 subrange 为一个新的活动范围，其起始点为 (last partially contained child, 0)，其结束点为 (original end node, original end offset)。
4. 令 subfragment 为克隆内容 subrange 的结果。
5. 将 subfragment 追加到 clone。
返回 fragment。

cloneContents() 方法的步骤是返回克隆内容此对象的结果。

要将一个节点 node 插入到一个活动范围 range 中，请执行以下步骤：

如果 range 的起始节点是一个 ProcessingInstruction 或 Comment 节点，是一个父节点为 null 的 Text 节点，或者是 node，则抛出一个“HierarchyRequestError”DOMException。
令 referenceNode 为 null。
如果 range 的起始节点是一个 Text 节点，则将 referenceNode 设置为该 Text 节点。
否则，将 referenceNode 设置为起始节点的索引为起始偏移量的子节点，如果不存在这样的子节点，则为 null。
令 parent 为：如果 referenceNode 为 null，则为 range 的起始节点；否则为 referenceNode 的父节点。
在 referenceNode 之前，确保将 node 插入到 parent 中的预插入有效性。
如果 range 的起始节点是一个 Text 节点，则将 referenceNode 设置为使用偏移量 range 的起始偏移量分割它的结果。
如果 node 是 referenceNode，则将 referenceNode 设置为其下一个兄弟节点。
如果 node 的父节点非空，则移除 node。
令 newOffset 为：如果 referenceNode 为 null，则为 parent 的长度；否则为 referenceNode 的索引。
如果 node 是一个 DocumentFragment 节点，则将 newOffset 增加 node 的长度；否则增加 1。
在 referenceNode 之前，将 node 预插入到 parent 中。
如果 range 是折叠的，则将 range 的结束点设置为 (parent, newOffset)。

insertNode(node) 方法的步骤是将 node 插入到此对象中。

surroundContents(newParent) 方法的步骤是：

如果一个非 Text 节点部分包含在此对象中，则抛出一个“InvalidStateError”DOMException。
如果 newParent 是一个 Document、DocumentType 或 DocumentFragment 节点，则抛出一个“InvalidNodeTypeError”DOMException。

由于历史原因，此处不检查 CharacterData 节点，并且最终会作为副作用稍后抛出异常。
令 fragment 为提取此对象的结果。
如果 newParent 有子节点，则在 newParent 中用 null 替换所有。
将 newParent 插入到此对象中。
将 fragment 追加到 newParent。
在此对象内选择 newParent。

cloneRange() 方法的步骤是返回一个新的活动范围，其起始点和结束点与此对象相同。

detach() 方法的步骤是什么也不做。其功能（禁用 Range 对象）已被移除，但该方法本身为了兼容性而保留。

position = range . comparePoint(node, offset): 如果点在范围之前，则返回 −1；如果点在范围内，则返回 0；如果点在范围之后，则返回 1。
intersects = range . intersectsNode(node): 返回 range 是否与 node 相交。

isPointInRange(node, offset) 方法的步骤是：

如果 node 的根与此对象的根不同，则返回 false。
如果 node 是一个文档类型节点，则抛出一个“InvalidNodeTypeError”DOMException。
如果 offset 大于 node 的长度，则抛出一个“IndexSizeError”DOMException。
如果 (node, offset) 在起始点之前或在结束点之后，则返回 false。
返回 true。

comparePoint(node, offset) 方法的步骤是：

如果 node 的根与此对象的根不同，则抛出一个“WrongDocumentError”DOMException。
如果 node 是一个文档类型节点，则抛出一个“InvalidNodeTypeError”DOMException。
如果 offset 大于 node 的长度，则抛出一个“IndexSizeError”DOMException。
如果 (node, offset) 在起始点之前，则返回 −1。
如果 (node, offset) 在结束点之后，则返回 1。
返回 0。

intersectsNode(node) 方法的步骤是：

如果 node 的根与此对象的根不同，则返回 false。
令 parent 为 node 的父节点。
如果 parent 为 null，则返回 true。
令 offset 为 node 的索引。
如果 (parent, offset) 在结束点之前，并且 (parent, offset 加 1) 在起始点之后，则返回 true。
返回 false。

字符串化行为必须执行以下步骤：

令 s 为空字符串。
如果此对象的起始节点与此对象的结束节点相同且它是一个 Text 节点，则返回该 Text 节点的数据中从此对象的起始偏移量开始到此对象的结束偏移量结束的子字符串。
如果此对象的起始节点是一个 Text 节点，则将该节点的数据中从此对象的起始偏移量到末尾的子字符串追加到 s。
将所有包含在此对象中的 Text 节点的数据按树顺序连接起来，并追加到 s。
如果此对象的结束节点是一个 Text 节点，则将该节点的数据中从其开始到此对象的结束偏移量的子字符串追加到 s。
返回 s。

createContextualFragment()、getClientRects() 和 getBoundingClientRect() 方法在其他规范中定义。[DOM-Parsing] [CSSOM-VIEW]

6. 遍历

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

每个 NodeIterator 和 TreeWalker 对象都有一个关联的活动标志，以避免递归调用。它最初是未设置的。

每个 NodeIterator 和 TreeWalker 对象还具有关联的根（一个节点）、一个 whatToShow（一个位掩码）和一个过滤器（一个回调）。

要在一个 NodeIterator 或 TreeWalker 对象 traverser 中过滤一个节点 node，请运行以下步骤：

如果 traverser 的活动标志已设置，则抛出一个 "InvalidStateError" DOMException。
令 n 为 node 的 nodeType 属性值 − 1。
如果 traverser 的 whatToShow 的第 n^th 位（其中 0 是最低有效位）未设置，则返回 FILTER_SKIP。
如果 traverser 的过滤器为 null，则返回 FILTER_ACCEPT。
设置 traverser 的活动标志。
令 result 为使用 traverser 的过滤器、"acceptNode" 和 « node » 调用用户对象操作的返回值。如果这引发异常，则取消设置 traverser 的活动标志并重新抛出该异常。
取消设置 traverser 的活动标志。
返回 result。

6.1. 接口 `NodeIterator`

[Exposed=Window]
interface NodeIterator {
  [SameObject] 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();

  undefined detach();
};

NodeIterator 对象可以使用 Document 对象上的 createNodeIterator() 方法创建。

每个 NodeIterator 对象都有一个关联的迭代器集合，它是一个以 NodeIterator 对象的根为根的集合，其过滤器匹配任何节点。

每个 NodeIterator 对象还具有一个关联的引用（一个节点）和一个引用前指针（一个布尔值）。

如前所述，NodeIterator 对象还具有关联的活动标志、根、whatToShow 和过滤器。

NodeIterator 预移除步骤，给定一个 nodeIterator 和 toBeRemovedNode，如下所示：

如果 toBeRemovedNode 不是 nodeIterator 的引用的包含性祖先，或者 toBeRemovedNode 是 nodeIterator 的根，则返回。
如果 nodeIterator 的引用前指针为 true：
1. 令 next 为 toBeRemovedNode 的第一个后续节点，该节点是 nodeIterator 的根的包含性后代，并且不是 toBeRemovedNode 的包含性后代，如果没有这样的节点，则为 null。
2. 如果 next 非 null，则将 nodeIterator 的引用设置为 next 并返回。
3. 否则，将 nodeIterator 的引用前指针设置为 false。
  
  步骤在此处未终止。
将 nodeIterator 的引用设置为 toBeRemovedNode 的父节点（如果 toBeRemovedNode 的前一个兄弟节点为 null），否则设置为 toBeRemovedNode 的前一个兄弟节点的包含性后代中最后出现在树顺序中的那个节点。

root getter 的步骤是返回此对象的根。

referenceNode getter 的步骤是返回此对象的引用。

pointerBeforeReferenceNode getter 的步骤是返回此对象的引用前指针。

whatToShow getter 的步骤是返回此对象的 whatToShow。

filter getter 的步骤是返回此对象的过滤器。

要遍历，给定一个 NodeIterator 对象 iterator 和一个方向 direction，请运行以下步骤：

令 node 为 iterator 的引用。
令 beforeNode 为 iterator 的引用前指针。
当 true 时：
1. 根据 direction 分支：
  
  next
  
  如果 beforeNode 为 false，则将 node 设置为 iterator 的迭代器集合中跟随 node 的第一个节点。如果没有这样的节点，则返回 null。
  
  如果 beforeNode 为 true，则将其设置为 false。
  
  previous
  
  如果 beforeNode 为 true，则将 node 设置为 iterator 的迭代器集合中先于 node 的第一个节点。如果没有这样的节点，则返回 null。
  
  如果 beforeNode 为 false，则将其设置为 true。
2. 令 result 为在 iterator 中过滤 node 的结果。
3. 如果 result 是 FILTER_ACCEPT，则中断。
将 iterator 的引用设置为 node。
将 iterator 的引用前指针设置为 beforeNode。
返回 node。

nextNode() 方法的步骤是返回使用此对象和 next 遍历的结果。

previousNode() 方法的步骤是返回使用此对象和 previous 遍历的结果。

detach() 方法的步骤是什么也不做。其功能（禁用 NodeIterator 对象）已被移除，但该方法本身为了兼容性而被保留。

6.2. 接口 `TreeWalker`

[Exposed=Window]
interface TreeWalker {
  [SameObject] 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 对象可以使用 Document 对象上的 createTreeWalker() 方法创建。

每个 TreeWalker 对象都有一个关联的当前节点（一个节点）。

如前所述，TreeWalker 对象还具有关联的根、whatToShow 和过滤器。

root getter 的步骤是返回此对象的根。

whatToShow getter 的步骤是返回此对象的 whatToShow。

filter getter 的步骤是返回此对象的过滤器。

currentNode getter 的步骤是返回此对象的当前节点。

currentNode setter 的步骤是将此对象的当前节点设置为给定值。

parentNode() 方法的步骤是：

令 node 为此对象的当前节点。
当 node 非 null 且不是此对象的根时：
1. 将 node 设置为 node 的父节点。
2. 如果 node 非 null 且在此对象中过滤 node 返回 FILTER_ACCEPT，则将此对象的当前节点设置为 node 并返回 node。
返回 null。

要遍历子节点，给定一个 walker 和 type，请运行以下步骤：

令 node 为 walker 的当前节点。
如果 type 是 first，则将 node 设置为 node 的第一个子节点；如果 type 是 last，则设置为 node 的最后一个子节点。
当 node 非 null 时：
1. 令 result 为在 walker 中过滤 node 的结果。
2. 如果 result 是 FILTER_ACCEPT，则将 walker 的当前节点设置为 node 并返回 node。
3. 如果 result 是 FILTER_SKIP：
  1. 如果 type 是 first，则令 child 为 node 的第一个子节点；如果 type 是 last，则为 node 的最后一个子节点。
  2. 如果 child 非 null，则将 node 设置为 child 并继续。
4. 当 node 非 null 时：
  1. 如果 type 是 first，则令 sibling 为 node 的下一个兄弟节点；如果 type 是 last，则为 node 的前一个兄弟节点。
  2. 如果 sibling 非 null，则将 node 设置为 sibling 并中断。
  3. 令 parent 为 node 的父节点。
  4. 如果 parent 为 null、walker 的根或 walker 的当前节点，则返回 null。
  5. 将 node 设置为 parent。
返回 null。

firstChild() 方法的步骤是使用此对象和 first 遍历子节点。

lastChild() 方法的步骤是使用此对象和 last 遍历子节点。

要遍历兄弟节点，给定一个 walker 和 type，请运行以下步骤：

令 node 为 walker 的当前节点。
如果 node 是根，则返回 null。
当 true 时：
1. 如果 type 是 next，则令 sibling 为 node 的下一个兄弟节点；如果 type 是 previous，则为 node 的前一个兄弟节点。
2. 当 sibling 非 null 时：
  1. 将 node 设置为 sibling。
  2. 令 result 为在 walker 中过滤 node 的结果。
  3. 如果 result 是 FILTER_ACCEPT，则将 walker 的当前节点设置为 node 并返回 node。
  4. 如果 type 是 next，则将 sibling 设置为 node 的第一个子节点；如果 type 是 previous，则为 node 的最后一个子节点。
  5. 如果 result 是 FILTER_REJECT 或 sibling 为 null，则如果 type 是 next，将 sibling 设置为 node 的下一个兄弟节点；如果 type 是 previous，则为 node 的前一个兄弟节点。
3. 将 node 设置为 node 的父节点。
4. 如果 node 为 null 或 walker 的根，则返回 null。
5. 如果在 walker 中过滤 node 的返回值是 FILTER_ACCEPT，则返回 null。

nextSibling() 方法的步骤是使用此对象和 next 遍历兄弟节点。

previousSibling() 方法的步骤是使用此对象和 previous 遍历兄弟节点。

previousNode() 方法的步骤是：

令 node 为此对象的当前节点。
当 node 不是此对象的根时：
1. 令 sibling 为 node 的前一个兄弟节点。
2. 当 sibling 非 null 时：
  1. 将 node 设置为 sibling。
  2. 令 result 为在此对象中过滤 node 的结果。
  3. 当 result 不是 FILTER_REJECT 且 node 有一个子节点时：
    1. 将 node 设置为 node 的最后一个子节点。
    2. 将 result 设置为在此对象中过滤 node 的结果。
  4. 如果 result 是 FILTER_ACCEPT，则将此对象的当前节点设置为 node 并返回 node。
  5. 将 sibling 设置为 node 的前一个兄弟节点。
3. 如果 node 是此对象的根或 node 的父节点为 null，则返回 null。
4. 将 node 设置为 node 的父节点。
5. 如果在此对象中过滤 node 的返回值是 FILTER_ACCEPT，则将此对象的当前节点设置为 node 并返回 node。
返回 null。

nextNode() 方法的步骤是：

令 node 为此对象的当前节点。
令 result 为 FILTER_ACCEPT。
当 true 时：
1. 当 result 不是 FILTER_REJECT 且 node 有一个子节点时：
  1. 将 node 设置为其第一个子节点。
  2. 将 result 设置为在此对象中过滤 node 的结果。
  3. 如果 result 是 FILTER_ACCEPT，则将此对象的当前节点设置为 node 并返回 node。
2. 令 sibling 为 null。
3. 令 temporary 为 node。
4. 当 temporary 非 null 时：
  1. 如果 temporary 是此对象的根，则返回 null。
  2. 将 sibling 设置为 temporary 的下一个兄弟节点。
  3. 如果 sibling 非 null，则将 node 设置为 sibling 并中断。
  4. 将 temporary 设置为 temporary 的父节点。
5. 将 result 设置为在此对象中过滤 node 的结果。
6. 如果 result 是 FILTER_ACCEPT，则将此对象的当前节点设置为 node 并返回 node。

6.3. 接口 `NodeFilter`

[Exposed=Window]
callback interface NodeFilter {
  // Constants for acceptNode()
  const unsigned short FILTER_ACCEPT = 1;
  const unsigned short FILTER_REJECT = 2;
  const unsigned short FILTER_SKIP = 3;

  // Constants for 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; // legacy
  const unsigned long SHOW_ENTITY = 0x20; // legacy
  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; // legacy

  unsigned short acceptNode(Node node);
};

NodeFilter 对象可以用作 NodeIterator 和 TreeWalker 对象的过滤器，并且还为其 whatToShow 位掩码提供常量。一个 NodeFilter 对象通常实现为一个 JavaScript 函数。

这些常量可用作过滤器的返回值：

FILTER_ACCEPT (1);
FILTER_REJECT (2);
FILTER_SKIP (3)。

这些常量可用于 whatToShow：

SHOW_ALL (4294967295，十六进制为 FFFFFFFF);
SHOW_ELEMENT (1);
SHOW_ATTRIBUTE (2);
SHOW_TEXT (4);
SHOW_CDATA_SECTION (8);
SHOW_PROCESSING_INSTRUCTION (64，十六进制为 40);
SHOW_COMMENT (128，十六进制为 80);
SHOW_DOCUMENT (256，十六进制为 100);
SHOW_DOCUMENT_TYPE (512，十六进制为 200);
SHOW_DOCUMENT_FRAGMENT (1024，十六进制为 400)。

7. 集合

是的，DOMTokenList 这个名称确实是遗留问题的不幸产物。

7.1. 接口 `DOMTokenList`

[Exposed=Window]
interface DOMTokenList {
  readonly attribute unsigned long length;
  getter DOMString? item(unsigned long index);
  boolean contains(DOMString token);
  [CEReactions] undefined add(DOMString... tokens);
  [CEReactions] undefined remove(DOMString... tokens);
  [CEReactions] boolean toggle(DOMString token, optional boolean force);
  [CEReactions] boolean replace(DOMString token, DOMString newToken);
  boolean supports(DOMString token);
  [CEReactions] stringifier attribute DOMString value;
  iterable<DOMString>;
};

一个 DOMTokenList 对象有一个关联的令牌集（一个有序集合），初始为空。

一个 DOMTokenList 对象还有一个关联的元素和一个属性的本地名称。

规范可以为一个 DOMTokenList 关联的属性的本地名称定义支持的令牌。

一个 DOMTokenList 对象的验证步骤（对于给定的 token）如下：

如果关联的属性的本地名称没有定义支持的令牌，则抛出一个 TypeError。
令 lowercase token 为 token 的一个副本，转换为ASCII 小写。
如果 lowercase token 存在于支持的令牌中，返回 true。
返回 false。

一个 DOMTokenList 对象的更新步骤如下：

如果关联的元素没有关联的属性且令牌集为空，则返回。
使用关联的属性的本地名称和运行令牌集的有序集合序列化器的结果，为关联的元素设置属性值。

一个 DOMTokenList 对象的序列化步骤是返回给定关联的元素和关联的属性的本地名称运行获取属性值的结果。

一个 DOMTokenList 对象对其关联的元素具有这些属性更改步骤：

如果 localName 是关联属性的本地名称，namespace 为 null，且 value 为 null，则清空令牌集。
否则，如果 localName 是关联属性的本地名称，namespace 为 null，则将令牌集设置为 value（已解析）。

当一个 DOMTokenList 对象被创建时，则：

令 element 为关联的元素。
令 localName 为关联属性的本地名称。
令 value 为给定 element 和 localName 获取属性值的结果。
为 element、localName、value、value 和 null 运行属性更改步骤。

tokenlist . length

返回令牌的数量。

tokenlist . item(index)

tokenlist[index]

返回索引为 index 的令牌。

tokenlist . contains(token)

如果存在 token，则返回 true；否则返回 false。

tokenlist . add(tokens…)

添加所有传递的参数，已存在的除外。

如果其中一个参数是空字符串，则抛出 "SyntaxError" DOMException。

如果其中一个参数包含任何ASCII 空白字符，则抛出 "InvalidCharacterError" DOMException。

tokenlist . remove(tokens…)

移除传递的参数（如果存在）。

如果其中一个参数是空字符串，则抛出 "SyntaxError" DOMException。

如果其中一个参数包含任何ASCII 空白字符，则抛出 "InvalidCharacterError" DOMException。

tokenlist . toggle(token [, force])

如果未给出 force，则“切换”token，如果存在则移除它，如果不存在则添加它。如果 force 为 true，则添加 token（与 add() 相同）。如果 force 为 false，则移除 token（与 remove() 相同）。

如果 token 现在存在，则返回 true；否则返回 false。

如果 token 为空，则抛出 "SyntaxError" DOMException。

如果 token 包含任何空格，则抛出 "InvalidCharacterError" DOMException。

tokenlist . replace(token, newToken)

用 newToken 替换 token。

如果 token 被 newToken 替换，则返回 true；否则返回 false。

如果其中一个参数是空字符串，则抛出 "SyntaxError" DOMException。

如果其中一个参数包含任何ASCII 空白字符，则抛出 "InvalidCharacterError" DOMException。

tokenlist . supports(token)

如果 token 在关联属性的支持的令牌中，则返回 true。否则返回 false。

如果关联属性没有定义支持的令牌，则抛出 TypeError。

tokenlist . value

返回关联的集合作为字符串。

可以设置，以更改关联的属性。

length 属性的 getter 必须返回此对象的令牌集的大小。

对象的支持的属性索引是范围从零到对象的令牌集的大小减一的数字，除非令牌集为空，在这种情况下，没有支持的属性索引。

item(index) 方法的步骤是：

如果 index 等于或大于此对象的令牌集的大小，则返回 null。
返回此对象的令牌集[index]。

contains(token) 方法的步骤是：如果此对象的令牌集[token] 存在，则返回 true；否则返回 false。

add(tokens…) 方法的步骤是：

对于 tokens 中的每个 token：
1. 如果 token 是空字符串，则抛出一个 "SyntaxError" DOMException。
2. 如果 token 包含任何ASCII 空白字符，则抛出一个 "InvalidCharacterError" DOMException。
对于 tokens 中的每个 token，将 token 追加到此对象的令牌集。
运行更新步骤。

remove(tokens…) 方法的步骤是：

对于 tokens 中的每个 token：
1. 如果 token 是空字符串，则抛出一个 "SyntaxError" DOMException。
2. 如果 token 包含任何ASCII 空白字符，则抛出一个 "InvalidCharacterError" DOMException。
对于 tokens 中的每个 token，从此对象的令牌集中移除 token。
运行更新步骤。

toggle(token, force) 方法的步骤是：

如果 token 是空字符串，则抛出一个 "SyntaxError" DOMException。
如果 token 包含任何ASCII 空白字符，则抛出一个 "InvalidCharacterError" DOMException。
如果此对象的令牌集[token] 存在：
1. 如果未给出 force 或者 force 为 false，则从此对象的令牌集中移除 token，运行更新步骤并返回 false。
2. 返回 true。
否则，如果未给出 force 或者 force 为 true，则将 token 追加到此对象的令牌集，运行更新步骤，并返回 true。
返回 false。

为了 Web 兼容性，toggle() 的更新步骤并非总是运行。

replace(token, newToken) 方法的步骤是：

如果 token 或 newToken 是空字符串，则抛出一个 "SyntaxError" DOMException。
如果 token 或 newToken 包含任何ASCII 空白字符，则抛出一个 "InvalidCharacterError" DOMException。
如果此对象的令牌集不包含 token，则返回 false。
在此对象的令牌集中用 newToken 替换 token。
运行更新步骤。
返回 true。

为了 Web 兼容性，replace() 的更新步骤并非总是运行。

supports(token) 方法的步骤是：

令 result 为使用 token 调用验证步骤的返回值。
返回 result。

value 属性必须返回运行此对象的序列化步骤的结果。

设置 value 属性必须使用关联的属性的本地名称和给定值，为关联的元素设置属性值。

8. XPath

DOM Level 3 XPath 定义了一个用于评估XPath 1.0表达式的 API。这些 API 被广泛实现，但未得到维护。接口定义在此保留，以便在 Web IDL 发生变化时可以更新。完整的这些 API 的定义仍然是必要的，此类工作已被跟踪并可以在 whatwg/dom#67 中贡献。 [DOM-Level-3-XPath] [XPath] [WEBIDL]

8.1. 接口 `XPathResult`

[Exposed=Window]
interface XPathResult {
  const unsigned short ANY_TYPE = 0;
  const unsigned short NUMBER_TYPE = 1;
  const unsigned short STRING_TYPE = 2;
  const unsigned short BOOLEAN_TYPE = 3;
  const unsigned short UNORDERED_NODE_ITERATOR_TYPE = 4;
  const unsigned short ORDERED_NODE_ITERATOR_TYPE = 5;
  const unsigned short UNORDERED_NODE_SNAPSHOT_TYPE = 6;
  const unsigned short ORDERED_NODE_SNAPSHOT_TYPE = 7;
  const unsigned short ANY_UNORDERED_NODE_TYPE = 8;
  const unsigned short FIRST_ORDERED_NODE_TYPE = 9;

  readonly attribute unsigned short resultType;
  readonly attribute unrestricted double numberValue;
  readonly attribute DOMString stringValue;
  readonly attribute boolean booleanValue;
  readonly attribute Node? singleNodeValue;
  readonly attribute boolean invalidIteratorState;
  readonly attribute unsigned long snapshotLength;

  Node? iterateNext();
  Node? snapshotItem(unsigned long index);
};

8.2. 接口 `XPathExpression`

[Exposed=Window]
interface XPathExpression {
  // XPathResult.ANY_TYPE = 0
  XPathResult evaluate(Node contextNode, optional unsigned short type = 0, optional XPathResult? result = null);
};

8.3. 混入 `XPathEvaluatorBase`

callback interface XPathNSResolver {
  DOMString? lookupNamespaceURI(DOMString? prefix);
};

interface mixin XPathEvaluatorBase {
  [NewObject] XPathExpression createExpression(DOMString expression, optional XPathNSResolver? resolver = null);
  Node createNSResolver(Node nodeResolver); // legacy
  // XPathResult.ANY_TYPE = 0
  XPathResult evaluate(DOMString expression, Node contextNode, optional XPathNSResolver? resolver = null, optional unsigned short type = 0, optional XPathResult? result = null);
};
Document includes XPathEvaluatorBase;

The createNSResolver(nodeResolver) 方法步骤是返回 nodeResolver。

此方法仅因历史原因存在。

8.4. 接口 `XPathEvaluator`

[Exposed=Window]
interface XPathEvaluator {
  constructor();
};

XPathEvaluator includes XPathEvaluatorBase;

由于历史原因，您既可以构造 XPathEvaluator 也可以在 Document 上访问相同的方法。

9. XSLT

XSL Transformations (XSLT) 是一种将 XML 文档转换为其他 XML 文档的语言。本节定义的 API 已被广泛实现，并在此保留，以便在 Web IDL 发生变化时可以更新。这些 API 的完整定义仍然是必要的，此类工作已被跟踪并可以在 whatwg/dom#181 中贡献。 [XSLT]

9.1. 接口 `XSLTProcessor`

[Exposed=Window]
interface XSLTProcessor {
  constructor();
  undefined importStylesheet(Node style);
  [CEReactions] DocumentFragment transformToFragment(Node source, Document output);
  [CEReactions] Document transformToDocument(Node source);
  undefined setParameter([LegacyNullToEmptyString] DOMString namespaceURI, DOMString localName, any value);
  any getParameter([LegacyNullToEmptyString] DOMString namespaceURI, DOMString localName);
  undefined removeParameter([LegacyNullToEmptyString] DOMString namespaceURI, DOMString localName);
  undefined clearParameters();
  undefined reset();
};

10. 安全和隐私考虑

此标准没有已知的安全或隐私考虑。

11. 历史

此标准曾包含多个已被移除的接口和接口成员。

这些接口已被移除：

DOMConfiguration
DOMError
DOMErrorHandler
DOMImplementationList
DOMImplementationSource
DOMLocator
DOMObject
DOMUserData
Entity
EntityReference
MutationEvent
MutationNameEvent
NameList
Notation
RangeException
TypeInfo
UserDataHandler

这些接口成员已被移除：

Attr

schemaTypeInfo
isId

Document

createEntityReference()
xmlEncoding
xmlStandalone
xmlVersion
strictErrorChecking
domConfig
normalizeDocument()
renameNode()

DocumentType

entities
notations
internalSubset

DOMImplementation

getFeature()

Element

schemaTypeInfo
setIdAttribute()
setIdAttributeNS()
setIdAttributeNode()

Node

isSupported
getFeature()
getUserData()
setUserData()

NodeIterator

expandEntityReferences

Text

isElementContentWhitespace
replaceWholeText()

TreeWalker

expandEntityReferences

致谢

多年来，许多人为使 DOM 更具互操作性作出了贡献，从而促进了该标准的目标。同样，许多人也为使该标准发展至今做出了帮助。

因此，特别感谢以下人士： Adam Klein, Adrian Bateman, Ahmid snuggs, Alex Komoroske, Alex Russell, Alexey Shvayka, Andreas Kling, Andreu Botella, Anthony Ramine, Arkadiusz Michalski, Arnaud Le Hors, Arun Ranganathan, Benjamin Gruenbaum, Björn Höhrmann, Boris Zbarsky, Brandon Payton, Brandon Slade, Brandon Wallace, Brian Kardell, C. Scott Ananian, Cameron McCormack, Chris Dumez, Chris Paris, Chris Rebert, Cyrille Tuzi, Dan Burzo, Daniel Clark, Daniel Glazman, Darien Maillet Valentine, Darin Fisher, David Baron, David Bruant, David Flanagan, David Håsäther, David Hyatt, Deepak Sherveghar, Dethe Elza, Dimitri Glazkov, Domenic Denicola, Dominic Cooney, Dominique Hazaël-Massieux, Don Jordan, Doug Schepers, Edgar Chen, Elisée Maurer, Elliott Sprehn, Emilio Cobos Álvarez, Eric Bidelman, Erik Arvidsson, François Daoust, François Remy, Gary Kacmarcik, Gavin Nicol, Giorgio Liscio, Glen Huang, Glenn Adams, Glenn Maynard, Hajime Morrita, Harald Alvestrand, Hayato Ito, Henri Sivonen, Hongchan Choi, Hunan Rostomyan, Ian Hickson, Igor Bukanov, Jacob Rossi, Jake Archibald, Jake Verbaten, James Graham, James Greene, James M Snell, James Robinson, Jeffrey Yasskin, Jens Lindström, Jeremy Davis, Jesse McCarthy, Jinho Bang, João Eiras, Joe Kesselman, John Atkins, John Dai, Jonas Sicking, Jonathan Kingston, Jonathan Robie, Joris van der Wel, Joshua Bell, J. S. Choi, Jungkee Song, Justin Summerlin, Kagami Sascha Rosylight, 呂康豪 (Kang-Hao Lu), 田村健人 (Kent TAMURA), Kevin J. Sung, Kevin Sweeney, Kirill Topolyan, Koji Ishii, Lachlan Hunt, Lauren Wood, Luca Casonato, Luke Zielinski, Magne Andersson, Majid Valipour, Malte Ubl, Manish Goregaokar, Manish Tripathi, Marcos Caceres, Mark Miller, Martijn van der Ven, Mason Freed, Mats Palmgren, Mounir Lamouri, Michael Stramel, Michael™ Smith, Mike Champion, Mike Taylor, Mike West, Nicolás Peña Moreno, Nidhi Jaju, Ojan Vafai, Oliver Nightingale, Olli Pettay, Ondřej Žára, Peter Sharpe, Philip Jägenstedt, Philippe Le Hégaret, Piers Wombwell, Pierre-Marie Dartus, prosody—Gab Vereable Context(, Rafael Weinstein, Rakina Zata Amni, Richard Bradshaw, Rick Byers, Rick Waldron, Robbert Broersma, Robin Berjon, Roland Steiner, Rune F. Halvorsen, Russell Bicknell, Ruud Steltenpool, Ryosuke Niwa, Sam Dutton, Sam Sneddon, Samuel Giles, Sanket Joshi, Scott Haseley, Sebastian Mayr, Seo Sanghyeon, Sergey G. Grekhov, Shiki Okasaka, Shinya Kawanaka, Simon Pieters, Simon Wülker, Stef Busking, Steve Byrne, Stig Halvorsen, Tab Atkins, Takashi Sakamoto, Takayoshi Kochi, Theresa O’Connor, Theodore Dubois, timeless, Timo Tijhof, Tobie Langel, Tom Pixley, Travis Leithead, Trevor Rowbotham, triple-underscore, Tristan Fraipont, Veli Şenol, Vidur Apparao, Warren He, Xidorn Quan, Yash Handa, Yehuda Katz, Yoav Weiss, Yoichi Osato, Yoshinori Sano, Yu Han, Yusuke Abe, 和 Zack Weinberg，感谢你们的出色贡献！

本标准由Anne van Kesteren (Apple, annevk@annevk.nl)编写，并得到了Aryeh Gregor (ayg@aryeh.name)和Ms2ger (ms2ger@gmail.com)的实质性贡献。

知识产权

与自定义元素相关的集成点的部分修订历史可以在 w3c/webcomponents 代码库中找到，该代码库根据 W3C 软件和文档许可证提供。

这是动态标准。那些对专利审查版本感兴趣的人应该查看动态标准审查草案。

DOM

摘要

1. 基础设施

1.1. 树

1.2. 有序集合

1.3. 选择器

1.4. 命名空间

2. 事件

2.1. “DOM 事件”简介

2.2. 接口 Event

2.3. 对 Window 接口的传统扩展

2.4. 接口 CustomEvent

2.5. 构造事件

2.6. 定义事件接口

2.7. 接口 EventTarget

2.8. 观察事件监听器

2.9. 分发事件

2.10. 触发事件

2.11. 行为与发生

3. 中止正在进行的活动

3.1. 接口 AbortController

3.2. 接口AbortSignal

3.2.1. 垃圾回收

3.3. 在 API 中使用 AbortController 和 AbortSignal 对象

4. 节点

4.1. “DOM”简介

4.2. 节点树

4.2.1. 文档树

4.2.2. 影子树

4.2.2.1. 插槽

4.2.2.2. 可插槽对象

4.2.2.3. 查找插槽和可插槽对象

4.2.2.4. 分配可插槽对象和插槽

4.2.2.5. 发出插槽变更信号

4.2.3. 变异算法

4.2.4. 混入 NonElementParentNode

4.2.5. Mixin DocumentOrShadowRoot

4.2.6. Mixin ParentNode

4.2.7. 混入 NonDocumentTypeChildNode

4.2.8. 混入 ChildNode

4.2.9. 混入 Slottable

4.2.10. 旧式集合：NodeList 和 HTMLCollection

4.2.10.1. 接口 NodeList

4.2.10.2. 接口HTMLCollection

4.3. Mutation observers

4.3.1. 接口 MutationObserver

4.3.2. 排队突变记录

4.3.3. 接口 MutationRecord

4.4. 接口 Node

4.5. 接口 Document

4.5.1.接口 DOMImplementation

4.6. 接口DocumentType

4.7. 接口DocumentFragment

4.8. 接口 ShadowRoot

4.9. 接口 Element

4.9.1. 接口 NamedNodeMap

4.9.2. 接口 Attr

4.10. 接口 CharacterData

4.11. 接口 Text

4.12. 接口 CDATASection

4.13. 接口 ProcessingInstruction

4.14. 接口 注释

5. Ranges

5.1. Introduction to "DOM Ranges"

5.2. Boundary points

5.3. 接口 AbstractRange

5.4. 接口 StaticRange

5.5. 接口 Range

6. 遍历

6.1. 接口 NodeIterator

6.2. 接口 TreeWalker

6.3. 接口 NodeFilter

7. 集合

7.1. 接口 DOMTokenList

8. XPath

8.1. 接口 XPathResult

8.2. 接口 XPathExpression

8.3. 混入 XPathEvaluatorBase

8.4. 接口 XPathEvaluator

9. XSLT

2.2. 接口 `Event`

2.3. 对 `Window` 接口的传统扩展

2.4. 接口 `CustomEvent`

2.7. 接口 `EventTarget`

3.1. 接口 `AbortController`

3.2. 接口`AbortSignal`

3.3. 在 API 中使用 `AbortController` 和 `AbortSignal` 对象

4.2.4. 混入 `NonElementParentNode`

4.2.5. Mixin `DocumentOrShadowRoot`

4.2.6. Mixin `ParentNode`

4.2.7. 混入 `NonDocumentTypeChildNode`

4.2.8. 混入 `ChildNode`

4.2.9. 混入 `Slottable`

4.2.10. 旧式集合：`NodeList` 和 `HTMLCollection`

4.2.10.1. 接口 `NodeList`

4.2.10.2. 接口`HTMLCollection`

4.3.1. 接口 `MutationObserver`

4.3.3. 接口 `MutationRecord`

4.4. 接口 `Node`

4.5. 接口 `Document`

4.5.1.接口 `DOMImplementation`

4.6. 接口`DocumentType`

4.7. 接口`DocumentFragment`

4.8. 接口 `ShadowRoot`

4.9. 接口 `Element`

4.9.1. 接口 `NamedNodeMap`

4.9.2. 接口 `Attr`

4.10. 接口 `CharacterData`

4.11. 接口 `Text`

4.12. 接口 `CDATASection`

4.13. 接口 `ProcessingInstruction`

4.14. 接口 `注释`

5.3. 接口 `AbstractRange`

5.4. 接口 `StaticRange`

5.5. 接口 `Range`

6.1. 接口 `NodeIterator`

6.2. 接口 `TreeWalker`

6.3. 接口 `NodeFilter`

7.1. 接口 `DOMTokenList`

8.1. 接口 `XPathResult`

8.2. 接口 `XPathExpression`

8.3. 混入 `XPathEvaluatorBase`

8.4. 接口 `XPathEvaluator`

9.1. 接口 `XSLTProcessor`