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。

要验证并提取一个 namespace 和 qualifiedName，给定一个 context：

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。

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

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. 初始化this，使用type、bubbles和cancelable。

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 创建事件，该接口必须是Event或继承自它的接口，并且可选地提供realm realm，运行以下步骤：

1. 如果未提供realm，则将其设置为null。

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

   如果需要成员，这种方法不起作用；请参见whatwg/dom#600。

3. 运行内部事件创建步骤，以eventInterface、realm、该事件信号发生的时间和dictionary为参数，得到event。

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

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

5. 返回event。

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

1. 使用eventInterface创建一个新对象作为event的结果。如果realm非空，则使用该realm；否则，使用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：

   • type是“touchstart”、“touchmove”、“wheel”或“mousewheel”。[TOUCH-EVENTS] [UIEVENTS]

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

2. 返回false。

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

1. 若eventTarget是一个ServiceWorkerGlobalScope 对象，其service worker的脚本资源的曾经评估过的标志被设置，且listener的类型与任何service worker 事件的类型属性值匹配，则向控制台报告一个警告，提示这可能不会产生预期结果。[SERVICE-WORKERS]

2. 如果 listener 的 signal 不为 null 并且已中止，则返回。

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

4. 若listener的被动为null，则将其设置为listener的默认被动值，根据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对象，并且它的Service Worker的要处理的事件类型集合包含listener的类型，那么报告一个警告到控制台，表明这可能不会产生预期的结果。[SERVICE-WORKERS]

2. 将listener的removed设置为true，并且从eventTarget的事件侦听器列表中移除listener。

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

要移除所有事件监听器，给定一个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 的 dispatch flag。

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

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

3. 令 activationTarget 为 null。

4. 令 relatedTarget 为将 event 的 relatedTarget 相对于 target 进行重定向的结果。

5. 令 clearTargets 为 false。

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

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

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

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

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

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

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

   7. 令 slotInClosedTree 为 false。

   8. 令 parent 为调用 target 的获取父级 并传入 event 的结果。

   9. 当 parent 非 null 时：

      1. 如果 slottable 非 null：

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

         2. 将 slottable 设置为 null。

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

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

      3. 令 relatedTarget 为将 event 的 relatedTarget 相对于 parent 进行重定向的结果。

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

      5. 对于 event 的 触摸目标列表中的每个 touchTarget：将 touchTarget 相对于 parent 进行重定向的结果 追加到 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 设置为调用 parent 的获取父级并传入 event 的结果。

      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，则 continue。

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

       3. 使用 item、event、"bubbling"，以及 给定时的 legacyOutputDidListenersThrowFlag 进行调用。

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

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

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

10. 取消设置 event 的 dispatch flag、stop propagation flag 和 stop immediate propagation flag。

11. 如果 clearTargets 为 true：

    1. 将 event 的 target 设置为 null。

    2. 将 event 的 relatedTarget 设置为 null。

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

12. 如果 activationTarget 非 null：

    1. 如果 event 的 canceled flag 未设置，则运行 activationTarget 的 激活行为并传入 event。

    2. 否则，如果 activationTarget 具有 旧式取消激活 行为，则运行 activationTarget 的 旧式取消激活 行为。

13. 如果 event 的 canceled flag 已设置，则返回 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， invocation-target-in-shadow-tree 为 invocationTargetInShadowTree， 影子调整后的目标为 shadowAdjustedTarget， relatedTarget 为 relatedTarget， 触摸目标列表为 touchTargets， root-of-closed-tree 为 rootOfClosedTree，并且 slot-in-closed-tree 为 slotInClosedTree。

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

1. 令 targetItem 为 pathItem。

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

3. 将 event 的 target 设置为 targetItem 的 影子调整后的目标。

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

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

6. 如果 event 的 stop propagation flag 已设置，则返回。

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

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

   这会避免在此之后添加的 事件监听器被运行。注意，由于 removed 字段， 移除操作仍然会生效。

9. 令 invocationTargetInShadowTree 为 pathItem 的 invocation-target-in-shadow-tree。

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 中每个 removed 为 false 的 listener：

   1. 如果 event 的 type 属性值不是 listener 的 type，则 continue。

   2. 将 found 设置为 true。

   3. 如果 phase 是 "capturing" 且 listener 的 capture 为 false，则 continue。

   4. 如果 phase 是 "bubbling" 且 listener 的 capture 为 true，则 continue。

   5. 如果 listener 的 once 为 true，则 移除事件监听器，给定 event 的 currentTarget 属性值 和 listener。

   6. 令 global 为 listener 的 回调的 关联 Realm的 全局对象。

   7. 令 currentEvent 为 undefined。

   8. 如果 global 是一个 Window 对象：

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

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

   9. 如果 listener 的 passive 为 true，则设置 event 的 in passive listener flag。

   10. 如果 global 是一个 Window 对象，则给定 event 和 listener 记录事件 监听器的计时信息。

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

       1. 为 listener 的 回调对应的 JavaScript 对象的 关联 Realm的 全局对象 报告 exception。

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

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

   12. 取消设置 event 的 in passive listener flag。

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

   14. 如果 event 的 stop immediate propagation flag 已设置，则 break。

3. 返回 found。

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

1. 如果未给出eventConstructor，则令eventConstructor为Event。

2. 令event为根据eventConstructor 创建事件的结果，且在target的相关领域中。

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

4. 按照此算法调用时描述的内容初始化event的其他IDL属性。

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

5. 返回调度event到target的结果，并在设置时设置legacy target override flag。

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

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

2. 设置this的signal为signal。

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

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

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

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

2. 将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。

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

4. 返回signal。

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

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

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

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

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

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

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

2. 将 signal 的 中止原因 设为 reason（如果提供）；否则设为一个新的 "AbortError" DOMException。

3. 将 dependentSignalsToAbort 设为一个新的 列表。

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

   1. 如果 dependentSignal 尚未 中止：

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

      2. 附加 dependentSignal 到 dependentSignalsToAbort。

5. 运行中止步骤 对于 signal。

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

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

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

2. 清空 signal 的 中止算法。

3. 触发事件，名为 abort，在 signal 上。

要从 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 未中止 且其依赖属性不为 true。

      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 为 child 的上一个同级 节点；否则令其为 parent 的最后一个子节点。

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

   1. 将 node 收养到 parent 的 节点文档中。

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

   3. 否则，将 node 插入 parent 的 子节点中，并使其位于 child 的索引之前。

   4. 如果 parent 是一个影子宿主，其影子根的 槽位分配为“named”， 且 node 是一个 可分配槽位对象，则为 node 分配槽位。

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

   6. 使用 node 的根运行为树分配可分配槽位对象。

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

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

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

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

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

         2. 如果 inclusiveDescendant 是自定义的，则使用 inclusiveDescendant、回调名称 “connectedCallback”和 « » 排入一个自定义元素回调反应。

         3. 否则，尝试升级 inclusiveDescendant。

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

      4. 否则，如果 inclusiveDescendant 是一个影子根， inclusiveDescendant 的自定义元素注册表 非 null，且 inclusiveDescendant 的自定义元素注册表的 是否限定作用域为 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. 如果 child 非 null：

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

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

18. 如果 child 非 null，则令 newPreviousSibling 为 child 的上一个同级节点；否则令其为 newParent 的最后一个子节点。

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

20. 否则，将 node 插入 newParent 的 子节点中，并使其位于 child 的索引之前。

21. 如果 newParent 是一个影子宿主，其影子根的 槽位分配为“named”，且 node 是一个 可分配槽位对象， 则为 node 分配槽位。

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

23. 使用 node 的根运行为树分配可分配槽位对象。

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

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

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

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

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

25. 为 oldParent 使用 « »、« node »、 oldPreviousSibling 和 oldNextSibling 排入一个树突变记录。

26. 为 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. 在 suppressObservers 设置 为 true 的情况下，移除 child。

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

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

9. 在 suppressObservers 设置为 true 的情况下，将 node 插入 parent 中，并使其位于 referenceChild 之前。

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，则在 suppressObservers 设置为 true 的情况下，将 node 插入 parent 中，并使其位于 null 之前。

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. 对于 parent 的每个含自身祖先 inclusiveAncestor，然后对于 inclusiveAncestor 的已注册观察器列表中的每个 registered，如果 registered 的 选项["subtree"] 为 true，则向 node 的 已注册观察器列表中追加一个新的临时已注册观察器，其 观察器为 registered 的 观察器，选项为 registered 的选项，且 来源为 registered。

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 获取器步骤是返回一个以 this 为根、仅匹配作为元素的 子节点的 HTMLCollection 集合。

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

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

childElementCount 获取器步骤是 返回 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. 令 notifySet 为 克隆 外围代理的 待处理突变观察者。

3. 清空 外围代理的待处理突变观察者。

4. 令 signalSet 为 克隆 外围代理的 信号槽。

5. 清空 外围代理的信号槽。

6. 对于 notifySet 中的每个 mo：

   1. 令 records 为 克隆 mo 的 记录队列。

   2. 清空 mo 的 记录队列。

   3. 对于 mo 的 节点列表中的每个 node： 移除 所有瞬态注册观察者，其 观察者 为 mo，从 node 的 注册观察者列表中。

   4. 如果 records 非空，则 调用 mo 的 回调，参数为 « records、mo » 和 "report"，并以 回调 this 值 mo 调用。

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

new MutationObserver(callback) 构造器步骤是：将 this 的回调设置为 callback。

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. 对于 target 的 已注册观察器列表中的每个 registered：如果 registered 的 观察器是 this：

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

   2. 将 registered 的选项设置为 options。

8. 否则：

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

   2. 向 this 的 节点列表中追加一个指向 target 的弱引用。

disconnect() 方法步骤如下：

1. 对于 this 的 节点列表中的每个 node：从 node 的 已注册观察器列表中移除所有以 this 为 观察器的已注册观察器。

2. 清空 this 的记录 队列。

takeRecords() 方法步骤如下：

1. 令 records 为 this 的 记录队列的一个克隆。

2. 清空 this 的记录 队列。

3. 返回 records。

要为 target 的 type 排队一个 突变记录， 带 name、namespace、oldValue、addedNodes、 removedNodes、previousSibling 和 nextSibling：

1. 令 interestedObservers 为空映射。

2. 令 nodes 为 target 的包含自身的祖先。

3. 对于 nodes 中的每个 node，然后对于 node 的 每个 registered，该 node 的已注册观察器 列表：

   1. 令 options 为 registered 的 options。

   2. 如果以下各项均不为真

      • node 不是 target 且 options["subtree"] 为 false
      • type 为 "attributes"，且 options["attributes"] 要么不存在 要么为 false
      • type 为 "attributes"， options["attributeFilter"] 存在，且 options["attributeFilter"] 不包含 name，或 namespace 为非 null
      • type 为 "characterData"，且 options["characterData"] 要么不 存在，要么为 false
      • type 为 "childList"，且 options["childList"] 为 false

      则：

      1. 令 mo 为 registered 的observer。

      2. 如果 interestedObservers[mo] 不存在，则 设置 interestedObservers[mo] 为 null。

      3. 如果 type 为 "attributes" 且 options["attributeOldValue"] 为 true，或者 type 为 "characterData" 且 options["characterDataOldValue"] 为 true，则 设置 interestedObservers[mo] 为 oldValue。

4. 对于 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 追加到周围代理的 待处理 mutation observers。

5. 排队一个 mutation observer 微任务。