DOM

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

1. 令inputTokens为在 ASCII 空白字符处分割input的结果。

2. 令tokens为一个新的有序集合。

3. 对于 inputTokens 中的每个 token: 将 token 追加到 tokens。

4. 返回tokens。

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

给定字符串 selectors 和 节点 node，作用域匹配选择器字符串 的步骤如下：

1. 令 selector 为 解析选择器 selectors 的结果。 [SELECTORS4]

2. 如果 selector 返回失败，则 抛出一个 "SyntaxError"DOMException。

3. 返回 selector 与 node 的 根节点 通过 作用域根 node 进行 在树中匹配选择器 的结果。[SELECTORS4]。

一个字符串是 一个有效的命名空间 前缀，如果其长度至少为 1，且 不包含ASCII 空白字符、U+0000 NULL、U+002F (/) 或 U+003E (>)。

一个字符串是 一个有效的 属性局部名称，如果其长度至少 为 1 且不包含ASCII 空白字符、U+0000 NULL、U+002F (/)、U+003D (=) 或 U+003E (>)。

一个字符串 name 是一个有效的元素局部名称，如果以下步骤返回 true：

1. 如果 name 的长度为 0，则返回 false。

2. 如果 name 的第 0 个码点是一个ASCII 字母：

   1. 如果 name 包含ASCII 空白字符、U+0000 NULL、U+002F (/) 或 U+003E (>)，则 返回 false。

   2. 返回 true。

3. 如果 name 的第 0 个码点不是 U+003A (:)、U+005F (_) 或处于 U+0080 至 U+10FFFF（含端点）的范围内，则返回 false。

4. 如果 name 后续的码点， 如果存在，不是ASCII 字母、ASCII 数字、 U+002D (-)、U+002E (.)、U+003A (:)、U+005F (_) 或 U+0080 至 U+10FFFF（含端点）范围内的码点， 则 返回 false。

5. 返回 true。

给定一个 context，要验证并 提取 namespace 和 qualifiedName，执行 以下步骤：

1. 如果 namespace 为空字符串，则将其设为 null。

2. 令 prefix 为 null。

3. 令 localName 为 qualifiedName。

4. 如果 qualifiedName 包含 U+003A (:)：

   1. 将 prefix 设为 qualifiedName 中第一个 U+003A (:) 之前的部分。

   2. 将 localName 设为 qualifiedName 中第一个 U+003A (:) 之后的部分。

   3. 如果 prefix 不是一个有效的命名空间前缀，则抛出一个 "InvalidCharacterError" DOMException。

5. 断言：prefix 要么为 null，要么是一个有效的命名空间前缀。

6. 如果 context 为 "attribute"，且 localName 不是一个 有效的属性局部名称，则抛出一个 "InvalidCharacterError" DOMException。

7. 如果 context 为 "element"，且 localName 不是一个 有效的元素局部名称，则抛出一个 "InvalidCharacterError" DOMException。

8. 如果 prefix 不为 null 且 namespace 为 null，则抛出一个 "NamespaceError" DOMException。

9. 如果 prefix 为 "xml"，且 namespace 不是 XML 命名空间，则抛出一个 "NamespaceError" DOMException。

10. 如果 qualifiedName 或 prefix 为 "xmlns"，且 namespace 不是XMLNS 命名空间，则抛出一个 "NamespaceError" DOMException。

11. 如果 namespace 是XMLNS 命名空间，而 qualifiedName 和 prefix 都不是 "xmlns"，则抛出一个 "NamespaceError" DOMException。

12. 返回 (namespace, prefix, localName)。

composedPath() 方法的步骤如下：

1. 令 composedPath 为一个空列表。

2. 令 path 为this 的路径。

3. 如果 path 为空，则返回 composedPath。

4. 令 currentTarget 为this 的 currentTarget 属性值。

5. 断言：currentTarget 是一个 EventTarget 对象。

6. 将 currentTarget 追加到 composedPath。

7. 令 currentTargetIndex 为 0。

8. 令 currentTargetHiddenSubtreeLevel 为 0。

9. 令 index 为 path 的大小减去 1。

10. 当 index 大于或等于 0 时：

    1. 如果 path[index] 的闭合树的根节点为 true，则将 currentTargetHiddenSubtreeLevel 增加 1。

    2. 如果 path[index] 的调用目标为 currentTarget，则将 currentTargetIndex 设为 index，并 跳出循环。

    3. 如果 path[index] 的闭合树中的插槽为 true，则将 currentTargetHiddenSubtreeLevel 减少 1。

    4. 将 index 减少 1。

11. 令 currentHiddenLevel 和 maxHiddenLevel 均为 currentTargetHiddenSubtreeLevel。

12. 将 index 设为 currentTargetIndex − 1。

13. 当 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。

14. 将 currentHiddenLevel 和 maxHiddenLevel 均设为 currentTargetHiddenSubtreeLevel。

15. 将 index 设为 currentTargetIndex + 1。

16. 当 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。

17. 返回 composedPath。

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

1. 设置 event 的已初始化标志。

2. 取消设置 event 的停止传播标志、 立即停止传播标志和已取消标志。

3. 将 event 的 isTrusted 属性设为 false。

4. 将 event 的目标设为 null。

5. 将 event 的 type 属性设为 type。

6. 将 event 的 bubbles 属性设为 bubbles。

7. 将 event 的 cancelable 属性设为 cancelable。

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

1. 如果this 的分派标志已设置，则返回。

2. 使用 type、bubbles 和 cancelable 初始化this。

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

1. 如果 this 的 dispatch flag 已设置，则返回。

2. 初始化 this ，包括 type、bubbles 和 cancelable。

3. 将 this 的 detail 属性设置为 detail。

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

1. 令 event 为使用此接口、null、当前时间和 eventInitDict 运行内部事件 创建步骤的 结果。

2. 将 event 的 type 属性初始化为 type。

3. 返回 event。

要 使用 eventInterface 创建事件， 其中 eventInterface 必须是 Event 或 继承自该接口的 接口，并且可以选择性地给定一个领域 realm，运行以下步骤：

1. 如果未给定 realm，则将其设为 null。

2. 令 dictionary 为将 JavaScript 值 undefined 转换 为 eventInterface 的构造函数所接受的字典类型的结果。 （此字典类型可以是 EventInit 或继承自它的 字典。）

   如果成员是必需的，则此方法不起作用；请参阅 whatwg/dom#600。

3. 令 event 为使用 eventInterface、realm、 事件所表示的发生时刻以及 dictionary 运行内部事件 创建步骤的结果。

   在 macOS 中，可以通过 NSEvent 对象的 timestamp 属性获取输入操作的发生时刻。

4. 将 event 的 isTrusted 属性初始化为 true。

5. 返回 event。

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

1. 令 event 为使用 eventInterface 创建新对象的结果。如果 realm 不为 null，则使用该领域；否则使用 Web IDL 中定义的默认行为。

   截至撰写本文时，Web IDL 尚未定义任何默认行为； 请参阅 whatwg/webidl#135。

2. 设置 event 的已初始化标志。

3. 将 event 的 timeStamp 属性初始化为根据 time 和 event 的 相关全局对象计算得到的相对高精度粗略 时间。

4. 对于 dictionary 中的每个 member → value： 如果 event 具有一个属性，且该属性的 标识符为 member，则 将该属性初始化为 value。

5. 使用 event 和 dictionary 运行事件构造步骤。

6. 返回 event。

要展平 options，运行以下 步骤：

1. 如果 options 是一个布尔值，则返回 options。

2. 返回 options["capture"]。

要进一步展平 options，运行以下 步骤：

1. 令 capture 为展平 options 的结果。

2. 令 once 为 false。

3. 令 passive 和 signal 为 null。

4. 如果 options 是一个字典：

   1. 将 once 设为 options["once"]。

   2. 如果 options["passive"] 存在，则将 passive 设为 options["passive"]。

   3. 如果 options["signal"] 存在，则将 signal 设为 options["signal"]。

5. 返回 capture、passive、once 和 signal。

给定事件类型 type 和一个 EventTarget eventTarget，默认被动 值按以下方式确定：

1. 如果以下条件全部为 true，则返回 true：

   • type 是 "touchstart"、"touchmove"、 "wheel" 或 "mousewheel" 之一。[TOUCH-EVENTS] [UIEVENTS]

   • eventTarget 是一个 Window 对象，或者是一个节点，其节点文档 为 eventTarget，或者是一个节点，其节点 文档的文档元素 为 eventTarget，或者是一个节点，其节点 文档的 body 元素为 eventTarget。[HTML]

2. 返回 false。

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

1. 如果 eventTarget 是一个 ServiceWorkerGlobalScope 对象，且其 服务工作线程的 脚本资源的 曾被求值标志已设置，并且 listener 的 类型 与任意 服务工作线程事件的 type 属性值匹配，则应向控制台报告一条警告，指出这 可能无法得到 预期结果。[SERVICE-WORKERS]

2. 如果 listener 的信号不为 null，且已被 中止，则返回。

3. 如果 listener 的回调为 null，则返回。

4. 如果 listener 的被动值为 null，则将其设为 根据 listener 的类型和 eventTarget 确定的默认 被动值。

5. 如果 eventTarget 的事件监听器列表不包含一个 事件监听器，其类型为 listener 的 类型， 回调为 listener 的 回调，且捕获值为 listener 的捕获值，则将 listener 追加 到 eventTarget 的事件 监听器列表。

6. 如果 listener 的信号不为 null，则 向其添加以下 中止步骤：

   1. 使用 eventTarget 和 listener 移除事件监听器。

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

addEventListener(type, callback, options) 方法的步骤如下：

1. 令 capture、passive、once 和 signal 为 进一步展平 options 的结果。

2. 使用this 和一个事件监听器，添加事件 监听器，其 类型 为 type，回调为 callback，捕获值为 capture， 被动值为 passive，单次值 为 once，且信号为 signal。

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

1. 如果 eventTarget 是一个 ServiceWorkerGlobalScope 对象，且其 服务工作线程的 待处理事件类型集合 包含 listener 的类型，则应向控制台报告一条警告， 指出这可能无法得到预期结果。[SERVICE-WORKERS]

2. 将 listener 的已移除设为 true，并 从 eventTarget 的移除 listener，即从其 事件监听器列表中移除。

HTML 需要此算法来定义事件处理器。[HTML]

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

HTML 需要此算法来定义 document.open()。[HTML]

removeEventListener(type, callback, options) 方法的步骤如下：

1. 令 capture 为展平 options 的结果。

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

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

dispatchEvent(event) 方法的步骤 如下：

1. 如果 event 的分派标志已设置，或者其已初始化标志未 设置，则抛出一个 "InvalidStateError" DOMException。

2. 将 event 的 isTrusted 属性初始化为 false。

3. 返回将 event 分派给this 的结果。

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

1. 令 callbacks 为 « »。

2. 对于每一个 listener 属于 global 的 事件监听器列表：如果 listener 的 类型为 "fetch" 并且 listener 的 回调 不为 null， 则将 listener 的 回调添加到 callbacks。

3. 返回 callbacks。

要向一个 事件 event 的 一个 EventTarget 对象 target 分派事件，并可选地提供 legacy target override flag 和 legacyOutputDidListenersThrowFlag：

1. 设置 event 的分派标志。

2. 如果未给定 legacy target override flag，则令 targetOverride 为 target；否则为 target 的关联的 Document。 [HTML]

   legacy target override flag 仅由 HTML 使用，且仅当 target 是一个 Window 对象时使用。

3. 令 activationTarget 为 null。

4. 令 relatedTarget 为以 target 为参照，对 event 的 relatedTarget 进行重定向的结果。

5. 令 clearTargets 为 false。

6. 如果 target 不等于 relatedTarget，或者 target 是 event 的 relatedTarget：

   1. 令 touchTargets 为一个新的列表。

   2. 对于 event 的触摸目标列表中的每个 touchTarget：将以 target 为参照 重定向 touchTarget 的结果追加到 touchTargets。

   3. 使用 event、target、 targetOverride、relatedTarget、touchTargets 和 false 追加到事件路径。

   4. 如果 event 是一个 MouseEvent 对象， 且 event 的 type 属性为 "click"，则令 isActivationEvent 为 true；否则为 false。

   5. 如果 isActivationEvent 为 true，且 target 具有 激活行为，则将 activationTarget 设为 target。

   6. 如果 target 是一个可插槽化对象 且已被分配，则令 slottable 为 target； 否则为 null。

   7. 令 slotInClosedTree 为 false。

   8. 令 parent 为使用 event 调用 target 的获取 父节点 算法的结果。

   9. 当 parent 不为 null 时：

      1. 如果 slottable 不为 null：

         1. 断言：parent 是一个插槽。

         2. 将 slottable 设为 null。

         3. 如果 parent 的根节点是一个影子根节点，且其 模式为 "closed"， 则将 slotInClosedTree 设为 true。

      2. 如果 parent 是一个可插槽化对象且已被分配，则 将 slottable 设为 parent。

      3. 令 relatedTarget 为以 parent 为参照，对 event 的 relatedTarget 进行重定向的结果。

      4. 令 touchTargets 为一个新的列表。

      5. 对于 event 的 触摸目标列表中的每个 touchTarget： 将以 parent 为参照，对 touchTarget 进行重定向 的结果追加到 touchTargets。

      6. 如果 parent 是一个 Window 对象，或者 parent 是一个节点， 且 target 的根节点是 parent 的包含影子树且包含自身的 祖先：

         1. 如果 isActivationEvent 为 true，event 的 bubbles 属性为 true，activationTarget 为 null，且 parent 具有 激活 行为，则将 activationTarget 设为 parent。

         2. 使用 event、parent、null、 relatedTarget、touchTargets 和 slotInClosedTree 追加到事件路径。

      7. 否则，如果 parent 为 relatedTarget，则将 parent 设为 null。

      8. 否则：

         1. 将 target 设为 parent。

         2. 如果 isActivationEvent 为 true，activationTarget 为 null，且 target 具有激活 行为，则将 activationTarget 设为 target。

         3. 使用 event、parent、 target、relatedTarget、touchTargets 和 slotInClosedTree 追加到事件路径。

      9. 如果 parent 不为 null，则将 parent 设为 使用 event 调用 parent 的获取父节点算法的结果。

      10. 将 slotInClosedTree 设为 false。

   10. 令 clearTargetsItem 为 event 的 路径中， 经影子树调整的目标不为 null 的最后一个事件路径项。

   11. 如果 clearTargetsItem 的经影子树调整的目标、 clearTargetsItem 的relatedTarget，或 clearTargetsItem 的触摸 目标列表中的一个 EventTarget 对象是一个节点， 且其根节点是一个影子根节点：则将 clearTargets 设为 true。

   12. 如果 activationTarget 不为 null，且 activationTarget 具有 遗留预激活 行为，则运行 activationTarget 的 遗留预激活 行为。

   13. 按照相反顺序，遍历 event 的路径中的每个 item：

       1. 如果 item 的经影子树调整的目标 不为 null，则 将 event 的 eventPhase 属性设为 AT_TARGET。

       2. 否则，将 event 的 eventPhase 属性设为 CAPTURING_PHASE。

       3. 使用 item、event、"capturing"， 以及给定的 legacyOutputDidListenersThrowFlag（如果提供）， 执行调用。

   14. 对于 event 的路径中的每个 item：

       1. 如果 item 的经影子树调整的目标 不为 null，则 将 event 的 eventPhase 属性设为 AT_TARGET。

       2. 否则：

          1. 如果 event 的 bubbles 属性为 false，则 继续。

          2. 将 event 的 eventPhase 属性设为 BUBBLING_PHASE。

       3. 使用 item、event、"bubbling"， 以及给定的 legacyOutputDidListenersThrowFlag（如果提供）， 执行调用。

7. 将 event 的 eventPhase 属性设为 NONE。

8. 将 event 的 currentTarget 属性设为 null。

9. 将 event 的路径设为空列表。

10. 取消设置 event 的分派标志、停止传播标志 和 立即停止传播标志。

11. 如果 clearTargets 为 true：

    1. 将 event 的目标设为 null。

    2. 将 event 的relatedTarget 设为 null。

    3. 将 event 的触摸目标列表设为空列表。

12. 如果 activationTarget 不为 null：

    1. 如果 event 的已取消标志未设置，则使用 event 运行 activationTarget 的激活行为。

    2. 否则，如果 activationTarget 具有 遗留已取消激活 行为，则运行 activationTarget 的遗留已取消激活 行为。

13. 如果 event 的已取消标志已设置，则返回 false；否则返回 true。

要追加到 事件路径，给定一个 事件 event、 一个 EventTarget 对象 invocationTarget、一个 潜在 事件目标 shadowAdjustedTarget、一个潜在事件目标 relatedTarget、一个由潜在事件目标组成的列表 touchTargets，以及一个布尔值 slotInClosedTree：

1. 令 invocationTargetInShadowTree 为 false。

2. 如果 invocationTarget 是一个节点，且其根节点是一个 影子 根节点，则将 invocationTargetInShadowTree 设为 true。

3. 令 rootOfClosedTree 为 false。

4. 如果 invocationTarget 是一个影子根节点，且其模式 为 "closed"，则将 rootOfClosedTree 设为 true。

5. 向 event 的路径中追加一个新的事件路径项，其 调用目标为 invocationTarget， 调用目标位于影子树中 为 invocationTargetInShadowTree， 经影子树调整的目标为 shadowAdjustedTarget， relatedTarget 为 relatedTarget， 触摸目标列表为 touchTargets， 闭合树的根节点为 rootOfClosedTree，且 闭合树中的插槽为 slotInClosedTree。

要调用，给定一个事件路径项 pathItem、一个事件 event、一个字符串 phase，以及可选的 legacyOutputDidListenersThrowFlag：

1. 令 targetItem 为 pathItem。

2. 当 targetItem 的经影子树调整的目标为 null 时：将 targetItem 设为 event 的 路径中位于 targetItem 之前的事件路径项。

3. 将 event 的目标设为 targetItem 的 经影子树调整的目标。

4. 将 event 的relatedTarget 设为 pathItem 的 relatedTarget。

5. 将 event 的触摸目标列表设为 pathItem 的 触摸目标列表。

6. 如果 event 的停止传播标志已设置，则返回。

7. 将 event 的 currentTarget 属性初始化为 pathItem 的 调用目标。

8. 令 listeners 为 event 的 currentTarget 属性值的事件监听器列表的克隆。

   这可以避免在此之后添加的事件监听器被 执行。请注意，由于已移除字段的存在，移除操作仍然有效。

9. 令 invocationTargetInShadowTree 为 pathItem 的 调用目标位于影子树中。

10. 令 found 为使用 event、 listeners、phase、invocationTargetInShadowTree 和 可选的 legacyOutputDidListenersThrowFlag 运行内部调用的结果。

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

    1. 令 originalEventType 为 event 的 type 属性值。

    2. 如果 event 的 type 属性值与下表第一列中的任一字符串匹配， 则将 event 的 type 属性值设为 同一行第二列中的字符串；否则返回。

       事件类型	遗留事件类型
       "animationend"	"webkitAnimationEnd"
       "animationiteration"	"webkitAnimationIteration"
       "animationstart"	"webkitAnimationStart"
       "transitionend"	"webkitTransitionEnd"

    3. 使用 event、listeners、phase、 invocationTargetInShadowTree 和 可选的 legacyOutputDidListenersThrowFlag 执行内部调用。

    4. 将 event 的 type 属性值设为 originalEventType。

要内部调用，给定一个 事件 event、一个由 事件 监听器组成的列表 listeners、一个 字符串 phase、一个布尔值 invocationTargetInShadowTree，以及可选的 legacyOutputDidListenersThrowFlag：

1. 令 found 为 false。

2. 对于 listeners 中每个 listener，其 已移除值为 false：

   1. 如果 event 的 type 属性值不等于 listener 的 类型，则继续。

   2. 将 found 设为 true。

   3. 如果 phase 为 "capturing"，且 listener 的 捕获值为 false，则继续。

   4. 如果 phase 为 "bubbling"，且 listener 的 捕获值为 true，则继续。

   5. 如果 listener 的单次值为 true，则 使用 event 的 currentTarget 属性值和 listener 移除事件监听器。

   6. 令 targetGlobal 为 event 的 currentTarget 的 节点文档的相关全局对象，如果 event 的 currentTarget 是一个节点； 否则为 event 的 currentTarget 的 相关全局对象。

   7. 令 listenerGlobal 为 listener 的 回调的关联领域的全局对象。

   8. 如果 targetGlobal 或 listenerGlobal 是一个 Window 对象，且其 关联的 Document 不是完全活动的，则 继续。

   9. 令 currentEvent 为 undefined。

   10. 如果 listenerGlobal 是一个 Window 对象：

       1. 将 currentEvent 设为 listenerGlobal 的 当前事件。

       2. 如果 invocationTargetInShadowTree 为 false，则将 listenerGlobal 的当前事件设为 event。

   11. 如果 listener 的被动值为 true，则设置 event 的处于被动监听器中标志。

   12. 如果 listenerGlobal 是一个 Window 对象，则 使用 event 和 listener 记录事件 监听器的计时信息。

   13. 使用 listener 的 回调、"handleEvent"、« event » 和 event 的 currentTarget 属性值，调用用户对象的操作。如果这抛出异常 exception：

       1. 针对 listener 的 回调对应的 JavaScript 对象的 关联领域的全局对象报告 exception。

       2. 如果给定了 legacyOutputDidListenersThrowFlag，则设置它。

          legacyOutputDidListenersThrowFlag 仅 由 Indexed Database API 使用。[INDEXEDDB]

   14. 取消设置 event 的处于被动监听器中标志。

   15. 如果 listenerGlobal 是一个 Window 对象，则将 listenerGlobal 的 当前事件设为 currentEvent。

   16. 如果 event 的立即停止传播标志已 设置，则 跳出循环。

3. 返回 found。

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

1. 令 recordingTimingAsTask 为调用 在需要时开始记录任务时间 并传入 target 的 相关设置对象所得到的结果。

2. 如果未给定 eventConstructor，则令 eventConstructor 为 Event。

3. 令 event 为创建事件的结果，传入 eventConstructor，在 target 的相关领域中创建。

4. 将 event 的 type 属性初始化为 e。

5. 按照调用此算法时的描述，初始化 event 的所有其他 IDL 属性。

   这也允许将 isTrusted 属性设置为 false。

6. 令 result 为在 target 上分发 event 的结果， 并在设置了 legacy target override flag 时将其设置。

7. 如果 recordingTimingAsTask 为 true：

   1. 断言：target 的相关设置对象是一个 Document。

   2. 以记录任务结束时间，传入不安全的共享当前时间以及 target 的 相关设置对象。

8. 返回 result。

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

1. 令 signal 为一个新的 AbortSignal 对象。

2. 将this 的信号设为 signal。

abort(reason) 方法的步骤是 使用 reason（如果给定），在this 上发出中止信号。

要在一个 AbortController controller 上发出中止信号，并可选地给定 reason，则 使用 reason（如果给定），在 controller 的信号上发出中止信号。

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

1. 令 signal 为一个新的 AbortSignal 对象。

2. 如果给定了 reason，则将 signal 的中止原因设为 reason； 否则设为一个新的 "AbortError" DOMException。

3. 返回 signal。

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

1. 令 signal 为一个新的 AbortSignal 对象。

2. 令 global 为 signal 的相关全局对象。

3. 给定 global、 "AbortSignal-timeout"、milliseconds 和以下步骤， 在超时后运行步骤：

   1. 给定 global，在计时器任务源上排入一个全局任务，以 使用 signal 和一个新的 "TimeoutError" DOMException 发出中止信号。

   在此超时期间，如果 signal 为其 abort 事件注册了任何事件监听器，则必须存在一个从 global 到 signal 的强引用。

4. 返回 signal。

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

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

1. 如果 signal 已被中止，则返回。

2. 将 algorithm 追加到 signal 的 中止算法中。

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

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

1. 如果 signal 已被中止，则返回。

2. 如果给定了 reason，则将 signal 的中止原因设为 reason； 否则 设为一个新的 "AbortError" DOMException。

3. 令 dependentSignalsToAbort 为一个新的列表。

4. 对于 signal 的依赖信号中的每个 dependentSignal：

   1. 如果 dependentSignal 尚未被中止：

      1. 将 dependentSignal 的中止原因设为 signal 的 中止原因。

      2. 将 dependentSignal 追加到 dependentSignalsToAbort。

5. 为 signal 运行 中止步骤。

6. 对于 dependentSignalsToAbort 中的每个 dependentSignal， 为其运行 中止步骤。

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

1. 对于 signal 的中止算法中的每个 algorithm：运行 algorithm。

2. 清空 signal 的中止 算法。

3. 在 signal 上触发一个 事件，其名称为 abort。

要创建一个 依赖中止信号，给定一个由 AbortSignal 对象组成的列表 signals，使用 signalInterface，其必须是 AbortSignal 或一个 继承自它的接口，以及一个 realm：

1. 令 resultSignal 为使用 realm 创建的实现 signalInterface 的新对象。

2. 对于 signals 中的每个 signal：如果 signal 已被 中止，则将 resultSignal 的中止原因设为 signal 的中止原因，并返回 resultSignal。

3. 将 resultSignal 的依赖标志设为 true。

4. 对于 signals 中的每个 signal：

   1. 如果 signal 的依赖标志为 false：

      1. 将 signal 追加到 resultSignal 的 源信号中。

      2. 将 resultSignal 追加到 signal 的 依赖信号中。

   2. 否则，对于 signal 的 源信号中的每个 sourceSignal：

      1. 断言：sourceSignal 尚未被中止， 且不是 依赖信号。

      2. 将 sourceSignal 追加到 resultSignal 的 源信号中。

      3. 将 resultSignal 追加到 sourceSignal 的 依赖信号中。

5. 返回 resultSignal。

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

1. 如果 slottable 的父节点为 null，则返回 null。

2. 设 shadow 为 slottable 的父节点的影子根。

3. 如果 shadow 为 null，则返回 null。

4. 如果 open 为 true 且 shadow 的模式不为“open”，则返回 null。

5. 如果 shadow 的插槽分配为“manual”，则返回 shadow 的后代中其手动分配的节点包含 slottable 的插槽（如果存在）；否则返回 null。

6. 返回 shadow 的后代中按树顺序排列的第一个其名称为 slottable 的名称的插槽（如果存在）；否则返回 null。

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

1. 设 result 为 « »。

2. 设 root 为 slot 的根。

3. 如果 root 不是影子根，则返回 result。

4. 设 host 为 root 的宿主。

5. 如果 root 的插槽分配为“manual”：

   1. 对于 slot 的手动分配的节点中的每个可插入对象 slottable，如果 slottable 的父节点是 host，则将 slottable 追加到 result。

6. 否则，对于 host 的每个可插入对象子节点 slottable，按树顺序：

   1. 设 foundSlot 为给定 slottable 查找插槽的结果。

   2. 如果 foundSlot 是 slot，则将 slottable 追加到 result。

7. 返回 result。

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

1. 设 result 为 « »。

2. 如果 slot 的根不是影子根，则返回 result。

3. 设 slottables 为给定 slot 查找可插入对象的结果。

4. 如果 slottables 是空列表，则将 slot 的每个可插入对象子节点按树顺序追加到 slottables。

5. 对于 slottables 中的每个 node：

   1. 如果 node 是一个插槽，其根是一个影子根：

      1. 设 temporaryResult 为给定 node 查找扁平化可插入对象的结果。

      2. 将 temporaryResult 中的每个可插入对象按顺序追加到 result。

   2. 否则，将 node 追加到 result。

6. 返回 result。

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

1. 设 slottables 为为 slot 查找可插入对象的结果。

2. 如果 slottables 和 slot 的已分配节点不相同，则为 slot 运行发出插槽更改信号。

3. 将 slot 的已分配节点设置为 slottables。

4. 对于 slottables 中的每个 slottable: 将 slottable 的已分配插槽设置为 slot。

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

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

1. 设 slot 为使用 slottable 查找插槽的结果。

2. 如果 slot 非空，则为 slot 运行分配可插入对象。

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

1. 将 slot 追加到 slot 的相关代理的信号插槽列表。

2. 将突变观察者微任务排入队列。

给定一个 节点 node、一个节点 parent、 null 或一个 节点 child，以及一个由列表中的节点 childrenToExclude 组成的确保预插入有效性：

1. 如果 parent 不是一个 Document、 DocumentFragment， 或 Element 节点，则抛出一个 "HierarchyRequestError" DOMException。

2. 如果 node 是 parent 的含宿主的包含性 祖先，则 抛出一个 "HierarchyRequestError" DOMException。

3. 如果 child 非 null 且其父节点不是 parent， 则抛出一个 "NotFoundError" DOMException。

4. 如果 node 不是一个 DocumentFragment、 DocumentType、 Element， 或 CharacterData 节点，则抛出一个 "HierarchyRequestError" DOMException。

5. 如果 parent 不是一个文档：

   1. 如果 node 是一个文档类型，则抛出 一个 "HierarchyRequestError" DOMException。

   2. 返回。

6. 如果 node 是一个 Text 节点，则抛出一个 "HierarchyRequestError" DOMException。

7. 如果 node 是一个 CharacterData 节点，则返回。

8. 如果 node 是一个 DocumentFragment 节点：

   1. 如果 node 有多个元素子节点，或者有一个 Text 节点子节点，则抛出 一个 "HierarchyRequestError" DOMException。

   2. 如果 node 没有元素子节点，则返回。

9. 如果 node 是一个 DocumentFragment 或 Element 节点：

   1. 如果以下任一条件为真：

      • parent 有一个元素子节点，且 childrenToExclude 不包含它；

      • child 非 null，且有一个文档类型跟随 child； 或者

      • child 是一个childrenToExclude 不 包含的文档类型，

      则抛出一个 "HierarchyRequestError" DOMException。

   2. 返回。

10. 断言：node 是一个文档类型。

11. 如果以下任一条件为真：

    • parent 有一个文档类型子节点，且 childrenToExclude 不包含它；

    • child 非 null，且有一个元素位于 child 之前；或者

    • child 为 null，且 parent 有一个元素 子节点，且 childrenToExclude 不 包含它，

    则抛出一个 "HierarchyRequestError" DOMException。

要将一个预插入 节点 node 到一个节点 parent 中，在 null 或节点 child 之前：

1. 给定 node、parent、 child 和 « »，确保预插入有效性。

2. 令 referenceChild 为 child。

3. 如果 referenceChild 是 node，则将 referenceChild 设置为 node 的下一个同胞节点。

4. 将 node 插入 parent 中，在 referenceChild 之前。

5. 返回 node。

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

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

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

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

要将一个插入节点 node 到 一个 节点 parent 中，在 null 或一个节点 child 之前，并带有一个 可选布尔值 suppressObservers（默认为 false）：

1. 如果 node 是一个 DocumentFragment 节点，则令 nodes 为 node 的子节点；否则为 « node »。

2. 令 count 为 nodes 的大小。

3. 如果 count 为 0，则返回。

4. 如果 node 是一个 DocumentFragment 节点：

   1. 将其子节点移除，并将 suppressObservers 设置为 true。

   2. 为 node 将树突变记录入队，并使用 « »、nodes、null 和 null。

      此步骤有意不考虑 suppressObservers。

5. 如果 child 非 null：

   1. 对于每个实时范围，如果其起始 节点是 parent，且 起始偏移量大于 child 的索引：将 其起始偏移量增加 count。

   2. 对于每个实时范围，如果其结束节点是 parent，且 结束偏移量大于 child 的索引：将 其结束偏移量增加 count。

6. 如果 child 为 null，则令 previousSibling 为 parent 的最后一个子节点；否则为 child 的前一个 同胞节点。

7. 对于 nodes 中的每个 node，按树顺序：

   1. 将 node 采用到 parent 的 节点文档中。

   2. 如果 child 为 null，则将 node 追加 到 parent 的子节点中。

   3. 否则，在 child 的索引之前，将 node 插入 parent 的 子节点中。

   4. 如果 parent 是一个影子宿主，其影子根的 插槽分配为 "named"， 且 node 是一个 可插槽项，则为 node 分配一个插槽。

   5. 如果 parent 的根是一个影子根，并且 parent 是一个插槽，其已分配节点是 空列表， 则为 parent 运行发出插槽变更信号。

   6. 使用 node 的根运行为树分配可插槽项。

   7. 对于 node 的每个影子包含的 包含性后代 inclusiveDescendant，按影子包含树顺序：

      1. 使用 inclusiveDescendant 运行插入步骤。

      2. 如果 inclusiveDescendant 未连接，则 继续。

      3. 如果 inclusiveDescendant 是一个元素，且 inclusiveDescendant 的自定义元素注册表非 null：

         1. 如果 inclusiveDescendant 的自定义元素 注册表的 is scoped 为 true，则将 inclusiveDescendant 的节点文档追加到 inclusiveDescendant 的自定义元素 注册表的 作用域文档集合中。

         2. 如果 inclusiveDescendant 是自定义的，则 使用 inclusiveDescendant、回调名称 "connectedCallback" 和 « » 将自定义元素回调反应 入队。

         3. 否则，尝试升级 inclusiveDescendant。

            如果这成功升级了 inclusiveDescendant，则其 connectedCallback 会在 升级元素 算法期间自动入队。

      4. 否则，如果 inclusiveDescendant 是一个影子 根， inclusiveDescendant 的自定义元素注册表 非 null，且 inclusiveDescendant 的自定义元素 注册表的 is scoped 为 true，则将 inclusiveDescendant 的节点 文档追加到 inclusiveDescendant 的自定义元素 注册表的 作用域文档集合中。

8. 如果 suppressObservers 为 false，则为 parent 将树 突变记录入队，并使用 nodes、« »、previousSibling 和 child。

9. 为 parent 运行子节点变更步骤。

10. 令 staticNodeList 为一个节点列表，初始为 « »。

    我们会在对其中任何一个节点调用 连接后步骤之前收集所有节点， 而不是在 遍历节点树时调用 连接后步骤。这是因为 连接后步骤可以修改 树的结构，使实时遍历变得不安全， 并可能导致同一个 节点的 连接后步骤被调用 多次。

11. 对于 nodes 中的每个 node，按树顺序：

    1. 对于 node 的每个影子包含的 包含性后代 inclusiveDescendant，按影子包含树顺序： 将 inclusiveDescendant 追加到 staticNodeList。

12. 对于 staticNodeList 中每个 node：如果 node 已 连接，则使用 node 运行连接后步骤。

要将一个追加节点 node 到一个 节点 parent：将 node 预插入 parent 中，在 null 之前。

规范可以为全部或部分节点定义 移动步骤。 如下面的移动算法所示，该 算法会被传入一个节点 movedNode、一个布尔值 isSubtreeRoot，以及一个节点 oldAncestor。 与 插入 步骤一样，这些步骤不得修改 movedNode 参与的节点树、创建浏览上下文、 触发事件，或 以其他方式执行 JavaScript。不过，这些步骤可以将任务入队， 以异步执行这些操作。

要将一个移动节点 node 到 一个节点 newParent 中，在 null 或一个节点 child 之前：

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

   这具有一个副作用，即确保仅当 newParent 的连接状态与 node 的连接状态相同时才执行移动。

2. 如果 node 是 newParent 的含宿主的包含性 祖先， 则抛出一个 "HierarchyRequestError" DOMException。

3. 如果 child 非 null 且其父节点不是 newParent， 则抛出一个 "NotFoundError" DOMException。

4. 如果 node 不是一个 Element 或一个 CharacterData 节点，则 抛出一个 "HierarchyRequestError" DOMException。

5. 如果 node 是一个 Text 节点，且 newParent 是一个 文档， 则抛出一个 "HierarchyRequestError" DOMException。

6. 如果 newParent 是一个文档，node 是一个 Element 节点，并且 newParent 有一个元素 子节点、 child 是一个文档类型，或者 child 非 null 且有一个 文档类型跟随 child，则抛出一个 "HierarchyRequestError" DOMException。

7. 令 oldParent 为 node 的父节点。

8. 断言：oldParent 非 null。

9. 给定 node，运行实时范围预移除步骤。

10. 对于每个 NodeIterator 对象 iterator，如果其 根的节点文档是 node 的 节点 文档：给定 node 和 iterator，运行NodeIterator 预移除步骤。

11. 令 oldPreviousSibling 为 node 的前一个 同胞节点。

12. 令 oldNextSibling 为 node 的下一个同胞节点。

13. 从 oldParent 的子节点中移除 node。

14. 如果 node 已分配，则为 node 的已分配插槽运行分配可插槽项。

15. 如果 oldParent 的根是一个影子根，并且 oldParent 是一个插槽，其已分配节点 为空，则为 oldParent 运行发出插槽变更信号。

16. 如果 node 有一个包含性后代是一个插槽：

    1. 使用 oldParent 的根运行为树分配可插槽项。

    2. 使用 node 运行为树分配可插槽项。

17. 添加临时注册观察器，参数为 node 和 oldParent。

18. 如果 child 非 null：

    1. 对于每个实时范围，如果其起始 节点是 newParent，且 起始偏移量大于 child 的索引：将 其起始偏移量增加 1。

    2. 对于每个实时范围，如果其结束节点是 newParent，且 结束偏移量大于 child 的索引：将 其结束偏移量增加 1。

19. 如果 child 非 null，则令 newPreviousSibling 为 child 的前一个 同胞节点；否则为 newParent 的最后一个子节点。

20. 如果 child 为 null，则将 node 追加到 newParent 的子节点中。

21. 否则，在 child 的索引之前，将 node 插入 newParent 的 子节点中。

22. 如果 newParent 是一个影子宿主，其影子根的 插槽分配为 "named"，且 node 是一个 可插槽项， 则为 node 分配一个插槽。

23. 如果 newParent 的根是一个影子根，并且 newParent 是一个插槽，其已分配节点 为空，则为 newParent 运行发出插槽变更信号。

24. 使用 node 的根运行为树分配可插槽项。

25. 对于 node 的每个影子包含的包含性 后代 inclusiveDescendant，按影子包含树顺序：

    1. 如果 inclusiveDescendant 是 node，则令 isSubtreeRoot 为 true；否则为 false。

    2. 使用 inclusiveDescendant、isSubtreeRoot 和 oldParent 运行移动步骤。

       由于移动算法是一个不同于 插入和移除的独立原语，因此它 不会为 inclusiveDescendant 调用插入步骤 或移除步骤。

    3. 如果 inclusiveDescendant 是自定义的，且 newParent 已 连接，则使用 inclusiveDescendant、回调名称 "connectedMoveCallback" 和 « » 将自定义元素 回调反应入队。

26. 为 oldParent 将树突变记录入队，并使用 « »、« node »、 oldPreviousSibling 和 oldNextSibling。

27. 为 newParent 将树突变记录入队，并使用 « node »、« »、 newPreviousSibling 和 child。

要在一个节点 parent 内，用一个节点 node 替换一个节点 child：

1. 给定 node、parent、 child 和 « child »，确保预插入有效性。

2. 令 referenceChild 为 child 的下一个同胞节点。

3. 如果 referenceChild 是 node，则将 referenceChild 设置为 node 的下一个同胞节点。

4. 令 previousSibling 为 child 的前一个 同胞节点。

5. 令 removedNodes 为空集合。

6. 将 node 采用到 parent 的节点文档中。

7. 如果 child 的父节点非 null：

   1. 将 removedNodes 设置为 « child »。

   2. 移除 child，并将suppressObservers 设置 为 true。

   只有当 child 是 node 时，上述条件才可能为 false。

8. 如果 node 是一个 DocumentFragment 节点，则令 nodes 为 node 的子节点；否则为 « node »。

9. 将 node 插入 parent 中，在 referenceChild 之前， 并将suppressObservers 设置为 true。

10. 为 parent 将树突变记录入队，并使用 nodes、 removedNodes、previousSibling 和 referenceChild。

11. 返回 child。

要在一个节点 parent 内，用一个节点或 null node 全部替换：

1. 令 removedNodes 为 parent 的子节点。

2. 令 addedNodes 为空集合。

3. 如果 node 是一个 DocumentFragment 节点，则将 addedNodes 设置为 node 的子节点。

4. 否则，如果 node 非 null，则将 addedNodes 设置为 « node »。

5. 按树顺序移除 parent 的所有子节点， 并将suppressObservers 设置为 true。

6. 如果 node 非 null，则将 node 插入 parent 中，在 null 之前，并将suppressObservers 设置为 true。

7. 如果 addedNodes 或 removedNodes 任一不 为空， 则为 parent 将树突变记录入队，并使用 addedNodes、 removedNodes、null 和 null。

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

要从一个节点 parent 中预移除 一个节点 child：

1. 如果 child 的父节点不是 parent，则抛出一个 "NotFoundError" DOMException。

2. 移除 child。

3. 返回 child。

规范可以为全部或部分节点定义 移除 步骤。如下面的移除 算法所示，该 算法会被传入一个节点 removedNode、一个布尔值 isSubtreeRoot，以及一个节点 oldAncestor。

要移除一个节点 node，并带有 一个 可选布尔值 suppressObservers（默认为 false）：

1. 令 parent 为 node 的父节点。

2. 断言：parent 非 null。

3. 给定 node，运行实时范围预移除步骤。

4. 对于每个 NodeIterator 对象 iterator，如果其 根的节点文档是 node 的 节点 文档：给定 node 和 iterator，运行NodeIterator 预移除步骤。

5. 令 oldPreviousSibling 为 node 的前一个 同胞节点。

6. 令 oldNextSibling 为 node 的下一个同胞节点。

7. 从其 parent 的子节点中移除 node。

8. 如果 node 已分配，则为 node 的已分配插槽运行分配可插槽项。

9. 如果 parent 的根是一个影子根，并且 parent 是一个插槽，其已分配节点是 空列表， 则为 parent 运行发出插槽变更信号。

10. 如果 node 有一个包含性后代是一个插槽：

    1. 使用 parent 的根运行为树分配可插槽项。

    2. 使用 node 运行为树分配可插槽项。

11. 使用 node、true 和 parent 运行移除步骤。

12. 令 isParentConnected 为 parent 的连接状态。

13. 如果 node 是自定义的，且 isParentConnected 为 true， 则 使用 node、回调名称 "disconnectedCallback" 和 « » 将自定义元素回调 反应入队。

    目前有意不将 parent 传递给自定义的元素。如果有需要， 这在未来可能会改变。

14. 对于 node 的每个影子包含后代 descendant，按 影子包含树顺序：

    1. 使用 descendant、 false 和 parent 运行移除步骤。

    2. 如果 descendant 是自定义的，且 isParentConnected 为 true，则使用 descendant、 回调名称 "disconnectedCallback" 和 « » 将自定义元素 回调反应入队。

15. 添加临时注册观察器 ，参数为 node 和 parent。

16. 如果 suppressObservers 为 false，则为 parent 将树 突变记录入队，并使用 « »、« node »、oldPreviousSibling 和 oldNextSibling。

17. 为 parent 运行子节点变更步骤。

要在给定一个节点 node 和一个 字符串 elementId 的情况下按 ID 获取元素，返回 node 的后代中，按树序排列的 第一个其 ID 为 elementId 的元素； 否则，如果没有这样的元素，则返回 null。

getElementById(elementId) 方法步骤是返回在给定 this 和 elementId 的情况下按 ID 获取元素的结果。

customElementRegistry getter 步骤 为：

1. 如果 this 是一个文档，则返回 this 的 自定义元素注册表。

2. 断言：this 是一个 ShadowRoot 节点。

3. 返回 this 的自定义元素注册表。

要将列表中的节点和 字符串 nodes 转换为 一个节点，给定文档 document：

1. 将 nodes 中的每个字符串替换为给定 document 和该字符串创建文本节点的结果。

2. 如果 nodes 的大小为 1，则返回 nodes[0]。

3. 令 fragment 为给定 document 创建 文档片段的结果。

4. 对于 nodes 中的每个 node：将 node 追加到 fragment。

5. 返回 fragment。

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

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

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

childElementCount getter 步骤是 返回 this 的子节点中属于元素的数量。

prepend(nodes) 方法步骤是：

1. 令 node 为给定 nodes 和 this 的节点文档将节点转换为一个节点的结果。

2. 将 node 预插入到this 中，在this 的 第一个子节点之前。

append(nodes) 方法步骤是：

1. 令 node 为给定 nodes 和 this 的节点文档将节点转换为一个节点的结果。

2. 将 node 追加到this。

replaceChildren(nodes) 方法 步骤 是：

1. 令 node 为给定 nodes 和 this 的节点文档将节点转换为一个节点的结果。

2. 给定 node、this、null 和 this 的子节点，确保预插入有效性。

3. 在this 中用 node 全部替换。

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

1. 令 referenceChild 为 child。

2. 如果 referenceChild 是 node，则将 referenceChild 设置为 node 的下一个同胞节点。

3. 将 node 移动到this 中，在 referenceChild 之前。

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

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

previousElementSibling getter 步骤是返回第一个先于它的、且为 元素的兄弟节点；否则返回 null。

nextElementSibling getter 步骤是返回第一个跟随于它的、且为 元素的兄弟节点；否则返回 null。

before(nodes) 方法步骤是：

1. 令 parent 为 this 的父节点。

2. 如果 parent 为 null，则返回。

3. 令 viablePreviousSibling 为 this 的第一个不在 nodes 中的前面的 同胞节点；否则为 null。

4. 令 node 为给定 nodes 和 this 的节点文档将节点转换为一个节点的结果。

5. 如果 viablePreviousSibling 为 null，则将其设置为 parent 的 第一个子节点；否则设置为 viablePreviousSibling 的 下一个同胞节点。

6. 将 node 预插入到 parent 中，在 viablePreviousSibling 之前。

after(nodes) 方法步骤是：

1. 令 parent 为 this 的父节点。

2. 如果 parent 为 null，则返回。

3. 令 viableNextSibling 为 this 的第一个不在 nodes 中的后面的 同胞节点；否则为 null。

4. 令 node 为给定 nodes 和 this 的节点文档将节点转换为一个节点的结果。

5. 将 node 预插入到 parent 中，在 viableNextSibling 之前。

replaceWith(nodes) 方法步骤是：

1. 令 parent 为 this 的父节点。

2. 如果 parent 为 null，则返回。

3. 令 viableNextSibling 为 this 的第一个不在 nodes 中的后面的 同胞节点；否则为 null。

4. 令 node 为给定 nodes 和 this 的节点文档将节点转换为一个节点的结果。

5. 如果 this 的父节点是 parent，则在 parent 中用 node 替换this。

   This 可能已被插入到 node 中。

6. 否则，将 node 预插入到 parent 中，在 viableNextSibling 之前。

remove() 方法步骤是：

1. 如果 this 的父节点为 null，则返回。

2. 移除 this。

assignedSlot 的 getter 步骤为：返回以 寻找插槽，传入 this 和 true 的结果。

要 排队一个突变观察者微任务：

1. 如果外围代理的突变观察者微任务已排队为 true，则返回。

2. 将外围代理的突变观察者微任务已排队设为 true。

3. 排队一个微任务用于通知突变观察者。

要通知 变更观察器：

1. 将周边代理的变更观察器微任务 已入队标志设置为 false。

2. 令 notifyList 为对以下对象进行排序的结果： 周边代理的待处理的变更 观察器，按升序排列，其中 a 小于 b 的条件是 a 的创建索引小于 b 的创建索引。

3. 清空周边代理的待处理的变更 观察器。

4. 令 signalSet 为以下对象的克隆： 周边代理的 信号 插槽。

5. 清空周边代理的信号插槽。

6. 对于 notifyList 中的每个 mo：

   1. 令 records 为 mo 的 克隆 副本，克隆自其 记录 队列。

   2. 清空 mo 的记录队列。

   3. 移除临时注册 观察器，针对 mo。

   4. 如果 records 非空，则调用 mo 的回调，传入 « records, mo » 和 "report"，并将回调的 this 值设为 mo。

7. 对于 signalSet 中的每个 slot：触发一个 事件，其名称为 slotchange，将其 bubbles 属性设置为 true， 目标为 slot。

要添加 临时注册观察器，给定一个节点 node 和一个 节点 parent：

1. 对于 parent 的每个包含自身的祖先 inclusiveAncestor， 然后对于 inclusiveAncestor 的 已注册观察器列表中的每个 registered：

   1. 如果 registered 的 选项["subtree"] 为 false，则 继续。

   2. 令 observer 为 registered 的 观察器。

   3. 如果 registered 是一个 临时注册观察器， 则令 source 为 registered 的 来源； 否则为 registered。

   4. 如果 node 的已注册观察器列表包含一个 临时注册观察器，其 来源为 source，则继续。

   5. 向 node 的已注册 观察器列表中追加一个新的临时注册观察器，其 观察器为 observer， 选项为 source 的 选项，且来源 为 source。

   6. 向 observer 的 临时节点集合中追加一个指向 node 的弱引用。

   7. 将 observer 追加到周边代理的 待处理的变更观察器中。

      这确保 node 的临时注册观察器会在 下次通知变更观察器时被 移除，即使没有任何MutationRecord 对象被加入队列 供 observer 处理。

   8. 将一个变更观察器 微任务加入队列。

要为一个MutationObserver 对象 observer 移除临时注册观察器：

1. 对于 observer 的 临时节点集合中的每个 node：从 node 的已注册观察器 列表中移除所有 临时注册观察器，其观察器为 observer。

2. 清空 observer 的临时节点集合。

new MutationObserver(callback) 构造函数的步骤如下：

1. 将this 的回调设为 callback。

2. 将this 的创建索引设为this 的 相关代理的变更观察器 计数器。

3. 将this 的相关代理的变更观察器 计数器增加 1。

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

1. 如果 options["attributeOldValue"] 或 options["attributeFilter"] 存在，并且 options["attributes"] 不存在，则将 options["attributes"] 设为 true。

2. 如果 options["characterDataOldValue"] 存在，且 options["characterData"] 不 存在，则将 options["characterData"] 设为 true。

3. 如果 options["childList"]、 options["attributes"] 和 options["characterData"] 均不为 true，则抛出一个 TypeError。

4. 如果 options["attributeOldValue"] 为 true，且 options["attributes"] 为 false，则抛出一个 TypeError。

5. 如果 options["attributeFilter"] 存在，且 options["attributes"] 为 false，则抛出一个 TypeError。

6. 如果 options["characterDataOldValue"] 为 true，且 options["characterData"] 为 false，则抛出一个 TypeError。

7. 令 registered 为 target 的已注册观察器列表中的已注册观察器，该观察器不是临时已注册观察器，且其 观察器为this（如果存在）；否则 为 null。

   如果 target 曾位于this 所观察的子树中，且已被 移除或 移动，则 target 的已注册观察器列表也可能包含 临时已注册观察器，其观察器为 this。这些观察器会被忽略，因为它们将在下次通知变更 观察器时被移除。

8. 如果 registered 不为 null：

   1. 对于this 的临时节点集合中的每个 node：从 node 的 已注册 观察器列表中移除所有 临时已注册观察器，其 来源为 registered。

   2. 将 registered 的选项设为 options。

9. 否则：

   1. 向 target 的 已注册观察器列表中追加一个新的已注册 观察器，其 观察器为this，且 选项为 options。

   2. 将 target 的弱引用追加到this 的 节点列表中。