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. 将 splitResult 设置为运行 严格拆分的结果，参数为 qualifiedName 和 U+003A (:)。

   2. 将 prefix 设置为 splitResult[0]。

   3. 将 localName 设置为 splitResult[1]。

   4. 如果 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] 的 slot-in-closed-tree 为 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] 的 root-of-closed-tree 为 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。

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

1. 设置event的分发标志。

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

   legacy target override flag仅由HTML使用，且仅当目标是一个窗口对象时使用。

3. 将activationTarget设置为null。

4. 将relatedTarget设置为针对目标重新定位event的relatedTarget的结果。

5. 设 clearTargets 为 false。

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

   1. 将touchTargets设置为一个新的列表。

   2. 对于每个touchTarget，它在event的触摸目标列表中: 追加针对目标重新定位touchTarget的结果到touchTargets中。

   3. 通过event、目标、targetOverride、relatedTarget、touchTargets，并设置为false，附加到事件路径。

   4. 如果event是一个鼠标事件对象，且event的类型属性为"click"，则isActivationEvent为true；否则为false。

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

   6. 如果目标是一个slottable且已分配，则将slottable设置为目标，否则为null。

   7. 将slot-in-closed-tree设置为false。

   8. 将parent设置为调用目标的获取父项结果的event。

   9. 当parent非空时：

      1. 如果slottable非空：

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

         2. 将slottable设置为null。

         3. 如果parent的根是一个影子根，且它的模式是"closed"，则将slot-in-closed-tree设置为true。

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

      3. 将relatedTarget设置为针对parent重新定位event的relatedTarget的结果。

      4. 将touchTargets设置为一个新的列表。

      5. 对于每个touchTarget ，它在event的触摸目标列表中: 追加针对parent重新定位touchTarget的结果到touchTargets中。

      6. 如果parent是一个窗口对象，或parent是一个节点且目标的根是parent的包括影子在内的包容性祖先，则：

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

         2. 附加到事件路径通过event、parent、null、relatedTarget、touchTargets，并设置slot-in-closed-tree。

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

      8. 否则：

         1. 将目标设置为parent

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

         3. 附加到事件路径通过event、parent、目标、relatedTarget、touchTargets，并设置slot-in-closed-tree。

      9. 如果parent非空，则将parent设置为调用parent的获取父项结果的event。

      10. 将slot-in-closed-tree设置为false。

   10. 将clearTargetsStruct设置为event的路径中的最后一个结构，其影子调整目标非空。

   11. 如果 clearTargetsStruct 的 shadow-adjusted target、clearTargetsStruct 的 relatedTarget，或 clearTargetsStruct 的 touch target list 中的 EventTarget 对象是一个节点，其根是一个影子根：则将 clearTargets 设置为 true。

   12. 如果activationTarget非空且activationTarget具有旧式预激活行为，则运行activationTarget的旧式预激活行为。

   13. 对于 event 的 path 中的每个 struct，按相反顺序：

       1. 如果struct的影子调整目标非空，则 将event的事件阶段属性设置为AT_TARGET。

       2. 否则，将event的事件阶段属性设置为CAPTURING_PHASE。

       3. 调用通过struct、event、"捕获"，以及如果给出的话legacyOutputDidListenersThrowFlag。

   14. 对于 event 的 path 中的每个 struct：

       1. 如果struct的影子调整目标非空，则 将event的事件阶段属性设置为AT_TARGET。

       2. 否则：

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

          2. 将event的事件阶段属性设置为BUBBLING_PHASE。

       3. 调用通过struct、event、"冒泡"，以及如果给出的话legacyOutputDidListenersThrowFlag。

7. 将event的事件阶段属性设置为NONE。

8. 将event的当前目标属性设置为null。

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

10. 取消设置event的分发标志、停止传播标志，以及立即停止传播标志。

11. 如果 clearTargets 为 true：

    1. 将event的目标设置为null。

    2. 将event的relatedTarget设置为null。

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

12. 如果activationTarget非空：

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

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

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

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

1. 将invocationTargetInShadowTree设置为false。

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

3. 将root-of-closed-tree设置为false。

4. 如果invocationTarget是一个影子根，且其模式是"closed"，则将root-of-closed-tree设置为true。

5. 追加一个新的结构到event的路径，其调用目标是invocationTarget，调用目标在影子树中是invocationTargetInShadowTree，影子调整目标是shadowAdjustedTarget，relatedTarget是relatedTarget，触摸目标列表是touchTargets，关闭树的根是root-of-closed-tree，以及slot-in-closed-tree是slot-in-closed-tree。

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

1. 将event的目标设置为event的路径中的最后一个结构，其影子调整目标非空，且为struct或struct之前的结构。

2. 将event的relatedTarget设置为struct的relatedTarget。

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

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

5. 初始化event的当前目标属性为struct的调用目标。

6. 将listeners设置为event的当前目标属性值的事件侦听器列表的克隆。

   这避免了在此点之后添加的事件侦听器被运行。请注意，由于已删除字段，移除仍然有影响。

7. 将invocationTargetInShadowTree设置为struct的调用目标在影子树中。

8. 将found设置为运行内部调用通过event、listeners、阶段、invocationTargetInShadowTree，以及如果给出的话legacyOutputDidListenersThrowFlag的结果。

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

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

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

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

   3. 内部调用通过event、listeners、阶段、invocationTargetInShadowTree，以及如果给出的话legacyOutputDidListenersThrowFlag。

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

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

1. 让 found 为 false。

2. 对于 listeners 中的每个 listener，其 removed 为 false：

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

   2. 将 found 设为 true。

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

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

   5. 如果 listener 的 once 为 true，则根据 event 的 currentTarget 属性值和 listener 移除一个事件侦听器。

   6. 让 global 成为 listener 的 回调 的 关联的领域的 全局对象。

   7. 让 currentEvent 为 undefined。

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

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

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

   9. 如果 listener 的 passive 为 true，则设定 event 的 被动监听器标志。

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

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

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

       2. 设置 legacyOutputDidListenersThrowFlag（如果提供）。

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

   12. 取消设定 event 的 被动监听器标志。

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

   14. 如果 event 的 停止立即传播标志已设置，则中断。

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 node 插入到一个node parent 中，在 null 或 node child 之前，确保其插入前有效性：

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

2. 如果 node 是 parent 的 host-including inclusive ancestor，则抛出 一个 "HierarchyRequestError" DOMException。

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

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

5. 如果 node 是一个 Text node 且 parent 是一个 document，或者 node 是一个 doctype 且 parent 不是 document，则抛出 一个 "HierarchyRequestError" DOMException。

6. 如果 parent 是一个 document，且下列按 node 接口 implements 切换的语句中任一为真，则抛出 一个 "HierarchyRequestError" DOMException。

   DocumentFragment

   如果 node 有多于一个的 element child，或有一个 Text node child。

   否则，如果 node 有一个 element child 并且任一满足：parent 有一个 element child、child 是一个 doctype，或 child 非 null 且存在一个 doctype 在 child 之后（following），则为真。

   Element

   如果 parent 有一个 element child，或者 child 是一个 doctype，或者 child 非 null 且存在一个 doctype 在 child 之后（following），则为真。

   DocumentType

   如果 parent 有一个 doctype child，child 非 null 且有一个 element 在 child 之前（preceding），或 child 为 null 且 parent 有一个 element child，则为真。

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

1. 确保插入前有效性：将 node 插入到 parent 的 child 之前。

2. 令 referenceChild 为 child。

3. 如果 referenceChild 是 node，则将 referenceChild 设为 node 的 next sibling。

4. 插入 node 到 parent，位于 referenceChild 之前。

5. 返回 node。

其他规范 可能为全部或部分nodes 定义插入步骤。该算法接收 insertedNode，如下面的 insert 算法所示。这些步骤不得修改 insertedNode 所参与的节点树、创建浏览上下文（browsing contexts）、触发事件，或以其他方式执行 JavaScript。然而，这些步骤可以通过排队任务来异步完成这些操作。

其他规范 也可能为全部或部分nodes 定义后连接步骤。该算法接收 connectedNode，如下面的 insert 算法所示。

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

其他规范 可能为全部或部分nodes 定义子节点变更步骤。该算法不接收参数，并由insert、remove 以及 replace data 调用。

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

1. 令 nodes 为 node 的 children（如果 node 是 DocumentFragment node）；否则为 « node »。

2. 令 count 为 nodes 的 size。

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

4. 如果 node 是 DocumentFragment node：

   1. 以 suppressObservers 为 true 的方式移除 其 children。

   2. 为 node 排队一个树突变记录，参数为 « », nodes, null, null。

      此步骤有意不考虑 suppressObservers。

5. 如果 child 非 null：

   1. 对于每个其 start node 为 parent 且 start offset 大于 child 的 index 的 live range：将其 start offset 增加 count。

   2. 对于每个其 end node 为 parent 且 end offset 大于 child 的 index 的 live range：将其 end offset 增加 count。

6. 令 previousSibling 为 child 的 previous sibling，若 child 为 null 则为 parent 的 last child。

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

   1. 将 node 采纳到 parent 的 node document 中。

   2. 如果 child 为 null，则 将 node 追加到 parent 的 children。

   3. 否则，将 node 插入到 parent 的 children 中，位置在 child 的 index 之前。

   4. 如果 parent 是一个其 shadow root 的 shadow host，且该 shadow root 的 slot assignment 为 "named"，并且 node 是一个 slottable，则为 node 分配一个 slot。

   5. 如果 parent 的 root 是一个 shadow root，且 parent 是一个 slot，且其 assigned nodes 为空列表，则为 parent 运行 signal a slot change。

   6. 运行 为树分配 slottables，参数为 node 的 root。

   7. 对于 node 的每个 shadow-including inclusive descendant inclusiveDescendant，按 shadow-including 树序：

      1. 对 inclusiveDescendant 运行 插入步骤。

      2. 如果 inclusiveDescendant 未 connected，则 继续。

      3. 如果 inclusiveDescendant 是一个 element 且其 custom element registry 非 null：

         1. 如果该 inclusiveDescendant 的 custom element registry 的 is scoped 为 true，则将 inclusiveDescendant 的 node document 追加到其 custom element registry 的 scoped document set。

         2. 如果 inclusiveDescendant 是 custom，则排队一个 custom element callback reaction，参数为 inclusiveDescendant、回调名 "connectedCallback"，以及 « »。

         3. 否则，尝试升级 inclusiveDescendant。

            如果这成功升级了 inclusiveDescendant，则在 upgrade an element 算法期间，connectedCallback 会被自动排队。

      4. 否则，如果 inclusiveDescendant 是一个 shadow root，且其 custom element registry 非 null，且该 registry 的 is scoped 为 true，则将 inclusiveDescendant 的 node document 追加到其 custom element registry 的 scoped document set。

8. 如果 suppressObservers 为 false，则为 parent 排队一个树突变记录，参数为 nodes, « », previousSibling, child。

9. 为 parent 运行 children changed steps。

10. 令 staticNodeList 为一个列表，初始为 « »，包含 nodes。

    我们在对任何一个节点调用 post-connection steps 之前先收集所有 nodes，而不是在遍历节点树时边遍历边调用 post-connection steps。这是因为 post-connection steps 可以修改树的结构，使得对实时遍历不安全，可能导致 post-connection steps 对同一节点 被多次调用。

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

    1. 对于该 node 的每个 shadow-including inclusive descendant inclusiveDescendant，按 shadow-including 树序：将 inclusiveDescendant 追加到 staticNodeList。

12. 对于 staticNodeList 中的每个 node（参见 For each）：如果 node 已 connected，则对 node 运行 post-connection steps。

要将节点 node 追加到节点 parent：预插入 node 到 parent 中，插入位置为 null 之前。

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

要将 移动 一个 node node 进入 一个 node newParent，在 null 或 一个 node child 之前：

1. 如果 newParent 的 shadow-including root 与 node 的 shadow-including root 不同，则抛出 一个 "HierarchyRequestError" DOMException。

   这有副作用，确保只有当 newParent 的 connected 与 node 的 connected 相同时才执行移动。

2. 如果 node 是 newParent 的 host-including inclusive ancestor，则抛出 一个 "HierarchyRequestError" DOMException。

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

4. 如果 node 既不是 Element 也不是 CharacterData node，则抛出 一个 "HierarchyRequestError" DOMException。

5. 如果 node 是一个 Text node 且 newParent 是一个 document，则抛出 一个 "HierarchyRequestError" DOMException。

6. 如果 newParent 是一个 document，且 node 是一个 Element node，并且任一：newParent 有一个 element child、child 是 doctype，或 child 非 null 且有一个 doctype 在 child 之后（following），则抛出 一个 "HierarchyRequestError" DOMException。

7. 令 oldParent 为 node 的 parent。

8. 断言：oldParent 非 null。

9. 运行 live range pre-remove steps，参数为 node。

10. 对于每个其 root 的 node document 与 node 相同的 NodeIterator 对象 iterator：对 iterator 运行 NodeIterator pre-remove steps，参数为 node 和 iterator。

11. 令 oldPreviousSibling 为 node 的 previous sibling。

12. 令 oldNextSibling 为 node 的 next sibling。

13. 从 oldParent 的 children 中移除 node。

14. 如果 node 是 assigned，则为其 assigned slot 运行 assign slottables。

15. 如果 oldParent 的 root 是一个 shadow root，且 oldParent 是一个 slot，且其 assigned nodes 为空，则为 oldParent 运行 signal a slot change。

16. 如果 node 有一个作为 slot 的 inclusive descendant：

    1. 对 oldParent 的 root 运行 assign slottables for a tree。

    2. 对 node 运行 assign slottables for a tree。

17. 如果 child 非 null：

    1. 对于每个其 start node 为 newParent 且 start offset 大于 child 的 index 的 live range：将其 start offset 增加 1。

    2. 对于每个其 end node 为 newParent 且 end offset 大于 child 的 index 的 live range：将其 end offset 增加 1。

18. 令 newPreviousSibling 为当 child 非 null 时 child 的 previous sibling，否则为 newParent 的 last child。

19. 如果 child 为 null，则将 node 追加到 newParent 的 children。

20. 否则，将 node 插入到 newParent 的 children，位置在 child 的 index 之前。

21. 如果 newParent 是一个其 shadow root 的 shadow host，且该 shadow root 的 slot assignment 为 "named"，并且 node 是一个 slottable，则为 node 分配一个 slot。

22. 如果 newParent 的 root 是一个 shadow root，且 newParent 是一个 slot，且其 assigned nodes 为空，则为 newParent 运行 signal a slot change。

23. 运行 为树分配 slottables，参数为 node 的 root。

24. 对于 node 的每个 shadow-including inclusive descendant inclusiveDescendant，按 shadow-including 树序：

    1. 如果 inclusiveDescendant 是 node，则对其运行 moving steps，参数为 inclusiveDescendant 和 oldParent。否则，对其运行 moving steps，参数为 inclusiveDescendant 和 null。

       因为 move 算法与 insert 和 remove 是独立的原语，所以它不会为 inclusiveDescendant 调用传统的 插入步骤 或 移除步骤。

    2. 如果 inclusiveDescendant 是 custom 且 newParent 是 connected，则为 inclusiveDescendant 排队一个 custom element callback reaction，回调名为 "connectedMoveCallback"，参数为 « »。

25. 为 oldParent 排队一个树突变记录，参数为 « », « node », oldPreviousSibling, oldNextSibling。

26. 为 newParent 排队一个树突变记录，参数为 « node », « », newPreviousSibling, child。

要 替换 一个 节点 child 为 一个 节点 node 在 一个 节点 parent：

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

2. 如果 node 是 parent 的 host-including inclusive ancestor，则抛出 一个 "HierarchyRequestError" DOMException。

3. 如果 child 的 parent 不是 parent，则抛出 一个 "NotFoundError" DOMException。

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

5. 如果 node 是一个 Text node 且 parent 是一个 document，或者 node 是一个 doctype 且 parent 不是 document，则抛出 一个 "HierarchyRequestError" DOMException。

6. 如果 parent 是一个 document，且下列按 node 接口 implements 切换的语句中任一为真，则抛出 一个 "HierarchyRequestError" DOMException。

   DocumentFragment

   如果 node 有多于一个的 element child，或有一个 Text node child。

   否则，如果 node 有一个 element child 并且任一条件成立：parent 有一个不是 child 的 element child，或存在一个 doctype 在 child 之后（following），则为真。

   Element

   如果 parent 有一个不是 child 的 element child，或存在一个 doctype 在 child 之后（following），则为真。

   DocumentType

   如果 parent 有一个不是 child 的 doctype child，或存在一个 element 在 child 之前（preceding），则为真。

   上述陈述与 pre-insert 算法不同。

7. 令 referenceChild 为 child 的 next sibling。

8. 如果 referenceChild 是 node，则将 referenceChild 设为 node 的 next sibling。

9. 令 previousSibling 为 child 的 previous sibling。

10. 令 removedNodes 为空集合。

11. 如果 child 的 parent 非 null：

    1. 将 removedNodes 设为 « child »。

    2. 以 suppressObservers 为 true 的方式移除 child。

    上述情况仅在 child 是 node 时才可能为假。

12. 令 nodes 为：如果 node 是 DocumentFragment node，则为其 children；否则为 « node »。

13. 将 node 插入到 parent 的 referenceChild 之前，且以 suppressObservers 为 true 的方式执行。

14. 为 parent 排队一个树突变记录，参数为 nodes, removedNodes, previousSibling, referenceChild。

15. 返回 child。

要在一个node parent 中用一个node 或 null node 执行 replace all：

1. 令 removedNodes 为 parent 的 children。

2. 令 addedNodes 为空集合。

3. 如果 node 是 DocumentFragment node，则将 addedNodes 设为 node 的 children。

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

5. 以 suppressObservers 为 true 的方式移除 parent 的所有 children（按树序）。

6. 如果 node 非 null，则以 插入 的方式将 node 插入到 parent 的 null 之前，且以 suppressObservers 为 true 的方式执行。

7. 如果 addedNodes 或 removedNodes 中任一不为空（参见 is not empty），则为 parent 排队一个树突变记录，参数为 addedNodes, removedNodes, null, null。

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

要从一个node parent 中预移除一个node child（pre-remove）：

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

2. 移除 child。

3. 返回 child。

其他规范 可能为全部或部分nodes 定义移除步骤。该算法接收一个node removedNode 和 一个可能为 null 的 node oldParent，如下面的 remove 算法所示。

要移除一个节点node，可选布尔参数 suppressObservers（默认为 false）：

1. 令 parent 为 node 的 parent。

2. 断言：parent 非 null。

3. 运行 live range pre-remove steps，参数为 node。

4. 对于每个其 root 的 node document 与 node 相同的 NodeIterator 对象 iterator：对 iterator 运行 NodeIterator pre-remove steps，参数为 node 和 iterator。

5. 令 oldPreviousSibling 为 node 的 previous sibling。

6. 令 oldNextSibling 为 node 的 next sibling。

7. 从 其 parent 的 children 中移除 node。

8. 如果 node 是 assigned，则为其 assigned slot 运行 assign slottables。

9. 如果 parent 的 root 是一个 shadow root，且 parent 是一个 slot，且其 assigned nodes 为空，则为 parent 运行 signal a slot change。

10. 如果 node 有一个作为 slot 的 inclusive descendant：

    1. 对 parent 的 root 运行 assign slottables for a tree。

    2. 对 node 运行 assign slottables for a tree。

11. 对 node 和 parent 运行 removing steps。

12. 令 isParentConnected 为 parent 的 connected。

13. 如果 node 是 custom 且 isParentConnected 为 true，则为 node 排队一个 custom element callback reaction，回调名为 "disconnectedCallback"，参数为 « »。

    目前有意不向 custom elements 传递 parent。如有需要，未来可能会更改。

14. 对于 node 的每个 shadow-including descendant descendant，按 shadow-including 树序：

    1. 对 descendant 以 descendant 和 null 为参数运行 removing steps。

    2. 如果 descendant 是 custom 且 isParentConnected 为 true，则为 descendant 排队一个 custom element callback reaction，回调名为 "disconnectedCallback"，参数为 « »。

15. 对于 parent 的每个 inclusive ancestor inclusiveAncestor，以及对其每个 registered（来自其 registered observer list），如果该 registered 的 options["subtree"] 为 true，则添加 一个新的 transient registered observer，其 observer 为该 registered 的 observer，options 为该 registered 的 options，且 source 为该 registered 到 node 的 registered observer list。

16. 如果 suppressObservers 为 false，则为 parent 排队一个树突变记录，参数为 « », « node », oldPreviousSibling, oldNextSibling。

17. 为 parent 运行 children changed steps。

The getElementById(elementId) 方法的步骤是返回在 树顺序（tree order） 中、位于 this 的 后代（descendants） 中的第一个 元素（element），且该元素的 ID 为 elementId；否则，如果不存在这样的 元素（element），则返回 null。

customElementRegistry getter 的步骤是：

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

2. 断言： 此对象是一个 ShadowRoot 节点。

3. 返回此对象的自定义元素注册表。

要将 nodes 转换为一个 node，给定一个列表的节点和字符串 nodes，以及document document：

1. 将 nodes 中的每个字符串替换为一个新的 Text 节点，其数据为该字符串，节点文档为 document。

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

3. 令 fragment 为一个新的 DocumentFragment 节点，其节点文档为 document。

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

5. 返回 fragment。

children 的 getter 步骤是：返回一个以 collection 形式、以 this 为根节点，仅匹配 元素 子节点 的 HTMLCollection。

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

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

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

prepend(nodes) 方法步骤：

1. 令 node 为调用 将 nodes 转换为一个 node、参数为 nodes 和 this 的 节点文档 的结果。

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

append(nodes) 方法步骤：

1. 令 node 为调用 将 nodes 转换为一个 node、参数为 nodes 和 this 的 节点文档 的结果。

2. 追加 node 到 this。

replaceChildren(nodes) 方法步骤：

1. 令 node 为调用 将 nodes 转换为一个 node、参数为 nodes 和 this 的 节点文档 的结果。

2. 确保预插入有效性，让 node 在 this 里的 null 位置插入。

3. 全部替换，使用 node 替换 this 里的内容。

moveBefore(node, child) 方法步骤：

1. 令 referenceChild 等于 child。

2. 如果 referenceChild 等于 node，则将 referenceChild 设为 node 的 下一个兄弟节点。

3. 移动 node 到 this，位置在 referenceChild 之前。

querySelector(selectors) 方法步骤是：若运行 作用域匹配选择器字符串 selectors 作用于 this 得到的结果不为空，则返回第一个结果；否则返回 null。

querySelectorAll(selectors) 方法步骤是：返回运行 作用域匹配选择器字符串 selectors 作用于 this 后得到的 静态集合结果。

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

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

before(nodes) 方法步骤：

1. 令 parent 为 this 的 父节点。

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

3. 令 viablePreviousSibling 为 this 首个 前序 兄弟节点，且不在 nodes 内，否则为 null。

4. 令 node 为调用 将 nodes 转换为一个 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 转换为一个 node、参数为 nodes 和 this 的 节点文档 的结果。

5. 预插入 node 到 parent，位置在 viableNextSibling 之前。

replaceWith(nodes) 方法步骤：

1. 令 parent 为 this 的 父节点。

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

3. 令 viableNextSibling 为 this 首个 后序 兄弟节点，且不在 nodes 内，否则为 null。

4. 令 node 为调用 将 nodes 转换为一个 node、参数为 nodes 和 this 的 节点文档 的结果。

5. 如果 this 的 父节点是 parent，替换 this 为 node，在 parent 内。

   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设置为 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 的 observer 是 this：

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

   2. 将 registered 的 options 设为 options。

8. 否则：

   1. 追加一个新的注册观察者， 其observer为this， options为options， 到 target 的 注册观察者列表。

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

disconnect() 方法的步骤如下：

1. 对于 this 的 节点列表中的每个 node： 移除 注册观察者，条件为 this 是其 observer， 从 node 的注册观察者列表中。

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：

   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 到外围代理的 待处理突变观察者。

5. 排队一个突变观察者微任务。