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到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]的关闭树中的插槽为 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]的关闭树的根为 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的结果。
如果目标不是relatedTarget或目标是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. 否则，将目标设置为parent，然后：
    1. 如果isActivationEvent为true，activationTarget为null，且目标具有激活行为，则将activationTarget设置为目标。
    2. 附加到事件路径通过event、parent、目标、relatedTarget、touchTargets，并设置slot-in-closed-tree。
  9. 如果parent非空，则将parent设置为调用parent的获取父项结果的event。
  10. 将slot-in-closed-tree设置为false。
10. 将clearTargetsStruct设置为event的路径中的最后一个结构，其影子调整目标非空。
11. 如果clearTargetsStruct的影子调整目标、clearTargetsStruct的relatedTarget，或者clearTargetsStruct的触摸目标列表中的事件目标对象是一个节点，且其根是一个影子根，则clearTargets为true；否则为false。
12. 如果activationTarget非空且activationTarget具有旧式预激活行为，则运行activationTarget的旧式预激活行为。
13. 对于每个在event的路径中的struct，按逆序：
  1. 如果struct的影子调整目标非空，则将event的事件阶段属性设置为AT_TARGET。
  2. 否则，将event的事件阶段属性设置为CAPTURING_PHASE。
  3. 调用通过struct、event、"捕获"，以及如果给出的话legacyOutputDidListenersThrowFlag。
14. 对于每个在event的路径中的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，则：
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。
对于每个 listener 在 listeners 中，其移除状态为 false：
1. 如果 event 的 type 属性值不是 listener 的类型，则继续。
2. 将 found 设为 true。
3. 如果 phase 是 "capturing" 并且 listener 的 capture 为 false，则继续。
4. 如果 phase 是 "bubbling" 并且 listener 的 capture 为 true，则继续。
5. 如果 listener 的 once 为 true，则移除 listener 从 event 的 currentTarget 属性值的事件监听器列表。
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。
返回 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没有内置的中止机制，但许多使用Promise的API需要中止语义。AbortController旨在通过提供abort()方法来支持这些需求，该方法可切换对应AbortSignal对象的状态。希望支持中止的API可以接受一个AbortSignal对象，并使用其状态来决定如何继续。

依赖于AbortController的API建议通过拒绝任何未决的Promise来响应abort()，并使用AbortSignal的abort reason。

一个假设的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 和一个可选的 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 不是已中止的，也不是依赖的。
  2. 将 sourceSignal 追加到 resultSignal 的源信号中。
  3. 将 resultSignal 追加到 sourceSignal 的依赖信号中。
返回 resultSignal。

3.2.1. 垃圾回收

一个非中止的依赖的 AbortSignal 对象，在其源信号非空且其已注册事件监听器监听其 abort 事件或其中止算法非空时，不能被垃圾回收。

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

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

通过 AbortSignal 对象通过 signal 字典成员接受信号。
通过使用 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和一个可选的开放标志（除非另有说明，否则不设置）查找插槽，请执行以下步骤：

如果slottable的父节点为null，则返回null。
令shadow为slottable的父节点的影子根。
如果shadow为null，则返回null。
如果开放标志被设置，且shadow的模式不是“open”，则返回null。
如果shadow的插槽分配为“manual”，则返回shadow的后代中其手动分配节点包含slottable的插槽，如果有的话；否则返回null。
返回shadow的后代中第一个其名称为slottable的名称的插槽，如果有的话；否则返回null。

要为给定的插槽slot查找可插槽对象，请执行以下步骤：

令result为空列表。
令root为slot的根。
如果root不是影子根，则返回result。
令host为root的宿主。
如果root的插槽分配为“manual”，则：
1. 令result为« »。
2. 对于每个可插槽对象slottable，在slot的手动分配节点中，如果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的包含后代中的每个插槽slot分配可插槽对象。

要为给定可插槽对象slottable 分配插槽，请运行以下步骤：

令slot为查找插槽给定slottable的结果。
如果slot不为null，则为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不为null，且其父节点不是parent，则抛出一个“NotFoundError”DOMException。
如果node不是DocumentFragment、DocumentType、Element或CharacterData节点，则抛出一个“HierarchyRequestError”DOMException。
如果node是一个文本节点且parent是一个文档，或node是一个文档类型，且parent不是文档，则抛出一个“HierarchyRequestError”DOMException。
如果parent是一个文档，且根据node实现的接口，下列语句中的任何一个为真，则抛出一个“HierarchyRequestError”DOMException。

文档片段

如果node有多个元素子节点，或有一个文本节点子节点。

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

Element

parent 有一个元素子元素，child是一个文档类型，或者child非null，并且文档类型在紧随child之后。

DocumentType

parent 有一个文档类型子元素，child非null，并且一个元素在先于child之前，或者child为null，并且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。这些步骤允许一批节点相对于脚本原子地插入，所有主要的副作用都在批量插入到节点树完成后发生。这确保了所有待处理的节点树插入完全完成后才会发生更多的插入。

规范可以为所有或某些节点定义子节点变化步骤。该算法不传递参数，并在插入、移除和替换数据时调用。

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

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

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

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

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

如果父节点不是Document、DocumentFragment或Element节点，则抛出一个"HierarchyRequestError"DOMException。
如果节点是父节点的包含宿主的包容性祖先，则抛出一个"HierarchyRequestError"DOMException。
如果子节点的父节点不是父节点，则抛出一个"NotFoundError"DOMException。
如果节点不是DocumentFragment、DocumentType、Element或CharacterData节点，则抛出一个"HierarchyRequestError"DOMException。
如果节点是文档，或文档类型，则抛出一个"HierarchyRequestError"DOMException。
如果父节点是文档，并且下面的某些语句为真，则抛出一个"HierarchyRequestError"DOMException。

DocumentFragment

如果节点有多个元素子节点，或有一个文本节点子节点。

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

元素

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

文档类型

父节点有一个文档类型子节点不是子节点，或者元素在子节点之前。

上面的语句与预插入算法不同。
将referenceChild赋值为子节点的下一个兄弟节点。
如果referenceChild是节点，则将referenceChild设置为节点的下一个兄弟节点。
将previousSibling赋值为子节点的前一个兄弟节点。
将removedNodes赋值为空集。
如果子节点的父节点非空，则：
1. 将removedNodes设置为«子节点»。
2. 移除子节点并设置抑制观察者标志。
上面的情况只有在子节点是节点时为假。
如果节点是DocumentFragment节点，则将节点的子节点赋值给nodes；否则赋值«节点»。
插入节点到父节点中，位于referenceChild之前，并设置抑制观察者标志。
为父节点排队一个树变更记录，包含nodes、removedNodes、previousSibling和referenceChild。
返回子节点。

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

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

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

要从父节点中预先移除子节点，请运行以下步骤：

如果子节点的父节点不是父节点，则抛出一个"NotFoundError"DOMException。
移除子节点。
返回子节点。

规范可以为所有或某些节点定义移除步骤。该算法传递节点removedNode和节点-或-nulloldParent，如下面的移除算法所示。

要移除节点节点，并带有一个可选的抑制观察者标志，请运行以下步骤：

将父节点赋值为节点的父节点。
断言：父节点非空。
将索引赋值为节点的索引。
对于每个活动范围，如果其起始节点是节点的包容性后代，则将其起始设置为（父节点，索引）。
对于每个活动范围，如果其结束节点是节点的包容性后代，则将其结束设置为（父节点，索引）。
对于每个活动范围，如果其起始节点是父节点，并且起始偏移量大于索引，则将其起始偏移量减 1。
对于每个活动范围，如果其结束节点是父节点，并且结束偏移量大于索引，则将其结束偏移量减 1。
对于每个NodeIterator对象迭代器，其根的节点文档是节点的节点文档，运行NodeIterator预移除步骤，给定节点和迭代器。
将oldPreviousSibling设置为节点的前一个兄弟节点。
将oldNextSibling设置为节点的下一个兄弟节点。
移除节点从父节点的子节点中。
如果节点已分配，则为节点的已分配槽运行分配可插槽。
如果父节点的根是阴影根，且父节点是一个槽，其已分配节点为空列表，则为父节点发出槽变更信号。
如果节点有一个包容性后代是槽，则：
1. 运行为树分配可插槽，使用父节点的根。
2. 运行为树分配可插槽，使用节点。
使用节点和父节点运行移除步骤。
将isParentConnected设置为父节点的已连接。
如果节点是自定义元素，并且isParentConnected为真，则为节点排队一个自定义元素回调反应，回调名称为"disconnectedCallback"，参数列表为空。

目前有意不传递父节点给自定义元素。如果有需要，将来可能会改变。
对于节点的每个包括阴影的后代descendant，按包括阴影的树顺序：
1. 使用descendant和null运行移除步骤。
2. 如果descendant是自定义元素，并且isParentConnected为真，则为descendant排队一个自定义元素回调反应，回调名称为"disconnectedCallback"，参数列表为空。
对于父节点的每个包容性祖先inclusiveAncestor，然后对于inclusiveAncestor的已注册观察者列表中的每个registered，如果registered的选项["subtree"]为真，则将新的临时已注册观察者追加到节点的已注册观察者列表中。
如果抑制观察者标志未设置，则为父节点排队一个树变更记录，包含«»、«节点»、oldPreviousSibling和oldNextSibling。
运行子节点变化步骤，针对父节点。

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) 方法的步骤是返回元素中第一个，其在树顺序中位于 this 的后代中，且其 ID 为 elementId；否则，如果没有这样的元素，则返回 null。

class="heading settled" data-level="4.2.6" id="interface-parentnode">4.2.6. 混入 ParentNode

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

让node为null。
用一个新的Text节点替换nodes中的每个字符串，其数据为字符串，节点文档为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 TrustedScript or DOMString)... nodes);
  [CEReactions, Unscopable] undefined append((Node or TrustedScript or DOMString)... nodes);
  [CEReactions, Unscopable] undefined replaceChildren((Node or TrustedScript or DOMString)... nodes);

  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，同时将字符串替换为等效的 Text节点。

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

node. append(nodes)

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

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

node. replaceChildren(nodes)

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

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

node. querySelector(selectors)

返回符合 selectors 的第一个后代元素。

node. querySelectorAll(selectors)

返回符合 selectors 的所有后代元素。

children 获取器步骤是返回一个 HTMLCollection集合，该集合以此为根，只匹配元素子节点。

firstElementChild 获取器步骤是返回第一个子节点，该子节点是元素；否则返回 null。

lastElementChild 获取器步骤是返回最后一个子节点，该子节点是元素；否则返回 null。

childElementCount 获取器步骤是返回子节点的数量，此只包含元素。

prepend(nodes)方法的步骤为：

让node成为将节点转换为节点的结果，给定nodes和此的节点文档。
预插入node至此，在此的第一个子节点之前。

append(nodes)方法的步骤为：

让node成为将节点转换为节点的结果，给定nodes和此的节点文档。
追加node至此。

replaceChildren(nodes)方法的步骤为：

让node成为将节点转换为节点的结果，给定nodes和此的节点文档。
确保预插入有效性，node至此，在null之前。
替换所有节点为node在此内。

querySelector(selectors)方法的步骤是返回第一个运行范围匹配选择器字符串的结果，给定selectors，针对此，如果结果不是空列表，则返回结果；否则为null。

querySelectorAll(selectors)方法的步骤是返回运行范围匹配选择器字符串的静态结果，给定selectors，针对此。

4.2.7. 混入 `NonDocumentTypeChildNode`

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

interfacemixinNonDocumentTypeChildNode {
   readonlyattributeElement? previousElementSibling;
   readonlyattributeElement? nextElementSibling;
};
ElementincludesNonDocumentTypeChildNode;
CharacterDataincludesNonDocumentTypeChildNode;

element=node. previousElementSibling: 返回第一个前面的兄弟，该兄弟是元素；否则返回 null。
element=node. nextElementSibling: 返回第一个后面的兄弟，该兄弟是元素；否则返回 null。

previousElementSibling获取器步骤是返回第一个前面的兄弟，该兄弟是元素；否则返回 null。

nextElementSibling获取器步骤是返回第一个后面的兄弟，该兄弟是元素；否则返回 null。

4.2.8. 混入 `ChildNode`

interfacemixinChildNode {
   [CEReactions,
   Unscopable] undefinedbefore((Node or DOMString)... nodes);
   [CEReactions,
   Unscopable] undefinedafter((Node or DOMString)... nodes);
   [CEReactions,
   Unscopable] undefinedreplaceWith((Node or DOMString)... nodes);
   [CEReactions,
   Unscopable] undefinedremove();
};
DocumentTypeincludesChildNode;
ElementincludesChildNode;
CharacterDataincludesChildNode;

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的下一个兄弟节点。
预插入node至parent，在viablePreviousSibling之前。

after(nodes) 方法的步骤为：

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

replaceWith(nodes) 方法的步骤为：

让parent成为此的父节点。
如果parent为 null，则返回。
让viableNextSibling成为此的第一个不在nodes中的后面的兄弟节点；否则为 null。
让node成为将节点转换为节点的结果，给定nodes和此的节点文档。
如果此的父节点为parent，则替换此为node在parent内。

此可能已被插入node。
否则，预插入node至parent，在viableNextSibling之前。

remove() 方法的步骤为：

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

4.2.9. 混入 `Slottable`

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

assignedSlot 获取器的步骤是返回给定查找插槽的结果，前提是设置了open flag。

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是一个我们无法从网络中消除的历史遗留物。当然，开发人员可以继续使用它，但新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”作为参数，并将回调的this值设置为mo，调用mo的回调。
对于signalSet中的每个slot，触发一个名为slotchange的事件，其bubbles属性设置为true，在slot处。

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

一个注册观察者由一个观察者（一个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。在 observe() 方法注册的节点变动后，调用 callback，传入一个 MutationRecord 对象的列表作为第一个参数，并将构造的 MutationObserver 对象作为第二个参数。

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) 构造函数的步骤是将 this 的回调设置为 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 的观察者是 this：
1. 对于 this 的节点列表中的每个 node，移除所有临时注册观察者，其来源是 registered，从 node 的注册观察者列表中移除。
2. 将 registered 的选项设置为 options。
否则：
1. 追加一个新的注册观察者，其观察者是 this，并将选项设置为 options，追加到 target 的注册观察者列表。
2. 追加一个指向 target 的弱引用到 this 的节点列表中。

disconnect() 方法的步骤如下：

对于 this 的节点列表中的每个 node，移除任何注册观察者，如果 this 是该观察者。
清空 this 的记录队列。

takeRecords() 方法的步骤如下：

将 this 的记录队列克隆为 records。
清空 this 的记录队列。
返回 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 非空。
排队一个突变记录类型为 "childList"，目标为 target，值为 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 deep = 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 是一个用于所有节点的抽象接口。你不能直接获取它的实例。

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

可以通过节点的节点文档更改adopt算法。

给定一个event时，节点的get the parent 算法返回已分配插槽，如果节点被分配了；否则，返回父节点。

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

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 步骤是返回第一个匹配的语句，切换接口 this implements：

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 步骤是返回第一个匹配的语句，切换接口 this implements：

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

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

baseURI 的 getter 步骤是返回 this 的节点文档的文档基础 URL，并且序列化。

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

isConnected 的 getter 步骤是如果 this 是连接的，则返回 true；否则返回 false。

ownerDocument 的 getter 步骤是如果 this 是文档，则返回 null；否则返回 this 的节点文档。

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

getRootNode(options) 方法步骤是如果 options["composed"] 为 true，则返回 this 的包括影子的根；否则返回 this 的根。

parentNode 的 getter 步骤是返回 this 的父级。

parentElement 的 getter 步骤是返回 this 的父元素。

hasChildNodes() 方法步骤是如果 this 有子节点，则返回 true；否则返回 false。

childNodes 的 getter 步骤是返回一个 NodeList，其根位于 this 处，仅匹配子节点。

firstChild 的 getter 步骤是返回 this 的第一个子节点。

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

previousSibling 的 getter 步骤是返回 this 的上一个兄弟节点。

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

nodeValue 的 getter 步骤是返回以下内容，切换接口 this implements：

Attr: this 的值。
CharacterData: this 的数据。
否则: Null。

nodeValue 的 setter 步骤是，如果给定的值为 null，则将其视为空字符串，然后按以下描述执行，切换接口 this implements：

Attr: 设置现有属性值，使用 this 和给定的值。
CharacterData: 替换数据，使用节点 this，偏移量 0，计数 this 的长度，以及数据给定的值。
否则: 什么也不做。

要获取文本内容，使用节点 node，返回以下内容，切换接口 node implements：

DocumentFragment
Element: node 的后代文本内容。
Attr: node 的值。
CharacterData: node 的数据。
否则: Null。

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

要字符串替换全部，使用一个字符串 string 在节点 parent 内，运行以下步骤：

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

要设置文本内容，使用一个节点 node 和一个字符串 value，按下述定义操作，切换接口 node implements：

DocumentFragment
Element: 字符串替换全部，使用 value 在 node 内。
Attr: 设置现有属性值，使用 node 和 value。
CharacterData: 替换数据，使用节点 node，偏移量 0，计数 node 的长度，以及数据 value。
否则: 什么也不做。

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

node . normalize(): 移除空的独占 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([deep = false]): 返回 node 的副本。如果 deep 为 true，副本还包括 node 的后代。
node . isEqualNode(otherNode): 返回 node 和 otherNode 是否具有相同的属性。

规范可能会为所有或部分节点定义克隆步骤。该算法会传递 copy、node、document 和一个可选的克隆子节点标志，如在克隆算法中所指示的。

HTML 为 script和input元素定义了克隆步骤。SVG 也应为其script元素做同样的事情，但目前尚未提到。

要克隆一个node，可选地带上document和克隆子节点标志，请运行以下步骤：

如果没有给出document，则令document为node的节点文档。
如果node是一个元素，则：
1. 令copy为创建元素的结果，给定document、node的本地名称、node的命名空间、node的命名空间前缀和node的is值，并且取消同步自定义元素标志。
2. 对于node的属性列表中的每个attribute：
  1. 令copyAttribute为attribute的克隆。
  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的节点文档和document为copy，如果copy是一个文档，否则将copy的节点文档设置为document。
运行任何在其他适用规范中为node定义的克隆步骤，并传递copy、node、document，以及如果设置了克隆子节点标志，则将其作为参数。
如果设置了克隆子节点标志，则对于node的每个子节点，按树顺序：将克隆子节点的结果（带有document和克隆子节点标志设置）附加到copy。
如果node是一个影宿主，且其影根的可克隆性为真：
1. 断言：copy不是一个影宿主。
2. 运行附加影根，使用copy、node的影根的模式、真、node的影根的可序列化性、node的影根的焦点委派，以及node的影根的插槽分配。
3. 将copy的影根的声明性设置为node的影根的声明性。
4. 对于node的影根的每个子节点，按树顺序：将克隆子节点的结果（带有document和克隆子节点标志设置）附加到copy的影根。
返回copy。

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

如果this是一个影根，则抛出"NotSupportedError"DOMException。
返回克隆的this，如果deep为 true，则设置克隆子节点标志。

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

A和B 实现相同的接口。
以下内容相等，基于A所实现的接口进行切换：

DocumentType
它的名称、公共ID和系统ID。
Element
它的命名空间、命名空间前缀、本地名称，以及它的属性列表的大小。
Attr
它的命名空间、本地名称和值。
ProcessingInstruction
它的目标和数据。
Text
Comment
它的数据。
否则
—
如果A是一个元素，则其属性列表中的每个属性都有一个等于属性列表中的属性。
A和B具有相同数量的子节点。
A的每个子节点等于相同索引处的B的子节点。

方法isEqualNode(otherNode)的步骤是：如果otherNode非空并且this 等于otherNode，则返回 true；否则返回 false。

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

node . compareDocumentPosition(other)

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

Node . DOCUMENT_POSITION_DISCONNECTED (1): 当node和other不在同一树中时设置。
Node . DOCUMENT_POSITION_PRECEDING (2): 当other在node之前preceding时设置。
Node . DOCUMENT_POSITION_FOLLOWING (4): 当other在node之后following时设置。
Node . DOCUMENT_POSITION_CONTAINS (8): 当other是node的祖先时设置。
Node . DOCUMENT_POSITION_CONTAINED_BY (16, 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)的步骤如下：

如果this是other，则返回零。
将node1设为other，node2设为this。
将attr1和attr2设为 null。
如果node1是一个属性，则将attr1设为node1，并将node1设为attr1的元素。
如果node2是一个属性，则：
1. 将attr2设为node2，并将node2设为attr2的元素。
2. 如果attr1和node1非空，且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非空，则返回DOCUMENT_POSITION_CONTAINS和DOCUMENT_POSITION_PRECEDING之和。
如果node1是node2的后代，并且attr2为 null，或node1是node2且attr1非空，则返回DOCUMENT_POSITION_CONTAINED_BY和DOCUMENT_POSITION_FOLLOWING之和。
如果node1在node2之前preceding，则返回DOCUMENT_POSITION_PRECEDING。

由于该算法处理属性的方式，导致节点的属性被认为在该节点之前，尽管属性不参与同一树。
返回DOCUMENT_POSITION_FOLLOWING。

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

要为一个使用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针对此的元素。
Otherwise
1. 如果此的父元素为 null，则返回 null。
2. 返回定位命名空间前缀的结果，使用namespace针对此的父元素。

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

如果prefix是空字符串，则将其设置为 null。
返回使用prefix在this上运行定位命名空间的结果。

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

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

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

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

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

方法removeChild(child)的步骤是返回从this中预删除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 deep = 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 {
  DOMString is;
};

Document 节点简称为文档。

文档的节点文档是它自己。

每个文档都有一个关联的编码（一个编码）、内容类型（一个字符串）、URL（一个URL）、来源（一个来源）、类型（"xml"或"html"）、模式（"no-quirks"、"quirks"或"limited-quirks"）和允许声明性影子根（一个布尔值）。[编码][URL][HTML]

除非另有说明，否则文档的编码是utf-8 编码，内容类型是"application/xml"，URL是"about:blank"，来源是不透明来源，类型是"xml"，模式是"no-quirks"，并且允许声明性影子根为假。

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

文档被称为无怪癖模式，如果其模式是"no-quirks"，怪癖模式，如果其模式是"quirks"，以及有限怪癖模式，如果其模式是"limited-quirks"。

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

无怪癖模式最初被称为“标准模式”，有限怪癖模式曾被称为“几乎标准模式”。它们被重命名是因为它们的细节现在由标准定义。（并且因为Ian Hickson以这些名字是荒谬的为理由否决了它们的原始名字。）

文档的获取父级算法在给定一个事件的情况下，如果事件的类型属性值是"load"或文档没有浏览上下文，则返回null；否则返回文档的相关全局对象。

document . doctype

返回 doctype，如果没有则返回 null。

document . documentElement

返回 document element。

collection = document . getElementsByTagName(qualifiedName)

如果 qualifiedName 是 "*"，则返回一个包含所有后代元素的 HTMLCollection。

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

collection = document . getElementsByTagNameNS(namespace, localName)

如果 namespace 和 localName 都是 "*"，则返回一个包含所有后代元素的 HTMLCollection。

如果只有 namespace 是 "*"，则返回一个包含所有后代元素的 HTMLCollection，其本地名为 localName。

如果只有 localName 是 "*"，则返回一个包含所有后代元素的 HTMLCollection，其命名空间为 namespace。

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

collection = document . getElementsByClassName(classNames)

collection = element . getElementsByClassName(classNames)

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

doctype 的 getter 步骤是返回 this 的一个 doctype 子节点；否则返回 null。

documentElement 的 getter 步骤是返回 this 的 document element。

getElementsByTagName(qualifiedName) 方法的步骤是返回具有限定名 qualifiedName 的元素列表，用于 this。

因此，在 HTML 文档中，document.getElementsByTagName("FOO") 将匹配不在 HTML 命名空间中的 <FOO> 元素，以及在 HTML 命名空间中的 <foo> 元素，但不会匹配在 HTML 命名空间中的 <FOO> 元素。

getElementsByTagNameNS(namespace, localName) 方法的步骤是返回具有命名空间 namespace 和本地名 localName 的元素列表，用于 this。

getElementsByClassName(classNames) 方法的步骤是返回具有类名 classNames 的元素列表，用于 this。

给出以下的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。

如果localName不匹配名称的生成，则会抛出一个"InvalidCharacterError"DOMException。

提供时，可以使用options的is来创建定制内建元素。

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

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

如果qualifiedName不匹配QName的生成，则会抛出一个"InvalidCharacterError"DOMException。

如果以下条件之一为真，则会抛出一个"NamespaceError"DOMException：

命名空间前缀不为null且namespace为空字符串。
命名空间前缀为"xml"，而namespace不是XML命名空间。
qualifiedName或命名空间前缀为"xmlns"，而namespace不是XMLNS命名空间。
namespace是XMLNS命名空间，而qualifiedName或命名空间前缀不是"xmlns"。

提供时，可以使用options的is来创建定制内建元素。

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不匹配名称的生成，则会抛出一个"InvalidCharacterError"DOMException。如果data包含"?>"，则会抛出一个"InvalidCharacterError"DOMException。

元素接口对于任何名称和命名空间都是Element，除非另有说明。

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

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

如果localName不匹配名称的生成，则抛出一个"InvalidCharacterError"DOMException。
如果this是一个HTML文档，则将localName设置为localName的小写形式。
将is设置为null。
如果options是一个字典，并且options["is"]存在，则将is设置为它。
如果this是一个HTML文档或this的内容类型为"application/xhtml+xml"，则将namespace设置为HTML命名空间；否则为null。
返回给定this、localName、namespace、null、is和设置了同步自定义元素标志的创建元素的结果。

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

让namespace、prefix和localName成为将namespace和qualifiedName传递给验证和提取的结果。
将is设置为null。
如果options是一个字典，并且options["is"]存在，则将is设置为它。
返回给定document、localName、namespace、prefix、is和设置了同步自定义元素标志的创建元素的结果。

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

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

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

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

不会检查data是否由符合Char生成规则的字符组成。

createCDATASection(data)方法步骤如下：

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

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

不会检查data是否由符合Char生成规则的字符组成，或是否包含两个相邻的连字符或以连字符结尾。

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

如果target不匹配Name的生成规则，则抛出一个"InvalidCharacterError"DOMException。
如果data包含字符串"?>"，则抛出一个"InvalidCharacterError"DOMException。
返回一个新的ProcessingInstruction节点，其目标设置为target，数据设置为data，节点文档设置为this。

不会检查target是否包含"xml"或":"，或data是否由符合Char生成规则的字符组成。

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

返回node的副本。如果deep为true，则副本也包括node的后代。

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

node = document . adoptNode(node)

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

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

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

如果node是文档或影子根，则抛出一个"NotSupportedError"DOMException。
返回node的副本，this和副本子项标志已设置（如果deep为true）。

规范可能会为所有或部分节点定义采用步骤。该算法将node和oldDocument作为输入，如采用算法中所示。

要将某个node采用到document中，执行以下步骤：

将oldDocument设为node的节点文档。
如果node的父节点不为null，则移除node。
如果document不是oldDocument，则：
1. 对于node的每个包括影子在内的包容性后代：
  1. 将包括影子在内的包容性后代的节点文档设置为document。
  2. 如果包括影子在内的包容性后代是一个元素，则将包括影子在内的包容性后代的每个属性的节点文档设置为document。
2. 对于node的每个包括影子在内的包容性后代，如果它是自定义元素，则入列一个自定义元素回调反应，其中包括包括影子在内的包容性后代、回调名称"adoptedCallback"，以及包含oldDocument和document的参数列表。
3. 对于node的每个包括影子在内的包容性后代，按包括影子在内的树顺序运行采用步骤，输入参数为包括影子在内的包容性后代和oldDocument。

adoptNode(node)方法步骤如下：

如果node是一个文档，则抛出一个"NotSupportedError"DOMException。
如果node是一个影子根，则抛出一个"HierarchyRequestError"DOMException。
如果node是一个DocumentFragment 节点，其容器不为null，则返回。
将node采用到this。
返回node。

createAttribute(localName)方法步骤如下：

如果localName不匹配Name在XML中的生成规则，则抛出一个"InvalidCharacterError"DOMException。
如果this是一个HTML文档，则将localName设置为ASCII小写形式。
返回一个新的属性，其本地名称为localName，其节点文档为this。

createAttributeNS(namespace, qualifiedName)方法步骤如下：

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

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指示的接口未在相关全局对象中暴露给this，则抛出一个"NotSupportedError"DOMException。

通常用户代理在某些配置中禁用对触摸事件的支持，在这种情况下，此条款将适用于TouchEvent接口。
让event成为创建事件的结果，输入为constructor。
初始化event的type属性为空字符串。
初始化event的timeStamp属性为调用当前高分辨率时间的结果，输入为this的相关全局对象。
初始化event的isTrusted属性为false。
取消设置event的初始化标志。
返回event。

Event构造器应该被使用。

createRange()方法步骤是返回一个新的活动范围，其this为起始点（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的doctype。如果qualifiedName与Name生产不匹配，将抛出“InvalidCharacterError”DOMException，如果它不匹配QName生产，将抛出“NamespaceError”DOMException。
doc = document . implementation . createDocument(namespace, qualifiedName [, doctype = null]): 返回一个具有qualifiedName作为local name，并且其namespace是namespace的XMLDocument，并且如果给出了doctype，它将作为其doctype。
当使用namespace和qualifiedName调用时，此方法抛出与createElementNS()方法相同的异常。
doc = document . implementation . createHTMLDocument([title]): 返回一个已经构建了基本树的document，包括一个title元素，除非省略了title参数。

createDocumentType(qualifiedName, publicId, systemId)方法步骤如下：

验证qualifiedName。
返回一个新的doctype，其qualifiedName为其name，publicId为其public ID，systemId为其system ID，并且其node document设置为document。

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

createDocument(namespace, qualifiedName, doctype)方法步骤如下：

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

HTML namespace
application/xhtml+xml
SVG namespace
image/svg+xml
任何其他命名空间
application/xml
返回document。

createHTMLDocument(title)方法步骤如下：

让doc成为一个新的document，该文档是一个HTML document。
将doc的内容类型设置为“text/html”。
附加一个新的doctype，其“html”作为其名称，并将其节点文档设置为doc，附加到doc。
附加根据doc创建的元素的结果，html，并将HTML namespace附加到doc。
附加根据doc创建的元素的结果，head，并将HTML namespace附加到之前创建的html元素。
如果给出了title：
1. 附加根据doc创建的元素的结果，title，并将HTML namespace附加到之前创建的head元素。
2. 附加一个新的Text节点，其数据设置为title（可以是空字符串），并将其节点文档设置为doc，附加到之前创建的title元素。
附加根据doc创建的元素的结果，body，并将HTML namespace附加到之前创建的html元素。
doc的来源是this关联的document的来源。
返回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 节点通常被称为文档类型定义（doctypes）。

文档类型定义（doctypes）具有相关的名称（name）、公有标识符（public ID）和系统标识符（system ID）。

创建文档类型定义（doctype）时，始终会提供其name。除非在创建文档类型定义（doctype）时显式提供，否则其public ID和system ID将为空字符串。

name获取器步骤是返回this的name。

publicId获取器步骤是返回this的public ID。

systemId获取器步骤是返回this的system ID。

4.7. 接口`DocumentFragment`

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

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

对象A是对象B的包含宿主的包容性祖先（host-including inclusive ancestor），如果A是B的包容性祖先，或者如果B的根有一个非空的宿主，并且A是B的包含宿主的包容性祖先的根的宿主。

DocumentFragment 节点的宿主概念对于HTML的模板（template） 元素和影子根（shadow roots）非常有用，并且会影响预插入（pre-insert）和替换（replace）算法。

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

new DocumentFragment() 构造函数步骤是将this的节点文档设置为当前全局对象的关联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 节点通常被称为影子根（shadow roots）。

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

影子根（Shadow roots）有一个关联的委派焦点（delegates focus）。它最初设置为false。

影子根（Shadow roots）有一个关联的可用于元素内部（available to element internals）。它最初设置为false。

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

影子根（Shadow roots）的关联宿主（host）从不为null。

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

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

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

给定一个event，影子根（shadow root）的获取父级（get the parent）算法返回null，如果event的组合标志（composed flag）未设置并且影子根是event的路径的第一个结构的调用目标的根；否则返回影子根的宿主。

mode获取器步骤是返回this的模式。

delegatesFocus获取器步骤是返回this的委派焦点（delegates focus）。

slotAssignment获取器步骤是返回this的槽分配。

clonable获取器步骤是返回this的可克隆性。

serializable获取器步骤是返回this的可序列化性。

host获取器步骤是返回this的宿主。

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

在影子包括树顺序（shadow-including tree order）中，是影子包括的先序，深度优先遍历（shadow-including preorder, depth-first traversal）节点树。影子包括的先序，深度优先遍历（Shadow-including preorder, depth-first traversal）是tree的先序，深度优先遍历，在tree中遇到的每个影子宿主（shadow host），影子包括的先序，深度优先遍历该元素的影子根的节点树，就在它被遇到之后。

shadow-including root 是对象的 root 的 host 的 shadow-including root，如果对象的 root 是一个 shadow root；否则为它的 root。

对象A是对象B的影子包括的后代（shadow-including descendant），如果A是B的后代，或者A的根是影子根，并且A的根的宿主是影子包括的包容性后代（shadow-including inclusive descendant）B。

影子包括的包容性后代（shadow-including inclusive descendant）是一个对象或其影子包括的后代之一。

对象A是对象B的影子包括的祖先（shadow-including ancestor），当且仅当B是A的影子包括的后代。

影子包括的包容性祖先（shadow-including inclusive ancestor）是一个对象或其影子包括的祖先之一。

节点A从节点B中是闭合影子隐藏的（closed-shadow-hidden），如果以下所有条件都为真：

A的根是影子根。
A的根不是影子包括的包容性祖先B。
A的根是影子根，其模式为“closed”，或A的根的宿主从闭合影子隐藏的B。

为了重新定位（retarget）对象A相对于对象B，重复这些步骤直到返回一个对象：

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

重新定位（retargeting）算法由事件调度以及其他规范（如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;

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

Element 节点通常被称为元素（elements）。

元素（Elements）有一个关联的命名空间（namespace）、命名空间前缀（namespace prefix）、本地名称（local name）、自定义元素状态（custom element state）、自定义元素定义（custom element definition）、is值。当创建元素时，所有这些值都会被初始化。

元素的自定义元素状态是“undefined”、“failed”、“uncustomized”、“precustomized”或“custom”之一。元素的自定义元素状态为“uncustomized”或“custom”时，被称为已定义（defined）。元素的自定义元素状态为“custom”时，被称为自定义（custom）。

元素是否被定义用于确定:defined伪类的行为。元素是否被自定义用于确定变动算法（mutation algorithms）的行为。“failed”和“precustomized”状态用于确保如果自定义元素构造函数（custom element constructor）第一次执行失败，它不会在元素升级（upgrade）时再次执行。

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

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

元素也有一个关联的 shadow root（为 null 或一个 shadow root）。除非另有说明，否则它为 null。如果一个元素的 shadow root 不为 null，那么该元素就是一个 shadow host。

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

元素的HTML大写限定名称（HTML-uppercased qualified name）的返回值通过以下步骤获得：

让qualifiedName成为this的限定名称。
如果this位于HTML命名空间中，并且其节点文档是一个HTML文档，则将qualifiedName设置为qualifiedName的ASCII大写形式。
返回qualifiedName。

用户代理可以通过将限定名称（qualified name）和HTML大写限定名称（HTML-uppercased qualified name）存储在内部槽中来进行优化。

为了创建一个元素（create an element），给定document、localName、namespace和可选的prefix、is、synchronous custom elements flag，执行以下步骤：

如果未给定prefix，则将prefix设为null。
如果未给定is，则将is设为null。
将result设为null。
将definition设为通过查找自定义元素定义给定document、namespace、localName和is的结果。
如果definition非null，并且definition的名称不等于其本地名称（即definition表示一个定制内置元素（customized built-in element）），则：
1. 让interface成为localName和HTML命名空间的元素接口。
2. 将result设置为一个新的元素，该元素实现了interface，没有属性，命名空间设为HTML命名空间，命名空间前缀设为prefix，本地名称设为localName，自定义元素状态设为“undefined”，自定义元素定义设为null，is值设为is，节点文档设为document。
3. 如果设置了synchronous custom elements flag，则在捕获任何异常的同时执行此步骤：
  1. 升级 result 使用 definition。
  如果此步骤抛出异常，则：
  1. 报告异常。
  2. 将result的自定义元素状态设置为“failed”。
4. 否则，排队一个自定义元素升级反应，给定result和definition。
否则，如果definition非null，则：
1. 如果设置了synchronous custom elements flag，则在捕获任何异常的同时执行以下步骤：
  1. 设C为definition的构造函数。
  2. 将result设为构造C的结果，没有参数。
  3. 断言：result的自定义元素状态和自定义元素定义已初始化。
  4. 断言：result的命名空间是HTML命名空间。
    
    IDL 强制规定result是一个HTMLElement对象，所有这些对象都使用HTML命名空间。
  5. 如果result的属性列表不为空，则抛出NotSupportedError的DOMException。
  6. 如果result有子节点，则抛出NotSupportedError的DOMException。
  7. 如果result的父节点非空，则抛出NotSupportedError的DOMException。
  8. 如果result的节点文档不是document，则抛出NotSupportedError的DOMException。
  9. 如果result的本地名称不等于localName，则抛出NotSupportedError的DOMException。
  10. 将result的命名空间前缀设置为prefix。
  11. 将result的is值设置为null。
  如果这些步骤中的任何一步抛出异常，则：
  1. 报告异常。
  2. 将result设为一个新的元素，该元素实现了HTMLUnknownElement接口，没有属性，命名空间设为HTML命名空间，命名空间前缀设为prefix，本地名称设为localName，自定义元素状态设为“failed”，自定义元素定义设为null，is值设为null，节点文档设为document。
2. 否则：
  1. 将result设为一个新的元素，该元素实现了HTMLElement接口，没有属性，命名空间设为HTML命名空间，命名空间前缀设为prefix，本地名称设为localName，自定义元素状态设为“undefined”，自定义元素定义设为null，is值设为null，节点文档设为document。
  2. 排队一个自定义元素升级反应，给定result和definition。
否则：
1. 让interface成为localName和namespace的元素接口。
2. 将result设置为一个新的元素，该元素实现了interface，没有属性，命名空间设为namespace，命名空间前缀设为prefix，本地名称设为localName，自定义元素状态设为“uncustomized”，自定义元素定义设为null，is值设为is，节点文档设为document。
3. 如果namespace是HTML命名空间，并且localName是一个有效的自定义元素名称或is非空，则将result的自定义元素状态设置为“undefined”。
返回result。

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

如果元素的元素具有属性A，则其属性列表包含A。

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

要处理属性更改，对于具有element、oldValue和newValue的属性attribute，执行以下步骤：

排队一个突变记录，内容为“attributes”，适用于element，包含attribute的本地名称、attribute的命名空间、oldValue、“« »”和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、null和attribute的值。

要移除属性attribute，执行以下步骤：

将element设为attribute的元素。
从element的属性列表中移除attribute。
将attribute的元素设为null。
处理属性更改，适用于attribute，包括element、attribute的值和null。

要替换属性oldAttr为属性newAttr，执行以下步骤：

替换oldAttr为newAttr，在oldAttr的元素的属性列表中。
将newAttr的元素设为oldAttr的元素。
将oldAttr的元素设为null。
处理属性更改，适用于oldAttr，包括newAttr的元素、oldAttr的值和newAttr的值。

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

如果element位于HTML命名空间中，且其节点文档是一个HTML文档，则将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：

如果 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 步骤是返回 this 的命名空间。

prefix 的 getter 步骤是返回 this 的命名空间前缀。

localName 的 getter 步骤是返回 this 的本地名称。

tagName 的 getter 步骤是返回 this 的 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 步骤: 返回运行获取属性值的结果，给定 this 和 name。
setter 步骤: 设置属性值，给定 this，使用 name 和给定的值。

id 属性必须反映 "id"。

className 属性必须反映 "class"。

classList 的 getter 步骤是返回一个 DOMTokenList 对象，其关联的元素是 this，且其关联的属性的本地名称是 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；否则返回 false。

hasAttributes() 方法的步骤是，如果 this 的属性列表为空，则返回 false；否则返回 true。

attributes 的 getter 步骤是返回关联的 NamedNodeMap。

getAttributeNames() 方法的步骤是按顺序返回限定名称，如果存在，属性在 this 的属性列表中；否则返回一个新的列表。

这些不能保证是唯一的。

getAttribute(qualifiedName) 方法的步骤是：

让 attr 成为通过获取属性的结果，给定 qualifiedName 和 this。
如果 attr 为 null，则返回 null。
返回 attr 的值。

getAttributeNS(namespace, localName) 方法的步骤是：

让 attr 成为通过获取属性的结果，给定 namespace，localName 和 this。
如果 attr 为 null，则返回 null。
返回 attr 的值。

setAttribute(qualifiedName, value) 方法的步骤是：

如果 qualifiedName 与 XML 中的 Name 生产不匹配，则抛出一个 "InvalidCharacterError" DOMException。
如果 this 在 HTML 命名空间中，并且其节点文档是 HTML 文档，则将 qualifiedName 设置为 qualifiedName 的 ASCII 小写字母。
让 attribute 成为 this 的属性列表中第一个属性，其限定名称为 qualifiedName，否则为 null。
如果 attribute 为 null，创建一个属性，其本地名称为 qualifiedName，值为 value，节点文档为 this 的节点文档，然后将此属性添加到 this，然后返回。
更改 attribute 为 value。

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

将 namespace、prefix 和 localName 作为传递 namespace 和 qualifiedName 的结果传递给验证和提取。
使用 localName、value 以及 prefix 和 namespace 设置属性值。

removeAttribute(qualifiedName) 方法的步骤是给定 qualifiedName 和 this 移除属性，然后返回 undefined。

removeAttributeNS(namespace, localName) 方法的步骤是给定 namespace、localName 和 this 移除属性，然后返回 undefined。

hasAttribute(qualifiedName) 方法的步骤是：

如果 this 在 HTML 命名空间中，并且其节点文档是 HTML 文档，则将 qualifiedName 设置为 qualifiedName 的 ASCII 小写字母。
如果 this 具有一个属性，其限定名称为 qualifiedName，则返回 true；否则返回 false。

toggleAttribute(qualifiedName, force) 方法的步骤是：

如果 qualifiedName 与 XML 中的 Name 生产不匹配，则抛出一个 "InvalidCharacterError" DOMException。
如果 this 在 HTML 命名空间中，并且其节点文档是 HTML 文档，则将 qualifiedName 设置为 qualifiedName 的 ASCII 小写字母。
让 attribute 成为 this 的属性列表中第一个属性，其限定名称为 qualifiedName，否则为 null。
如果 attribute 为 null，则：
1. 如果未给定 force 或为 true，创建一个属性，其本地名称为 qualifiedName，值为空字符串，节点文档为 this 的节点文档，然后将此属性添加到 this，然后返回 true。
2. 返回 false。
否则，如果未给定 force 或为 false，给定 qualifiedName 和 this 移除属性，然后返回 false。
返回 true。

hasAttributeNS(namespace, localName) 方法的步骤是：

如果 namespace 为空字符串，则将其设置为 null。
如果 this 具有一个属性，其命名空间是 namespace，且本地名称是 localName，则返回 true；否则返回 false。

getAttributeNode(qualifiedName) 方法的步骤是返回给定 qualifiedName 和 this 的获取属性的结果。

getAttributeNodeNS(namespace, localName) 方法的步骤是返回给定 namespace、localName 和 this 的获取属性的结果。

setAttributeNode(attr) 和 setAttributeNodeNS(attr) 方法的步骤是返回给定 attr 和 this 的设置属性的结果。

removeAttributeNode(attr) 方法的步骤如下：

如果 this 的属性列表不包含 attr，则抛出一个 "NotFoundError" DOMException。
移除 attr。
返回 attr。

var shadow = element . attachShadow(init): 为 element 创建一个 shadow root 并返回它。
var shadow = element . shadowRoot: 返回 element 的 shadow root，如果有，并且如果 shadow root 的 mode 是 "open"，否则返回 null。

有效的 shadow 宿主名称是：

一个有效的自定义元素名称
"article", "aside", "blockquote", "body", "div", "footer", "h1", "h2", "h3", "h4", "h5", "h6", "header", "main", "nav", "p", "section", 或 "span"

attachShadow(init) 方法的步骤是：

运行附加一个 shadow root，使用 this，init["mode"], init["clonable"], init["serializable"], init["delegatesFocus"], 和 init["slotAssignment"]。
返回 this 的 shadow root。

要附加一个 shadow root，给定一个元素 element，一个字符串 mode，一个布尔值 clonable，一个布尔值 serializable，一个布尔值 delegatesFocus，和一个字符串 slotAssignment：

如果 element 的命名空间不是 HTML 命名空间，则抛出一个 "NotSupportedError" DOMException。
如果 element 的本地名称不是一个有效的 shadow 宿主名称，则抛出一个 "NotSupportedError" DOMException。
如果 element 的本地名称是一个有效的自定义元素名称，或者 element 的 is 值不为空，则：
1. 让 definition 成为给定 element 的节点文档、其命名空间、其本地名称和其 is 值的查找自定义元素定义的结果。
2. 如果 definition 不为空并且 definition 的禁用 shadow 为真，则抛出一个 "NotSupportedError" DOMException。
如果 element 是一个 shadow 宿主，则：
1. 让 currentShadowRoot 成为 element 的 shadow root。
2. 如果以下任意一项为真：
  - currentShadowRoot 的声明式为假；或者
  - currentShadowRoot 的模式不为 mode，
  则抛出一个 "NotSupportedError" DOMException。
3. 否则：
  1. 移除 currentShadowRoot 的所有子节点，按树顺序。
  2. 将 currentShadowRoot 的声明式设置为假。
  3. 返回。
让 shadow 成为一个新的 shadow root，其节点文档是 element 的节点文档，宿主是 element，模式是 mode。
将 shadow 的 delegates focus 设置为 delegatesFocus。
如果 element 的自定义元素状态是 "precustomized" 或 "custom"，则将 shadow 的可用于元素内部设置为真。
将 shadow 的 slot assignment 设置为 slotAssignment。
将 shadow 的声明式设置为假。
将 shadow 的 clonable 设置为 clonable。
将 shadow 的 serializable 设置为 serializable。
将 element 的 shadow root 设置为 shadow。

shadowRoot getter 方法的步骤是：

让 shadow 成为 this 的 shadow root。
如果 shadow 为 null 或其模式为 "closed"，则返回 null。
返回 shadow。

element . closest(selectors): 返回第一个（从 element 开始）匹配 selectors 的包含祖先，否则返回 null。
element . matches(selectors): 如果匹配 selectors 时，element 的根返回 element，则返回 true；否则返回 false。

closest(selectors) 方法的步骤是：

让 s 成为从 selectors 解析选择器的结果。[SELECTORS4]
如果 s 解析失败，则抛出一个 "SyntaxError" DOMException。
让 elements 成为 this 的包含祖先，这些祖先是元素，按树顺序逆序排列。
对于 elements 中的每个 element，如果使用 s、element 和 scoping root 匹配选择器成功，则返回 element。[SELECTORS4]
返回 null。

matches(selectors) 和 webkitMatchesSelector(selectors) 方法的步骤是：

让 s 成为从 selectors 解析选择器的结果。[SELECTORS4]
如果 s 解析失败，则抛出一个 "SyntaxError" DOMException。
如果使用 s、this 和 scoping root 匹配选择器的结果为成功，则返回 true；否则返回 false。[SELECTORS4]

getElementsByTagName(qualifiedName) 方法的步骤是返回具有限定名称 qualifiedName 的元素列表，用于 this。

getElementsByTagNameNS(namespace, localName) 方法的步骤是返回具有命名空间 namespace 和本地名称 localName 的元素列表，用于 this。

getElementsByClassName(classNames) 方法的步骤是返回具有类名 classNames 的元素列表，用于 this。

要插入相邻元素，给定一个元素 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) 方法的步骤是返回运行插入相邻元素的结果，给定 this、where 和 element。

insertAdjacentText(where, data) 方法的步骤是：

创建一个新的 Text 节点，其数据为 data，并且节点文档为 this 的节点文档。
运行插入相邻元素，给定 this、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 获取器步骤是返回属性列表的大小。

item(index) 方法步骤为：

如果 index 等于或大于 this 的属性列表的大小，则返回 null。
否则，返回 this 的属性列表[index]。

一个 NamedNodeMap 对象的支持的属性名称是运行这些步骤返回的值：

让 names 成为此 NamedNodeMap 对象的属性列表中

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

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