HTML — スクリプト処理

`~agentを作成する@ ときは、 所与の ( 真偽値 %canBlock ) に対し： ◎ To create an agent, given a boolean canBlock:

1. %signifier ~LET 新たな一意な内部的な値 ◎ Let signifier be a new unique internal value.
2. %実行候補 ~LET 新たな`実行候補$ ◎ Let candidateExecution be a new candidate execution.
3. %~agent ~LET 新たな`~agent$ — その ⇒＃ `CanBlock^sl ~SET %canBlock, `Signifier^sl ~SET %signifier, `CandidateExecution^sl ~SET %実行候補, `IsLockFree1^sl, `IsLockFree2^sl, `LittleEndian^sl ~SET いずれも，実装の裁量による何か ◎ Let agent be a new agent whose [[CanBlock]] is canBlock, [[Signifier]] is signifier, [[CandidateExecution]] is candidateExecution, and [[IsLockFree1]], [[IsLockFree2]], and [[LittleEndian]] are set at the implementation's discretion.
4. %~agent の`~event~loop$aG ~SET 新たな`~event~loop$ ◎ Set agent's event loop to a new event loop.
5. ~RET %~agent ◎ Return agent.

`生成元が類似な~window~agentを得する@ ときは、 所与の ( `生成元$ %生成元, `閲覧~文脈~group$ %~group, 真偽値 %生成元~agent~clusterを要請するか ) に対し，次を走らす： ◎ To obtain a similar-origin window agent, given an origin origin, a browsing context group group, and a boolean requestsOAC, run these steps:

1. %~key ~LET `~siteを得する$( %生成元 ) ◎ Let site be the result of obtaining a site with origin. ◎ Let key be site.
2. ~IF［ %~group の`非同一-生成元~隔離~mode$bcG ~NEQ `none$l ］ ⇒ %~key ~SET %生成元 ◎ If group's cross-origin isolation mode is not "none", then set key to origin.
3. ~ELIF［ %~group の`履歴上の~agent~cluster~key~map$bcG[ %生成元 ] ~NEQ ε ］ ⇒ %~key ~SET %~group の`履歴上の~agent~cluster~key~map$bcG[ %生成元 ] ◎ Otherwise, if group's historical agent cluster key map[origin] exists, then set key to group's historical agent cluster key map[origin].

4. ~ELSE ◎ Otherwise:

   1. ~IF［ %生成元~agent~clusterを要請するか ~EQ ~T ］ ⇒ %~key ~SET %生成元 ◎ If requestsOAC is true, then set key to origin.
   2. %~group の`履歴上の~agent~cluster~key~map$bcG[ %生成元 ] ~SET %~key ◎ Set group's historical agent cluster key map[origin] to key.

5. ~IF［ %~group の`~agent~cluster~map$bcG[ %~key ] ~EQ ε ］： ◎ If group's agent cluster map[key] does not exist, then:

   1. %~agent~cluster ~SET 新たな`~agent~cluster$ ◎ Let agentCluster be a new agent cluster.
   2. %~agent~cluster の`非同一-生成元~隔離~mode$agC ~SET %~group の`非同一-生成元~隔離~mode$bcG ◎ Set agentCluster's cross-origin isolation mode to group's cross-origin isolation mode.
   3. %~agent~cluster の`生成元を~keyにするか$ ~SET ~IS［ %~key ~EQ %生成元 ］ ◎ Set agentCluster's is origin-keyed to true if key equals origin; otherwise false.
   4. %~agent~cluster に次の結果を追加する ⇒ `~agentを作成する$( ~F ) ◎ Add the result of creating an agent, given false, to agentCluster.
   5. %~group の`~agent~cluster~map$bcG[ %~key ] ~SET %~agent~cluster ◎ Set group's agent cluster map[key] to agentCluster.
6. ~RET %~group の`~agent~cluster~map$bcG[ %~key ] 内に 1 つだけ在る，`生成元が類似な~window~agent$ ◎ Return the single similar-origin window agent contained in group's agent cluster map[key].

注記： これは、 各 閲覧~文脈~agent~clusterには， `生成元が類似な~window~agent$は 1 つだけ在ることを意味する （しかしながら，［ `専用~worker~agent$／`~worklet~agent$ ］は、 同じ~cluster内に複数在るかもしれない）。 ◎ This means that there is only one similar-origin window agent per browsing context agent cluster. (However, dedicated worker and worklet agents might be in the same cluster.)

`~worker／~worklet~agentを得する@ ときは、 所与の ( `環境~設定群~obj$または~NULL %外側~設定群, 真偽値 %~top-levelか, 真偽値 %canBlock ) に対し，次の手続きを走らす： ◎ To obtain a worker/worklet agent, given an environment settings object or null outside settings, a boolean isTopLevel, and a boolean canBlock, run these steps:

1. %~agent~cluster ~LET ~NULL ◎ Let agentCluster be null.

2. ~IF［ %~top-levelか ~EQ ~T ］： ◎ If isTopLevel is true, then:

   1. %~agent~cluster ~SET 新たな`~agent~cluster$ ◎ Set agentCluster to a new agent cluster.

   2. %~agent~cluster の`生成元を~keyにするか$ ~SET ~T ◎ Set agentCluster's is origin-keyed to true.

      注記： これらの~workerは、 生成元を~keyにするものと見なせる。 しかしながら、 これは，~APIを通しては公開されない （ `originAgentCluster$m が~window用に生成元を~keyにするか否かを公開するような仕方では）。 ◎ These workers can be considered to be origin-keyed. However, this is not exposed through any APIs (in the way that originAgentCluster exposes the origin-keyedness for windows).

3. ~ELSE： ◎ Otherwise:

   1. ~Assert： %外側~設定群 ~NEQ ~NULL ◎ Assert: outside settings is not null.
   2. %所有者~agent ~LET %外側~設定群 の`~realm$enV用の`~agent$rM ◎ Let ownerAgent be outside settings's realm's agent.
   3. %~agent~cluster ~SET %所有者~agent を包含する~agent~cluster ◎ Set agentCluster to the agent cluster which contains ownerAgent.
4. %~agent ~LET `~agentを作成する$( %canBlock ) ◎ Let agent be the result of creating an agent given canBlock.
5. %~agent~cluster に %~agent を追加する ◎ Add agent to agentCluster.
6. ~RET %~agent ◎ Return agent.

`専用／共用~worker~agentを得する@ ときは、 所与の ( `環境~設定群~obj$ %外側~設定群, 真偽値 %共用か ) に対し，次の結果を返す ⇒ `~worker／~worklet~agentを得する$( %外側~設定群, %共用か, ~T ) ◎ To obtain a dedicated/shared worker agent, given an environment settings object outside settings and a boolean isShared, return the result of obtaining a worker/worklet agent given outside settings, isShared, and true.

`~worklet~agentを得する@ ときは、 所与の ( `環境~設定群~obj$ %外側~設定群 ) に対し，次の結果を返す ⇒ `~worker／~worklet~agentを得する$( %外側~設定群, ~F, ~F ) ◎ To obtain a worklet agent, given an environment settings object outside settings, return the result of obtaining a worker/worklet agent given outside settings, false, and false.

`~sw~agentを得する@ ときは、次の結果を返す ⇒ `~worker／~worklet~agentを得する$( ~NULL, ~T, ~F ) ◎ To obtain a service worker agent, return the result of obtaining a worker/worklet agent given null, true, and false.

`~agent$ %~agent 内で `新たな~realmを作成する@ ときは、 次の手続きに従う： ◎ To create a new realm in an agent agent,＼

1. この手続きには、 次に挙げる指示書きも，それぞれ任意選択で供される ⇒＃ 大域~objを作成する ／ 利用する大域 `this^jv 束縛 ◎ optionally with instructions to create a global object or a global this binding (or both), the following steps are taken:

   この指示書きにより~custom化する下で， `InitializeHostDefinedRealm$jA() を遂行する ◎ Perform InitializeHostDefinedRealm() with the provided customizations for creating the global object and the global this binding.

2. %~realm実行~文脈 ~LET `走っている~JS実行~文脈$ ◎ Let realm execution context be the running JavaScript execution context.

   注記： これは、 前~段で作成された`~JS実行~文脈$になる。 ◎ This is the JavaScript execution context created in the previous step.

3. `~JS実行~文脈~stack$から %~realm実行~文脈 を除去する ◎ Remove realm execution context from the JavaScript execution context stack.
4. %~realm ~LET %~realm実行~文脈 の~Realm成分 ◎ Let realm be realm execution context's Realm component.

5. ~IF［ %~agent の`~agent~cluster$の`非同一-生成元~隔離~mode$agC ~EQ `none$l ］： ◎ If agent's agent cluster's cross-origin isolation mode is "none", then:

   1. %大域~obj ~LET %~realm の`大域~obj$rM ◎ Let global be realm's global object.
   2. %状態s ~LET ~NOABRUPT %大域~obj .`Delete^sl( `SharedArrayBuffer^l ) ◎ Let status be ! global.[[Delete]]("SharedArrayBuffer").
   3. ~Assert： %状態s ~EQ ~T ◎ Assert: status is true.

   注記： これは，~web内容との互換性を得るために行われるが、 将来には除去できる希望もある。 ~web開発者は，依然として、 次を通して構築子を入手できる ⇒ `new WebAssembly.Memory({ shared:true, initial:0, maximum:0 }).buffer.constructor^c ◎ This is done for compatibility with web content and there is some hope that this can be removed in the future. Web developers can still get at the constructor through new WebAssembly.Memory({ shared:true, initial:0, maximum:0 }).buffer.constructor.

6. ~RET %~realm実行~文脈 ◎ Return realm execution context.

所与の`環境$ %環境 は、 次の~algoが ~T を返すとき，そのときに限り， `~secureな文脈@enV （ `secure context^en ）であるとされる： ◎ An environment environment is a secure context if the following algorithm returns true:

1. ~IF［ %環境 は`環境~設定群~obj$である ］： ◎ If environment is an environment settings object, then:

   1. %大域~obj ~LET %環境 の`大域~obj$enV ◎ Let global be environment's global object.

   2. ~IF［ %大域~obj は `WorkerGlobalScope$I である ］ ⇒ ~RET ~IS［ %大域~obj の`所有者~集合$[ 0 ] に`関連な設定群~obj$は`~secureな文脈$enVである ］

      注記： `所有者~集合$は、 最初の~item以外を検査する必要はない — それらすべてが一貫することが必要とされているので。

      ◎ If global is a WorkerGlobalScope, then: • If global's owner set[0]'s relevant settings object is a secure context, then return true. • We only need to check the 0th item since they will necessarily all be consistent. • Return false.

   3. ~IF［ %大域~obj は `WorkletGlobalScope$I である ］ ⇒ ~RET ~T ◎ If global is a WorkletGlobalScope, then return true.

      注記： ~workletを作成できるのは、 ~secureな文脈~内に限られる。 ◎ Worklets can only be created in secure contexts.

2. ~RET ~IS［ 次の結果 ~EQ `価し得る^i ］ ⇒ `~URLは信用に価し得るか？$( %環境 の`~top-level作成時の~URL$enV ) ◎ If the result of Is url potentially trustworthy? given environment's top-level creation URL is "Potentially Trustworthy", then return true. ◎ Return false.

`~secureな文脈$enVでない`環境$は、 `~secureでない文脈@enV （ `non-secure context^en ）であるとされる。 【この訳では、この用語は利用せず，単に “`~secureな文脈$enVでない” と記すことにする。】 ◎ An environment is a non-secure context if it is not a secure context.

【 `~secureな文脈$enVの意味論や具体例その他は、 `SECURE-CONTEXTS$r に見出せる。 】

`子孫~script~fetch~option群を取得する@ ときは、 所与の ⇒＃ `~script~fetch~option群$ %元の~option群, `~URL$ %~URL, `環境~設定群~obj$ %設定群~obj ◎終 に対し： ◎ To get the descendant script fetch options given a script fetch options originalOptions, a URL url, and an environment settings object settingsObject:

1. %新たな~option群 ~LET %元の~option群 の複製 ◎ Let newOptions be a copy of originalOptions.
2. %新たな~option群 の`完全性~metadata$sfO ~SET `~module完全性~metadataを解決する$( %~URL, %設定群~obj ) ◎ Let integrity be the result of resolving a module integrity metadata with url and settingsObject. ◎ Set newOptions's integrity metadata to integrity.
3. %新たな~option群 の`~fetch優先度$sfO ~SET `auto^l ◎ Set newOptions's fetch priority to "auto".
4. ~RET %新たな~option群 ◎ Return newOptions.

`~module完全性~metadataを解決する@ ときは、 所与の ( `~URL$ %~URL, `環境~設定群~obj$ %設定群~obj ) に対し： ◎ To resolve a module integrity metadata, given a URL url and an environment settings object settingsObject:

1. %~map ~LET %設定群~obj の`大域~obj$enVの`~import~map$gL ◎ Let map be settingsObject's global object's import map.
2. ~IF［ %~map の`完全性$iM[ %~URL ] ~NEQ ε ］ ⇒ ~RET 空~文字列 ◎ If map's integrity[url] does not exist, then return the empty string.
3. ~RET %~map の`完全性$iM[ %~URL ] ◎ Return map's integrity[url].

`古典~scriptを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %設定群~obj, `~script~fetch~option群$ %~option群, `~CORS設定群~属性$用の状態 %~CORS設定, `符号化法$ %符号化法, %完了-時の手続き, ◎終 に対し，次を走らす： ◎ To fetch a classic script given a URL url, an environment settings object settingsObject, a script fetch options options, a CORS settings attribute state corsSetting, an encoding encoding, and an algorithm onComplete, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`古典~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a classic script (on success).
2. %要請 ~LET `~CORSになり得る要請を作成する$( %~URL, `script^l, %~CORS設定 ) ◎ Let request be the result of creating a potential-CORS request given url, "script", and corsSetting.
3. %要請 の ⇒＃ `~client$rq ~SET %設定群~obj, `起動元~種別$rq ~SET `script^l ◎ Set request's client to settingsObject. ◎ Set request's initiator type to "script".
4. `古典~script要請を設定しておく$( %要請, %~option群 ) ◎ Set up the classic script request given request and options.

5. %要請 を`~fetchする$ — 次を与える下で ⇒ `応答の本体を消費する処理n$i ~SET 次に定義する手続き ◎ Fetch request with the following processResponseConsumeBody steps＼

   手続きは、 所与の ( `応答$ %応答, ［ ~NULL ／ `失敗^i ／ `~byte列$ ］ %本体~byte列 ) に対し： ◎ given response response and null, failure, or a byte sequence bodyBytes:

   注記： %応答 は、［ `~CORS同一-生成元$, `~CORS非同一-生成元$ ］いずれにもなり得る。 これは、 ~error報告ngがどう起こるかにのみ影響する。 ◎ response can be either CORS-same-origin or CORS-cross-origin. This only affects how error reporting happens.

   1. %応答 ~SET %応答 の`安全でない応答$ ◎ Set response to response's unsafe response.

   2. ~IF［ %本体~byte列 ~IN { ~NULL, `失敗^i } ］~OR［ %応答 の`状態s$rs ~NIN { `~ok状態s$rs } ］ ⇒＃ %完了-時の手続き( ~NULL )； ~RET ◎ If any of the following are true: • bodyBytes is null or failure; or • response's status is not an ok status, then run onComplete given null, and abort these steps.

      注記： この節における他の［ ~scriptを~fetchする~algo ］と違って、 歴史的な理由から，この~algoは~MIME型を検査しない。 ◎ For historical reasons, this algorithm does not include MIME type checking, unlike the other script-fetching algorithms in this section.

   3. %符号化法を与え得る~MIME型 ~LET `~header~listから~MIME型を抽出する$( %応答 の`~header~list$rs ) ◎ Let potentialMIMETypeForEncoding be the result of extracting a MIME type given response's header list.

   4. %符号化法 ~SET `旧来~用に符号化法を抽出する$( %符号化法を与え得る~MIME型, %符号化法 ) ◎ Set encoding to the result of legacy extracting an encoding given potentialMIMETypeForEncoding and encoding.

      注記： これは、 ~MIME型の`~essence$を意図的に無視する。 ◎ This intentionally ignores the MIME type essence.

   5. %~source~text ~LET `~Unicodeに復号する$( %本体~byte列, %符号化法 ) ◎ Let sourceText be the result of decoding bodyBytes to Unicode, using encoding as the fallback encoding.

      注記： ~fileに~BOMがある場合、 この復号する~algoは %符号化法 を上書きする。 ◎ The decode algorithm overrides encoding if the file contains a BOM.

   6. %~errorを黙秘するか ~LET ~IS［ %応答 は`~CORS非同一-生成元$である ］ ◎ Let mutedErrors be true if response was CORS-cross-origin, and false otherwise.
   7. %~script ~LET `古典~scriptを作成する$( ↓ ) ⇒＃ %~source~text, %設定群~obj, %応答 の`~URL$rs, %~option群, %~errorを黙秘するか, %~URL ◎ Let script be the result of creating a classic script given sourceText, settingsObject, response's URL, options, mutedErrors, and url.
   8. %完了-時の手続き( %~script ) ◎ Run onComplete given script.

`~worker用~古典~scriptを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, `環境~設定群~obj$ %設定群~obj, %完了-時の手続き, `~fetch~hookを遂行する~algo$ %~fetchを遂行する（省略時は ε ） ◎終 に対し，次を走らす： ◎ To fetch a classic worker script given a URL url, an environment settings object fetchClient, a destination destination, an environment settings object settingsObject, an algorithm onComplete, and an optional perform the fetch hook performFetch, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`古典~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a classic script (on success).
2. %要請 ~LET 新たな`要請$ — その ⇒＃ `~URL$rq ~SET %~URL, `~client$rq ~SET %~fetch~client, `行先$rq ~SET %行先, `起動元~種別$rq ~SET `other^l, `~mode$rq ~SET `same-origin^l, `資格証~mode$rq ~SET `same-origin^l, `構文解析器~metadata$rq ~SET `not-parser-inserted^l【！not parser-inserted 】, `~URL資格証を利用するか$rq ~SET ~T ◎ Let request be a new request whose URL is url, client is fetchClient, destination is destination, initiator type is "other", mode is "same-origin", credentials mode is "same-origin", parser metadata is "not parser-inserted", and whose use-URL-credentials flag is set.

3. ~IF［ %~fetchを遂行する ~NEQ ε ］ ⇒ %~fetchを遂行する( %要請, ~T, %応答の本体を消費する処理n† ) ◎ If performFetch was given, run performFetch with request, true, and with processResponseConsumeBody as defined below.

   ~ELSE ⇒ %要請 を`~fetchする$ — 次を与える下で ⇒ `応答の本体を消費する処理n$i ~SET %応答の本体を消費する処理n† ◎ Otherwise, fetch request with processResponseConsumeBody set to processResponseConsumeBody as defined below.

   † %応答の本体を消費する処理n は、 所与の ( `応答$ %応答, ［ ~NULL ／ `失敗^i ／ `~byte列$ ］ %本体~byte列 ) に対し： ◎ In both cases, let processResponseConsumeBody given response response and null, failure, or a byte sequence bodyBytes be the following algorithm:

   1. %応答 ~SET %応答 の`安全でない応答$ ◎ Set response to response's unsafe response.
   2. ~IF［ %本体~byte列 ~IN { ~NULL, `失敗^i } ］~OR［ %応答 の`状態s$rs ~NIN { `~ok状態s$rs } ］ ⇒＃ %完了-時の手続き( ~NULL )； ~RET ◎ If any of the following are true: • bodyBytes is null or failure; or • response's status is not an ok status, then run onComplete given null, and abort these steps.

   3. ~IF［ ~AND↓ ］… ◎ If all of the following are true:

      • %応答 の`~URL$rsの`~scheme$urlは`~HTTP_S~scheme$である ◎ response's URL's scheme is an HTTP(S) scheme; and
      • 次の結果は`~JS~MIME型$でない ⇒ `~header~listから~MIME型を抽出する$( %応答 の`~header~list$rs ) ◎ the result of extracting a MIME type from response's header list is not a JavaScript MIME type,

      …ならば ⇒＃ %完了-時の手続き( ~NULL ) ~RET ◎ then run onComplete given null, and abort these steps.

      注記： 他の`~fetch~scheme$に対しては、 歴史的な~web互換性の理由から，~MIME型の検査は免除されている。 これは、 将来には，整備-可能になるかもしれない — `課題 #3255＠~HTMLissue/3255$ を見よ。 ◎ Other fetch schemes are exempted from MIME type checking for historical web-compatibility reasons. We might be able to tighten this in the future; see issue #3255.

   4. %~source~text ~LET `~UTF-8復号する$( %本体~byte列 ) ◎ Let sourceText be the result of UTF-8 decoding bodyBytes.
   5. %~script ~LET `古典~scriptを作成する$( ↓ ) ⇒＃ %~source~text, %設定群~obj, %応答 の`~URL$rs, `既定の~script~fetch~option群$ ◎ Let script be the result of creating a classic script using sourceText, settingsObject, response's URL, and the default script fetch options.
   6. %完了-時の手続き( %~script ) ◎ Run onComplete given script.

`~workerが~importした古典~scriptを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %設定群~obj, `~fetch~hookを遂行する~algo$ %~fetchを遂行する（省略時は ε ） ◎終 に対し，次を走らす — この~algoは、［ 成功~時には`古典~script$を返す／ 失敗~時には例外を投出する ］： ◎ To fetch a classic worker-imported script given a URL url, an environment settings object settingsObject, and an optional perform the fetch hook performFetch, run these steps. The algorithm will return a classic script on success, or throw an exception on failure.

1. %応答 ~LET ~NULL ◎ Let response be null.
2. %本体~byte列 ~LET ~NULL ◎ Let bodyBytes be null.
3. %要請 ~LET 新たな`要請$ — その ⇒＃ `~URL$rq ~SET %~URL, `~client$rq ~SET %設定群~obj, `行先$rq ~SET `script^l, `起動元~種別$rq ~SET `other^l, `構文解析器~metadata$rq ~SET `not-parser-inserted^l, `~URL資格証を利用するか$rq ~SET ~T ◎ Let request be a new request whose URL is url, client is settingsObject, destination is "script", initiator type is "other", parser metadata is "not parser-inserted", and whose use-URL-credentials flag is set.

4. ~IF［ %~fetchを遂行する ~NEQ ε ］ ⇒ %~fetchを遂行する( %要請, %~top-levelか, %応答の本体を消費する処理n† ) ◎ If performFetch was given, run performFetch with request, isTopLevel, and with processResponseConsumeBody as defined below.

   ~ELSE ⇒ %要請 を`~fetchする$ — 次を与える下で ⇒ `応答の本体を消費する処理n$i ~SET %応答の本体を消費する処理n† ◎ Otherwise, fetch request with processResponseConsumeBody set to processResponseConsumeBody as defined below.

   † %応答の本体を消費する処理n は、 所与の ( `応答$ %ある応答, ［ ~NULL ／ `失敗^i ／ `~byte列$ ］ %ある本体~byte列 ) に対し： ◎ In both cases, let processResponseConsumeBody given response res and null, failure, or a byte sequence bb be the following algorithm:

   1. %本体~byte列 ~SET %ある本体~byte列 ◎ Set bodyBytes to bb.
   2. %応答 ~SET %ある応答 ◎ Set response to res.

5. ［ %応答 ~NEQ ~NULL ］になるまで`静止する$ ◎ Pause until response is not null.

   注記： この節の他の~algoと違って，ここでの~fetchingは同期的に行われる。 ◎ Unlike other algorithms in this section, the fetching process is synchronous here.

6. %応答 ~SET %応答 の`安全でない応答$ ◎ Set response to response's unsafe response.

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

   • %本体~byte列 ~IN { ~NULL, `失敗^i } ◎ bodyBytes is null or failure;
   • %応答 の`状態s$rsは`~ok状態s$rsでない ◎ response's status is not an ok status; or
   • 次の結果は`~JS~MIME型$でない ⇒ `~header~listから~MIME型を抽出する$( %応答 の`~header~list$rs ) ◎ the result of extracting a MIME type from response's header list is not a JavaScript MIME type,

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

8. %~source~text ~LET `~UTF-8復号する$( %本体~byte列 ) ◎ Let sourceText be the result of UTF-8 decoding bodyBytes.
9. %~errorを黙秘するか ~LET ~IS［ %応答 は`~CORS非同一-生成元$である ］ ◎ Let mutedErrors be true if response was CORS-cross-origin, and false otherwise.
10. %~script ~LET `古典~scriptを作成する$( ↓ ) ⇒＃ %~source~text, %設定群~obj, %応答 の`~URL$rs, `既定の~script~fetch~option群$, %~errorを黙秘するか ◎ Let script be the result of creating a classic script given sourceText, settingsObject, response's URL, the default script fetch options, and mutedErrors.
11. ~RET %~script ◎ Return script.

`外部~module~script~graphを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %設定群~obj, `~script~fetch~option群$ %~option群, %完了-時の手続き, ◎終 に対し，次を走らす： ◎ To fetch an external module script graph given a URL url, an environment settings object settingsObject, a script fetch options options, and an algorithm onComplete, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).

2. `単独の~module~scriptを~fetchする$( ↓ ) ⇒＃ %~URL, %設定群~obj, `script^l, %~option群, %設定群~obj, `client^l, ~T, 次に定義する手続き ◎ Fetch a single module script given url, settingsObject, "script", options, settingsObject, "client", true, and with＼

   手続きは、 所与の ( %結果 ) に対し： ◎ the following steps given result:

   1. ~IF［ %結果 ~EQ ~NULL ］ ⇒＃ %完了-時の手続き( ~NULL )； ~RET ◎ If result is null, run onComplete given null, and abort these steps.
   2. `~module~scriptの子孫を~fetchして~linkする$( ↓ ) ⇒＃ %結果, %設定群~obj, `script^l, %完了-時の手続き ◎ Fetch the descendants of and link result given settingsObject, "script", and onComplete.

`~modulepreload~script~graphを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `行先$rq %行先, `環境~設定群~obj$ %設定群~obj, `~script~fetch~option群$ %~option群, %完了-時の手続き, ◎終 に対し，次を走らす： ◎ To fetch a modulepreload module script graph given a URL url, a destination destination, an environment settings object settingsObject, a script fetch options options, and an algorithm onComplete, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).

2. `単独の~module~scriptを~fetchする$( ↓ ) ⇒＃ %~URL, %設定群~obj, %行先, %~option群, %設定群~obj, `client^l, ~T, 次に定義する手続き ◎ Fetch a single module script given url, settingsObject, destination, options, settingsObject, "client", true, and with＼

   手続きは、 所与の ( %結果 ) に対し： ◎ the following steps given result:

   1. %完了-時の手続き( %結果 ) ◎ Run onComplete given result.
   2. ~Assert： %設定群~obj の`大域~obj$enVは `Window$I を実装する ◎ Assert: settingsObject's global object implements Window.
   3. ~IF［ %結果 ~EQ ~NULL ］ ⇒ ~RET ◎ If result is not null,＼

   4. 任意選択で ⇒ `~module~scriptの子孫を~fetchして~linkする$( ↓ ) ⇒＃ %結果, %設定群~obj, %行先, 何もしない~algo ◎ optionally fetch the descendants of and link result given settingsObject, destination, and an empty algorithm.

      注記： 一般に、 この段を遂行すれば，処理能にとって有益になる。 それは、 ~graph全体を~fetchする~algo — `外部~module~script~graphを~fetchする$など — を介して後で結局~要請される~moduleを，予め読込むことを許容するので。 しかしながら，~UAは、［ 帯域幅が拘束されている状況／関連な~fetchはすでに~~伝送中にある状況 ］においては，それを飛ばしたいと望むこともあろう。 ◎ Generally, performing this step will be beneficial for performance, as it allows pre-loading the modules that will invariably be requested later, via algorithms such as fetch an external module script graph that fetch the entire graph. However, user agents might wish to skip them in bandwidth-constrained situations, or situations where the relevant fetches are already in flight.

`~inline~module~script~graphを~fetchする@ ときは、 所与の ⇒＃ `文字列$ %~source~text, `~URL$ %基底~URL, `環境~設定群~obj$ %設定群~obj, `~script~fetch~option群$ %~option群, %完了-時の手続き, ◎終 に対し，次を走らす： ◎ To fetch an inline module script graph given a string sourceText, a URL baseURL, an environment settings object settingsObject, a script fetch options options, and an algorithm onComplete, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).
2. %~script ~LET `~JS~module~scriptを作成する$( ↓ ) ⇒＃ %~source~text, %設定群~obj, %基底~URL, %~option群 ◎ Let script be the result of creating a JavaScript module script using sourceText, settingsObject, baseURL, and options.
3. `~module~scriptの子孫を~fetchして~linkする$( ↓ ) ⇒＃ %~script, %設定群~obj, `script^l, %完了-時の手続き ◎ Fetch the descendants of and link script, given settingsObject, "script", and onComplete.

`~module~worker~script~graphを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, `資格証~mode$sfO %資格証~mode, `環境~設定群~obj$ %設定群~obj, %完了-時の手続き ◎終 に対し ⇒ `［~worklet／~module~worker］~script~graphを~fetchする$( ↓ ) ⇒＃ %~URL, %~fetch~client, %行先, %資格証~mode, %設定群~obj, %完了-時の手続き ◎ To fetch a module worker script graph given a URL url, an environment settings object fetchClient, a destination destination, a credentials mode credentialsMode, an environment settings object settingsObject, and an algorithm onComplete, fetch a worklet/module worker script graph given url, fetchClient, destination, credentialsMode, settingsObject, and onComplete.

`~worklet~script~graphを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, `資格証~mode$sfO %資格証~mode, `環境~設定群~obj$ %設定群~obj, `~module応答~map$wL %~module応答~map, %完了-時の手続き ◎終 に対し ⇒ `［~worklet／~module~worker］~script~graphを~fetchする$( ↓ ) ⇒＃ %~URL, %~fetch~client, %行先, %資格証~mode, %設定群~obj, %完了-時の手続き, 次に定義する（`~fetch~hookを遂行する~algo$を成す）手続き ◎ To fetch a worklet script graph given a URL url, an environment settings object fetchClient, a destination destination, a credentials mode credentialsMode, an environment settings object settingsObject, a module responses map moduleResponsesMap, and an algorithm onComplete,＼ fetch a worklet/module worker script graph given url, fetchClient, destination, credentialsMode, settingsObject, onComplete, and the following perform the fetch hook＼

`［~worklet／~module~worker］~script~graphを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, `資格証~mode$sfO %資格証~mode, `環境~設定群~obj$ %設定群~obj, %完了-時の手続き, `~fetch~hookを遂行する~algo$ %~fetchを遂行する（省略時は ε ） ◎終 に対し，次を走らす： ◎ To fetch a worklet/module worker script graph given a URL url, an environment settings object fetchClient, a destination destination, a credentials mode credentialsMode, an environment settings object settingsObject, an algorithm onComplete, and an optional perform the fetch hook performFetch, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).
2. %~option群 ~LET 新たな`~script~fetch~option群$ — その ⇒＃ `暗号用~nonce$sfO ~SET 空~文字列, `完全性~metadata$sfO ~SET 空~文字列, `構文解析器~metadata$sfO ~SET `not-parser-inserted^l, `資格証~mode$sfO ~SET %資格証~mode, `~referrer施策$sfO ~SET 空~文字列, `~fetch優先度$sfO ~SET `auto^l ◎ Let options be a script fetch options whose cryptographic nonce is the empty string, integrity metadata is the empty string, parser metadata is "not-parser-inserted", credentials mode is credentialsMode, referrer policy is the empty string, and fetch priority is "auto".

3. `単独の~module~scriptを~fetchする$( ↓ ) ⇒＃ %~URL, %~fetch~client, %行先, %~option群, %設定群~obj, `client^l, ~T, 次に定義する手続き, %~fetchを遂行する ◎ Fetch a single module script given url, fetchClient, destination, options, settingsObject, "client", true, and onSingleFetchComplete as defined below. If performFetch was given, pass it along as well.

   手続き【！onSingleFetchComplete】は、 所与の ( %結果 ) に対し： ◎ onSingleFetchComplete given result is the following algorithm:

   1. ~IF［ %結果 ~EQ ~NULL ］ ⇒＃ %完了-時の手続き( ~NULL )； ~RET ◎ If result is null, run onComplete given null, and abort these steps.
   2. `~module~scriptの子孫を~fetchして~linkする$( ↓ ) ⇒＃ %結果, %~fetch~client, %行先, %完了-時の手続き, %~fetchを遂行する ◎ Fetch the descendants of and link result given fetchClient, destination, and onComplete. If performFetch was given, pass it along as well.

`~module~scriptの子孫を~fetchして~linkする@ ときは、 所与の ⇒＃ `~module~script$ %~module~script, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, %完了-時の手続き, `~fetch~hookを遂行する~algo$ %~fetchを遂行する（省略時は ε ） ◎終 に対し，次を走らす： ◎ To fetch the descendants of and link a module script moduleScript, given an environment settings object fetchClient, a destination destination, an algorithm onComplete, and an optional perform the fetch hook performFetch, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).
2. %~record ~LET %~module~script の`~record$sC ◎ Let record be moduleScript's record.

3. ~IF［ %~record ~EQ ~NULL ］： ◎ If record is null, then:

   1. %~module~script の`再投出-用~error$sC ~SET %~module~script の`構文解析-~error$sC 【！誤:~HTMLparsing#parse-errors】 ◎ Set moduleScript's error to rethrow to moduleScript's parse error.
   2. %完了-時の手続き( %~module~script ) ◎ Run onComplete given moduleScript.
   3. ~RET ◎ Return.
4. %状態 ~LET 新たな`~Record$ — その ⇒＃ `ParseError^sl ~SET ~NULL, `Destination^sl ~SET %行先, `PerformFetch^sl ~SET ~NULL, `FetchClient^sl ~SET %~fetch~client ◎ Let state be Record { [[ParseError]]: null, [[Destination]]: destination, [[PerformFetch]]: null, [[FetchClient]]: fetchClient }.
5. ~IF［ %~fetchを遂行する ~NEQ ε ］ ⇒ %状態 .`PerformFetch^sl ~SET %~fetchを遂行する ◎ If performFetch was given, set state.[[PerformFetch]] to performFetch.

6. %読込ng~promise ~LET %~record .`LoadRequestedModules$jA( %状態 ) ◎ Let loadingPromise be record.LoadRequestedModules(state).

   注記： この段は、 当の~moduleの推移的な依存物~すべてを再帰的に読込むことになる。 ◎ This step will recursively load all the module transitive dependencies.

   • %読込ng~promise の`充足-時$には、 次の手続きを走らす： ◎ Upon fulfillment of loadingPromise, run the following steps:

     1. %~record .`Link$jA() ◎ Perform record.Link().

        注記： この段は、 当の~moduleの依存物のうち~linkされていないものすべてに対し， `Link$jA を再帰的に~callすることになる。 ◎ This step will recursively call Link on all of the module's unlinked dependencies.

        この段で例外 %E が投出されたときは、 ~catchして ⇒＃ %~module~script の`再投出-用~error$sC ~SET %E ◎ If this throws an exception, catch it, and set moduleScript's error to rethrow to that exception.

     2. %完了-時の手続き( %~module~script ) ◎ Run onComplete given moduleScript.

   • %読込ng~promise の`却下-時$には、 次の手続きを走らす： ◎ Upon rejection of loadingPromise, run the following steps:

     1. ~IF［ %状態 .`ParseError^sl ~NEQ ~NULL ］ ⇒＃ %~module~script の`再投出-用~error$sC ~SET %状態 .`ParseError^sl； %完了-時の手続き( %~module~script ) ◎ If state.[[ParseError]] is not null, set moduleScript's error to rethrow to state.[[ParseError]] and run onComplete given moduleScript.

     2. ~ELSE ⇒ %完了-時の手続き( ~NULL ) ◎ Otherwise, run onComplete given null.

        注記： 読込ng~errorに因り %読込ng~promise が却下された場合、［ %状態 .`ParseError^sl ~EQ ~NULL ］になる。 ◎ state.[[ParseError]] is null when loadingPromise is rejected due to a loading error.

`単独の~module~scriptを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, `~script~fetch~option群$ %~option群, `環境~設定群~obj$ %設定群~obj, `~referrer$rq %~referrer, `~module要請~Record$ %~module要請【！省略時は ε 】, 真偽値 `~top-levelか$V, %完了-時の手続き, `~fetch~hookを遂行する~algo$ %~fetchを遂行する（省略時は ε ） ◎終 に対し，次を走らす： ◎ To fetch a single module script, given a URL url, an environment settings object fetchClient, a destination destination, a script fetch options options, an environment settings object settingsObject, a referrer referrer, an optional ModuleRequest Record moduleRequest, a boolean isTopLevel, an algorithm onComplete, and an optional perform the fetch hook performFetch, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).
2. %~module種別 ~LET %~module要請 に応じて ⇒＃ ε ならば `javascript-or-wasm^l ／ ~ELSE_ `~module要請から~module種別を得る$( %~module要請 ) ◎ Let moduleType be "javascript-or-wasm". ◎ If moduleRequest was given, then set moduleType to the result of running the module type from module request steps given moduleRequest.

3. ~Assert： `~module種別は許容されるか？$( %~module種別, %設定群~obj ) ~EQ ~T ◎ Assert: the result of running the module type allowed steps given moduleType and settingsObject is true.＼

   さもなければ、 この地点に達することはない — それに先立って，［ `HostLoadImportedModule$A の`中で＠#validate-requested-module-specifiers$ ］あるいは［ `単独の~importされた~module~scriptを~fetchする$とき ］に［ %~module要請 .`Attributes^sl を検分するとき ］に失敗に終わったはずなので。 ◎ Otherwise, we would not have reached this point because a failure would have been raised when inspecting moduleRequest.[[Attributes]] in HostLoadImportedModule or fetch a single imported module script.

4. %~module~map ~LET %設定群~obj の`~module~map$enV ◎ Let moduleMap be settingsObject's module map.
5. %~key ~LET ( %~URL, %~module種別 )

6. ~IF［ %~module~map[ %~key ] ~EQ `fetching^l ］：

   1. %~module~map[ %~key ] の値が変化するまで，`並列的$に待機する
   2. `~taskを~queueする$( `~network用~task~source$, この手続きの以降を続行する手続き )
   3. ~RET 【この段は、この訳による補完。】
   ◎ If moduleMap[(url, moduleType)] is "fetching", wait in parallel until that entry's value changes, then queue a task on the networking task source to proceed with running the following steps.
7. ~IF［ %~module~map[ %~key ] ~NEQ ε ］ ⇒＃ %完了-時の手続き( %~module~map[ %~key ] )； ~RET ◎ If moduleMap[(url, moduleType)] exists, run onComplete given moduleMap[(url, moduleType)], and return.
8. %~module~map[ %~key ] ~SET `fetching^l ◎ Set moduleMap[(url, moduleType)] to "fetching".
9. %要請 ~LET 新たな`要請$ — その ⇒＃ `~URL$rq ~SET %~URL, `~mode$rq ~SET `cors^l, `~referrer$rq ~SET %~referrer, `~client$rq ~SET %~fetch~client, `行先$rq ~SET `~module種別から~fetch用の行先を得る$( %行先, %~module種別 ) ◎ Let request be a new request whose URL is url, mode is "cors", referrer is referrer, and client is fetchClient. ◎ Set request's destination to the result of running the fetch destination from module type steps given destination and moduleType.
10. ~IF［ %行先 ~IN { `worker^l, `sharedworker^l, `serviceworker^l } ］~AND［ %~top-levelか ~EQ ~T ］ ⇒ %要請 の`~mode$rq ~SET `same-origin^l ◎ If destination is "worker", "sharedworker", or "serviceworker", and isTopLevel is true, then set request's mode to "same-origin".
11. %要請 の`起動元~種別$rq ~SET `script^l ◎ Set request's initiator type to "script".
12. `~module~script要請を設定しておく$( %要請, %~option群 ) ◎ Set up the module script request given request and options.

13. ~IF［ %~fetchを遂行する ~NEQ ε ］ ⇒ %~fetchを遂行する( %要請, %~top-levelか, %応答の本体を消費する処理n† ) ◎ If performFetch was given, run performFetch with request, isTopLevel, and with processResponseConsumeBody as defined below.

    ~ELSE ⇒ %要請 を`~fetchする$ — 次を与える下で ⇒ `応答の本体を消費する処理n$i ~SET %応答の本体を消費する処理n† ◎ Otherwise, fetch request with processResponseConsumeBody set to processResponseConsumeBody as defined below.

    † %応答の本体を消費する処理n は、 所与の ( `応答$ %応答, ［ ~NULL ／ `失敗^i ／ `~byte列$ ］ %本体~byte列 ) に対し： ◎ In both cases, let processResponseConsumeBody given response response and null, failure, or a byte sequence bodyBytes be the following algorithm:

    注記： %応答 は、 常に`~CORS同一-生成元$になる。 ◎ response is always CORS-same-origin.

    1. ~IF［ %本体~byte列 ~IN { ~NULL, `失敗^i } ］~OR［ %応答 の`状態s$rsは`~ok状態s$rsでない ］ ⇒＃ %~module~map[ %~key ] ~SET ~NULL； %完了-時の手続き( ~NULL )； ~RET ◎ If any of the following are true: • bodyBytes is null or failure; or • response's status is not an ok status, then set moduleMap[(url, moduleType)] to null, run onComplete given null, and abort these steps.
    2. %~MIME型 ~LET `~header~listから~MIME型を抽出する$( %応答 の`~header~list$rs ) ◎ Let mimeType be the result of extracting a MIME type from response's header list.
    3. %~module~script ~LET ~NULL ◎ Let moduleScript be null.
    4. %~referrer施策 ~LET `~referrer施策を構文解析する$( %応答 ) `REFERRERPOLICY$r ◎ Let referrerPolicy be the result of parsing the `Referrer-Policy` header given response. [REFERRERPOLICY]
    5. ~IF［ %~referrer施策 ~NEQ 空~文字列 ］ ⇒ %~option群 の`~referrer施策$sfO ~SET %~referrer施策 ◎ If referrerPolicy is not the empty string, set options's referrer policy to referrerPolicy.
    6. ~IF［ %~MIME型 の`~essence$ ~EQ "`application/wasm$mt" ］~AND［ %~module種別 ~EQ `javascript-or-wasm^l ］ ⇒ %~module~script ~SET `~WebAssembly~module~scriptを作成する$( ↓ ) ⇒＃ %本体~byte列, %設定群~obj, %応答 の`~URL$rs, %~option群 ◎ If mimeType's essence is "application/wasm" and moduleType is "javascript-or-wasm", then set moduleScript to the result of creating a WebAssembly module script given bodyBytes, settingsObject, response's URL, and options.

    7. ~ELSE： ◎ Otherwise:

       1. %~source~text ~LET `~UTF-8復号する$( %本体~byte列 ) ◎ Let sourceText be the result of UTF-8 decoding bodyBytes.
       2. ~IF［ %~MIME型 は`~JS~MIME型$である ］~AND［ %~module種別 ~EQ `javascript-or-wasm^l ］ ⇒ %~module~script ~SET `~JS~module~scriptを作成する$( ↓ ) ⇒＃ %~source~text, %設定群~obj, %応答 の`~URL$rs, %~option群 ◎ If mimeType is a JavaScript MIME type and moduleType is "javascript-or-wasm", then set moduleScript to the result of creating a JavaScript module script given sourceText, settingsObject, response's URL, and options.
       3. ~IF［ %~MIME型 の`~essence$ ~EQ "`text/css$mt" ］~AND［ %~module種別 ~EQ `css^l ］ ⇒ %~module~script ~SET `~CSS~module~scriptを作成する$( %~source~text, %設定群~obj ) ◎ If the MIME type essence of mimeType is "text/css" and moduleType is "css", then set moduleScript to the result of creating a CSS module script given sourceText and settingsObject.
       4. ~IF［ %~MIME型 は`~JSON~MIME型$である ］~AND［ %~module種別 ~EQ `json^l ］ ⇒ %~module~script ~SET `~JSON~module~scriptを作成する$( %~source~text, %設定群~obj ) ◎ If mimeType is a JSON MIME type and moduleType is "json", then set moduleScript to the result of creating a JSON module script given sourceText and settingsObject.
    8. %~module~map[ %~key ] ~SET %~module~script ◎ Set moduleMap[(url, moduleType)] to moduleScript,＼

    9. %完了-時の手続き( %~module~script ) ◎ and run onComplete given moduleScript.

       注記： `~module~map$は`要請~URL$rqを~keyに利用する一方で，`~module~script$の`基底~URL$sCは`応答~URL$rsに設定するのは、 意図的である。 前者は~fetchを重複させないために利用される一方で、 後者は~URL解決に利用される。 ◎ It is intentional that the module map is keyed by the request URL, whereas the base URL for the module script is set to the response URL. The former is used to deduplicate fetches, while the latter is used for URL resolution.

`単独の~importされた~module~scriptを~fetchする@ ときは、 所与の ⇒＃ `~URL$ %~URL, `環境~設定群~obj$ %~fetch~client, `行先$rq %行先, `~script~fetch~option群$ %~option群, `環境~設定群~obj$ %設定群~obj, `~referrer$rq %~referrer, `~module要請~Record$ %~module要請, %完了-時の手続き, `~fetch~hookを遂行する~algo$ %~fetchを遂行する（省略時は ε ） ◎終 に対し，次を走らす： ◎ To fetch a single imported module script, given a URL url, an environment settings object fetchClient, a destination destination, a script fetch options options, environment settings object settingsObject, a referrer referrer, a ModuleRequest Record moduleRequest, an algorithm onComplete, and an optional perform the fetch hook performFetch, run these steps.＼

1. ~Assert： %完了-時の手続き は、［ ~NULL （失敗~時）／`~module~script$（成功~時） ］を受容する~algoである。 ◎ onComplete must be an algorithm accepting null (on failure) or a module script (on success).
2. ~Assert： どの`~Record$ %~entry ~IN %~module要請 .`Attributes^sl も［ %~entry .`Key^sl ~EQ `type^l ］を満たす — `HostGetSupportedImportAttributes$A にて， `type^l 属性を伴うものに限り依頼したので。 ◎ Assert: moduleRequest.[[Attributes]] does not contain any Record entry such that entry.[[Key]] is not "type", because we only asked for "type" attributes in HostGetSupportedImportAttributes.
3. %~module種別 ~LET `~module要請から~module種別を得る$( %~module要請 ) ◎ Let moduleType be the result of running the module type from module request steps given moduleRequest.
4. ~IF［ `~module種別は許容されるか？$( %~module種別, %設定群~obj ) ~EQ ~F ］ ⇒＃ %完了-時の手続き( ~NULL )； ~RET ◎ If the result of running the module type allowed steps given moduleType and settingsObject is false, then run onComplete given null, and return.
5. `単独の~module~scriptを~fetchする$( ↓ ) ⇒＃ %~URL, %~fetch~client, %行先, %~option群, %設定群~obj, %~referrer, %~module要請, ~F, %完了-時の手続き, %~fetchを遂行する ◎ Fetch a single module script given url, fetchClient, destination, options, settingsObject, referrer, moduleRequest, false, and onComplete. If performFetch was given, pass it along as well.

`古典~scriptを作成する@ ときは、 所与の ⇒＃ `文字列$ %~source, `環境~設定群~obj$ %設定群, `~URL$ %基底~URL, `~script~fetch~option群$ %~option群, 真偽値 %~errorを黙秘するか（省略時は ~F ）, ［`~URL$／~NULL］ %~window~script用の~source~URL（省略時は ~NULL ） ◎終 に対し，次を走らす： ◎ To create a classic script, given a string source, an environment settings object settings, a URL baseURL, a script fetch options options, an optional boolean mutedErrors (default false), and an optional URL-or-null sourceURLForWindowScripts (default null):

1. ~IF［ %~errorを黙秘するか ~EQ ~T ］ ⇒ %基底~URL ~SET `about:blank＠~HTMLdep#about:blank$sc ◎ If mutedErrors is true, then set baseURL to about:blank.

   注記： %~errorを黙秘するか ~EQ ~T のとき、 %基底~URL は，当の~scriptの`~CORS非同一-生成元$な`応答$の`~URL$rsになる — それは，~JSには公開されないベキなので、 %基底~URL は，ここで無毒化される。 ◎ When mutedErrors is true, baseURL is the script's CORS-cross-origin response's url, which shouldn't be exposed to JavaScript. Therefore, baseURL is sanitized here.

2. ~IF［ %設定群 用の`~scriptingは不能化されて$sttいる ］ ⇒ %~source ~SET 空~文字列 ◎ If scripting is disabled for settings, then set source to the empty string.
3. %~script ~LET 新たな`古典~script$ — その ⇒＃ `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET %基底~URL, `~fetch~option群$sC ~SET %~option群 `~errorを黙秘するか$sC ~SET %~errorを黙秘するか, `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL ◎ Let script be a new classic script that this algorithm will subsequently initialize. ◎ Set script's settings object to settings. ◎ Set script's base URL to baseURL. ◎ Set script's fetch options to options. ◎ Set script's muted errors to mutedErrors. ◎ Set script's parse error and error to rethrow to null.
4. `古典~scriptの作成~時刻を記録する$( %~script, %~window~script用の~source~URL ) ◎ Record classic script creation time given script and sourceURLForWindowScripts.

5. %結果 ~LET `ParseScript$jA( %~source, %設定群 の`~realm$enV, %~script ) ◎ Let result be ParseScript(source, settings's realm, script).

   注記： ここで最後の~parameterに %~script を渡すことにより，［ %結果 .`HostDefined^sl ~EQ %~script ］になることが確保される。 ◎ Passing script as the last parameter here ensures result.[[HostDefined]] will be script.

6. ~IF［ %結果 は ~errorたちが成す`~list$である ］： ◎ If result is a list of errors, then:

   1. %~script の ⇒＃ `構文解析-~error$sC ~SET %結果[0], `再投出-用~error$sC ~SET %結果[0] ◎ Set script's parse error and its error to rethrow to result[0].
   2. ~RET %~script ◎ Return script.
7. %~script の`~record$sC ~SET %結果 ◎ Set script's record to result.
8. ~RET %~script ◎ Return script.

`~JS~module~scriptを作成する@ ときは、 所与の ⇒＃ `文字列$ %~source, `環境~設定群~obj$ %設定群, `~URL$ %基底~URL, `~script~fetch~option群$ %~option群 ◎終 に対し，次を走らす： ◎ To create a JavaScript module script, given a string source, an environment settings object settings, a URL baseURL, and a script fetch options options:

1. ~IF［ %設定群 用の`~scriptingは不能化されて$sttいる ］ ⇒ %~source ~SET 空~文字列 ◎ If scripting is disabled for settings, then set source to the empty string.
2. %~script ~LET 新たな`~module~script$ — その ⇒＃ `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET %基底~URL, `~fetch~option群$sC ~SET %~option群 `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL ◎ Let script be a new module script that this algorithm will subsequently initialize. ◎ Set script's settings object to settings. ◎ Set script's base URL to baseURL. ◎ Set script's fetch options to options. ◎ Set script's parse error and error to rethrow to null.

3. %結果 ~LET `ParseModule$jA( %~source, %設定群 の`~realm$enV, %~script ) ◎ Let result be ParseModule(source, settings's realm, script).

   注記： ここで最後の~parameterに %~script を渡すことにより，［ %結果 .`HostDefined^sl ~EQ %~script ］になることが確保される。 ◎ Passing script as the last parameter here ensures result.[[HostDefined]] will be script.

4. ~IF［ %結果 は ~errorたちが成す`~list$である ］： ◎ If result is a list of errors, then:

   1. %~script の`構文解析-~error$sC ~SET %結果[0] ◎ Set script's parse error to result[0].
   2. ~RET %~script ◎ Return script.
5. %~script の`~record$sC ~SET %結果 ◎ Set script's record to result.
6. ~RET %~script ◎ Return script.

`~WebAssembly~module~scriptを作成する@ ときは、 所与の ⇒＃ `~byte列$ %本体~byte列, `環境~設定群~obj$ %設定群, `~URL~record$ %基底~URL, `~script~fetch~option群$ %~option群 ◎終 に対し： ◎ To create a WebAssembly module script, given a byte sequence bodyBytes, an environment settings object settings, a URL baseURL, and a script fetch options options:

1. ~IF［ %設定群 用の`~scriptingは不能化されて$sttいる ］ ⇒ %本体~byte列 ~SET ~byte列 0x00 0x61 0x73 0x6d 0x01 0x00 0x00 0x00 ◎ If scripting is disabled for settings, then set bodyBytes to the byte sequence 0x00 0x61 0x73 0x6d 0x01 0x00 0x00 0x00.

   注記： この~byte列は、［ ~magic~byte列, ~version番号 ］のみを供する空な~WebAssembly~moduleに対応する。 ◎ This byte sequence corresponds to an empty WebAssembly module with only the magic bytes and version number provided.

2. %~script ~LET 新たな`~module~script$ — その ⇒＃ `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET %基底~URL, `~fetch~option群$sC ~SET %~option群, `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL, ◎ Let script be a new module script that this algorithm will subsequently initialize. ◎ Set script's settings object to settings. ◎ Set script's base URL to baseURL. ◎ Set script's fetch options to options. ◎ Set script's parse error and error to rethrow to null.

3. %結果 ~LET `~WebAssembly~moduleを構文解析する$( %本体~byte列, %設定群 の`~realm$enV, %~script ) ◎ Let result be the result of parsing a WebAssembly module given bodyBytes, settings's realm, and script.

   注記： ここで，最後の~parameterとして %~script を渡すことにより、 %結果. `HostDefined^sl が %~script になることを確保する。 ◎ Passing script as the last parameter here ensures result.[[HostDefined]] will be script.

   ~error %~error が投出されたときは、 ~catchして： ◎ If the previous step threw an error error, then:

   1. %~script の`構文解析-~error$sC ~SET %~error ◎ Set script's parse error to error.
   2. ~RET %~script ◎ Return script.
4. %~script の`~record$sC ~SET %結果 ◎ Set script's record to result.
5. ~RET %~script ◎ Return script.

注記： `WASMESM$r は、 ~WebAssemblyを `JAVASCRIPT$r ~module読込ngへ統合するための~hookを指定する。 これは、［ 直な依存関係~import（ `direct dependency imports^en ）, ~source段階~import（ `source phase imports^en ） ］両者~用の~supportを含む — それは、［ ~virtual化（ `virtualization^en ）, 複-~instance化（ `multi-instantiation^en ） ］を~supportする。 `WASMESM$r ◎ WebAssembly JavaScript Interface: ESM Integration specifies the hooks for the WebAssembly integration with ECMA-262 module loading. This includes support both for direct dependency imports, as well as for source phase imports, which support virtualization and multi-instantiation. [WASMESM]

`~CSS~module~scriptを作成する@ ときは、 所与の ( 文字列 %~source, `環境~設定群~obj$ %設定群 ) に対し： ◎ To create a CSS module script, given a string source and an environment settings object settings:

1. %~script ~LET 新たな`~module~script$ — その ⇒＃ `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET ~NULL, `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL ◎ Let script be a new module script that this algorithm will subsequently initialize. ◎ Set script's settings object to settings. ◎ Set script's base URL and fetch options to null. ◎ Set script's parse error and error to rethrow to null.
2. %~stylesheet ~LET 新たな `CSSStyleSheet$I ~obj ◎ ↓
3. %~stylesheet 上の `new CSSStyleSheet$m 構築子~手続き( 空な辞書 ) 【！構築-済みな~CSSStyleSheetを作成する】 ◎ Let sheet be the result of running the steps to create a constructed CSSStyleSheet with an empty dictionary as the argument.

4. %~stylesheet 上の `replaceSync$m ~method手続き( %~source ) 【！~CSS規則~群を同期的に置換する】 ◎ Run the steps to synchronously replace the rules of a CSSStyleSheet on sheet given source.

   この段で例外 %E が投出されたときは、 ~catchして ⇒＃ %~script の`構文解析-~error$sC ~SET %E ； ~RET %~script ◎ If this throws an exception, catch it, and set script's parse error to that exception, and return script.

   注記： `replaceSync$m ~method手続きは、 %~source が `import$at 規則を包含する場合には，例外を投出することになる。 【と記されているが、実際の手続きは，そうなるかどうか明瞭でない。】 これは、 今の所は設計による — ~CSS~module~script用にこれらを取扱う方法に対し，まだ合意が無いので。 したがって総意に達するまでは，一律に阻止される。 ◎ The steps to synchronously replace the rules of a CSSStyleSheet will throw if source contains any @import rules. This is by-design for now because there is not yet an agreement on how to handle these for CSS module scripts; therefore they are blocked altogether until a consensus is reached.

5. %~script の`~record$sC ~SET `CreateDefaultExportSyntheticModule$jA( %~stylesheet ) ◎ Set script's record to the result of CreateDefaultExportSyntheticModule(sheet).
6. ~RET %~script ◎ Return script.

`~JSON~module~scriptを作成する@ ときは、 所与の ( 文字列 %~source, `環境~設定群~obj$ %設定群 ) に対し，次を走らす： ◎ To create a JSON module script, given a string source and an environment settings object settings:

1. %~script ~LET 新たな`~module~script$ — その ⇒＃ `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET ~NULL, `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL ◎ Let script be a new module script that this algorithm will subsequently initialize. ◎ Set script's settings object to settings. ◎ Set script's base URL and fetch options to null. ◎ Set script's parse error and error to rethrow to null.

2. %結果 ~LET `ParseJSONModule$jA( %~source ) ◎ Let result be ParseJSONModule(source).

   この段で例外 %E が投出されたときは、 ~catchして ⇒＃ %~script の`構文解析-~error$sC ~SET %E； ~RET %~script ◎ If this throws an exception, catch it, and set script's parse error to that exception, and return script.

3. %~script の`~record$sC ~SET %結果 ◎ Set script's record to result.
4. ~RET %~script ◎ Return script.

`~module要請から~module種別を得る@ 手続きは、 所与の ( `~module要請~Record$ %~module要請 ) 対し，次に従う： ◎ The module type from module request steps, given a ModuleRequest Record moduleRequest, are as follows:

1. %~module種別 ~LET `javascript-or-wasm^l ◎ Let moduleType be "javascript-or-wasm".

2. ~IF［ %~module要請 .`Attributes^sl は、 `~Record$ %~entry として［ %~entry .`Key^sl ~EQ `type^l ］を満たすものを有する ］： ◎ If moduleRequest.[[Attributes]] has a Record entry such that entry.[[Key]] is "type", then:

   1. ~Assert： そのような`~Record$が複数個 在ることはない。 【この段は、この訳による補完。】

   2. ~IF［ %~entry .`Value^sl ~EQ `javascript-or-wasm^l ］ ⇒ %~module種別 ~SET ~NULL ◎ If entry.[[Value]] is "javascript-or-wasm", then set moduleType to null.

      注記： この仕様は、［ `~JS~module~script$, `~WebAssembly~module~script$ ］用には，~module種別 `javascript-or-wasm^l を内部的に利用するので、 この段は，［ ~moduleが `javascript-or-wasm^l 種別~属性を利用して~importされる ］ことを防止するために必要になる （ %~module種別 ~NULL は、 `~module種別は許容されるか？$の検査を失敗させる）。 ◎ This specification uses the "javascript-or-wasm" module type internally for JavaScript module scripts or WebAssembly module scripts, so this step is needed to prevent modules from being imported using a "javascript-or-wasm" type attribute (a null moduleType will cause the module type allowed check to fail).

   3. ~ELSE ⇒ %~module種別 ~SET %~entry .`Value^sl ◎ Otherwise, set moduleType to entry.[[Value]].
3. ~RET %~module種別 ◎ Return moduleType.

`~module種別は許容されるか？@ は、 所与の ( `文字列$ %~module種別, `環境~設定群~obj$ %設定群 ) に対し： ◎ The module type allowed steps, given a string moduleType and an environment settings object settings, are as follows:

1. ~RET ~IS［ ~OR↓ ］：

   • %~module種別 ~IN { `javascript-or-wasm^l, `json^l }
   • ［ %~module種別 ~EQ `css^l ］~AND［ `CSSStyleSheet$I ~interfaceは %設定群 の`~realm$enV 内に`公開されて$いる ］
   ◎ If moduleType is not "javascript-or-wasm", "css", or "json", then return false. ◎ If moduleType is "css" and the CSSStyleSheet interface is not exposed in settings's realm, then return false. ◎ Return true.

`~module種別から~fetch用の行先を得る@ ときは、 所与の ( `行先$rq %既定の行先, `文字列$ %~module種別 ) に対し ⇒ ~RET %~module種別 に応じて ⇒＃ `json^l ならば `json^l ／ `css^l ならば `style^l ／ ~ELSE_ %既定の行先 ◎ The fetch destination from module type steps, given a destination defaultDestination and a string moduleType, are as follows: • If moduleType is "json", then return "json". • If moduleType is "css", then return "style". • Return defaultDestination.

`古典~scriptを走らす@ ときは、 所与の ( `古典~script$ %~script, 真偽値 %~errorは再投出するか （省略時は ~F ） ) に対し： ◎ To run a classic script given a classic script script and an optional boolean rethrow errors (default false):

1. %設定群 ~LET %~script の`設定群~obj$sC ◎ Let settings be the settings object of script.
2. ~IF［ `~scriptは走れるかどうか検査する$( %設定群 ) ~EQ `走るな^i ］ ⇒ ~RET `NormalCompletion$jA( `empty^i ) ◎ Check if we can run script with settings. If this returns "do not run" then return NormalCompletion(empty).
3. `古典~scriptの実行~開始~時刻を記録する$( %~script ) ◎ Record classic script execution start time given script.
4. `~scriptを走らすために準備する$( %設定群 ) ◎ Prepare to run script given settings.
5. %評価~状態s ~LET ~NULL ◎ Let evaluationStatus be null.
6. ~IF［ %~script の`再投出-用~error$sC ~NEQ ~NULL ］ ⇒ %評価~状態s ~SET 新たな`完了~Record$ — その ⇒＃ `Type^sl ~SET `throw^i, `Value^sl ~SET %~script の`再投出-用~error$sC, `Target^sl ~SET `empty^i ◎ If script's error to rethrow is not null, then set evaluationStatus to Completion { [[Type]]: throw, [[Value]]: script's error to rethrow, [[Target]]: empty }.

7. ~ELSE：

   1. %評価~状態s ~SET `ScriptEvaluation$jA( %~script の`~record$sC )

      ~IF［ ~UAは`走っている~scriptを中止-$したため， `ScriptEvaluation$jA は完了しなかった ］：

      1. `走らせた~scriptを片付ける$( %設定群 )
      2. ~RET 新たな`完了~Record$ — その ⇒＃ `Type^sl ~SET `throw^i, `Value^sl ~SET 新たな `QuotaExceededError$E 例外, `Target^sl ~SET `empty^i
   ◎ Otherwise, set evaluationStatus to ScriptEvaluation(script's record). ◎ If ScriptEvaluation does not complete because the user agent has aborted the running script, leave evaluationStatus as null. ◎ ↓↓

8. ~IF［ %評価~状態s は`中途完了$である ］： ◎ If evaluationStatus is an abrupt completion, then:

   1. ~IF［ %~errorは再投出するか ~EQ ~T ］：

      1. `走らせた~scriptを片付ける$( %設定群 )
      2. ~THROW ［ %~script の`~errorを黙秘するか$sC ］に応じて ⇒＃ ~T ならば `NetworkError$E ／ ~F ならば %評価~状態s .`Value^sl
      ◎ If rethrow errors is true and script's muted errors is false, then: • Clean up after running script with settings. • Rethrow evaluationStatus.[[Value]]. ◎ If rethrow errors is true and script's muted errors is true, then: • Clean up after running script with settings. • Throw a "NetworkError" DOMException.

   2. ~ELSE： ◎ Otherwise, rethrow errors is false. Perform the following steps:

      1. `例外を報告する$( %評価~状態s .`Value^sl, %~script の`設定群~obj$sCの`大域~obj$enV ) ◎ Report an exception given by evaluationStatus.[[Value]] for script's settings object's global object.
      2. `走らせた~scriptを片付ける$( %設定群 ) ◎ Clean up after running script with settings.
      3. ~RET %評価~状態s ◎ Return evaluationStatus.

9. ~ELSE（ %評価~状態s は正常完了である）：

   1. `走らせた~scriptを片付ける$( %設定群 )
   2. ~RET %評価~状態s
   ◎ Clean up after running script with settings. ◎ If evaluationStatus is a normal completion, then return evaluationStatus. ◎ ↑↑If we've reached this point, evaluationStatus was left as null because the script was aborted prematurely during evaluation. Return Completion { [[Type]]: throw, [[Value]]: a new "QuotaExceededError" DOMException, [[Target]]: empty }.

`~module~scriptを走らす@ ときは、 所与の ( `~module~script$ %~script, 真偽値 %~error報告ngは防止するか （省略時は ~F ） ) に対し： ◎ To run a module script given a module script script and an optional boolean preventErrorReporting (default false):

1. %設定群 ~LET %~script の`設定群~obj$sC ◎ Let settings be the settings object of script.
2. ~IF［ `~scriptは走れるかどうか検査する$( %設定群 ) ~EQ `走るな^i ］ ⇒ ~RET `却下される~promise$( `undefined^jv ) ◎ Check if we can run script with settings. If this returns "do not run", then return a promise resolved with undefined.
3. `~module~scriptの実行~開始~時刻を記録する$( %~script ) ◎ Record module script execution start time given script.
4. `~scriptを走らすために準備する$( %設定群 ) ◎ Prepare to run script given settings.
5. %評価~promise ~LET ~NULL ◎ Let evaluationPromise be null.
6. ~IF［ %~script の`再投出-用~error$sC ~NEQ ~NULL ］ ⇒ %評価~promise ~SET `却下される~promise$( %~script の`再投出-用~error$sC ) ◎ If script's error to rethrow is not null, then set evaluationPromise to a promise rejected with script's error to rethrow.

7. ~ELSE： ◎ Otherwise:

   1. %~record ~LET %~script の`~record$sC ◎ Let record be script's record.

   2. %評価~promise ~SET %~record .`Evaluate$jA() ◎ Set evaluationPromise to record.Evaluate().

      注記： この段は、 ~moduleの依存物すべてを再帰的に評価することになる。 ◎ This step will recursively evaluate all of the module's dependencies.

      ~IF［ ~UAが`走っている~scriptを中止-$したため， `Evaluate$jA は完了しなかった ］ ⇒ %評価~promise ~SET `却下される~promise$( `QuotaExceededError$E 例外 ) ◎ If Evaluate fails to complete as a result of the user agent aborting the running script, then set evaluationPromise to a promise rejected with a new "QuotaExceededError" DOMException.

8. ~IF［ %~error報告ngは防止するか ~EQ ~F ］： ◎ If preventErrorReporting is false, then＼

   1. %評価~promise の`却下-時$には、 所与の ( 事由 %事由 ) に対し，次の手続きを走らす ⇒ `例外を報告する$( %事由, %~script の`設定群~obj$sCの`大域~obj$enV ) ◎ upon rejection of evaluationPromise with reason, report an exception given by reason for script's settings object's global object.
9. `走らせた~scriptを片付ける$( %設定群 ) ◎ Clean up after running script with settings.
10. ~RET %評価~promise ◎ Return evaluationPromise.

`~scriptは走れるかどうか検査する@ ときは、 所与の ( `環境~設定群~obj$ %設定群 ) に対し，次を走らす — これは、［ `走れ^i, `走るな^i ］のいずれかを返す： ◎ The steps to check if we can run script with an environment settings object settings are as follows. They return either "run" or "do not run".

1. ~IF［ %設定群 の`大域~obj$enVは`~window$である ］~AND［ %設定群 の`文書$は`全部的に作動中$でない ］ ⇒ ~RET `走るな^i ◎ If the global object specified by settings is a Window object whose Document object is not fully active, then return "do not run".
2. ~IF［ %設定群 用の`~scriptingは不能化されて$sttいる ］ ⇒ ~RET `走るな^i ◎ If scripting is disabled for settings, then return "do not run".
3. ~RET `走れ^i ◎ Return "run".

`~scriptを走らすために準備する@ ときは、 所与の ( `環境~設定群~obj$ %設定群 ) に対し，次を走らす： ◎ The steps to prepare to run script with an environment settings object settings are as follows:

1. `~JS実行~文脈~stack$に［ %設定群 の`~realm実行~文脈$enV ］を~pushする — この時点で、 それが`走っている~JS実行~文脈$になる。 ◎ Push settings's realm execution context onto the JavaScript execution context stack; it is now the running JavaScript execution context.
2. `~surrounding~agent$の`~event~loop$aGの`現在~走っている~task$の`~script評価 環境~設定群~obj集合$tKに %設定群 を追加する ◎ Add settings to the surrounding agent's event loop's currently running task's script evaluation environment settings object set.

`走らせた~scriptを片付ける@ ときは、 所与の ( `環境~設定群~obj$ %設定群 ) に対し，次を走らす： ◎ The steps to clean up after running script with an environment settings object settings are as follows:

1. ~Assert： %設定群 の`~realm実行~文脈$enVは、 `走っている~JS実行~文脈$である ◎ Assert: settings's realm execution context is the running JavaScript execution context.
2. `~JS実行~文脈~stack$から， %設定群 の`~realm実行~文脈$enVを除去する ◎ Remove settings's realm execution context from the JavaScript execution context stack.
3. ~IF［ `~JS実行~文脈~stack$は空になった ］ ⇒ `小task~checkpointを遂行する$ （これが~scriptを走らす場合、 この~algoは，再入的に呼出されることになる。） ◎ If the JavaScript execution context stack is now empty, perform a microtask checkpoint. (If this runs scripts, these algorithms will be invoked reentrantly.)

`~error情報を抽出する@ ときは、 所与の ( ~JS値 %例外 ) に対し： ◎ To extract error information from a JavaScript value exception:

1. %属性~群 ~LET 新たな`有順序~map$ — `ErrorEvent$I に定義される各~IDL属性を~keyに利用する。 ◎ Let attributes be an empty map keyed by IDL attributes.
2. %属性~群[ `error$m ] ~SET %例外 ◎ Set attributes[error] to exception.

3. ~EACH( %~key ~IN { `message$m, `filename$m, `lineno$m, `colno$m } ) に対し ⇒ %属性~群[ %~key ] ~SET %例外 から導出された`実装定義$な値 ◎ Set attributes[message], attributes[filename], attributes[lineno], and attributes[colno] to implementation-defined values derived from exception.

   注記： 各~browserは、［ ここ, および~JS仕様 ］においては指定されない，［ 【開発者に】役立つ値を集める挙動 ］を実装する — 通例的でない事例（例： `eval^c ）を含めて。 将来においては、 これは，ずっと詳細に指定されるかもしれない。 ◎ Browsers implement behavior not specified here or in the JavaScript specification to gather values which are helpful, including in unusual cases (e.g., eval). In the future, this might be specified in greater detail.

4. ~RET %属性~群 ◎ Return attributes.

`例外を報告する@ ときは、 所与の ⇒＃ ~JS値 %例外, `大域~obj$ %大域~obj, %~errorを省略するか ~IN { ε, `~errorを省略する^i } （省略時は ε ） ◎終 に対し： ◎ To report an exception exception which is a JavaScript value, for a particular global object global and optional boolean omitError (default false):

1. %取扱われなかったか ~LET ~T ◎ Let notHandled be true.
2. %~error報 ~LET `~error情報を抽出する$( %例外 ) ◎ Let errorInfo be the result of extracting error information from exception.

3. %~script ~LET `実装定義$な仕方で見出された`~script$または ~NULL — これは、 通例的には，`走っている~script$になるベキである （とりわけ，`古典~scriptを走らす$間は）。 ◎ Let script be a script found in an implementation-defined way, or null. This should usually be the running script (most notably during run a classic script).

   注記： さほど共通でない事例において， どの~scriptを利用して~errorを黙秘するかどうか決定するかに関して、 各~実装は，まだ相互運用可能な挙動に決着してない。 ◎ Implementations have not yet settled on interoperable behavior for which script is used to determine whether errors are muted in less common cases.

4. ~IF［ %~script は`古典~script$である ］~AND［ %~script の`~errorを黙秘するか$sC ~EQ ~T ］ ⇒＃ %~error報[ `error$m ] ~SET ~NULL, %~error報[ `message$m ] ~SET `Script error.^l, %~error報[ `filename$m ] ~SET 空~文字列, %~error報[ `lineno$m ] ~SET 0, %~error報[ `colno$m ] ~SET 0 ◎ If script is a classic script and script's muted errors is true, then set errorInfo[error] to null, errorInfo[message] to "Script error.", errorInfo[filename] to the empty string, errorInfo[lineno] to 0, and errorInfo[colno] to 0.
5. ~IF［ %~errorを省略するか ~EQ `~errorを省略する^i ］ ⇒ %~error報[ `error$m ] ~SET ~NULL ◎ If omitError is true, then set errorInfo[error] to null.

6. ~IF［ %大域~obj の`~error報告ng~modeか$gL ~EQ ~F ］： ◎ If global is not in error reporting mode, then:

   1. %大域~obj の`~error報告ng~modeか$gL ~SET ~T ◎ Set global's in error reporting mode to true.

   2. ~IF［ %大域~obj は `EventTarget$I を実装する ］ ⇒ %取扱われなかったか ~SET `~eventを発火する$( %大域~obj, `error$et, `ErrorEvent$I ) — 次のように初期化して ⇒＃ `cancelable$m ~SET ~T, `ErrorEvent$I による追加的な各~属性を %~error報 に則って設定する ◎ If global implements EventTarget, then set notHandled to the result of firing an event named error at global, using ErrorEvent, with the cancelable attribute initialized to true, and additional attributes initialized according to errorInfo.

      注記： ~event~handlerが ~T を返した場合、 `~event~handler処理~algo$に従って， 当の~eventは取消されることになる。 ◎ Returning true in an event handler cancels the event per the event handler processing algorithm.

   3. %大域~obj の`~error報告ng~modeか$gL ~SET ~F ◎ Set global's in error reporting mode to false.

7. ~IF［ %取扱われなかったか ~EQ ~T ］： ◎ If notHandled is true, then:

   1. %~error報[ `error$m ] ~SET ~NULL ◎ Set errorInfo[error] to null.

   2. ~IF［ %大域~obj は `DedicatedWorkerGlobalScope$I を実装する ］ ⇒ `大域~taskを~queueする$( `~DOM操作~task~source$, %大域~obj に結付けられた `Worker$I ~objに`関連な大域~obj$, 次の手続き ) ◎ If global implements DedicatedWorkerGlobalScope, queue a global task on the DOM manipulation task source with the global's associated Worker's relevant global object to run these steps:

      手続きは：

      1. %~worker~obj ~LET %大域~obj に結付けられた `Worker$I ~obj ◎ Let workerObject be the Worker object associated with global.
      2. %取扱われなかったか ~SET `~eventを発火する$( %~worker~obj, `error$et, `ErrorEvent$I ) — 次のように初期化して ⇒＃ `cancelable$m 属性 ~SET ~T, `ErrorEvent$I による追加的な各~属性を %~error報 に則って設定する ◎ Set notHandled be the result of firing an event named error at workerObject, using ErrorEvent, with the cancelable attribute initialized to true, and additional attributes initialized according to errorInfo.

      3. ~IF［ %取扱われなかったか ~EQ ~T ］ ⇒ `例外を報告する$( %例外, %~worker~obj に`関連な大域~obj$, `~errorを省略する^i ) ◎ If notHandled is true, then report exception for workerObject's relevant global object with omitError set to true.

         注記： 実際の %例外 値は，所有者~realm内では可用にならないが、 それでも，~UAは［ `message$m, `filename$m, その他の属性を設定する ］ため, および［ 場合によっては，開発者~consoleへ報告する ］ために十分な情報を成し遂げる。 ◎ The actual exception value will not be available in the owner realm, but the user agent still carries through enough information to set the message, filename, and other attributes, as well as potentially report to a developer console.

8. ~ELSE ⇒ 任意選択で ⇒ %例外 を開発者~consoleへ報告する ◎ Otherwise, the user agent may report exception to a developer console.

`Worker$I ~objへ接続している`暗黙的な~port$への連絡が絶たれていた場合 （すなわち，当の~workerの親~workerが終了されていた場合）、 ~UAは［ 当の `Worker$I ~objには `error$et ~event~handlerは無かった ］かつ［ その~workerの `onerror＠~WORKERS#handler-workerglobalscope-onerror$m 属性は ~NULLであった ］かのように動作するモノトスル。 他の場合は、 上で述べたとおり動作するモノトスル。 ◎ If the implicit port connecting a worker to its Worker object＼ has been disentangled (i.e. if the parent worker has been terminated), then the user agent must act as if the Worker object had no error event handler and as if that worker's onerror attribute was null,＼ but must otherwise act as described above.

注記： したがって，~error報告は、 専用~workerたちが成す連鎖を遡って，元の`文書$まで伝播する — この連鎖~沿いに在る いずれかの~workerが終了され，~garbage収集された場合でも。 ◎ Thus, error reports propagate up to the chain of dedicated workers up to the original Document, even if some of the workers along this chain have been terminated and garbage collected.

この仕様の以前の改訂は， `例外を報告する＠#report-the-exception@ （ `report the exception^en ） ~algoを`課題 #958＠~HTMLissue/958$ の一部として定義したが、 挙動も入力も異なる この~algo — `例外を報告する$（ `report an exception^en ） — に取って代わられた。 この［ 仕様~levelの~ecosystem ］を更新することは、 `課題 #10516＠~HTMLissue/10516$ にて追跡される。 ◎ Previous revisions of this standard defined an algorithm to report the exception. As part of issue #958, this has been superseded by report an exception which behaves differently and takes different inputs. Issue #10516 tracks updating the specification ecosystem.

`WindowOrWorkerGlobalScope$I の `reportError(e)@m ~method手続きは ⇒ `例外を報告する$( %e, コレ ) ◎ The reportError(e) method steps are to report the exception e.

ここで`~errorを黙秘するか$sCが適用-可能かどうかは、 不明瞭である — Chrome, Safari は黙秘する一方で， Firefox は黙秘しない。 `課題 #958＠~HTMLissue/958$ も見よ。 ◎ It is unclear whether muting is applicable here. In Chrome and Safari it is muted, but in Firefox it is not. See also issue #958.

`却下-済み~promiseについて通知する@ ときは、 所与の ( `大域~obj$ %大域~obj ) に対し： ◎ To notify about rejected promises given a global object global:

1. %~list ~LET %大域~obj の`通知待ちな却下-済み~promise~list$gLを`~cloneする$ ◎ Let list be a clone of global's about-to-be-notified rejected promises list.
2. ~IF［ %~list は`空$である ］ ⇒ ~RET ◎ If list is empty, then return.
3. %大域~obj の`通知待ちな却下-済み~promise~list$gLを`空にする$ ◎ Empty global's about-to-be-notified rejected promises list.

4. `大域~taskを~queueする$( `~DOM操作~task~source$, %大域~obj, 次の手続き ) ◎ Queue a global task on the DOM manipulation task source given global to＼

   手続きは： ◎ run the following step:

   1. %~list を成す ~EACH( ~promise %p ) に対し： ◎ For each promise p of list:

      1. ~IF［ %p . `PromiseIsHandled^sl ~EQ ~T ］ ⇒ ~CONTINUE ◎ If p.[[PromiseIsHandled]] is true, then continue.
      2. %取消されなかったか ~LET `~eventを発火する$( %大域~obj, `unhandledrejection$et, `PromiseRejectionEvent$I ) — 次のように初期化して ⇒＃ `cancelable$m ~SET ~T, `promise$m ~SET %p, `reason$m ~SET %p . `PromiseResult^sl ◎ Let notCanceled be the result of firing an event named unhandledrejection at global, using PromiseRejectionEvent, with the cancelable attribute initialized to true, the promise attribute initialized to p, and the reason attribute initialized to p.[[PromiseResult]].
      3. ~IF［ %取消されなかったか ~EQ ~T ］ ⇒ 任意選択で ⇒ %p . `PromiseResult^sl を開発者~consoleへ報告する ◎ If notCanceled is true, then the user agent may report p.[[PromiseResult]] to a developer console.
      4. ~IF［ %p . `PromiseIsHandled^sl ~EQ ~F ］ ⇒ %大域~obj の`未決な却下-済み~promiseへの弱い参照たちが成す集合$gLに %p を`付加する$set ◎ If p.[[PromiseIsHandled]] is false, then append p to global's outstanding rejected promises weak set.

`~import~map構文解析-結果を作成する@ ときは、 所与の ( `文字列$ %入力, `~URL$ %基底~URL ) に対し： ◎ To create an import map parse result given a string input and a URL baseURL:

1. %結果 ~LET 新たな`~import~map構文解析-結果$ — その ⇒＃ `~import~map$impR ~SET ~NULL, `再投出-用~error$impR ~SET ~NULL ◎ Let result be an import map parse result whose import map is null and whose error to rethrow is null.

2. %結果 の`~import~map$impR ~SET `~import~map文字列を構文解析する$( %入力, %基底~URL ) ◎ Parse an import map string given input and baseURL,＼

   例外が投出されたときは、 ~catchして ⇒ %結果 の`再投出-用~error$impR ~SET その例外 ◎ catching any exceptions. If this threw an exception, then set result's error to rethrow to that exception. Otherwise, set result's import map to the return value.

3. ~RET %結果 ◎ Return result.

`~import~mapを登録する@ ときは、 所与の ( `Window$I %大域~obj, `~import~map構文解析-結果$ %結果 ) に対し： ◎ To register an import map given a Window global and an import map parse result result:

1. ~IF［ %結果 の`再投出-用~error$impR ~NEQ ~NULL ］ ⇒＃ `例外を報告する$( %結果 の`再投出-用~error$impR, %大域~obj )； ~RET ◎ If result's error to rethrow is not null, then report an exception given by result's error to rethrow for global and return.
2. `既存の~import~mapと新たな~import~mapを併合する$( %大域~obj, %結果 の`~import~map$impR ) ◎ Merge existing and new import maps, given global and result's import map.

`~module指定子を解決する@ ときは、 所与の ( ［ `~script$【！`script$e】／~NULL ］ %参照rしている~script, `文字列$ %指定子 ) に対し： ◎ To resolve a module specifier given a script-or-null referringScript and a string specifier:

1. %設定群~obj ~LET ~NULL ◎ ↓
2. %基底~URL ~LET ~NULL ◎ Let settingsObject and baseURL be null.

3. ~IF［ %参照rしている~script ~NEQ ~NULL ］： ◎ If referringScript is not null, then:

   1. %設定群~obj ~SET %参照rしている~script の`設定群~obj$sC ◎ Set settingsObject to referringScript's settings object.
   2. %基底~URL ~SET %参照rしている~script の`基底~URL$sC ◎ Set baseURL to referringScript's base URL.

4. ~ELSE： ◎ Otherwise:

   1. ~Assert： `現在の設定群~obj$は在る。 【参考：`課題 #8410＠~HTMLissue/8410$】 ◎ Assert: there is a current settings object.
   2. %設定群~obj ~SET `現在の設定群~obj$ ◎ Set settingsObject to the current settings object.
   3. %基底~URL ~SET %設定群~obj の`~API用~基底~URL$enV ◎ Set baseURL to settingsObject's API base URL.
5. %~import~map ~LET `空な~import~map$ ◎ Let importMap be an empty import map.
6. ~IF［ %設定群~obj の`大域~obj$enV は `Window$I を実装する ］ ⇒ %~import~map ~SET %設定群~obj の`大域~obj$enVの`~import~map$gL ◎ If settingsObject's global object implements Window, then set importMap to settingsObject's global object's import map.
7. %直列化-済み基底~URL ~LET `~URLを直列化する$( %基底~URL ) ◎ Let serializedBaseURL be baseURL, serialized.
8. %~as~URL ~LET `~URLの様な~module指定子を解決する$( %指定子, %基底~URL ) ◎ Let asURL be the result of resolving a URL-like module specifier given specifier and baseURL.
9. %正規化-済み指定子 ~LET %~as~URL に応じて ⇒＃ ~NULL ならば ~NULL ／ ~ELSE_ `~URLを直列化する$( %~as~URL ) ◎ Let normalizedSpecifier be the serialization of asURL, if asURL is non-null; otherwise, specifier.
10. %結果 ~LET ~NULL【！a URL-or-null, initially null】 ◎ Let result be a URL-or-null, initially null. ◎ ↓

11. %~import~map の`~scope群$iMを成す ~EACH( %~scope接頭辞 → %~scope~import群 ) に対し： ◎ For each scopePrefix → scopeImports of importMap's scopes:

    1. ~IF［ %~scope接頭辞 ~EQ %直列化-済み基底~URL ］~OR［［ %~scope接頭辞 は `/^l `で終端して$いる ］~AND［ %~scope接頭辞 は %直列化-済み基底~URL の`符号単位~接頭辞$である ］］： ◎ If scopePrefix is serializedBaseURL, or if scopePrefix ends with U+002F (/) and scopePrefix is a code unit prefix of serializedBaseURL, then:

       1. %~scope~import群との合致- ~LET `~import群との合致-を解決する$( %正規化-済み指定子, %~as~URL, %~scope~import群 ) ◎ Let scopeImportsMatch be the result of resolving an imports match given normalizedSpecifier, asURL, and scopeImports.
       2. ~IF［ %~scope~import群との合致- ~NEQ ~NULL ］ ⇒＃ %結果 ~SET %~scope~import群との合致-； ~BREAK ◎ If scopeImportsMatch is not null, then set result to scopeImportsMatch, and break.
12. ~IF［ %結果 ~EQ ~NULL ］ ⇒ %結果 ~SET `~import群との合致-を解決する$( %正規化-済み指定子, %~as~URL, %~import~map の`~import群$iM ) ◎ If result is null, set result be the result of resolving an imports match given normalizedSpecifier, asURL, and importMap's imports.

13. 注記： この時点では、［ %結果 ~EQ ~NULL ］ならば， %指定子 は %~import~map により何かへ対応付-直されなかったが、 ~URLに転じることは可能かもしれない。 ◎ At this point, if result is null, specifier wasn't remapped to anything by importMap, but it might have been able to be turned into a URL.

    ~IF［ %結果 ~EQ ~NULL ］ ⇒ %結果 ~SET %~as~URL ◎ If result is null, set it to asURL.

14. ~IF［ %結果 ~NEQ ~NULL ］： ◎ If result is not null, then:

    1. ~Assert： %結果 は`~URL$である。 ◎ ↑
    2. `解決-済み~module集合に~moduleを追加する$( ↓ ) ⇒＃ %設定群~obj, %直列化-済み基底~URL, %正規化-済み指定子, %~as~URL ◎ Add module to resolved module set given settingsObject, serializedBaseURL, normalizedSpecifier, and asURL.
    3. ~RET %結果 ◎ Return result.
15. ~THROW `TypeError$jc — これは、 次を指示する ⇒ %指定子 は裸な指定子であったが， %~import~map により何かへ対応付-直されなかった。 ◎ Throw a TypeError indicating that specifier was a bare specifier, but was not remapped to anything by importMap.

`~import群との合致-を解決する@ ときは、 所与の ( `文字列$ %正規化-済み指定子, ［ `~URL$／~NULL ］ %~as~URL, `~module指定子~map$ %指定子~map ) に対し： ◎ To resolve an imports match, given a string normalizedSpecifier, a URL-or-null asURL, and a module specifier map specifierMap:

1. %指定子~map を成す ~EACH( %指定子~key → %解決~結果 ) に対し： ◎ For each specifierKey → resolutionResult of specifierMap:

   1. ~IF［ %指定子~key ~EQ %正規化-済み指定子 ］： ◎ If specifierKey is normalizedSpecifier, then:

      1. ~IF［ %解決~結果 ~EQ ~NULL ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ %指定子~key の解決は、 ある ~NULL ~entryにより阻まれた。 ◎ If resolutionResult is null, then throw a TypeError indicating that resolution of specifierKey was blocked by a null entry.

         注記： これは、 `~module指定子を解決する$~algo全体を — 更なる~fallbackを伴うことなく — 終了させることになる。 ◎ This will terminate the entire resolve a module specifier algorithm, without any further fallbacks.

      2. ~Assert： %解決~結果 は`~URL$である ◎ Assert: resolutionResult is a URL.
      3. ~RET %解決~結果 ◎ Return resolutionResult.

   2. ~IF［ ~AND↓ ］… ◎ If all of the following are true:

      • %指定子~key は `/^l `で終端して$いる ◎ specifierKey ends with U+002F (/);
      • %指定子~key は、 %正規化-済み指定子 の`符号単位~接頭辞$である ◎ specifierKey is a code unit prefix of normalizedSpecifier; and
      • ［ %~as~URL ~EQ ~NULL ］~OR［ %~as~URL は`特別$urlである ］ ◎ either asURL is null, or asURL is special,

      …ならば： ◎ then:

      1. ~IF［ %解決~結果 ~EQ ~NULL ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ %指定子~key の解決は，ある ~NULL ~entryにより阻まれた。 ◎ If resolutionResult is null, then throw a TypeError indicating that the resolution of specifierKey was blocked by a null entry.

         注記： これは、 `~module指定子を解決する$~algo全体を — 更なる~fallbackを伴うことなく — 終了させることになる。 ◎ This will terminate the entire resolve a module specifier algorithm, without any further fallbacks.

      2. ~Assert： %解決~結果 は`~URL$である。 ◎ Assert: resolutionResult is a URL.
      3. %接頭辞より後 ~LET %正規化-済み指定子 の中の［ %指定子~key の`長さ$ ］から`終端までを成す符号単位~部分文字列$ ◎ Let afterPrefix be the portion of normalizedSpecifier after the initial specifierKey prefix.
      4. ~Assert： ［ `~URLを直列化する$( %解決~結果 ) の結果 ］は、 `/^l `で終端して$いる — `~import~map文字列を構文解析する$ときに，そうなるよう施行されたので。 ◎ Assert: resolutionResult, serialized, ends with U+002F (/), as enforced during parsing.
      5. %~URL ~LET `~URL構文解析する$( %接頭辞より後, %解決~結果 ) ◎ Let url be the result of URL parsing afterPrefix with resolutionResult.

      6. ~IF［ %~URL ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ %正規化-済み指定子 の解決は阻まれた — %接頭辞より後 を成す部位は［ %指定子~key 接頭辞により対応付けられた %解決~結果 ］に相対的に~URL構文解析できなかったので。 ◎ If url is failure, then throw a TypeError indicating that resolution of normalizedSpecifier was blocked since the afterPrefix portion could not be URL-parsed relative to the resolutionResult mapped to by the specifierKey prefix.

         注記： これは、 `~module指定子を解決する$~algo全体を — 更なる~fallbackを伴うことなく — 終了させることになる。 ◎ This will terminate the entire resolve a module specifier algorithm, without any further fallbacks.

      7. ~Assert： %~URL は`~URL$である。 ◎ Assert: url is a URL.

      8. ~IF［［ `~URLを直列化する$( %解決~結果 ) の結果 ］は［ `~URLを直列化する$( %~URL ) の結果 ］の`符号単位~接頭辞$でない ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ %正規化-済み指定子 の解決は、［ その接頭辞 %指定子~key の上へ引き~~返している（ `backtracking above^en ） ］ことに因り阻まれた ◎ If the serialization of resolutionResult is not a code unit prefix of the serialization of url, then throw a TypeError indicating that the resolution of normalizedSpecifier was blocked due to it backtracking above its prefix specifierKey.

         注記： これは、 `~module指定子を解決する$~algo全体を — 更なる~fallbackを伴うことなく — 終了させることになる。 ◎ This will terminate the entire resolve a module specifier algorithm, without any further fallbacks.

      9. ~RET %~URL ◎ Return url.

2. ~RET ~NULL ◎ Return null.

   注記： `~module指定子を解決する$~algoは、 より特定度が低い~scope — あるいは，アリな場合は `imports^l — へ~fall-backすることになる。 ◎ The resolve a module specifier algorithm will fall back to a less-specific scope, or to "imports", if possible.

`~URLの様な~module指定子を解決する@ ときは、 所与の ( `文字列$ %指定子, `~URL$ %基底~URL ) に対し： ◎ To resolve a URL-like module specifier, given a string specifier and a URL baseURL:

1. ~IF［ %指定子 は 次に挙げるいずれか`から開始して$いる ］… ⇒＃ `/^l, `./^l, `../^l ◎終 …ならば： ◎ If specifier starts with "/", "./", or "../", then:

   1. %~URL ~LET `~URL構文解析する$( %指定子, %基底~URL ) ◎ Let url be the result of URL parsing specifier with baseURL.

   2. ~IF［ %~URL ~EQ `失敗^i ］ ⇒ ~RET ~NULL ◎ If url is failure, then return null.

      これは、 例えば，次が満たされる場合に起こり得る ⇒ ［ %指定子 ~EQ `../foo^l ］~AND［ %基底~URL の`~scheme$url ~EQ "`data＠~RFCx/rfc2397#section-2$sc" ］ ◎ One way this could happen is if specifier is "../foo" and baseURL is a data: URL.

   3. ~RET %~URL ◎ Return url.

   注記： これは、 %指定子 が `//^l `から開始して$いる事例 — すなわち，~schemeに相対的な~URLである事例 — を含む。 したがって、 %~URL の`~host$urlは， %基底~URL のそれと同じになるとは限らない。 ◎ This includes cases where specifier starts with "//", i.e., scheme-relative URLs. Thus, url might end up with a different host than baseURL.

2. %~URL ~LET `~URL構文解析する$( %指定子 ) — （基底~URLは与えない） ◎ Let url be the result of URL parsing specifier (with no base URL).
3. ~IF［ %~URL ~EQ `失敗^i ］ ⇒ ~RET ~NULL ◎ If url is failure, then return null.
4. ~RET %~URL ◎ Return url.

`解決-済み~module集合に~moduleを追加する@ ときは、 所与の ⇒＃ `環境~設定群~obj$ %設定群~obj, `文字列$ %直列化-済み基底~URL, `文字列$ %正規化-済み指定子, ［ ~NULL ／ `~URL$ ］ %~as~URL ◎終 に対し： ◎ To add module to resolved module set given an environment settings object settingsObject, a string serializedBaseURL, a string normalizedSpecifier, and a URL-or-null asURL:

1. %大域~obj ~LET %設定群~obj の`大域~obj$enV ◎ Let global be settingsObject's global object.
2. ~IF［ %大域~obj は `Window$I を実装しない ］ ⇒ ~RET ◎ If global does not implement Window, then return.
3. %~record ~LET 新たな`指定子~解決~record$ — その ⇒＃ `直列化された基底~URL$ssR ~SET %直列化-済み基底~URL, `指定子$ssR ~SET %正規化-済み指定子, `~URLとしての指定子$ssR ~SET %~as~URL ◎ Let record be a new specifier resolution record, with serialized base URL set to serializedBaseURL, specifier set to normalizedSpecifier, and specifier as a URL set to asURL.
4. %大域~obj の`解決-済み~module集合$gLに %~record を`付加する$set ◎ Append record to global's resolved module set.

`~import~map文字列を構文解析する@ ときは、 所与の ( `文字列$ %入力, `~URL$ %基底~URL ) に対し： ◎ To parse an import map string, given a string input and a URL baseURL:

1. %構文解析した結果 ~LET `~JSON文字列を~Infra値に構文解析する$( %入力 ) ◎ Let parsed be the result of parsing a JSON string to an Infra value given input.
2. ~IF［ %構文解析した結果 は`有順序~map$でない ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ ~top-levelの値は、 ~JSON `object^jc にする必要がある ◎ If parsed is not an ordered map, then throw a TypeError indicating that the top-level value needs to be a JSON object.
3. %~sortして正規化した~import群 ~LET 新たな`有順序~map$ ◎ Let sortedAndNormalizedImports be an empty ordered map.
4. %~import群 ~LET %構文解析した結果[ `imports^l ] ◎ ↓

5. ~IF［ %~import群 ~NEQ ε ］： ◎ If parsed["imports"] exists, then:

   1. ~IF［ %~import群 は`有順序~map$でない ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ ~top-levelの~key `imports^l 用の値は、 ~JSON `object^jc にする必要がある ◎ If parsed["imports"] is not an ordered map, then throw a TypeError indicating that the value for the "imports" top-level key needs to be a JSON object.
   2. %~sortして正規化した~import群 ~SET `~module指定子~mapを~sortして正規化する$( %~import群, %基底~URL ) ◎ Set sortedAndNormalizedImports to the result of sorting and normalizing a module specifier map given parsed["imports"] and baseURL.
6. %~sortして正規化した~scope群 ~LET 新たな`有順序~map$ ◎ Let sortedAndNormalizedScopes be an empty ordered map.
7. %~scope群 ~LET %構文解析した結果[ `scopes^l ] ◎ ↓

8. ~IF［ %~scope群 ~NEQ ε ］： ◎ If parsed["scopes"] exists, then:

   1. ~IF［ %~scope群 は`有順序~map$でない ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ ~top-levelの~key `scopes^l 用の値は、 ~JSON `object^jc にする必要がある ◎ If parsed["scopes"] is not an ordered map, then throw a TypeError indicating that the value for the "scopes" top-level key needs to be a JSON object.
   2. %~sortして正規化した~scope群 ~SET `~scope群を~sortして正規化する$( %~scope群, %基底~URL ) ◎ Set sortedAndNormalizedScopes to the result of sorting and normalizing scopes given parsed["scopes"] and baseURL.
9. %正規化-済み完全性 ~LET 新たな`有順序~map$ ◎ Let normalizedIntegrity be an empty ordered map.

10. ~IF［ %構文解析した結果[ `integrity^l ] ~NEQ ε ］： ◎ If parsed["integrity"] exists, then:

    1. ~IF［ %構文解析した結果[ `integrity^l ] は`有順序~map$でない ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ ~top-levelの~key `integrity^l 用の値は、 ~JSON `object^jc にする必要がある ◎ If parsed["integrity"] is not an ordered map, then throw a TypeError indicating that the value for the "integrity" top-level key needs to be a JSON object.
    2. %正規化-済み完全性 ~SET `~module完全性~mapを正規化する$( %構文解析した結果[ `integrity^l ], %基底~URL ) ◎ Set normalizedIntegrity to the result of normalizing a module integrity map given parsed["integrity"] and baseURL.

11. %構文解析した結果 の`~key群$mapを成す ~EACH( %~key ) に対し：

    1. ~IF［ %~key ~IN { `imports^l, `scopes^l, `integrity^l } ］ ⇒ ~CONTINUE
    2. ~UAは、 次を指示するよう，`~consoleに警告を報告-$するベキである ⇒ 当の~import~map内に妥当でない~top-levelの~keyが在った
    3. ~BREAK

    ◎ If parsed's keys contains any items besides "imports", "scopes", or "integrity", then the user agent should report a warning to the console indicating that an invalid top-level key was present in the import map.

    注記： これは、 誤記を検出し易くするものであり，~errorではない — さもなければ、 将来に拡張を後方-互換に追加できなくなるので。 ◎ This can help detect typos. It is not an error, because that would prevent any future extensions from being added backward-compatibly.

12. ~RET 新たな`~import~map$ — その ⇒＃ `~import群$iM ~SET %~sortして正規化した~import群, `~scope群$iM ~SET %~sortして正規化した~scope群, `完全性$iM ~SET %正規化-済み完全性 ◎ Return an import map whose imports are sortedAndNormalizedImports, whose scopes are sortedAndNormalizedScopes, and whose integrity are normalizedIntegrity.

`新旧~module指定子~mapを併合する@ ときは、 所与の ( `~module指定子~map$ %新-~map, `~module指定子~map$ %旧-~map ) に対し： ◎ To merge module specifier maps, given a module specifier map newMap and a module specifier map oldMap:

1. %併合-済み~map ~LET %旧-~map の深い複製 ◎ Let mergedMap be a deep copy of oldMap.

2. %新-~map を成す ~EACH( %指定子 → %~URL ) に対し： ◎ For each specifier → url of newMap:

   1. ~IF［ %旧-~map[ %指定子 ] ~NEQ ε ］： ◎ If specifier exists in oldMap, then:

      1. ~UAは、 無視された規則を指示するよう，`~consoleに警告を報告-$してもヨイ — 当の規則が既存のいずれかの規則と一致する場合、 そうしないことを選んでもヨイ。 ◎ The user agent may report a warning to the console indicating the ignored rule. They may choose to avoid reporting if the rule is identical to an existing one.
      2. ~CONTINUE ◎ Continue.
   2. %併合-済み~map[ %指定子 ] ~SET %~URL ◎ Set mergedMap[specifier] to url.
3. ~RET %併合-済み~map ◎ Return mergedMap.

`既存の~import~mapと新たな~import~mapを併合する@ ときは、 所与の ( `大域~obj$enV %大域~obj, `~import~map$ %新-~import~map ) に対し： ◎ To merge existing and new import maps, given a global object global and an import map newImportMap:

1. %新-~import~map~scope群 ~LET %新-~import~map の`~scope群$iMの深い複製 ◎ Let newImportMapScopes be a deep copy of newImportMap's scopes.

   注記： この複製は、 以下において変異する — それが~scopeに特有な規則を無視するために利用されたとき， そこから~entry【！~item】を除去することにより。 次の段の複製も同様【！This is true for…】。 ◎ We're mutating these copies and removing items from them when they are used to ignore scope-specific rules. This is true for newImportMapScopes, as well as to newImportMapImports below.

2. %新-~import~map~import群 ~LET %新-~import~map の`~import群$iMの深い複製 ◎ Let newImportMapImports be a deep copy of newImportMap's imports.

3. %新-~import~map~scope群 を成す ~EACH( %~scope接頭辞 → %~scope~import群 ) に対し： ◎ For each scopePrefix → scopeImports of newImportMapScopes:

   1. %大域~obj の`解決-済み~module集合$gLを成す ~EACH( %~record ) に対し： ◎ For each record of global's resolved module set:

      1. ~IF［ ~OR↓ ］…

         • %~scope接頭辞 ~EQ %~record の`直列化された基底~URL$ssR

         • ~AND↓：

           • %~scope接頭辞 は `/^l `で終端して$いる
           • %~scope接頭辞 は %~record の`直列化された基底~URL$ssRの`符号単位~接頭辞$である

         …ならば：

         ◎ If scopePrefix is record's serialized base URL,＼ or if scopePrefix ends with U+002F (/) and scopePrefix is a code unit prefix of record's serialized base URL, then:

         1. %~scope~import群 を成す ~EACH( %指定子~key → %解決~結果 ) に対し： ◎ For each specifierKey → resolutionResult of scopeImports:

            1. ~IF［ %指定子~key ~EQ %~record の`指定子$ssR ］~OR［ ~AND↓ ］… ◎ If specifierKey is record's specifier, or if all of the following conditions are true:

               • %指定子~key は `/^l `で終端して$いる ◎ specifierKey ends with U+002F (/);
               • %指定子~key は %~record の`指定子$ssRを成す`符号単位~接頭辞$である ◎ specifierKey is a code unit prefix of record's specifier;

               • ~OR↓：

                 • %~record の`~URLとしての指定子$ssR ~EQ ~NULL
                 • %~record の`~URLとしての指定子$ssRは`特別$urlである
                 ◎ either record's specifier as a URL is null or is special,

               …ならば： ◎ then:

               1. ~UAは、 無視された規則を指示するよう，`~consoleに警告を報告-$してもヨイ — 当の規則が既存のいずれかの規則と一致する場合、 そうしないことを選んでもヨイ。 ◎ The user agent may report a warning to the console indicating the ignored rule. They may choose to avoid reporting if the rule is identical to an existing one.
               2. %~scope~import群[ %指定子~key【！%指定子】 ] ~SET ε ◎ Remove scopeImports[specifier].

      注記： 実装者には、 `解決-済み~module集合$gLで作業するときには， もっと効率的な照合~algoを実装することが奨励される。 指導として、 巨大な~app内で［ 解決される／対応付けられる ］~moduleの個数は，数千にもなり得る。 ◎ Implementers are encouraged to implement a more efficient matching algorithm when working with the resolved module set. As guidance, the number of resolved/mapped modules in a large application can be on the order of thousands.

   2. %旧-~scope群 ~LET %旧-~import~map の`~scope群$iM ◎ ↓
   3. ~IF［ %旧-~scope群[ %~scope接頭辞 ] ~NEQ ε ］ ⇒ %旧-~scope群[ %~scope接頭辞 ] ~SET `新旧~module指定子~mapを併合する$( %~scope~import群, %旧-~scope群[ %~scope接頭辞 ] ) ◎ If scopePrefix exists in oldImportMap's scopes, then set oldImportMap's scopes[scopePrefix] to the result of merging module specifier maps, given scopeImports and oldImportMap's scopes[scopePrefix].
   4. ~ELSE ⇒ %旧-~scope群[ %~scope接頭辞 ] ~SET %~scope~import群 ◎ Otherwise, set oldImportMap's scopes[scopePrefix] to scopeImports.

4. %新-~import~map の`完全性$iMを成す ~EACH( %~URL → %完全性 ) に対し： ◎ For each url → integrity of newImportMap's integrity:

   1. ~IF［ %旧-~import~map の`完全性$iM[ %~URL ] ~NEQ ε ］： ◎ If url exists in oldImportMap's integrity, then:

      1. ~UAは、 無視された規則を指示するよう，`~consoleに警告を報告-$してもヨイ — 当の規則が既存のいずれかの規則と一致する場合、 そうしないことを選んでもヨイ。 ◎ The user agent may report a warning to the console indicating the ignored rule. They may choose to avoid reporting if the rule is identical to an existing one.
      2. ~CONTINUE ◎ Continue.
   2. %旧-~import~map の`完全性$iM[ %~URL ] ~SET %完全性 ◎ Set oldImportMap's integrity[url] to integrity.

5. %大域~obj の`解決-済み~module集合$gLを成す ~EACH( %~record ) に対し： ◎ For each record of global's resolved module set:

   1. %新-~import~map~import群 を成す ~EACH( %指定子 → %~URL ) に対し： ◎ For each specifier → url of newImportMapImports:

      1. ~IF［ %指定子 は %~record の`指定子$ssR`から開始して$いる ］： ◎ If specifier starts with record's specifier, then:

         1. ~UAは、 無視された規則を指示するよう，`~consoleに警告を報告-$してもヨイ — 当の規則が既存のいずれかの規則と一致する場合、 そうしないことを選んでもヨイ。 ◎ The user agent may report a warning to the console indicating the ignored rule. They may choose to avoid reporting if the rule is identical to an existing one.
         2. %新-~import~map~import群[ %指定子 ] ~SET ε ◎ Remove newImportMapImports[specifier].
6. %旧-~import~map の`~import群$iM ~SET `新旧~module指定子~mapを併合する$( %新-~import~map~import群, %旧-~import~map の`~import群$iM ) ◎ Set oldImportMap's imports to the result of merge module specifier maps, given newImportMapImports and oldImportMap's imports.

`~module指定子~mapを~sortして正規化する@ ときは、 所与の ( `有順序~map$ %元の~map, `~URL$ %基底~URL ) に対し： ◎ To sort and normalize a module specifier map, given an ordered map originalMap and a URL baseURL:

1. %正規化した結果 ~LET 新たな`有順序~map$ ◎ Let normalized be an empty ordered map.

2. %元の~map を成す ~EACH( %指定子~key → %値 ) に対し： ◎ For each specifierKey → value of originalMap:

   1. %正規化-済み指定子~key ~LET `指定子~keyを正規化する$( %指定子~key, %基底~URL ) ◎ Let normalizedSpecifierKey be the result of normalizing a specifier key given specifierKey and baseURL.
   2. ~IF［ %正規化-済み指定子~key ~EQ ~NULL ］ ⇒ ~CONTINUE ◎ If normalizedSpecifierKey is null, then continue.

   3. ~IF［ %値 は`文字列$でない ］： ◎ If value is not a string, then:

      1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ ~addressは文字列にする必要がある ◎ The user agent may report a warning to the console indicating that addresses need to be strings.
      2. %正規化した結果[ %正規化-済み指定子~key ] ~SET ~NULL ◎ Set normalized[normalizedSpecifierKey] to null.
      3. ~CONTINUE ◎ Continue.
   4. %~address~URL ~LET `~URLの様な~module指定子を解決する$( %値, %基底~URL ) ◎ Let addressURL be the result of resolving a URL-like module specifier given value and baseURL.

   5. ~IF［ %~address~URL ~EQ ~NULL ］： ◎ If addressURL is null, then:

      1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ 当の~addressは妥当でなかった。 ◎ The user agent may report a warning to the console indicating that the address was invalid.
      2. %正規化した結果[ %正規化-済み指定子~key ] ~SET ~NULL ◎ Set normalized[normalizedSpecifierKey] to null.
      3. ~CONTINUE ◎ Continue.

   6. ~IF［ %指定子~key は `/^l `で終端して$いる ］~AND［ `~URLを直列化する$( %~address~URL ) の結果は `/^l `で終端して$いない ］： ◎ If specifierKey ends with U+002F (/), and the serialization of addressURL does not end with U+002F (/), then:

      1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ %指定子~key に妥当でない~addressが与えられた — %指定子~key は~slashで終端しているので、 ~addressもそうなる必要がある。 ◎ The user agent may report a warning to the console indicating that an invalid address was given for the specifier key specifierKey; since specifierKey ends with a slash, the address needs to as well.
      2. %正規化した結果[ %正規化-済み指定子~key ] ~SET ~NULL ◎ Set normalized[normalizedSpecifierKey] to null.
      3. ~CONTINUE ◎ Continue.
   7. %正規化した結果[ %正規化-済み指定子~key ] ~SET %~address~URL ◎ Set normalized[normalizedSpecifierKey] to addressURL.
3. ~RET `降順に~sortする$map( %正規化した結果, ~LT`符号単位$sub ) ◎ Return the result of sorting in descending order normalized, with an entry a being less than an entry b if a's key is code unit less than b's key.

`~scope群を~sortして正規化する@ ときは、 所与の ( `有順序~map$ %元の~map, `~URL$ %基底~URL ) に対し： ◎ To sort and normalize scopes, given an ordered map originalMap and a URL baseURL:

1. %正規化した結果 ~LET 新たな`有順序~map$ ◎ Let normalized be an empty ordered map.

2. %元の~map を成す ~EACH( %~scope接頭辞 → %指定子~mapになり得るもの ) に対し： ◎ For each scopePrefix → potentialSpecifierMap of originalMap:

   1. ~IF［ %指定子~mapになり得るもの は`有順序~map$でない ］ ⇒ ~THROW `TypeError$jc — これは、 次を指示する ⇒ 接頭辞に %~scope接頭辞 を伴う~scopeの値は、 ~JSON `object^jc にする必要がある ◎ If potentialSpecifierMap is not an ordered map, then throw a TypeError indicating that the value of the scope with prefix scopePrefix needs to be a JSON object.
   2. %~scope接頭辞~URL ~LET `~URL構文解析する$( %~scope接頭辞, %基底~URL ) ◎ Let scopePrefixURL be the result of URL parsing scopePrefix with baseURL.

   3. ~IF［ %~scope接頭辞~URL ~EQ `失敗^i ］： ◎ If scopePrefixURL is failure, then:

      1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ 当の~scope接頭辞~URLは構文解析-可能でなかった ◎ The user agent may report a warning to the console that the scope prefix URL was not parseable.
      2. ~CONTINUE ◎ Continue.
   4. %正規化-済み~scope接頭辞 ~LET `~URLを直列化する$( %~scope接頭辞~URL ) ◎ Let normalizedScopePrefix be the serialization of scopePrefixURL.
   5. %正規化した結果[ %正規化-済み~scope接頭辞 ] ~SET `~module指定子~mapを~sortして正規化する$( %指定子~mapになり得るもの, %基底~URL ) ◎ Set normalized[normalizedScopePrefix] to the result of sorting and normalizing a module specifier map given potentialSpecifierMap and baseURL.
3. ~RET `降順に~sortする$map( %正規化した結果, ~LT`符号単位$sub ) ◎ Return the result of sorting in descending order normalized, with an entry a being less than an entry b if a's key is code unit less than b's key.

`~module完全性~mapを正規化する@ ときは、 所与の ( `有順序~map$ %元の~map ) に対し： ◎ To normalize a module integrity map, given an ordered map originalMap:

1. %正規化した結果 ~LET 新たな`有順序~map$ ◎ Let normalized be an empty ordered map.

2. %元の~map を成す ~EACH( %~key → %値 ) に対し： ◎ For each key → value of originalMap:

   1. %解決-済み~URL ~LET `~URLの様な~module指定子を解決する$( %~key, %基底~URL ) ◎ Let resolvedURL be the result of resolving a URL-like module specifier given key and baseURL.

      `imports^l と違って、 完全性~mapを成す~keyは，~module指定子ではなく~URLとして扱われる。 しかしながら、 `foo^c の様な［ ~module指定子~用であると~~誤認され易い “裸な” 相対~URL ］を禁制するため， `~URLの様な~module指定子を解決する$~algoを利用する。 ◎ Unlike "imports", keys of the integrity map are treated as URLs, not module specifiers. However, we use the resolve a URL-like module specifier algorithm to prohibit "bare" relative URLs like foo, which could be mistaken for module specifiers.

   2. ~IF［ %解決-済み~URL ~EQ ~NULL ］： ◎ If resolvedURL is null, then:

      1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ ~keyを解決するのに失敗した ◎ The user agent may report a warning to the console indicating that the key failed to resolve.
      2. ~CONTINUE ◎ Continue.

   3. ~IF［ %値 は`文字列$でない ］： ◎ If value is not a string, then:

      1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ `完全性~metadata$rq用の値は`文字列$にする必要がある ◎ The user agent may report a warning to the console indicating that integrity metadata values need to be strings.
      2. ~CONTINUE ◎ Continue.
   4. %正規化した結果[ %解決-済み~URL ] ~SET %値 ◎ Set normalized[resolvedURL] to value.
3. ~RET %正規化した結果 ◎ Return normalized.

`指定子~keyを正規化する@ ときは、 所与の ( `文字列$ %指定子~key, `~URL$ %基底~URL ) に対し： ◎ To normalize a specifier key, given a string specifierKey and a URL baseURL:

1. ~IF［ %指定子~key ~EQ 空~文字列 ］： ◎ If specifierKey is the empty string, then:

   1. ~UAは、 次を指示するよう，`~consoleに警告を報告-$してもヨイ ⇒ 指定子~keyは、 空~文字列~以外にする必要がある。 ◎ The user agent may report a warning to the console indicating that specifier keys may not be the empty string.
   2. ~RET ~NULL ◎ Return null.
2. %~URL ~LET `~URLの様な~module指定子を解決する$( %指定子~key, %基底~URL ) ◎ Let url be the result of resolving a URL-like module specifier, given specifierKey and baseURL.
3. ~IF［ %~URL ~NEQ ~NULL ］ ⇒ ~RET `~URLを直列化する$( %~URL ) ◎ If url is not null, then return the serialization of url.
4. ~RET %指定子~key ◎ Return specifierKey.

~UAは、 次の実装を利用するモノトスル： ◎ User agents must use the following implementation: [JAVASCRIPT]

1. ~IF［ %O は `WindowProxy$I ~objである ］~OR［ %O は `Location$I を`実装-$する ］ ⇒ ~RET 新たな`完了~Record$ — その ⇒＃ `Type^sl ~SET `throw^i, `Value^sl ~SET 新たな `TypeError$jc ◎ If O is a WindowProxy object, or implements Location, then return Completion { [[Type]]: throw, [[Value]]: a new TypeError }.
2. ~RET `NormalCompletion$jA( `unused^i ) ◎ Return NormalCompletion(unused).

~UAは、 次の実装を利用するモノトスル： ◎ User agents must use the following implementation: [JAVASCRIPT] [JSDYNAMICCODEBRANDCHECKS]

1. ~ABRUPT `EnsureCSPDoesNotBlockStringCompilation$jA( %~realm, %~parameter文字列~群, %本体~文字列, %~code文字列, %~compilation種別, %~parameter引数~群, %本体~引数 ) `CSP$r ◎ Perform ? EnsureCSPDoesNotBlockStringCompilation(realm, parameterStrings, bodyString, codeString, compilationType, parameterArgs, bodyArg). [CSP]

~UAは、 次の実装を利用するモノトスル： ◎ User agents must use the following implementation: [JSDYNAMICCODEBRANDCHECKS]

1. ~IF［ %引数 は `TrustedScript$I ~objである ］ ⇒ ~RET %引数 の`~data＠~TRUSTED-TYPES#trustedscript-data$ ◎ If argument is a TrustedScript object, then return argument's data.
2. ~RET `no-code^i ◎ Otherwise, return no-code.

~UAは、 次の実装を利用するモノトスル： ◎ User agents must use the following implementation: [JAVASCRIPT]

1. %~script ~LET `走っている~script$ ◎ Let script be the running script.
2. ~IF［ %~script は`古典~script$である ］~AND［ %~script の`~errorを黙秘するか$sC ~EQ ~T ］ ⇒ ~RET ◎ If script is a classic script and script's muted errors is true, then return.
3. %設定群~obj ~LET `現在の設定群~obj$ ◎ Let settingsObject be the current settings object.
4. ~IF［ %~script ~NEQ ~NULL ］ ⇒ %設定群~obj ~SET %~script の`設定群~obj$sC ◎ If script is not null, then set settingsObject to script's settings object.
5. %大域~obj ~LET %設定群~obj の`大域~obj$enV ◎ Let global be settingsObject's global object.
6. %却下-済み~list ~LET %大域~obj の`通知待ちな却下-済み~promise~list$gL ◎ ↓
7. ~IF［ %演算 ~EQ `reject^l ］ ⇒ %却下-済み~list に %promise を`付加する$ ◎ If operation is "reject", then: • Append promise to global's about-to-be-notified rejected promises list.

8. ~ELIF［ %演算 ~EQ `handle^l ］： ◎ If operation is "handle", then:

   1. ~IF［ %promise ~IN %却下-済み~list ］ ⇒＃ %却下-済み~list から %promise を`除去する$； ~RET ◎ If global's about-to-be-notified rejected promises list contains promise, then remove promise from that list and return.
   2. %弱い参照たちが成す集合 ~LET %大域~obj の`未決な却下-済み~promiseへの弱い参照たちが成す集合$gL ◎ ↓
   3. ~IF［ %promise ~NIN %弱い参照たちが成す集合 ］ ⇒ ~RET ◎ If global's outstanding rejected promises weak set does not contain promise, then return.
   4. %弱い参照たちが成す集合 から %promise を`除去する$ ◎ Remove promise from global's outstanding rejected promises weak set.

   5. `大域~taskを~queueする$( `~DOM操作~task~source$, %大域~obj, 次の手続き ) ◎ Queue a global task on the DOM manipulation task source given global to＼

      手続きは ⇒ `~eventを発火する$( %大域~obj, `rejectionhandled$et, `PromiseRejectionEvent$I ) — 次のように初期化して ⇒＃ `promise$m ~SET %promise, `reason$m ~SET %promise .`PromiseResult^sl ◎ fire an event named rejectionhandled at global, using PromiseRejectionEvent, with the promise attribute initialized to promise, and the reason attribute initialized to promise.[[PromiseResult]].

~UAは、 次の実装を利用するモノトスル： ◎ User agents must use the following implementation: [JSTEMPORAL]

1. %設定群~obj ~LET %大域~obj に`関連な設定群~obj$ ◎ Let settingsObject be global's relevant settings object.
2. %時刻 ~LET `現在の壁~時計~時刻$enV( %設定群~obj ) ◎ Let time be settingsObject's current wall time.
3. %ns ~LET ［ `~Unix~epoch$から %時刻 まで ］を成す~nano秒数を最も近い整数に丸めた結果 ◎ Let ns be the number of nanoseconds from the Unix epoch to time, rounded to the nearest integer.
4. ~RET %ns を `nsMinInstant＠https://tc39.es/proposal-temporal/#eqn-nsMinInstant$jv 以上, `nsMaxInstant＠https://tc39.es/proposal-temporal/#eqn-nsMaxInstant$jv 以下 に`切詰める＠https://tc39.es/ecma262/#clamping$ ◎ Return the result of clamping ns between nsMinInstant and nsMaxInstant.

`~window~event~loop$ %~loop 用の `同じ~loop内の~window群@ を取得するときは ⇒ ~RET 次を満たす すべての`~window$ ⇒ `関連な~agent$の`~event~loop$aG ~EQ %~loop ◎ To get the same-loop windows for a window event loop loop, return all Window objects whose relevant agent's event loop is loop.

1. %~queue ~LET %~event~loop に属する`~task~queue$のうち， %~task~source に結付けられたもの ◎ ↓
2. %~task ~LET 新たな`~task$ — その ⇒＃ `手続き$tK ~SET %手続き, `~source$tK ~SET %~task~source, `文書$tK ~SET %文書, `~script評価 環境~設定群~obj集合$tK ~SET 新たな`有順序~集合$, ◎ Let task be a new task. • Set task's steps to steps. • Set task's source to source. • Set task's document to the document. • Set task's script evaluation environment settings object set to an empty set. ◎ Let queue be the task queue to which source is associated on event loop.
3. %~queue に %~task を`付加する$ ◎ Append task to queue.

4. ~RET %~task

   【 原文は何も返していないが、 ときには，この~algoを利用している文脈から~queueした~taskを~~参照する必要もあり、 （その表記上の都合により）この訳では %~task を返すことにしている。 以下の［ “`大域~taskを~queueする$” ／ “`要素~taskを~queueする$” ］も同様。 】

`~taskを~queueする$ときに［ ~event~loop, 文書 ］を渡し損なうことは、 多義的で拙く指定された［ `暗黙な~event~loop$, `暗黙な文書$ ］の概念に依拠することを意味する。 仕様~策定者は、 これらの値を常に渡すか，この~algoを包装する［ `大域~taskを~queueする$／`要素~taskを~queueする$ ］~algo（こちらの方が推奨される）を利用すること。 ◎ Failing to pass an event loop and document to queue a task means relying on the ambiguous and poorly-specified implied event loop and implied document concepts. Specification authors should either always pass these values, or use the wrapper algorithms queue a global task or queue an element task instead. Using the wrapper algorithms is recommended.

`大域~taskを~queueする@ ときは、 所与の ( `~task~source$ %~task~source, `大域~obj$ %大域~obj, 何かを遂行する一連の段 %手続き ) に対し： ◎ To queue a global task on a task source source, with a global object global and a series of steps steps:

1. %~event~loop ~LET %大域~obj に`関連な~agent$ の`~event~loop$aG ◎ Let event loop be global's relevant agent's event loop.
2. %文書 ~LET ［ %大域~obj は`~window$であるならば それに`結付けられた文書$ ／ ~ELSE_ ~NULL ］ ◎ Let document be global's associated Document, if global is a Window object; otherwise null.
3. ~RET `~taskを~queueする$( %~task~source, %~event~loop, %文書, %手続き ) ◎ Queue a task given source, event loop, document, and steps.

`要素~taskを~queueする@ ときは、 所与の ( `~task~source$ %~task~source, 要素 %要素, 何かを遂行する一連の段 %手続き ) に対し： ◎ To queue an element task on a task source source, with an element element and a series of steps steps:

1. %大域~obj ~LET %要素 に`関連な大域~obj$ ◎ Let global be element's relevant global object.
2. ~RET `大域~taskを~queueする$( %~task~source, %大域~obj, %手続き ) ◎ Queue a global task given source, global, and steps.

`小taskを~queueする@ ときは、 所与の ( 何かを遂行する一連の段からなる %手続き, `文書$ %文書 （省略時は ε ） ) に対し…： ◎ To queue a microtask which performs a series of steps steps, optionally given a document document:

1. ~Assert： `~surrounding~agent$は在る — すなわち、 この~algoは，`並列的$な手続きから~callされてはいない。 ◎ Assert: there is a surrounding agent. I.e., this algorithm is not called while in parallel.
2. %~event~loop ~LET `~surrounding~agent$の`~event~loop$aG ◎ Let eventLoop be the surrounding agent's event loop.
3. ~IF［ %文書 ~EQ ε ］ ⇒ %文書 ~SET `暗黙な文書$ ◎ If document was not given, set document to the implied document.
4. %小task ~LET 新たな`~task$ — その ⇒＃ `手続き$tK ~SET %手続き, `~source$tK ~SET `小task~task~source@, `文書$tK ~SET %文書, `~script評価 環境~設定群~obj集合$tK ~SET 新たな`有順序~集合$ ◎ Let microtask be a new task. • Set microtask's steps to steps. • Set microtask's source to the microtask task source. • Set microtask's document to document. • Set microtask's script evaluation environment settings object set to an empty set.
5. %~event~loop の`小task~queue$に %小task を`~enqueueする$ ◎ Enqueue microtask on eventLoop's microtask queue.

`~event~loop$ %~event~loop に~task %~task を~queueするときの `暗黙な文書@ は、 次に従って決定される： ◎ The implied document when queuing a task on an event loop event loop is determined as follows:

1. ~IF［ %~event~loop は`~window~event~loop$でない ］ ⇒ ~RET ~NULL ◎ If event loop is not a window event loop, then return null.
2. ~IF［ %~task はある要素の文脈にて~queueされている ］ ⇒ ~RET 要素の`~node文書$ ◎ If the task is being queued in the context of an element, then return the element's node document.
3. ~IF［ %~task はある`閲覧~文脈$の文脈にて~queueされている ］ ⇒ ~RET その`閲覧~文脈$にて`作動中な文書$ ◎ If the task is being queued in the context of a browsing context, then return the browsing context's active document.
4. ~IF［ %~task は`~script$［ により／用に ］~queueされている ］ ⇒ ~RET その~scriptの`設定群~obj$sCの`大域~obj$enVに`結付けられた文書$ ◎ If the task is being queued by or for a script, then return the script's settings object's global object's associated Document.
5. ~Assert： この段に達することは決してない — ここまでの条件いずれかが満たされるので。 本当か？ ◎ Assert: this step is never reached, because one of the previous conditions is true. Really?

`~event~loop$ %~event~loop は、 存在する限り，次の手続きを断続的に（反復的に）走らせ続けるモノトスル： ◎ An event loop must continually run through the following steps for as long as it exists:

1. %~task ~LET ~NULL ◎ Let oldestTask and＼
2. %~task開始~時刻 ~LET ~NULL ◎ taskStartTime be null.
3. %~task~queue群 ~LET ［ %~event~loop に属する`~task~queue$のうち，`可走な~task$を包含するもの ］たちが成す集合 ◎ ↓

4. ~IF［ %~task~queue群 は空でない ］： ◎ If the event loop has a task queue with at least one runnable task, then:

   1. %~task~queue ~LET %~task~queue群 を成す`~task~queue$のうち，`実装定義$な方式で選ばれるいずれか ◎ Let taskQueue be one such task queue, chosen in an implementation-defined manner.

      注記： `小task~queue$は`~task~queue$ではないので、 この段で選ばれることはない。 しかしながら、 `小task~task~source$が結付けられた`~task~queue$が，この段で選ばれることはある。 その事例では，下の段で選ばれる`~task$（ %~task ）は、 元々は`小task$であったが，`~event~loopを回す$一部として移動されたものになる。 ◎ Remember that the microtask queue is not a task queue, so it will not be chosen in this step. However, a task queue to which the microtask task source is associated might be chosen in this step. In that case, the task chosen in the next step was originally a microtask, but it got moved as part of spinning the event loop.

   2. %~task開始~時刻 ~SET `安全でない共有される現在の時刻$ ◎ Set taskStartTime to the unsafe shared current time.
   3. %~task ~SET %~task~queue を成す`可走な~task$のうち最初のもの ◎ Set oldestTask to the first runnable task in taskQueue,＼
   4. %~task~queue から %~task を`除去する$ ◎ and remove it from taskQueue.
   5. ~IF［ %~task の`文書$tK ~NEQ ~NULL ］ ⇒ `~task開始~時刻を記録する$( %~task開始~時刻, %~task の`文書$tK ) ◎ If oldestTask's document is not null, then record task start time given taskStartTime and oldestTask's document.
   6. %~event~loop の`現在~走っている~task$ ~SET %~task ◎ Set the event loop's currently running task to oldestTask.
   7. %~task の`手続き$tKを走らす ◎ Perform oldestTask's steps.
   8. %~event~loop の`現在~走っている~task$ ~SET ~NULL ◎ Set the event loop's currently running task back to null.
   9. `小task~checkpointを遂行する$ ◎ Perform a microtask checkpoint.
5. %~task終了~時刻 ~LET `安全でない共有される現在の時刻$ `HRT$r ◎ Let taskEndTime be the unsafe shared current time. [HRT]

6. ~IF［ %~task ~NEQ ~NULL ］： ◎ If oldestTask is not null, then:

   1. %~top-level閲覧~文脈~群 ~LET 新たな`有順序~集合$ ◎ Let top-level browsing contexts be an empty set.

   2. %~task の`~script評価 環境~設定群~obj集合$tKを成す ~EACH( `環境~設定群~obj$ %設定群 ) に対し： ◎ For each environment settings object settings of oldestTask's script evaluation environment settings object set:

      1. %大域~obj ~LET %設定群 の`大域~obj$enV ◎ Let global be settings's global object.
      2. ~IF［ %大域~obj は `Window$I ~objでない ］ ⇒ ~CONTINUE ◎ If global is not a Window object, then continue.
      3. %閲覧~文脈 ~LET %大域~obj に`対応する閲覧~文脈$ ◎ ↓
      4. ~IF［ %閲覧~文脈 ~EQ ~NULL ］ ⇒ ~CONTINUE ◎ If global's browsing context is null, then continue.
      5. %~top-level閲覧~文脈 ~LET %閲覧~文脈 の`~top-level閲覧~文脈$bc ◎ Let tlbc be global's browsing context's top-level browsing context.
      6. ~IF［ %~top-level閲覧~文脈 ~NEQ ~NULL ］ ⇒ %~top-level閲覧~文脈~群 に %~top-level閲覧~文脈 を`付加する$set ◎ If tlbc is not null, then append it to top-level browsing contexts.
   3. `長い~taskを報告する$( ↓ ) ⇒＃ %~task開始~時刻, %~task終了~時刻, %~top-level閲覧~文脈~群, %~task ◎ Report long tasks, passing in taskStartTime, taskEndTime, top-level browsing contexts, and oldestTask.
   4. ~IF［ %~task の`文書$tK ~NEQ ~NULL ］ ⇒ `~task終了~時刻を記録する$( %~task終了~時刻, %~task の`文書$tK ) ◎ If oldestTask's document is not null, then record task end time given taskEndTime and oldestTask's document.

7. ~IF［ %~event~loop は`~window~event~loop$である ］~AND［ %~event~loop の`~task~queue$内に`可走な~task$は無い ］： ◎ If this is a window event loop that has no runnable task in this event loop's task queues, then:

   1. %~event~loop の`最後の遊休期間~開始-時刻$ ~SET `安全でない共有される現在の時刻$ ◎ Set this event loop's last idle period start time to the unsafe shared current time.

   2. %刻限を算出する手続き ~LET 次を走らす手続き： ◎ Let computeDeadline be the following steps:

      1. %刻限 ~LET %~event~loop の`最後の遊休期間~開始-時刻$ ~PLUS 50 ◎ Let deadline be this event loop's last idle period start time plus 50.

         注記： 50ms 後の未来までにしているのは、 新たな利用者~入力に対し，ヒトから知覚される閾値~内に~~収まる応答性を確保するためである。 ◎ The cap of 50ms in the future is to ensure responsiveness to new user input within the threshold of human perception.

      2. %処理待ち描画-はあるか ~LET ~F ◎ Let hasPendingRenders be false.
      3. %~window群 ~LET %~event~loop 用の`同じ~loop内の~window群$() ◎ ↓

      4. %~window群 を成す ~EACH( %~window ) に対し： ◎ For each windowInSameLoop of the same-loop windows for this event loop:

         1. ~IF［ %~window の`~animation~frame~callback~map$は`空$mapでない ］~OR［ ~UAは［ %~window には、 処理待ち描画~更新があり得る ］と予見する ］ ⇒ %処理待ち描画-はあるか ~SET ~T ◎ If windowInSameLoop's map of animation frame callbacks is not empty, or if the user agent believes that the windowInSameLoop might have pending rendering updates, set hasPendingRenders to true.
         2. %~timer~callback見積もり群 ~LET %~window の`作動中な~timer群が成す~map$の`値~群$map ◎ Let timerCallbackEstimates be the result of getting the values of windowInSameLoop's map of active timers.
         3. %~timer~callback見積もり群 を成す ~EACH( %~timeout刻限 ) に対し ⇒ ~IF［ %~timeout刻限 ~LT %刻限 ］ ⇒ %刻限 ~SET %~timeout刻限 ◎ For each timeoutDeadline of timerCallbackEstimates, if timeoutDeadline is less than deadline, set deadline to timeoutDeadline.

      5. ~IF［ %処理待ち描画-はあるか ~EQ ~T ］： ◎ If hasPendingRenders is true, then:

         1. %次回の描画-刻限 ~LET %~event~loop の`最後の描画-機会~時刻$ ~PLUS ( 1000 ~DIV 現在の更新率 ) ◎ Let nextRenderDeadline be this event loop's last render opportunity time plus (1000 divided by the current refresh rate).

            注記： 更新率は、 ~hardwareや実装に特有になり得る。 更新率が 60Hz なら、 %次回の描画-刻限 は `最後の描画-機会~時刻$より約 16.67ms 後になろう。 ◎ The refresh rate can be hardware- or implementation-specific. For a refresh rate of 60Hz, the nextRenderDeadline would be about 16.67ms after the last render opportunity time.

         2. ~IF［ %次回の描画-刻限 ~LT %刻限 ］ ⇒ ~RET %次回の描画-刻限 ◎ If nextRenderDeadline is less than deadline, then return nextRenderDeadline.
      6. ~RET %刻限 ◎ Return deadline.
   3. %~window群 ~LET %~event~loop 用の`同じ~loop内の~window群$() ◎ ↓

   4. %~window群 を成す ~EACH( %~window ) に対し：

      1. %手続き ~LET 次を走らす手続き：

         1. %刻限 ~LET %刻限を算出する手続き()
         2. %隔離されるか ~LET %~window に`関連な設定群~obj$の`非同一-生成元~能力は隔離されるか？$enV
         3. ~RET `時刻を粗化する$( %刻限, %隔離されるか )
      2. `遊休期間を開始する$( %~window, %手続き ) `REQUESTIDLECALLBACK$r
      ◎ For each win of the same-loop windows for this event loop, perform the start an idle period algorithm for win with the following step: return the result of calling computeDeadline, coarsened given win's relevant settings object's cross-origin isolated capability. [REQUESTIDLECALLBACK]

8. ~IF［ %~event~loop は`~worker~event~loop$である ］： ◎ If this is a worker event loop, then:

   1. %~worker ~LET ［ %~event~loop の`~agent$を成す単独の`~realm$ ］の`大域~obj$rM ◎ ↓
   2. ~Assert： %~worker は `WorkerGlobalScope$I ~objである。 【この段は、この訳による補完。】

   3. ~IF［ %~worker は `DedicatedWorkerGlobalScope$I である ］~AND［ %~worker は`~supportされている＠~HTMLGAPI#concept-animationframeprovider-supported$ ］~AND［ ~UAは、 この時点で描画を更新することに益があるものと予見している ］： ◎ If this event loop's agent's single realm's global object is a supported DedicatedWorkerGlobalScope and the user agent believes that it would benefit from having its rendering updated at this time, then:

      1. %now ~LET `現在の高分解能~時刻$( %~worker【！the DedicatedWorkerGlobalScope】 ) `HRT$r ◎ Let now be the current high resolution time given the DedicatedWorkerGlobalScope. [HRT]
      2. %~worker 用に `各~animation~frame~callbackを走らす$( %now ) ◎ Run the animation frame callbacks for that DedicatedWorkerGlobalScope, passing in now as the timestamp.
      3. %~worker の描画を［ 現在の状態を反映する ］よう更新する ◎ Update the rendering of that dedicated worker to reflect the current state.

      注記： `~window~event~loop$における`描画を更新する$ときの注記と同様に、 ~UAは，専用~workerにおける描画の更新率を決定できる。 ◎ Similar to the notes for updating the rendering in a window event loop, a user agent can determine the rate of rendering in the dedicated worker.

   4. ~IF［ %~event~loop 内のどの`~task~queue$も空である ］~AND［ %~worker【！the WorkerGlobalScope object】 の`~close中か$wG ~EQ ~T ］：

      1. この手続きは中止した上で， %~event~loop を破壊する
      2. `§ ~Web~worker＠~WORKERS#workers$ に述べられる`~workerを走らす$手続きを再開する
      ◎ If there are no tasks in the event loop's task queues and the WorkerGlobalScope object's closing flag is true, then destroy the event loop, aborting these steps, resuming the run a worker steps described in the Web workers section below.

`~window~event~loop$ %~event~loop は、 存在する限り，次も`並列的$に走らすモノトスル： ◎ A window event loop eventLoop must also run the following in parallel, as long as it exists:

1. 次を満たす`~navigable$のうち 1 つ以上が，`描画~機会$を有し得るようになるまで待機する ⇒ それにて`作動中な文書$navに`関連な~agent$の`~event~loop$aG ~EQ %~event~loop ◎ Wait until at least one navigable whose active document's relevant agent's event loop is eventLoop might have a rendering opportunity.
2. %~event~loop の`最後の描画-機会~時刻$ ~SET `安全でない共有される現在の時刻$ ◎ Set eventLoop's last render opportunity time to the unsafe shared current time.

3. ~EACH( `描画~機会$を有する`~navigable$ %~navigable ) に対し ⇒ `大域~taskを~queueする$( `描画~task~source$, %~navigable にて`作動中な~window$nav, `描画を更新する$ ) ◎ For each navigable that has a rendering opportunity, queue a global task on the rendering task source given navigable's active window to update the rendering:

   注記： これは、 `描画を更新する$手続きを冗長に~callするかもしれないが、 そのような~callによる効果は，観測-可能にならない — `不必要な描画^i 段により、 必要yな描画は無いので。 実装は、 更なる最適化を導入できる — この~taskを~task~queue内に無いときに限り~queueするなど。 しかしながら、 この~taskの`文書$tKは，~taskが処理される前に作動中でなくなることもあることに注意。 ◎ This might cause redundant calls to update the rendering. However, these calls would have no observable effect because there will be no rendering necessary, as per the Unnecessary rendering step. Implementations can introduce further optimizations such as only queuing this task when it is not already queued. However, note that the document associated with the task might become inactive before the task is processed.

   `描画を更新する@ 手続きは：

   1. %~frame時刻印 ~LET %~event~loop の`最後の描画-機会~時刻$ ◎ Let frameTimestamp be eventLoop's last render opportunity time.

   2. %文書~群 ~LET `全部的に作動中$な`文書$のうち［ それに`関連な~agent$の`~event~loop$aG ~EQ %~event~loop ］を満たすものたちが成す~list — ~list内の どの 2 つの`文書$ %A, %B に対しても， それらの順序は、 %B の`容器~文書$docを %B1 とするとき， 次に挙げる条件を満たすモノトスル（条件~以外は任意）： ◎ Let docs be all fully active Document objects whose relevant agent's event loop is eventLoop, sorted arbitrarily except that the following conditions must be met:

      • ［ %A ~EQ %B1 ］ならば、 %B は %A より後になる。 ◎ Any Document B whose container document is A must be listed after A in the list.
      • ［ %A の`容器~文書$doc ~EQ %B1 ］ならば、 %A, %B の順序は，［ %B1 の`~node~tree$における`~shadowも含めた~tree順序$ ］による［ %A の`~navigable容器$, %B の`~navigable容器$ ］の順序に合致する。 ◎ If there are two documents A and B that both have the same non-null container document C, then the order of A and B in the list must match the shadow-including tree order of their respective navigable containers in C's node tree.

      以下において %文書~群 を成す ~EACH( %文書 ) にわたって反復する各~段においては、 この順序で処理するモノトスル。 ◎ In the steps below that iterate over docs, each Document must be processed in the order it is found in the list.

   3. `描画-可能でない文書を~filterする^i ⇒ %文書~群 から ~OR↓ を満たす`文書$を除去する ◎ Filter non-renderable documents: Remove from docs any Document object doc for which any of the following are true:

      • その`具現化は阻まれて$いる ◎ doc is render-blocked;
      • その`可視性~状態$doc ~EQ `hidden^l ◎ doc's visibility state is "hidden";
      • その描画は`~view遷移~用の具現化は抑止されて＠~CSSVT#document-rendering-suppression-for-view-transitions$いる ◎ doc's rendering is suppressed for view transitions; or
      • その`~node~navigable$には，現在は`描画~機会$を有さない ◎ doc's node navigable doesn't currently have a rendering opportunity.

      注記： `並列的$な手続き内で検査した描画~機会の有無は、 ここでも検査する必要がある — %文書~群 【！that share the same event loop】を成す一部の文書は、 この時点では`描画~機会$を有さないかもしれないので。 ◎ We have to check for rendering opportunities here, in addition to checking that in the in parallel steps, as some documents that share the same event loop might not have a rendering opportunity at the same time.

   4. `不必要な描画^i ⇒ %文書~群 から ~AND↓ を満たす`文書$ %文書 をすべて除去する： ◎ Unnecessary rendering: Remove from docs any Document object doc for which all of the following are true:

      • ~UAは、 %文書 の`~node~navigable$の描画を更新しても，可視な効果はないものと予見している ◎ the user agent believes that updating the rendering of doc's node navigable would have no visible effect; and
      • %文書 の`~animation~frame~callback~map$は空である ◎ doc's map of animation frame callbacks is empty.

   5. %文書~群 から次に該当する`文書$をすべて除去する ⇒ ~UAは、 その他の理由により，文書の描画を更新するのは飛ばした方が好ましいと予見している ◎ Remove from docs all Document objects for which the user agent believes that it's preferable to skip updating the rendering for other reasons.

      `描画-可能でない文書を~filterする^i 段は、 新たな内容を利用者に呈示-不能なときに，~UAが描画を更新するのを防止する。 ◎ The step labeled Filter non-renderable documents prevents the user agent from updating the rendering when it is unable to present new content to the user.

      `不必要な描画^i 段は、 新たに描く内容が無いときに，~UAが描画を更新するのを防止する。 ◎ The step labeled Unnecessary rendering prevents the user agent from updating the rendering when there's no new content to draw.

      この段は、~UAが［ 他の理由でも，以下の手続きを走らすのを防止する ］ことを可能化する — 例えば、 ある種の`~task$たちを［ ~~間断なく順に実行して、 間に差挟まれるのは，`小task~checkpointを遂行する$ことに限る ］ことを確保するなど （例えば，`各~animation~frame~callbackを走らす$ことなく）。 具体的には、 ~UAは，例えば［ 複数の~timer~callbackを，描画~更新を挟まずに合体したい ］と望むかもしれない。 ◎ This step enables the user agent to prevent the steps below from running for other reasons, for example, to ensure certain tasks are executed immediately after each other, with only microtask checkpoints interleaved (and without, e.g., animation frame callbacks interleaved). Concretely, a user agent might wish to coalesce timer callbacks together, with no intermediate rendering updates.

   6. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `文書を露呈する$( %文書 ) ◎ For each doc of docs, reveal doc.
   7. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ ~IF［ %文書 の`~node~navigable$は`~top-level辿可能$である ］ ⇒ `自動focus候補~群を洗出す$( %文書 ) ◎ For each doc of docs, flush autofocus candidates for doc if its node navigable is a top-level traversable.
   8. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `文書の~resize手続き$( %文書 ) `CSSOMVIEW$r ◎ For each doc of docs, run the resize steps for doc. [CSSOMVIEW]
   9. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `文書の~scroll手続き$( %文書 ) `CSSOMVIEW$r ◎ For each doc of docs, run the scroll steps for doc. [CSSOMVIEW]
   10. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `文書~用の媒体~queryを評価して変化を報告する$( %文書 ) `CSSOMVIEW$r ◎ For each doc of docs, evaluate media queries and report changes for doc. [CSSOMVIEW]
   11. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `~animationを更新して~eventを送信する$( %文書, `相対的な高分解能~時刻$( %~frame時刻印, %文書 に`関連な大域~obj$ ) ) `WEBANIMATIONS$r ◎ For each doc of docs, update animations and send events for doc, passing in relative high resolution time given frameTimestamp and doc's relevant global object as the timestamp [WEBANIMATIONS]
   12. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `全screen化~手続き$( %文書 ) `FULLSCREEN$r ◎ For each doc of docs, run the fullscreen steps for doc. [FULLSCREEN]

   13. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ ~IF［ ~UAは，ある［ `CanvasRenderingContext2D$I ／ `OffscreenCanvasRenderingContext2D$I ］文脈に結付けられた裏~storageを喪失したことを検出した ］ ⇒ そのような ~EACH( 文脈 %文脈 ) に対し ⇒ `文脈~喪失d時の手続き$を走らす ◎ For each doc of docs, if the user agent detects that the backing storage associated with a CanvasRenderingContext2D or an OffscreenCanvasRenderingContext2D, context, has been lost, then it must run the context lost steps for each such context:

       `文脈~喪失d時の手続き@ は： ◎ ↑

       1. %~canvas ~LET %文脈 に応じて ⇒＃ `CanvasRenderingContext2D$I であるならば %文脈 の `canvas$m 属性の値 ／ `OffscreenCanvasRenderingContext2D$I であるならば %文脈 の`~OffscreenCanvas~obj$o2D ◎ Let canvas be the value of context's canvas attribute, if context is a CanvasRenderingContext2D, or the associated OffscreenCanvas object for context otherwise.
       2. %文脈 の`文脈~喪失dか$ ~SET ~T ◎ Set context's context lost to true.
       3. `描画~文脈を既定の状態に設定し直す$( %文脈 ) ◎ Reset the rendering context to its default state given context.
       4. %復旧するべきか ~LET `~eventを発火する$( %~canvas, `contextlost$et ) — 次のように初期化して ⇒ `cancelable$m 属性 ~SET ~T ◎ Let shouldRestore be the result of firing an event named contextlost at canvas, with the cancelable attribute initialized to true.
       5. ~IF［ %復旧するべきか ~EQ ~F ］ ⇒ ~RET ◎ If shouldRestore is false, then abort these steps.
       6. %文脈 を復旧するよう試みる — %文脈 の属性~群を利用して裏~storageを作成して， %文脈 にそれを結付けることにより ◎ Attempt to restore context by creating a backing storage using context's attributes and associating them with context.＼
       7. ~IF［ 前~段に失敗した ］ ⇒ ~RET ◎ If this fails, then abort these steps.
       8. %文脈 の`文脈~喪失dか$ ~SET ~F ◎ Set context's context lost to false.
       9. `~eventを発火する$( %~canvas, `contextrestored$et ) ◎ Fire an event named contextrestored at canvas.
   14. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `各~animation~frame~callbackを走らす$( %文書, `相対的な高分解能~時刻$( %~frame時刻印, %文書 に`関連な大域~obj$ ) ) ◎ For each doc of docs, run the animation frame callbacks for doc, passing in the relative high resolution time given frameTimestamp and doc's relevant global object as the timestamp.
   15. %~styleと~layoutの安全でない開始~時刻 ~LET `安全でない共有される現在の時刻$ ◎ Let unsafeStyleAndLayoutStartTime be the unsafe shared current time.

   16. %文書~群 を成す ~EACH( %文書 ) に対し： ◎ For each doc of docs:

       1. %~resize観測器の深さ ~LET 0 ◎ Let resizeObserverDepth be 0.

       2. ~WHILE 無条件 ◎ While true:

          1. %文書 の~styleを計算し直して，その~layoutを更新する ◎ Recalculate styles and update layout for doc.
          2. %内容~可視性に関する初期~決定を経たか ~LET ~F ◎ Let hadInitialVisibleContentVisibilityDetermination be false.

          3. 【%文書 内の】［ `content-visibility$p の使用~値 ~EQ `auto^v ］を満たす ~EACH( 要素 %要素 ) に対し： ◎ For each element element with 'auto' used value of 'content-visibility':

             1. %初期~決定~用に検査するか ~LET ~IS［ %要素 の`表示域への近接度$ ~EQ `未決定$i ］~AND［ ~NOT %要素 は`利用者に関連する$ ］ ◎ Let checkForInitialDetermination be true if element's proximity to the viewport is not determined and it is not relevant to the user. Otherwise, let checkForInitialDetermination be false.
             2. %要素 の`表示域への近接度を決定する$ ◎ Determine proximity to the viewport for element.
             3. ~IF［ %初期~決定~用に検査するか ~EQ ~T ］~AND［ %要素 は`利用者に関連する$ ］ ⇒ %内容~可視性に関する初期~決定を経たか ~SET ~T ◎ If checkForInitialDetermination is true and element is now relevant to the user, then set hadInitialVisibleContentVisibilityDetermination to true.

          4. ~IF［ %内容~可視性に関する初期~決定を経たか ~EQ ~T ］ ⇒ ~CONTINUE ◎ If hadInitialVisibleContentVisibilityDetermination is true, then continue.

             注記： この段の意図は、［ 表示域への近接度に対する初期~決定 ］が即時に効果を発揮するよう，この~loopを成す始めの段で遂げられた［ ~styleと~layoutの計算 ］に反映させることにある。 近接度に対する初期~以外の決定は、 次回の`描画~機会$にて効果を発揮する。 `CSSCONTAIN$r ◎ The intent of this step is for the initial viewport proximity determination, which takes effect immediately, to be reflected in the style and layout calculation which is carried out in a previous step of this loop. Proximity determinations other than the initial one take effect at the next rendering opportunity. [CSSCONTAIN]

          5. `ある深さ以上で作動中な~resize観測nを集める$( %文書, %~resize観測器の深さ ) ◎ Gather active resize observations at depth resizeObserverDepth for doc.
          6. ~IF［ `作動中な~resize観測nはあるか？$( %文書 ) ~EQ ~T ］： ◎ If doc has active resize observations:
             1. %~resize観測器の深さ ~SET `作動中な~resize観測nを~broadcastする$( %文書 ) ◎ Set resizeObserverDepth to the result of broadcasting active resize observations given doc.
             2. ~CONTINUE ◎ Continue.
          7. ~ELSE ⇒ ~BREAK ◎ Otherwise, break.
       3. ~IF［ `飛ばした~resize観測nはあるか？$( %文書 ) ~EQ ~T ］ ⇒ `~resize~loop~errorを送達する$( %文書 ) ◎ If doc has skipped resize observations, then deliver resize loop error given doc.

   17. %文書~群 を成す ~EACH( %文書 ) に対し：

       1. ~IF［ %文書 が`指名する被focus区画$docは`~focus可能な区画$である ］ ⇒ ~CONTINUE
       2. `~objを~focusする$( %文書 の`表示域$ )
       3. %文書 に`関連な大域~obj$の`~navi~API$の`進行中な~naviの間に~focusは変化したか$ ~SET ~F

       ◎ For each doc of docs, if the focused area of doc is not a focusable area, then run the focusing steps for doc's viewport, and set doc's relevant global object's navigation API's focus changed during ongoing navigation to false.

       これは，例えば、 要素に `hidden$a 属性が追加され，`具現化されなく＠~HTMLrendering#being-rendered$なったときに起こり得る。 また、 `input$e 要素においては，それが`不能化され＠~HTMLforms#concept-fe-disabled$たときにも起こり得る。 ◎ For example, this might happen because an element has the hidden attribute added, causing it to stop being rendered. It might also happen to an input element when the element gets disabled.

       注記： これは、 `通例的＠~HTMLinteraction#note-sometimes-no-blur-event$には `blur$et ~eventを発火することになり， 場合によっては `change$et ~eventも発火することになる。 ◎ This will usually fire blur events, and possibly change events.

       注記： `指名する被focus区画$docが %文書 から除去された場合、 この非同期的な~focusの修復に加えて， `同期的な修復＠~HTMLINFRA#node-remove-focus-fixup$もある。 そこでは、［ `blur$et ／ `change$et ］~eventは`発火されない^em。 ◎ In addition to this asynchronous fixup, if the focused area of the document is removed, there is a synchronous fixup. That one will not fire blur or change events.

   18. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `処理待ち遷移~演算を遂行する＠~CSSVT#perform-pending-transition-operations$( %文書 ) `CSSVIEWTRANSITIONS$r ◎ For each doc of docs, perform pending transition operations for doc. [CSSVIEWTRANSITIONS]
   19. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `交差~観測nを更新する$( %文書, `相対的な高分解能~時刻$( %~frame時刻印【！%now】, %文書 に`関連な大域~obj$ ) ) `INTERSECTIONOBSERVER$r ◎ For each doc of docs, run the update intersection observations steps for doc, passing in the relative high resolution time given now and doc's relevant global object as the timestamp. [INTERSECTIONOBSERVER]
   20. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `描画~時刻を記録する$( %文書, %~styleと~layoutの安全でない開始~時刻 ) ◎ For each doc of docs, record rendering time for doc given unsafeStyleAndLayoutStartTime.
   21. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `塗り計時を刻む$( %文書 ) `PAINTTIMING$r ◎ For each doc of docs, mark paint timing for doc.
   22. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ ［ %文書, および その`~node~navigable$ ］の描画や~UIを，現在の状態を反映するように更新する ◎ For each doc of docs, update the rendering or user interface of doc and its node navigable to reflect the current state.
   23. %文書~群 を成す ~EACH( %文書 ) に対し ⇒ `上端~層からの除去を処理する$( %文書 ) ◎ For each doc of docs, process top layer removals given doc.

`小task~checkpointを遂行する@ ときは，次を走らすモノトスル： ◎ When a user agent is to perform a microtask checkpoint:

1. %~event~loop ~LET 当の`~event~loop$ ◎ ↓
2. ~IF［ %~event~loop の`小task~checkpoint遂行-中か$ ~EQ ~T ］ ⇒ ~RET ◎ If the event loop's performing a microtask checkpoint is true, then return.
3. %~event~loop の`小task~checkpoint遂行-中か$ ~SET ~T ◎ Set the event loop's performing a microtask checkpoint to true.

4. ~WHILE［ %~event~loop の`小task~queue$は空でない ］： ◎ While the event loop's microtask queue is not empty:

   1. %小task ~LET %~event~loop の`小task~queue$から`~dequeueする$ ◎ Let oldestMicrotask be the result of dequeuing from the event loop's microtask queue.
   2. %~event~loop の`現在~走っている~task$ ~SET %小task ◎ Set the event loop's currently running task to oldestMicrotask.

   3. %小task を走らす ◎ Run oldestMicrotask.

      注記： これは、 ~scriptによる~callbackの呼出ngを孕むかもしれず， 最終的に `走らせた~scriptを片付ける$手続きを~callする結果、 この~algoが再度~callされることになる。 `小task~checkpoint遂行-中か$を利用しているのは、 その再入性を避けるためである。 ◎ This might involve invoking scripted callbacks, which eventually calls the clean up after running script steps, which call this perform a microtask checkpoint algorithm again, which is why we use the performing a microtask checkpoint flag to avoid reentrancy.

   4. %~event~loop の`現在~走っている~task$ ~SET ~NULL ◎ Set the event loop's currently running task back to null.
5. ~EACH( `環境~設定群~obj$ %設定群~obj ) に対し ⇒ ~IF［ %設定群~obj の`担当の~event~loop$enV ~EQ %~event~loop ］ ⇒ `却下-済み~promiseについて通知する$( %設定群~obj の`大域~obj$enV ) ◎ For each environment settings object settingsObject whose responsible event loop is this event loop, notify about rejected promises given settingsObject's global object.
6. `Indexed Database ~transactionを片付ける＠~INDEXEDDB#cleanup-indexed-database-transactions$ ◎ Cleanup Indexed Database transactions.

7. `ClearKeptObjects$jA() ◎ Perform ClearKeptObjects().

   注記： `WeakRef.prototype.deref()$m が~objを返すとき、 その~objは，次回の `ClearKeptObjects$jA() の呼出nまで生きたまま保たれ、 その後に再び~garbage収集の~subjectになる。 ◎ When WeakRef.prototype.deref() returns an object, that object is kept alive until the next invocation of ClearKeptObjects(), after which it is again subject to garbage collection.

8. %~event~loop の`小task~checkpoint遂行-中か$ ~SET ~F ◎ Set the event loop's performing a microtask checkpoint to false.
9. `小task~checkpoint用に計時~報を記録する$() ◎ Record timing info for microtask checkpoint.

~UAは、 `並列的$に走っている %~algo において， `安定~状態を待受ける@ ときは、 %~algo 自身の実行を いったん停止すると同時に，次を遂行するモノトスル ⇒ `小taskを~queueする$( 次の手続き ) ◎ When an algorithm running in parallel is to await a stable state, the user agent must queue a microtask that runs the following steps, and must then stop executing (execution of the algorithm resumes when the microtask is run, as described in the following steps):

~algoにて，所与の条件 %目標 が満たされるまで `~event~loopを回す@ と記される箇所は、 次の手続きが成す~algoで代用することに等価とする： ◎ Algorithm steps that say to spin the event loop until a condition goal is met are equivalent to substituting in the following algorithm steps:

1. %~task ~LET 当の`~event~loop$の`現在~走っている~task$ ◎ Let task be the event loop's currently running task.

   注記： %~task は`小task$の場合もある。 ◎ task could be a microtask.

2. %~task~source ~LET %~task の`~source$tK ◎ Let task source be task's source.
3. %旧~stack ~LET `~JS実行~文脈~stack$の複製 ◎ Let old stack be a copy of the JavaScript execution context stack.
4. `~JS実行~文脈~stack$を空にする ◎ Empty the JavaScript execution context stack.

5. `小task~checkpointを遂行する$ ◎ Perform a microtask checkpoint.

   注記： %~task が`小task$である場合、［ `小task~checkpoint遂行-中か$ ~EQ ~T ］に因り，この段は何もしない。 ◎ If task is a microtask this step will be a no-op due to performing a microtask checkpoint being true.

6. この段は`並列的$に走らす： ◎ In parallel:

   1. %目標 が満たされるまで待機する ◎ Wait until the condition goal is met.

   2. `~taskを~queueする$( %~task~source, 次の手続き ) ◎ Queue a task on task source to:

      手続きは： ◎ ↑

      1. `~JS実行~文脈~stack$を %旧~stack に置換する ◎ Replace the JavaScript execution context stack with old stack.

      2. 元の~algo内の［ この`~event~loopを回す$と記された箇所の後に現れる手続き ］があれば それを遂行する ◎ Perform any steps that appear after this spin the event loop instance in the original algorithm.

         注記： これは %~task を再開する ◎ This resumes task.

7. %~task を停止して，それを呼出した~algoを何であれ再開できるようにする ◎ Stop task, allowing whatever algorithm that invoked it to resume.

   注記： これは、 次のいずれかの~algoを継続させる ⇒＃ `~event~loop$の~main手続き【`~event~loop処理~model$】, `小task~checkpointを遂行する$ ◎ This causes the event loop's main set of steps or the perform a microtask checkpoint algorithm to continue.

歴史的な理由から、 この仕様における一部の~algoは，~UAに対し［ ある`~task$ %~task が走っている間、 所与の %目標 が満たされるまで `静止する@ ］よう要求する。 これは、 次の手続きを走らすことを意味する： ◎ Some of the algorithms in this specification, for historical reasons, require the user agent to pause while running a task until a condition goal is met. This means running the following steps:

1. %大域~obj ~LET `現在の大域~obj$ ◎ Let global be the current global object.
2. %静止-前の時刻 ~LET `現在の高分解能~時刻$( %大域~obj ) ◎ Let timeBeforePause be the current high resolution time given global.
3. 必要yなら、［ `文書$や`~navigable$ ］の［ 描画や~UI ］を［ 現在の状態を反映する ］よう更新する ◎ If necessary, update the rendering or user interface of any Document or navigable to reflect the current state.

4. %目標 が満たされるまで待機する — %~task を`静止-$している間は、 ~UAは：

   • %~task が属している`~event~loop$は、 他の`~task$を走らせないモノトスル。
   • `現在~走っている~task$における~script実行は、 阻むモノトスル。
   • 利用者~入力に対しては、 即応可能であり続けるべきである — しかしながら、 `~event~loop$は何もしなくなるので，~~能力は抑制されることになる。
   ◎ Wait until the condition goal is met. While a user agent has a paused task, the corresponding event loop must not run further tasks, and any script in the currently running task must block. User agents should remain responsive to user input while paused, however, albeit in a reduced capacity since the event loop will not be doing anything.
5. `静止-所要時間を記録する$( `所要時間を得る$( %静止-前の時刻, `現在の高分解能~時刻$( %大域~obj ) ) ◎ Record pause duration given the duration from timeBeforePause to the current high resolution time given global.

`~event~handlerの~targetを決定する@ ときは、 所与の ( %~event~target, %名前 ) に対し，次の手続きを走らす： ◎ To determine the target of an event handler, given an EventTarget object eventTarget on which the event handler is exposed, and an event handler name name, the following steps are taken:

1. ~Assert ⇒＃ %~event~target は ある`~event~handler$を公開する `EventTarget$I ~objである ／ %名前 は ある`~event~handler$の`名前$eHを与える文字列である ◎ ↑
2. ~IF［ %~event~target は［ `body$e ／ `frameset$e ］要素でない ］ ⇒ ~RET %~event~target ◎ If eventTarget is not a body element or a frameset element, then return eventTarget.
3. ~IF［ %名前 は `WindowEventHandlers$I ~interface~mixinの属性~memberの名前でない ］~AND［ %名前 ~NIN `~windowを反映する~body要素~event~handler集合$ ］ ⇒ ~RET %~event~target ◎ If name is not the name of an attribute member of the WindowEventHandlers interface mixin and the Window-reflecting body element event handler set does not contain name, then return eventTarget.

4. ~IF［ %~event~target の`~node文書$は`作動中な文書$でない ］ ⇒ ~RET ~NULL ◎ If eventTarget's node document is not an active document, then return null.

   注記： これは例えば、 %~event~target が［ 対応する`~window$が無い `body$e 要素 ］である場合に起こり得る。 ◎ This could happen if this object is a body element without a corresponding Window object, for example.

   注記： ［ `body$e ／ `frameset$e ］要素が自身の`~node文書$の`~body要素$でない場合、 この段で終えるとは限らない。 特に、 `作動中な文書$内で （たぶん， `document.createElement()$c を用いて） 作成された `body$e 要素であるが，`接続されて$いないものにも、 要素を通して公開される いくつかの`~event~handler$の`~target$eHになるような，対応する`~window$がある。 ◎ This check does not necessarily prevent body and frameset elements that are not the body element of their node document from reaching the next step. In particular, a body element created in an active document (perhaps with document.createElement()) but not connected will also have its corresponding Window object as the target of several event handlers exposed through it.

5. ~RET %~event~target の`~node文書$に`関連な大域~obj$ ◎ Return eventTarget's node document's relevant global object.

名前 %名前 の`~event~handler~IDL属性$の取得子~手続きは： ◎ The getter of an event handler IDL attribute with name name, when called, must run these steps:

1. %~event~target ~LET `~event~handlerの~targetを決定する$( コレ, %名前 ) ◎ Let eventTarget be the result of determining the target of an event handler given this object and name.
2. ~IF［ %~event~target ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If eventTarget is null, then return null.
3. ~RET `~event~handlerの現在の値を取得する$( %~event~target, %名前 ) ◎ Return the result of getting the current value of the event handler given eventTarget and name.

名前 %名前 の`~event~handler~IDL属性$の設定子~手続きは： ◎ The setter of an event handler IDL attribute with name name, when called, must run these steps:

1. %~event~target ~LET `~event~handlerの~targetを決定する$( コレ, %名前 ) ◎ Let eventTarget be the result of determining the target of an event handler given this object and name.
2. ~IF［ %~event~target ~EQ ~NULL ］ ⇒ ~RET ◎ If eventTarget is null, then return.
3. ~IF［ 所与の値 ~EQ ~NULL ］ ⇒ `~event~handlerを非作動化する$( %~event~target, %名前 ) ◎ If the given value is null, then deactivate an event handler given eventTarget and name.

4. ~ELSE： ◎ Otherwise:

   1. %~event~handler ~LET %~event~target の`~event~handler~map$[ %名前 ] ◎ Let handlerMap be eventTarget's event handler map. ◎ Let eventHandler be handlerMap[name].
   2. %~event~handler の`値$eH ~SET 所与の値 ◎ Set eventHandler's value to the given value.
   3. `~event~handlerを作動化する$( %~event~target, %名前 ) ◎ Activate an event handler given eventTarget and name.

`~event~handler内容~属性$と`~event~handler$とを同期するため、 `属性~変更-時の手続き$ `DOM$r が利用される — それは、 所与の ( %局所~名, %旧-値, %値, %名前空間 ) に対し，次を走らす： ◎ The following attribute change steps are used to synchronize between event handler content attributes and event handlers: [DOM]

1. ~IF［ %名前空間 ~NEQ ~NULL ］~OR［ %局所~名 ~NEQ %要素 上の`~event~handler内容~属性$の名前 ］ ⇒ ~RET ◎ If namespace is not null, or localName is not the name of an event handler content attribute on element, then return.
2. %~event~target ~LET `~event~handlerの~targetを決定する$( %要素, %局所~名 ) ◎ Let eventTarget be the result of determining the target of an event handler given element and localName.
3. ~IF［ %~event~target ~EQ ~NULL ］ ⇒ ~RET ◎ If eventTarget is null, then return.
4. ~IF［ %値 ~EQ ~NULL ］ ⇒ `~event~handlerを非作動化する$( %~event~target, %局所~名 ) ◎ If value is null, then deactivate an event handler given eventTarget and localName.

5. ~ELSE： ◎ Otherwise:

   1. ~IF［ `要素における~inline型の挙動は~CSPにより阻止されるべきか？$( %要素, `script attribute^l, %値 ) ~EQ `阻止される^i `CSP$r ］ ⇒ ~RET ◎ If the Should element's inline behavior be blocked by Content Security Policy? algorithm returns "Blocked" when executed upon element, "script attribute", and value, then return. [CSP]
   2. %~event~handler ~LET %~event~target の`~event~handler~map$[ %局所~名 ] ◎ Let handlerMap be eventTarget's event handler map. ◎ Let eventHandler be handlerMap[localName].
   3. %所在 ~LET この手続きの実行を誘発した~scriptの所在 ◎ Let location be the script location that triggered the execution of these steps.
   4. %~event~handler の`値$eH ~SET ( %値, %所在 ) 組からなる，`内部的な生の未compileな~handler$ ◎ Set eventHandler's value to the internal raw uncompiled handler value/location.
   5. `~event~handlerを作動化する$( %~event~target, %局所~名 ) ◎ Activate an event handler given eventTarget and localName.

注記： `DOM$r 標準により，この手続きは： %旧-値, %値 が一致する場合（属性をその現在の値に設定したとき）でも走るが、 両~値とも ~NULL の場合（現在~存在しない属性を除去したとき）には`走らない^em。 ◎ Per the DOM Standard, these steps are run even if oldValue and value are identical (setting an attribute to its current value), but not if oldValue and value are both null (removing an attribute that doesn't currently exist). [DOM]

`~event~handlerを非作動化する@ ときは、 所与の ( %~event~target, %名前 ) に対し，次の手続きを走らす： ◎ To deactivate an event handler given an EventTarget object eventTarget and a string name that is the name of an event handler, run these steps:

1. ~Assert ⇒＃ %~event~target は `EventTarget$I ~objである ／ %名前 は ある`~event~handler$の`名前$eHを与える文字列である ◎ ↑
2. %~event~handler ~LET %~event~target の`~event~handler~map$[ %名前 ] ◎ Let handlerMap be eventTarget's event handler map. ◎ Let eventHandler be handlerMap[name].
3. %~event~handler の`値$eH ~SET ~NULL ◎ Set eventHandler's value to null.
4. %~listener ~LET %~event~handler の`~listener$eH ◎ Let listener be eventHandler's listener.
5. ~IF［ %~listener ~NEQ ~NULL ］ ⇒ `~event~listenerを除去する$( %~event~target, %~listener ) ◎ If listener is not null, then remove an event listener with eventTarget and listener.
6. %~event~handler の`~listener$eH ~SET ~NULL ◎ Set eventHandler's listener to null.

`すべての~event~listener／~event~handlerを消去する@ ときは、 所与の ( `EventTarget$I ~obj %~event~target ) に対し，次の手続きを走らす： ◎ To erase all event listeners and handlers given an EventTarget object eventTarget, run these steps:

1. %~event~target の`~event~handler~map$を成す ~EACH( %名前 → %~event~handler ) に対し ⇒ `~event~handlerを非作動化する$( %~event~target, %名前 ) ◎ If eventTarget has an associated event handler map, then for each name → eventHandler of eventTarget's associated event handler map, deactivate an event handler given eventTarget and name.
2. `~event~listenerをすべて除去する$( %~event~target ) ◎ Remove all event listeners given eventTarget.

この~algoは `document.open()$c を定義するために利用される。 ◎ This algorithm is used to define document.open().

`~event~handlerを作動化する@ ときは、 所与の ( %~event~target, %名前 ) に対し，次の手続きを走らす： ◎ To activate an event handler given an EventTarget object eventTarget and a string name that is the name of an event handler, run these steps:

1. ~Assert ⇒＃ %~event~target は `EventTarget$I ~objである ／ %名前 は ある`~event~handler$の`名前$eHを与える文字列である ◎ ↑
2. %~event~handler ~LET %~event~target の`~event~handler~map$[ %名前 ] ◎ Let handlerMap be eventTarget's event handler map. ◎ Let eventHandler be handlerMap[name].
3. ~IF［ %~event~handler の`~listener$eH ~NEQ ~NULL ］ ⇒ ~RET ◎ If eventHandler's listener is not null, then return.

4. %callback ~LET ［ 1 個の引数 %引数 をとり，次を実行する関数 ］への参照を表現している，~Web~IDL `EventListener$I ~instanceを作成した結果 ⇒ `~event~handler処理~algo$( %~event~target, %名前, %引数 ) ◎ Let callback be the result of creating a Web IDL EventListener instance representing a reference to a function of one argument that executes the steps of the event handler processing algorithm, given eventTarget, name, and its argument.

   `EventListener$I の`~callback文脈$は、 任意なものをとれる — それは、 `~event~handler処理~algo$には影響iしない。 `DOM$r ◎ The EventListener's callback context can be arbitrary; it does not impact the steps of the event handler processing algorithm. [DOM]

   注記： `callback^i は、 `~event~handler$そのもの`ではない^emことに注意。 どの`~event~handler$も、 同じ `~callback^i — すなわち，下に定義する~algo — を登録する結果になる。 その~algoが、［ 的確な~codeを呼出して，その~codeから返される値を処理する ］ことを受け持つ。 ◎ The callback is emphatically not the event handler itself. Every event handler ends up registering the same callback, the algorithm defined below, which takes care of invoking the right code, and processing the code's return value.

5. %~listener ~LET 新たな`~event~listener$ — その ⇒＃ `型$evL ~SET %~event~handler に対応する `~event~handler~event型@ `~callback$evL ~SET %~callback ◎ Let listener be a new event listener whose type is the event handler event type corresponding to eventHandler and callback is callback.

   注記： `~event~listener$は `EventListener$I とは異なることに注意。 ◎ To be clear, an event listener is different from an EventListener.

6. `~event~listenerを追加する$( %~event~target, %~listener ) ◎ Add an event listener with eventTarget and listener.
7. %~event~handler の`~listener$eH ~SET %~listener ◎ Set eventHandler's listener to listener.

`~event~handler処理~algo@ は、 所与の ( %~event~target, %名前, %~event ) に対し，次を走らす： ◎ The event handler processing algorithm for an EventTarget object eventTarget, a string name representing the name of an event handler, and an Event object event is as follows:

1. ~Assert ⇒＃ %~event~target は `EventTarget$I ~objである ／ %名前 は ある`~event~handler$の`名前$eHを与える文字列である ／ %~event は `Event$I ~objである ◎ ↑
2. %~callback ~LET `~event~handlerの現在の値を取得する$( %~event~target, %名前 ) ◎ Let callback be the result of getting the current value of the event handler given eventTarget and name.
3. ~IF［ %~callback ~EQ ~NULL ］ ⇒ ~RET ◎ If callback is null, then return.
4. %特別な~error~event取扱いか ~LET ~IS［ %~event は `ErrorEvent$I ~objである ］~AND［ %~event の `type$m ~EQ "`error$et" ］~AND［ %~event の `currentTarget$m 値は `WindowOrWorkerGlobalScope$I ~mixinを実装する ］ ◎ Let special error event handling be true if event is an ErrorEvent object, event's type is "error", and event's currentTarget implements the WindowOrWorkerGlobalScope mixin. Otherwise, let special error event handling be false.

5. %引数~群 ~LET %特別な~error~event取扱いか に応じて：

   • ~F ⇒ « %~event »
   • ~T ⇒ %~event の次に挙げる属性の値たちが成す同順の`~list$ ⇒ `message$m, `filename$m, `lineno$m, `colno$m, `error$m
   ◎ ↓

6. %返り値 ~LET `~callback関数を呼出す$( %~callback, %引数~list, `投出し直す^i, %~event の `currentTarget$m 属性の値 ) ◎ Process the Event object event as follows: • If special error event handling is true •• Let return value be the result of invoking callback with « event's message, event's filename, event's lineno, event's colno, event's error », "rethrow", and with callback this value set to event's currentTarget. • Otherwise •• Let return value be the result of invoking callback with « event », "rethrow", and with callback this value set to event's currentTarget.

   注記： %~callback から例外が投出された場合、 投出し直され，この手続きを終えることになる （当の例外は、 `~DOM~event配送-~logic＠~DOM4#concept-event-listener-invoke$へ伝播して， そこで`報告される＠#report-an-exception$ことになる）。 ◎ If an exception gets thrown by the callback, it will be rethrown, ending these steps. The exception will propagate to the DOM event dispatch logic, which will then report it.

7. ~IF［ %~event は `BeforeUnloadEvent$I ~objである ］~AND［ %~event の `type$m ~EQ "`beforeunload$et" ］： ◎ Process return value as follows: • If event is a BeforeUnloadEvent object and event's type is "beforeunload"

   注記： この事例では、 `~event~handler~IDL属性$の型は `OnBeforeUnloadEventHandler$I 型になるので、 %返り値 は［ ~NULL または `DOMString^I ］型に型強制されることになる。 ◎ • In this case, the event handler IDL attribute's type will be OnBeforeUnloadEventHandler, so return value will have been coerced into either null or a DOMString.

   1. ~IF［ %返り値 ~EQ ~NULL ］ ⇒ ~RET ◎ If return value is not null, then:
   2. %~event の`取消されたか$ev ~SET ~T ◎ Set event's canceled flag.
   3. ~IF［ %~event の `returnValue$m 属性の値 ~EQ 空~文字列 ］ ⇒ %~event の `returnValue$m 属性の値 ~SET %返り値 ◎ If event's returnValue attribute's value is the empty string, then set event's returnValue attribute's value to return value.
8. ~ELIF［ %特別な~error~event取扱いか ~EQ ~T ］ ⇒ ~IF［ %返り値 ~EQ ~T ］ ⇒ %~event の`取消されたか$ev ~SET ~T ◎ • If special error event handling is true •• If return value is true, then set event's canceled flag.

9. ~ELIF［ %返り値 ~EQ ~F ］ ⇒ %~event の`取消されたか$ev ~SET ~T ◎ • Otherwise •• If return value is false, then set event's canceled flag.

   注記： ［ %~event の `type$m ~EQ "`beforeunload$et" ］だが［ %~event は `BeforeUnloadEvent$I ~objでない ］がため，この段に達した場合、 %返り値 は決して ~F にならない — すでに［ ~NULL または `DOMString^I ］型に型強制されているので。 ◎ • If we've gotten to this "Otherwise" clause because event's type is "beforeunload" but event is not a BeforeUnloadEvent object, then return value will never be false, since in such cases return value will have been coerced into either null or a DOMString.

~UAは `~event~handlerの現在の値を取得する@ ときは、 所与の ( %~event~target, %名前 ) に対し，次を走らすモノトスル： ◎ When the user agent is to get the current value of the event handler given an EventTarget object eventTarget and a string name that is the name of an event handler, it must run these steps:

1. ~Assert ⇒＃ %~event~target は `EventTarget$I ~objである ／ %名前 は ある`~event~handler$の`名前$eHを与える文字列である ◎ ↑
2. %~event~handler ~LET %~event~target の`~event~handler~map$[ %名前 ] ◎ Let handlerMap be eventTarget's event handler map. ◎ Let eventHandler be handlerMap[name].
3. ~IF［ %~event~handler の`値$eHは、 `内部的な生の未compileな~handler$でない ］ ⇒ ~RET %~event~handler の`値$eH ◎ If eventHandler's value is an internal raw uncompiled handler, then:

4. ( %要素, %文書 ) ~LET %~event~target に応じて：

   • ある要素 %E である ⇒ ( %E, %E の`~node文書$ )
   • ある`~window$ %W である ⇒ ( ~NULL, %W に`結付けられた文書$ )
   ◎ If eventTarget is an element, then let element be eventTarget, and document be element's node document. Otherwise, eventTarget is a Window object, let element be null, and document be eventTarget's associated Document.
5. ~IF［ %文書 用の`~scriptingは不能化されて$いる ］ ⇒ ~RET ~NULL ◎ If scripting is disabled for document, then return null.
6. %本体 ~LET %~event~handler の`値$eHを成す未compileな~script本体 ◎ Let body be the uncompiled script body in eventHandler's value.
7. %所在 ~LET %本体 が出自にしている所在 ◎ Let location be the location where the script body originated, as given by eventHandler's value.
8. %~form所有者 ~LET ~NULL ◎ ↓
9. ~IF［ %要素 ~NEQ ~NULL ］~AND［ %要素 には`~form所有者$ %F がある ］ ⇒ %~form所有者 ~LET %F ◎ If element is not null and element has a form owner, let form owner be that form owner. Otherwise, let form owner be null.
10. %設定群~obj ~LET %文書 に`関連な設定群~obj$ ◎ Let settings object be the relevant settings object of document.

11. ~IF［ %本体 は `FunctionBody$P として構文解析-可能でない ］~OR［ 構文解析-時に`早期~error$が検出された ］： ◎ If body is not parsable as FunctionBody or if parsing detects an early error, then follow these substeps:

    1. %~event~handler の`値$eH ~SET ~NULL ◎ Set eventHandler's value to null.

       注記： これは、 `~event~handlerを非作動化する$ことはない — それは、 ~event~handlerの`~listener$eHが在れば， それも`除去する＠~DOM4#remove-an-event-listener$。 ◎ This does not deactivate the event handler, which additionally removes the event handler's listener (if present).

    2. %構文~error ~LET %設定群~obj の`~realm$enV に属する新たな `SyntaxError$E 例外 — これは、 検出された~errorを述べるものであり， 【その`~message＠~WEBIDL#domexception-message$は】 %所在 に基づくベキである。 ◎ Let syntaxError be a new SyntaxError exception associated with settings object's realm which describes the error while parsing. It should be based on location, where the script body originated.
    3. `例外を報告する$( %構文~error, %設定群~obj の`大域~obj$enV ) ◎ Report an exception with syntaxError for settings object's global object.
    4. ~RET ~NULL ◎ Return null.

12. `~JS実行~文脈~stack$に［ %設定群~obj の`~realm実行~文脈$enV ］を~pushする — それが，現在 `走っている~JS実行~文脈$になる ◎ Push settings object's realm execution context onto the JavaScript execution context stack; it is now the running JavaScript execution context.

    注記： これは、 後の `OrdinaryFunctionCreate$jA の呼出nが正しい`~realm$に属するようにするため，必要yである。 ◎ This is necessary so the subsequent invocation of OrdinaryFunctionCreate takes place in the correct realm.

13. %onerror用か ~LET ~IS［ %名前 ~EQ `onerror$hd ］~AND［ %~event~target は`~window$である ］ ◎ ↓

14. %関数 ~LET 次を引数に `OrdinaryFunctionCreate$jA を~callした結果： ◎ Let function be the result of calling OrdinaryFunctionCreate, with arguments:

    %functionPrototype

    `Function.prototype$jI

    %sourceText

    次を順に連結して形成される文字列 ⇒＃ `function ^l, %名前, 下に与える %S, ` {^l, `000A^U `LF^cn, %本体, `000A^U `LF^cn, `}^l

    上の %S は、 %onerror用か に応じて ⇒＃ ~T ならば `(event, source, lineno, colno, error)^l ／ ~F ならば `(event)^l

    ◎ If name is onerror and eventTarget is a Window object • The string formed by concatenating "function ", name, "(event, source, lineno, colno, error) {", U+000A LF, body, U+000A LF, and "}". ◎ Otherwise • The string formed by concatenating "function ", name, "(event) {", U+000A LF, body, U+000A LF, and "}".

    %ParameterList

    %関数 は %onerror用か に応じて，次に与える名前の引数をとる ⇒＃ ~T ならば 5 個の引数 ( `event^c, `source^c, `lineno^c, `colno^c, `error^c ) ／ ~F ならば 1 個の引数 ( `event^c ) ◎ If name is onerror and eventTarget is a Window object • Let the function have five arguments, named event, source, lineno, colno, and error. ◎ Otherwise • Let the function have a single argument called event.

    %body

    %本体 を構文解析した結果 ◎ The result of parsing body above.

    %thisMode

    `non-lexical-this^i

    %scope

    次の手続きを走らせた結果： ◎ —

    1. %~realm ~LET %設定群~obj の`~realm$enV ◎ Let realm be settings object's realm.
    2. %視野 ~LET %~realm .`GlobalEnv^sl ◎ Let scope be realm.[[GlobalEnv]].
    3. ~IF［ %~event~handler は要素の`~event~handler$である ］ ⇒ %視野 ~SET `NewObjectEnvironment$jA( %文書, ~T, %視野 ) ◎ If eventHandler is an element's event handler, then set scope to NewObjectEnvironment(document, true, scope).
    4. ~ELSE ⇒ ~Assert： %~event~handler は`~window$の`~event~handler$である ◎ (Otherwise, eventHandler is a Window object's event handler.)
    5. ~IF［ %~form所有者 ~NEQ ~NULL ］ ⇒ %視野 ~SET `NewObjectEnvironment$jA( %~form所有者, ~T, %視野 ) ◎ If form owner is not null, then set scope to NewObjectEnvironment(form owner, true, scope).
    6. ~IF［ %要素 ~NEQ ~NULL ］ ⇒ %視野 ~SET `NewObjectEnvironment$jA( %要素, ~T, %視野 ) ◎ If element is not null, then set scope to NewObjectEnvironment(element, true, scope).
    7. ~RET %視野 ◎ Return scope.

15. %設定群~obj の`~realm実行~文脈$enVを，`~JS実行~文脈~stack$から除去する ◎ Remove settings object's realm execution context from the JavaScript execution context stack.

16. %関数 .`ScriptOrModule^sl ~SET ~NULL ◎ Set function.[[ScriptOrModule]] to null.

    注記： これを行うわけは、［ 作成した %関数 を当の~stack上で最も近い`~script$に結付けるとする，既定の挙動 ］では，~pathに依存する結果を導き得るからである： 例えば、 ~event~handlerが利用者-ヤリトリにより最初に呼出された場合， `ScriptOrModule^sl は ~NULL になる （その時点では`作動中な~script$は ~NULL であり，この~algoは、 そのとき最初に呼出されるので） 一方で、 ~scriptから~eventを配送することにより最初に呼出された場合， `ScriptOrModule^sl は その~scriptに設定されることになる。 ◎ This is done because the default behavior, of associating the created function with the nearest script on the stack, can lead to path-dependent results. For example, an event handler which is first invoked by user interaction would end up with null [[ScriptOrModule]] (since then this algorithm would be first invoked when the active script is null), whereas one that is first invoked by dispatching an event from script would have its [[ScriptOrModule]] set to that script.

    ここでは代わりに、 `ScriptOrModule^sl は常に ~NULL に設定することにする。 こうすれば、 もっと直感的になる — ［ 最初に~eventを配送した~scriptが、 どうにかして，当の~event~handler~codeを担当する ］とする案では、 不確かになる。 ◎ Instead, we just always set [[ScriptOrModule]] to null. This is more intuitive anyway; the idea that the first script which dispatches an event is somehow responsible for the event handler code is dubious.

    これは，実施においては、 `import()$m を介する相対~URLの解決に限り影響する — それは、 結付けられた~scriptの`基底~URL$sCを諮る。 `ScriptOrModule^sl を ~NULL 化することは、［ `HostLoadImportedModule$jA は、 `現在の設定群~obj$の`~API用~基底~URL$enVに~fall-backする ］ことを意味する。 ◎ In practice, this only affects the resolution of relative URLs via import(), which consult the base URL of the associated script. Nulling out [[ScriptOrModule]] means that HostLoadImportedModule will fall back to the current settings object's API base URL.

17. %~event~handler の値 ~SET 新たな~Web~IDL `EventHandler$I ~callback関数 — その ⇒＃ その~obj参照 ~SET %関数, その`~callback文脈$ ~SET %設定群~obj ◎ Set eventHandler's value to the result of creating a Web IDL EventHandler callback function object whose object reference is function and whose callback context is settings object.
18. ~RET %~event~handler の値 ◎ Return eventHandler's value.

`合成な~pointer~eventを発火する@ ときは、 所与の ( %~target（~eventの配送-先）, %e（~event名）, %~trustされないか ~IN { `~trustされない^i, ε } （省略時は ε ） ) に対し，次の手続きを走らす： ◎ Firing a synthetic pointer event named e at target, with an optional not trusted flag, means running these steps:

1. %~event ~LET `~eventを作成する$( `PointerEvent$I ) ◎ Let event be the result of creating an event using PointerEvent.

2. 以下に従って， %~event を初期化する： ◎ ↓

   1. `type$m ~SET %e ◎ Initialize event's type attribute to e.
   2. `bubbles$m ~SET ~T ◎ ↓
   3. `cancelable$m ~SET ~T ◎ Initialize event's bubbles and cancelable attributes to true.
   4. `~composedか$ev ~SET ~T ◎ Set event's composed flag.
   5. ~IF［ %~trustされないか ~EQ `~trustされない^i ］ ⇒ `isTrusted$m ~SET ~F ◎ If the not trusted flag is set, initialize event's isTrusted attribute to false.
   6. ［ `ctrlKey^m, `shiftKey^m, `altKey^m, `metaKey^m ］は、 ~UIkey入力~装置の現在の状態に則って初期化する （可用でない~UIkeyに対しては ~F にする） ◎ Initialize event's ctrlKey, shiftKey, altKey, and metaKey attributes according to the current state of the key input device, if any (false for any keys that are not available).
   7. `view$m ~SET %~target の`~node文書$の`~window$が［ あれば それ／ なければ ~NULL ］ ◎ Initialize event's view attribute to target's node document's Window object, if any, and null otherwise.
   8. `getModifierState()^m ~methodは、 ~UIkey入力~装置の現在の状態を適切に述べる値を返すようにする ◎ event's getModifierState() method is to return values appropriately describing the current state of the key input device.
3. ~RET `~eventを配送する$( %~target, %~event ) ◎ Return the result of dispatching event at target.