DOM

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的信号不为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的事件监听器列表：

   1. 如果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 插入到 节点 parent 中， 插入位置为 null 或某个 节点 child 之前时，执行如下步骤：

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

2. 如果 node 是 parent 的宿主包含的祖先节点，则抛出一个“HierarchyRequestError”DOMException。

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

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

5. 如果 node 是一个 Text 节点且 parent 是一个文档，或者 node 是一个文档类型且 parent 不是一个文档，则抛出一个“HierarchyRequestError”DOMException。

6. 如果 parent 是一个文档，并且以下根据 node 实现的接口切换的任何语句为真，则抛出一个“HierarchyRequestError”DOMException。

   DocumentFragment

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

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

   Element

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

   DocumentType

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

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

1. 确保预插入有效性，即将 node 插入到 parent 中，位于 child 之前。

2. 设 referenceChild 为 child。

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

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

5. 返回 node。

Specifications 可能为全部或部分 nodes 定义 insertion steps。该算法会接收 insertedNode，如下面 insert 算法所示。该等步骤不得修改 node tree（即 insertedNode 所参与的树），不得创建 browsing contexts、fire events，或以其他方式执行 JavaScript。不过，这些步骤可以通过 queue tasks 来异步完成这些操作。

相关规范 也可以为所有或部分 nodes 定义 post-connection steps。该算法接收 connectedNode， 如下面 insert 算法所示。

执行 post-connection steps 的目的是为 nodes 提供机会去执行任何与连接相关的操作，这些操作可能会修改 node tree（即 connectedNode 所 participates 的树）、创建 浏览上下文，或以其他方式执行 JavaScript。这些步骤允许一批 nodes 就脚本而言作为一个 原子操作被 inserted， 所有主要的副作用都在将该批次插入到 node tree 完成之后发生。这确保了所有挂起的 node tree 插入在更多插入发生之前完全完成。

相关规范 可能为所有或部分 nodes 定义 children changed steps。该算法不接收参数，由 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. Remove 其 children，并将 suppressObservers 设为 true。

   2. Queue a tree mutation record，为 node 排队，参数为 « »、nodes、null 和 null。

      此步骤故意不考虑 suppressObservers。

5. 如果 child 非空：

   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，按 tree order：

   1. Adopt 该 node 到 parent 的 node document。

   2. 如果 child 为 null，则 append node 到 parent 的 children。

   3. 否则，insert 该 node 到 parent 的 children，插入位置为 child 的 index 之前。

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

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

   6. 运行 assign slottables for a tree，参数为 node 的 root。

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

      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 是 shadow root， inclusiveDescendant 的 自定义元素注册表 不为 null， 并且 inclusiveDescendant 的 自定义元素注册表 的 “is scoped” 属性为 true，则 追加 inclusiveDescendant 的 节点文档到 inclusiveDescendant 的 自定义元素注册表的 文档作用域集合。

8. 如果 suppressObservers 为 false，则为 parent 排队一个 tree mutation record，参数为 nodes、« »、previousSibling 与 child。

9. 为 parent 运行 children changed steps。

10. 令 staticNodeList 为一个list，其内容类型为 nodes，初始为 « »。

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

11. 对于 nodes 中的每个 node，按 tree order：

    1. 对于 node 的每个 shadow-including inclusive descendant inclusiveDescendant，按 shadow-including tree order： append inclusiveDescendant 到 staticNodeList。

12. For each node of staticNodeList：如果 node 是 connected， 则运行 post-connection steps，参数为该 node。

要 append 一个 node node 到一个 node parent： pre-insert node 到 parent 的 null 之前。

规范 可能为全部或部分 nodes 定义 moving steps。该算法会传入一个 node movedNode，以及一个 node-or-null oldParent，如下面的 move 算法所示。像 insertion steps 一样，这些步骤不得修改 node tree（即 movedNode 所参与的树）、创建 browsing contexts、fire events，或以其他方式执行 JavaScript。不过，这些步骤可以将任务排入队列以异步完成这些操作。

要 move 一个 node node 到一个 node newParent 中， 在 null 或一个 node child 之前：

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

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

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

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

4. 如果 node 既不是 Element 也不是 CharacterData 类型的 node， 则 throw 一个 "HierarchyRequestError" DOMException。

5. 如果 node 是一个 Text 节点，且 newParent 是一个 document， 则 throw 一个 "HierarchyRequestError" DOMException。

6. 如果 newParent 是一个 document，且 node 是一个 Element 节点， 并且以下情形之一为真：newParent 已经有一个 element 子节点、child 是一个 doctype，或 child 非空且有一个 doctype 在 child 的后面， 则 throw 一个 "HierarchyRequestError" DOMException。

7. 令 oldParent 为 node 的 parent。

8. Assert：oldParent 非空。

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

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

11. 令 oldPreviousSibling 为 node 的 previous sibling。

12. 令 oldNextSibling 为 node 的 next sibling。

13. Remove node 从其 parent 的 children 中移除。

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

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

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

    1. 运行 assign slottables for a tree，参数为 oldParent 的 root。

    2. 运行 assign slottables for a tree，参数为 node。

17. 如果 child 非空：

    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 非空，则为 child 的 previous sibling；否则为 newParent 的 last child。

19. 如果 child 为 null，则 append node 到 newParent 的 children。

20. 否则，insert node 到 newParent 的 children，在 child 的 index 之前。

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

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

23. 运行 assign slottables for a tree，参数为 node 的 root。

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

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

       因为 move 算法 是独立于 insert 与 remove 的原语， 它不会为 inclusiveDescendant 调用传统的 insertion steps 或 removing steps。

    2. 如果 inclusiveDescendant 是 custom 且 newParent 是 connected，则以 inclusiveDescendant、 回调名 "connectedMoveCallback" 及 « » 入队一个自定义元素回调反应。

25. Queue a tree mutation record，为 oldParent 排队，参数为 « »、« node »、oldPreviousSibling 与 oldNextSibling。

26. Queue a tree mutation record，为 newParent 排队，参数为 « node »、« »、newPreviousSibling 与 child。

要 replace 一个 node child，用一个 node node 在 node parent 中：

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

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

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

4. 如果 node 不是 DocumentFragment、 DocumentType、Element 或 CharacterData 类型的 node，则 throw 一个 "HierarchyRequestError" DOMException。

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

6. 如果 parent 是一个 document，并且下列关于 node 的接口实现（switched on the interface） 中任一条为真，则 throw 一个 "HierarchyRequestError" DOMException。

   DocumentFragment

   如果 node 有多于一个的 element 子节点，或有一个 Text 子节点。

   否则，如果 node 有一个 element 子节点，且同时 parent 有一个不是 child 的 element 子节点，或有一个 doctype 位于 child 之后。

   Element

   如果 parent 有一个不是 child 的 element 子节点，或有一个 doctype 位于 child 之后。

   DocumentType

   如果 parent 有一个不是 child 的 doctype 子节点，或有一个 element 位于 child 之前。

   上述判断与 pre-insert 算法不同。

7. 令 referenceChild 为 child 的 next sibling。

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

9. 令 previousSibling 为 child 的 previous sibling。

10. 令 removedNodes 为空集合。

11. 如果 child 的 parent 非空：

    1. 将 removedNodes 设为 « child »。

    2. Remove child，并将 suppressObservers 设为 true。

    上述情况只有在 child 为 node 时才为假。

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

13. Insert node 到 parent 的 referenceChild 之前，并将 suppressObservers 设为 true。

14. Queue a tree mutation record，为 parent 排队，参数为 nodes、removedNodes、previousSibling 与 referenceChild。

15. 返回 child。

要在节点或null node内，对节点 parent替换全部：

1. 令 removedNodes 为 parent 的 children。

2. 令 addedNodes 为空集。

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

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

5. Remove parent 的全部 children，按 tree order，并将 suppressObservers 设为 true。

6. 如果 node 非空，则以 insert 将 node 插入到 parent 的 null 之前，并将 suppressObservers 设为 true。

7. 如果 addedNodes 或 removedNodes 中任一者 非空，则为 parent 排队一个 tree mutation record，参数为 addedNodes、removedNodes、null 和 null。

该算法不会对 node tree 约束进行任何检查。规范作者需谨慎使用。

要从一个 node parent 中 pre-remove 一个 node child：

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

2. Remove child。

3. 返回 child。

相关规范 可能为所有或部分 nodes 定义 removing steps。 该算法接收一个 node removedNode 与一个可为 null 的 node-or-null oldParent，如下面 remove 算法所示。

要 remove 一个 node node，可选地带有布尔型 suppressObservers （默认 false）：

1. 令 parent 为 node 的 parent。

2. 断言：parent 非空。

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

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

5. 令 oldPreviousSibling 为 node 的 previous sibling。

6. 令 oldNextSibling 为 node 的 next sibling。

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

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

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

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

    1. 运行 assign slottables for a tree，参数为 parent 的 root。

    2. 运行 assign slottables for a tree，参数为 node。

11. 运行 removing steps，参数为 node 与 parent。

12. 令 isParentConnected 为 parent 的 connected。

13. 如果 node 是 custom 且 isParentConnected 为 true， 则以 node、回调名 "disconnectedCallback" 及 « » 入队一个自定义元素回调反应。

    当前刻意不向 custom elements 传入 parent。如果未来有需要，可能会改变。

14. 对于 node 的每个 shadow-including descendant descendant，按 shadow-including tree order：

    1. 对 descendant 运行 removing steps，参数为 descendant 与 null。

    2. 如果 descendant 是 custom 且 isParentConnected 为 true， 则以 descendant、回调名 "disconnectedCallback" 及 « » 入队一个自定义元素回调反应。

15. 对于 parent 的每个 inclusive ancestor inclusiveAncestor，然后对其 registered observer list 中的每个 registered：如果 registered 的 options["subtree"] 为 true，则追加一个新的 transient registered observer，其 observer 为 registered 的 observer，其 options 为 registered 的 options，且其 source 为指向 node 的 registered observer list 的 registered。

16. 如果 suppressObservers 为 false，则为 parent 排队一个 tree mutation record，参数为 « »、« node »、 oldPreviousSibling 与 oldNextSibling。

17. 为 parent 运行 children changed steps。