DOM

`有順序~集合として構文解析する@ ~algoは、 所与の ( 文字列 %入力 ) に対し： ◎ The ordered set parser takes a string input and then runs these steps:

1. %入力~token群 ~LET `~ASCII空白で分割する$( %入力 ) ◎ Let inputTokens be the result of splitting input on ASCII whitespace.
2. %~token群 ~LET 新たな`有順序~集合$ ◎ Let tokens be a new ordered set.
3. %入力~token群 を成す ~EACH( %~token ) に対し ⇒ %~token群 に %~token を`付加する$set ◎ For each token of inputTokens, append token to tokens.
4. ~RET %~token群 ◎ Return tokens.

`有順序~集合を直列化する@ ~algoは、 所与の ( 文字列たちが成す`有順序~集合$ %集合 ) に対し ⇒ ~RET %集合 を `0020^U `SPACE^cn で`連結する$ ◎ The ordered set serializer takes a set and returns the concatenation of set using U+0020 SPACE.

%~node の `視野の下で選択子を照合する@ ~algoは、 所与の ( 文字列 %選択子 ) に対し： ◎ To scope-match a selectors string selectors against a node, run these steps:

1. %S ~LET `選択子として構文解析する$( %選択子 ) `SELECTORS4$r ◎ Let s be the result of parse a selector selectors. [SELECTORS4]
2. ~IF［ %S ~EQ `失敗^i ］ ⇒ ~THROW `SyntaxError$E ◎ If s is failure, then throw a "SyntaxError" DOMException.
3. ~RET `~treeに対し選択子を照合する$( 選択子 %S, 根~要素たちが成す集合 { %~node の`根$ }, `視野ng根$たちが成す集合 { %~node } ) `SELECTORS4$r ◎ Return the result of match a selector against a tree with s and node’s root using scoping root node. [SELECTORS4].

注記： 選択子の中の~ns用の~supportは、 計画されておらず，追加されることはない。 ◎ Support for namespaces within selectors is not planned and will not be added.

`~nsと名前を検証して抽出する@ ~algoは、 所与の ( %~ns, %名前, %文脈 【 ~IN { `属性^i, `要素^i } 】) に対し： ◎ To validate and extract a namespace and qualifiedName, given a context:

1. ~IF［ %~ns ~EQ 空~文字列 ］ ⇒ %~ns ~SET ~NULL ◎ If namespace is the empty string, then set it to null.
2. %接頭辞 ~LET ~NULL ◎ Let prefix be null.
3. %局所~名 ~LET %名前 ◎ Let localName be qualifiedName.

4. ~IF［ %名前 は `003A^U `:^smb を包含する ］： ◎ If qualifiedName contains a U+003A (:):

   1. %分割-結果 ~LET `区切子で厳密に分割する$( %名前, `003A^U `:^smb ) ◎ Let splitResult be the result of running strictly split given qualifiedName and U+003A (:).
   2. %接頭辞 ~SET %分割-結果[ 0 ] ◎ Set prefix to splitResult[0].
   3. %局所~名 ~SET %分割-結果[ 1 ] ◎ Set localName to splitResult[1].

   【 複数個の `003A^U `:^smb がある場合、 %分割-結果 を成す 3 個目以降の~itemは無視されることになる。 】

5. ~IF［ ~OR↓ ］…

   • %接頭辞 は`妥当な~ns接頭辞$でない
   • ［ %文脈 ~EQ `属性^i ］~AND［ %局所~名 は`妥当な属性~局所~名$でない ］
   • ［ %文脈 ~EQ `要素^i ］~AND［ %局所~名 は`妥当な要素~局所~名$でない ］

   …ならば ⇒ ~THROW `InvalidCharacterError$E

   ◎ If prefix is not a valid namespace prefix, then throw an "InvalidCharacterError" DOMException. ◎ If context is "attribute" and localName is not a valid attribute local name, then throw an "InvalidCharacterError" DOMException. ◎ If context is "element" and localName is not a valid element local name, then throw an "InvalidCharacterError" DOMException.

6. ~IF［ ~OR↓ ］…

   • ［ %~ns ~EQ ~NULL ］~AND［ %接頭辞 ~NEQ ~NULL ］
   • ［ %~ns ~NEQ `~XML~ns$ ］~AND［ %接頭辞 ~EQ `xml^l ］
   • ［ %~ns ~NEQ `~XMLNS~ns$ ］~AND［［ %名前 ~EQ `xmlns^l ］~OR［ %接頭辞 ~EQ `xmlns^l ］］
   • ［ %~ns ~EQ `~XMLNS~ns$ ］~AND［ %名前 ~NEQ `xmlns^l ］~AND［ %接頭辞 ~NEQ `xmlns^l ］

   …ならば ⇒ ~THROW `NamespaceError$E

   ◎ If prefix is non-null and namespace is null, then throw a "NamespaceError" DOMException. ◎ If prefix is "xml" and namespace is not the XML namespace, then throw a "NamespaceError" DOMException. ◎ If either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace, then throw a "NamespaceError" DOMException. ◎ If namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns", then throw a "NamespaceError" DOMException.
7. ~RET ( %~ns, %接頭辞, %局所~名 ) ◎ Return (namespace, prefix, localName).

@type 取得子~手続きは、 初期化-時の値を返す。 `~event$の作成-時には、 この属性は空~文字列に初期化するモノトスル。 ◎ The type attribute must return the value it was initialized to. When an event is created the attribute must be initialized to the empty string.

@currentTarget 取得子~手続きは、 初期化-時の値を返す。 ◎ The currentTarget attribute must return the value it was initialized to.＼

`~event$の作成-時には、 この属性は ~NULL に初期化するモノトスル。 ◎ When an event is created the attribute must be initialized to null.

@composedPath() ~method手続きは： ◎ The composedPath() method steps are:

1. %~composed経路 ~LET « » ◎ Let composedPath be an empty list.
2. %経路 ~LET コレの`経路$ ◎ Let path be this’s path.
3. ~IF［ %経路 は`空$である ］ ⇒ ~RET %~composed経路 ◎ If path is empty, then return composedPath.
4. %現-~target ~LET コレの $currentTarget 属性~値 ◎ Let currentTarget be this’s currentTarget attribute value.
5. ~Assert： %現-~target は $EventTarget ~objである。 ◎ Assert: currentTarget is an EventTarget object.
6. %~composed経路 に %現-~target を`付加する$ ◎ Append currentTarget to composedPath.
7. %現-~target~index ~LET 0 ◎ Let currentTargetIndex be 0.
8. %現-~targetの非可視~下位tree~level ~LET 0 ◎ Let currentTargetHiddenSubtreeLevel be 0.
9. %~index ~LET %経路 の`~size$ − 1 ◎ Let index be path’s size − 1.

10. ~WHILE［ %~index ~GTE 0 ］： ◎ While index is greater than or equal to 0:

    1. ~IF［ %経路[ %~index ] の`閉な~treeの根か$evP ~EQ ~T ］ ⇒ %現-~targetの非可視~下位tree~level ~INCBY 1 ◎ If path[index]'s root-of-closed-tree is true, then increase currentTargetHiddenSubtreeLevel by 1.
    2. ~IF［ %経路[ %~index ] の`呼出n~target$evP ~EQ %現-~target ］ ⇒＃ %現-~target~index ~SET %~index； ~BREAK ◎ If path[index]'s invocation target is currentTarget, then set currentTargetIndex to index and break.
    3. ~IF［ %経路[ %~index ] の`~slotは閉な~tree内か$evP ~EQ ~T ］ ⇒ %現-~targetの非可視~下位tree~level ~DECBY 1 ◎ If path[index]'s slot-in-closed-tree is true, then decrease currentTargetHiddenSubtreeLevel by 1.
    4. %~index ~DECBY 1 ◎ Decrease index by 1.
11. %現-非可視~level ~LET %現-~targetの非可視~下位tree~level ◎ ↓
12. %最大-非可視~level ~LET %現-~targetの非可視~下位tree~level ◎ Let currentHiddenLevel and maxHiddenLevel be currentTargetHiddenSubtreeLevel.
13. %~index ~SET %現-~target~index ~MINUS 1 ◎ Set index to currentTargetIndex − 1.

14. ~WHILE［ %~index ~GTE 0 ］： ◎ While index is greater than or equal to 0:

    1. ~IF［ %経路[ %~index ] の`閉な~treeの根か$evP ~EQ ~T ］ ⇒ %現-非可視~level ~INCBY 1 ◎ If path[index]'s root-of-closed-tree is true, then increase currentHiddenLevel by 1.
    2. ~IF［ %現-非可視~level ~LTE %最大-非可視~level ］ ⇒ %~composed経路 に %経路[ %~index ] の`呼出n~target$evPを`前付加する$ ◎ If currentHiddenLevel is less than or equal to maxHiddenLevel, then prepend path[index]'s invocation target to composedPath.

    3. ~IF［ %経路[ %~index ] の`~slotは閉な~tree内か$evP ~EQ ~T ］： ◎ If path[index]'s slot-in-closed-tree is true:

       1. %現-非可視~level ~DECBY 1 ◎ Decrease currentHiddenLevel by 1.
       2. ~IF［ %最大-非可視~level ~GTE %現-非可視~level ］ ⇒ %最大-非可視~level ~SET %現-非可視~level ◎ If currentHiddenLevel is less than maxHiddenLevel, then set maxHiddenLevel to currentHiddenLevel.
    4. %~index ~DECBY 1 ◎ Decrease index by 1.
15. %現-非可視~level ~SET %現-~targetの非可視~下位tree~level ◎ ↓
16. %最大-非可視~level ~SET %現-~targetの非可視~下位tree~level ◎ Set currentHiddenLevel and maxHiddenLevel to currentTargetHiddenSubtreeLevel.
17. %~index ~SET %現-~target~index ~PLUS 1 ◎ Set index to currentTargetIndex + 1.

18. ~WHILE［ %~index ~LT %経路 の`~size$ ］： ◎ While index is less than path’s size:

    1. ~IF［ %経路[ %~index ] の`~slotは閉な~tree内か$evP ~EQ ~T ］ ⇒ %現-非可視~level ~INCBY 1 ◎ If path[index]'s slot-in-closed-tree is true, then increase currentHiddenLevel by 1.
    2. ~IF［ %現-非可視~level ~LTE %最大-非可視~level ］ ⇒ %~composed経路 に %経路[ %~index ] の`呼出n~target$evPを`付加する$ ◎ If currentHiddenLevel is less than or equal to maxHiddenLevel, then append path[index]'s invocation target to composedPath.

    3. ~IF［ %経路[ %~index ] の`閉な~treeの根か$evP ~EQ ~T ］： ◎ If path[index]'s root-of-closed-tree is true:

       1. %現-非可視~level ~DECBY 1 ◎ Decrease currentHiddenLevel by 1.
       2. ~IF［ %最大-非可視~level ~GTE %現-非可視~level ］ ⇒ %最大-非可視~level ~SET %現-非可視~level ◎ If currentHiddenLevel is less than maxHiddenLevel, then set maxHiddenLevel to currentHiddenLevel.
    4. %~index ~INCBY 1 ◎ Increase index by 1.
19. ~RET %~composed経路 ◎ Return composedPath.

@eventPhase 取得子~手続きは、 初期化-時の値を返す — それは、 次のいずれかをとるモノトスル（括弧内は数-値）： ◎ The eventPhase attribute must return the value it was initialized to, which must be one of the following:

@NONE (0)

まだ`配送-$されていない`~event$はこの相に属する。 ◎ Events not currently dispatched are in this phase.

@CAPTURING_PHASE (1)

`~event$が`~tree$に`関与-$している~objに向けて`配送-$されるとき、 ~eventがその`~target$に到達するまでは，この相に属する。 ◎ When an event is dispatched to an object that participates in a tree it will be in this phase before it reaches its target.

@AT_TARGET (2)

`~event$が`配送-$されるとき、 ~eventの`~target$上では，この相に属する。 ◎ When an event is dispatched it will be in this phase on its target.

@BUBBLING_PHASE (3)

`~event$が`~tree$に`関与-$している~objに向けて`配送-$されるとき、 ~eventがその`~target$に到達した後は，この相に属する。 ◎ When an event is dispatched to an object that participates in a tree it will be in this phase after it reaches its target.

`~event$の作成-時には、 この属性は $NONE に初期化するモノトスル。 ◎ Initially the attribute must be initialized to NONE.

`取消されたかを設定する@ ~algoは、 所与の ( `~event$ %~event ) に対し ⇒ ~IF［ %~event の $cancelable 属性~値 ~EQ ~T ］~AND［ %~event の`受動-~listener内か$ev ~EQ ~F ］ ⇒ %~event の`取消されたか$ev ~SET ~T ◎ To set the canceled flag, given an event event, if event’s cancelable attribute value is true and event’s in passive listener flag is unset, then set event’s canceled flag, and do nothing otherwise.

@preventDefault() ~method手続きは ⇒ `取消されたかを設定する$( コレ ) ◎ The preventDefault() method steps are to set the canceled flag with this.

注記： $preventDefault() を呼出しても効果がない局面もある。 ~UAには、 ~debugを援助するため，精確な~~原因を開発者~consoleに~logすることが奨励される。 ◎ There are scenarios where invoking preventDefault() has no effect. User agents are encouraged to log the precise cause in a developer console, to aid debugging.

@isTrusted 取得子~手続きは、 初期化-時の値を返す。 ◎ The isTrusted attribute must return the value it was initialized to.＼

`~event$の作成-時には、 この属性は ~F に初期化するモノトスル。 ◎ When an event is created the attribute must be initialized to false.

注記： $isTrusted は、 `~event$は （ $EventTarget.dispatchEvent() を利用してではなく） ~UAにより`配送-$されたかどうかを簡便に指示する。 唯一の旧来の例外は `click()＠~HTMLinteraction#dom-click$c であり，~UAに`~event$を［ $isTrusted 属性は ~F に初期化- ］した上で配送させる。 ◎ isTrusted is a convenience that indicates whether an event is dispatched by the user agent (as opposed to using dispatchEvent()). The sole legacy exception is click(), which causes the user agent to dispatch an event whose isTrusted attribute is initialized to false.

`~eventを初期化する@ ~algoは、 所与の ( %event, %type, %bubbles, %cancelable ) に対し， %event の各種~propを次のように設定するモノトスル ⇒＃ `初期化-済みか$ev ~SET ~T, `伝播を停止するか$ev ~SET ~F, `伝播を即時に停止するか$ev ~SET ~F, `取消されたか$ev ~SET ~F, $isTrusted 属性 ~SET ~F, `~target$ ~SET ~NULL, $type 属性 ~SET %type, $bubbles 属性 ~SET %bubbles, $cancelable 属性 ~SET %cancelable ◎ To initialize an event, with type, bubbles, and cancelable, run these steps: • Set event’s initialized flag. • Unset event’s stop propagation flag, stop immediate propagation flag, and canceled flag. • Set event’s isTrusted attribute to false. • Set event’s target to null. • Set event’s type attribute to type. • Set event’s bubbles attribute to bubbles. • Set event’s cancelable attribute to cancelable.

@initEvent(type, bubbles, cancelable) ~method手続きは： ◎ The initEvent(type, bubbles, cancelable) method steps are:

1. ~IF［ コレの`配送-中か$ev ~EQ ~T ］ ⇒ ~RET ◎ If this’s dispatch flag is set, then return.
2. `~eventを初期化する$( コレ, %type, %bubbles, %cancelable ) ◎ Initialize this with type, bubbles, and cancelable.

注記： $initEvent() は、 `~event$には構築子があるので冗長であり， $composed も設定できないが、 旧来の内容~用に~supportされる必要がある。 ◎ initEvent() is redundant with event constructors and incapable of setting composed. It has to be supported for legacy content.

@initCustomEvent(type, bubbles, cancelable, detail) ~method手続きは： ◎ The initCustomEvent(type, bubbles, cancelable, detail) method steps are:

1. ~IF［ コレの`配送-中か$ev ~EQ ~T ］ ⇒ ~RET ◎ If this’s dispatch flag is set, then return.
2. `~eventを初期化する$( コレ, %type, %bubbles, %cancelable ) ◎ Initialize this with type, bubbles, and cancelable.
3. コレの $detail 属性 ~SET %detail ◎ Set this’s detail attribute to detail.

［ $Event ~interface, それを継承する各~interface ］の構築子は、 `~event構築子@ と総称され，この仕様においては @Event.Event(type, eventInitDict), @CustomEvent.CustomEvent(type, eventInitDict) が該当する。 そのような~interface %~interface の`~event構築子$は、 次の手続きを走らすモノトスル： ◎ When a constructor of the Event interface, or of an interface that inherits from the Event interface, is invoked, these steps must be run, given the arguments type and eventInitDict:

1. %~event ~LET `~eventを内的に作成する$( %~interface, ~NULL, 現在時, %eventInitDict ) ◎ Let event be the result of running the inner event creation steps with this interface, null, now, and eventInitDict.
2. %~event の $Event.type 属性 ~SET %type に初期化する ◎ Initialize event’s type attribute to type.
3. ~RET %~event ◎ Return event.

`~eventを作成する@ ~algoは、 所与の ⇒＃ $Event または それを継承する~interface %~event~interface, ［`~realm$ ／ ~NULL］ %~realm （省略時は ~NULL ） ◎終 に対し： ◎ To create an event using eventInterface, which must be either Event or an interface that inherits from it, and optionally given a realm realm, run these steps: • If realm is not given, then set it to null.

1. %辞書~型 ~LET %~event~interface の構築子が引数に受容する`辞書$型 （ $EventInit またはそれを継承する辞書~型）

   【 $Event を継承する~interfaceであって，複数の構築子を宣言するものは、 現時点では，おそらく無い（今後も定義されないと見込まれる）。 】

   ◎ ↓

2. %辞書 ~LET `~IDL値に変換する$( ~JS `undefined^jv 値, %辞書~型 ) ◎ Let dictionary be the result of converting the JavaScript value undefined to the dictionary type accepted by eventInterface’s constructor. (This dictionary type will either be EventInit or a dictionary that inherits from it.)

   これは、 %辞書~型 に `required^c を伴う~memberが在る場合に働かない。 `課題 #600＠~DOMissue/600$ を見よ。 ◎ This does not work if members are required; see whatwg/dom#600.

3. %~event ~LET `~eventを内的に作成する$( ↓ ) ⇒＃ %~event~interface, %~realm, 当の~eventが通達している何かが生じた時刻†, %辞書 ◎ Let event be the result of running the inner event creation steps with eventInterface, realm, the time of the occurrence that the event is signaling, and dictionary.

   †注記： 例えば macOS においては、 入力~動作が生じた時刻は ^NSEvent ~objの ^timestamp ~propを介して可用になる。 ◎ In macOS the time of the occurrence for input actions is available via the timestamp property of NSEvent objects.

4. %~event の $Event.isTrusted 属性 ~SET ~T に初期化する ◎ Initialize event’s isTrusted attribute to true.
5. ~RET %~event ◎ Return event.

注記： `~eventを作成する$手続きは、 単純に`~eventを発火する$代わりに［ `~eventを作成する$, `~eventを配送する$ ］手続きを別々に呼出す必要がある，他の仕様からの利用が意味される。 これは、 ~eventの属性が既定の値に正しく初期化されることを確保する。 ◎ Create an event is meant to be used by other specifications which need to separately create and dispatch events, instead of simply firing them. It ensures the event’s attributes are initialized to the correct defaults.

`~eventを内的に作成する@ ~algoは、 所与の ( %~event~interface, %~realm, %時刻, %辞書 ) に対し： ◎ The inner event creation steps, given an eventInterface, realm, time, and dictionary, are as follows:

1. %~event ~LET `新たな~obj$( %~event~interface, %~realm ) — ただし， %~realm ~EQ ~NULL の場合は Web IDL に定義される既定の挙動に従う ◎ Let event be the result of creating a new object using eventInterface. If realm is non-null, then use that realm; otherwise, use the default behavior defined in Web IDL.

   これを書いている時点では、 ~Web~IDLは，まだこの既定の挙動を定義していない。 `whatwg/webidl 課題 #135＠https://github.com/whatwg/webidl/issues/135$ を見よ。 ◎ As of the time of this writing Web IDL does not yet define any default behavior; see whatwg/webidl#135.

2. %~event の`初期化-済みか$ev ~SET ~T ◎ Set event’s initialized flag.
3. %~event の $Event.timeStamp 属性 ~SET `相対的な粗い高分解能~時刻$( %時刻, %~event に`関連な大域~obj$ ) ◎ Initialize event’s timeStamp attribute to the relative high resolution coarse time given time and event’s relevant global object.
4. %辞書 を成す ~EACH( %~member → %値 ) に対し ⇒ ~IF［ %~event には %~member を`識別子$とする属性はある ］ ⇒ その属性 ~SET %値 に初期化する ◎ For each member → value of dictionary, if event has an attribute whose identifier is member, then initialize that attribute to value.
5. `適用-可能な仕様$にて %~event 用に`定義された各$( `~event構築-時の手続き$ %手続き ) に対し ⇒ %手続き( %~event, %辞書 ) ◎ Run the event constructing steps with event and dictionary.
6. ~RET %~event ◎ Return event.

`~option群を平坦~化する@ ~algoは、 所与の ( %~option群 ) に対し： ◎ To flatten options, run these steps:

1. ~RET %~option群 の型に応じて ⇒＃ $boolean ならば %~option群 ／ `辞書$ならば %~option群[ "$EventListenerOptions.capture" ] ◎ If options is a boolean, then return options. ◎ Return options["capture"].

`~option群をもっと平坦~化する@ ~algoは、 所与の ( %~option群 ) に対し： ◎ To flatten more options, run these steps:

1. ( %capture, %passive, %once, %signal ) ~LET ( `~option群を平坦~化する$( %~option群 ), ε, ~F, ε ) ◎ Let capture be the result of flattening options. ◎ Let once be false. ◎ Let passive and signal be null.
2. ~IF［ %~option群 は`辞書$である ］ ⇒＃ %passive ~SET %~option群[ "$AddEventListenerOptions.passive" ]； %once ~SET %~option群[ "$AddEventListenerOptions.once" ]； %signal ~SET %~option群[ "$AddEventListenerOptions.signal" ] ◎ If options is a dictionary: • Set once to options["once"]. • If options["passive"] exists, then set passive to options["passive"]. • If options["signal"] exists, then set signal to options["signal"].
3. ~IF［ %passive ~EQ ε ］ ⇒ %passive ~SET ~NULL ◎ ↑
4. ~IF［ %signal ~EQ ε ］ ⇒ %signal ~SET ~NULL ◎ ↑
5. ~RET ( %capture, %passive, %once, %signal ) ◎ Return capture, passive, once, and signal.

@EventTarget() 構築子~手続きは、 何もしない。 ◎ The new EventTarget() constructor steps are to do nothing.

注記： 他所に言明される既定により、 返される $EventTarget の`親~targetを取得する$~algoは，~NULL を返すことになり、［ `作動化の挙動$, `旧来の作動化~前の挙動$, `旧来の作動化~取消~時の挙動$ ］は無い。 ◎ Because of the defaults stated elsewhere, the returned EventTarget’s get the parent algorithm will return null, and it will have no activation behavior, legacy-pre-activation behavior, or legacy-canceled-activation behavior.

注記： 将来には、 `親~targetを取得する$~custom~algoも許容され得る。 作者は、 それが自身の~programに有用になるなら知らせてほしい。 今の所は、 作者が作成したどの $EventTarget も，~tree構造には関与しない。 ◎ In the future we could allow custom get the parent algorithms. Let us know if this would be useful for your programs. For now, all author-created EventTargets do not participate in a tree structure.

`既定の受動-値@ は、 所与の ( ~event型 %型, $EventTarget ~obj %~target ) に対し ⇒ ~RET ~IS ~AND↓：

• %型 ~IN { `touchstart^l, `touchmove^l, `wheel^l, `mousewheel^l } `TOUCH-EVENTS$r `UIEVENTS$r

• ~OR↓：

  • %~target は $Window ~objである
  • ［ %~target は`~node$である ］~AND［ %~target の`~node文書$ %文書 は次を満たす ］ ⇒ %~target ~IN { %文書, %文書 の`文書~要素$, %文書 の`~body要素$ } `HTML$r

`~event~listenerを追加する@ ~algoは、 所与の ( $EventTarget ~obj %~target, `~event~listener$ %~listener ) に対し： ◎ To add an event listener, given an EventTarget object eventTarget and an event listener listener, run these steps:

1. ~IF［ %~target は $ServiceWorkerGlobalScope ~objである ］~AND［ %~target の`~sw$SWGの`~script資源$の`これまでに評価されたか$ ~EQ ~T ］~AND［ %~listener の`型$evLは ある`~sw~event$の $type 属性~値に合致する† ］`SERVICE-WORKERS$r ⇒ `~consoleに警告を報告する$( “期待される結果を与えないであろう” ) ◎ If eventTarget is a ServiceWorkerGlobalScope object, its service worker’s script resource’s has ever been evaluated flag is set, and listener’s type matches the type attribute value of any of the service worker events, then report a warning to the console that this might not give the expected results. [SERVICE-WORKERS]

   【† そのような~eventの~instanceが在ることも要求しているかのように解釈できる条件だが、 単に，~sw~eventの ^type 属性~値がとり得る値たちが成す集合に入ることを意味するのかも？ （しかしながら、 `~event~listenerを除去する$ときのように，明示的な用語 “`取扱う~event型の集合$” を利用していないので、 実際にその解釈が意図されているのかもしれない。） 】

2. %通達 ~LET %~listener の`通達$evL ◎ ↓
3. ~IF［ %通達 ~NEQ ~NULL ］~AND［ %通達 は`中止-済み$aBである ］ ⇒ ~RET ◎ If listener’s signal is not null and is aborted, then return.
4. ~IF［ %~listener の`~callback$evL ~EQ ~NULL ］ ⇒ ~RET ◎ If listener’s callback is null, then return.
5. ~IF［ %~listener の`受動的か$evL ~EQ ~NULL ］ ⇒ %~listener の`受動的か$evL ~SET `既定の受動-値$( %~listener の`型$evL, %~target ) ◎ If listener’s passive is null, then set it to the default passive value given listener’s type and eventTarget.
6. ~IF［ 次を満たす`~event~listener$ %L は無い ］… ⇒ ［ %L ~IN %~target の`~event~listener~list$ ］~AND［ %L の ( `型$evL, `~callback$evL, `捕捉するか$evL ) ~EQ %~listener の ( `型$evL, `~callback$evL, `捕捉するか$evL ) ］ ◎終 …ならば ⇒ %~target の`~event~listener~list$に %~listener を`付加する$ ◎ If eventTarget’s event listener list does not contain an event listener whose type is listener’s type, callback is listener’s callback, and capture is listener’s capture, then append listener to eventTarget’s event listener list.
7. ~IF［ %通達 ~NEQ ~NULL ］ ⇒ `通達に~algoを追加する$( %通達, 次を走らす中止-手続き ) ⇒ `~event~listenerを除去する$( %~target, %~listener ) ◎ If listener’s signal is not null, then add the following abort steps to it: • Remove an event listener with eventTarget and listener.

注記： ［ `~event~listenerを追加する$ ］の概念は、［ `~event~handler$ `HTML$r が同じ `code path^en【！＊】を利用する ］ことを確保するためにある。 ◎ The add an event listener concept exists to ensure event handlers use the same code path. [HTML]

@addEventListener(type, callback, options) ~method手続きは： ◎ The addEventListener(type, callback, options) method steps are:

1. ( %捕捉するか, %受動的か, %一度限りか, %通達 ) ~LET `~option群をもっと平坦~化する$( %options ) ◎ Let capture, passive, once, and signal be the result of flattening more options.
2. `~event~listenerを追加する$( コレ, 次のように設定された`~event~listener$ ) ⇒＃ `型$evL ~SET %type , `~callback$evL ~SET %callback , `捕捉するか$evL ~SET %捕捉するか , `受動的か$evL ~SET %受動的か , `一度限りか$evL ~SET %一度限りか, `通達$evL ~SET %通達 ◎ Add an event listener with this and an event listener whose type is type, callback is callback, capture is capture, passive is passive, once is once, and signal is signal.

`~event~listenerを除去する@ ~algoは、 所与の ( $EventTarget ~obj %~target, `~event~listener$ %~listener ) に対し： ◎ To remove an event listener, given an EventTarget object eventTarget and an event listener listener, run these steps:

1. ~IF［ %~target は $ServiceWorkerGlobalScope ~objである ］~AND［ %~listener の`型$evL ~IN %~target の`~sw$SWGが`取扱う~event型の集合$ ］`SERVICE-WORKERS$r ⇒ `~consoleに警告を報告する$( “期待される結果を与えないであろう” ) ◎ If eventTarget is a ServiceWorkerGlobalScope object and its service worker’s set of event types to handle contains listener’s type, then report a warning to the console that this might not give the expected results. [SERVICE-WORKERS]
2. %~listener の`除去-済みか$evL ~SET ~T ◎ Set listener’s removed to true and＼
3. %~target の`~event~listener~list$から %~listener を`除去する$ ◎ remove listener from eventTarget’s event listener list.

注記： ~HTMLは、 ~event~handlerを定義するために これを必要とする。 `HTML$r ◎ HTML needs this to define event handlers. [HTML]

`~event~listenerをすべて除去する@ ~algoは、 所与の ( $EventTarget ~obj %~target ) に対し ⇒ %~target の`~event~listener~list$を成す ~EACH( %~listener ) に対し ⇒ `~event~listenerを除去する$( %~target, %~listener ) ◎ To remove all event listeners, given an EventTarget object eventTarget, for each listener of eventTarget’s event listener list, remove an event listener with eventTarget and listener.

注記： ~HTMLは、 ^document.open() を定義するために これを必要とする。 `HTML$r ◎ HTML needs this to define document.open(). [HTML]

@removeEventListener(type, callback, options) ~method手続きは： ◎ The removeEventListener(type, callback, options) method steps are:

1. %capture ~LET `~option群を平坦~化する$( %options ) ◎ Let capture be the result of flattening options.
2. ~IF［ 次を満たす`~event~listener$ %~listener は在る ］… ⇒ ［ %~listener ~IN コレの`~event~listener~list$ ］~AND［ %~listener の ( `型$evL, `~callback$evL, `捕捉するか$evL ) ~EQ ( %type, %callback, %capture ) ］ ◎終 …ならば ⇒ `~event~listenerを除去する$( コレ, %~listener ) ◎ If this’s event listener list contains an event listener whose type is type, callback is callback, and capture is capture, then remove an event listener with this and that event listener.

注記： ~event~listener~listが ( `type^evL, `callback^evL, `capture^evL ) が互いに等しい複数の~event~listenerを包含することはない。 それは、 `~event~listenerを追加する$ときに防止される。 ◎ The event listener list will not contain multiple event listeners with equal type, callback, and capture, as add an event listener prevents that.

@dispatchEvent(event) ~method手続きは： ◎ The dispatchEvent(event) method steps are:

1. ~IF［ %event の`配送-中か$ev ~EQ ~T ］~OR［ %event の`初期化-済みか$ev ~EQ ~F ］ ⇒ ~THROW `InvalidStateError$E ◎ If event’s dispatch flag is set, or if its initialized flag is not set, then throw an "InvalidStateError" DOMException.
2. %event の $isTrusted 属性 ~SET ~F に初期化する ◎ Initialize event’s isTrusted attribute to false.
3. ~RET `~eventを配送する$( コレ, %event ) ◎ Return the result of dispatching event to this.

`~sw~fetch~event~listener~callback群を得する旧来の手続き@ は、 所与の ( $ServiceWorkerGlobalScope %大域~obj ) に対し，［ $EventListener ~objたちが成す`~list$ ］を返す： ◎ To legacy-obtain service worker fetch event listener callbacks given a ServiceWorkerGlobalScope global, run these steps. They return a list of EventListener objects.

1. %~callback群 ~LET « » ◎ Let callbacks be « ».
2. %大域~obj の`~event~listener~list$を成す ~EACH( %~listener ) に対し ⇒ ~IF［ %~listener の`型$evL ~EQ `fetch^l ］~AND［ %~listener の`~callback$evL ~NEQ ~NULL ］ ⇒ %~callback群 に %~listener の`~callback$evLを`付加する$ ◎ For each listener of global’s event listener list: • If listener’s type is "fetch", and listener’s callback is not null, then append listener’s callback to callbacks.
3. ~RET %~callback群 ◎ Return callbacks.

`~eventを配送する@ ~algoは、 所与の ( %~target, `~event$ %~event, %~targetを上書きするか ~IN { `~targetを上書きする^i, ε }（省略時は ε ） ) に対し： ◎ To dispatch an event to a target, with an optional legacy target override flag and an optional legacyOutputDidListenersThrowFlag, run these steps:

【 この手続きは、 “%~target に向けて（~eventを）配送する” のような形の句でも参照される （例えば，地の文の中で）。 】

【 原文では，省略可能な引数として［ `INDEXEDDB$r のみから利用される %legacyOutputDidListenersThrowFlag ］も — 参照渡しとして — とるが、 この訳では，［ その仕様に定義される関連な~eventに`（旧来の）~listenerは投出したか$を結付ける ］よう定義することにより［ この引数の受け渡しに関する記述 ］を`簡素化する＠#_legacyOutputDidListenersThrowFlag$。 】

1. %~event の`配送-中か$ev ~SET ~T ◎ Set event’s dispatch flag.

2. %上書きする~target ~LET %~targetを上書きするか に応じて ⇒＃ `~targetを上書きする^i ならば %~target に`結付けられた文書$ `HTML$r ／ ε ならば %~target ◎ Let targetOverride be target, if legacy target override flag is not given, and target’s associated Document otherwise. [HTML]

   注記： %~targetを上書きするか は，旧来の~flagであり、 ~HTMLからのみ, それも %~target が $Window ~objである場合に限り，非 ε にされる。 ◎ legacy target override flag is only used by HTML and only when target is a Window object.

3. %作動化~target ~LET ~NULL ◎ Let activationTarget be null.
4. %関係する~target ~LET %~event の`関係する~target$を %~target に向けて`~targetし直す$ ◎ Let relatedTarget be the result of retargeting event’s relatedTarget against target.
5. %~targetたちを~clearするか ~LET ~F ◎ Let clearTargets be false.

6. ~IF［ %~target ~NEQ %関係する~target ］~OR［ %~target ~EQ %~event の`関係する~target$ ］： ◎ If target is not relatedTarget or target is event’s relatedTarget:

   1. %~touch~target群 ~LET « » ◎ Let touchTargets be a new list.
   2. %~event の`~touch~target~list$を成す ~EACH( %~touch~target ) に対し ⇒ %~touch~target群 に次の結果を`付加する$ ⇒ %~touch~target を %~target に向けて`~targetし直す$ ◎ For each touchTarget of event’s touch target list, append the result of retargeting touchTarget against target to touchTargets.
   3. `~event経路に付加する$( ↓ ) ⇒＃ %~event, %~target, %上書きする~target, %関係する~target, %~touch~target群, ~F ◎ Append to an event path with event, target, targetOverride, relatedTarget, touchTargets, and false.
   4. %作動化~eventか ~LET ~IS［ %~event は $MouseEvent ~objである ］~AND［ %~event の $type 属性 ~EQ `click^l ］ ◎ Let isActivationEvent be true, if event is a MouseEvent object and event’s type attribute is "click"; otherwise false.
   5. ~IF［ %作動化~eventか ~EQ ~T ］~AND［ %~target には`作動化の挙動$が有る ］ ⇒ %作動化~target ~SET %~target ◎ If isActivationEvent is true and target has activation behavior, then set activationTarget to target.
   6. %~slot可能 ~LET［ 次が満たされるならば %~target ／ ~ELSE_ ~NULL ］ ⇒ ［ %~target は`~slot可能$である ］~AND［ %~target の`割当-先~slot$ ~NEQ ~NULL ］ ◎ Let slottable be target, if target is a slottable and is assigned, and null otherwise.
   7. %~slotは閉な~tree内か ~LET ~F ◎ Let slot-in-closed-tree be false.
   8. %親 ~LET %~target の`親~targetを取得する$( %~event ) ◎ Let parent be the result of invoking target’s get the parent with event.

   9. ~WHILE［ %親 ~NEQ ~NULL ］： ◎ While parent is non-null:

      1. ~IF［ %~slot可能 ~NEQ ~NULL ］： ◎ If slottable is non-null:

         1. ~Assert： %親 は`~slot$である ◎ Assert: parent is a slot.
         2. %~slot可能 ~SET ~NULL ◎ Set slottable to null.
         3. ~IF［ %親 の`根$は［ `~shadow根$である ］~AND［ `~mode$sR ~EQ `closed^l ］を満たす ］ ⇒ %~slotは閉な~tree内か ~SET ~T ◎ If parent’s root is a shadow root whose mode is "closed", then set slot-in-closed-tree to true.
      2. ~IF［ %親 は`~slot可能$である ］~AND［ %親 の`割当-先~slot$ ~NEQ ~NULL ］ ⇒ %~slot可能 ~SET %親 ◎ If parent is a slottable and is assigned, then set slottable to parent.
      3. %関係する~target ~LET %関係する~target を %親 に向けて`~targetし直す$ ◎ Let relatedTarget be the result of retargeting event’s relatedTarget against parent.
      4. %~touch~target群 ~LET « » ◎ Let touchTargets be a new list.
      5. %~event の`~touch~target~list$を成す ~EACH( %~touch~target ) に対し ⇒ %~touch~target群 に次の結果を`付加する$ ⇒ %~touch~target を %親 に向けて`~targetし直す$ ◎ For each touchTarget of event’s touch target list, append the result of retargeting touchTarget against parent to touchTargets.

      6. ~IF［ %親 は $Window ~objである ］~OR［［ %親 は`~node$である ］~AND［ %~target の`根$ は %親 の`~shadowも含めた広義-先祖$である ］］： ◎ If parent is a Window object, or parent is a node and target’s root is a shadow-including inclusive ancestor of parent:

         1. ~IF［ %作動化~eventか ~EQ ~T ］~AND［ %~event の $bubbles 属性 ~EQ ~T ］~AND［ %作動化~target ~EQ ~NULL ］~AND［ %親 には`作動化の挙動$が有る ］ ⇒ %作動化~target ~SET %親 ◎ If isActivationEvent is true, event’s bubbles attribute is true, activationTarget is null, and parent has activation behavior, then set activationTarget to parent.

         2. `~event経路に付加する$( ↓ ) ⇒＃ %~event, %親, ~NULL, %関係する~target, %~touch~target群, %~slotは閉な~tree内か ◎ Append to an event path with event, parent, null, relatedTarget, touchTargets, and slot-in-closed-tree.
      7. ~ELIF［ %親 ~EQ %関係する~target ］ ⇒ %親 ~SET ~NULL ◎ Otherwise, if parent is relatedTarget, then set parent to null.

      8. ~ELSE： ◎ Otherwise:

         1. %~target ~SET %親 ◎ Set target to parent.
         2. ~IF［ %作動化~eventか ~EQ ~T ］~AND［ %作動化~target ~EQ ~NULL ］~AND［ %~target には`作動化の挙動$が有る ］ ⇒ %作動化~target ~SET %~target ◎ If isActivationEvent is true, activationTarget is null, and target has activation behavior, then set activationTarget to target.
         3. `~event経路に付加する$( ↓ ) ⇒＃ %~event, %親, %~target, %関係する~target, %~touch~target群, %~slotは閉な~tree内か ◎ Append to an event path with event, parent, target, relatedTarget, touchTargets, and slot-in-closed-tree.
      9. ~IF［ %親 ~NEQ ~NULL ］ ⇒ %親 ~SET %親 の`親~targetを取得する$( %~event ) ◎ If parent is non-null, then set parent to the result of invoking parent’s get the parent with event.
      10. %~slotは閉な~tree内か ~SET ~F ◎ Set slot-in-closed-tree to false.
   10. %~target~clear用の構造体 ~LET %~event の`経路$を成す~itemのうち，次を満たす`最後のもの？$ ⇒ `~shadow調整-済み~target$evP ~NEQ ~NULL ◎ Let clearTargetsStruct be the last struct in event’s path whose shadow-adjusted target is non-null.
   11. ~Assert： %~target~clear用の構造体 ~NEQ ~NULL 【この段は、この訳による補完。】

   12. ~IF［ ~AND↓ を満たす`~node$ %~node は在る ］…

       • %~node の`根$は`~shadow根$である

       • ~OR↓

         • %~node ~EQ %~target~clear用の構造体 の`~shadow調整-済み~target$evP
         • %~node ~EQ %~target~clear用の構造体 の`関係する~target$evP
         • %~node ~IN %~target~clear用の構造体 の`~touch~target~list$evP

       …ならば ⇒ %~targetたちを~clearするか ~SET ~T

       ◎ If clearTargetsStruct’s shadow-adjusted target, clearTargetsStruct’s relatedTarget, or an EventTarget object in clearTargetsStruct’s touch target list is a node whose root is a shadow root: set clearTargets to true.
   13. ~IF［ %作動化~target ~NEQ ~NULL ］~AND［ %作動化~target には`旧来の作動化~前の挙動$が有る ］ ⇒ その挙動を走らす ◎ If activationTarget is non-null and activationTarget has legacy-pre-activation behavior, then run activationTarget’s legacy-pre-activation behavior.

   14. %~event の`経路$を成す ~EACH( %構造体 ) に対し，逆順に： ◎ For each struct of event’s path, in reverse order:

       1. %~event の $eventPhase 属性 ~SET ［ %構造体 の`~shadow調整-済み~target$evP ~NEQ ~NULL ならば $AT_TARGET ／ ~ELSE_ $CAPTURING_PHASE ］ ◎ If struct’s shadow-adjusted target is non-null, then set event’s eventPhase attribute to AT_TARGET. ◎ Otherwise, set event’s eventPhase attribute to CAPTURING_PHASE.
       2. `~listenerを呼出す$( %構造体, %~event, `capturing^l ) ◎ Invoke with struct, event, "capturing", and legacyOutputDidListenersThrowFlag if given.

   15. %~event の`経路$を成す ~EACH( %構造体 ) に対し： ◎ For each struct of event’s path:

       1. ~IF［ %構造体 の`~shadow調整-済み~target$evP ~NEQ ~NULL ］ ⇒ %~event の $eventPhase 属性 ~SET $AT_TARGET ◎ If struct’s shadow-adjusted target is non-null, then set event’s eventPhase attribute to AT_TARGET.

       2. ~ELSE： ◎ Otherwise:

          1. ~IF［ %~event の $bubbles 属性 ~EQ ~F ］ ⇒ ~CONTINUE ◎ If event’s bubbles attribute is false, then continue.
          2. %~event の $eventPhase 属性 ~SET $BUBBLING_PHASE ◎ Set event’s eventPhase attribute to BUBBLING_PHASE.
       3. `~listenerを呼出す$( %構造体, %~event, `bubbling^l ) ◎ Invoke with struct, event, "bubbling", and legacyOutputDidListenersThrowFlag if given.
7. %~event の $eventPhase 属性 ~SET $NONE ◎ Set event’s eventPhase attribute to NONE.
8. %~event の $currentTarget 属性 ~SET ~NULL ◎ Set event’s currentTarget attribute to null.
9. %~event の`経路$ ~SET « » ◎ Set event’s path to the empty list.
10. %~event の ⇒＃ `配送-中か$ev ~SET ~F, `伝播を停止するか$ev ~SET ~F, `伝播を即時に停止するか$ev ~SET ~F ◎ Unset event’s dispatch flag, stop propagation flag, and stop immediate propagation flag.

11. ~IF［ %~targetたちを~clearするか ~EQ ~T ］ ⇒ %~event の ⇒＃ `~target$ ~SET ~NULL `関係する~target$ ~SET ~NULL `~touch~target~list$ ~SET « » ◎ If clearTargets is true: • Set event’s target to null. • Set event’s relatedTarget to null. • Set event’s touch target list to the empty list.

12. ~IF［ %作動化~target ~NEQ ~NULL ］： ◎ If activationTarget is non-null:

    1. ~IF［ %~event の`取消されたか$ev ~EQ ~F ］ ⇒ %作動化~target の`作動化の挙動$( %~event ) ◎ If event’s canceled flag is unset, then run activationTarget’s activation behavior with event.
    2. ~ELIF［ %作動化~target には`旧来の作動化~取消~時の挙動$が有る ］ ⇒ その挙動を走らす ◎ Otherwise, if activationTarget has legacy-canceled-activation behavior, then run activationTarget’s legacy-canceled-activation behavior.
13. ~RET ~IS［ %~event の`取消されたか$ev ~EQ ~F ］ ◎ Return false if event’s canceled flag is set; otherwise true.

`~event経路に付加する@ ~algoは、 所与の ⇒＃ %~event, %呼出n~target, %~shadow調整-済み~target, %関係する~target, %~touch~target群, %~slotは閉な~tree内か ◎終 に対し： ◎ To append to an event path, given an event, invocationTarget, shadowAdjustedTarget, relatedTarget, touchTargets, and a slot-in-closed-tree, run these steps:

1. %呼出n~targetは~shadow~tree内か ~LET ~IS［ %呼出n~target は`~node$である ］~AND［ %呼出n~target の`根$は`~shadow根$である ］ ◎ Let invocationTargetInShadowTree be false. ◎ If invocationTarget is a node and its root is a shadow root, then set invocationTargetInShadowTree to true.
2. %閉な~treeの根か ~LET ~IS［ %呼出n~target は`~shadow根$である ］~AND［ %呼出n~target の`~mode$sR ~EQ `closed^l ］ ◎ Let root-of-closed-tree be false. ◎ If invocationTarget is a shadow root whose mode is "closed", then set root-of-closed-tree to true.
3. %~event の`経路$に次を`付加する$ ⇒ 新たな`構造体$ — その ⇒＃ `呼出n~target$evP ~SET %呼出n~target, `呼出n~targetは~shadow~tree内か$evP ~SET %呼出n~targetは~shadow~tree内か `~shadow調整-済み~target$evP ~SET %~shadow調整-済み~target, `関係する~target$evP ~SET %関係する~target, `閉な~treeの根か$evP ~SET %閉な~treeの根か, `~touch~target~list$evP ~SET %~touch~target群 `~slotは閉な~tree内か$evP ~SET %~slotは閉な~tree内か ◎ Append a new struct to event’s path whose invocation target is invocationTarget, invocation-target-in-shadow-tree is invocationTargetInShadowTree, shadow-adjusted target is shadowAdjustedTarget, relatedTarget is relatedTarget, touch target list is touchTargets, root-of-closed-tree is root-of-closed-tree, and slot-in-closed-tree is slot-in-closed-tree.

`~listenerを呼出す@ ~algoは、 所与の ( %構造体, %~event, %相 ) に対し： ◎ To invoke, given a struct, event, phase, and an optional legacyOutputDidListenersThrowFlag, run these steps:

1. %~event の`~target$ ~SET ［ %~event の`経路$内の［ %構造体 または %構造体 に先行する構造体 ］のうち，［ `~shadow調整-済み~target$evP ~NEQ ~NULL ］を満たすもののうち，最後の構造体 ］の`~shadow調整-済み~target$evP ◎ Set event’s target to the shadow-adjusted target of the last struct in event’s path, that is either struct or preceding struct, whose shadow-adjusted target is non-null.
2. %~event の`関係する~target$ ~SET %構造体 の`関係する~target$evP ◎ Set event’s relatedTarget to struct’s relatedTarget.
3. %~event の`~touch~target~list$ ~SET %構造体 の`~touch~target~list$evP ◎ Set event’s touch target list to struct’s touch target list.
4. ~IF［ %~event の`伝播を停止するか$ev ~EQ ~T ］ ⇒ ~RET ◎ If event’s stop propagation flag is set, then return.
5. %~event の $currentTarget 属性 ~SET %構造体 の`呼出n~target$evPに初期化する ◎ Initialize event’s currentTarget attribute to struct’s invocation target.

6. %~listener群 ~LET %構造体 の`呼出n~target$evPの`~event~listener~list$を`~cloneする$ ◎ Let listeners be a clone of event’s currentTarget attribute value’s event listener list.

   注記： これは、 この時点以降に追加された~event~listenerは，走らせないようにする。 除去については、 `除去-済みか$evL ~fieldに因り，依然として効果を及ぼすことに注意。 ◎ This avoids event listeners added after this point from being run. Note that removal still has an effect due to the removed field.

7. %呼出n~targetは~shadow~tree内か ~LET %構造体 の`呼出n~targetは~shadow~tree内か$evP ◎ Let invocationTargetInShadowTree be struct’s invocation-target-in-shadow-tree.
8. %見出されたか ~LET `~listenerを内的に呼出す$( ↓ ) ⇒＃ %~event, %~listener群, %相, %呼出n~targetは~shadow~tree内か ◎ Let found be the result of running inner invoke with event, listeners, phase, invocationTargetInShadowTree, and legacyOutputDidListenersThrowFlag if given.

9. ~IF［ %見出されたか ~EQ ~F ］~AND［ %~event の $isTrusted 属性 ~EQ ~T ］~AND［ %~event の $type 属性~値は［ 下の表tの 1 列目に挙げるいずれかの文字列 ］に `~ASCII大小無視$で合致する ］… ◎ If found is false and event’s isTrusted attribute is true: ◎ Let originalEventType be event’s type attribute value. ◎ If event’s type attribute value is a match for any of the strings in the first column in the following table, set event’s type attribute value to the string in the second column on the same row as the matching string, and return otherwise.

   ~event型 ◎ Event type	旧来の~event型 ◎ Legacy event type
   `animationend^l	`webkitAnimationEnd^l
   `animationiteration^l	`webkitAnimationIteration^l
   `animationstart^l	`webkitAnimationStart^l
   `transitionend^l	`webkitTransitionEnd^l

   …ならば：

   1. %元の~event型 ~LET %~event の $type 属性~値 ◎ ↑
   2. %~event の $type 属性 ~SET 合致した行の 2 列目に与える文字列 ◎ ↑
   3. `~listenerを内的に呼出す$( ↓ ) ⇒＃ %~event, %~listener群, %相, %呼出n~targetは~shadow~tree内か ◎ Inner invoke with event, listeners, phase, invocationTargetInShadowTree, and legacyOutputDidListenersThrowFlag if given.
   4. %~event の $type 属性 ~SET %元の~event型 ◎ Set event’s type attribute value to originalEventType.

`~listenerを内的に呼出す@ ~algoは、 所与の ⇒＃ %~event, %~listener群, %相, %呼出n~targetは~shadow~tree内か ◎終 に対し： ◎ To inner invoke, given an event, listeners, phase, invocationTargetInShadowTree, and an optional legacyOutputDidListenersThrowFlag, run these steps:

1. %見出されたか ~LET ~F ◎ Let found be false.

2. %~listener群 を成す ~EACH( `~event~listener$ %~listener ) に対し： ◎ For each listener of listeners, whose removed is false:

   1. ~IF［ %~listener の`除去-済みか$evL ~EQ ~T ］ ⇒ ~CONTINUE ◎ ↑
   2. ~IF［ %~listener の`型$evL ~NEQ %~event の $type 属性~値 ］ ⇒ ~CONTINUE ◎ If event’s type attribute value is not listener’s type, then continue.
   3. %見出されたか ~SET ~T ◎ Set found to true.
   4. ~IF［ %相 ~EQ `capturing^l ］~AND［ %~listener の`捕捉するか$evL ~EQ ~F ］ ⇒ ~CONTINUE ◎ If phase is "capturing" and listener’s capture is false, then continue.
   5. ~IF［ %相 ~EQ `bubbling^l ］~AND［ %~listener の`捕捉するか$evL ~EQ ~T ］ ⇒ ~CONTINUE ◎ If phase is "bubbling" and listener’s capture is true, then continue.
   6. ~IF［ %~listener の`一度限りか$evL ~EQ ~T ］ ⇒ `~event~listenerを除去する$( %~event の $currentTarget 属性~値, %~listener ) ◎ If listener’s once is true, then remove an event listener given event’s currentTarget attribute value and listener.
   7. %大域~obj ~LET %~listener の`~callback$evLが`属する~realm$の`大域~obj$rM ◎ Let global be listener callback’s associated realm’s global object.
   8. %現在の~event ~LET $undefined ◎ Let currentEvent be undefined.

   9. ~IF［ %大域~obj は $Window ~objである ］： ◎ If global is a Window object:

      1. %現在の~event ~SET %大域~obj の`現在の~event$ ◎ Set currentEvent to global’s current event.
      2. ~IF［ %呼出n~targetは~shadow~tree内か ~EQ ~F ］ ⇒ %大域~obj の`現在の~event$ ~SET %~event ◎ If invocationTargetInShadowTree is false, then set global’s current event to event.
   10. ~IF［ %~listener の`受動的か$evL ~EQ ~T ］ ⇒ %~event の`受動-~listener内か$ev ~SET ~T ◎ If listener’s passive is true, then set event’s in passive listener flag.
   11. ~IF［ %大域~obj は $Window ~objである ］ ⇒ `~event~listener用に計時~報を記録する$( %~event, %~listener ) ◎ If global is a Window object, then record timing info for event listener given event and listener.

   12. `利用元~objの演算を~callする$( ↓ ) ⇒＃ %~listener の`~callback$evL, `handleEvent^l, « %~event », %~event の$currentTarget 属性~値 ◎ Call a user object’s operation with listener’s callback, "handleEvent", « event », and event’s currentTarget attribute value.＼

       例外 %例外 が投出されたときは、 ~catchして： ◎ If this throws an exception exception:

       1. `例外を報告する$( %例外, %~listener の`~callback$evLに対応する~JS~objが`属する~realm$の`大域~obj$rM ) ◎ Report exception for listener’s callback’s corresponding JavaScript object’s associated realm’s global object.

       2. ~IF［ %~event には`（旧来の）~listenerは投出したか$が結付けられている ］ ⇒ %~event の`（旧来の）~listenerは投出したか$ ~SET ~T ◎ Set legacyOutputDidListenersThrowFlag if given.

          注記： `INDEXEDDB$r のみが、 これを利用する。 ◎ The legacyOutputDidListenersThrowFlag is only used by Indexed Database API. [INDEXEDDB]

   13. %~event の`受動-~listener内か$ev ~SET ~F ◎ Unset event’s in passive listener flag.
   14. ~IF［ %大域~obj は $Window ~objである ］ ⇒ %大域~obj の`現在の~event$ ~SET %現在の~event ◎ If global is a Window object, then set global’s current event to currentEvent.
   15. ~IF［ %~event の`伝播を即時に停止するか$ev ~EQ ~T ］ ⇒ ~BREAK ◎ If event’s stop immediate propagation flag is set, then break.
3. ~RET %見出されたか ◎ Return found.

1. %~event ~LET `~eventを作成する$( %~event構築子, %~target に`関連な~realm$ ) ◎ Let event be the result of creating an event given eventConstructor, in the relevant realm of target.
2. %~event の $type 属性 ~SET %e に初期化する ◎ Initialize event’s type attribute to e.

3. %~event の各種~IDL属性を %記述 に従って初期化する ◎ Initialize any other IDL attributes of event as described in the invocation of this algorithm.

   注記： ここでは［ $isTrusted 属性 ~SET ~F ］にすることも許容される。 ◎ This also allows for the isTrusted attribute to be set to false.

4. ~RET `~eventを配送する$( %~target, %~event, %~targetを上書きするか ) ◎ Return the result of dispatching event at target, with legacy target override flag set if set.

注記： ~DOMの文脈における “`~eventを発火する$” とは、 `~event$を［ `作成-＠#concept-event-create$して, 初期化して, `配送-$する ］ことの略語であり，この処理nを容易に書けるようにするためにある。 ◎ Fire in the context of DOM is short for creating, initializing, and dispatching an event. Fire an event makes that process easier to write down.

@AbortController() 構築子~手続きは ⇒ コレの`通達$aC ~SET `新たな~obj$( $AbortSignal ) ◎ The new AbortController() constructor steps are: • Let signal be a new AbortSignal object. • Set this’s signal to signal.

`中止-を通達する@aC ~algoは、 所与の ( $AbortController %制御器, %事由 （省略時は ε ） ) に対し ⇒ `中止-を通達する$aB( %制御器 の`通達$aC, %事由 ) ◎ To signal abort on an AbortController controller with an optional reason, signal abort on controller’s signal with reason if it is given.

静的な @abort(reason) ~method手続きは： ◎ The static abort(reason) method steps are:

1. %通達 ~LET `新たな~obj$( $AbortSignal ) ◎ Let signal be a new AbortSignal object.
2. %通達 の`中止-事由$aB ~SET %reason に応じて ⇒＃ ε ならば新たな `AbortError$E 例外 ／ ~ELSE_ %reason ◎ Set signal’s abort reason to reason if it is given; otherwise to a new "AbortError" DOMException.
3. ~RET %通達 ◎ Return signal.

静的な @timeout(milliseconds) ~method手続きは： ◎ The static timeout(milliseconds) method steps are:

1. %通達 ~LET `新たな~obj$( $AbortSignal ) ◎ Let signal be a new AbortSignal object.
2. %大域~obj ~LET %通達 に`関連な大域~obj$ ◎ Let global be signal’s relevant global object.

3. `手続きを~timeout後に走らす$( %大域~obj, `AbortSignal-timeout^l, %milliseconds, 次の手続き ) ◎ Run steps after a timeout given global, "AbortSignal-timeout", milliseconds, and the following step:

   手続きは ⇒ `大域~taskを~queueする$( `~timer~task~source$, %大域~obj, 次の手続き )

   手続きは ⇒ `中止-を通達する$aB( %通達, 新たな `TimeoutError$E 例外 )

   ◎ • Queue a global task on the timer task source given global to signal abort given signal and a new "TimeoutError" DOMException.

   この~timeoutまでの間は、 %通達 の `abort$et ~event用に~event~listenerが登録されている限り， %大域~obj から %通達 への強い参照があるモノトスル。 ◎ For the duration of this timeout, if signal has any event listeners registered for its abort event, there must be a strong reference from global to signal.

4. ~RET %通達 ◎ Return signal.

静的な @any(signals) ~method手続きは ⇒ ~RET `依存~中止-通達を作成する$( %signals, $AbortSignal, `現在の~realm$ ) ◎ The static any(signals) method steps are to return the result of creating a dependent abort signal from signals using AbortSignal and the current realm.

@throwIfAborted() ~method手続きは ⇒ ~IF［ コレは`中止-済み$aBである ］ ⇒ コレの`中止-事由$aBを投出する ◎ The throwIfAborted() method steps are to throw this’s abort reason, if this is aborted.

async function waitForCondition(%func, %targetValue, { %signal } = {}) {
  while (true) {
    %signal?.throwIfAborted();

    const %result = await %func();
    if (%result === %targetValue) {
      return;
    }
  }
}

`通達に~algoを追加する@ ~algoは、 所与の ( $AbortSignal ~obj %通達, ~algo %~algo ) に対し： ◎ To add an algorithm algorithm to an AbortSignal object signal:

1. ~IF［ %通達 は`中止-済み$aBである ］ ⇒ ~RET ◎ If signal is aborted, then return.
2. %通達 の`中止する~algo群$aBに %~algo を`付加する$set ◎ Append algorithm to signal’s abort algorithms.

`通達から~algoを除去する@ ~algoは、 所与の ( $AbortSignal ~obj %通達, ~algo %A ) に対し ⇒ %通達 の`中止する~algo群$aBから %A を`除去する$ ◎ To remove an algorithm algorithm from an AbortSignal signal, remove algorithm from signal’s abort algorithms.

`中止-を通達する@aB ~algoは、 所与の ( $AbortSignal ~obj %通達, %事由（省略時は ε ） ) に対し： ◎ To signal abort, given an AbortSignal object signal and an optional reason:

1. ~IF［ %通達 は`中止-済み$aBである ］ ⇒ ~RET ◎ If signal is aborted, then return.
2. ~Assert： %事由 ~NEQ `undefined^jv 【この段は、この訳による補完。】
3. %通達 の`中止-事由$aB ~SET %事由 に応じて ⇒＃ ε ならば新たな `AbortError$E 例外 ／ ~ELSE_ %事由 ◎ Set signal’s abort reason to reason if it is given; otherwise to a new "AbortError" DOMException.
4. %中止する依存~通達~群 ~LET 新たな`~list$ ◎ Let dependentSignalsToAbort be a new list.

5. %通達 の`依存~通達~群$aBを成す ~EACH( %依存~通達 ) に対し： ◎ For each dependentSignal of signal’s dependent signals:

   1. ~IF［ %依存~通達 は`中止-済み$aBでない ］： ◎ If dependentSignal is not aborted:

      1. %依存~通達 の`中止-事由$aB ~SET %通達 の`中止-事由$aB ◎ Set dependentSignal’s abort reason to signal’s abort reason.
      2. %中止する依存~通達~群 に %依存~通達 を`付加する$ ◎ Append dependentSignal to dependentSignalsToAbort.
6. `通達~用の中止-手続きを走らす$( %通達 ) ◎ Run the abort steps for signal.
7. %中止する依存~通達~群 を成す ~EACH( %依存~通達 ) に対し ⇒ `通達~用の中止-手続きを走らす$( %依存~通達 ) ◎ For each dependentSignal of dependentSignalsToAbort, run the abort steps for dependentSignal.

`通達~用の中止-手続きを走らす@ ~algoは、 所与の ( $AbortSignal ~obj %通達 ) に対し： ◎ To run the abort steps for an AbortSignal signal:

1. %通達 の`中止する~algo群$aBを成す ~EACH( %~algo ) に対し ⇒ %~algo を走らす ◎ For each algorithm of signal’s abort algorithms: run algorithm.
2. %通達 の`中止する~algo群$aBを`空にする$ ◎ Empty signal’s abort algorithms.
3. `~eventを発火する$( %通達, `abort$et ) ◎ Fire an event named abort at signal.

`依存~中止-通達を作成する@ ~algoは、 所与の ( %通達~群, %通達~interface, %~realm ) に対し： ◎ To create a dependent abort signal from a list of AbortSignal objects signals, using signalInterface, which must be either AbortSignal or an interface that inherits from it, and a realm:

1. ~Assert ⇒＃ %通達~群 は $AbortSignal ~objたちが成す~listである。 %通達~interface は $AbortSignal ~interfaceか それを継承する~interfaceである。 ◎ ↑
2. %結果~通達 ~LET `新たな~obj$( %通達~interface, %~realm ) ◎ Let resultSignal be a new object implementing signalInterface using realm.
3. %通達~群 を成す ~EACH( %通達 ) に対し ⇒ ~IF［ %通達 は`中止-済み$aBである ］ ⇒＃ %結果~通達 の`中止-事由$aB ~SET %通達 の`中止-事由$aB； ~RET %結果~通達 ◎ For each signal of signals: if signal is aborted, then set resultSignal’s abort reason to signal’s abort reason and return resultSignal.
4. %結果~通達 の`依存か$aB ~SET ~T ◎ Set resultSignal’s dependent to true.

5. %通達~群 を成す ~EACH( %通達 ) に対し： ◎ For each signal of signals:

   1. ~IF［ %通達 の`依存か$aB ~EQ ~F ］： ◎ If signal’s dependent is false:

      1. %結果~通達 の`~source通達~群$aBに %通達 を`付加する$set ◎ Append signal to resultSignal’s source signals.
      2. %通達 の`依存~通達~群$aBに %結果~通達 を`付加する$set ◎ Append resultSignal to signal’s dependent signals.
      3. ~CONTINUE ◎ ↓

   2. %通達 の`~source通達~群$aBを成す ~EACH( %~source通達 ) に対し： ◎ Otherwise, for each sourceSignal of signal’s source signals:

      1. ~Assert： %~source通達 は次を満たす ⇒ ［ `中止-済み$aBでない ］~AND［ `依存か$aB ~EQ ~F ］ ◎ Assert: sourceSignal is not aborted and not dependent.
      2. %結果~通達 の`~source通達~群$aBに %~source通達 を`付加する$set ◎ Append sourceSignal to resultSignal’s source signals.
      3. %~source通達 の`依存~通達~群$aBに %結果~通達 を`付加する$set ◎ Append resultSignal to sourceSignal’s dependent signals.
6. ~RET %結果~通達 ◎ Return resultSignal.

`~node$ %~node の `長さ@node は、 %~node が`実装-$する~interfaceに応じて，次で決定される ⇒＃ $DocumentType ならば 0 ／ $Attr ならば 0 ／ $CharacterData ならば %~node の`~data$の`長さ$str ／ ~ELSE_ %~node の`子~群$の`~size$ ◎ To determine the length of a node node, run these steps: • If node is a DocumentType or Attr node, then return 0. • If node is a CharacterData node, then return node’s data’s length. • Return the number of node’s children.

`変異~観測器 小taskを~queueする@ ~algoは： ◎ To queue a mutation observer microtask, run these steps:

1. ~IF［ `~surrounding~agent$の`変異~観測器の小taskは~queueされたか$ ~EQ ~T ］ ⇒ ~RET ◎ If the surrounding agent’s mutation observer microtask queued is true, then return.
2. `~surrounding~agent$の`変異~観測器の小taskは~queueされたか$ ~SET ~T ◎ Set the surrounding agent’s mutation observer microtask queued to true.
3. `小taskを~queueする$( `変異~観測器に通知する$手続き ) ◎ Queue a microtask to notify mutation observers.

`変異~観測器に通知する@ ~algoは： ◎ To notify mutation observers, run these steps:

1. `~surrounding~agent$の`変異~観測器の小taskは~queueされたか$ ~SET ~F ◎ Set the surrounding agent’s mutation observer microtask queued to false.
2. %通知-集合 ~LET `~surrounding~agent$の`処理待ち変異~観測器~群$を`~cloneする$ ◎ Let notifySet be a clone of the surrounding agent’s pending mutation observers.
3. `~surrounding~agent$の`処理待ち変異~観測器~群$を`空にする$ ◎ Empty the surrounding agent’s pending mutation observers.
4. %通達~slot集合 ~LET `~surrounding~agent$の`通達~slot群$を`~cloneする$ ◎ Let signalSet be a clone of the surrounding agent’s signal slots.
5. `~surrounding~agent$の`通達~slot群$を`空にする$ ◎ Empty the surrounding agent’s signal slots.

6. %通知-集合 を成す ~EACH( %観測器 ) に対し： ◎ For each mo of notifySet:

   1. %記録~群 ~LET %観測器 の`記録~queue$moを`~cloneする$ ◎ Let records be a clone of mo’s record queue.
   2. %観測器 の`記録~queue$moを`空にする$ ◎ Empty mo’s record queue.
   3. %観測器 の`~node~list$moを成す ~EACH( %~node ) に対し ⇒ %~node の`登録-済み観測器~list$から 次を満たす`一時~登録-済み観測器$をすべて`除去する$ ⇒ その`観測器$ob ~EQ %観測器 ◎ For each node of mo’s node list, remove all transient registered observers whose observer is mo from node’s registered observer list.
   4. ~IF［ %記録~群 は`空$でない ］ ⇒ `~callback関数を呼出す$( %観測器 の`~callback$mo, « %記録~群, %観測器 », `報告する^i, %観測器 ) ◎ If records is not empty, then invoke mo’s callback with « records, mo » and "report", and with callback this value mo.
7. %通達~slot集合 を成す ~EACH( `~slot$ %~slot ) に対し ⇒ `~eventを発火する$( %~slot, `slotchange@et ) — 次のように初期化して ⇒ $Event.bubbles 属性 ~SET ~T ◎ For each slot of signalSet, fire an event named slotchange, with its bubbles attribute set to true, at slot.

`~node$ %~node の`親~targetを取得する$ときは ⇒ ~RET ［ %~node の`割当-先~slot$ ~NEQ ~NULL ならば それ ／ ~ELSE_ %~node の`親$ ］ ◎ A node’s get the parent algorithm, given an event, returns the node’s assigned slot, if node is assigned; otherwise node’s parent.

【 ［ `~shadow根$／`文書$ ］は、 これをさらに上書きする。 】

@ownerDocument 取得子~手続きは ⇒ ~RET ［ コレは`文書$である ならば ~NULL ／ ~ELSE_ コレの`~node文書$ ］ ◎ The ownerDocument getter steps are to return null, if this is a document; otherwise this’s node document.

注記： `文書$の`~node文書$は，`文書$自身である。 すべての`~node$は、 どの時点であれ，`~node文書$を有する。 ◎ The node document of a document is that document itself. All nodes have a node document at all times.

$nodeValue 設定子~手続きは： ◎ The nodeValue setter steps are to,＼

1. %値 ~LET ［ 所与の値 ~NEQ ~NULL ならば それ ／ ~ELSE_ 空~文字列 ］ ◎ if the given value is null, act as if it was the empty string instead, and then＼

2. コレが`実装-$する~interfaceに応じて： ◎ do as described below, switching on the interface this implements:

   • $Attr ⇒ `既存の属性o値を設定する$( コレ, %値 ) ◎ Attr • Set an existing attribute value with this and the given value.
   • $CharacterData ⇒ コレの`~dataを置換する$( 0, コレの`長さ$node, %値 ) ◎ CharacterData • Replace data with node this, offset 0, count this’s length, and data the given value.
   • その他 ⇒ 何もしない ◎ Otherwise • Do nothing.

`~node$ %親 の `全~内容を文字列に置換する@ ~algoは、 所与の ( 文字列 %文字列 ) に対し： ◎ To string replace all with a string string within a node parent, run these steps:

1. %~node ~LET ~NULL ◎ Let node be null.
2. ~IF［ %文字列 ~NEQ 空~文字列 ］ ⇒ %~node ~SET `新たな~Text~node$( %文字列, %親 の`~node文書$ ) ◎ If string is not the empty string, then set node to a new Text node whose data is string and node document is parent’s node document.
3. %親 の`全~内容を~nodeで置換する$( %~node ) ◎ Replace all with node within parent.

`~nodeの~text内容を設定する@ ~algoは、 所与の ( `~node$ %~node, 文字列 %値 ) に対し， %~node が`実装-$する~interfaceに応じて： ◎ To set text content with a node node and a string value, do as defined below, switching on the interface node implements:

• $DocumentFragment ／ $Element ⇒ コレの`全~内容を文字列に置換する$( %値 ) ◎ DocumentFragment Element • String replace all with value within node.
• $Attr ⇒ `既存の属性o値を設定する$( コレ, %値 ) ◎ Attr • Set an existing attribute value with node and value.
• $CharacterData ⇒ コレの`~dataを置換する$( 0, コレの`長さ$node, %値 ) ◎ CharacterData • Replace data with node node, offset 0, count node’s length, and data value.
• その他【すなわち， $Document ／ $DocumentType 】 ⇒ 何もしない ◎ Otherwise • Do nothing.

$textContent 設定子~手続きは： ◎ The textContent setter steps are to,＼

1. %値 ~LET ［ 所与の値 ~NEQ ~NULL ならば %値 ／ ~ELSE_ 空~文字列 ］ ◎ if the given value is null, act as if it was the empty string instead, and then＼
2. `~nodeの~text内容を設定する$( コレ, %値 ) ◎ run set text content with this and the given value.

@normalize() ~method手続きは： ◎ The normalize() method steps are to run these steps＼

1. コレの`子孫$である ~EACH( `狭義-~Text~node$ %~node ) に対し： ◎ for each descendant exclusive Text node node of this:

   【 ~tree順序で。 加えて、 このループの中で~treeから除去される ^Text ~nodeに対する反復は， 飛ばす必要もある。 】

   1. %長さ ~LET %~node の`長さ$node ◎ Let length be node’s length.
   2. %長さ ~EQ 0 ⇒＃ `~nodeを除去する$( %~node )； ~CONTINUE ◎ If length is zero, then remove node and continue with the next exclusive Text node, if any.
   3. %除去-対象 ~LET %~node を含む`連続的な狭義-~Text~node列$ ◎ ↓
   4. %除去-対象 から %~node （常に先頭に在る）を`除去する$ ◎ ↓
   5. %~data ~LET `~text~dataを連結する$( %除去-対象 ) ◎ Let data be the concatenation of the data of node’s contiguous exclusive Text nodes (excluding itself), in tree order.
   6. %~node の`~dataを置換する$( %長さ, 0, %~data ) ◎ Replace data with node node, offset length, count 0, and data data.

   7. %除去-対象 を成す ~EACH( %text ) に対し： ◎ Let currentNode be node’s next sibling. ◎ While currentNode is an exclusive Text node:

      1. ~EACH( `~live範囲o$ %範囲o ) に対し： ◎ ↓

         1. ~IF［ %範囲o の`始端~node$ ~EQ %text ］ ⇒＃ %範囲o の`始端~offset$ ~INCBY %長さ； %範囲o の`始端~node$ ~SET %~node ◎ For each live range whose start node is currentNode, add length to its start offset and set its start node to node.
         2. ~IF［ %範囲o の`終端~node$ ~EQ %text ］ ⇒＃ %範囲o の`終端~offset$ ~INCBY %長さ； %範囲o の`終端~node$ ~SET %~node ◎ For each live range whose end node is currentNode, add length to its end offset and set its end node to node.
         3. ~IF［ %範囲o の`始端~node$ ~EQ %text の`親$ ］~AND［ %範囲o の`始端~offset$ ~EQ %text の`~index$ ］ ⇒＃ %範囲o の`始端~node$ ~SET %~node； %範囲o の`始端~offset$ ~SET %長さ ◎ For each live range whose start node is currentNode’s parent and start offset is currentNode’s index, set its start node to node and its start offset to length.
         4. ~IF［ %範囲o の`終端~node$ ~EQ %text の`親$ ］~AND［ %範囲o の`終端~offset$ ~EQ %text の`~index$ ］ ⇒＃ %範囲o の`終端~node$ ~SET %~node； %範囲o の`終端~offset$ ~SET %長さ ◎ For each live range whose end node is currentNode’s parent and end offset is currentNode’s index, set its end node to node and its end offset to length.
      2. %長さ ~INCBY %text の`長さ$node ◎ Add currentNode’s length to length. ◎ Set currentNode to its next sibling.
   8. %除去-対象 を成す ~EACH( %text ) に対し，順に ⇒ `~nodeを除去する$( %text ) ◎ Remove node’s contiguous exclusive Text nodes (excluding itself), in tree order.

`~nodeを~cloneする@ ~algoは、 所与の ⇒＃ `~node$ %~node, 真偽値 %下位treeもか （省略時は ~F ）, `文書$ %文書 （省略時は %~node の`~node文書$ ）, ［ ~NULL／`~node$ ］ %親 （省略時は ~NULL）, ［ ~NULL／ $CustomElementRegistry ~obj ］ %~fallback~registry （省略時は ~NULL） ◎終 に対し： ◎ To clone a node given a node node and an optional document document (default node’s node document), boolean subtree (default false), node-or-null parent (default null), and null or a CustomElementRegistry object fallbackRegistry (default null):

1. ~Assert： ［ %~node は`文書$でない ］~OR［ %~node ~EQ %文書 ］ ◎ Assert: node is not a document or node is document.
2. %複製 ~LET `単独の~nodeを~cloneする$( %~node, %文書, %~fallback~registry ) ◎ Let copy be the result of cloning a single node given node, document, and fallbackRegistry.
3. `適用-可能な仕様$にて %~node 用に`定義された各$( `~clone時の手続き$ %手続き ) に対し ⇒ %手続き( %~node, %複製, %下位treeもか ) ◎ Run any cloning steps defined for node in other applicable specifications and pass node, copy, and subtree as parameters.
4. ~IF［ %親 ~NEQ ~NULL ］ ⇒ %親 に`~nodeを付加する$( %複製 ) ◎ If parent is non-null, then append copy to parent.
5. ~IF［ %下位treeもか ~EQ ~T ］ ⇒ %~node の`子~群$を成す ~EACH( %子 ) に対し【！`~tree順序$で】 ⇒ `~nodeを~cloneする$( %子, %下位treeもか, %文書, %複製, %~fallback~registry ) ◎ If subtree is true, then for each child of node’s children, in tree order: clone a node given child with document set to document, subtree set to subtree, parent set to copy, and fallbackRegistry set to fallbackRegistry.
6. %~shadow根 ~LET %~node の`~shadow根$el ◎ ↓

7. ~IF［ %~node は`要素$である ］~AND［ %~shadow根 ~NEQ ~NULL【！%~node は`~shadow~host$である】 ］~AND［ %~shadow根 の`~clone可能か$sR ~EQ ~T ］： ◎ If node is an element, node is a shadow host, and node’s shadow root’s clonable is true:

   1. ~Assert： %複製 は`~shadow~host$でない。 ◎ Assert: copy is not a shadow host.
   2. `~shadow根を付する$( ↓ ) ⇒＃ %複製, %~shadow根 の`~mode$sR, ~T, %~shadow根 の`直列化-可能か$sR, %~shadow根 の`~focusを委任するか$sR, %~shadow根 の`~slot割当n~mode$sR, %~shadow根 の`~custom要素~registry$sR ◎ Let shadowRootRegistry be node’s shadow root’s custom element registry. ◎ Attach a shadow root with copy, node’s shadow root’s mode, true, node’s shadow root’s serializable, node’s shadow root’s delegates focus, node’s shadow root’s slot assignment, and shadowRootRegistry.
   3. %複製 の`~shadow根$elの`宣言的か$sR ~SET %~shadow根 の`宣言的か$sR ◎ Set copy’s shadow root’s declarative to node’s shadow root’s declarative.

   4. %~shadow根 の`子~群$を成す ~EACH( %子 ) に対し【！`~tree順序$で】 ⇒ `~nodeを~cloneする$( %子, %下位treeもか, %文書, %複製 の`~shadow根$el ) ◎ For each child of node’s shadow root’s children, in tree order: clone a node given child with document set to document, subtree set to subtree, and parent set to copy’s shadow root.

      注記： ここでは、 `~fallback~registry^i 引数を意図的に渡さない。 ◎ This intentionally does not pass the fallbackRegistry argument.

8. ~RET %複製 ◎ Return copy.

`単独の~nodeを~cloneする@ ~algoは、 所与の ( `~node$ %~node, `文書$ %文書, ［ ~NULL／ $CustomElementRegistry ~obj ］ %~fallback~registry ) に対し： ◎ To clone a single node given a node node, document document, and null or a CustomElementRegistry object fallbackRegistry:

1. %複製 ~LET ~NULL ◎ Let copy be null.

2. ~IF［ %~node は`要素$である ］： ◎ If node is an element:

   1. %~registry ~LET %~node の`~custom要素~registry$el ◎ Let registry be node’s custom element registry.
   2. ~IF［ %~registry ~EQ ~NULL ］ ⇒ %~registry ~SET %~fallback~registry ◎ If registry is null, then set registry to fallbackRegistry.
   3. %複製 ~SET `要素を作成する$( ↓ ) ⇒＃ %文書, %~node の`局所~名$el, %~node の`~ns$el, %~node の`~ns接頭辞$el, %~node の`~is0値$el, ~F, %~registry ◎ Set copy to the result of creating an element, given document, node’s local name, node’s namespace, node’s namespace prefix, node’s is value, false, and registry.
   4. %~node の`属性o~list$elを成す ~EACH( %属性o ) に対し ⇒ `属性oを付加する$( 次の結果, %複製 ) ⇒ `単独の~nodeを~cloneする$( %属性o, %文書 ) ◎ For each attribute of node’s attribute list: • Let copyAttribute be the result of cloning a single node given attribute, document • Append copyAttribute to copy.

3. ~ELSE： ◎ Otherwise,＼

   1. %複製 ~SET `新たな~obj$( %~node の`首~interface$ ) ◎ set copy to a node that implements the same interfaces as node, and＼

   2. %~node が`実装-$する~interfaceに応じて： ◎ fulfills these additional requirements, switching on the interface node implements:

      • $Document ⇒ %複製 の ⇒＃ `符号化法$doc ~SET %~node の`符号化法$doc, `内容~型$doc ~SET %~node の`内容~型$doc, `~URL$doc ~SET %~node の`~URL$doc, `生成元$doc ~SET %~node の`生成元$doc, `種別$doc ~SET %~node の`種別$doc, `~mode$doc ~SET %~node の`~mode$doc, `~custom要素~registry$doc ~SET %~node の`~custom要素~registry$doc ◎ Document • Set copy’s encoding, content type, URL, origin, type, mode, and custom element registry to those of node.
      • $DocumentType ⇒ %複製 の ⇒＃ `名前$dT ~SET %~node の`名前$dT, `公な~ID$dT ~SET %~node の`公な~ID$dT, `~system~ID$dT ~SET %~node の`~system~ID$dT ◎ DocumentType • Set copy’s name, public ID, and system ID to those of node.
      • $Attr ⇒ %複製 の ⇒＃ `~ns$a ~SET %~node の`~ns$a, `~ns接頭辞$a ~SET %~node の`~ns接頭辞$a, `局所~名$a ~SET %~node の`局所~名$a, `値$a ~SET %~node の`値$a ◎ Attr • Set copy’s namespace, namespace prefix, local name, and value to those of node.
      • $Text ／ $Comment ⇒ %複製 の`~data$ ~SET %~node の`~data$ ◎ Text Comment • Set copy’s data to that of node.
      • $ProcessingInstruction ⇒ %複製 の ⇒＃ `~target$pI ~SET %~node の`~target$pI, `~data$ ~SET %~node の`~data$ ◎ ProcessingInstruction • Set copy’s target and data to those of node.
      • その他【すなわち， $DocumentFragment 】 ⇒ 何もしない ◎ Otherwise • Do nothing.
4. ~Assert： %複製 は`~node$である。 ◎ Assert: copy is a node.
5. %複製 の`~node文書$ ~SET %複製 に応じて ⇒＃ `文書$であるならば %複製 ／ ~ELSE_ %文書 ◎ If node is a document, then set document to copy. ◎ Set copy’s node document to document.
6. ~RET %複製 ◎ Return copy.

@cloneNode(subtree) ~method手続きは： ◎ The cloneNode(subtree) method steps are:

1. ~IF［ コレは`~shadow根$である ］ ⇒ ~THROW `NotSupportedError$E ◎ If this is a shadow root, then throw a "NotSupportedError" DOMException.
2. ~RET `~nodeを~cloneする$( コレ, %subtree ) ◎ Return the result of cloning a node given this with subtree set to subtree.

2 つの`~node$ %A, %B が `同等@node であるとは、 ~AND↓ を満たすことをいう： ◎ A node A equals a node B if all of the following conditions are true:

• %A, %B は同じ~interfaceを`実装-$する ◎ A and B implement the same interfaces.

• %A が`実装-$する~interfaceに応じて，次に挙げるものもすべて同等である： ◎ The following are equal, switching on the interface A implements:

  • $DocumentType ⇒＃ `名前$dT, `公な~ID$dT, `~system~ID$dT ◎ DocumentType • Its name, public ID, and system ID.
  • $Element ⇒＃ `~ns$el, `~ns接頭辞$el, `局所~名$el, `属性o~list$elの`~size$ ◎ Element • Its namespace, namespace prefix, local name, and its attribute list’s size.
  • $Attr ⇒＃ `~ns$a, `局所~名$a, `値$a ◎ Attr • Its namespace, local name, and value.
  • $ProcessingInstruction ⇒＃ `~target$pI, `~data$ ◎ ProcessingInstruction • Its target and data.
  • $CharacterData【！$Text ／ $Comment】 ⇒＃ `~data$ ◎ Text Comment • Its data.
  • その他【すなわち， $Document, $DocumentFragment 】 ⇒ なし 【すなわち，比較するものは無いので無条件（原文には “—” としか記されていないが）。】 ◎ Otherwise • —
• %A は`要素$であるならば、 次が満たされる ⇒ %A の`属性o~list$elを成す どの`属性o$も，［ %B の`属性o~list$elを成す ある`属性o$ ］と`同等$nodeである ◎ If A is an element, each attribute in its attribute list has an attribute that equals an attribute in B’s attribute list.
• %A の`子~群$の`~size$ ~EQ %B の`子~群$の`~size$ ◎ A and B have the same number of children.
• 各 %~index ~IN { 0 〜 %A の`子~群$の`~size$ ~MINUS 1 } に対し ⇒ ( %A の`子~群$[ %~index ], %B の`子~群$[ %~index ] ) は`同等$nodeである ◎ Each child of A equals the child of B at the identical index.

@compareDocumentPosition(other) ~method手続きは： ◎ The compareDocumentPosition(other) method steps are:

1. ~IF［ コレ ~EQ %other ］ ⇒ ~RET 0 ◎ If this is other, then return zero.
2. ( %他~node, %自~node ) ~LET ( %other, コレ ) ◎ Let node1 be other and node2 be this.
3. ( %他~属性o, %自~属性o ) ~LET ( ~NULL, ~NULL ) ◎ Let attr1 and attr2 be null.
4. ~IF［ %他~node は`属性o$である ］ ⇒＃ %他~属性o ~SET %他~node； %他~node ~SET %他~属性o が`属する要素$ ◎ If node1 is an attribute, then set attr1 to node1 and node1 to attr1’s element.

5. ~IF［ %自~node は`属性o$である ］： ◎ If node2 is an attribute:

   1. %自~属性o ~SET %自~node ◎ ↓
   2. %自~node ~SET %自~属性o が`属する要素$ ◎ Set attr2 to node2 and node2 to attr2’s element.

   3. ~IF［ %他~属性o ~NEQ ~NULL ］~AND［ %自~属性o ~NEQ ~NULL ］~AND［ %自~node ~EQ %他~node ］： ◎ If attr1 and node1 are non-null, and node2 is node1:

      1. %自~node の`属性o~list$elを成す ~EACH( %属性o ) に対し： ◎ For each attr of node2’s attribute list:

         1. ~IF［ ( %属性o, %他~属性o ) は`同等$nodeである ］ ⇒ ~RET $DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC ~PLUS $DOCUMENT_POSITION_PRECEDING ◎ If attr equals attr1, then return the result of adding DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and DOCUMENT_POSITION_PRECEDING.
         2. ~IF［ ( %属性o, %自~属性o ) は`同等$nodeである ］ ⇒ ~RET $DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC ~PLUS $DOCUMENT_POSITION_FOLLOWING ◎ If attr equals attr2, then return the result of adding DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and DOCUMENT_POSITION_FOLLOWING.

6. ~IF［ %他~node ~EQ ~NULL ］~OR［ %自~node ~EQ ~NULL ］~OR［ %他~node の`根$ ~NEQ %自~node の`根$ ］ ⇒ ~RET ［ $DOCUMENT_POSITION_DISCONNECTED ~PLUS $DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC ~PLUS ［ $DOCUMENT_POSITION_PRECEDING または $DOCUMENT_POSITION_FOLLOWING （ただし，いずれが~~選択されるかは一貫するものとする）］ ］ ◎ If node1 or node2 is null, or node1’s root is not node2’s root, then return the result of adding DOCUMENT_POSITION_DISCONNECTED, DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, and either DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING, with the constraint that this is to be consistent, together.

   注記： $DOCUMENT_POSITION_PRECEDING, $DOCUMENT_POSITION_FOLLOWING のどちらを返すかは，概して~pointer比較を介して実装される。 ~JS実装においては `Math.random()^c 値を利用できる。 【理想的には、各~node~treeどうしの順序も循環しないように一貫するべきであろう。】 ◎ Whether to return DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING is typically implemented via pointer comparison. In JavaScript implementations a cached Math.random() value can be used.

7. ~IF［［ %他~node は %自~node の`先祖$である ］~AND［ %他~属性o ~EQ ~NULL ］］~OR［［ %他~node ~EQ %自~node ］~AND［ %自~属性o ~NEQ ~NULL ］］ ⇒ ~RET $DOCUMENT_POSITION_CONTAINS ~PLUS $DOCUMENT_POSITION_PRECEDING ◎ If node1 is an ancestor of node2 and attr1 is null, or node1 is node2 and attr2 is non-null, then return the result of adding DOCUMENT_POSITION_CONTAINS to DOCUMENT_POSITION_PRECEDING.
8. ~IF［［ %他~node は %自~node の`子孫$である ］~AND［ %自~属性o ~EQ ~NULL ］］~OR［［ %他~node ~EQ %自~node ］~AND［ %他~属性o ~NEQ ~NULL ］］ ⇒ ~RET $DOCUMENT_POSITION_CONTAINED_BY ~PLUS $DOCUMENT_POSITION_FOLLOWING ◎ If node1 is a descendant of node2 and attr2 is null, or node1 is node2 and attr1 is non-null, then return the result of adding DOCUMENT_POSITION_CONTAINED_BY to DOCUMENT_POSITION_FOLLOWING.

9. ~IF［ %他~node は %自~node に`先行-$する ］ ⇒ ~RET $DOCUMENT_POSITION_PRECEDING ◎ If node1 is preceding node2, then return DOCUMENT_POSITION_PRECEDING.

   注記： `属性o$は，自身が`属する要素$と同じ`~tree$には`関与-$しないが、 この~algoに因り［ 属性oは，自身が属する要素の`子$に`先行-$する ］ものとされることになる。 ◎ Due to the way attributes are handled in this algorithm this results in a node’s attributes counting as preceding that node’s children, despite attributes not participating in the same tree.

10. ~RET $DOCUMENT_POSITION_FOLLOWING ◎ Return DOCUMENT_POSITION_FOLLOWING.

%要素 用の `~ns接頭辞を~locateする@ ~algoは、 所与の ( %~ns ) に対し： ◎ To locate a namespace prefix for an element using namespace, run these steps:

1. ~IF［ %要素 の`~ns$el ~EQ %~ns ］~AND［ %要素 の`~ns接頭辞$el ~NEQ ~NULL ］ ⇒ ~RET %要素 の`~ns接頭辞$el ◎ If element’s namespace is namespace and its namespace prefix is non-null, then return its namespace prefix.
2. %属性o ~LET %要素 の`属性o~list$elを成す`属性o$のうち，次を満たす`最初のもの？$ ⇒ ［ `~ns接頭辞$a ~EQ `xmlns^l ］~AND［ `値$a ~EQ %~ns ］ ◎ If element has an attribute whose namespace prefix is "xmlns" and value is namespace, then return element’s first such attribute’s local name.
3. ~IF［ %属性o ~NEQ ~NULL ］ ⇒ ~RET %属性o の`局所~名$a ◎ ↑
4. %親 ~SET %要素 の`親~要素$ ◎ ↓
5. ~IF［ %親 ~NEQ ~NULL ］ ⇒ ~RET %親 用の`~ns接頭辞を~locateする$( %~ns ) ◎ If element’s parent element is not null, then return the result of running locate a namespace prefix on that element using namespace.
6. ~RET ~NULL ◎ Return null.

%~node 用の `~nsを~locateする@ ~algoは、 所与の ( %接頭辞 ) に対し： ◎ To locate a namespace for a node using prefix,＼ ↓switch on the interface node implements:

1. ~IF［ %~node は $Element を`実装-$する ］： ◎ Element

   1. ~IF［ %接頭辞 ~EQ `xml^l ］ ⇒ ~RET `~XML~ns$ ◎ If prefix is "xml", then return the XML namespace.
   2. ~IF［ %接頭辞 ~EQ `xmlns^l ］ ⇒ ~RET `~XMLNS~ns$ ◎ If prefix is "xmlns", then return the XMLNS namespace.
   3. ~IF［ %~node の`~ns$el ~NEQ ~NULL ］~AND［ %~node の`~ns接頭辞$el ~EQ %接頭辞 ］ ⇒ ~RET その`~ns$el ◎ If its namespace is non-null and its namespace prefix is prefix, then return namespace.

   4. %属性o ~LET %~node の`属性o~list$elを成す`属性o$のうち，［ %接頭辞 に応じて，次に与える条件 ］を満たす`最初のもの？$：

      • %接頭辞 ~NEQ ~NULL の場合 ⇒ ［ `~ns$a ~EQ `~XMLNS~ns$ ］~AND［ `~ns接頭辞$a ~EQ `xmlns^l ］~AND［ `局所~名$a ~EQ %接頭辞 ］
      • %接頭辞 ~EQ ~NULL の場合 ⇒ ［ `~ns$a ~EQ `~XMLNS~ns$ ］~AND［ `~ns接頭辞$a ~EQ ~NULL ］~AND［ `局所~名$a ~EQ `xmlns^l ］
      ◎ If it has an attribute whose namespace is the XMLNS namespace, namespace prefix is "xmlns", and local name is prefix, or if prefix is null and it has an attribute whose namespace is the XMLNS namespace, namespace prefix is null, and local name is "xmlns",＼
   5. ~IF［ %属性o ~NEQ ~NULL ］ ⇒ ~RET ［ %属性o の`値$a ~NEQ 空~文字列 ならばそれ ／ ~ELSE_ ~NULL ］ ◎ then return its value if it is not the empty string, and null otherwise. ◎ ↓If its parent element is null, then return null. ◎ ↓Return the result of running locate a namespace on its parent element using prefix.
2. %要素 ~LET %~node が`実装-$する~interfaceに応じて ⇒＃ $Element ならば %~node の`親~要素$ ／ $Document ならば %~node の`文書~要素$ ／ $DocumentType ならば ~NULL ／ $DocumentFragment ならば ~NULL ／ $Attr ならば %~node が`属する要素$ ／ ~ELSE_【すなわち， $CharacterData ならば】 %~node の`親~要素$ ◎ Document • If its document element is null, then return null. • Return the result of running locate a namespace on its document element using prefix. DocumentType DocumentFragment • Return null. Attr • If its element is null, then return null. • Return the result of running locate a namespace on its element using prefix. Otherwise • If its parent element is null, then return null. • Return the result of running locate a namespace on its parent element using prefix.
3. ~IF［ %要素 ~NEQ ~NULL ］ ⇒ ~RET %要素 用の`~nsを~locateする$( %接頭辞 ) ◎ ↑
4. ~RET ~NULL ◎ ↑

@lookupPrefix(namespace) ~method手続きは： ◎ The lookupPrefix(namespace) method steps are:

1. ~IF［ %namespace ~IN { ~NULL, 空~文字列 } ］ ⇒ ~RET ~NULL ◎ If namespace is null or the empty string, then return null.
2. %要素 ~LET コレが`実装-$する~interfaceに応じて ⇒＃ $Element ならばコレ ／ $Document ならばコレの`文書~要素$ ／ $DocumentType ならば ~NULL ／ $DocumentFragment ならば ~NULL ／ $Attr ならばコレが`属する要素$ ／ ~ELSE_【すなわち， $CharacterData ならば】コレの`親~要素$ ◎ Switch on the interface this implements: ◎ ↓
3. ~IF ［ %要素 ~NEQ ~NULL ］ ⇒ ~RET %要素 用の`~ns接頭辞を~locateする$( %namespace ) ◎ • Element •• Return the result of locating a namespace prefix for this using namespace. ◎ • Document •• If this’s document element is null, then return null. •• Return the result of locating a namespace prefix for this’s document element using namespace. ◎ • DocumentType • DocumentFragment •• Return null. ◎ • Attr •• If this’s element is null, then return null. •• Return the result of locating a namespace prefix for this’s element using namespace. ◎ • Otherwise •• If this’s parent element is null, then return null. •• Return the result of locating a namespace prefix for this’s parent element using namespace.
4. ~RET ~NULL ◎ ↑

@lookupNamespaceURI(prefix) ~method手続きは： ◎ The lookupNamespaceURI(prefix) method steps are:

1. ~IF［ %prefix ~EQ 空~文字列 ］ ⇒ %prefix ~SET ~NULL ◎ If prefix is the empty string, then set it to null.
2. ~RET コレ用の`~nsを~locateする$( %prefix ) ◎ Return the result of running locate a namespace for this using prefix.

@isDefaultNamespace(namespace) ~method手続きは： ◎ The isDefaultNamespace(namespace) method steps are:

1. ~IF［ %namespace ~EQ 空~文字列 ］ ⇒ %namespace ~SET ~NULL ◎ If namespace is the empty string, then set it to null.
2. %既定~ns ~LET コレ用の`~nsを~locateする$( ~NULL ) ◎ Let defaultNamespace be the result of running locate a namespace for this using null.
3. ~RET ~IS［ %既定~ns ~EQ %namespace ］ ◎ Return true if defaultNamespace is the same as namespace; otherwise false.

@insertBefore(node, child) ~method手続きは ⇒ ~RET コレの中で`~nodeを子の前に前挿入する$( %node, %child ) ◎ The insertBefore(node, child) method steps are to return the result of pre-inserting node into this before child.

`~node$ %根 用の［ %有修飾~名 を `有修飾~名に持つ要素の~list@ ］は、 次のように設定された $HTMLCollection を返す： ◎ The list of elements with qualified name qualifiedName for a node root is the HTMLCollection returned by the following algorithm:

• `根$cL ~SET %根 ◎ ↓

• `~filter$cLは［ %根 の`子孫$である`要素$ %要素 のうち［ ~OR↓ ］が満たされるもの ］に合致する： ◎ ↓

  • %有修飾~名 ~EQ `002A^U `*^smb （この場合、 %要素 に関する条件は問われない） ◎ If qualifiedName is U+002A (*), then return an HTMLCollection rooted at root, whose filter matches only descendant elements.

  • ［ %根 の`~node文書$は`~HTML文書$である ］~AND［ ~OR↓ ］： ◎ Otherwise, if root’s node document is an HTML document, return an HTMLCollection rooted at root, whose filter matches the following descendant elements:

    • ［ `~ns$el ~EQ `~HTML~ns$ ］~AND［ %要素 の`有修飾~名$ ~EQ `~ASCII小文字~化する$( %有修飾~名 ) ］ ◎ Whose namespace is the HTML namespace and whose qualified name is qualifiedName, in ASCII lowercase.
    • ［ `~ns$el ~NEQ `~HTML~ns$ ］~AND［ %要素 の`有修飾~名$ ~EQ %有修飾~名 ］ ◎ Whose namespace is not the HTML namespace and whose qualified name is qualifiedName.
  • %要素 の`有修飾~名$ ~EQ %有修飾~名 ◎ Otherwise, return an HTMLCollection rooted at root, whose filter matches descendant elements whose qualified name is qualifiedName.

以前の~callと同じ引数で呼出されたときは、 %根 の`~node文書$の`種別$docが変化していない限り，そのときに返したものと同じ $HTMLCollection ~objを返してもヨイ。 ◎ When invoked with the same argument, and as long as root’s node document’s type has not changed, the same HTMLCollection object may be returned as returned by an earlier call.

`~node$ %根 用の［ ( %~ns, %局所~名 ) を `( ~ns, 局所~名 ) に持つ要素の~list@ ］は、 次のように設定された $HTMLCollection を返す： ◎ The list of elements with namespace namespace and local name localName for a node root is the HTMLCollection returned by the following algorithm:

• `根$cL ~SET %根 ◎ ↓

• `~filter$cLは［ %根 の`子孫$である`要素$ %要素 のうち，次の結果 ~EQ ~T になるもの ］に合致する：

  1. 【！cp-normalize-ns】 ~IF［ %~ns ~EQ 空~文字列 ］ ⇒ %~ns ~SET ~NULL
  2. ~RET ~IS［ %~ns ~IN { `002A^U `*^smb, %要素 の`~ns$el } ］~AND［ %局所~名 ~IN { `002A^U `*^smb, %要素 の`局所~名$el } ］

  （ %~ns ~EQ %局所~名 ~EQ `*^l の場合、 %要素 は~~無条件に合致することになる）

  ◎ If namespace is the empty string, then set it to null. ◎ If both namespace and localName are U+002A (*), then return an HTMLCollection rooted at root, whose filter matches descendant elements. ◎ If namespace is U+002A (*), then return an HTMLCollection rooted at root, whose filter matches descendant elements whose local name is localName. ◎ If localName is U+002A (*), then return an HTMLCollection rooted at root, whose filter matches descendant elements whose namespace is namespace. ◎ Return an HTMLCollection rooted at root, whose filter matches descendant elements whose namespace is namespace and local name is localName.

以前の~callと同じ引数で呼出されたときは、 そのときに返したものと同じ $HTMLCollection ~objを返してもヨイ。 ◎ When invoked with the same argument, the same HTMLCollection object may be returned as returned by an earlier call.

`~node$ %根 用の［ %classNames を `~class群に含む要素の~list@ ］とは、 次の~algoが返す $HTMLCollection である： ◎ The list of elements with class names classNames for a node root is the HTMLCollection returned by the following algorithm:

1. %~class群 ~LET `有順序~集合として構文解析する$( %classNames ) ◎ Let classes be the result of running the ordered set parser on classNames.
2. ~IF［ %~class群 は`空$である ］ ⇒ ~RET 空な $HTMLCollection ◎ If classes is the empty set, return an empty HTMLCollection.

3. ~RET 次のように設定された $HTMLCollection `~collection$ ⇒＃ `根$cL ~SET %根, `~filter$cLは %根 の`子孫$である`要素$のうち次を満たすものに合致する ⇒ その`~class群$は %~class群 を成す どの~tokenも含む ◎ Return an HTMLCollection rooted at root, whose filter matches descendant elements that have all their classes in classes.

   `~class群$と %~class群 の中の各~tokenの比較は、［ %根 の`~node文書$の`~mode$docが `quirks^l ならば `~ASCII大小無視$ ／ ~ELSE_ `一致する$かどうか ］で行うモノトスル。 ◎ The comparisons for the classes must be done in an ASCII case-insensitive manner if root’s node document’s mode is "quirks"; otherwise in an identical to manner.

`文書$ %文書 の`親~targetを取得する$ときは、 所与の ( ~event %~event ) に対し：

1. ~IF［ %~event の $Event.type 属性~値 ~EQ `load^l ］~OR［ %文書 が`属する閲覧~文脈$ ~EQ ~NULL ］ ⇒ ~RET ~NULL
2. ~RET %文書 に`関連な大域~obj$

@Document() 構築子~手続きは ⇒ コレの`生成元$doc ~SET `現在の大域~obj$に`結付けられた文書$の`生成元$doc `HTML$r ◎ The new Document() constructor steps are to set this’s origin to the origin of current global object’s associated Document. [HTML]

注記： $DOMImplementation.createDocument() と違って、 この構築子は $XMLDocument ~objではなく，`文書$（ $Document ~obj）を返す。 ◎ Unlike createDocument(), this constructor does not return an XMLDocument object, but a document (Document object).

@URL, @documentURI 取得子~手続きは、 いずれも ⇒ ~RET `~URLを直列化する$( コレの`~URL$doc ) ◎ The URL and documentURI getter steps are to return this’s URL, serialized.

@getElementsByTagName(qualifiedName) ~method手続きは ⇒ ~RET コレ用の［ %qualifiedName を`有修飾~名に持つ要素の~list$ ］ ◎ The getElementsByTagName(qualifiedName) method steps are to return the list of elements with qualified name qualifiedName for this.

注記： したがって，`~HTML文書$においては、 `document.getElementsByTagName("FOO")^c は `~HTML~ns$に属さない `FOO^e 要素と `~HTML~ns$に属する `foo^e 要素に合致し， `~HTML~ns$に属する `FOO^e 要素には合致しないことになる。 ◎ Thus, in an HTML document, document.getElementsByTagName("FOO") will match <FOO> elements that are not in the HTML namespace, and <foo> elements that are in the HTML namespace, but not <FOO> elements that are in the HTML namespace.

@getElementsByClassName(classNames) ~method手続きは ⇒ ~RET コレ用の［ %classNames を`~class群に含む要素の~list$ ］ ◎ The getElementsByClassName(classNames) method steps are to return the list of elements with class names classNames for this.

@createElement(localName, options) ~method手続きは： ◎ The createElement(localName, options) method steps are:

1. ~IF［ %localName は`妥当な要素~局所~名$でない ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If localName is not a valid element local name, then throw an "InvalidCharacterError" DOMException.
2. ~IF［ コレは`~HTML文書$ である ］ ⇒ %localName ~SET `~ASCII小文字~化する$( %localName ) ◎ If this is an HTML document, then set localName to localName in ASCII lowercase.
3. ( %~registry, %is ) ~LET `要素~作成~option群を平坦~化する$( %options, コレ ) ◎ Let registry and is be the result of flattening element creation options given options and this.
4. %~ns ~LET ［ 次が満たされるならば `~HTML~ns$ ／ ~ELSE_ ~NULL ］ ⇒ ［ コレは`~HTML文書$である ］~OR［ コレの`内容~型$doc ~EQ `application/xhtml+xml^l ］ ◎ Let namespace be the HTML namespace, if this is an HTML document or this’s content type is "application/xhtml+xml"; otherwise null.
5. ~RET `要素を作成する$( ↓ ) ⇒＃ コレ, %localName, %~ns, ~NULL, %is, ~T, %~registry ◎ Return the result of creating an element given this, localName, namespace, null, is, true, and registry.

`内部 createElementNS 手続き@ は、 所与の ( %文書, %namespace, %qualifiedName, %options ) に対し： ◎ The internal createElementNS steps, given document, namespace, qualifiedName, and options, are as follows:

1. ( %~ns, %接頭辞, %局所~名 ) ~LET `~nsと名前を検証して抽出する$( %namespace, %qualifiedName, `要素^i ) ◎ Let (namespace, prefix, localName) be the result of validating and extracting namespace and qualifiedName given "element".
2. ~RET `要素を作成する$( ↓ ) ⇒＃ %文書, %局所~名, %~ns, %接頭辞, %is, ~T, %~registry ◎ Return the result of creating an element given document, localName, namespace, prefix, is, true, and registry.

`要素~作成~option群を平坦~化する@ ~algoは、 所与の ( ［ 文字列／ $ElementCreationOptions 辞書 ］ %~option群, `文書$ %文書 ) に対し：

1. ~IF［ %~option群 は文字列である ］ ⇒ %~option群 ~SET 空な $ElementCreationOptions
2. %~registry ~LET %~option群[ "$ElementCreationOptions.customElementRegistry" ]
3. %is ~LET %~option群[ "$ElementCreationOptions.is" ]
4. ~IF［ %~registry ~NEQ ε ］~AND［ %is ~NEQ ε ］ ⇒ ~THROW `NotSupportedError$E
5. ~IF［ %~registry ~EQ ε ］ ⇒ %~registry ~SET `~custom要素~registryを検索する$( %文書 )
6. ~IF［ %is ~EQ ε ］ ⇒ %is ~SET ~NULL
7. ~RET ( %~registry, %is )

@createCDATASection(data) ~method手続きは： ◎ The createCDATASection(data) method steps are:

1. ~IF［ コレは`~HTML文書$である ］ ⇒ ~THROW `NotSupportedError$E ◎ If this is an HTML document, then throw a "NotSupportedError" DOMException.
2. ~IF［ %data は文字列 `]]>^l を包含する ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If data contains the string "]]>", then throw an "InvalidCharacterError" DOMException.
3. ~RET `新たな~obj$( $CDATASection ) — その ⇒＃ `~data$ ~SET %data, `~node文書$ ~SET コレ ◎ Return a new CDATASection node with its data set to data and node document set to this.

@createProcessingInstruction(target, data) ~method手続きは： ◎ The createProcessingInstruction(target, data) method steps are:

1. ~IF［ %target は `Name$prod 生成規則に合致しない ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If target does not match the Name production, then throw an "InvalidCharacterError" DOMException.
2. ~IF［ %data は文字列 `?>^l を含む ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If data contains the string "?>", then throw an "InvalidCharacterError" DOMException.
3. ~RET `新たな~obj$( $ProcessingInstruction ) — その ⇒＃ `~target$pI【！$ProcessingInstruction.target】 ~SET %target, `~data$ ~SET %data, `~node文書$ ~SET コレ ◎ Return a new ProcessingInstruction node, with target set to target, data set to data, and node document set to this.

@importNode(node, options) ~method手続きは： ◎ The importNode(node, options) method steps are:

1. ~IF［ %node は［ `文書$／`~shadow根$ ］である ］ ⇒ ~THROW `NotSupportedError$E ◎ If node is a document or shadow root, then throw a "NotSupportedError" DOMException.
2. %下位treeもか ~LET ~F ◎ Let subtree be false.
3. %~registry ~LET ε ◎ Let registry be null.
4. ~IF［ %options は真偽値である ］ ⇒ %下位treeもか ~SET %options ◎ If options is a boolean, then set subtree to options.

5. ~ELSE： ◎ Otherwise:

   1. %下位treeもか ~SET ~IS［ ~NOT %options[ "$ImportNodeOptions.selfOnly" ] ~EQ ~T ］ ◎ Set subtree to the negation of options["selfOnly"].
   2. %~registry ~SET %~option群[ "$ImportNodeOptions.customElementRegistry" ] ◎ If options["customElementRegistry"] exists, then set registry to it.
6. ~IF［ %~registry ~EQ ε ］ ⇒ %~registry ~SET `~custom要素~registryを検索する$( コレ ) ◎ If registry is null, then set registry to the result of looking up a custom element registry given this.
7. ~RET `~nodeを~cloneする$( %node, %下位treeもか, コレ, ~NULL, %~registry ) ◎ Return the result of cloning a node given node with document set to this, subtree set to subtree, and fallbackRegistry set to registry.

%文書 に `~nodeを受入する@ ~algoは、 所与の ( %~node ) に対し： ◎ To adopt a node into a document, run these steps:

1. %旧-文書 ~LET %~node の`~node文書$ ◎ Let oldDocument be node’s node document.
2. ~IF［ %~node の`親$ ~NEQ ~NULL ］ ⇒ `~nodeを除去する$( %~node ) ◎ If node’s parent is non-null, then remove node.

3. ~IF［ %文書 ~NEQ %旧-文書 ］： ◎ If document is not oldDocument:

   1. %~node の ~EACH( `~shadowも含めた広義-子孫$ %広義-子孫 ) に対し ◎ For each inclusiveDescendant in node’s shadow-including inclusive descendants:

      1. %広義-子孫 の`~node文書$ ~SET %文書 ◎ Set inclusiveDescendant’s node document to document.
      2. ~IF［ %広義-子孫 は`要素$である ］ ⇒ %広義-子孫 の`属性o~list$elを成す ~EACH( %属性o ) に対し ⇒ %属性o の`~node文書$ ~SET %文書 ◎ If inclusiveDescendant is an element, then set the node document of each attribute in inclusiveDescendant’s attribute list to document.
   2. %~node の ~EACH( `~shadowも含めた広義-子孫$ %広義-子孫 ) に対し ⇒ ~IF［ %広義-子孫 は`~custom$である ］ ⇒ `~custom要素~callback反応を~enqueueする$( %広義-子孫, `adoptedCallback^l, « %旧-文書, %文書 » ) ◎ For each inclusiveDescendant in node’s shadow-including inclusive descendants that is custom, enqueue a custom element callback reaction with inclusiveDescendant, callback name "adoptedCallback", and « oldDocument, document ».
   3. %~node の`~shadowも含めた広義-子孫$たちを成す ~EACH( %広義-子孫 ) に対し，`~shadowも含めた~tree順序$で ⇒ `適用-可能な仕様$にて %広義-子孫 用に`定義された各$( `受入-時の手続き$ %手続き ) に対し ⇒ %手続き( %広義-子孫, %旧-文書 ) ◎ For each inclusiveDescendant in node’s shadow-including inclusive descendants, in shadow-including tree order, run the adopting steps with inclusiveDescendant and oldDocument.

@adoptNode(node) ~method手続きは： ◎ The adoptNode(node) method steps are:

1. ~IF［ %node は`文書$である ］ ⇒ ~THROW `NotSupportedError$E ◎ If node is a document, then throw a "NotSupportedError" DOMException.
2. ~IF［ %node は`~shadow根$である ］ ⇒ ~THROW `HierarchyRequestError$E ◎ If node is a shadow root, then throw a "HierarchyRequestError" DOMException.
3. ~IF［ %node は`文書片$である ］~AND［ %node の`~host$ ~NEQ ~NULL ］ ⇒ ~RET ◎ If node is a DocumentFragment node whose host is non-null, then return.
4. コレに`~nodeを受入する$( %node ) ◎ Adopt node into this.
5. ~RET %node ◎ Return node.

@createAttribute(localName) ~method手続きは： ◎ The createAttribute(localName) method steps are:

1. ~IF［ %localName は`妥当な属性~局所~名$でない ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If localName is not a valid attribute local name, then throw an "InvalidCharacterError" DOMException.
2. ~IF［ コレは`~HTML文書$である ］ ⇒ %localName ~SET `~ASCII小文字~化する$( %localName ) ◎ If this is an HTML document, then set localName to localName in ASCII lowercase.
3. ~RET 新たな`属性o$ — その ⇒＃ `局所~名$a ~SET %localName, `~node文書$ ~SET コレ ◎ Return a new attribute whose local name is localName and node document is this.

@createAttributeNS(namespace, qualifiedName) ~method手続きは： ◎ The createAttributeNS(namespace, qualifiedName) method steps are:

1. ( %~ns, %接頭辞, %局所~名 ) ~LET `~nsと名前を検証して抽出する$( %namespace, %qualifiedName, `属性^i ) ◎ Let (namespace, prefix, localName) be the result of validating and extracting namespace and qualifiedName given "attribute".
2. ~RET 新たな`属性o$ — その ⇒＃ `~ns$a ~SET %~ns, `~ns接頭辞$a ~SET %接頭辞, `局所~名$a ~SET %局所~名, `~node文書$ ~SET コレ ◎ Return a new attribute whose namespace is namespace, namespace prefix is prefix, local name is localName, and node document is this.

@createEvent(interface) ~method手続きは： ◎ The createEvent(interface) method steps are:

1. %構築子 ~LET ~NULL ◎ Let constructor be null.

2. ~IF［ %interface は［ 下の表tのいずれかの行の 1 列目の文字列 ］に `~ASCII大小無視$で合致する ］ ⇒ %構築子 ~SET ［ 合致した行の 2 列目の~interface ］の構築子 ◎ If interface is an ASCII case-insensitive match for any of the strings in the first column in the following table, then set constructor to the interface in the second column on the same row as the matching string:

   文字列 ◎ String	~interface ◎ Interface	仕様（空欄はこの仕様） ◎ Notes
   `beforeunloadevent^l	$BeforeUnloadEvent	`HTML$r
   `compositionevent^l	$CompositionEvent	`UIEVENTS$r
   `customevent^l	$CustomEvent
   `devicemotionevent^l	$DeviceMotionEvent	`DEVICE-ORIENTATION$r
   `deviceorientationevent^l	$DeviceOrientationEvent	同上
   `dragevent^l	$DragEvent	`HTML$r
   `event^l	$Event
   `events^l	同上
   `focusevent^l	$FocusEvent	`UIEVENTS$r
   `hashchangeevent^l	$HashChangeEvent	`HTML$r
   `htmlevents^l	$Event
   `keyboardevent^l	$KeyboardEvent	`UIEVENTS$r
   `messageevent^l	$MessageEvent	`HTML$r
   `mouseevent^l	$MouseEvent	`UIEVENTS$r
   `mouseevents^l	同上	同上
   `storageevent^l	$StorageEvent	`HTML$r
   `svgevents^l	$Event
   `textevent^l	$TextEvent	`UIEVENTS$r
   `touchevent^l	$TouchEvent	`TOUCH-EVENTS$r
   `uievent^l	$UIEvent	`UIEVENTS$r
   `uievents^l	同上	同上

3. ~IF［ %構築子 ~EQ ~NULL ］ ⇒ ~THROW `NotSupportedError$E ◎ If constructor is null, then throw a "NotSupportedError" DOMException.

4. ~IF［ %構築子 が指示する~interfaceは，コレに`関連な大域~obj$に公開されていない ］ ⇒ ~THROW `NotSupportedError$E ◎ If the interface indicated by constructor is not exposed on the relevant global object of this, then throw a "NotSupportedError" DOMException.

   注記： 概して~UAは、 環境設定によっては，~touch~eventの~supportを不能化する — その場合、 この段が $TouchEvent ~interface用に誘発されることになる。 ◎ Typically user agents disable support for touch events in some configurations, in which case this clause would be triggered for the interface TouchEvent.

5. %~event ~LET `~eventを作成する$( %構築子 ) ◎ Let event be the result of creating an event given constructor.
6. %~event の次に挙げる属性を初期化する ⇒＃ $Event.type ~SET 空~文字列, $Event.timeStamp ~SET `現在の高分解能~時刻$( コレに`関連な大域~obj$ ), $Event.isTrusted ~SET ~F ◎ Initialize event’s type attribute to the empty string. ◎ Initialize event’s timeStamp attribute to the result of calling current high resolution time with this’s relevant global object. ◎ Initialize event’s isTrusted attribute to false.
7. %~event の`初期化-済みか$ev ~SET ~F ◎ Unset event’s initialized flag.
8. ~RET %~event ◎ Return event.

注記： 代わりに，`~event$構築子が利用されるべきである。 ◎ Event constructors ought to be used instead.

@createRange() ~method手続きは ⇒ ~RET 新たな`~live範囲o$ — その ⇒＃ `始端$ ~SET `境界点$( コレ, 0 ), `終端$ ~SET `境界点$( コレ, 0 ) ◎ The createRange() method steps are to return a new live range with (this, 0) as its start an end.

注記： 代わりに， $Range.Range() 構築子を利用できる。 ◎ The Range() constructor can be used instead.

@DocumentFragment() 構築子~手続きは ⇒ コレの`~node文書$ ~SET `現在の大域~obj$に`結付けられた文書$ ◎ The new DocumentFragment() constructor steps are to set this’s node document to current global object’s associated Document.

`~shadow根$ %根 の`親~targetを取得する$ときは、 所与の ( ~event %~event ) に対し： ◎ A shadow root’s get the parent algorithm, given an event,＼

1. ~IF［ %~event の`~composedか$ev ~EQ ~F ］~AND［ %根 ~EQ ［［［ %~event の`経路$ ］内の最初の構造体 ］の`呼出n~target$evP ］の`根$ ］ ⇒ ~RET ~NULL ◎ returns null if event’s composed flag is unset and shadow root is the root of event’s path’s first struct’s invocation target;＼
2. ~RET %根 の`~host$ ◎ otherwise shadow root’s host.

~obj %A を ~obj %B に向けて `~targetし直す@ ~algoは： ◎ To retarget an object A against an object B,＼

1. ~WHILE 無条件： ◎ repeat these steps until they return an object:

   1. %根 ~LET %A の`根$ ◎ ↓

   2. ~IF［ ~OR↓ ］… ◎ If one of the following is true

      • %A は`~node$でない ◎ A is not a node
      • %根 は`~shadow根$でない ◎ A’s root is not a shadow root
      • ［ %B は`~node$である ］~AND［ %根 は %B の`~shadowも含めた広義-先祖$である ］ ◎ B is a node and A’s root is a shadow-including inclusive ancestor of B

      …ならば ⇒ ~RET %A ◎ then return A.

   3. %A ~SET %根 の`~host$ ◎ Set A to A’s root’s host.

注記： `~targetし直す$~algoは、 ~eventの`配送-$時, および `FULLSCREEN$r などの他の仕様により利用される。 ◎ The retargeting algorithm is used by event dispatch as well as other specifications, such as Fullscreen. [FULLSCREEN]

`要素$ %要素 の `有修飾~名@ は、 次の手続きの結果を返す：

1. %接頭辞 ~LET %要素 の`~ns接頭辞$el
2. %局所~名 ~LET %要素 の`局所~名$el
3. ~IF［ %接頭辞 ~EQ ~NULL ］ ⇒ ~RET %局所~名
4. ~RET 次を順に`連結する$ ⇒＃ %接頭辞, `:^l, %局所~名

`要素$ %要素 の `~HTML大文字~化~有修飾~名@ は、 次の手続きの結果を返す： ◎ An element’s HTML-uppercased qualified name is the return value of these steps:

1. %有修飾~名 ~LET %要素 の`有修飾~名$ ◎ Let qualifiedName be this’s qualified name.
2. ~IF［ %要素 は`~HTML~ns$に属する ］~AND［ %要素 の`~node文書$は`~HTML文書$である ］ ⇒ ~RET `~ASCII大文字~化する$( %有修飾~名 ) ◎ If this is in the HTML namespace and its node document is an HTML document, then set qualifiedName to qualifiedName in ASCII uppercase.
3. ~RET %有修飾~名 ◎ Return qualifiedName.

注記： ~UAは、 `有修飾~名$と`~HTML大文字~化~有修飾~名$を内部~slotに格納して最適化することもできる。 ◎ User agents could optimize qualified name and HTML-uppercased qualified name by storing them in internal slots.

`要素を作成する@ ~algoは、 所与の ⇒＃ `文書$ %文書, 文字列 %局所~名, ［ ~NULL ／文字列 ］ %~ns, ［ ~NULL ／文字列 ］ %接頭辞 （省略時は ~NULL ）, ［ ~NULL ／文字列 ］ %is （省略時は ~NULL ）, 真偽値 %同期~custom要素か（省略時は ~F ）, ［ ~NULL ／ `default^l ／ $CustomElementRegistry ~obj ］ %~registry （省略時は ~F ） ◎終 に対し： ◎ To create an element, given a document document, string localName, string-or-null namespace, and optionally a string-or-null prefix (default null), string-or-null is (default null), boolean synchronousCustomElements (default false), and "default", null, or a CustomElementRegistry object registry (default "default"):

1. %結果 ~LET ~NULL ◎ Let result be null.
2. ~IF［ %~registry ~EQ `default^l ］ ⇒ %~registry ~SET `~custom要素~registryを検索する$( %文書 ) ◎ If registry is "default", then set registry to the result of looking up a custom element registry given document.
3. %定義 ~LET `~custom要素~定義を検索する$( %~registry, %~ns, %局所~名, %is ) ◎ Let definition be the result of looking up a custom element definition given registry, namespace, localName, and is.

4. ~IF［ %定義 ~NEQ ~NULL ］~AND［ %定義 の`名前$cD ~NEQ %定義 の`局所~名$cD ］（すなわち，%定義 は`~custom化された組込みの要素$を表現する）： ◎ If definition is non-null, and definition’s name is not equal to its local name (i.e., definition represents a customized built-in element):

   1. %~interface ~LET ( %局所~名, `~HTML~ns$ ) 用の`要素~interface$ ◎ Let interface be the element interface for localName and the HTML namespace.
   2. %結果 ~SET `要素を内部的に作成する$( ↓ ) ⇒＃ %文書, %~interface, %局所~名, `~HTML~ns$, %接頭辞, `undefined^l, %is, %~registry ◎ Set result to the result of creating an element internal given document, interface, localName, the HTML namespace, prefix, "undefined", is, and registry.

   3. ~IF［ %同期~custom要素か ~EQ ~T ］ ⇒ `要素を昇格する$( %定義, %結果 ) ◎ If synchronousCustomElements is true, then run this step while catching any exceptions: • Upgrade result using definition.

      この段から例外 %例外 が投出されたときは、 ~catchして： ◎ If this step threw an exception exception:

      1. `例外を報告する$( %例外, %定義 の`構築子$cDに対応する~JS~objが`属する~realm$の`大域~obj$rM ) ◎ Report exception for definition’s constructor’s corresponding JavaScript object’s associated realm’s global object.
      2. %結果 の`~custom要素~状態$el ~SET `failed^l ◎ Set result’s custom element state to "failed".
   4. ~ELSE ⇒ `~custom要素~昇格~反応を~enqueueする$( %結果, %定義 ) ◎ Otherwise, enqueue a custom element upgrade reaction given result and definition.

5. ~ELIF［ %定義 ~NEQ ~NULL ］~AND［ %同期~custom要素か ~EQ ~T ］： ◎ Otherwise, if definition is non-null: • If synchronousCustomElements is true:

   1. %C ~LET %定義 の`構築子$cD ◎ Let C be definition’s constructor.
   2. `~surrounding~agent$にて`作動中な~custom要素~構築子~map$[ %C ] ~SET %~registry ◎ Set the surrounding agent’s active custom element constructor map[C] to registry.

   3. この段から例外が投出されたときは、 ~catchして，下の (A) に~~移行するとする： ◎ Run these steps while catching any exceptions:

      1. %結果 ~SET `~callback関数で構築する$( %C, 空な引数~list ) ◎ Set result to the result of constructing C, with no arguments.
      2. ~Assert： %結果 の［ `~custom要素~状態$el, `~custom要素~定義$el ］は初期化-済みである ◎ Assert: result’s custom element state and custom element definition are initialized.

      3. ~Assert： %結果 の`~ns$el ~EQ `~HTML~ns$ ◎ Assert: result’s namespace is the HTML namespace.

         注記： ~IDLにより， %結果 は $HTMLElement ~objになるよう施行され、 そのような~objは，すべて`~HTML~ns$を利用する。 ◎ IDL enforces that result is an HTMLElement object, which all use the HTML namespace.

      4. ~IF［ ~OR↓ ］…

         • %結果 の`属性o~list$elは`空$でない
         • %結果 の`子~群$は`空$でない
         • %結果 の`親$ ~NEQ ~NULL
         • %結果 の`~node文書$ ~NEQ %文書
         • %結果 の`局所~名$el ~NEQ %局所~名

         …ならば ⇒ ~THROW `NotSupportedError$E

         ◎ If result’s attribute list is not empty, then throw a "NotSupportedError" DOMException. ◎ If result has children, then throw a "NotSupportedError" DOMException. ◎ If result’s parent is not null, then throw a "NotSupportedError" DOMException. ◎ If result’s node document is not document, then throw a "NotSupportedError" DOMException. ◎ If result’s local name is not equal to localName, then throw a "NotSupportedError" DOMException.
      5. %結果 の ⇒＃ `~ns接頭辞$el ~SET %接頭辞, `~is0値$el ~SET ~NULL, `~custom要素~registry$el ~SET %~registry ◎ Set result’s namespace prefix to prefix. ◎ Set result’s is value to null. ◎ Set result’s custom element registry to registry.

      (A) — 上の手続きにて，例外 %例外 が投出されたときは： ◎ If any of these steps threw an exception exception:

      1. `例外を報告する$( %例外, %定義 の`構築子$cDに対応する~JS~objが`属する~realm$の`大域~obj$rM ) ◎ Report exception for definition’s constructor’s corresponding JavaScript object’s associated realm’s global object.
      2. %結果 ~SET `要素を内部的に作成する$( ↓ ) ⇒＃ %文書, $HTMLUnknownElement, %局所~名, `~HTML~ns$, %接頭辞, `failed^l, ~NULL, %~registry ◎ Set result to the result of creating an element internal given document, HTMLUnknownElement, localName, the HTML namespace, prefix, "failed", null, and registry.

   4. `~surrounding~agent$にて`作動中な~custom要素~構築子~map$[ %C ] ~SET ε ◎ Remove the surrounding agent’s active custom element constructor map[C].

      注記： 通常の状況下では、 この~entryは，この時点ですでに除去-済み（ ε ）である。 ◎ Under normal circumstances it will already have been removed at this point.

6. ~ELIF［ %定義 ~NEQ ~NULL ］： ◎ ↑ ◎ Otherwise:

   1. %結果 ~SET `要素を内部的に作成する$( ↓ ) ⇒＃ %文書, $HTMLElement, %局所~名, `~HTML~ns$, %接頭辞, `undefined^l, ~NULL, %~registry ◎ Set result to the result of creating an element internal given document, HTMLElement, localName, the HTML namespace, prefix, "undefined", null, and registry.
   2. `~custom要素~昇格~反応を~enqueueする$( %結果, %定義 ) ◎ Enqueue a custom element upgrade reaction given result and definition.

7. ~ELSE： ◎ Otherwise:

   1. %~interface ~LET ( %局所~名, %~ns ) 用の`要素~interface$ ◎ Let interface be the element interface for localName and namespace.
   2. %結果 ~SET `要素を内部的に作成する$( ↓ ) ⇒＃ %文書, %~interface, %局所~名, %~ns, %接頭辞, `uncustomized^l, %is, %~registry ◎ Set result to the result of creating an element internal given document, interface, localName, namespace, prefix, "uncustomized", is, and registry.

   3. ~IF［ ~AND↓ ］…

      • %~ns ~EQ `~HTML~ns$
      • ［ %局所~名 は`妥当な~custom要素~名$である ］~OR［ %is ~NEQ ~NULL ］

      …ならば ⇒ %結果 の`~custom要素~状態$el ~SET `undefined^l

      ◎ If namespace is the HTML namespace, and either localName is a valid custom element name or is is non-null, then set result’s custom element state to "undefined".
8. ~RET %結果 ◎ Return result.

`要素を内部的に作成する@ ~algoは、 所与の ⇒＃ `文書$ %文書, 要素~interface %~interface, 文字列 %局所~名, ［ ~NULL／ 文字列 ］ %~ns, ［ ~NULL／ 文字列 ］ %接頭辞, 文字列 %状態, ［ ~NULL／ 文字列 ］ %is, ［ ~NULL／ $CustomElementRegistry ~obj ］ %~registry ◎終 に対し： ◎ To create an element internal given a document document, an interface interface a string localName, a string-or-null namespace, a string-or-null prefix, a string state, a string-or-null is, and null or a CustomElementRegistry object registry:

1. %要素 ~LET `新たな~obj$( %~interface ) — その ⇒＃ `~ns$el ~SET %~ns, `~ns接頭辞$el ~SET %接頭辞, `局所~名$el ~SET %局所~名 , `~custom要素~registry$el ~SET %~registry , `~custom要素~状態$el ~SET %状態 , `~custom要素~定義$el ~SET ~NULL, `~is0値$el ~SET %is, `~node文書$ ~SET %文書 ◎ Let element be a new element that implements interface, with namespace set to namespace, namespace prefix set to prefix, local name set to localName, custom element registry set to registry, custom element state set to state, custom element definition set to null, is value set to is, and node document set to document.
2. ~Assert： %要素 の`属性o~list$elは`空$である ◎ Assert: element’s attribute list is empty.
3. ~RET %要素 ◎ Return element.

`属性o値の変化を取扱う@ ~algoは、 所与の ( `属性o$ %属性o, %要素, %旧-値, %新-値 ) に対し： ◎ To handle attribute changes for an attribute attribute with element, oldValue, and newValue, run these steps:

1. %要素 用に種別 `attributes^l の`変異~記録を~queueする$( ↓ ) ⇒＃ %属性o の`局所~名$a, %属性o の`~ns$a, %旧-値, « », « », ~NULL, ~NULL ◎ Queue a mutation record of "attributes" for element with attribute’s local name, attribute’s namespace, oldValue, « », « », null, and null.
2. ~IF［ %要素 は`~custom$である ］ ⇒ `~custom要素~callback反応を~enqueueする$( %要素, `attributeChangedCallback^l, « %属性o の`局所~名$a, %旧-値, %新-値, %属性o の`~ns$a » ) ◎ If element is custom, then enqueue a custom element callback reaction with element, callback name "attributeChangedCallback", and « attribute’s local name, oldValue, newValue, attribute’s namespace ».
3. `適用-可能な仕様$にて %要素 用に`定義された各$( `属性o変更-時の手続き$ %手続き ) に対し ⇒ %手続き( %属性o の`局所~名$a, %旧-値, %新-値, %属性o の`~ns$a ) ◎ Run the attribute change steps with element, attribute’s local name, oldValue, newValue, and attribute’s namespace.

`属性o値を変更する@ ~algoは、 所与の ( `属性o$ %属性o, %値 ) に対し： ◎ To change an attribute attribute to value, run these steps:

1. %旧-値 ~LET %属性o の`値$a ◎ Let oldValue be attribute’s value.
2. %属性o の`値$a ~SET %値 ◎ Set attribute’s value to value.
3. `属性o値の変化を取扱う$( %属性o, %属性o が`属する要素$, %旧-値, %値 ) ◎ Handle attribute changes for attribute with attribute’s element, oldValue, and value.

`属性oを付加する@ ~algoは、 所与の ( `属性o$ %属性o, `要素$ %要素 ) に対し： ◎ To append an attribute attribute to an element element, run these steps:

1. %要素 の`属性o~list$elに %属性o を`付加する$ ◎ Append attribute to element’s attribute list.
2. %属性o が`属する要素$ ~SET %要素 ◎ Set attribute’s element to element.
3. %属性o の`~node文書$ ~SET %要素 の`~node文書$ ◎ Set attribute’s node document to element’s node document.
4. `属性o値の変化を取扱う$( %属性o, %要素, ~NULL, %属性o の`値$a ) ◎ Handle attribute changes for attribute with element, null, and attribute’s value.

`属性oを除去する@ ~algoは、 所与の ( `属性o$ %属性o ) に対し： ◎ To remove an attribute attribute, run these steps:

1. %要素 ~LET %属性o が`属する要素$ ◎ Let element be attribute’s element.
2. %要素 の`属性o~list$elから %属性o を`除去する$ ◎ Remove attribute from element’s attribute list.
3. %属性o が`属する要素$ ~SET ~NULL ◎ Set attribute’s element to null.
4. `属性o値の変化を取扱う$( %属性o, %要素, %属性o の`値$a, ~NULL ) ◎ Handle attribute changes for attribute with element, attribute’s value, and null.

`属性oを置換する@ ~algoは、 所与の ( `属性o$ %旧-属性o, `属性o$ %新-属性o ) に対し： ◎ To replace an attribute oldAttribute with an attribute newAttribute:

1. %要素 ~LET %旧-属性o が`属する要素$ ◎ Let element be oldAttribute’s element.
2. %要素 の`属性o~list$el内で， %旧-属性o を %新-属性o に`置換する$ ◎ Replace oldAttribute by newAttribute in element’s attribute list.
3. %新-属性o が`属する要素$ ~SET %要素 ◎ Set newAttribute’s element to element.
4. %新-属性o の`~node文書$ ~SET %要素 の`~node文書$ ◎ Set newAttribute’s node document to element’s node document.
5. %旧-属性o が`属する要素$ ~SET ~NULL ◎ Set oldAttribute’s element to null.
6. `属性o値の変化を取扱う$( %旧-属性o, %要素, %旧-属性o の`値$a, %新-属性o の`値$a ) ◎ Handle attribute changes for oldAttribute with element, oldAttribute’s value, and newAttribute’s value.

`要素$ %要素 の `属性oを名前により取得する@ ~algoは、 所与の ( 文字列 %有修飾~名 ) に対し： ◎ To get an attribute by name given a string qualifiedName and an element element:

1. ~IF［ %要素 は`~HTML~ns$に属する ］~AND［ %要素 の`~node文書$は`~HTML文書$である ］ ⇒ %有修飾~名 ~SET `~ASCII小文字~化する$( %有修飾~名 ) ◎ If element is in the HTML namespace and its node document is an HTML document, then set qualifiedName to qualifiedName in ASCII lowercase.
2. ~RET %要素 の`属性o~list$elを成す`属性o$のうち，次を満たす`最初のもの？$ ⇒ `有修飾~名$a ~EQ %有修飾~名 ◎ Return the first attribute in element’s attribute list whose qualified name is qualifiedName; otherwise null.

`要素$ %要素 の `属性oを~nsと局所~名により取得する@ ~algoは、 所与の ( ［ 文字列 ／ ~NULL ］ %~ns, 文字列 %局所~名 ) に対し： ◎ To get an attribute by namespace and local name given null or a string namespace, a string localName, and an element element:

1. ~RET %要素 の`属性o~list$elを成す`属性o$のうち，次を満たす`最初のもの？$ ⇒ ［ `~ns$a ~EQ %~ns ］~AND［ `局所~名$a ~EQ %局所~名 ］ ◎ Return the attribute in element’s attribute list whose namespace is namespace and local name is localName, if any; otherwise null.

`要素$ %要素 の `属性o値を取得する@ ~algoは、 所与の ( 文字列 %局所~名, ［ 文字列 ／ ~NULL ］ %~ns （省略時は ~NULL ） ) に対し： ◎ To get an attribute value given an element element, a string localName, and an optional null or string namespace (default null):

1. %属性o ~LET %要素 の`属性oを~nsと局所~名により取得する$( %局所~名, %~ns ) ◎ Let attr be the result of getting an attribute given namespace, localName, and element.
2. ~RET ［ %属性o ~EQ ~NULL ならば空~文字列 ／ ~ELSE_ %属性o の`値$a ］ ◎ If attr is null, then return the empty string. ◎ Return attr’s value.

`要素$ %要素 の `属性oを設定する@ ~algoは、 所与の ( `属性o$ %属性o ) に対し： ◎ To set an attribute given an attribute attr and an element element:

1. ~IF［ %属性o が`属する要素$ ~NIN { ~NULL, %要素 } ］ ⇒ ~THROW `InUseAttributeError$E ◎ If attr’s element is neither null nor element, throw an "InUseAttributeError" DOMException.
2. %旧-属性o ~LET %要素 の`属性oを~nsと局所~名により取得する$( %属性o の`~ns$a, %属性o の`局所~名$a ) ◎ Let oldAttr be the result of getting an attribute given attr’s namespace, attr’s local name, and element.
3. ~IF［ %旧-属性o ~EQ %属性o ］ ⇒ ~RET %属性o ◎ If oldAttr is attr, return attr.
4. ~IF［ %旧-属性o ~NEQ ~NULL ］ ⇒ `属性oを置換する$( %旧-属性o, %属性o ) ◎ If oldAttr is non-null, then replace oldAttr with attr.
5. ~ELSE ⇒ `属性oを付加する$( %属性o, %要素 ) ◎ Otherwise, append attr to element.
6. ~RET %旧-属性o ◎ Return oldAttr.

`要素$ %要素 の `属性o値を設定する@ ~algoは、 所与の ⇒＃ 文字列 %局所~名, 文字列 %値, ［ 文字列 ／ ~NULL ］ %接頭辞 （省略時は ~NULL ）, ［ 文字列 ／ ~NULL ］ %~ns （省略時は ~NULL ） ) ◎終 に対し： ◎ To set an attribute value given an element element, a string localName, a string value, an optional null or string prefix (default null), and an optional null or string namespace (default null):

1. %属性o ~LET %要素 の`属性oを~nsと局所~名により取得する$( %~ns, %局所~名 ) ◎ Let attribute be the result of getting an attribute given namespace, localName, and element.

2. ~IF［ %属性o ~EQ ~NULL ］： ◎ If attribute is null,＼

   1. %属性o ~LET 新たな`属性o$ — その ⇒＃ `~ns$a ~SET %~ns, `~ns接頭辞$a ~SET %接頭辞, `局所~名$a ~SET %局所~名, `値$a ~SET %値, `~node文書$ ~SET %要素 の`~node文書$ ◎ create an attribute whose namespace is namespace, namespace prefix is prefix, local name is localName, value is value, and node document is element’s node document,＼
   2. `属性oを付加する$( %属性o, %要素 ) ◎ then append this attribute to element,＼
   3. ~RET ◎ and then return.
3. `属性o値を変更する$( %属性o, %値 ) ◎ Change attribute to value.

`要素$ %要素 の `属性oを名前により除去する@ ~algoは、 所与の ( 文字列 %有修飾~名 ) に対し： ◎ To remove an attribute by name given a string qualifiedName and an element element:

1. %属性o ~LET %要素 の`属性oを名前により取得する$( %有修飾~名 ) ◎ Let attr be the result of getting an attribute given qualifiedName and element.
2. ~IF［ %属性o ~NEQ ~NULL ］ ⇒ `属性oを除去する$( %属性o ) ◎ If attr is non-null, then remove attr.
3. ~RET %属性o ◎ Return attr.

`要素$ %要素 の `属性oを~nsと局所~名により除去する@ ~algoは、 所与の ( ［ 文字列 ／ ~NULL ］ %~ns, 文字列 %局所~名 ) に対し： ◎ To remove an attribute by namespace and local name given null or a string namespace, a string localName, and an element element:

1. %属性o ~LET %要素 の`属性oを~nsと局所~名により取得する$( %~ns, %局所~名 ) ◎ Let attr be the result of getting an attribute given namespace, localName, and element.
2. ~IF［ %属性o ~NEQ ~NULL ］ ⇒ `属性oを除去する$( %属性o ) ◎ If attr is non-null, then remove attr.
3. ~RET %属性o ◎ Return attr.

`要素$ %要素 の`~ID$を更新するときは、 %要素 用の`属性o変更-時の手続き$として次を利用する — それは、 所与の ( %局所~名, %旧-値, %値, %~ns ) に対し：

1. ~IF［ %局所~名 ~EQ `id^l ］~AND［ %~ns ~EQ ~NULL ］ ⇒ %要素 の`~ID$ ~SET ［ %値 ~IN { ~NULL, 空~文字列 } ならば ε ／ ~ELSE_ %値 ］

@classList 取得子~手続きは ⇒ ~RET $DOMTokenList — その ⇒＃ `要素$tL ~SET コレ, `属性oの局所~名$tL ~SET ^class ◎ The classList getter steps are to return a DOMTokenList object whose associated element is this and whose associated attribute’s local name is class.＼

この取得子が返す $DOMTokenList ~objの`~token集合$tLは、 当の`要素$の `~class群@ とも称される。 ◎ The token set of this particular DOMTokenList object are also known as the element’s classes.

【 [`SameObject$] が指定されているので、 各~要素と $DOMTokenList の各~instanceは，一対一に対応する。 】

@getAttributeNames() ~method手続きは：

1. %結果 ~LET « »
2. コレの`属性o~list$elを成す ~EACH( %属性o ) に対し ⇒ %結果 に %属性o の`有修飾~名$aを`付加する$
3. ~RET %結果

注記： 名前が %結果 内で一意になることは保証されない。

@getAttribute(qualifiedName) ~method手続きは： ◎ The getAttribute(qualifiedName) method steps are:

1. %属性o ~LET コレの`属性oを名前により取得する$( %qualifiedName ) ◎ Let attr be the result of getting an attribute given qualifiedName and this.
2. ~RET ［ %属性o ~EQ ~NULL ならば ~NULL ／ ~ELSE_ %属性o の`値$a ］ ◎ If attr is null, return null. ◎ Return attr’s value.

@getAttributeNS(namespace, localName) ~method手続きは： ◎ The getAttributeNS(namespace, localName) method steps are:

1. %属性o ~LET コレの`属性oを~nsと局所~名により取得する$( %namespace, %localName ) ◎ Let attr be the result of getting an attribute given namespace, localName, and this.
2. ~IF［ %属性o ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If attr is null, return null.
3. ~RET %属性o の`値$a ◎ Return attr’s value.

@setAttribute(qualifiedName, value) ~method手続きは： ◎ The setAttribute(qualifiedName, value) method steps are:

1. ~IF［ %qualifiedName は`妥当な属性~局所~名$でない ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If qualifiedName is not a valid attribute local name, then throw an "InvalidCharacterError" DOMException.

   注記： %qualifiedName と命名されてはいるが、 それは［ それを`有修飾~名$aに伴う`属性o$が すでに存在する場合 ］に限り有修飾~名として利用される。 他の場合、 新たな属性oの`局所~名$aとして利用される。 それを検証する必要は、 後者の事例に限られる。 ◎ Despite the parameter naming, qualifiedName is only used as a qualified name if an attribute already exists with that qualified name. Otherwise, it is used as the local name of the new attribute. We only need to validate it for the latter case.

2. ~IF［ コレは`~HTML~ns$に属する ］~AND［ コレの`~node文書$は`~HTML文書$である ］ ⇒ %qualifiedName ~SET `~ASCII小文字~化する$( %qualifiedName ) ◎ If this is in the HTML namespace and its node document is an HTML document, then set qualifiedName to qualifiedName in ASCII lowercase.
3. %属性o ~LET コレの`属性o~list$elを成す`属性o$のうち，次を満たす`最初のもの？$ ⇒ `有修飾~名$a ~EQ %qualifiedName ◎ Let attribute be the first attribute in this’s attribute list whose qualified name is qualifiedName, and null otherwise.

4. ~IF［ %属性o ~EQ ~NULL ］： ◎ If attribute is null,＼

   1. %属性o ~LET 新たな`属性o$ — その ⇒＃ `局所~名$a ~SET %qualifiedName, `値$a ~SET %value, `~node文書$ ~SET コレの`~node文書$ ◎ create an attribute whose local name is qualifiedName, value is value, and node document is this’s node document,＼
   2. `属性oを付加する$( %属性o, コレ ) ◎ then append this attribute to this,＼
   3. ~RET ◎ and then return.
5. `属性o値を変更する$( %属性o, %value ) ◎ Change attribute to value.

@setAttributeNS(namespace, qualifiedName, value) ~method手続きは： ◎ The setAttributeNS(namespace, qualifiedName, value) method steps are:

1. コレの`属性o値を設定する$( %局所~名, %value, %接頭辞, %~ns ) ◎ Set an attribute value for this using localName, value, and also prefix and namespace.

@hasAttribute(qualifiedName) ~method手続きは： ◎ The hasAttribute(qualifiedName) method steps are:

1. ~RET ~IS［ コレの`属性o~list$el内に次を満たす`属性o$は在る ］ ⇒ `有修飾~名$a ~EQ %qualifiedName ◎ Return true if this has an attribute whose qualified name is qualifiedName; otherwise false.

@toggleAttribute(qualifiedName, force) ~method手続きは： ◎ The toggleAttribute(qualifiedName, force) method steps are:

1. 注記： なぜ %qualifiedName を［ 有修飾~名ではなく局所~名 ］として検証するかについては、 `上の論点＠#node-setAttribute-qualifiedName$ を見よ。 ◎ See the discussion above about why we validate it as a local name, instead of a qualified name.

2. %結果 ~LET ~IS［ %force ~EQ ~T ］~OR［［ %force ~EQ ε ］~AND［ %属性o ~EQ ~NULL ］］ ◎ ↓

3. ~IF［ %結果 ~EQ ~T ］~AND［ %属性o ~EQ ~NULL ］： ◎ If attribute is null:

   1. %属性o ~LET 新たな`属性o$ — その ⇒＃ `局所~名$a ~SET %qualifiedName, `値$a ~SET 空~文字列, `~node文書$ ~SET コレの`~node文書$ ◎ ↑If force is not given or is true,＼ create an attribute whose local name is qualifiedName, value is the empty string, and node document is this’s node document,＼
   2. `属性oを付加する$( %属性o, コレ ) ◎ then append this attribute to this,＼ ↓and then return true. ◎ ↓Return false.
4. ~ELIF［ %結果 ~EQ ~F ］~AND［ %属性o ~NEQ ~NULL ］ ⇒＃ コレの`属性oを名前により除去する$( %qualifiedName )； ◎ Otherwise, if force is not given or is false, remove an attribute given qualifiedName and this,＼ ↓and then return false.
5. ~RET %結果 ◎ Return true.

@hasAttributeNS(namespace, localName) ~method手続きは： ◎ The hasAttributeNS(namespace, localName) method steps are:

1. ~RET ~IS［ コレの`属性o~list$el内に次を満たす`属性o$は在る ］ ⇒ ［ `~ns$a ~EQ %namespace ］~AND［ `局所~名$a ~EQ %localName ］ ◎ Return true if this has an attribute whose namespace is namespace and local name is localName; otherwise false.

@removeAttributeNode(attr) ~method手続きは： ◎ The removeAttributeNode(attr) method steps are:

1. ~IF［ %attr ~NIN コレの`属性o~list$el ］ ⇒ ~THROW `NotFoundError$E ◎ If this’s attribute list does not contain attr, then throw a "NotFoundError" DOMException.
2. `属性oを除去する$( %attr ) ◎ Remove attr.
3. ~RET %attr ◎ Return attr.

@attachShadow(init) ~method手続きは： ◎ The attachShadow(init) method steps are:

1. %~registry ~LET %init[ "$ShadowRootInit.customElementRegistry" ] ◎ ↓
2. ~IF［ %~registry ~EQ ε ］ ⇒ %~registry ~SET コレの`~custom要素~registry$el ◎ Let registry be this’s custom element registry. ◎ If init["customElementRegistry"] exists, then set registry to it.
3. `~shadow根を付する$( ↓ ) ⇒＃ コレ, %init[ "$ShadowRootInit.mode" ], %init[ "$ShadowRootInit.clonable" ], %init[ "$ShadowRootInit.serializable" ], %init[ "$ShadowRootInit.delegatesFocus" ], %init[ "$ShadowRootInit.slotAssignment" ], %~registry ◎ Run attach a shadow root with this, init["mode"], init["clonable"], init["serializable"], init["delegatesFocus"], init["slotAssignment"], and registry.
4. ~RET コレの`~shadow根$el ◎ Return this’s shadow root.

`~shadow根を付する@ ~algoは、 所与の ⇒＃ `要素$ %要素, 文字列 %~mode, 真偽値 %~clone可能か, 真偽値 %直列化-可能か, 真偽値 %~focusを委任するか, $SlotAssignmentMode 値【！文字列】 %~slot割当n~mode, ［ ~NULL／ $CustomElementRegistry ~obj ］ %~fallback~registry ◎終 に対し： ◎ To attach a shadow root, given an element element, a string mode, a boolean clonable, a boolean serializable, a boolean delegatesFocus, a string slotAssignment, and null or a CustomElementRegistry object registry:

1. ~IF［ %要素 の`~ns$el ~NEQ `~HTML~ns$ ］ ⇒ ~THROW `NotSupportedError$E ◎ If element’s namespace is not the HTML namespace, then throw a "NotSupportedError" DOMException.
2. ~IF［ %要素 の`局所~名$elは`妥当な~shadow~host名$でない ］ ⇒ ~THROW `NotSupportedError$E ◎ If element’s local name is not a valid shadow host name, then throw a "NotSupportedError" DOMException.

3. ~IF［ %要素 の`局所~名$elは`妥当な~custom要素~名$である ］~OR［ %要素 の`~is0値$el ~NEQ ~NULL ］： ◎ If element’s local name is a valid custom element name, or element’s is value is non-null:

   1. %定義 ~LET `~custom要素~定義を検索する$( ↓ ) ⇒＃ %要素 の`~custom要素~registry$el, %要素 の`~ns$el, %要素 の`局所~名$el, %要素 の`~is0値$el ◎ Let definition be the result of looking up a custom element definition given element’s custom element registry, its namespace, its local name, and its is value.
   2. ~IF［ %定義 ~NEQ ~NULL ］~AND［ %定義 の`~shadowを不能化するか$cD ~EQ ~T ］ ⇒ ~THROW `NotSupportedError$E ◎ If definition is not null and definition’s disable shadow is true, then throw a "NotSupportedError" DOMException.
4. %現在の~shadow根 ~LET %要素 の`~shadow根$el ◎ ↓

5. ~IF［ %現在の~shadow根 ~NEQ ~NULL【！`~shadow~host$である】 ］： ◎ If element is a shadow host: • Let currentShadowRoot be element’s shadow root.

   1. ~IF［ ~OR↓ ］… ◎ If any of the following are true:

      • %現在の~shadow根 の`宣言的か$sR ~EQ ~F ◎ currentShadowRoot’s declarative is false; or
      • %現在の~shadow根 の`~mode$sR ~NEQ %~mode ◎ currentShadowRoot’s mode is not mode,

      …ならば ⇒ ~THROW `NotSupportedError$E ◎ then throw a "NotSupportedError" DOMException.

   2. ~ELSE： ◎ Otherwise:

      1. %現在の~shadow根 の`子~群$を成す ~EACH( %子 ) に対し【！`~tree順序$で】 ⇒ `~nodeを除去する$( %子 ) ◎ Remove all of currentShadowRoot’s children, in tree order.
      2. %現在の~shadow根 の`宣言的か$sR ~SET ~F ◎ Set currentShadowRoot’s declarative to false.
      3. ~RET ◎ Return.
6. %要素の内部特能から可用か ~LET ~IS［ %要素 の`~custom要素~状態$el ~IN { `precustomized^l, `custom^l } ］ ◎ ↓
7. %要素 の`~shadow根$el ~SET `新たな~obj$( $ShadowRoot ) — その ⇒＃ `~node文書$ ~SET %要素 の`~node文書$, `~host$ ~SET %要素, `~mode$sR ~SET %~mode, `~focusを委任するか$sR ~SET %~focusを委任するか, `要素の内部特能から可用か$sR ~SET %要素の内部特能から可用か, `~slot割当n~mode$sR ~SET %~slot割当n~mode, `宣言的か$sR ~SET ~F, `~clone可能か$sR ~SET %~clone可能か, `直列化-可能か$sR ~SET %直列化-可能か, `~custom要素~registry$sR ~SET %~registry ◎ Let shadow be a new shadow root whose node document is element’s node document, host is element, and mode is mode. ◎ Set shadow’s delegates focus to delegatesFocus. ◎ If element’s custom element state is "precustomized" or "custom", then set shadow’s available to element internals to true. ◎ Set shadow’s slot assignment to slotAssignment. ◎ Set shadow’s declarative to false. ◎ Set shadow’s clonable to clonable. ◎ Set shadow’s serializable to serializable. ◎ Set shadow’s custom element registry to registry. ◎ Set element’s shadow root to shadow.

@shadowRoot 取得子~手続きは： ◎ The shadowRoot getter steps are:

1. %~shadow ~LET コレの`~shadow根$el ◎ Let shadow be this’s shadow root.
2. ~IF［ %~shadow ~EQ ~NULL ］~OR［ %~shadow の`~mode$sR ~EQ `closed^l ］ ⇒ ~RET ~NULL ◎ If shadow is null or its mode is "closed", then return null.
3. ~RET %~shadow ◎ Return shadow.

@closest(selectors) ~method手続きは： ◎ The closest(selectors) method steps are:

1. %選択子 ~LET `選択子として構文解析する$( %selectors ) `SELECTORS4$r ◎ Let s be the result of parse a selector from selectors. [SELECTORS4]
2. ~IF［ %選択子 ~EQ `失敗^i ］ ⇒ ~THROW `SyntaxError$E ◎ If s is failure, then throw a "SyntaxError" DOMException.
3. %要素 ~LET コレ ◎ ↓

4. ~WHILE［ %要素 は`要素$である ］：

   1. ~IF［ `要素に対し選択子を照合する$( %要素, %選択子, `視野ng根$たちが成す集合 { コレ } ) ~EQ `成功^i `SELECTORS4$r ］ ⇒ ~RET %要素
   2. %要素 ~SET %要素 の`親$
   ◎ Let elements be this’s inclusive ancestors that are elements, in reverse tree order. ◎ For each element in elements, if match a selector against an element, using s, element, and scoping root this, returns success, return element. [SELECTORS4]
5. ~RET ~NULL ◎ Return null.

@matches(selectors) ~method手続きは： ◎ The matches(selectors) and webkitMatchesSelector(selectors) method steps are:

1. %選択子 ~LET `選択子として構文解析する$( %selectors ) `SELECTORS4$r ◎ Let s be the result of parse a selector from selectors. [SELECTORS4]
2. ~IF［ %選択子 ~EQ `失敗^i ］ ⇒ ~THROW `SyntaxError$E ◎ If s is failure, then throw a "SyntaxError" DOMException.
3. ~RET ~IS［ 次の結果 ~EQ `成功^i ］ ⇒ `要素に対し選択子を照合する$( コレ, %選択子, `視野ng根$たちが成す集合 { コレ } ) `SELECTORS4$r ◎ If the result of match a selector against an element, using s, this, and scoping root this, returns success, then return true; otherwise, return false. [SELECTORS4]

`要素$ %要素 の `隣に~nodeを挿入する@ ~algoは、 所与の ( 文字列 %where, `~node$ %~node ) に対し： ◎ To insert adjacent, given an element element, string where, and a node node,＼

1. %where ~SET `~ASCII小文字~化する$( %where ) ◎ ↓

2. %where に応じて： ◎ run the steps associated with the first ASCII case-insensitive match for where:

   • `beforebegin^l ⇒ ◎ "beforebegin"

     1. ~IF［ %要素 の`親$ ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If element’s parent is null, return null.
     2. ~RET %要素 の`親$の中で`~nodeを子の前に前挿入する$( %~node, %要素 ) ◎ Return the result of pre-inserting node into element’s parent before element.
   • `afterbegin^l ⇒ ~RET %要素 の中で`~nodeを子の前に前挿入する$( %~node, %要素 の`最初の子？$ ) ◎ "afterbegin" • Return the result of pre-inserting node into element before element’s first child.
   • `beforeend^l ⇒ ~RET %要素 の中で`~nodeを子の前に前挿入する$( %~node, ~NULL ) ◎ "beforeend" • Return the result of pre-inserting node into element before null.

   • `afterend^l： ◎ "afterend"

     1. ~IF［ %要素 の`親$ ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If element’s parent is null, return null.
     2. ~RET %要素 の`親$の中で`~nodeを子の前に前挿入する$( %~node, %要素 の`直後の同胞？$ ) ◎ Return the result of pre-inserting node into element’s parent before element’s next sibling.
   • その他 ⇒ ~THROW `SyntaxError$E ◎ Otherwise • Throw a "SyntaxError" DOMException.

@insertAdjacentText(where, data) ~method手続きは： ◎ The insertAdjacentText(where, data) method steps are:

1. %text ~LET `新たな~Text~node$( %data, コレの`~node文書$ ) ◎ Let text be a new Text node whose data is data and node document is this’s node document.
2. コレの`隣に~nodeを挿入する$( %where, %text ) ◎ Run insert adjacent, given this, where, and text.

注記： この~methodは何も返さない — それを設計する機会cを得る前からすでに存在していたので。 ◎ This method returns nothing because it existed before we had a chance to design it.

`文字~data~node$ %~node の `~dataを置換する@ ~algoは、 所与の ( %offset, %count, %data ) に対し： ◎ To replace data of node node with offset offset, count count, and data data, run these steps:

1. %長さ ~LET %~node の`長さ$node ◎ Let length be node’s length.
2. ~IF［ %offset ~GT %長さ ］ ⇒ ~THROW `IndexSizeError$E ◎ If offset is greater than length, then throw an "IndexSizeError" DOMException.
3. ~IF［ %offset ~PLUS %count ~GT %長さ ］ ⇒ %count ~SET %長さ ~MINUS %offset ◎ If offset plus count is greater than length, then set count to length minus offset.
4. %~node 用に種別 `characterData^l の`変異~記録を~queueする$( ↓ ) ⇒＃ ~NULL, ~NULL, %~node の`~data$, « », « », ~NULL, ~NULL ◎ Queue a mutation record of "characterData" for node with null, null, node’s data, « », « », null, and null.
5. %~node の`~data$ ~SET 次を順に`連結する$ ⇒＃ %~node の`~data$の中の 0 から %offset までを`成す符号単位~部分文字列$, %data, %~node の`~data$の中の ( %offset ~PLUS %count ) から`終端までを成す符号単位~部分文字列$ ◎ Insert data into node’s data after offset code units. ◎ Let delete offset be offset + data’s length. ◎ Starting from delete offset code units, remove count code units from node’s data.
6. %差分 ~LET %data の`長さ$str ~MINUS %count ◎ ↓

7. ~EACH( `~live範囲o$ %範囲o ) に対し：

   1. ~IF［ %範囲o の`始端~node$ ~EQ %~node ］：

      1. ~IF［ %offset ~LT %範囲o の`始端~offset$ ~LTE %offset ~PLUS %count ］ ⇒ %範囲o の`始端~offset$ ~SET %offset
      2. ~IF［ %範囲o の`始端~offset$ ~GT %offset ~PLUS %count ］ ⇒ %範囲o の`始端~offset$ ~INCBY %差分

   2. ~IF［ %範囲o の`終端~node$ ~EQ %~node ］：

      1. ~IF［ %offset ~LT %範囲o の`終端~offset$ ~LTE %offset ~PLUS %count ］ ⇒ %範囲o の`終端~offset$ ~SET %offset

         【 %範囲o の終端がちょうど置換される~~範囲の末尾を指している場合も，終端は置換した~~範囲の先頭に “寄せられる” ことになる。 】

      2. ~IF［ %範囲o の`終端~offset$ ~GT %offset ~PLUS %count ］ ⇒ %範囲o の`終端~offset$ ~INCBY %差分
   ◎ For each live range whose start node is node and start offset is greater than offset but less than or equal to offset plus count, set its start offset to offset. ◎ For each live range whose end node is node and end offset is greater than offset but less than or equal to offset plus count, set its end offset to offset. ◎ For each live range whose start node is node and start offset is greater than offset plus count, increase its start offset by data’s length and decrease it by count. ◎ For each live range whose end node is node and end offset is greater than offset plus count, increase its end offset by data’s length and decrease it by count.
8. ~IF［ %~node の`親$ ~NEQ ~NULL ］ ⇒ `適用-可能な仕様$にて %~node の`親$用に`定義された各$( `子~群~変更-時の手続き$ %手続き ) に対し ⇒ %手続き() ◎ If node’s parent is non-null, then run the children changed steps for node’s parent.

`文字~data~node$ %~node の `~dataの部分文字列@ は、 所与の ( %offset, %count ) に対し，次を走らせた結果を返す： ◎ To substring data with node node, offset offset, and count count, run these steps:

1. ~IF［ %offset ~PLUS %count ~GT %長さ ］ ⇒ %count ~LET %長さ ~MINUS %offset ◎ If offset plus count is greater than length, return a string whose value is the code units from the offsetth code unit to the end of node’s data, and then return.
2. ~RET `符号単位~部分文字列$( %~node の`~data$, %offset, %count ) ◎ Return a string whose value is the code units from the offsetth code unit to the offset+countth code unit in node’s data.

`新たな~Text~node@ は、 所与の ( %文字列, %文書 ) に対し ⇒ ~RET `新たな~obj$( $Text ) — その ⇒＃ `~data$ ~SET %文字列, `~node文書$ ~SET %文書

【 この手続きは、 他所を簡潔に述べるための，この訳による追加。 】

条件 %条件 を満たす， %~node を含む `連続的な同胞~列@ は、 次の結果を返す：

1. ~Assert： %~node は %条件 を満たす
2. ~WHILE［ %~node の`直前の同胞？$は %条件 を満たす ］ ⇒ %~node ~SET %~node の`直前の同胞？$
3. %~list ~LET « »

4. ~WHILE［ %~node は %条件 を満たす ］：

   1. %~list に %~node を`付加する$
   2. %~node ~SET %~node の`直後の同胞？$
5. ~RET %~list

【 この手続きは、 原文による “連続的な…” の（再帰的な）定義を等価な（かつ平坦~化された平易な）定義に変形したものである。 】

`~node$ %~node の `子~text内容@ は、 次の結果を返す：

1. %~list ~LET %~node の`子$のうち $Text `~node$であるものたちが成す`~tree順序$による`~list$
2. ~RET `~text~dataを連結する$( %~list )

`~node$ %~node の `子孫~text内容@ は、 次の結果を返す：

1. %~list ~LET %~node の`子孫$のうち $Text `~node$であるものたちが成す`~tree順序$による`~list$
2. ~RET `~text~dataを連結する$( %~list )

`~text~dataを連結する@ ~algoは、 所与の ( $Text `~node$たちが成す`~list$ %~list ) に対し：

1. %~data群 ~LET « »
2. %~list を成す ~EACH( %text ) に対し ⇒ %~data群 に %text の`~data$を`付加する$
3. ~RET %~data群 を`連結する$

【 この手続きは、 他所を簡潔に述べるための，この訳による追加。 】

@Text(data) 構築子~手続きは ⇒＃ コレの`~data$ ~SET %data, コレの`~node文書$ ~SET `現在の大域~obj$に`結付けられた文書$ ◎ The new Text(data) constructor steps are to set this’s data to data and this’s node document to current global object’s associated Document.

`~Text~nodeを分割する@ ~algoは、 所与の ( $Text `~node$ %~node, ~offset %offset ) に対し： ◎ To split a Text node node with offset offset, run these steps:

1. %count ~LET %長さ ~MINUS %offset ◎ Let count be length minus offset.
2. %新-~data ~LET コレの`~dataの部分文字列$( %offset, %count ) ◎ Let new data be the result of substringing data with node node, offset offset, and count count.
3. %新-~node ~LET `新たな~Text~node$( %新-~data, %~node の`~node文書$ ) ◎ Let new node be a new Text node, with the same node document as node. Set new node’s data to new data.
4. %親 ~LET %~node の`親$ ◎ Let parent be node’s parent.

5. ~IF［ %親 ~NEQ ~NULL ］： ◎ If parent is not null:

   1. %親 の中で`~nodeを子の前に挿入する$( %新-~node, %~node の`直後の同胞？$ ) ◎ Insert new node into parent before node’s next sibling.

   2. ~EACH( `~live範囲o$ %範囲o ) に対し： ◎ ↓

      1. ~IF［ %範囲o の`始端~node$ ~EQ %~node ］~AND［ %範囲o の`始端~offset$ ~GT %offset ］ ⇒＃ %範囲o の`始端~node$ ~SET %新-~node； %範囲o の`始端~offset$ ~DECBY %offset ◎ For each live range whose start node is node and start offset is greater than offset, set its start node to new node and decrease its start offset by offset.
      2. ~IF［ %範囲o の`終端~node$ ~EQ %~node ］~AND［ %範囲o の`終端~offset$ ~GT %offset ］ ⇒＃ %範囲o の`終端~node$ ~SET %新-~node； %範囲o の`終端~offset$ ~DECBY %offset ◎ For each live range whose end node is node and end offset is greater than offset, set its end node to new node and decrease its end offset by offset.
      3. ~IF［ %範囲o の`始端~node$ ~EQ %親 ］~AND［ %範囲o の`始端~offset$ ~EQ %~node の`~index$ ~PLUS 1 ］ ⇒ %範囲o の`始端~offset$ ~INCBY 1 ◎ For each live range whose start node is parent and start offset is equal to the index of node plus 1, increase its start offset by 1.
      4. ~IF［ %範囲o の`終端~node$ ~EQ %親 ］~AND［ %範囲o の`終端~offset$ ~EQ %~node の`~index$ ~PLUS 1 ］ ⇒ %範囲o の`終端~offset$ ~INCBY 1 ◎ For each live range whose end node is parent and end offset is equal to the index of node plus 1, increase its end offset by 1.
6. %~node の`~dataを置換する$( %offset, %count, 空~文字列 ) ◎ Replace data with node node, offset offset, count count, and data the empty string.
7. ~RET %新-~node ◎ Return new node.

@Comment(data) 構築子~手続きは ⇒＃ コレの`~data$ ~SET %data, コレの`~node文書$ ~SET `現在の大域~obj$に`結付けられた文書$ ◎ The new Comment(data) constructor steps are to set this’s data to data and this’s node document to current global object’s associated Document.

`境界点$ %A の［ `境界点$ %B に `相対的な位置bp@ ］が， %B ［ `より前@i ／ `に等しい@i ／ `より後@i ］のいずれかになるかは、 次に従って決定される： ◎ The position of a boundary point (nodeA, offsetA) relative to a boundary point (nodeB, offsetB) is before, equal, or after, as returned by these steps:

【 この~algoは、 2 つの境界点に対し，上に示した様な模式図における位置関係（左側が “より前” ）を算出する。 】

1. ( %nodeA, %offsetA, %nodeB, %offsetB ) ~LET ( %A の`~node$bp, %A の`~offset$bp, %B の`~node$bp, %B の`~offset$bp ) ◎ ↑
2. ~Assert： %nodeA の`根$ ~EQ %nodeB の`根$ ◎ Assert: nodeA and nodeB have the same root.
3. ~IF［ %nodeA ~EQ %nodeB ］ ⇒ ~RET ［ %offsetA ~LT %offsetB ならば `より前$i ／ %offsetA ~EQ %offsetB ならば `に等しい$i ／ %offsetA ~GT %offsetB ならば `より後$i ］ ◎ If nodeA is nodeB, then return equal if offsetA is offsetB, before if offsetA is less than offsetB, and after if offsetA is greater than offsetB.
4. ~IF［ %nodeA は %nodeB に`後続-$する ］ ⇒ ~RET %B は %A ［ `より前$i ならば `より後$i ／ `より後$i ならば `より前$i ］ ◎ If nodeA is following nodeB, then if the position of (nodeB, offsetB) relative to (nodeA, offsetA) is before, return after, and if it is after, return before.

5. ~IF［ %nodeA は %nodeB の`先祖$である ］： ◎ If nodeA is an ancestor of nodeB:

   1. %子 ~LET %nodeB ◎ Let child be nodeB.
   2. ~WHILE［ %子 の`親$ ~NEQ %nodeA ］ ⇒ %子 ~SET %子 の`親$ ◎ While child is not a child of nodeA, set child to its parent.
   3. ~IF［ %子 の`~index$ ~LT %offsetA ］ ⇒ ~RET `より後$i ◎ If child’s index is less than offsetA, then return after.
6. ~RET `より前$i ◎ Return before.

@StaticRange(init) 構築子~手続きは：

1. %始端~node ~LET %init[ "$startContainer" ]
2. %終端~node ~LET %init[ "$endContainer" ]
3. ~IF［ %始端~node, %終端~node いずれかは［ $DocumentType ／ $Attr ］`~node$である ］ ⇒ ~THROW `InvalidNodeTypeError$E
4. コレの`始端$ ~SET `境界点$( %始端~node, %init[ "$startOffset" ] ),
5. コレの`終端$ ~SET `境界点$( %終端~node, %init[ "$endOffset" ] )

`~live範囲o用の除去-前の手続き@ は、 所与の ( `~node$ %~node ) に対し： ◎ The live range pre-remove steps given a node node, are as follows:

1. %親 ~LET %~node の`親$ ◎ Let parent be node’s parent.
2. ~Assert： %親 ~NEQ ~NULL ◎ Assert: parent is not null.
3. %~index ~LET %~node の`~index$ ◎ Let index be node’s index.

4. ~EACH( `~live範囲o$ %範囲o ) に対し：

   1. ~IF［ %範囲o の`始端~node$ は %~node の`広義-子孫$である ］ ⇒＃ %範囲o の`始端~node$ ~SET %親； %範囲o の`始端~offset$ ~SET %~index
   2. ~IF［ %範囲o の`終端~node$ は %~node の`広義-子孫$である ］ ⇒＃ %範囲o の`終端~node$ ~SET %親； %範囲o の`終端~offset$ ~SET %~index
   3. ~IF［ %範囲o の`始端~node$ ~EQ %親 ］~AND［ %範囲o の`始端~offset$ ~GT %~index ］ ⇒ %範囲o の`始端~offset$ ~DECBY 1
   4. ~IF［ %範囲o の`終端~node$ ~EQ %親 ］~AND［ %範囲o の`終端~offset$ ~GT %~index ］ ⇒ %範囲o の`終端~offset$ ~DECBY 1
   ◎ For each live range whose start node is an inclusive descendant of node, set its start to (parent, index). ◎ For each live range whose end node is an inclusive descendant of node, set its end to (parent, index). ◎ For each live range whose start node is parent and start offset is greater than index, decrease its start offset by 1. ◎ For each live range whose end node is parent and end offset is greater than index, decrease its end offset by 1.

@Range() 構築子~手続きは：

1. %文書 ~LET `現在の大域~obj$に`結付けられた文書$
2. コレの`始端$ ~SET `境界点$( %文書, 0 )
3. コレの`終端$ ~SET `境界点$( %文書, 0 )

同じ~treeに`関与-$している 2 つの~node %A, %B の（最も末端の） `共通な広義-先祖@ は、 次を走らせた結果を返す：

1. ~WHILE［ %A は %B の`広義-先祖$でない ］ ⇒ %A ~SET %A の`親$
2. ~RET %A

【 この手続きは、 他所を簡潔に述べるための，この訳による追加。 】

`範囲o$ %範囲o の `境界点を設定する@ ~algoは、 所与の ( %端 ~IN { `始端^i, `終端^i }, `~node$ %node, 負でない整数 %offset ) に対し： ◎ To set the start or end of a range to a boundary point (node, offset), run these steps:

1. ~IF［ %node は`~doctype$である ］ ⇒ ~THROW `InvalidNodeTypeError$E ◎ If node is a doctype, then throw an "InvalidNodeTypeError" DOMException.
2. ~IF［ %offset ~GT %node の`長さ$node ］ ⇒ ~THROW `IndexSizeError$E ◎ If offset is greater than node’s length, then throw an "IndexSizeError" DOMException.
3. %境界点 ~LET `境界点$( %node, %offset ) ◎ Let bp be the boundary point (node, offset).

4. ~IF［ %端 ~EQ `始端^i ］： ◎ If these steps were invoked as "set the start"

   1. ~IF［ %範囲o の`根$rg ~NEQ %node の`根$ ］~OR［ %境界点 は %範囲o の`終端$`より後$i ］ ⇒ %範囲o の`終端$ ~SET %境界点 ◎ If range’s root is not equal to node’s root, or if bp is after the range’s end, set range’s end to bp.
   2. %範囲o の`始端$ ~SET %境界点 ◎ Set range’s start to bp.

5. ~ELSE（ %端 ~EQ `終端^i ） ◎ If these steps were invoked as "set the end"

   1. ~IF［ %範囲o の`根$rg ~NEQ %node の`根$ ］~OR［ %境界点 は %範囲o の`始端$`より前$i ］ ⇒ %範囲o の`始端$ ~SET %境界点 ◎ If range’s root is not equal to node’s root, or if bp is before the range’s start, set range’s start to bp.
   2. %範囲o の`終端$ ~SET %境界点 ◎ Set range’s end to bp.

@setStartBefore(node) ~method手続きは： ◎ The setStartBefore(node) method steps are:

1. %親 ~LET %node の`親$ ◎ Let parent be node’s parent.
2. ~IF［ %親 ~EQ ~NULL ］ ⇒ ~THROW `InvalidNodeTypeError$E ◎ If parent is null, then throw an "InvalidNodeTypeError" DOMException.
3. コレの`境界点を設定する$( `始端^i, %親, %node の`~index$ ) ◎ Set the start of this to boundary point (parent, node’s index).

@setStartAfter(node) ~method手続きは： ◎ The setStartAfter(node) method steps are:

1. コレの`境界点を設定する$( `始端^i, %親, %node の`~index$ ~PLUS 1 ) ◎ Set the start of this to boundary point (parent, node’s index plus 1).

@setEndBefore(node) ~method手続きは： ◎ The setEndBefore(node) method steps are:

1. コレの`境界点を設定する$( `終端^i, %親, %node の`~index$ ) ◎ Set the end of this to boundary point (parent, node’s index).

@setEndAfter(node) ~method手続きは： ◎ The setEndAfter(node) method steps are:

1. コレの`境界点を設定する$( `終端^i, %親, %node の`~index$ ~PLUS 1 ) ◎ Set the end of this to boundary point (parent, node’s index plus 1).

@collapse(toStart) ~method手続きは： ◎ The collapse(toStart) method steps are to,＼

1. ~IF［ %toStart ~EQ ~T ］ ⇒ コレの`終端$ ~SET `境界点$( コレの`始端~node$, コレの`始端~offset$ ) ◎ if toStart is true, set end to start;＼
2. ~ELSE ⇒ コレの`始端$ ~SET `境界点$( コレの`終端~node$, コレの`終端~offset$ ) ◎ otherwise set start to end.

`範囲oの中身として選択する@ ~algoは、 所与の ( `範囲o$ %範囲o, `~node$ %node ) に対し： ◎ To select a node node within a range range, run these steps:

1. %index ~LET %node の`~index$ ◎ Let index be node’s index.
2. %範囲o の`始端$ ~SET `境界点$( %親, %index ) ◎ Set range’s start to boundary point (parent, index).
3. %範囲o の`終端$ ~SET `境界点$( %親, %index ~PLUS 1 ) ◎ Set range’s end to boundary point (parent, index plus 1).

@selectNode(node) ~method手続きは ⇒ `範囲oの中身として選択する$( コレ, %node ) ◎ The selectNode(node) method steps are to select node within this.

@selectNodeContents(node) ~method手続きは： ◎ The selectNodeContents(node) method steps are:

1. ~IF［ %node は`~doctype$である ］ ⇒ ~THROW `InvalidNodeTypeError$E ◎ If node is a doctype, throw an "InvalidNodeTypeError" DOMException.
2. %長さ ~LET %node の`長さ$node ◎ Let length be the length of node.
3. コレの`始端$ ~SET `境界点$( %node, 0 ) ◎ Set start to the boundary point (node, 0).
4. コレの`終端$ ~SET `境界点$( %node, %長さ ) ◎ Set end to the boundary point (node, length).

@compareBoundaryPoints(how, sourceRange) ~method手続きは： ◎ The compareBoundaryPoints(how, sourceRange) method steps are:

1. ~IF［ %how ~NIN { $START_TO_START, $START_TO_END, $END_TO_END, $END_TO_START } ］ ⇒ ~THROW `NotSupportedError$E ◎ If how is not one of • START_TO_START • START_TO_END • END_TO_END • END_TO_START ◎ then throw a "NotSupportedError" DOMException.
2. ~IF［ コレの`根$rg ~NEQ %sourceRange の`根$rg ］ ⇒ ~THROW `WrongDocumentError$E ◎ If this’s root is not the same as sourceRange’s root, then throw a "WrongDocumentError" DOMException.

3. ( %基準点, %この点 ) ~LET %how に応じて，次で与えられる 2 個の`境界点$： ◎ If how is:

   $START_TO_START:

   ( %sourceRange の`始端$, コレの`始端$ ) ◎ Let this point be this’s start. Let other point be sourceRange’s start.

   $START_TO_END:

   ( %sourceRange の`始端$, コレの`終端$ ) ◎ Let this point be this’s end. Let other point be sourceRange’s start.

   $END_TO_END:

   ( %sourceRange の`終端$, コレの`終端$ ) ◎ Let this point be this’s end. Let other point be sourceRange’s end.

   $END_TO_START:

   ( %sourceRange の`終端$, コレの`始端$ ) ◎ Let this point be this’s start. Let other point be sourceRange’s end.

4. ~RET ［ %この点 は %基準点 ［ `より前$i ならば ~MINUS 1 ／ `に等しい$i ならば 0 ／ `より後$i ならば 1 ］ ◎ If the position of this point relative to other point is ◎ before • Return −1. ◎ equal • Return 0. ◎ after • Return 1.

@deleteContents() ~method手続きは： ◎ The deleteContents() method steps are:

1. ~IF［ コレは`畳まれて$いる ］ ⇒ ~RET ◎ If this is collapsed, then return.
2. ( %元の始端~node, %元の始端~offset, %元の終端~node, %元の終端~offset ) ~LET 順に，コレの ( `始端~node$, `始端~offset$, `終端~node$, `終端~offset$ ) ◎ Let original start node, original start offset, original end node, and original end offset be this’s start node, start offset, end node, and end offset, respectively.

3. ~IF［ %元の始端~node ~EQ %元の終端~node ］~AND［ %元の始端~node は`文字~data~node$である ］： ◎ If original start node is original end node and it is a CharacterData node, then＼

   1. %元の始端~node の`~dataを置換する$( %元の始端~offset, %元の終端~offset ~MINUS %元の始端~offset, 空~文字列 ) ◎ replace data with node original start node, offset original start offset, count original end offset minus original start offset, and data the empty string,＼
   2. ~RET ◎ and then return.
4. %除去-対象 ~LET 次を満たす`~node$たちが成す，`~tree順序$による~list ⇒ ［ コレに`包含され$ている ］~AND［ その`親$はコレに`包含され$ていない ］ ◎ Let nodes to remove be a list of all the nodes that are contained in this, in tree order, omitting any node whose parent is also contained in this.
5. ~IF［ %元の始端~node は %元の終端~node の`広義-先祖$である ］ ⇒＃ %新-~node ~LET %元の始端~node； %新-~offset ~LET %元の始端~offset ◎ If original start node is an inclusive ancestor of original end node, set new node to original start node and new offset to original start offset.

6. ~ELSE：

   1. %新-~node ~LET ( %元の始端~node, %元の終端~node ) の`共通な広義-先祖$
   2. %新-~offset ~LET ［ %新-~node の`子$のうち, %元の始端~node の`広義-先祖$である`~node$ † ］の`~index$ ~PLUS 1

   【 見通しを良くするため、 ここの訳は，原文を等価な記述に変形している。 前~段の条件の否定が成立することから † に該当する~nodeは必ず存在し， %新-~node に`部分的に包含され$ている子のうち 最初のものになる。 】

   ◎ Otherwise: • Let reference node equal original start node. • While reference node’s parent is not null and is not an inclusive ancestor of original end node, set reference node to its parent. • Set new node to the parent of reference node, and new offset to one plus the index of reference node. • If reference node’s parent were null, it would be the root of this, so would be an inclusive ancestor of original end node, and we could not reach this point.
7. ~IF［ %元の始端~node は`文字~data~node$である ］ ⇒ %元の始端~node の`~dataを置換する$( %元の始端~offset, %元の始端~node の`長さ$node ~MINUS %元の始端~offset, 空~文字列 ) ◎ If original start node is a CharacterData node, then replace data with node original start node, offset original start offset, count original start node’s length − original start offset, data the empty string.
8. %除去-対象 を成す ~EACH( %node ) に対し【！`~tree順序$で】 ⇒ `~nodeを除去する$( %node ) ◎ For each node in nodes to remove, in tree order, remove node.
9. ~IF［ %元の終端~node は`文字~data~node$である ］ ⇒ %元の終端~node の`~dataを置換する$( 0, %元の終端~offset, 空~文字列 ) ◎ If original end node is a CharacterData node, then replace data with node original end node, offset 0, count original end offset and data the empty string.
10. コレの ⇒＃ `始端$ ~SET `境界点$( %新-~node, %新-~offset )； `終端$ ~SET `境界点$( %新-~node, %新-~offset ) ◎ Set start and end to (new node, new offset).

`範囲oの中身を抽出する@ ~algoは、 所与の ( `~live範囲o$ %範囲o ) に対し： ◎ To extract a live range range, run these steps:

1. %文書片 ~LET 新たな`文書片$ — その ⇒ `~node文書$ ~SET %範囲o の`始端~node$の`~node文書$ ◎ Let fragment be a new DocumentFragment node whose node document is range’s start node’s node document.
2. ~IF［ %範囲o は`畳まれて$いる ］ ⇒ ~RET %文書片 ◎ If range is collapsed, then return fragment.
3. ( %元の始端~node, %元の始端~offset, %元の終端~node, %元の終端~offset ) ~LET 順に， %範囲o の ( `始端~node$, `始端~offset$, `終端~node$, `終端~offset$ ) ◎ Let original start node, original start offset, original end node, and original end offset be range’s start node, start offset, end node, and end offset, respectively.

4. ~IF［ %元の始端~node ~EQ %元の終端~node ］~AND［ %元の始端~node は`文字~data~node$である ］： ◎ If original start node is original end node and it is a CharacterData node:

   1. %clone ~LET `~nodeを~cloneする$( %元の始端~node ) ◎ Let clone be a clone of original start node.
   2. %clone の`~data$ ~SET %元の始端~node の`~dataの部分文字列$( %元の始端~offset, ( %元の終端~offset ~MINUS %元の始端~offset ) ) ◎ Set the data of clone to the result of substringing data with node original start node, offset original start offset, and count original end offset minus original start offset.
   3. %文書片 に`~nodeを付加する$( %clone ) ◎ Append clone to fragment.
   4. %元の始端~node の`~dataを置換する$( %元の始端~offset, %元の終端~offset ~MINUS %元の始端~offset, 空~文字列 ) ◎ Replace data with node original start node, offset original start offset, count original end offset minus original start offset, and data the empty string.
   5. ~RET %文書片 ◎ Return fragment.
5. %共通な広義-先祖 ~LET ( %元の始端~node, %元の終端~node ) の`共通な広義-先祖$ ◎ Let common ancestor be original start node. ◎ While common ancestor is not an inclusive ancestor of original end node, set common ancestor to its own parent.
6. %部分的に包含された最初の子 ~LET ~NULL ◎ Let first partially contained child be null.
7. ~IF［ %元の始端~node は %元の終端~node の`広義-先祖$でない ］ ⇒ %部分的に包含された最初の子 ~SET %範囲o に`部分的に包含され$ている［ %共通な広義-先祖 の`子$ ］のうち，最初のもの ◎ If original start node is not an inclusive ancestor of original end node, set first partially contained child to the first child of common ancestor that is partially contained in range.
8. %部分的に包含された最後の子 ~LET ~NULL ◎ Let last partially contained child be null.

9. ~IF［ %元の終端~node は %元の始端~node の`広義-先祖$でない ］ ⇒ %部分的に包含された最後の子 ~SET %範囲o に`部分的に包含され$ている［ %共通な広義-先祖 の`子$ ］のうち，最後のもの ◎ If original end node is not an inclusive ancestor of original start node, set last partially contained child to the last child of common ancestor that is partially contained in range.

   注記： これらの変数~代入は実際に常にイミを成す。 例えば， %元の始端~node が %元の終端~node の`広義-先祖$でない場合、［ %元の始端~node ~EQ %共通な広義-先祖 ］にはなり得ないので［ %元の始端~node の広義-先祖であって %共通な広義-先祖 の子孫でもあるもの ］が 1 つ以上あり，それらは %範囲o に`部分的に包含され$、 それらのうち %共通な広義-先祖 の子であるものが該当するものになる。 逆の場合も同様になる。 また、 2 つの子がいずれも定義されたなら，それらは決して等しくならないことにも注意。 ◎ These variable assignments do actually always make sense. For instance, if original start node is not an inclusive ancestor of original end node, original start node is itself partially contained in range, and so are all its ancestors up until a child of common ancestor. common ancestor cannot be original start node, because it has to be an inclusive ancestor of original end node. The other case is similar. Also, notice that the two children will never be equal if both are defined.

10. %包含された子~群 ~LET 次を満たす`~node$たちが成す，`~tree順序$による~list ⇒ ［ %共通な広義-先祖 の`子$である ］~AND %範囲o に`包含され$ている ］ ◎ Let contained children be a list of all children of common ancestor that are contained in range, in tree order.

11. ~IF［ %包含された子~群 内に`~doctype$が在る ］ ⇒ ~THROW `HierarchyRequestError$E ◎ If any member of contained children is a doctype, then throw a "HierarchyRequestError" DOMException.

    注記： `~doctype$が`部分的に包含され$ることは決してないので、 部分的に包含される~nodeを気にする必要はない。 それは 範囲o の境界点 【始端~node／終端~node】 にはなり得ず, 何かの先祖にもなり得ない。 ◎ We do not have to worry about the first or last partially contained node, because a doctype can never be partially contained. It cannot be a boundary point of a range, and it cannot be the ancestor of anything.

12. ~ELSE ⇒＃ %新-~node ~LET %共通な広義-先祖； %新-~offset ~LET %部分的に包含された最初の子 の`~index$ ~PLUS 1

    【 ここの訳は、 原文の記述と同じ結果を得るものに簡略化している。 】

    ◎ Otherwise: • Let reference node equal original start node. • While reference node’s parent is not null and is not an inclusive ancestor of original end node, set reference node to its parent. • Set new node to the parent of reference node, and new offset to one plus reference node’s index. • If reference node’s parent is null, it would be the root of range, so would be an inclusive ancestor of original end node, and we could not reach this point.

13. ~IF［ %部分的に包含された最初の子 は`文字~data~node$である ］： ◎ If first partially contained child is a CharacterData node:

    この事例では， %部分的に包含された最初の子 は %元の始端~node である。 ◎ In this case, first partially contained child is original start node.

    1. %clone の`~data$ ~SET %元の始端~node の`~dataの部分文字列$( %元の始端~offset, ( %元の始端~node の`長さ$node ~MINUS %元の始端~offset ) ) ◎ Set the data of clone to the result of substringing data with node original start node, offset original start offset, and count original start node’s length − original start offset.
    2. %元の始端~node の`~dataを置換する$( %元の始端~offset, %元の始端~node の`長さ$node ~MINUS %元の始端~offset, 空~文字列 ) ◎ Replace data with node original start node, offset original start offset, count original start node’s length − original start offset, and data the empty string.

14. ~ELIF［ %部分的に包含された最初の子 ~NEQ ~NULL ］： ◎ Otherwise, if first partially contained child is not null:

    1. %clone ~LET `~nodeを~cloneする$( %部分的に包含された最初の子 ) ◎ Let clone be a clone of first partially contained child.
    2. %下位-範囲o ~LET 新たな`~live範囲o$ — その ⇒＃ `始端$ ~SET `境界点$( %元の始端~node, %元の始端~offset ), `終端$ ~SET `境界点$( %部分的に包含された最初の子, %部分的に包含された最初の子 の`長さ$node ) ◎ Let subrange be a new live range whose start is (original start node, original start offset) and whose end is (first partially contained child, first partially contained child’s length).
    3. %下位-素片 ~LET `範囲oの中身を抽出する$( %下位-範囲o ) ◎ Let subfragment be the result of extracting subrange.
    4. %clone に`~nodeを付加する$( %下位-素片 ) ◎ Append subfragment to clone.
15. %包含された子~群 を成す ~EACH( %包含された子 ) に対し ⇒ %文書片 に`~nodeを付加する$( %包含された子 ) ◎ For each contained child in contained children, append contained child to fragment.

16. ~IF［ %部分的に包含された最後の子 は`文字~data~node$である ］： ◎ If last partially contained child is a CharacterData node:

    注記： この事例では， %部分的に包含された最後の子 は %元の始端~node である。 ◎ In this case, last partially contained child is original end node.

    1. %clone ~LET `~nodeを~cloneする$( %元の終端~node ) ◎ Let clone be a clone of original end node.
    2. %clone の`~data$ ~SET %元の終端~node の`~dataの部分文字列$( 0, %元の終端~offset ) ◎ Set the data of clone to the result of substringing data with node original end node, offset 0, and count original end offset.
    3. %元の終端~node の`~dataを置換する$( 0, %元の終端~offset, 空~文字列 ) ◎ Replace data with node original end node, offset 0, count original end offset, and data the empty string.

17. ~ELIF［ %部分的に包含された最後の子 ~NEQ ~NULL ］： ◎ Otherwise, if last partially contained child is not null:

    1. %clone ~LET `~nodeを~cloneする$( %部分的に包含された最後の子 ) ◎ Let clone be a clone of last partially contained child.
    2. %下位-範囲o ~LET 新たな`~live範囲o$ — その ⇒＃ `始端$ ~SET `境界点$( %部分的に包含された最後の子, 0 ), `終端$ ~SET `境界点$( %元の終端~node, %元の終端~offset ) ◎ Let subrange be a new live range whose start is (last partially contained child, 0) and whose end is (original end node, original end offset).
18. %範囲o の ⇒＃ `始端$ ~SET `境界点$( %新-~node, %新-~offset )； `終端$ ~SET `境界点$( %新-~node, %新-~offset ) ◎ Set range’s start and end to (new node, new offset).

`範囲oの中身を~cloneする@ ~algoは、 所与の ( `~live範囲o$ %範囲o ) に対し： ◎ To clone the contents of a live range range, run these steps:

3. 1. %下位-素片 ~LET `範囲oの中身を~cloneする$( %下位-範囲o ) ◎ Let subfragment be the result of cloning the contents of subrange.

4. %包含された子~群 を成す ~EACH( %包含された子 ) に対し： ◎ For each contained child in contained children:

   1. %clone ~LET `~nodeを~cloneする$( %包含された子, ~T【！the clone children flag set】 ) ◎ Let clone be a clone of contained child with the clone children flag set.

`範囲oの中へ挿入する@ ~algoは、 所与の ( `~live範囲o$ %範囲o, `~node$ %node ) に対し： ◎ To insert a node node into a live range range, run these steps:

【 `始端$の直後に %node を挿入する。 それに伴い、 終端は，末尾側からの相対位置が変化しないように適宜ずらされる （すなわち、［ 始端／終端 ］は，挿入-後においても［ 先頭／末尾 ］からの相対位置は不変）。 始端が`文字~data~node$の内部を指している場合、 その~nodeは始端の所で 2 つに分割される。 】

1. ( %始端~node, %始端~offset ) ~LET %範囲o の ( `始端~node$, `始端~offset$ ) ◎ ↓

2. ~IF［ %始端~node は ~OR↓ を満たす ］…

   • $ProcessingInstruction ~nodeである
   • $Comment ~nodeである
   • ［ $Text `~node$である ］~AND［ `親$ ~EQ ~NULL ］
   • %始端~node ~EQ %node

   …ならば ⇒ ~THROW `HierarchyRequestError$E

   ◎ If range’s start node is a ProcessingInstruction or Comment node, is a Text node whose parent is null, or is node, then throw a "HierarchyRequestError" DOMException.
3. %基準~node ~LET ~NULL ◎ Let referenceNode be null.
4. ~IF［ %始端~node は $Text `~node$である ］ ⇒ %基準~node ~SET %始端~node ◎ If range’s start node is a Text node, set referenceNode to that Text node.
5. ~ELIF［ %始端~node の`子$に［ `~index$ ~EQ %始端~offset ］なるものが在る ］ ⇒ %基準~node ~SET それ ◎ Otherwise, set referenceNode to the child of start node whose index is start offset, and null if there is no such child.
6. %親 ~LET ［ %基準~node ~NEQ ~NULL ならば その`親$ ／ ~ELSE_ %始端~node ］ ◎ Let parent be range’s start node if referenceNode is null, and referenceNode’s parent otherwise.
7. `親の中で子の前に挿入できるか検証する$( %node, %親, %基準~node ) ◎ Ensure pre-insert validity of node into parent before referenceNode.

8. ~IF［ %始端~node は $Text `~node$である ］ ⇒ %基準~node ~SET `~Text~nodeを分割する$( %始端~node, %始端~offset )

   【 %始端~offset が 0 でも分割されることになる。 】

   ◎ If range’s start node is a Text node, set referenceNode to the result of splitting it with offset range’s start offset.
9. ~IF［ %node ~EQ %基準~node ］ ⇒ %基準~node ~SET %node の`直後の同胞？$ ◎ If node is referenceNode, set referenceNode to its next sibling.
10. ~IF［ %node の`親$ ~NEQ ~NULL ］ ⇒ `~nodeを除去する$( %node ) ◎ If node’s parent is non-null, then remove node.
11. %新-~offset ~LET ［ %基準~node ~NEQ ~NULL ならば その`~index$ ／ ~ELSE_ %親 の`長さ$node ］ ◎ Let newOffset be parent’s length if referenceNode is null; otherwise referenceNode’s index.
12. %新-~offset ~INCBY ［ %node は`文書片$であるならば その`長さ$node ／ ~ELSE_ 1 ］ ◎ Increase newOffset by node’s length if node is a DocumentFragment node; otherwise 1.
13. %親 の中で`~nodeを子の前に前挿入する$( %node, %基準~node ) ◎ Pre-insert node into parent before referenceNode.

14. ~IF［ %範囲o は`畳まれて$いる ］ ⇒ %範囲o の`終端$ ~SET `境界点$( %親, %新-~offset )

    【 畳まれていない場合の終端の位置は，`~nodeを子の前に前挿入する$（手続きの中で`~nodeを子の前に挿入する$）段階で適宜ずらされる。 】

    ◎ If range is collapsed, then set range’s end to (parent, newOffset).

@surroundContents(newParent) ~method手続きは： ◎ The surroundContents(newParent) method steps are:

1. ~IF［ ある非 $Text `~node$がコレに`部分的に包含され$ている ］ ⇒ ~THROW `InvalidStateError$E ◎ If a non-Text node is partially contained in this, then throw an "InvalidStateError" DOMException.

2. ~IF［ %newParent は $Document, $DocumentType, $DocumentFragment `~node$ のいずれかである ］ ⇒ ~THROW `InvalidNodeTypeError$E ◎ If newParent is a Document, DocumentType, or DocumentFragment node, then throw an "InvalidNodeTypeError" DOMException.

   注記： 歴史的な理由から、 `文字~data~node$に対しては、 この段では検査されず，後の段にて副作用とともに例外が投出される結果になる。 ◎ For historical reasons CharacterData nodes are not checked here and end up throwing later on as a side effect.

3. %文書片 ~LET `範囲oの中身を抽出する$( コレ ) ◎ Let fragment be the result of extracting this.
4. ~IF［ %newParent の`子~群$は`空$でない ］ ⇒ %newParent の`全~内容を~nodeで置換する$( ~NULL ) ◎ If newParent has children, then replace all with null within newParent.
5. `範囲oの中へ挿入する$( コレ, %newParent ) ◎ Insert newParent into this.
6. %newParent に`~nodeを付加する$( %文書片 ) ◎ Append fragment to newParent.
7. `範囲oの中身として選択する$( コレ, %newParent ) ◎ Select newParent within this.

@detach() ~method手続きは、 何もしない。 ◎ The detach() method steps are to do nothing.＼

注記： この機能性（ ^Range ~objを不能化する）は、 除去された。 互換性のため存続はするが。 ◎ Its functionality (disabling a Range object) was removed, but the method itself is preserved for compatibility.

@isPointInRange(node, offset) ~method手続きは： ◎ The isPointInRange(node, offset) method steps are:

1. ~IF［ %node の`根$ ~NEQ コレの`根$rg ］ ⇒ ~RET ~F ◎ If node’s root is different from this’s root, return false.
2. ~IF［ `境界点$( %node, %offset ) は［［ コレの`始端$`より前$i ］~OR［ コレの`終端$`より後$i ］］］ ⇒ ~RET ~F ◎ If (node, offset) is before start or after end, return false.
3. ~RET ~T ◎ Return true.

@comparePoint(node, offset) ~method手続きは： ◎ The comparePoint(node, offset) method steps are:

1. ~IF［ %node の`根$ ~NEQ コレの`根$rg ］ ⇒ ~THROW `WrongDocumentError$E ◎ If node’s root is different from this’s root, then throw a "WrongDocumentError" DOMException.
2. ~IF［ `境界点$( %node, %offset ) は コレの`始端$`より前$i ］ ⇒ ~RET ~MINUS 1 ◎ If (node, offset) is before start, return −1.
3. ~IF［ `境界点$( %node, %offset ) は コレの`終端$`より後$i ］ ⇒ ~RET 1 ◎ If (node, offset) is after end, return 1.
4. ~RET 0 ◎ Return 0.

@intersectsNode(node) ~method手続きは： ◎ The intersectsNode(node) method steps are:

1. ~IF［ %親 ~EQ ~NULL 【！すなわち node は根】 ］ ⇒ ~RET ~T ◎ If parent is null, return true.
2. %offset ~LET %node の`~index$ ◎ Let offset be node’s index.
3. ~IF［ `境界点$( %親, %offset ) は コレの`終端$`より前$i ］~AND［ `境界点$( %親, %offset ~PLUS 1 ) は コレの`始端$`より後$i 【！selectNode の結果】 ］ ⇒ ~RET ~T ◎ If (parent, offset) is before end and (parent, offset plus 1) is after start, return true.
4. ~RET ~F ◎ Return false.

@stringifier における`文字列~化の挙動$は： ◎ The stringification behavior must run these steps:

1. %結果 ~LET 空~文字列 ◎ Let s be the empty string.
2. ( %始端~node, %始端~offset, %終端~node, %終端~offset ) ~LET コレの ( `始端~node$, `始端~offset$, `終端~node$, `終端~offset$ ) ◎ ↓

3. ~IF［ %始端~node は $Text `~node$である ］：

   1. ~IF［ %始端~node ~EQ %終端~node ］ ⇒ ~RET %始端~node の`~data$の中の %始端~offset から %終端~offset までを`成す符号単位~部分文字列$
   2. %結果 に次を付加する ⇒ %始端~node の`~data$の中の %始端~offset から`終端までを成す符号単位~部分文字列$
   ◎ If this’s start node is this’s end node and it is a Text node, then return the substring of that Text node’s data beginning at this’s start offset and ending at this’s end offset. ◎ If this’s start node is a Text node, then append the substring of that node’s data from this’s start offset until the end to s.
4. コレに`包含され$ている ~EACH( $Text `~node$ %~node ) に対し，`~tree順序$で ⇒ %結果 に %~node の`~data$を付加する ◎ Append the concatenation of the data of all Text nodes that are contained in this, in tree order, to s.
5. ~IF［ %終端~node は $Text `~node$である ］ ⇒ %結果 に次を付加する ⇒ %終端~node の`~data$の中の 0 から %終端~offset までを`成す符号単位~部分文字列$ ◎ If this’s end node is a Text node, then append the substring of that node’s data from its start until this’s end offset to s.
6. ~RET %結果 ◎ Return s.

`~node反復器~用の除去-前の手続き@ は、 所与の ( $NodeIterator %反復器, `~node$ %除去される~node ) に対し： ◎ The NodeIterator pre-remove steps given a nodeIterator and toBeRemovedNode, are as follows:

1. ~IF［ %除去される~node は %反復器 の`起点r$tVの`広義-先祖$でない ］~OR［ %除去される~node ~EQ %反復器 の`根$tV ］ ⇒ ~RET ◎ If toBeRemovedNode is not an inclusive ancestor of nodeIterator’s reference, or toBeRemovedNode is nodeIterator’s root, then return.

2. ~IF［ %反復器 の`起点rの直前か$tV ~EQ ~T ］： ◎ If nodeIterator’s pointer before reference is true:

   1. %直後の ~LET ~AND↓ を満たす`~node$のうち，`最初のもの？$：

      • %除去される~node に`後続-$する
      • %反復器 の`根$tVの`広義-子孫$である
      • %除去される~node の`広義-子孫$でない
      ◎ Let next be toBeRemovedNode’s first following node that is an inclusive descendant of nodeIterator’s root and is not an inclusive descendant of toBeRemovedNode, and null if there is no such node.
   2. ~IF［ %直後の ~NEQ ~NULL ］ ⇒＃ %反復器 の`起点r$tV ~SET %直後の； ~RET ◎ If next is non-null, then set nodeIterator’s reference to next and return.
   3. %反復器 の`起点rの直前か$tV ~SET ~F ◎ Otherwise, set nodeIterator’s pointer before reference to false. ◎ Steps are not terminated here.
3. %直前の同胞 ~LET %除去される~node の`直前の同胞？$ ◎ ↓
4. %反復器 の`起点r$tV ~SET %直前の同胞 に応じて ⇒＃ ~NULL ならば %除去される~node の`親$ ／ ~ELSE_ %直前の同胞 の`広義-子孫$のうち `最後のもの？$ ◎ Set nodeIterator’s reference to toBeRemovedNode’s parent, if toBeRemovedNode’s previous sibling is null, and to the inclusive descendant of toBeRemovedNode’s previous sibling that appears last in tree order otherwise.

`反復器で辿る@ ~algoは、 所与の ( $NodeIterator ~obj %反復器, %方向 ~IN { `順^i, `逆^i } ) に対し： ◎ To traverse, given a NodeIterator object iterator and a direction direction, run these steps:

1. %~node ~LET %反復器 の`起点r$tV ◎ Let node be iterator’s reference.
2. %直前か ~LET %反復器 の`起点rの直前か$tV ◎ Let beforeNode be iterator’s pointer before reference.
3. %~collection ~LET %反復器 の`反復器~collection$ ◎ ↓

4. ~WHILE 無条件： ◎ While true:

   1. ~IF［ %方向 ~EQ `順^i ］： ◎ Branch on direction: ◎ next

      1. ~IF［ %直前か ~EQ ~F ］： ◎ If beforeNode is false, then＼

         1. %~node ~SET %~collection の中で %~node に`後続-$する`~node$のうち，`最初のもの？$ ◎ set node to the first node following node in iterator’s iterator collection.＼
         2. ~IF［ %~node ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If there is no such node, then return null.
      2. ~ELSE ⇒ %直前か ~SET ~F ◎ If beforeNode is true, then set it to false.

   2. ~ELSE（ %方向 ~EQ `逆^i ）： ◎ previous

      1. ~IF［ %直前か ~EQ ~T ］： ◎ If beforeNode is true, then＼

         1. %~node ~SET %~collection の中で %~node に`先行-$する`~node$のうち，`最後のもの？$ ◎ set node to the first node preceding node in iterator’s iterator collection.＼
         2. ~IF［ %~node ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If there is no such node, then return null.
      2. ~ELSE ⇒ %直前か ~SET ~T ◎ If beforeNode is false, then set it to true.
   3. ~IF［ `辿器の中で~nodeを~filterにかける$( %反復器, %~node ) ~EQ $NodeFilter.FILTER_ACCEPT ］ ⇒ ~BREAK ◎ Let result be the result of filtering node within iterator. ◎ If result is FILTER_ACCEPT, then break.
5. %反復器 の`起点r$tV ~SET %~node ◎ Set iterator’s reference to node.
6. %反復器 の`起点rの直前か$tV ~SET %直前か ◎ Set iterator’s pointer before reference to beforeNode.
7. ~RET %~node ◎ Return node.

【 辿り方向が前回と逆向きに切り替わった場合、 探索処理は，前回の辿りによる “現在の” ~node（ `起点r$tV ）から開始されることに注意（その直後の／直前の~nodeからではなく）。 探索した結果，`~filter$cLに合致する~nodeが見出されなかった場合、 `起点r$tVは変更されない。 見出された場合、 `起点r$tVは，新たに見出された~nodeになり、 `起点rの直前か$tV（ “現在の” 辿り方向）は，渡された %方向 を反映するようになる （ ~F が `順^i 方向に対応する）。 】

@detach() ~method手続きは、 何もしない。 ◎ The detach() method steps are to do nothing.＼

注記： この機能性（ ^NodeIterator ~objを不能化する）は、 除去された。 互換性のため存続はするが。 ◎ Its functionality (disabling a NodeIterator object) was removed, but the method itself is preserved for compatibility.

@parentNode() ~method手続きは： ◎ The parentNode() method steps are:

1. %~node ~LET コレの`現-~node$tV ◎ Let node be this’s current.

2. ~WHILE［ %~node の`親$ ~NEQ ~NULL ］~AND［ %~node ~NEQ コレの`根$tV ］：

   1. %~node ~SET %~node の`親$
   2. %結果 ~LET `辿器の中で~nodeを~filterにかける$( コレ, %~node )
   3. ~IF［ %結果 ~NEQ $NodeFilter.FILTER_ACCEPT ］ ⇒ ~CONTINUE
   4. コレの`現-~node$tV ~SET %~node
   5. ~RET %~node
   ◎ While node is non-null and is not this’s root: • Set node to node’s parent. • If node is non-null and＼ filtering node within this returns FILTER_ACCEPT, then set this’s current to node and return node.
3. ~RET ~NULL ◎ Return null.

`子~群を辿る@ ~algoは、 所与の ( %walker, %向き ~IN { `最初から^i, `最後から^i } ) に対し： ◎ To traverse children, given a walker and type, run these steps:

1. %~node ~LET %walker の`現-~node$tV ◎ Let node be walker’s current.
2. %~node ~SET %向き に応じて ⇒＃ `最初から^i ならば %~node の`最初の子？$ ／ `最後から^i ならば %~node の`最後の子？$ ◎ Set node to node’s first child if type is first, and node’s last child if type is last.

3. ~WHILE［ %~node ~NEQ ~NULL ］： ◎ While node is non-null:

   1. %結果 ~LET `辿器の中で~nodeを~filterにかける$( %walker, %~node ) ◎ Let result be the result of filtering node within walker.
   2. ~IF［ %結果 ~EQ $NodeFilter.FILTER_ACCEPT ］ ⇒＃ %walker の`現-~node$tV ~SET %~node； ~RET %~node ◎ If result is FILTER_ACCEPT, then set walker’s current to node and return node.

   3. ~IF［ %結果 ~EQ $NodeFilter.FILTER_SKIP ］： ◎ If result is FILTER_SKIP:

      1. %子 ~LET %向き に応じて ⇒＃ `最初から^i ならば %~node の`最初の子？$ ／ `最後から^i ならば %~node の`最後の子？$ ◎ Let child be node’s first child if type is first, and node’s last child if type is last.
      2. ~IF［ %子 ~NEQ ~NULL ］ ⇒＃ %~node ~SET %子； ~CONTINUE ◎ If child is non-null, then set node to child and continue.

   4. ~WHILE［ %~node ~NEQ ~NULL ］： ◎ While node is non-null:

      1. %同胞 ~LET %向き に応じて ⇒＃ `最初から^i ならば %~node の`直後の同胞？$ ／ `最後から^i ならば %~node の`直前の同胞？$ ◎ Let sibling be node’s next sibling if type is first, and node’s previous sibling if type is last.
      2. ~IF［ %同胞 ~NEQ ~NULL ］ ⇒＃ %~node ~SET %同胞； ~BREAK ◎ If sibling is non-null, then set node to sibling and break.
      3. %親 ~LET %~node の`親$ ◎ Let parent be node’s parent.
      4. ~IF［ %親 ~IN { ~NULL, %walker の`根$tV, %walker の`現-~node$tV } ］ ⇒ ~RET ~NULL ◎ If parent is null, walker’s root, or walker’s current, then return null.
      5. %~node ~SET %親 ◎ Set node to parent.
4. ~RET ~NULL ◎ Return null.

`同胞たちを辿る@ ~algoは、 所与の ( %walker, %向き ~IN { `順^i, `逆^i } ) に対し： ◎ To traverse siblings, given a walker and type, run these steps:

1. ~IF［ %~node ~EQ %walker の`根$tV ］ ⇒ ~RET ~NULL ◎ If node is root, then return null.
2. 1. %同胞 ~LET %向き に応じて ⇒＃ `順^i ならば %~node の`直後の同胞？$ ／ `逆^i ならば %~node の`直前の同胞？$ ◎ Let sibling be node’s next sibling if type is next, and node’s previous sibling if type is previous.

   2. ~WHILE［ %同胞 ~NEQ ~NULL ］： ◎ While sibling is non-null:

      1. %~node ~SET %同胞 ◎ Set node to sibling.
      2. %同胞 ~SET %向き に応じて ⇒＃ `順^i ならば %~node の`最初の子？$ ／ `逆^i ならば %~node の`最後の子？$ ◎ Set sibling to node’s first child if type is next, and node’s last child if type is previous.
      3. ~IF［ %結果 ~EQ $NodeFilter.FILTER_REJECT ］~OR［ %同胞 ~EQ ~NULL ］ ⇒ %同胞 ~SET %向き に応じて ⇒＃ `順^i ならば %~node の`直後の同胞？$ ／ `逆^i ならば %~node の`直前の同胞？$ ◎ If result is FILTER_REJECT or sibling is null, then set sibling to node’s next sibling if type is next, and node’s previous sibling if type is previous.
   3. %~node ~SET %~node の`親$ ◎ Set node to node’s parent.
   4. ~IF［ %~node ~IN { ~NULL, %walker の`根$tV } ］ ⇒ ~RET ~NULL ◎ If node is null or walker’s root, then return null.
   5. ~IF［ `辿器の中で~nodeを~filterにかける$( コレ, %~node ) ~EQ $NodeFilter.FILTER_ACCEPT ］ ⇒ ~RET ~NULL ◎ If the return value of filtering node within walker is FILTER_ACCEPT, then return null.

@previousNode() ~method手続きは： ◎ The previousNode() method steps are:

1. ~WHILE［ %~node ~NEQ コレの`根$tV ］： ◎ While node is not this’s root:

   1. %同胞 ~LET %~node の`直前の同胞？$ ◎ Let sibling be node’s previous sibling.

   2. ~WHILE［ %同胞 ~NEQ ~NULL ］： ◎ While sibling is non-null:

      1. %~node ~SET %同胞 ◎ Set node to sibling.
      2. %結果 ~LET `辿器の中で~nodeを~filterにかける$( コレ, %~node ) ◎ Let result be the result of filtering node within this.

      3. ~WHILE［ %結果 ~NEQ $NodeFilter.FILTER_REJECT ］~AND［ %~node の`子~群$は`空$でない ］： ◎ While result is not FILTER_REJECT and node has a child:

         1. %~node ~SET %~node の`最後の子？$ ◎ Set node to node’s last child.
         2. %結果 ~SET `辿器の中で~nodeを~filterにかける$( コレ, %~node ) ◎ Set result to the result of filtering node within this.
      4. ~IF［ %結果 ~EQ $NodeFilter.FILTER_ACCEPT ］ ⇒＃ コレの`現-~node$tV ~SET %~node； ~RET %~node ◎ If result is FILTER_ACCEPT, then set this’s current to node and return node.
      5. %同胞 ~SET %~node の`直前の同胞？$ ◎ Set sibling to node’s previous sibling.
   3. ~IF［ %~node ~EQ コレの`根$tV ］~OR［ %~node の`親$ ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If node is this’s root or node’s parent is null, then return null.
   4. %~node ~SET %~node の`親$ ◎ Set node to node’s parent.
   5. %結果 ~LET `辿器の中で~nodeを~filterにかける$( コレ, %~node ) ◎ ↓
   6. ~IF［ %結果 ~EQ $NodeFilter.FILTER_ACCEPT ］ ⇒＃ コレの`現-~node$tV ~SET %~node； ~RET %~node ◎ If the return value of filtering node within this is FILTER_ACCEPT, then set this’s current to node and return node.
2. ~RET ~NULL ◎ Return null.

@nextNode() ~method手続きは： ◎ The nextNode() method steps are:

1. %結果 ~LET $NodeFilter.FILTER_ACCEPT ◎ Let result be FILTER_ACCEPT.
2. 1. 1. %~node ~SET %~node の`最初の子？$ ◎ Set node to its first child.
   2. %同胞 ~LET ~NULL ◎ Let sibling be null.
   3. %temporary ~LET %~node ◎ Let temporary be node.

   4. ~WHILE［ %temporary ~NEQ ~NULL ］： ◎ While temporary is non-null:

      1. ~IF［ %temporary ~EQ コレの`根$tV ］ ⇒ ~RET ~NULL ◎ If temporary is this’s root, then return null.
      2. %同胞 ~SET %temporary の`直後の同胞？$ ◎ Set sibling to temporary’s next sibling.
      3. ~IF［ %同胞 ~NEQ ~NULL ］ ⇒＃ %~node ~SET %同胞； ~BREAK ◎ If sibling is non-null, then set node to sibling and break.
      4. %temporary ~SET %temporary の`親$ ◎ Set temporary to temporary’s parent.

@item(index) ~method手続きは： ◎ The item(index) method steps are:

1. ~IF［ %index ~NIN { コレが`~supportする~prop~index$ } ］ ⇒ ~RET ~NULL ◎ If index is equal to or greater than this’s token set’s size, then return null.
2. ~RET コレの`~token集合$tL[ %index ] ◎ Return this’s token set[index].

`~tokenを検査する@ ~algoは、 所与の ( %token ) に対し：

1. ~IF［ %token ~EQ 空~文字列 ］ ⇒ ~THROW `SyntaxError$E
2. ~IF［ %token は`~ASCII空白$を含んでいる ］ ⇒ ~THROW `InvalidCharacterError$E

@add(tokens…) ~method手続きは： ◎ The add(tokens…) method steps are:

1. %tokens を成す ~EACH( %token ) に対し，与えられた順に ⇒ `~tokenを検査する$( %token ) ◎ For each token of tokens: • If token is the empty string, then throw a "SyntaxError" DOMException. • If token contains any ASCII whitespace, then throw an "InvalidCharacterError" DOMException.
2. %tokens を成す ~EACH( %token ) に対し ⇒ コレの`~token集合$tLに %token を`付加する$set ◎ For each token of tokens, append token to this’s token set.
3. コレの`更新~手続き$tL() ◎ Run the update steps.

@remove(tokens…) ~method手続きは： ◎ The remove(tokens…) method steps are:

1. %tokens を成す ~EACH( %token ) に対し ⇒ コレの`~token集合$tLから %token を`除去する$ ◎ For each token of tokens, remove token from this’s token set.

@toggle(token, force) ~method手続きは： ◎ The toggle(token, force) method steps are:

1. `~tokenを検査する$( %token ) ◎ If token is the empty string, then throw a "SyntaxError" DOMException. ◎ If token contains any ASCII whitespace, then throw an "InvalidCharacterError" DOMException.

2. ~IF［ %token ~IN コレの`~token集合$tL ］： ◎ If this’s token set[token] exists:

   1. ~IF［ %force ~EQ ε ］~OR［ %force ~EQ ~F ］：

      1. コレの`~token集合$tLから %token を`除去する$
      2. コレの`更新~手続き$tL()
      3. ~RET ~F
      ◎ If force is either not given or is false, then remove token from this’s token set, run the update steps and return false.
   2. ~RET ~T ◎ Return true.

3. ~IF［ %force ~EQ ε ］~OR［ %force ~EQ ~T ］：

   1. コレの`~token集合$tLに %token を`付加する$set
   2. コレの`更新~手続き$tL()
   3. ~RET ~T
   ◎ Otherwise, if force not given or is true, append token to this’s token set, run the update steps, and return true.
4. ~RET ~F ◎ Return false.

注記： ~web互換性のため、 $toggle() に対しては，`更新~手続き$tLを常に走らすとは限らない。 ◎ The update steps are not always run for toggle() for web compatibility.

@replace(token, newToken) ~method手続きは： ◎ The replace(token, newToken) method steps are:

1. ~IF［ %token ~EQ 空~文字列 ］~OR［ %newToken ~EQ 空~文字列 ］ ⇒ ~THROW `SyntaxError$E ◎ If either token or newToken is the empty string, then throw a "SyntaxError" DOMException.
2. ~IF［ %token は`~ASCII空白$を含んでいる ］~OR［ %newToken は`~ASCII空白$を含んでいる ］ ⇒ ~THROW `InvalidCharacterError$E ◎ If either token or newToken contains any ASCII whitespace, then throw an "InvalidCharacterError" DOMException.
3. ~IF［ %token ~NIN コレの`~token集合$tL ］ ⇒ ~RET ~F ◎ If this’s token set does not contain token, then return false.
4. コレの`~token集合$tL内で %token を %newToken に`置換する$set ◎ Replace token in this’s token set with newToken.
5. ~RET ~T ◎ Return true.

注記： ~web互換性のため、 $replace() に対しては，`更新~手続き$tLを常に走らすとは限らない。 ◎ The update steps are not always run for replace() for web compatibility.

【 最初と二番目の段は、 %token, %newToken の順に`~tokenを検査する$のとは，挙動が異なる。 】