8.1. ~scripting

【この訳に特有な表記規約】

この訳の,~algoや定義の記述に利用されている各種記号( ~LET, ~IF, ~GOTO 等々)の意味や定義の詳細は,~SYMBOL_DEF_REFを~~参照されたし。

8.1.1. 序論

作者から供された実行-可能な~codeは、種々の仕組みにより,文書の文脈において走らす。 これらの仕組みには、(少なくとも)次のものが含まれる: ◎ Various mechanisms can cause author-provided executable code to run in the context of a document. These mechanisms include, but are probably not limited to:

  • `script$e 要素の処理。 ◎ Processing of script elements.
  • `javascript$sc ~URLへ~navigateするとき。 ◎ Navigating to javascript: URLs.
  • 次による~event~handler ⇒# ~DOMの `addEventListener()^m を利用して登録されたもの, 明示的な`~event~handler内容~属性$, `~event~handler~IDL属性$, その他 ◎ Event handlers, whether registered through the DOM using addEventListener(), by explicit event handler content attributes, by event handler IDL attributes, or otherwise.
  • SVG の様な,自前の~scripting特能を有する技術の処理。 ◎ Processing of technologies like SVG that have their own scripting features.

8.1.2 ~agentと~agent~cluster

8.1.2.1. ~JS~agent形式化との統合

~JSは、`~agent$の概念を定義している。 この節では、その言語~levelの概念から~web~platformへの対応付けを与える。 ◎ JavaScript defines the concept of an agent. This section gives the mapping of that language-level concept on to the web platform.

注記: `~agent$の概念は、概念的には,~architectureに依存しない理想化された “~thread” である — その~thread内で~JS~codeを走らすような。 そのような~codeは,互いに同期的に~accessできる複数の[ 大域~obj / `~Realm$gL ]を孕み得るので、単独の実行~thread内で走らす必要がある。 ◎ Conceptually, the agent concept is an architecture-independent, idealized "thread" in which JavaScript code runs. Such code can involve multiple globals/realms that can synchronously access each other, and thus needs to run in a single execution thread.

2 つの`~window$は、同じ`~agent$に属していても,互いの~realm内に作成された すべての~objに直に~accessできるわけではない。 そのためには、`同じ生成元~domain$に属する必要がある。 `IsPlatformObjectSameOrigin$jA を見よ ◎ Two Window objects having the same agent does not indicate they can directly access all objects created in each other's realms. They would have to be same origin-domain; see IsPlatformObjectSameOrigin.

~web~platformには、次に挙げる型の~agentが存在する: ◎ The following types of agents exist on the web platform:

`生成元が類似な~window~agent@ ◎ Similar-origin window agent
直に, または `document.domain$m を利用することにより,互いに到達し得るような、様々な`~window$を包含する。 ◎ Contains various Window objects which can potentially reach each other, either directly or by using document.domain.
包摂している`~agent~cluster$の`非同一-生成元~隔離-済み$ ~EQ ~T の場合、すべての`~window$は,[ 互いに`同一-生成元$になる/ 互いに直に到達し得る/ `document.domain$m は何もしない ]ことになる。 ◎ If the encompassing agent cluster's cross-origin isolated is true, then all the Window objects will be same origin, can reach each other directly, and document.domain will no-op.
注記: `同一-生成元$に属する 2 個の`~window$は、異なる`生成元が類似な~window~agent$に属することもある — 一例として、それぞれが自前の`閲覧文脈~group$に属する場合。 ◎ Two Window objects that are same origin can be in different similar-origin window agents, for instance if they are each in their own browsing context group.
`専用~worker~agent@ ◎ Dedicated worker agent
1 個の `DedicatedWorkerGlobalScope$I を包含する。 ◎ Contains a single DedicatedWorkerGlobalScope.
`共用~worker~agent@ ◎ Shared worker agent
1 個の `SharedWorkerGlobalScope$I ~objを包含する。 ◎ Contains a single SharedWorkerGlobalScope.
`~sw~agent@ ◎ Service worker agent
1 個の `ServiceWorkerGlobalScope$I ~objを包含する。 ◎ Contains a single ServiceWorkerGlobalScope.
`~worklet~agent@ ◎ Worklet agent
1 個の `WorkletGlobalScope$I ~objを包含する。 ◎ Contains a single WorkletGlobalScope object.
注記: 所与の~workletは、複数の~realmを有し得る。 そのような各~realmは、互いに~codeを独立にかつ同時に実行できるので,それぞれに自前の~agentが必要になる。 ◎ Although a given worklet can have multiple realms, each such realm needs its own agent, as each realm can be executing code independently and at the same time as the others.

[ `共用~worker~agent$/`専用~worker~agent$ ]に限り,`前方-進捗$を阻み得る~JS `Atomics$jc ~APIの利用を許容する。 ◎ Only shared and dedicated worker agents allow the use of JavaScript Atomics APIs to potentially block.

`~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.

`~platform~obj$ %O に `関連な~agent@ は、 %O に`関連な~Realm$の`~agent$とする。 ~Realmの~agentが何を指すかは、まだ~JS仕様に定義されていない — tc39/ecma262#1357 を見よ。 ◎ The relevant agent for a platform object platformObject is platformObject's relevant Realm's agent. This pointer is not yet defined in the JavaScript specification; see tc39/ecma262#1357.

注記: `現在の~Realm~Record$に等価な~agentは、`~surrounding~agent$である。 ◎ The agent equivalent of the current Realm Record is the surrounding agent.

8.1.2.2. ~JS~agent~cluster形式化との統合

~JSは、`~agent~cluster$の概念も定義する。 この標準は、[ `生成元が類似な~window~agentを得する$/ `~worker/~worklet~agentを得する$ ]~algoを利用して~agentが作成されたとき,それを適切に設置することにより、その概念を~web~platformに対応付ける。 ◎ JavaScript also defines the concept of an agent cluster, which this standard maps to the web platform by placing agents appropriately when they are created using the obtain a similar-origin window agent or obtain a worker/worklet agent algorithms.

`~agent~cluster$の概念は、~JS~memory~model — 特に,どの`~agent$どうしが `SharedArrayBuffer$I ~objの~~下層~dataを共有できるか — を定義するために不可欠である。 ◎ The agent cluster concept is crucial for defining the JavaScript memory model, and in particular among which agents the backing data of SharedArrayBuffer objects can be shared.

注記: `~agent~cluster$の概念は、概念的には,複数の “~thread” ( `~agent$ )を一緒に~group化するような, ~architectureに依存しない理想化された “~process境界” を成す。 仕様が定義する`~agent~cluster$は、一般に,~UA内で実装される実際の~process境界より制約的である。 これらの理想化された区分を 仕様~levelで施行することにより、~process~modelが~UA間で様々でも, ある~UA内で変化しても,共用~memoryの挙動は ~web開発者からは相互運用可能に見えることが確保される。 ◎ Conceptually, the agent cluster concept is an architecture-independent, idealized "process boundary" that groups together multiple "threads" (agents). The agent clusters defined by the specification are generally more restrictive than the actual process boundaries implemented in user agents. By enforcing these idealized divisions at the specification level, we ensure that web developers see interoperable behavior with regard to shared memory, even in the face of varying and changing user agent process models.

各`~agent~cluster$には、真偽値をとる `非同一-生成元~隔離-済み@ が結付けられ,初期~時には ~F とする。 ◎ An agent cluster has an associated cross-origin isolated (a boolean), which is initially false.

各`~agent~cluster$には、真偽値をとる `生成元~隔離-済み@ が結付けられ,初期~時には ~F とする。 ◎ An agent cluster has an associated origin-isolated (a boolean), which is initially false.


`~agent~cluster$への`生成元が類似な~window~agent$の割振りは、以下に従って定義される。 ◎ The following defines the allocation of the agent clusters of similar-origin window agents.

`~agent~cluster~key@ は、[ `~site$/`成分組~生成元$ ]である。 それは、~web開発者による 生成元~隔離 を達成する動作がなければ,`~site$になる。 ◎ An agent cluster key is a site or tuple origin. Without web developer action to achieve origin isolation, it will be a site.

注記: “`~agent~cluster~key$は[ `~scheme&~host$/`生成元$ ]である” としても等価な公式化を成す。 ◎ An equivalent formulation is that an agent cluster key can be a scheme-and-host or an origin.

`生成元が類似な~window~agentを得する@ ときは、所与の ( `生成元$ %生成元, `閲覧文脈~group$ %~group, 真偽値 %生成元~隔離を要請する ) に対し,次を走らす: ◎ To obtain a similar-origin window agent, given an origin origin, a browsing context group group, and a boolean requestsOI, 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 の`非同一-生成元~隔離-済み$bcG ~EQ ~T ] ⇒ %~key ~SET %生成元 ◎ If group's cross-origin isolated is true, then set key to origin.
  3. ~ELIF[ %~group の`履歴上の~agent~cluster~key~map$[ %生成元 ] ~NEQ ε ] ⇒ %~key ~SET %~group の`履歴上の~agent~cluster~key~map$[ %生成元 ] ◎ 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[ %生成元~隔離を要請する ~EQ ~T ] ⇒ %~key ~SET %生成元 ◎ If requestsOI is true, then set key to origin.
    2. %~group の`履歴上の~agent~cluster~key~map$[ %生成元 ] ~SET %~key ◎ Set group's historical agent cluster key map[origin] to key.
  5. ~IF[ %~group の`~agent~cluster~map$[ %~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 の`非同一-生成元~隔離-済み$ ~SET %~group の`非同一-生成元~隔離-済み$bcG ◎ Set agentCluster's cross-origin isolated to group's cross-origin isolated.
    3. %~agent~cluster の`生成元~隔離-済み$ ~SET [ %~key ~EQ %生成元 ならば ~T / ~ELSE_ ~F ] ◎ Set agentCluster's origin-isolated 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$[ %~key ] ~SET %~agent~cluster ◎ Set group's agent cluster map[key] to agentCluster.
  6. ~RET %~group の`~agent~cluster~map$[ %~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.)


他のすべての型の~agentが成す`~agent~cluster$の割振りは、以下で定義される。 ◎ The following defines the allocation of the agent clusters of all other types of agents.

`~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 の`生成元~隔離-済み$ ~SET ~T ◎ Set agentCluster's origin-isolated to true.

      注記: これらの~workerは、生成元~隔離されるものと見なせる。 しかしながら、これは,~APIを通しては公開されない( `originIsolated$m が~window用に生成元~隔離~状態を公開するような仕方では)。 ◎ These workers can be considered to be origin-isolated. However, this is not exposed through any APIs (in the way that originIsolated exposes the origin-isolation state for windows).

  3. ~ELSE: ◎ Otherwise:

    1. ~Assert: %外側~設定群 ~NEQ ~NULL ◎ Assert: outside settings is not null.
    2. %所有者~agent ~LET %外側~設定群 の`~Realm$enVの~agent ◎ 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.


次に挙げる大域~objどうしは、同じ`~agent~cluster$内にあり,互いの~memoryを共有する `SharedArrayBuffer$I ~instanceを利用できる: ◎ The following pairs of global objects are each within the same agent cluster, and thus can use SharedArrayBuffer instances to share memory with each other:

  • `~window$と, それが作成した専用~worker ◎ A Window object and a dedicated worker that it created.
  • ~worker(型は問わない)と, それが作成した専用~worker ◎ A worker (of any type) and a dedicated worker it created.
  • `~window$と, それが作成した `iframe$e 要素の`~window$であって,互いに`同じ生成元~domain$になれるもの ◎ A Window object A and the Window object of an iframe element that A created that could be same origin-domain with A.
  • `~window$と, それを開いた`~window$であって,互いに`同じ生成元~domain$であるもの ◎ A Window object and a same origin-domain Window object that opened it.
  • `~window$と, それが作成した~worklet ◎ A Window object and a worklet that it created.

次に挙げる大域~objどうしは、同じ`~agent~cluster$に`属さない^emので,~memoryを共有できない: ◎ The following pairs of global objects are not within the same agent cluster, and thus cannot share memory:

  • `~window$と, それが作成した共用~worker ◎ A Window object and a shared worker it created.
  • ~worker(型は問わない)と, それが作成した共用~worker ◎ A worker (of any type) and a shared worker it created.
  • `~window$と, それが作成した~sw ◎ A Window object and a service worker it created.
  • `~window$と, それが作成した `iframe$e 要素の`~window$であって,互いに`同じ生成元~domain$になれないもの ◎ A Window object and the Window object of an iframe element that A created that cannot be same origin-domain with A.
  • 互いの`閲覧文脈$が 次の関係性を満たさないような, 2 つの`~window$ ⇒ [ 一方は他方を`開いた閲覧文脈$である ]~OR[ 一方は他方の`先祖~閲覧文脈$である ]

    このことは、当の 2 つの`~window$が`同一-生成元$であっても,保持される。

    ◎ Any two Window objects whose browsing contexts do not have a non-null opener or ancestor relationship. This holds even if the two Window objects are same origin.

8.1.3. ~realm, それに相応するもの

~JS仕様は、`~JS~realm$の概念を導入する — それは、~scriptを中で走らす大域~環境を表現する。 各~realmには、`実装定義$な`大域~obj$が伴われる。 この仕様の大半は、大域~objと その各~propを定義することに割かれている。 ◎ The JavaScript specification introduces the realm concept, representing a global environment in which script is run. Each realm comes with an implementation-defined global object; much of this specification is devoted to defining that global object and its properties.

~web仕様~用には、値や~algoを ( ~realm / 大域~obj ) が成す~pairに結付けると有用になることが多い。 そのような値は、特定0の型の~realmに特有であるときは,当の大域~objに直に結付けられる — 例:[ `Window$I / `WorkerGlobalScope$I ]~interfaceの定義~内に。 複数の~realmにまたがる有用性がある値には、`環境~設定群~obj$の概念が利用する。 ◎ For web specifications, it is often useful to associate values or algorithms with a realm/global object pair. When the values are specific to a particular type of realm, they are associated directly with the global object in question, e.g., in the definition of the Window or WorkerGlobalScope interfaces. When the values have utility across multiple realms, we use the environment settings object concept.

一部の事例では、[ ~realm/大域~obj/環境~設定群~obj ]が存在するようになる前であっても(例えば,`~navigate$の間に),結付けられる値を追跡することが必要とされる。 これらの値は、`環境$の概念にて追跡される。 ◎ Finally, in some cases it is necessary to track associated values before a realm/global object/environment settings object even comes into existence (for example, during navigation). These values are tracked in the environment concept.

8.1.3.1. 環境

`環境@ とは、[ 現在の実行~環境,または そうなり得るもの ]の設定群を識別する~objである。 各 `環境$ %環境 は、次のものを有する: ◎ An environment is an object that identifies the settings of a current or potential execution environment. An environment has the following fields:

`~id@enV ◎ An id
%環境 を一意に識別する,不透明な文字列。 ◎ An opaque string that uniquely identifies this environment.
`作成時の~URL@enV ◎ A creation URL
%環境 が結付けられている資源の所在を表現している,`~URL$。 ◎ A URL that represents the location of the resource with which this environment is associated.
注記: `環境~設定群~obj$の事例では、この~URLは — `history.pushState$m などの仕組みに因り — `環境~設定群~obj$の`担当の文書$enVの`~URL$docとは別物にもなり得ることに注意。 ◎ In the case of an environment settings object, this URL might be distinct from the environment settings object's responsible document's URL, due to mechanisms such as history.pushState().
`~top-level作成時の~URL@enV ◎ A top-level creation URL
~NULL, または “~top-level” `環境$の`作成時の~URL$enVを表現する`~URL$ [ ~worker/~worklet ]用には ~NULL になる。 ◎ Null or a URL that represents the creation URL of the "top-level" environment. It is null for workers and worklets.
`~top-level生成元@enV ◎ A top-level origin
次のいずれか ⇒# 今の所は`実装定義$な値/ ~NULL/ `生成元$ ◎ A for now implementation-defined value, null, or an origin.\
“~top-level” 実行~環境になり得るもの用には ~NULL に(すなわち、まだ応答は無い)/ 他の場合は “~top-level” `環境$の`生成元$enVになる。 [ 専用~worker/~worklet ]用には、その作成元の`~top-level生成元$enVになる。 [ 共用~worker/~sw ]用には、`実装定義$な値になる。 ◎ For a "top-level" potential execution environment it is null (i.e., when there is no response yet); otherwise it is the "top-level" environment's origin. For a dedicated worker or worklet it is the top-level origin of its creator. For a shared or service worker it is an implementation-defined value.
注記: これは、[ ~sandbox法/~worker/~worklet ]が孕まれるときは、`~top-level作成時の~URL$enVの`生成元$urlとは別物になる。 ◎ This is distinct from the top-level creation URL's origin when sandboxing, workers, and worklets are involved.
`~target閲覧文脈@enV ◎ A target browsing context
~NULL, または `~navi要請$の~target`閲覧文脈$。 ◎ Null or a target browsing context for a navigation request.
【 `~navigate$される閲覧文脈。`~navigate~fetchを処理する$とき,非 ~NULL に設定される。 】
`作動中の~sw@enV ◎ An active service worker
~NULL, または %環境 を`制御-$xしている`~sw$。 ◎ Null or a service worker that controls the environment.
`実行~準備済み~flag@enV ◎ An execution ready flag
~T ならば、 %環境 はすでに設定しておかれたことを指示する。 初期~時は ~F とする。 ◎ A flag that indicates whether the environment setup is done. It is initially unset.

各種~仕様は、環境~用に `環境を破棄する手続き@ を定義してもヨイ。 この手続きは、入力として`環境$をとる。 ◎ Specifications may define environment discarding steps for environments. The steps take an environment as input.

注記: `環境を破棄する手続き$が走るのは、ごく限られた環境に限られる。 決して,実行~準備済みには — 例えば,読込むのに失敗したために — ならないものなど。 ◎ The environment discarding steps are run for only a select few environments: the ones that will never become execution ready because, for example, they failed to load.

8.1.3.2. 環境~設定群~obj

`環境~設定群~obj@ %設定群 とは、`環境$であることに加え,次を得るための各種~algoも指定するものである: ◎ An environment settings object is an environment that additionally specifies algorithms for:

`~realm実行~文脈@enV ◎ A realm execution context
%設定群 を利用するすべての `~script$x から共有される,`~JS実行~文脈$。 すなわち、これらの~scriptは,この`~JS~realm$内にある。 [ `古典~script$ / `~module~script$ ]を走らすときは、この実行~文脈が`~JS実行~文脈~stack$の一番上になり,その上に当の~scriptに特有な別の実行~文脈が~pushされる。 (こう設定しておけば、[ `ParseScript$jA / `~source~text~Module-Record$の `Evaluate$jA ]は,どの~Realmを利用するかを知れるようになる。) ◎ A JavaScript execution context shared by all scripts that use this settings object, i.e. all scripts in a given JavaScript realm. When we run a classic script or run a module script, this execution context becomes the top of the JavaScript execution context stack, on top of which another execution context specific to the script in question is pushed. (This setup ensures ParseScript and Source Text Module Record's Evaluate know which Realm to use.)
`~module~map@enV ◎ A module map
`~module~map$ — ~JS~moduleを~importするときに利用される。 ◎ A module map that is used when importing JavaScript modules.
担当の閲覧文脈【!廃】
【 この用語は原文から廃された。 しかしながら、まだ参照している仕様があるので残してある。 代わる用語は、[ %設定群 の`大域~obj$enV(これは、`~window$であることが含意される)に`対応する閲覧文脈$ ]になるであろう(~algoではなくなる)。 】
`担当の文書@enV ◎ A responsible document
[ %設定群 を利用する~scriptがとる動作 ]を担当するものとされる,`文書$。 ◎ A Document that is assigned responsibility for actions taken by the scripts that use this environment settings object.
例えば、`担当の文書$enVの`~URL$docは、`文書$の`~URL$docを設定するために利用される — それが `document.open()$m を利用して再設定された後に。 ◎ For example, the URL of the responsible document is used to set the URL of the Document after it has been reset using document.open().
`担当の~event~loop$enVが`~window~event~loop$でない場合、 %設定群 は,`担当の文書$enVを持たない。 ◎ If the responsible event loop is not a window event loop, then the environment settings object has no responsible document.
`~API用~URL文字~符号化法@enV ◎ An API URL character encoding
[ %設定群 を利用する~scriptから~callされる~API ]が,~URLを符号化するときに利用する文字~符号化法。 ◎ A character encoding used to encode URLs by APIs called by scripts that use this environment settings object.
`~API用~基底~URL@enV ◎ An API base URL
[ %設定群 を利用する~scriptから~callされる~API ]が,~URLを`相対的に構文解析-$するときに利用する`~URL$。 ◎ A URL used by APIs called by scripts that use this environment settings object to parse URLs.
`生成元@enV ◎ An origin
~security検査に利用される`生成元$。 ◎ An origin used in security checks.
`~referrer施策@enV ◎ A referrer policy
[ %設定群 を`要請~client$rqに利用して遂行される`~fetch$ ]用の,既定の`~referrer施策$。 `REFERRERPOLICY$r ◎ The default referrer policy for fetches performed using this environment settings object as a request client. [REFERRERPOLICY]
`埋込元~施策@enV ◎ An embedder policy
[ %設定群 を`要請~client$rqに利用して遂行される`~fetch$ ]用の`非同一-生成元~資源~施策~検査$に利用される`埋込元~施策$。 ◎ An embedder policy used by cross-origin resource policy checks for fetches performed using this environment settings object as a request client.
`非同一-生成元~隔離-済み能力@enV ◎ A cross-origin isolated capability
次を表現する真偽値 ⇒ %設定群 を利用する~scriptには、[ 非同一-生成元~隔離を要求する~API ]を利用することは,許容されるかどうか ◎ A boolean representing whether scripts that use this environment settings object are allowed to use APIs that require cross-origin isolation.

各 `環境~設定群~obj$に対しては、次も定義される:

`通知待ちの却下-済み~promise~list@enV
次項とともに, 未取扱いの~promise却下 を追跡するために利用される。
`未決の却下-済み~promiseへの弱い参照の集合@enV
~promiseへの弱い参照からなる集合 — これらのどの参照も強い参照ではないモノトスル。 実装はまた、含まれる参照の個数を自由に制限してよい — 例えば、新たな参照が追加されたときに,古いものを除去するなど。
◎ An environment settings object also has an outstanding rejected promises weak set and an about-to-be-notified rejected promises list, used to track unhandled promise rejections. The outstanding rejected promises weak set must not create strong references to any of its members, and implementations are free to limit its size, e.g. by removing old entries from it when new ones are added.

`環境~設定群~obj$の `担当の~event~loop@enV は、その`大域~obj$enVに`関連な~agent$の`~event~loop$aGとする。 ◎ An environment settings object's responsible event loop is its global object's relevant agent's event loop.

8.1.3.3. ~realm, 設定群~obj, 大域~obj

`大域~obj@ とは、`~JS~realm$の `GlobalObject^sl ~fieldである~JS~objである。 ◎ A global object is a JavaScript object that is the [[GlobalObject]] field of a JavaScript realm.

注記: この仕様では、すべての`~JS~realm$は,`大域~obj$として[ `Window$I, `WorkerGlobalScope$I ]いずれかの~objを伴って`作成-$rMされる。 ◎ In this specification, all JavaScript realms are created with global objects that are either Window or WorkerGlobalScope objects.

[ `~JS~realm$ %R, `大域~obj$ %G, `環境~設定群~obj$ %S ]は、常に,互いに 1:1:1 に対応する: ◎ There is always a 1-to-1-to-1 mapping between JavaScript realms, global objects, and environment settings objects:

  • %R 視点からは:

    • %R の `HostDefined^sl ~fieldが, %S を与える — %S を指して %R の `設定群~obj@rM という。
    • %R の `GlobalObject^sl ~fieldが, %G を与える — %G を指して %R の `大域~obj@rM という。
    ◎ A JavaScript realm has a [[HostDefined]] field, which contains the Realm's settings object. ◎ A JavaScript realm has a [[GlobalObject]] field, which contains the Realm's global object.
  • %G 視点からは:

    • この仕様における %G は、 %R が`作成-$rMされる間に作成される。 %R を指して %G の `~Realm@gL という。
    • この仕様における %G は、 %S と並行して作成される。 %S は %G に`関連な設定群~obj$と呼ばれる。
    ◎ Each global object in this specification is created during the creation of a corresponding JavaScript realm, known as the global object's Realm. ◎ Each global object in this specification is created alongside a corresponding environment settings object, known as its relevant settings object.
  • %S 視点からは:

    • %S の`~realm実行~文脈$enVの~Realm成分が, %R を与える — %R を指して %S の `~Realm@enV という。
    • %G (すなわち, %S の`~Realm$enVの `GlobalObject^sl ~field)を指して %S の `大域~obj@enV という。
    ◎ An environment settings object's realm execution context's Realm component is the environment settings object's Realm. ◎ An environment settings object's Realm then has a [[GlobalObject]] field, which contains the environment settings object's global object.

`~agent$ %~agent 内で `新たな~JS~realmを作成する@ ときは、次の手続きに従う: ◎ To create a new JavaScript 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. %~realm の~agent ~SET %~agent %~realm の~agentが何を指すかは、まだ~JS仕様に定義されていない — tc39/ecma262#1357 を見よ。 ◎ Set realm's agent to agent. This pointer is not yet defined in the JavaScript specification; see tc39/ecma262#1357.
  6. ~IF[ %~agent の`~agent~cluster$の`非同一-生成元~隔離-済み$ ~EQ ~F ]: ◎ If agent's agent cluster's cross-origin isolated is false, 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.

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

この仕様~全体を通して、~algoを成す手続きを定義するときに,どの`~JS~realm$が利用されるか — あるいは,同じことだが、どの`大域~obj$/`環境~設定群~obj$が利用されるか — を指示することが重要になることは、よくある。 一般に、少なくとも次の 4 種いずれかで指示される: ◎ When defining algorithm steps throughout this specification, it is often important to indicate what JavaScript realm is to be used—or, equivalently, what global object or environment settings object is to be used. In general, there are at least four possibilities:

`入口~某@ ( `entry^en 某)
これは、現在~走っている~script動作を起動した~scriptに対応する 【もしあれば】 : すなわち、[ 作者~codeの中へ~callした~UA ]の中へ~callした[ 関数/~script ]。 ◎ This corresponds to the script that initiated the currently running script action: i.e., the function or script that the user agent called into when it called into author code.
`現任の某@ ( `incumbent^en 某)

これは、作者による[ 関数/~script ]のうち,次のいずれかに該当するものに対応する:

  • ~stack上で最も近過去に入ったもの
  • 現在~走っている~callbackを 元々~scheduleしたもの
◎ This corresponds to the most-recently-entered author function or script on the stack, or the author function or script that originally scheduled the currently-running callback.
`現在の某@ ( `current^en 某)
これは、現在~走っている関数~objに対応する。 これには、~JSとして実装されていないかもしれないような,~UAに組込みの関数も含まれる(それは`現在の~JS~realm$から導出される)。 ◎ This corresponds to the currently-running function object, including built-in user-agent functions which might not be implemented as JavaScript. (It is derived from the current JavaScript realm.)
`某に関連な@ ( 某に relevant な)
どの`~platform~obj$にも`関連な~Realm$がある — それは概ね,その~objの作成-元である`~JS~realm$である。 ~algoを書くときに,[ `関連な~Realm$が重要になり得るような`~platform~obj$ ]として,真っ先に挙がるのは、現在~走っている関数~objの `this^jv 値になる。 一部の事例では、引数のそれなど,`関連な~Realm$が重要になるものが他にもあり得る。 ◎ Every platform object has a relevant Realm, which is roughly the JavaScript realm in which it was created. When writing algorithms, the most prominent platform object whose relevant Realm might be important is the this value of the currently-running function object. In some cases, there can be other important relevant Realms, such as those of any arguments.

[ `入口~某$ / `現任の某$ / `現在の某$ ]の概念は,限定句なしに利用-可能な一方で、`某に関連な$の概念は,特定0の`~platform~obj$に適用されなければナラナイことに注意。 ◎ Note how the entry, incumbent, and current concepts are usable without qualification, whereas the relevant concept must be applied to a particular platform object.

`現任の某$, `入口~某$ の概念は、あまりに複雑で直感的でないので,新たな仕様には利用されるべきでない。 既存の利用は,~platformからほぼ除去すべく~~策定が進められている。 `現任の某$ については, issue #1430 を、`入口~某$ については, issue #1431 を見よ。 ◎ The incumbent and entry concepts should not be used by new specifications, as they are excessively complicated and unintuitive to work with. We are working to remove almost all existing uses from the platform: see issue #1430 for incumbent, and issue #1431 for entry.

一般に,~web~platform仕様は、`某に関連な$の概念を,演算-対象の~obj(通例的には現在の~methodの `this^jv 値になる)に適用して利用するべきである。 これは、~JS仕様と合致していない — そこでは、一般に,`現在の某$が既定として利用されている(例: `Array.prototype.map^c の結果を構築する際に利用されるべき `Array^c 構築子が属する`~JS~realm$を決定するときなど)。 が、この不一致は,策定を進めるためには受容する必要があるものとして,~platformに埋込まれている。 ◎ In general, web platform specifications should use the relevant concept, applied to the object being operated on (usually the this value of the current method). This mismatches the JavaScript specification, where current is generally used as the default (e.g. in determining the JavaScript realm whose Array constructor should be used to construct the result in Array.prototype.map). But this inconsistency is so embedded in the platform that we have to accept it going forward.

次の各~pageを考える。 ここでは、 `a.html^s は~browser~window内に読込まれていて, `b.html^s は 示されているように `iframe$e 内に読込まれていて, `c.html^s, `d.html^s は省略されている(単純に,空~文書でもよい) とする: ◎ Consider the following pages, with a.html being loaded in a browser window, b.html being loaded in an iframe as shown, and c.html and d.html omitted (they can simply be empty documents):

<!-- a.html -->
<!DOCTYPE html>
<html lang="ja">
<title>入口~page</title>

<iframe src="b.html"></iframe>
<button onclick="frames[0].hello()">Hello</button>

<!--b.html -->
<!DOCTYPE html>
<html lang="ja">
<title>現任の~page</title>

<iframe src="c.html" id="c"></iframe>
<iframe src="d.html" id="d"></iframe>

<script>
  const %c = document.querySelector("#c").contentWindow;
  const %d = document.querySelector("#d").contentWindow;

  window.hello = () => {
    %c.print.call(%d);
  };
</script>

各~pageは、自前の`閲覧文脈$を有し,したがって自前の[ `~JS~realm$, `大域~obj$, `環境~設定群~obj$ ]を有する。 ◎ Each page has its own browsing context, and thus its own JavaScript realm, global object, and environment settings object.

`a.html^s 内の~buttonの押下げに呼応して `print()$m ~methodが~callされたときは: ◎ When the print() method is called in response to pressing the button in a.html, then:

  • `入口~Realm$は、 `a.html^s のそれになる。 ◎ The entry Realm is that of a.html.
  • `現任の~Realm$は、 `b.html^s のそれになる。 ◎ The incumbent Realm is that of b.html.
  • `現在の~Realm~Record$は、 `c.html^s のそれになる(走っている~codeは、 `c.html^s に属する `print()$m ~methodなので)。 ◎ The current Realm is that of c.html (since it is the print() method from c.html whose code is running).
  • `print()$m ~methodが~callされている~objに`関連な~Realm$は、 `d.html^s のそれになる。 ◎ The relevant Realm of the object on which the print() method is being called is that of d.html.

`某に関連な$の概念が,`現在の某$の概念よりも一般に良い既定になる理由の一つは、複数回にわたり返されるような持続的な~objを作成するときに,その方が相応しくなるからである。 例えば `getBattery()$m ~method `BATTERY$r は、それが呼出された `Navigator$I ~objに`関連な~Realm$内に~promiseを作成する。 これは、次に影響iする: ◎ One reason why the relevant concept is generally a better default choice than the current concept is that it is more suitable for creating an object that is to be persisted and returned multiple times. For example, the navigator.getBattery() method creates promises in the relevant Realm for the Navigator object on which it is invoked. This has the following impact: [BATTERY]

<!-- outer.html -->
<!DOCTYPE html>
<html lang="ja">
<title>関連な~Realmのデモ: outer ~page</title>
<script>
  function doTest() {
    const %promise = navigator.getBattery.call(frames[0].navigator);

    console.log(%promise instanceof Promise);           // logs false
    console.log(%promise instanceof frames[0].Promise); // logs true

    frames[0].hello();
  }
</script>
<iframe src="inner.html" onload="doTest()"></iframe>

<!-- inner.html -->
<!DOCTYPE html>
<html lang="ja">
<title>関連な~Realmのデモ: inner ~page</title>
<script>
  function hello() {
    const %promise = navigator.getBattery();

    console.log(%promise instanceof Promise);        // logs true
    console.log(%promise instanceof parent.Promise); // logs false
  }
</script>

`getBattery()$m ~methodの~algoが,代わりに`現在の~Realm~Record$を利用した場合、すべての結果が覆されることになる。 すなわち、 `outer.html^s 内の `getBattery()$m に対する最初の~callの後、 `inner.html^s 内の `Navigator$I ~objは, `outer.html^s の`~JS~realm$にて作成された `Promise^c ~objを恒久的に格納することになる結果、 `hello()^c 関数の内側における同様の~callは, “間違った” ~realmからの~promiseを返すことになる。 これは望ましくないので、~algoは、上の~commentで指示されるような~~分別のある結果を与える,`関連な~Realm$を代わりに利用する。 ◎ If the algorithm for the getBattery() method had instead used the current Realm, all the results would be reversed. That is, after the first call to getBattery() in outer.html, the Navigator object in inner.html would be permanently storing a Promise object created in outer.html's JavaScript realm, and calls like that inside the hello() function would thus return a promise from the "wrong" realm. Since this is undesirable, the algorithm instead uses the relevant Realm, giving the sensible results indicated in the comments above.


この節の以降では、[ `入口~某$, `現任の某$, `現在の某$, `某に関連な$ ]の概念について,正式に定義する。 ◎ The rest of this section deals with formally defining the entry, incumbent, current, and relevant concepts.

8.1.3.3.1. 入口~某

~script~call時の処理- は、`~realm実行~文脈$enVを,`~JS実行~文脈~stack$に — 他の`~JS実行~文脈$の合間に挟みながら — [ ~push/~pop ]することになる。 ◎ The process of calling scripts will push or pop realm execution contexts onto the JavaScript execution context stack, interspersed with other execution contexts.

これをもって, `入口~実行~文脈@ は、`~JS実行~文脈~stack$内の~itemのうち,最も近過去に~pushされた`~realm実行~文脈$enVとして定義される。 `入口~Realm@ は、`入口~実行~文脈$の~Realm成分で与えられる。 ◎ With this in hand, we define the entry execution context to be the most recently pushed item in the JavaScript execution context stack that is a realm execution context. The entry Realm is the entry execution context's Realm component.

これにより、次も定義される: ◎ ↓

  • `入口~設定群~obj@ は、`入口~Realm$の`設定群~obj$rMである。 ◎ Then, the entry settings object is the environment settings object of the entry Realm.
  • `入口~大域~obj@ は、`入口~Realm$の`大域~obj$rMである。 ◎ Similarly, the entry global object is the global object of the entry Realm.
8.1.3.3.2. 現任の某

各`~JS実行~文脈$は、自身の~code評価~状態を成す一部として, `現任の決定-時に飛ばす~counter@ 値 — 初期~時は 0 とする — を包含するモノトスル。 この値は、[ `~callbackを走らすために準備する$ / `走らせた~callbackを片付ける$ ]処理-において,増減されることになる。 ◎ All JavaScript execution contexts must contain, as part of their code evaluation state, a skip-when-determining-incumbent counter value, which is initially zero. In the process of preparing to run a callback and cleaning up after running a callback, this value will be incremented and decremented.

どの`~event~loop$にも, `予備の現任の設定群~obj~stack@ が結付けられ、初期~時は空にされる。 それは 大雑把に言えば、[ ~stack上に作者~codeは無いが、走らされた現在の~algoは,作者~codeが 何らかの仕方で担当している ]ときに,`現任の設定群~obj$を決定するために利用される。 この~stackは,[ `~callbackを走らすために準備する$ / `走らせた~callbackを片付ける$ ]処理-から操作される。 `WEBIDL$r ◎ Every event loop has an associated backup incumbent settings object stack, initially empty. Roughly speaking, it is used to determine the incumbent settings object when no author code is on the stack, but author code is responsible for the current algorithm having been run in some way. The process of preparing to run a callback and cleaning up after running a callback manipulate this stack. [WEBIDL]

[ ~Web~IDLを利用して 作者~codeを`呼出す$x / `HostEnqueuePromiseJob$A が~promise~jobを呼出す ]とき、それは,以下に与える各種~algoを利用して[ `現任の設定群~obj$を決定するための関連な~data ]を追跡する: ◎ When Web IDL is used to invoke author code, or when HostEnqueuePromiseJob invokes a promise job, they use the following algorithms to track relevant data for determining the incumbent settings object:

`~callbackを走らすために準備する@ ときは、所与の ( `環境~設定群~obj$ %設定群 ) に対し,次を走らす: ◎ To prepare to run a callback with an environment settings object settings:

  1. `予備の現任の設定群~obj~stack$に %設定群 を~pushする ◎ Push settings onto the backup incumbent settings object stack.
  2. %文脈 ~LET `最上端の~scriptを有する実行~文脈$ ◎ Let context be the topmost script-having execution context.
  3. ~IF[ %文脈 ~NEQ ~NULL ] ⇒ %文脈 の`現任の決定-時に飛ばす~counter$ ~INCBY 1 ◎ If context is not null, increment context's skip-when-determining-incumbent counter.

`走らせた~callbackを片付ける@ ときは、所与の ( `環境~設定群~obj$ %設定群 ) に対し,次に従う: ◎ To clean up after running a callback with an environment settings object settings:

  1. %文脈 ~LET `最上端の~scriptを有する実行~文脈$ ◎ Let context be the topmost script-having execution context.

    注記: これは、この手続きの呼出nと対にされた[ `~callbackを走らすために準備する$呼出n ]の内側の,`最上端の~scriptを有する実行~文脈$と同じになる。 ◎ This will be the same as the topmost script-having execution context inside the corresponding invocation of prepare to run a callback.

  2. ~IF[ %文脈 ~NEQ ~NULL ] ⇒ %文脈 の`現任の決定-時に飛ばす~counter$ ~DECBY 1 ◎ If context is not null, decrement context's skip-when-determining-incumbent counter.
  3. ~Assert: `予備の現任の設定群~obj~stack$の最上端の~entry ~EQ %設定群 ◎ Assert: the topmost entry of the backup incumbent settings object stack is settings.
  4. `予備の現任の設定群~obj~stack$から %設定群 を除去する ◎ Remove settings from the backup incumbent settings object stack.

ここで, `最上端の~scriptを有する実行~文脈@ は、[ `~JS実行~文脈~stack$の最上端の~entry %~entry が[ %~entry の~ScriptOrModule成分 ~NEQ ~NULL ]を満たすならば %~entry / ~ELSE_ ~NULL ]とする。 ◎ Here, the topmost script-having execution context is the topmost entry of the JavaScript execution context stack that has a non-null ScriptOrModule component, or null if there is no such entry in the JavaScript execution context stack.

以上をふまえた下で, `現任の設定群~obj@ は、次に従って決定される: ◎ With all this in place, the incumbent settings object is determined as follows:

  1. %文脈 ~LET `最上端の~scriptを有する実行~文脈$ ◎ Let context be the topmost script-having execution context.
  2. ~IF[ %文脈 ~EQ ~NULL ]~OR[ %文脈 の`現任の決定-時に飛ばす~counter$ ~GT 0 ]: ◎ If context is null, or if context's skip-when-determining-incumbent counter is greater than zero, then:

    1. ~Assert: `予備の現任の設定群~obj~stack$は空でない ◎ Assert: the backup incumbent settings object stack is not empty.

      注記: この ~Assert は、[[ ~scriptを~callする / ~Web~IDLにより ~callbackを`呼出す$x ]ことにより誘発されたものではない~algo ]の内側から`現任の設定群~obj$を得しようと試行したときには,失敗することになる。 例えば、[ `~event~loop$の一部として定期的に走る~algoであって,作者~codeは孕まれていないもの ]が,それを試行したときなど。 そのような事例では、`現任の某$ の概念は利用できない。 ◎ This assert would fail if you try to obtain the incumbent settings object from inside an algorithm that was triggered neither by calling scripts nor by Web IDL invoking a callback. For example, it would trigger if you tried to obtain the incumbent settings object inside an algorithm that ran periodically as part of the event loop, with no involvement of author code. In such cases the incumbent concept cannot be used.

    2. ~RET `予備の現任の設定群~obj~stack$の最上端の~entry ◎ Return the topmost entry of the backup incumbent settings object stack.
  3. ~RET %文脈 の~Realm成分の`設定群~obj$rM ◎ Return context's Realm component's settings object.

以上により、次も定義される: ◎ ↓

  • `現任の~Realm@ は、`現任の設定群~obj$の`~Realm$enVである。 ◎ Then, the incumbent Realm is the Realm of the incumbent settings object.
  • `現任の大域~obj@ は、`現任の設定群~obj$の`大域~obj$enVである。 ◎ Similarly, the incumbent global object is the global object of the incumbent settings object.

以下に示す一連の例は、各種 仕組みが `現任の某$ の概念の定義にどう関わるかを,はっきりさせるために意図されている: ◎ The following series of examples is intended to make it clear how all of the different mechanisms contribute to the definition of the incumbent concept:

手始めに,次の例を考える: ◎ Consider the following starter example:

<!DOCTYPE html>
<iframe></iframe>
<script>
  frames[0].postMessage("some data", "*");
</script>

ここで,注目する`環境~設定群~obj$には、[ `window^c のそれ, `frames[0]^c のそれ ]の 2 つがある。 ここでの懸案は、 `postMessage()$m 用の~algoを実行する時点で,何が`現任の設定群~obj$になるか? である。 ◎ There are two interesting environment settings objects here: that of window, and that of frames[0]. Our concern is: what is the incumbent settings object at the time that the algorithm for postMessage() executes?

その~algoを起こした担当の作者~scriptは, `frames[0]^c ではなく `window^c 内で実行されているので、直感的に捉えるなら,`window^c のそれになるべきである。 これはイミを成す: `~windowに~messageを投函する手続き$は、`現任の設定群~obj$を利用して,結果の `MessageEvent$I の `source$m ~propを決定する — この事例では、当の~messageの~sourceは,確かに `window^c になる。 ◎ It should be that of window, to capture the intuitive notion that the author script responsible for causing the algorithm to happen is executing in window, not frames[0]. This makes sense: the window post message steps use the incumbent settings object to determine the source property of the resulting MessageEvent, and in this case window is definitely the source of the message.

上で与えた手続きが、直感的に欲される結果として, `window^c に`関連な設定群~obj$をどう与えてくれるかを以下に説明する。 ◎ Let us now explain how the steps given above give us our intuitively-desired result of window's relevant settings object.

`~windowに~messageを投函する手続き$が`現任の設定群~obj$を検索するとき、`最上端の~scriptを有する実行~文脈$は, `script$e 要素に対応している それになる。 それは、`古典~scriptを走らす$~algoの間に, `ScriptEvaluation$jA() の一部として,`~JS実行~文脈~stack$に~pushされたものである。 ~Web~IDL~callbackの呼出nは孕まれないので、この文脈の`現任の決定-時に飛ばす~counter$は 0 であり、したがってそれが,`現任の設定群~obj$を決定するために利用される。 その結果は、 `window^c の`環境~設定群~obj$になる。 ◎ When the window post message steps look up the incumbent settings object, the topmost script-having execution context will be that corresponding to the script element: it was pushed onto the JavaScript execution context stack as part of ScriptEvaluation during the run a classic script algorithm. Since there are no Web IDL callback invocations involved, the context's skip-when-determining-incumbent counter is zero, so it is used to determine the incumbent settings object; the result is the environment settings object of window.

( `frames[0]^c の`環境~設定群~obj$は, `postMessage()$m ~methodが~callされた時点でコレに`関連な設定群~obj$になるので、~messageの`宛先^emを決定するときには,それが孕まれることに注意。 その一方,`~source^emを決定するときには、現任の某が利用される。) ◎ (Note how the environment settings object of frames[0] is the relevant settings object of this at the time the postMessage() method is called, and thus is involved in determining the target of the message. Whereas the incumbent is used to determine the source.)

次に、もっと複雑な例を考える: ◎ Consider the following more complicated example:

<!DOCTYPE html>
<iframe></iframe>
<script>
  const %bound = frames[0].postMessage.bind(frames[0], "some data", "*");
  window.setTimeout(%bound);
</script>

この例は,前の例によく似るが、 `Function.prototype.bind^c を通して間接-化され, `setTimeout()$m も伴う。 それでも,答えは同じになるべきである — `現任の某$の概念は、非同期な~algoの呼出ngにより変化するべきでない。 ◎ This example is very similar to the previous one, but with an extra indirection through Function.prototype.bind as well as setTimeout(). But, the answer should be the same: invoking algorithms asynchronously should not change the incumbent concept.

今回の結果は、より複雑な仕組みを孕む: ◎ This time, the result involves more complicated mechanisms:

%bound が ~Web~IDL~callback型に`変換-$xされるとき、`現任の設定群~obj$は,(上の手始めの例と同じ方式で) `window^c に対応しているそれになる。 ~Web~IDLは、これを,結果の~callback値の`~callback文脈$として格納する。 ◎ When bound is converted to a Web IDL callback type, the incumbent settings object is that corresponding to window (in the same manner as in our starter example above). Web IDL stores this as the resulting callback value's callback context.

`setTimeout()$m により~postされた`~task$が実行されるとき、その~task用の~algoは,~Web~IDLを利用して 格納された~callback値を`呼出す$x。 それに応じて、~Web~IDLは,上述した[ `~callbackを走らすために準備する$ ]~algoを~callする。 これは、格納された`~callback文脈$を,`予備の現任の設定群~obj~stack$に~pushする。 この時点(~timer~taskの内側)では,その~stack上には作者~codeは無いので、`最上端の~scriptを有する実行~文脈$は ~NULL であり,`現任の決定-時に飛ばす~counter$は増やされない。 ◎ When the task posted by setTimeout() executes, the algorithm for that task uses Web IDL to invoke the stored callback value. Web IDL in turn calls the above prepare to run a callback algorithm. This pushes the stored callback context onto the backup incumbent settings object stack. At this time (inside the timer task) there is no author code on the stack, so the topmost script-having execution context is null, and nothing gets its skip-when-determining-incumbent counter incremented.

次に、~callbackの呼出ngは, %bound を~callする。 それに応じて、 `frames[0]^c の `postMessage()$m ~methodが~callされる。 `postMessage()$m ~algoが`現任の設定群~obj$を検索するとき,~stack上にはまだ作者~codeはない — `bound()^c 関数は、単に組込みの~methodを直に~callするだけなので。 よって、`最上端の~scriptを有する実行~文脈$は ~NULL になる: `~JS実行~文脈$ ~stackは、 `postMessage()$m に対応している実行~文脈 — それも,`ScriptEvaluation$jA 文脈や,それに類するものを伴わないもの — のみを包含する。 ◎ Invoking the callback then calls bound, which in turn calls the postMessage() method of frames[0]. When the postMessage() algorithm looks up the incumbent settings object, there is still no author code on the stack, since the bound function just directly calls the built-in method. So the topmost script-having execution context will be null: the JavaScript execution context stack only contains an execution context corresponding to postMessage(), with no ScriptEvaluation context or similar below it.

`予備の現任の設定群~obj~stack$に~fall-backするのは、ここである。 上で注記したとおり、この~stackは,最上端の~entryとして `window^c に`関連な設定群~obj$を包含することになる。 よって、それが `postMessage()$m ~algoを実行している間に`現任の設定群~obj$として利用されるものになる。 ◎ This is where we fall back to the backup incumbent settings object stack. As noted above, it will contain as its topmost entry the relevant settings object of window. So that is what is used as the incumbent settings object while executing the postMessage() algorithm.

~~最後に、もっと込み入った例を考える: ◎ Consider this final, even more convoluted example:

<!-- a.html -->
<!DOCTYPE html>
<button>click me</button>
<iframe></iframe>
<script>
const %bound = frames[0].location.assign.bind(
    frames[0].location,
    "https://example.com/"
);
document.querySelector("button").addEventListener("click", %bound);
</script>
<!-- b.html -->
<!DOCTYPE html>
<iframe src="a.html"></iframe>
<script>
  const %iframe = document.querySelector("iframe");
  %iframe.onload = function onLoad() {
    %iframe.contentWindow.document.querySelector("button").click();
  };
</script>

ここでも,注目する`環境~設定群~obj$には、[ `a.html^c のそれ, `b.html^c のそれ ]の 2 つがある。 `assign()$m ~methodが`~Location~objにより~navigate$する~algoを誘発するとき、何が`現任の設定群~obj$になるか? それは、前のように直感的には, `a.html^c のそれになるべきである: `click$et ~listenerは,元々は `a.html^c により~scheduleされたので、 `b.html^c を孕んでいる何かが その~listenerを発火させたとしても, `現任の某$が担当するのは `a.html^c のそれになる。 ◎ Again there are two interesting environment settings objects in play: that of a.html, and that of b.html. When the location.assign() method triggers the Location-object navigate algorithm, what will be the incumbent settings object? As before, it should intuitively be that of a.html: the click listener was originally scheduled by a.html, so even if something involving b.html causes the listener to fire, the incumbent responsible is that of a.html.

ここでの~callbackに対する~~設定は、前の例に類似する: %bound が ~Web~IDL~callback型に`変換-$xされるとき、`現任の設定群~obj$は, `a.html^c に対応しているそれになり、~callbackの`~callback文脈$に格納される。 ◎ The callback setup is similar to the previous example: when bound is converted to a Web IDL callback type, the incumbent settings object is that corresponding to a.html, which is stored as the callback's callback context.

`b.html^c の内側で `click$m ~methodが~callされたとき、~methodは, `a.html^c の内側にある~buttonへ向けて `click$et ~eventを`配送-$する。 この~event配送-の一部として,`~callbackを走らすために準備する$~algoが実行される時点では、~stack上には作者~codeが`ある^em。 `最上端の~scriptを有する実行~文脈$は、 `onLoad()^c 関数のそれであり,その`現任の決定-時に飛ばす~counter$は 増やされる。 加えて、 `a.html^c の`環境~設定群~obj$( `EventHandler$I の`~callback文脈$として格納されている)が,`予備の現任の設定群~obj~stack$に~pushされる。 ◎ When the click() method is called inside b.html, it dispatches a click event on the button that is inside a.html. This time, when the prepare to run a callback algorithm executes as part of event dispatch, there is author code on the stack; the topmost script-having execution context is that of the onLoad function, whose skip-when-determining-incumbent counter gets incremented. Additionally, a.html's environment settings object (stored as the EventHandler's callback context) is pushed onto the backup incumbent settings object stack.

この時点で[ `~Location~objにより~navigate$する~algoが`現任の設定群~obj$を検索する ]ときの,`最上端の~scriptを有する実行~文脈$は、依然として `onLoad^c 関数 のそれである( `bound()^c 関数を~callbackとして利用している事実に因る)。 しかしながら,その`現任の決定-時に飛ばす~counter$ 値は 1 なので、`予備の現任の設定群~obj~stack$に~fall-backする。 これは、期待されるように `a.html^c の`環境~設定群~obj$を与えてくれる。 ◎ Now, when the Location-object navigate algorithm looks up the incumbent settings object, the topmost script-having execution context is still that of the onLoad function (due to the fact we are using a bound function as the callback). Its skip-when-determining-incumbent counter value is one, however, so we fall back to the backup incumbent settings object stack. This gives us the environment settings object of a.html, as expected.

これは、 ~navigateするのは `a.html^c の内側の `iframe$e であっても, `~source閲覧文脈$として利用されるのは `a.html^c 自身であることを意味することに注意。 それが、`要請~client$rqを決定する。 たぶんこれが、 ~web~platform上で,現任の某の概念の利用を正当化できる唯一のものである。 他のすべての事例における その概念の利用は,単に~~理解を難しくするだけであり、いつの日か[ `現在の某$ / `某に関連な$ ]のうち適切な方を利用するよう切替えられるものと希望されている。 ◎ Note that this means that even though it is the iframe inside a.html that navigates, it is a.html itself that is used as the source browsing context, which determines among other things the request client. This is perhaps the only justifiable use of the incumbent concept on the web platform; in all other cases the consequences of using it are simply confusing and we hope to one day switch them to use current or relevant as appropriate.

8.1.3.3.3. 現在の某

~JS仕様は、 `現在の~Realm~Record$を定義している — “現在の~Realm” と略称されるときもある。 `JAVASCRIPT$r ◎ The JavaScript specification defines the current Realm Record, sometimes abbreviated to the "current Realm". [JAVASCRIPT]

これにより、次も定義される: ◎ ↓

  • `現在の設定群~obj@ は、`現在の~Realm~Record$の`設定群~obj$rMである。 ◎ Then, the current settings object is the environment settings object of the current Realm Record.
  • `現在の大域~obj@ は、`現在の~Realm~Record$の`大域~obj$rMである。 ◎ Similarly, the current global object is the global object of the current Realm Record.
8.1.3.3.4. 某に関連な

所与の`~platform~obj$ %O に対し: ◎ ↓

  • %O に `関連な~Realm@ は、 %O の `Realm$sl ~fieldの値で与えられる。 ◎ The relevant Realm for a platform object is the value of its [[Realm]] field.
  • %O に `関連な設定群~obj@ は、 %O に`関連な~Realm$の`設定群~obj$rMを指す。 ◎ Then, the relevant settings object for a platform object o is the environment settings object of the relevant Realm for o.
  • %O に `関連な大域~obj@ は、 %O に`関連な~Realm$の`大域~obj$rMを指す。 ◎ Similarly, the relevant global object for a platform object o is the global object of the relevant Realm for o.

8.1.3.4. ~scriptingの可能化-法と不能化-法

所与の時点で,`環境~設定群~obj$ %設定群 用の `~scriptingは可能化されて@ いるとは、次に挙げる条件~すべてが満たされることをいう: ◎ Scripting is enabled for an environment settings object settings when all of the following conditions are true:

  • ~UAは~scriptingを~supportする。 ◎ The user agent supports scripting.
  • ~FINGERPRINTING この時点で、利用者は, %設定群 用の~scriptingを不能化していない。 (~UAは、利用者に~scriptingを ~~全面的に, あるいは~~細部的に — 例えば,個別の生成元ごとに, 個別の`環境~設定群~obj$の~levelまで降りて — 不能化する選択肢を供してもヨイ) ◎ (This is a tracking vector.) The user has not disabled scripting for settings at this time. (User agents may provide users with the option to disable scripting globally, or in a finer-grained manner, e.g., on a per-origin basis, down to the level of individual environment settings objects.)
  • [ %設定群 の`大域~obj$enVは`~window$でない ]~OR[ `閲覧文脈~sandbox化( ~script )~flag$ ~NIN [ %設定群 の`大域~obj$enVに`結付けられている文書$の`作動中の~sandbox法~flag集合$ ] ◎ Either settings's global object is not a Window object, or settings's global object's associated Document's active sandboxing flag set does not have its sandboxed scripts browsing context flag set.

所与の時点で,`環境~設定群~obj$用の `~scriptingは不能化されて@ いるとは、上の否定 — `~scriptingは可能化されて$いない — ことを意味する。 ◎ Scripting is disabled for an environment settings object when scripting is not enabled for it, i.e., when any of the above conditions are false.


`~node用の~scriptingは可能化されて@ いるとは、所与の~node %~node に対し,[ %~node の`~node文書$が`属する閲覧文脈$ %B ~NEQ ~NULL ], かつ[ %~node に`関連な設定群~obj$用の`~scriptingは可能化されて$いる ]ことを意味する。 ◎ Scripting is enabled for a node node if node's node document's browsing context is non-null, and scripting is enabled for node's relevant settings object.

`~node用の~scriptingは不能化されて@ いるとは、上の否定 — `~node用の~scriptingは可能化されて$いない — ことを意味する。 ◎ Scripting is disabled for a node when scripting is not enabled, i.e., when its node document's browsing context is null or when scripting is disabled for its relevant settings object.

8.1.3.5. ~secureな文脈

所与の`環境$ %環境 は、次の~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[ 次が満たされるならば ~T / ~ELSE_ ~F ] ⇒ %大域~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 [ 次が満たされるならば ~T / ~ELSE_ ~F ] ⇒ `~URLは信用に価し得るか?$( %環境 の`~top-level作成時の~URL$enV ) ~EQ `価し得る^i ◎ 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.

8.1.4. ~script処理~model

8.1.4.1. ~script

`~script@ は、 2 種の`構造体$に大別される。 いずれにせよ、各~scriptは次の~itemを有する: ◎ A script is one of two possible structs. All scripts have:

`設定群~obj@sC ◎ A settings object
`環境~設定群~obj$ — 同じ文脈に属する他の~scriptと共有されるような,種々の設定を包含する。 ◎ An environment settings object, containing various settings that are shared with other scripts in the same context.
`~record@sC ◎ A record
[ 構文解析に失敗したことを表現する ~NULL ], または[ 構文解析された~script ]を表現する次のいずれか ⇒# `Script Record$js — `古典~script$用/ `~source~text~Module-Record$ — `~module~script$用 ◎ Either a Script Record, for classic scripts; a Source Text Module Record, for module scripts; or null. In the former two cases, it represents a parsed script; null represents a failure parsing.
`構文解析-~error@sC ◎ A parse error
~JS値。 意味があるのは、`~record$sC ~EQ ~NULL の場合に限られ、対応する~script~source~textを構文解析できなかったことを指示する。 ◎ A JavaScript value, which has meaning only if the record is null, indicating that the corresponding script source text could not be parsed.
注記: この値は、~scriptの作成-時における即時な構文解析-~errorを内部的に追跡するために利用され,直に利用されることはない。 この~scriptが “何か間違った” か決定するときには、代わりに,`再投出-用~error$sCにアタること。 ◎ This value is used for internal tracking of immediate parse errors when creating scripts, and is not to be used directly. Instead, consult the error to rethrow when determining "what went wrong" for this script.
`再投出-用~error@sC ◎ An error to rethrow
評価を成功させなくする~errorを表現している,~JS値。 ~scriptを走らすよう試みられたときには、これが再~投出されることになる。 ◎ A JavaScript value representing an error that will prevent evaluation from succeeding. It will be re-thrown by any attempts to run the script.
注記: これは,当の~scriptの`構文解析-~error$sCにもなり得るが、`~module~script$の事例では,代わりに[ そのいずれかの依存物における`構文解析-~error$sC / `~module指定子を解決する$ときの~error ]にもなり得る。 ◎ This could be the script's parse error, but in the case of a module script it could instead be the parse error from one of its dependencies, or an error from resolve a module specifier.
注記: この例外~値は~JS仕様により供され,決して ~NULL にならないことはわかっているので、~errorは生じなかったことを通達するときには, ~NULL を利用することにする。 ◎ Since this exception value is provided by the JavaScript specification, we know that it is never null, so we use null to signal that no error has occurred.
`~fetch~options@sC ◎ Fetch options
`~script~fetch~options$ — [ この~script, および それが~importする`~module~script$ ]を~fetchするときに関係する,様々な~optionを包含する。 ◎ A script fetch options, containing various options related to fetching this script or module scripts that it imports.
`基底~URL@sC ◎ A base URL
`~module指定子を解決する$ときに利用される基底~URL。 これは、外部~module~scriptに対しては,~scriptが得された~URLになり、~inline~scriptに対しては,それを包含している文書の`基底~URL$になる。 ◎ A base URL used for resolving module specifiers. This will either be the URL from which the script was obtained, for external scripts, or the document base URL of the containing document, for inline scripts.

`古典~script@ は、`~script$の一種であり,次の`~item$も有する: ◎ A classic script is a type of script that has the following additional item:

`~errorは黙秘する@sC ◎ A muted errors boolean
真偽値。 ~T ならば、この~scriptにおける~errorに対しては,~error情報は供されなくなる。 ~private情報を漏洩し得る非同一-生成元~scriptに対し、~errorを黙秘するために利用される。 ◎ A boolean which, if true, means that error information will not be provided for errors in this script. This is used to mute errors for cross-origin scripts, since that can leak private information.

`~module~script@ も`~script$の一種であるが、追加的な~itemは有さない。 ◎ A module script is another type of script. It has no additional items.

`作動中の~script@ は、次の~algoにより決定される: ◎ The active script is determined by the following algorithm:

  1. %~record ~LET `GetActiveScriptOrModule$jA() ◎ Let record be GetActiveScriptOrModule().
  2. ~IF[ %~record ~EQ ~NULL ] ⇒ ~RET ~NULL ◎ If record is null, return null.
  3. ~RET %~record . `HostDefined^sl ◎ Return record.[[HostDefined]].

注記: `作動中の~script$の概念が利用されるのは、 `import()$m 特能が[ 相対~module指定子を解決するために,利用する`基底~URL$sCを決定するとき ]の他にない。 ◎ The active script concept is so far only used by the import() feature, to determine the base URL to use for resolving relative module specifiers.

8.1.4.2. ~scriptの~fetch法

この節では、~scriptを~fetchするための各種~algoを導入する。 それらは、種々の必要な入力から[ `古典~script$, または`~module~script$ ]を得る。 ◎ This section introduces a number of algorithms for fetching scripts, taking various necessary inputs and resulting in classic or module scripts.


`~script~fetch~options@ は、次の`~item$を有する`構造体$である: ◎ Script fetch options is a struct with the following items:

`暗号用~nonce@sfO
初期~fetchに, および ~importした~moduleを~fetchするときに利用される,`暗号用~nonce~metadata$rq。 ◎ The cryptographic nonce metadata used for the initial fetch and for fetching any imported modules
`完全性~metadata@sfO
初期~fetchに利用される,`完全性~metadata$rq。 ◎ The integrity metadata used for the initial fetch
`構文解析器~metadata@sfO
初期~fetchに, および ~importした~moduleを~fetchするときに利用される,`構文解析器~metadata$rq。 ◎ The parser metadata used for the initial fetch and for fetching any imported modules
`資格証~mode@sfO
初期~fetchに, および — `~module~script$の場合に限り — ~importした~moduleを~fetchするときに利用される,`資格証~mode$rq。 ◎ The credentials mode used for the initial fetch (for module scripts) and for fetching any imported modules (for both module scripts and classic scripts)
`~referrer施策@sfO
初期~fetch, および ~importした~moduleを~fetchするときに利用される,`~referrer施策$rq。 ◎ The referrer policy used for the initial fetch and for fetching any imported modules

注記: `古典~script$は、 `import()$m 特能を介して`~module~script$を~importできることに~~留意されたし。 ◎ Recall that via the import() feature, classic scripts can import module scripts.

`既定の古典~script~fetch~options@ は、次のようにされた`~script~fetch~options$である ⇒# `暗号用~nonce$sfO ~SET 空~文字列, `完全性~metadata$sfO ~SET 空~文字列, `構文解析器~metadata$sfO ~SET `not-parser-inserted^l, `資格証~mode$sfO ~SET `same-origin^l, `~referrer施策$sfO ~SET 空~文字列 ◎ The default classic script fetch options are 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 "same-origin", and referrer policy is the empty string.

所与の ( `要請$ %要請, `~script~fetch~options$ %~options ) に対し,次が定義される: ◎ Given a request request and a script fetch options options, we define:

  • `古典~script要請を設定しておく@ ときは、次のように %要請 を設定する ⇒# `暗号用~nonce~metadata$rq ~SET %~options の`暗号用~nonce$sfO, `完全性~metadata$rq ~SET %~options の`完全性~metadata$sfO, `構文解析器~metadata$rq ~SET %~options の`構文解析器~metadata$sfO, `~referrer施策$rq ~SET %~options の`~referrer施策$sfO ◎ set up the classic script request • Set request's cryptographic nonce metadata to options's cryptographic nonce, its integrity metadata to options's integrity metadata, its parser metadata to options's parser metadata, and its referrer policy to options's referrer policy.
  • `~module~script要請を設定しておく@ ときは、次のように %要請 を設定する ⇒# `暗号用~nonce~metadata$rq ~SET %~options の`暗号用~nonce$sfO, `完全性~metadata$rq ~SET %~options の`完全性~metadata$sfO, `構文解析器~metadata$rq ~SET %~options の`構文解析器~metadata$sfO, `資格証~mode$rq ~SET %~options の`資格証~mode$sfO, `~referrer施策$rq ~SET %~options の`~referrer施策$sfO ◎ set up the module script request • Set request's cryptographic nonce metadata to options's cryptographic nonce, its integrity metadata to options's integrity metadata, its parser metadata to options's parser metadata, its credentials mode to options's credentials mode, and its referrer policy to options's referrer policy.

`子孫~script~fetch~options@ は、所与の ( `~script~fetch~options$ %~options ) に対し,次のようにされた新たな`~script~fetch~options$を返す ⇒# `完全性~metadata$sfO ~SET 空~文字列, 他のすべての`~item$は %~options と同じ値 ◎ For any given script fetch options options, the descendant script fetch options are a new script fetch options whose items all have the same values, except for the integrity metadata, which is instead the empty string.


これらの~algoを利用する仕様は、任意選択で `~fetchを遂行する@ ~custom~hookを給して,~algoを~custom化できる — この~custom~hookは、次のように指定されなければナラナイ: ◎ The algorithms below can be customized by optionally supplying a custom perform the fetch hook,\

  • ( `要請$, %~top-level内~flag ~IN { `~top-level内@i, ε } ) を入力にとる。 ◎ which takes a request and an is top-level flag.\
  • `応答$を結果とする(`~network~error$も可)。 ◎ The algorithm must complete with a response (which may be a network error),\
  • `~workerが~importした古典~scriptを~fetchする$ときは,結果を同期的に返し、他の場合は,`非同期に完了-$する。 ◎ either synchronously (when using fetch a classic worker-imported script) or asynchronously (otherwise).\

上の %~top-level内~flag は:

  • [ `古典~script$に対する すべての~fetch, および[ `外部~module~script~graphを~fetchする$ / `~module~worker~script~graphを~fetchする$ / `~import_~script~graphを~fetchする$ ]ときの初期~fetch ]に対しては, `~top-level内$i にされる
  • [ ~module~script~graphを通り抜ける間に遭遇した `import^c 文 ]による結果の~fetchに対しては, ε にされる。
◎ The is top-level flag will be set for all classic script fetches, and for the initial fetch when fetching an external module script graph, fetching a module worker script graph, or fetching an import() module script graph, but not for the fetches resulting from import statements encountered throughout the graph.

注記: `~fetchを遂行する$~hookを給さない,既定の場合では、以下の~algoは,単純に 所与の`要請$を`~fetch$することになるが、[ `要請$, および 結果の`応答$の検証 ]に対する~algoに特有な~custom化も伴う。 ◎ By default, not supplying the perform the fetch will cause the below algorithms to simply fetch the given request, with algorithm-specific customizations to the request and validations of the resulting response.

~algoに特有な~custom化の上層に,自前の~custom化を重ねたい仕様~策定者は、次のような`~fetchを遂行する$~hookを給すること ⇒ 所与の`要請$を改変して, それを`~fetch$して, 結果の`応答$に対する特有な検証を遂行する(検証に失敗したなら`~network~error$で完了する) ◎ To layer your own customizations on top of these algorithm-specific ones, supply a perform the fetch hook that modifies the given request, fetches it, and then performs specific validations of the resulting response (completing with a network error if the validations fail).

この~hookは、もっと微妙な~custom化を遂行するためにも利用できる — `応答$を~cacheしておいて,`~fetch$をまったく遂行せずに済ませるためなど。 ◎ The hook can also be used to perform more subtle customizations, such as keeping a cache of responses and avoiding performing a fetch at all.

注記: Service Workers `SW$r は、この~hookとして自前の~optionを与えて,これらの~algoを走らす仕様の例である。 ◎ Service Workers is an example of a specification that runs these algorithms with its own options for the hook. [SW]


各種~algo自体は、ここから: ◎ Now for the algorithms themselves.

`古典~scriptを~fetchする@ ときは、所与の ( %~url, %設定群~obj, %~options, %~CORS設定, %文字~符号化法 ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / 新たな`古典~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch a classic script given a url, a settings object, some options, a CORS setting, and a character encoding, run these steps. The algorithm will asynchronously complete with either null (on failure) or a new classic script (on success).

  1. %要請 ~LET `~CORSになり得る要請を作成する$( %~url, `script^l, %~CORS設定 ) ◎ Let request be the result of creating a potential-CORS request given url, "script", and CORS setting.
  2. %要請 の`~client$rq ~SET %設定群~obj ◎ Set request's client to settings object.
  3. `古典~script要請を設定しておく$( %要請, %~options ) ◎ Set up the classic script request given request and options.
  4. ~IF[ この~algoの~call元にて,`~fetchを遂行する$ ~custom手続き %手続き が指定されている ]:

    1. %手続き を遂行する( %要請, `~top-level内$i )
    2. ~RET — ただし,以降の手続きは、 %手続き を完了した結果の`応答$ %応答 に対し走らす
    ◎ If the caller specified custom steps to perform the fetch, perform them on request, with the is top-level flag set. Return from this algorithm, and when the custom perform the fetch steps complete with response response, run the remaining steps.

    ~ELSE:

    1. %要請 を`~fetch$する
    2. ~RET — ただし,以降の手続きは、[ ~fetchした結果の`応答$ %応答 に対し`応答を処理する$ ]一部として走らす
    ◎ Otherwise, fetch request. Return from this algorithm, and run the remaining steps as part of the fetch's process response for the response response.

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

  5. %応答 ~SET %応答 の`非安全~応答$ ◎ Set response to response's unsafe response.
  6. ~IF[ %応答 の`種別$rs ~EQ `error^l ]~OR[ %応答 の`状態s$rs ~NIN { `~ok状態s$rs } ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If response's type is "error", or response's status is not an ok status, then asynchronously complete this algorithm with null, and return.

    注記: この節における他の[ ~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.

  7. ~IF[ %応答 には`~Content-Type~metadata$が在って、それは,~UAが~supportする文字~符号化法 %符号化法 を指定する ] ⇒ %文字~符号化法 ~SET %符号化法 (渡された %文字~符号化法 は無視する) ◎ If response's Content Type metadata, if any, specifies a character encoding, and the user agent supports that encoding, then set character encoding to that encoding (ignoring the passed-in value).
  8. %~source~text ~LET `~Unicodeに復号する$( %応答 の`本体$rs, %文字~符号化法 ) ◎ Let source text be the result of decoding response's body to Unicode, using character encoding as the fallback encoding.

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

  9. %~errorは黙秘する ~LET [ %応答 は`~CORS非同一-生成元$であるならば ~T / ~ELSE_ ~F ] ◎ Let muted errors be true if response was CORS-cross-origin, and false otherwise.
  10. %~script ~LET `古典~scriptを作成する$( %~source~text, %応答 の`~URL$rs, %~options, %~errorは黙秘する ) ◎ Let script be the result of creating a classic script given source text, settings object, response's url, options, and muted errors.
  11. %~script を結果として`非同期に完了-$する ◎ Asynchronously complete this algorithm with script.

`~worker用~古典~scriptを~fetchする@ ときは、所与の ⇒# %~url, %~fetch~client設定群~obj, %行先, %~script設定群~obj ◎終 に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / 新たな`古典~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch a classic worker script given a url, a fetch client settings object, a destination, and a script settings object, run these steps. The algorithm will asynchronously complete with either null (on failure) or a new classic script (on success).

  1. %要請 ~LET 次のようにされた新たな`要請$ ⇒# `~URL$rq ~SET %~url, `~client$rq ~SET %~fetch~client設定群~obj, `行先$rq ~SET %行先, `~mode$rq ~SET `same-origin^l, `資格証~mode$rq ~SET `same-origin^l, `構文解析器~metadata$rq ~SET `not-parser-inserted^l【!*not parser-inserted 】, `~URL資格証~利用~flag$rq ~SET ~T ◎ Let request be a new request whose url is url, client is fetch client settings object, destination is destination, mode is "same-origin", credentials mode is "same-origin", parser metadata is "not parser-inserted", and whose use-URL-credentials flag is set.
  2. ~IF[ この~algoの~call元にて,`~fetchを遂行する$ ~custom手続き %手続き が指定されている ]:

    1. %手続き を遂行する( %要請, `~top-level内$i )
    2. ~RET — ただし,以降の手続きは、 %手続き を完了した結果の`応答$ %応答 に対し走らす
    ◎ If the caller specified custom steps to perform the fetch, perform them on request, with the is top-level flag set. Return from this algorithm, and when the custom perform the fetch steps complete with response response, run the remaining steps.

    ~ELSE:

    1. %要請 を`~fetch$する
    2. ~RET — ただし,以降の手続きは、[ ~fetchした結果の`応答$ %応答 に対し`応答を処理する$ ]一部として走らす
    ◎ Otherwise, fetch request. Return from this algorithm, and run the remaining steps as part of the fetch's process response for the response response.
  3. %応答 ~SET %応答 の`非安全~応答$ ◎ Set response to response's unsafe response.
  4. ~IF[ %応答 の`種別$rs ~EQ `error^l ]~OR[ %応答 の`状態s$rs ~NIN { `~ok状態s$rs } ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If either of the following conditions are met: • response's type is "error"; or • response's status is not an ok status, then asynchronously complete this algorithm with null, and return.
  5. ~IF[ 次がいずれも満たされる ]…: ◎ If both of the following conditions are met:

    • %応答 の`~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 を結果として`非同期に完了-$する ◎ then asynchronously complete this algorithm with null, and return.

    注記: 他の`~fetch~scheme$に対しては、歴史的な~web互換性の理由から,~MIME型の検査は免除されている。 これは、将来には,引き締め可能になるかもしれない — 課題 #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.

  6. %~source~text ~LET `~UTF-8復号する$( %応答 の`本体$rs ) ◎ Let source text be the result of UTF-8 decoding response's body.
  7. %~script ~LET `古典~scriptを作成する$( %~source~text, %~script設定群~obj, %応答 の`~URL$rs, `既定の古典~script~fetch~options$ ) ◎ Let script be the result of creating a classic script using source text, script settings object, response's url, and the default classic script fetch options.
  8. %~script を結果として`非同期に完了-$する ◎ Asynchronously complete this algorithm with script.

`~workerが~importした古典~scriptを~fetchする@ ときは、所与の ( %~url, %設定群~obj ) に対し,次を走らす — この~algoは、同期的に完了し,例外を投出する(失敗~時)か, 新たな`古典~script$を返す(成功~時): ◎ To fetch a classic worker-imported script given a url and a settings object, run these steps. The algorithm will synchronously complete with a classic script on success, or throw an exception on failure.

  1. %要請 ~LET 次のようにされた新たな`要請$ ⇒# `~URL$rq ~SET %~url, `~client$rq ~SET %設定群~obj, `行先$rq ~SET `script^l, `構文解析器~metadata$rq ~SET `not-parser-inserted^l, `同期~flag$rq ~SET ~T, `~URL資格証~利用~flag$rq ~SET ~T ◎ Let request be a new request whose url is url, client is settings object, destination is "script", parser metadata is "not parser-inserted", synchronous flag is set, and whose use-URL-credentials flag is set.
  2. ~IF[ この~algoの~call元にて,`~fetchを遂行する$ ~custom手続き %手続き が指定されている ] ⇒ %応答 ~LET %手続き を遂行する( %要請, `~top-level内$i ) ◎ If the caller specified custom steps to perform the fetch, perform them on request, with the is top-level flag set. Let response be the result.

    ~ELSE ⇒ %応答 ~LET %要請 を`~fetch$した結果 ◎ Otherwise, fetch request, and let response be the result.

    注記: この節の他の~algoと違って,ここでの~fetchingは同期的に行われる。 したがって、ここで`~fetchを遂行する$どの手続きも,その作業を同期的に完遂することになる。 ◎ Unlike other algorithms in this section, the fetching process is synchronous here. Thus any perform the fetch steps will also finish their work synchronously.

  3. %応答 ~SET %応答 の`非安全~応答$ ◎ Set response to response's unsafe response.
  4. ~IF[ 次のいずれかが満たされる ]…: ◎ If any of the following conditions are met:

    • %応答 の`種別$rs ~EQ `error^l ◎ response's type is "error"; or
    • %応答 の`状態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.

  5. %~source~text ~LET `~UTF-8復号する$( %応答 の`本体$rs ) ◎ Let source text be the result of UTF-8 decoding response's body.
  6. %~errorは黙秘する ~LET [ %応答 は`~CORS非同一-生成元$であるならば ~T / ~ELSE_ ~F ] ◎ Let muted errors be true if response was CORS-cross-origin, and false otherwise.
  7. %~script ~LET `古典~scriptを作成する$( %~source~text, %設定群~obj, %応答 の`~URL$rs, `既定の古典~script~fetch~options$, %~errorは黙秘する ) ◎ Let script be the result of creating a classic script given source text, settings object, response's url, the default classic script fetch options, and muted errors.
  8. ~RET %~script ◎ Return script.

`外部~module~script~graphを~fetchする@ ときは、所与の ( %~url, %設定群~obj, %~options ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch an external module script graph given a url, a settings object, and some options, run these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success).

  1. 次を与える下で,`単独の~module~scriptを~fetchする$ ⇒# %~url, %設定群~obj, `script^l, %~options, %設定群~obj, `client^l, `~top-level~module~fetch^i ◎終 — この~algoの~call元にて`~fetchを遂行する$ ~custom手続きが指定されている場合、それも渡す。 ◎ Fetch a single module script given url, settings object, "script", options, settings object, "client", and with the top-level module fetch flag set. If the caller of this algorithm specified custom perform the fetch steps, pass those along as well.\
  2. 前~段の~algoが %結果 を結果として`非同期に完了-$するまで待機する ◎ Wait until the algorithm asynchronously completes with result.
  3. ~IF[ %結果 ~EQ ~NULL ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If result is null, asynchronously complete this algorithm with null, and return.
  4. %訪問-済み集合 ~LET « %~url » ◎ Let visited set be « url ».
  5. %結果 の`子孫を~fetchして~linkする$( %設定群~obj, %行先, %訪問-済み集合 ) ◎ Fetch the descendants of and link result given settings object, destination, and visited set.\
  6. 前~段の~algoが %最終~結果 を結果として`非同期に完了-$したときは ⇒ %最終~結果 を結果として`非同期に完了-$する ◎ When this asynchronously completes with final result, asynchronously complete this algorithm with final result.

`~import_~script~graphを~fetchする@ ときは、所与の ( %指定子, %基底~URL, %設定群~obj, %~options ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch an import() module script graph given a specifier, a base URL, a settings object, and some options, run these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success).

  1. %~url ~LET `~module指定子を解決する$( %基底~URL, %指定子 ) ◎ Let url be the result of resolving a module specifier given base URL and specifier.
  2. ~IF[ %~url ~EQ `失敗^i ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If url is failure, then asynchronously complete this algorithm with null, and return.
  3. 次を与える下で,`単独の~module~scriptを~fetchする$ ⇒# %~url, %設定群~obj, `script^l, %~options, %設定群~obj, `client^l, `~top-level~module~fetch^i ◎終 — この~algoの~call元にて`~fetchを遂行する$ ~custom手続きが指定されている場合、それも渡す。 ◎ Fetch a single module script given url, settings object, "script", options, settings object, "client", and with the top-level module fetch flag set. If the caller of this algorithm specified custom perform the fetch steps, pass those along as well.\
  4. 前~段の~algoが %結果 を結果として`非同期に完了-$するまで待機する ◎ Wait until the algorithm asynchronously completes with result.
  5. ~IF[ %結果 ~EQ ~NULL ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If result is null, asynchronously complete this algorithm with null, and return.
  6. %訪問-済み集合 ~LET « %~url » ◎ Let visited set be « url ».
  7. %結果 の`子孫を~fetchして~linkする$( %設定群~obj, %行先, %訪問-済み集合 ) ◎ Fetch the descendants of and link result given settings object, destination, and visited set.\
  8. 前~段の~algoが %最終~結果 を結果として`非同期に完了-$したときは ⇒ %最終~結果 を結果として`非同期に完了-$する ◎ When this asynchronously completes with final result, asynchronously complete this algorithm with final result.

`~modulepreload~script~graphを~fetchする@ ときは、所与の ( %~url, %行先, %設定群~obj, %~options ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$することに加え、完了した後も任意選択の手続きを遂行することになる: ◎ To fetch a modulepreload module script graph given a url, a destination, a settings object, and some options, run these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success), although it will perform optional steps even after completing.

  1. 次を与える下で,`単独の~module~scriptを~fetchする$ ⇒# %~url, %設定群~obj, %行先, %~options, %設定群~obj, `client^l, `~top-level~module~fetch^i ◎ Fetch a single module script given url, settings object, destination, options, settings object, "client", and with the top-level module fetch flag set.\
  2. 前~段の~algoが %結果 を結果として`非同期に完了-$するまで待機する ◎ Wait until algorithm asynchronously completes with result.
  3. %結果 を結果として`非同期に完了-$する — `ただし^em、この手続きは継続する ◎ Asynchronously complete this algorithm with result, but do not return.
  4. ~IF[ %結果 ~EQ ~NULL ] ⇒ ~RET ◎ If result is not null,\
  5. 任意選択で,次の手続きを遂行する: ◎ optionally perform the following steps:

    1. %訪問-済み集合 ~LET « %~url » ◎ Let visited set be « url ».
    2. %結果 の`子孫を~fetchして~linkする$( %設定群~obj, %行先, %訪問-済み集合 ) ◎ Fetch the descendants of and link result given settings object, destination, and visited set.

    注記: 一般に、この段を遂行すれば,処理能にとって有益になる。 それは、~graph全体を~fetchする~algo — `外部~module~script~graphを~fetchする$など — を介して後で結局~要請される~moduleを,予め読込むことを許容するので。 しかしながら,~UAは、[ 帯域幅が拘束されている状況/関連な~fetchはすでに~~伝送中にある状況 ]においては,それを飛ばしたいと望むこともあろう。 ◎ Generally, performing these steps 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~script~graphを~fetchする@ ときは、所与の ( %~source~text, %基底~URL, %設定群~obj, %~options ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch an inline module script graph given a source text, base URL, settings object, and options, run these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success).

  1. %~script ~LET `~module~scriptを作成する$( %~source~text, %設定群~obj, %基底~URL, %~options ) ◎ Let script be the result of creating a module script using source text, settings object, base URL, and options.
  2. ~IF[ %~script ~EQ ~NULL ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If script is null, asynchronously complete this algorithm with null, and return.
  3. %訪問-済み集合 ~LET 新たな`集合$ ◎ Let visited set be an empty set.
  4. %~script の`子孫を~fetchして~linkする$( %設定群~obj, `script^l, %訪問-済み集合 ) ◎ Fetch the descendants of and link script, given settings object, the destination "script", and visited set.\
  5. 前~段の~algoが %最終~結果 を結果として`非同期に完了-$したときは ⇒ %最終~結果 を結果として`非同期に完了-$する ◎ When this asynchronously completes with final result, asynchronously complete this algorithm with final result.

`~module~worker~script~graphを~fetchする@ ときは、所与の ⇒# %~url, %~fetch~client設定群~obj, %行先, %資格証~mode, %~module~map設定群~obj ◎終 に対し: ◎ To fetch a module worker script graph given a url, a fetch client settings object, a destination, a credentials mode, and a module map settings object,\

  1. `[~worklet/~module~worker]~script~graphを~fetchする$( 次に挙げる引数 ) ⇒# %~url, %~fetch~client設定群~obj, %行先, %資格証~mode, %~module~map設定群~obj ◎ fetch a worklet/module worker script graph given url, fetch client settings object, destination, credentials mode, and module map settings object,\
  2. 前~段の~algoが %結果 を結果として`非同期に完了-$したときは ⇒ %結果 を結果として`非同期に完了-$する ◎ asynchronously completing with the asynchronous completion result of that algorithm.

`~worklet~script~graphを~fetchする@ ときは、所与の ⇒# %~url, %~fetch~client設定群~obj, %行先, %資格証~mode, %~module~map設定群~obj, %~module応答~map ◎終 に対し: ◎ To fetch a worklet script graph given a url, a fetch client settings object, a destination, a credentials mode, a module map settings object, and a module responses map,\

  1. `[~worklet/~module~worker]~script~graphを~fetchする$( 次に挙げる引数 ) ⇒# %~url, %~fetch~client設定群~obj, %行先, %資格証~mode, %~module~map設定群~obj ◎ fetch a worklet/module worker script graph given url, fetch client settings object, destination, credentials mode, and module map settings object,\

    加えて、`~fetchを遂行する$ための~custom手続きとして,下に与える手続きを利用する ◎ ↓

  2. 前~段の~algoが %結果 を結果として`非同期に完了-$したときは ⇒ %結果 を結果として`非同期に完了-$する ◎ asynchronously completing with the asynchronous completion result of that algorithm.\

上で与える~custom手続きは、所与の ( %応答 ) に対し 次を走らす: ◎ Use the following custom steps to perform the fetch given response:

  1. %要請~URL ~LET %要請 の`~URL$rq ◎ Let requestURL be request's url.
  2. ~IF[ %~module応答~map[ %要請~URL ] ~EQ `fetching^l ]:

    1. %~module応答~map[ %要請~URL ] の値が変化するまで`並列的$に待機する
    2. `~network用~task源$から,この手続きの以降を続行する`~taskを~queueする$ 【手続きはここで中断され、まだ`非同期に完了-$しない。】
    ◎ If moduleResponsesMap[requestURL] 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.
  3. ~IF[ %~module応答~map[ %要請~URL ] ~NEQ ε ] ⇒ %~module応答~map[ %要請~URL ] を結果として,`非同期に完了-$する ◎ If moduleResponsesMap[requestURL] exists, then asynchronously complete the perform the fetch steps with moduleResponsesMap[requestURL].
  4. %~module応答~map[ %要請~URL ] ~SET `fetching^l ◎ Set moduleResponsesMap[requestURL] to "fetching".
  5. %要請 を`~fetch$する — 所与の ( `応答$ %応答 ) 用に`応答を処理する$ときは: ◎ Fetch request.\

    1. %~module応答~map[ %要請~URL ] ~SET %応答 ◎ Set moduleResponsesMap[requestURL] to response.
    2. %応答 を結果として,`非同期に完了-$する ◎ Asynchronously complete the perform the fetch steps with response.

以下に与える各種~algoは、[ `外部~module~script~graphを~fetchする$,その他の上に与えた類似な概念 ]の一部を成すものとして,この仕様の内部~利用のみに意味されている。 他の仕様は、これらを直に利用するべきではない。 ◎ The following algorithms are meant for internal use by this specification only as part of fetching an external module script graph or other similar concepts above, and should not be used directly by other specifications.

これらの~algoが[ 上に与えたものに, および互いに ]どう関係するかを、次の図式に示す:

  • 次に挙げる~algoが、外部から直に利用され得る ⇒# (A) `外部~module~script~graphを~fetchする$/ (B) `~import_~script~graphを~fetchする$/ (C) `~modulepreload~script~graphを~fetchする$/ (D) `~inline~script~graphを~fetchする$/ (E) `~module~worker~script~graphを~fetchする$/ (F) `~worklet~script~graphを~fetchする$
  • (E), (F) は、次を呼出す ⇒ (U) `[~worklet/~module~worker]~script~graphを~fetchする$
  • (A), (B), (C), (D), (U) は、次を呼出す ⇒ (V) `~module~scriptの子孫を~fetchする$
  • (V) は、次を呼出す ⇒ (W) `~module~script~graphを~fetchする内部手続き$
  • (W) は、 (V) を再帰的に呼出す

【 原文は~SVG画像による図式で示されているが、日本語表示~上の都合により,単に~markupと~textで示す。 】

◎ This diagram illustrates how these algorithms relate to the ones above, as well as to each other: ◎ • fetch an external module script graph • fetch an import() module script graph • fetch a modulepreload module script graph • fetch an inline module script graph • fetch a module worker script graph • fetch a worklet script graph ◎ • fetch a worklet/module worker script graph • fetch the descendants of and link a module script • fetch the descendants of a module script • internal module script graph fetching procedure

`[~worklet/~module~worker]~script~graphを~fetchする@ ときは、所与の ⇒# %~url, %~fetch~client設定群~obj, %行先, %資格証~mode, %~module~map設定群~obj ◎終 に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch a worklet/module worker script graph given a url, a fetch client settings object, a destination, a credentials mode, and a module map settings object, run these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success).

  1. %~options ~LET 次のようにされた`~script~fetch~options$ ⇒# `暗号用~nonce$sfO ~SET 空~文字列, `完全性~metadata$sfO ~SET 空~文字列, `構文解析器~metadata$sfO ~SET `not-parser-inserted^l, `資格証~mode$sfO ~SET %資格証~mode, `~referrer施策$sfO ~SET 空~文字列 ◎ 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 credentials mode, and referrer policy is the empty string.
  2. 次を与える下で,`単独の~module~scriptを~fetchする$ ⇒# %~url, %~fetch~client設定群~obj, %行先, %~options, %~module~map設定群~obj, `client^l, `~top-level~module~fetch^i ◎終 — この~algoの~call元にて`~fetchを遂行する$ ~custom手続きが指定されている場合、それも渡す。 ◎ Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, "client", and with the top-level module fetch flag set. If the caller of this algorithm specified custom perform the fetch steps, pass those along as well.\
  3. 前~段の~algoが %結果 を結果として`非同期に完了-$するまで待機する ◎ Wait until the algorithm asynchronously completes with result.
  4. ~IF[ %結果 ~EQ ~NULL ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If result is null, asynchronously complete this algorithm with null, and return.
  5. %訪問-済み集合 ~LET « %~url » ◎ Let visited set be « url ».
  6. %結果 の`子孫を~fetchして~linkする$( %~fetch~client設定群~obj, %行先, %訪問-済み集合 ) ◎ Fetch the descendants of and link result given fetch client settings object, destination, and visited set.\
  7. 前~段の~algoが %最終~結果 を結果として`非同期に完了-$したときは ⇒ %最終~結果 を結果として`非同期に完了-$する ◎ When this asynchronously completes with final result, asynchronously complete this algorithm with final result.

`~module~script$ %~module~script の `子孫を~fetchして~linkする@ ときは、所与の ( %~fetch~client設定群~obj, %行先, %訪問-済み集合 ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch the descendants of and link a module script module script, given a fetch client settings object, a destination, and a visited set, run these steps. The algorithm will asynchronously complete with either null (on failure) or with module script (on success).

  1. %~module~script の`子孫を~fetchする$( %~fetch~client設定群~obj, %行先, %訪問-済み集合 ) ◎ Fetch the descendants of module script, given fetch client settings object, destination, and visited set.
  2. ~RET — ただし,前~段の~algoが %結果 を結果として `非同期に完了-$したときには、以下を走らす: ◎ Return from this algorithm, and run the following steps when fetching the descendants of a module script asynchronously completes with result.
  3. ~IF[ %結果 ~EQ ~NULL ] ⇒ %結果 を結果として`非同期に完了-$する ◎ If result is null, then asynchronously complete this algorithm with result.

    注記: この事例では, 1 個~以上の子孫において、~fetchingに~errorが生じている。 よって、~linkしようとは試みない。 ◎ In this case, there was an error fetching one or more of the descendants. We will not attempt to link.

  4. %構文解析-~error ~LET `最初の~errorを見出す$( %結果 ) ◎ Let parse error be the result of finding the first parse error given result.
  5. ~IF[ %構文解析-~error ~EQ ~NULL ]: ◎ If parse error is null, then:

    1. ( %結果 の`~record$sC ) . `Link$jA() を遂行する ◎ Let record be result's record. ◎ Perform record.Link().

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

      この段で例外 %E が投出されたときは ⇒ %結果 の`再投出-用~error$sC ~SET %E ◎ If this throws an exception, set result's error to rethrow to that exception.

  6. ~ELSE ⇒ %結果 の`再投出-用~error$sC ~SET %構文解析-~error ◎ Otherwise, set result's error to rethrow to parse error.
  7. %結果 を結果として`非同期に完了-$する ◎ Asynchronously complete this algorithm with result.

`~module~script$ %~module~script の `子孫を~fetchする@ ときは、所与の ( %~fetch~client設定群~obj, %行先, %訪問-済み集合 ) に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch the descendants of a module script module script, given a fetch client settings object, a destination, and a visited set, run these steps. The algorithm will asynchronously complete with either null (on failure) or with module script (on success).

  1. %~record ~LET %~module~script の`~record$sC ◎ ↓
  2. ~IF[ %~record ~EQ ~NULL ] ⇒ %~module~script を結果として`非同期に完了-$する ◎ If module script's record is null, then asynchronously complete this algorithm with module script and return. ◎ Let record be module script's record.
  3. ~IF[ %~record は`循環な~Module-Record$でない ]~OR[ %~record . `RequestedModules^sl は`空$である ] ⇒ %~module~script を結果として`非同期に完了-$する ◎ If record is not a Cyclic Module Record, or if record.[[RequestedModules]] is empty, asynchronously complete this algorithm with module script.
  4. %~url~list ~LET 新たな空`~list$ ◎ Let urls be a new empty list.
  5. %~record . `RequestedModules^sl 内の `~EACH$( 文字列 %要請された何か ) に対し: ◎ For each string requested of record.[[RequestedModules]],

    1. %~url ~LET `~module指定子を解決する$( %~module~script の`基底~URL$sC, %要請された何か ) ◎ Let url be the result of resolving a module specifier given module script's base URL and requested.
    2. ~Assert: %~url ~NEQ `失敗^i — 以前にも、同じ引数で,`~module指定子を解決する$のに成功している。 ◎ Assert: url is never failure, because resolving a module specifier must have been previously successful with these same two arguments.
    3. ~IF[ %~url ~NIN %訪問-済み集合 ]: ◎ If visited set does not contain url, then:

      1. %~url~list に %~url を`付加する$ ◎ Append url to urls.
      2. %訪問-済み集合 に %~url を`付加する$set ◎ Append url to visited set.
  6. %~options ~LET `子孫~script~fetch~options$( %~module~script の`~fetch~options$sC ) ◎ Let options be the descendant script fetch options for module script's fetch options.
  7. ~Assert: %~options ~NEQ ~NULL — %~module~script は`~module~script$であるので。 ◎ Assert: options is not null, as module script is a module script.
  8. %~url~list 内の `~EACH$( %~url ) に対し ⇒ 次を与える下で,`~module~script~graphを~fetchする内部手続き$を遂行する ⇒# %~url, %~fetch~client設定群~obj, %行先, %~options, %~module~script の`設定群~obj$sC, %訪問-済み集合, %~module~script の`基底~URL$sC ◎終 — この~algoの~call元にて`~fetchを遂行する$ ~custom手続きが指定されている場合、それも渡す。 ◎ For each url in urls, perform the internal module script graph fetching procedure given url, fetch client settings object, destination, options, module script's settings object, visited set, and module script's base URL. If the caller of this algorithm specified custom perform the fetch steps, pass those along while performing the internal module script graph fetching procedure.

    これらの`~module~script~graphを~fetchする内部手続き$の呼出nは、互いに並列的に遂行されるべきである — そうするかどうかに関わらず: ◎ These invocations of the internal module script graph fetching procedure should be performed in parallel to each other.

    1. ~IF[ ある呼出nが ~NULL を結果として`非同期に完了-$した ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If any of the invocations of the internal module script graph fetching procedure asynchronously complete with null, asynchronously complete this algorithm with null, and return.
    2. ~ELSE — したがって[ すべての呼出nが `非同期に完了-$する ]まで待機した上で ⇒ %~module~script を結果として`非同期に完了-$する ◎ Otherwise, wait until all of the internal module script graph fetching procedure invocations have asynchronously completed. Asynchronously complete this algorithm with module script.

`~module~script~graphを~fetchする内部手続き@ を遂行するときは、所与の ⇒# %~url, %~fetch~client設定群~obj, %行先, %~options, %~module~map設定群~obj, %訪問-済み集合, %~referrer ◎終 に対し,次の手続きを遂行する — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To perform the internal module script graph fetching procedure given a url, a fetch client settings object, a destination, some options, a module map settings object, a visited set, and a referrer, perform these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success).

  1. ~Assert: %~url ~IN %訪問-済み集合 ◎ Assert: visited set contains url.
  2. 次を与える下で,`単独の~module~scriptを~fetchする$ ⇒# %~url, %~fetch~client設定群~obj, %行先, %~options, %~module~map設定群~obj, %~referrer, ε ◎終 — この~algoの~call元にて`~fetchを遂行する$ ~custom手続きが指定されている場合、それも渡す。 ◎ Fetch a single module script given url, fetch client settings object, destination, options, module map settings object, referrer, and with the top-level module fetch flag unset. If the caller of this algorithm specified custom perform the fetch steps, pass those along while fetching a single module script.
  3. 前~段の~algoが %結果 を結果として`非同期に完了-$したときは: ◎ Return from this algorithm, and run the following steps when fetching a single module script asynchronously completes with result:

    1. ~IF[ %結果 ~EQ ~NULL ] ⇒ ~NULL を結果として`非同期に完了-$する ◎ If result is null, asynchronously complete this algorithm with null, and return.
    2. %結果 の`子孫を~fetchする$( %~fetch~client設定群~obj, %行先, %訪問-済み集合 ) ◎ Fetch the descendants of result given fetch client settings object, destination, and visited set.
    3. 前~段の~algoが %最終~結果 を結果として`非同期に完了-$したときは ⇒ %最終~結果 を結果として`非同期に完了-$する ◎ When the appropriate algorithm asynchronously completes with final result, asynchronously complete this algorithm with final result.

`単独の~module~scriptを~fetchする@ ときは、所与の ⇒# %~url, %~fetch~client設定群~obj, %行先, %~options, %~module~map設定群~obj, %~referrer, %~top-level~module~fetch~flag ~IN { `~top-level~module~fetch^i, ε } ◎終 に対し,次を走らす — この~algoは、[ ~NULL (失敗~時) / `~module~script$(成功~時) ]を結果として`非同期に完了-$する: ◎ To fetch a single module script, given a url, a fetch client settings object, a destination, some options, a module map settings object, a referrer, and a top-level module fetch flag, run these steps. The algorithm will asynchronously complete with either null (on failure) or a module script (on success).

  1. %~module~map ~LET %~module~map設定群~obj の`~module~map$enV ◎ Let moduleMap be module map settings object's module map.
  2. ~IF[ %~module~map[ %~url ] ~EQ `fetching^l ]:

    1. %~module~map[ %~url ] の値が変化するまで,`並列的$に待機する
    2. `~network用~task源$から,この手続きの以降を続行する`~taskを~queueする$ 【手続きはここで中断され、まだ`非同期に完了-$しない。】
    ◎ If moduleMap[url] 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.
  3. ~IF[ %~module~map[ %~url ] ~NEQ ε ] ⇒ %~module~map[ %~url ] を結果として`非同期に完了-$する ◎ If moduleMap[url] exists, asynchronously complete this algorithm with moduleMap[url], and return.
  4. %~module~map[ %~url ] ~SET `fetching^l ◎ Set moduleMap[url] to "fetching".
  5. %要請 ~LET 次のようにされた新たな`要請$ ⇒# `~URL$rq ~SET %~url, `行先$rq ~SET %行先, `~mode$rq ~SET `cors^l, `~referrer$rq ~SET %~referrer, `~client$rq ~SET %~fetch~client設定群~obj ◎ Let request be a new request whose url is url, destination is destination, mode is "cors", referrer is referrer, and client is fetch client settings object.
  6. ~IF[ %行先 ~IN { `worker^l, `sharedworker^l } ]~AND[ %~top-level~module~fetch~flag ~EQ `~top-level~module~fetch^i ] ⇒ %要請 の`~mode$rq ~SET `same-origin^l ◎ If destination is "worker" or "sharedworker" and the top-level module fetch flag is set, then set request's mode to "same-origin".
  7. `~module~script要請を設定しておく$( %要請, %~options ) ◎ Set up the module script request given request and options.
  8. ~IF[ この~algoの~call元にて,`~fetchを遂行する$ ~custom手続き %手続き が指定されている ]:

    1. %~top-level内~flag ~LET %~top-level~module~fetch~flag に応じて ⇒ ε ならば ε / `~top-level~module~fetch^i ならば `~top-level内$i
    2. %手続き を遂行する( %要請, %~top-level内~flag )
    3. ~RET — ただし,以降の手続きは、 %手続き を完了した結果の`応答$ %応答 に対し走らす
    ◎ If the caller specified custom steps to perform the fetch, perform them on request, setting the is top-level flag if the top-level module fetch flag is set. Return from this algorithm, and when the custom perform the fetch steps complete with response response, run the remaining steps.

    ~ELSE:

    1. %要請 を`~fetch$する
    2. ~RET — ただし,以降の手続きは、[ ~fetchした結果の`応答$ %応答 に対し`応答を処理する$ ]一部として走らす
    ◎ Otherwise, fetch request. Return from this algorithm, and run the remaining steps as part of the fetch's process response for the response response.

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

  9. ~IF[ 次のいずれかが満たされる ]…: ◎ If any of the following conditions are met:

    • %応答 の`種別$rs ~EQ `error^l ◎ response's type is "error"; or
    • %応答 の`状態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,

    …ならば ⇒# %~module~map[ %~url ] ~SET ~NULL; ~NULL を結果として`非同期に完了-$する ◎ then set moduleMap[url] to null, asynchronously complete this algorithm with null, and return.

  10. %~source~text ~LET `~UTF-8復号する$( %応答 の`本体$rs ) ◎ Let source text be the result of UTF-8 decoding response's body.
  11. %~module~script ~LET `~module~scriptを作成する$( %~source~text, %~module~map設定群~obj, %応答 の`~URL$rs, %~options ) ◎ Let module script be the result of creating a module script given source text, module map settings object, response's url, and options.
  12. %~module~map[ %~url ] ~SET %~module~script;
    %~module~script を結果として`非同期に完了-$する ◎ Set moduleMap[url] to module script, and asynchronously complete this algorithm with module script.

    注記: `~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.

`最初の~errorを見出す@ ときは、所与の ( 根 %~module~script, %発見-済み集合 (省略時は新たな`集合$) ) に対し,次を走らす: ◎ To find the first parse error given a root moduleScript and an optional discoveredSet:

  1. %~module~map ~LET %~module~script の`設定群~obj$sCの`~module~map$enV ◎ Let moduleMap be moduleScript's settings object's module map. ◎ If discoveredSet was not given, let it be an empty set.
  2. %発見-済み集合 に %~module~script を`付加する$set 【!* list-append 】 ◎ Append moduleScript to discoveredSet.
  3. ~IF[ %~module~script の`~record$sC ~EQ ~NULL ] ⇒ ~RET %~module~script の`構文解析-~error$sC ◎ If moduleScript's record is null, then return moduleScript's parse error.
  4. %子~指定子~list ~LET ( %~module~script の`~record$sC ) . `RequestedModules^sl ◎ Let childSpecifiers be the value of moduleScript's record's [[RequestedModules]] internal slot.
  5. %子~URL~list ~LET 新たな`~list$ ◎ Let childURLs be the list\
  6. %子~指定子~list 内の ~EACH( %~item ) に対し ⇒ %子~URL~list に次の結果を`付加する$ ⇒ `~module指定子を解決する$( %~module~script の`基底~URL$sC, %~item )

    注記: どの %~item に対しても,この結果は `失敗^i にはならない — さもなければ、 %~module~script 自身が 構文解析-~errorとされている 筈なので。

    ◎ obtained by calling resolve a module specifier once for each item of childSpecifiers, given moduleScript's base URL and that item. (None of these will ever fail, as otherwise moduleScript would have been marked as itself having a parse error.)
  7. %子~module~list ~LET 新たな`~list$ ◎ Let childModules be the list\
  8. %子~URL~list 内の ~EACH( %~item ) に対し ⇒ %子~module~list に %~module~map[ %~item ] を`付加する$ ◎ obtained by getting each value in moduleMap whose key is given by an item of childURLs.
  9. %子~module~list 内の `~EACH$( %子~module ) に対し: ◎ For each childModule of childModules:

    1. ~Assert: %子~module は`~module~script$である (すなわち、 %子~module ~NIN { `fetching^l, ~NULL } ) — この時点までに、[ ~graph内の, %~module~script を根とする すべての`~module~script$ ]に対する~fetchは,成功したことになる。 ◎ Assert: childModule is a module script (i.e., it is not "fetching" or null); by now all module scripts in the graph rooted at moduleScript will have successfully been fetched.
    2. ~IF[ %子~module ~IN %発見-済み集合 ] ⇒ ~CONTINUE ◎ If discoveredSet already contains childModule, continue.
    3. %子~構文解析-~error ~LET `最初の~errorを見出す$( %子~module, %発見-済み集合 ) ◎ Let childParseError be the result of finding the first parse error given childModule and discoveredSet.
    4. ~IF[ %子~構文解析-~error ~NEQ ~NULL ] ⇒ ~RET %子~構文解析-~error ◎ If childParseError is not null, return childParseError.
  10. ~RET ~NULL ◎ Return null.

8.1.4.3. ~scriptの作成-法

`古典~scriptを作成する@ ときは、所与の ⇒# `文字列$ %~source, `環境~設定群~obj$ %設定群, `~URL$ %基底~URL, `~script~fetch~options$ %~options, 真偽値 %~errorは黙秘する (省略時は ~F ) ◎終 に対し,次を走らす: ◎ To create a classic script, given a string source, an environment settings object settings, a URL baseURL, some script fetch options options, and an optional muted errors boolean: • If muted errors was not provided, let it be false.

  1. ~IF[ %~errorは黙秘する ~EQ ~T ] ⇒ %基底~URL ~SET `~about_blank$sc ◎ If muted errors is true, then set baseURL to about:blank.

    注記: %~errorは黙秘する ~EQ ~T のとき、 %基底~URL は,当の~scriptの`~CORS非同一-生成元$な`応答$の`~URL$rsになる — それは,~JSには公開されないベキなので、 %基底~URL は,ここで無毒化される。 ◎ When muted errors 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は不能化されて$いる ] ⇒ %~source ~SET 空~文字列 ◎ If scripting is disabled for settings, then set source to the empty string.
  3. %~script ~LET 新たな`古典~script$ ◎ Let script be a new classic script that this algorithm will subsequently initialize.
  4. %~script の ⇒# `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET %基底~URL, `~fetch~options$sC ~SET %~options `~errorは黙秘する$sC ~SET %~errorは黙秘する, `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL ◎ 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 muted errors. ◎ Set script's parse error and error to rethrow to null.
  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.

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

  1. ~IF[ %設定群 用の`~scriptingは不能化されて$いる ] ⇒ %~source ~SET 空~文字列 ◎ If scripting is disabled for settings, then set source to the empty string.
  2. %~script ~LET 新たな`~module~script$ ◎ Let script be a new module script that this algorithm will subsequently initialize.
  3. %~script の ⇒# `設定群~obj$sC ~SET %設定群, `基底~URL$sC ~SET %基底~URL, `~fetch~options$sC ~SET %~options `構文解析-~error$sC ~SET ~NULL, `再投出-用~error$sC ~SET ~NULL ◎ 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.
  4. %結果 ~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.

  5. ~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.
  6. %結果 . `RequestedModules^sl 内の ~EACH( 文字列 %要請された何か ) に対し: ◎ For each string requested of result.[[RequestedModules]]:

    1. %~url ~LET `~module指定子を解決する$( %~script の`基底~URL$sC, %要請された何か ) ◎ Let url be the result of resolving a module specifier given script's base URL and requested.
    2. ~IF[ %~url ~EQ `失敗^i ]: ◎ If url is failure, then:

      1. %~error ~LET 新たな `TypeError$jc 例外 ◎ Let error be a new TypeError exception.
      2. %~script の`構文解析-~error$sC ~SET %~error ◎ Set script's parse error to error.
      3. ~RET %~script ◎ Return script.

    注記: この段は、本質的に,要請された~module指定子すべてを検証する。 解決-不能な~module指定子は,構文解析できなかったときと同じに扱う — 後で~moduleを~linkするような考えは排される。 ◎ This step is essentially validating all of the requested module specifiers. We treat a module with unresolvable module specifiers the same as one that cannot be parsed; in both cases, a syntactic issue makes it impossible to ever contemplate linking the module later.

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

8.1.4.4. ~scriptの~call法

`古典~scriptを走らす@ ときは、所与の ( `古典~script$ %~script, 真偽値 %~errorは再投出する (省略時は ~F ) ) に対し,次を走らす: ◎ To run a classic script given a classic script script and an optional rethrow errors boolean: • If rethrow errors is not given, let it be false.

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

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

      ~IF[ ~UAは`走っている~scriptを中止-$したため, `ScriptEvaluation$jA は完了しなかった ]:

      1. `走らせた~scriptを片付ける$( %設定群 )
      2. ~RET `Completion^js{ `Type^sl: `throw^js, `Value^sl: 新たな `QuotaExceededError$E 例外, `Target^sl: `empty^js }
    ◎ 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. ◎ ↓↓
  7. ~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. `例外を報告する$( %~script, %評価~状態s . `Value^sl ) ◎ Report the exception given by evaluationStatus.[[Value]] for script.
      2. `走らせた~scriptを片付ける$( %設定群 ) ◎ Clean up after running script with settings.
      3. ~RET %評価~状態s ◎ Return evaluationStatus.
  8. ~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は再投出する (省略時は ~F ) ) に対し,次を走らす: ◎ To run a module script given a module script script, with an optional rethrow errors boolean: • If rethrow errors is not given, let it be false.

  1. %設定群 ~LET %~script の`設定群~obj$sC ◎ Let settings be the settings object of script.
  2. ~IF[ `~scriptは走れるかどうか検査する$( %設定群 ) ~EQ `走るな^i ] ⇒ ~RET `NormalCompletion$jA( `empty^jv ) ◎ Check if we can run script with settings. If this returns "do not run" then return NormalCompletion(empty).
  3. `~scriptを走らすために準備する$( %設定群 ) ◎ Prepare to run script given settings.
  4. %評価~状態s ~LET ~NULL ◎ Let evaluationStatus be null.
  5. ~IF[ %~script の`再投出-用~error$sC ~NEQ ~NULL ] ⇒ %評価~状態s ~SET `Completion^js{ `Type^sl: `throw^js, `Value^sl: %~script の`再投出-用~error$sC, `Target^sl: `empty^js } ◎ If script's error to rethrow is not null, then set evaluationStatus to Completion { [[Type]]: throw, [[Value]]: script's error to rethrow, [[Target]]: empty }.
  6. ~ELSE: ◎ Otherwise:

    1. %~record ~LET %~script の`~record$sC ◎ Let record be script's record.
    2. %評価~状態s ~SET %~record . `Evaluate$jA() ◎ Set evaluationStatus to record.Evaluate().

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

      ~IF[ ~UAが`走っている~scriptを中止-$したため, `Evaluate$jA は完了しなかった ] ⇒ %評価~状態s ~SET `Completion^js{ `Type^sl: `throw^js, `Value^sl: 新たな `QuotaExceededError$E 例外, `Target^sl: `empty^js } ◎ If Evaluate fails to complete as a result of the user agent aborting the running script, then set evaluationStatus to Completion { [[Type]]: throw, [[Value]]: a new "QuotaExceededError" DOMException, [[Target]]: empty }.

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

    1. ~IF[ %~errorは再投出する ~EQ ~T ] ⇒ ~THROW %評価~状態s . `Value^sl ◎ If rethrow errors is true, rethrow the exception given by evaluationStatus.[[Value]].
    2. ~ELSE ⇒ `例外を報告する$( %~script, %評価~状態s . `Value^sl ) ◎ Otherwise, report the exception given by evaluationStatus.[[Value]] for script.
  8. `走らせた~scriptを片付ける$( %設定群 ) ◎ Clean up after running script with settings.
  9. ~RET %評価~状態s ◎ Return evaluationStatus.

`~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は不能化されて$いる ] ⇒ ~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. 現在~走っている`~task$の`~script評価 環境~設定群~obj集合$tKに %設定群 を追加する ◎ Add settings to the 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.)

注記: これらの~algoは、ある~scriptが別の~scriptを直に~callして呼出されることはないが、間接的な方式で再入的に呼出され得る — 例えば、~scriptが~eventを配送したとき,その~event用に~event~listenerが登録されている場合。 ◎ These algorithms are not invoked by one script directly calling another, but they can be invoked reentrantly in an indirect manner, e.g. if a script dispatches an event which has event listeners registered.

`走っている~script@ とは、`走っている~JS実行~文脈$の~ScriptOrModule成分の `HostDefined^sl ~field内の`~script$である。 ◎ The running script is the script in the [[HostDefined]] field in the ScriptOrModule component of the running JavaScript execution context.

8.1.4.5. ~scriptの強制終了

`走っている~scriptを中止-@ する必要が生じることも,ときにはある — ~JS仕様はその可能性について織込んでいないが。 これは、[ `ScriptEvaluation$jA / `~source~text~Module-Record$の `Evaluate$jA ]の呼出nがあれば即時に止めた上で, `finally^c ~blockの様な通常の仕組みを誘発することなく,`~JS実行~文脈~stack$を空にする。 `JAVASCRIPT$r ◎ Although the JavaScript specification does not account for this possibility, it's sometimes necessary to abort a running script. This causes any ScriptEvaluation or Source Text Module Record Evaluate invocations to cease immediately, emptying the JavaScript execution context stack without triggering any of the normal mechanisms like finally blocks. [JAVASCRIPT]

~UAは、~scriptに~~割り振る計算資源に制限を課してもヨイ — 例えば[ CPU ~quota / ~memory / 実行~時間の総計 / 帯域幅 ]に対する制限など。 ~scriptがこれらの制限sを超過したときは、~UAは,次のいずれかをしてヨイ: ◎ User agents may impose resource limitations on scripts, for example CPU quotas, memory limits, total execution time limits, or bandwidth limitations. When a script exceeds a limit, the user agent may either\

  • `QuotaExceededError$E 例外を投出する
  • 例外を投出せずに~scriptを`中止-$する
  • 利用者に~promptする
  • ~script実行を絞る
◎ throw a "QuotaExceededError" DOMException, abort the script without an exception, prompt the user, or throttle script execution.

例えば、次の~scriptは,決して終了しない。 ~UAは、数~秒~待機した後に,利用者に[ ~scriptを終了するか,そのまま継続させるか ]を~promptすることもできる。 ◎ For example, the following script never terminates. A user agent could, after waiting for a few seconds, prompt the user to either terminate the script or let it continue.

<script>
 while (true) { /* loop */ }
</script>

~UAには、次のときには,利用者が~scriptingを不能化できるようにすることが奨励される:

  • ~scriptが利用者に~promptしたとき(例えば `window.alert()$m ~APIを利用して)。
  • ~scriptの動作が何らかの制限-を超過したとき(例えば、時間~制限-)。
◎ User agents are encouraged to allow users to disable scripting whenever the user is prompted either by a script (e.g. using the window.alert() API) or because of a script's actions (e.g. because it has exceeded a time limit).

~scriptが実行-中の間に,~scriptingが不能化された場合、~scriptは即時に終了されるべきである。 ◎ If scripting is disabled while a script is executing, the script should be terminated immediately.

~UAは、利用者が[ `閲覧文脈$を何もさせずに閉じる目的で,特定的に~scriptを不能化する ]ことを許容してもヨイ。 ◎ User agents may allow users to specifically disable scripts just for the purposes of closing a browsing context.

例えば上の例で言及した~promptは、[ `unload$et ~event~handlerを走らすことなく,ただ~page全体を閉じる仕組み ]を利用者に提供することもできる。 ◎ For example, the prompt mentioned in the example above could also offer the user with a mechanism to just close the page entirely, without running any unload event handlers.

8.1.4.6. 実行時~script~error

~UAは、 `~errorを報告する@ よう要求されたときは、所与の ⇒# `~script$: %~script, 問題箇所: ( %行番号, %列番号 ), `大域~obj$: %標的 ◎終 に対し,以下を走らすモノトスル。 この手続きは、その結果として,~errorの `取扱済み~flag@err を ~T にし得る — 各~errorには,この~flagが結付けられ、初期~時は ~F (すなわち,~errorは `取扱済みでない@err )にされる。 ◎ When the user agent is required to report an error for a particular script script with a particular position line:col, using a particular target target, it must run these steps, after which the error is either handled or not handled:

  1. ~IF[ %標的 は`~error報告ng~mode下$にある ] ⇒ ~RET 【!~errorの取扱済み~flag$err ~SET ~F】 ◎ If target is in error reporting mode, then return; the error is not handled.
  2. %標的 を `~error報告ng~mode下@ におく ◎ Let target be in error reporting mode.
  3. ~FINGERPRINTING %~message ~LET ~errorについて役立つ何かを述べるような,`実装定義$な文字列 ◎ (This is a tracking vector.) Let message be an implementation-defined string describing the error in a helpful manner.
  4. %~error値 ~LET 次の様な,~errorを表現する~obj:

    • ~catchされなかった例外の事例では、投出された値になる。
    • ~JS~errorの事例では、 `Error$E ~objになる。
    • 対応する値がない場合、代わりに ~NULL 値を利用するモノトスル。
    ◎ Let errorValue be the value that represents the error: in the case of an uncaught exception, that would be the value that was thrown; in the case of a JavaScript error that would be an Error object. If there is no corresponding value, then the null value must be used instead.
  5. %~url文字列 ~LET `~URLを直列化する$( %~script が得された資源に対応する`~URL~record$ ) ◎ Let urlString be the result of applying the URL serializer to the URL record that corresponds to the resource from which script was obtained.

    注記: ~scriptを包含している資源は、概して,例えば[ ~inline `script$e 要素 / `~event~handler内容~属性$ ]に対しては,構文解析した`文書$の~fileになり、外部~scriptに対しては,それを含んでいる~JS~fileになる。 動的に生成される~scriptに対するときでも、~UAには,~scriptの元の~sourceを保ち続けるよう試みることが強く奨励される。 例えば、~HTMLの構文解析-時に,外部~scriptが `document.write()$m ~APIを利用して~inline `script$e 要素を挿入した場合、当の~scriptとして[ その~scriptを包含している資源の~URL ]が報告され,行番号として[ `document.write()$m ~callの所, あるいは その~callに渡された文字列が最初に構築された所 ]の行lが報告されるのが、理想的になる。 当然、これを実装するには,自明でない部分もある。 ◎ The resource containing the script will typically be the file from which the Document was parsed, e.g. for inline script elements or event handler content attributes; or the JavaScript file that the script was in, for external scripts. Even for dynamically-generated scripts, user agents are strongly encouraged to attempt to keep track of the original source of a script. For example, if an external script uses the document.write() API to insert an inline script element during parsing, the URL of the resource containing the script would ideally be reported as being the external script, and the line number might ideally be reported as the line with the document.write() call or where the string passed to that call was first constructed. Naturally, implementing this can be somewhat non-trivial.

    注記: 同様に,~UAには、文書が構文解析されるに伴い文書を変異させるような `document.write()$m ~callや,複数~行lにまたがっている`~event~handler内容~属性$に直面したとしても、元の行番号を保ち続けることが奨励される。 ◎ User agents are similarly encouraged to keep careful track of the original line numbers, even in the face of document.write() calls mutating the document as it is parsed, or event handler content attributes spanning multiple lines.

  6. ~IF[ %~script の`~errorは黙秘する$sC ~EQ ~T ] ⇒# %~message ~SET `Script error.^l, %~url文字列 ~SET 空~文字列, %行番号 ~SET 0, %列番号 ~SET 0, %~error値 ~SET ~NULL ◎ If script's muted errors is true, then set message to "Script error.", urlString to the empty string, line and col to 0, and errorValue to null.
  7. %未取扱0 ~LET ~T ◎ Let notHandled be true.
  8. ~IF[ %標的 は `EventTarget$I を実装する ] ⇒ %未取扱0 ~SET %標的 に向けて,名前 `error$et の`~eventを発火する$ — `ErrorEvent$I を利用し,次のように初期化して ⇒# `cancelable$m ~SET ~T, `message$m ~SET %~message, `filename$m ~SET %~url文字列, `lineno$m ~SET %行番号, `colno$m ~SET %列番号, `error$m ~SET %~error値 ◎ If target implements EventTarget, then set notHandled to the result of firing an event named error at target, using ErrorEvent, with the cancelable attribute initialized to true, the message attribute initialized to message, the filename attribute initialized to urlString, the lineno attribute initialized to line, the colno attribute initialized to col, and the error attribute initialized to errorValue.
  9. %標的 を`~error報告ng~mode下$から外す ◎ Let target no longer be in error reporting mode.
  10. ~errorの`取扱済み~flag$err ~SET[ %未取扱0 ~EQ ~F ならば ~T / ~ELSE_ ~F ] ◎ If notHandled is false, then the error is handled. Otherwise, the error is not handled.

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

`例外を報告する@ ときは、所与の ( `~script$ %~script, 例外 %例外 ) に対し,次を走らすモノトスル:

  1. 次を与える下で,その`~errorを報告する$ ⇒# ~script: %~script, 問題箇所: %~script を包含している資源~内の問題箇所 ( 行番号, 列番号 ), 標的: %~script の`設定群~obj$sCの`大域~obj$enV
  2. ~IF[ %例外 の`取扱済み~flag$err ~EQ ~F ] ⇒ 任意選択で、 %例外 を~UAの開発者~consoleに報告する
◎ When the user agent is to report an exception E, the user agent must report the error for the relevant script, with the problematic position (line number and column number) in the resource containing the script, using the global object specified by the script's settings object as the target. If the error is still not handled after this, then the error may be reported to a developer console.

[ `~errorを報告する$, `例外を報告する$ ]の 2 つが存在するのは,紛らわしく、両~algoとも既知な問題がある。 課題 #958にて、この分野における将来の整理を追跡できる。 ◎ The existence of both report an error and report an exception is confusing, and both algorithms have known problems. You can track future cleanup in this area in issue #958.

`ErrorEvent$I ~interfaceは、次で定義される: ◎ The ErrorEvent interface is defined as follows:

[Exposed=(Window,Worker)]
interface `ErrorEvent@I : `Event$I {
  `constructor$(DOMString %type, optional `ErrorEventInit$I %eventInitDict = {});

  readonly attribute DOMString `message$m;
  readonly attribute USVString `filename$m;
  readonly attribute unsigned long `lineno$m;
  readonly attribute unsigned long `colno$m;
  readonly attribute any `error$m;
};

dictionary `ErrorEventInit@I : `EventInit$I {
  DOMString %message = "";
  USVString %filename = "";
  unsigned long %lineno = 0;
  unsigned long %colno = 0;
  any %error = null;
};
`message@m 取得子~手続きは、初期化-時の値を返す。 結果は、~error~messageを表現する。 ◎ The message attribute must return the value it was initialized to.\ It represents the error message.
`filename@m 取得子~手続きは、初期化-時の値を返す。 結果は、~scriptにおいて~errorが元々生じた所の`~URL$を表現する。 ◎ The filename attribute must return the value it was initialized to.\ It represents the URL of the script in which the error originally occurred.
`lineno@m 取得子~手続きは、初期化-時の値を返す。 結果は、~scriptにおいて~errorが元々生じた所の行番号を表現する。 ◎ The lineno attribute must return the value it was initialized to.\ It represents the line number where the error occurred in the script.
`colno@m 取得子~手続きは、初期化-時の値を返す。 結果は、~scriptにおいて~errorが元々生じた所の列番号を表現する。 ◎ The colno attribute must return the value it was initialized to.\ ◎ It represents the column number where the error occurred in the script.
`error@m 取得子~手続きは、初期化-時の値を返す。 結果は、適切になる所では,~errorを表現している~objになる(例: ~catchされなかった~DOM例外の事例では、例外~objになる)。 ◎ The error attribute must return the value it was initialized to.\ Where appropriate, it is set to the object representing the error (e.g., the exception object in the case of an uncaught DOM exception).

8.1.4.7. 未取扱いの~promise却下

同期的な`実行時~script~error$に加えて、~scriptは,非同期的な~promise却下に出くわすこともある — それは、[ `unhandledrejection$et, `rejectionhandled$et ]~eventを介して追跡される。 これらの却下の追跡は, `HostPromiseRejectionTracker^A 抽象-演算を介して行われるが、それらの報告-法は,ここで定義される。 ◎ In addition to synchronous runtime script errors, scripts may experience asynchronous promise rejections, tracked via the unhandledrejection and rejectionhandled events. Tracking these rejections is done via the HostPromiseRejectionTracker abstract operation, but reporting them is defined here.

`却下-済み~promiseについて通知する@ ときは、所与の ( `環境~設定群~obj$ %設定群~obj ) に対し: ◎ To notify about rejected promises on a given environment settings object settings object:

  1. %~list ~LET %設定群~obj の`通知待ちの却下-済み~promise~list$enVの複製 ◎ Let list be a copy of settings object's about-to-be-notified rejected promises list.
  2. ~IF[ %~list は空である ] ⇒ ~RET ◎ If list is empty, return.
  3. %設定群~obj の`通知待ちの却下-済み~promise~list$enVを~~空にする ◎ Clear settings object's about-to-be-notified rejected promises list.
  4. %大域~obj ~LET %設定群~obj の`大域~obj$enV ◎ Let global be settings object's global object.
  5. 次を走らす`大域~taskを~queueする$( `~DOM操作~task源$, %大域~obj ): ◎ Queue a global task on the DOM manipulation task source given global to run the following substep:

    1. %~list 内の ~EACH( ~promise %p ) に対し: ◎ For each promise p in list:

      1. ~IF[ %p の `PromiseIsHandled^sl 内部~slot ~EQ ~T ] ⇒ ~CONTINUE ◎ If p's [[PromiseIsHandled]] internal slot is true, continue to the next iteration of the loop.
      2. %未取扱0 ~LET %大域~obj に向けて,名前 `unhandledrejection$et の`~eventを発火する$ — `PromiseRejectionEvent$I を利用し,次のように初期化して ⇒# `cancelable$m ~SET ~T, `promise$m ~SET %p, `reason$m ~SET %p の `PromiseResult^sl 内部~slotの値 ◎ Let notHandled 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 the value of p's [[PromiseResult]] internal slot.
      3. ~IF[ %未取扱0 ~EQ ~F ] ⇒ この~promise却下の`取扱済み~flag$rej ~SET ~T ◎ If notHandled is false, then the promise rejection is handled. Otherwise, the promise rejection is not handled.
      4. ~IF[ %p の `PromiseIsHandled^sl 内部~slot ~EQ ~F ] ⇒ %設定群~obj の`未決の却下-済み~promiseへの弱い参照の集合$enVに %p を追加する ◎ If p's [[PromiseIsHandled]] internal slot is false, add p to settings object's outstanding rejected promises weak set.

この~algoは,~promise却下の `取扱済み~flag@rej を ~T にし得る — 各~promise却下には,この~flagが結付けられ、初期~時は ~F にされる(すなわち,~promise却下は `取扱済みでない@rej )。 これは、~script~errorに対する`取扱済み~flag$errと並行する概念である。 この~algoの結果、却下の`取扱済み~flag$rejが依然として ~F ならば、その却下は,~UAの開発者~consoleに報告されてもヨイ。 ◎ This algorithm results in promise rejections being marked as handled or not handled. These concepts parallel handled and not handled script errors. If a rejection is still not handled after this, then the rejection may be reported to a developer console.

`PromiseRejectionEvent$I ~interfaceは、次で定義される: ◎ The PromiseRejectionEvent interface is defined as follows:

[Exposed=(Window,Worker)]
interface `PromiseRejectionEvent@I : `Event$I {
  `constructor$(DOMString %type, `PromiseRejectionEventInit$I %eventInitDict);

  readonly attribute Promise<any> `promise$m;
  readonly attribute any `reason$m;
};

dictionary `PromiseRejectionEventInit@I : `EventInit$I {
  required Promise<any> %promise;
  any %reason;
};
`promise@m 取得子~手続きは、初期化-時の値を返す。 結果は、この通知が~~対象にしている~promiseを表現する。 ◎ The promise attribute must return the value it was initialized to.\ It represents the promise which this notification is about.
`reason@m 取得子~手続きは、初期化-時の値を返す。 結果は、~promiseの却下~事由を表現する。 ◎ The reason attribute must return the value it was initialized to.\ It represents the rejection reason for the promise.

8.1.5 ~JS仕様~host~hook

~JS仕様には,いくつかの`実装定義$な抽象-演算があり、~host環境に依存して変わる。 この節では、~UA~host用のそれらを定義する。 ◎ The JavaScript specification contains a number of implementation-defined abstract operations, that vary depending on the host environment. This section defines them for user agent hosts.

8.1.5.1. `HostEnqueuePromiseJob^A(%~job, %~realm)

~JS `JAVASCRIPT$r は、 `Promise^jc に関係する演算を~scheduleするための抽象-演算 `HostEnqueuePromiseJob$jA を`実装定義$としている。 ~HTMLは、それらの演算を小task~queue内で~scheduleする。 ~UAは、次の実装を利用するモノトスル: ◎ JavaScript contains an implementation-defined HostEnqueuePromiseJob(job, realm) abstract operation to schedule Promise-related operations. HTML schedules these operations in the microtask queue. User agents must use the following implementation: [JAVASCRIPT]

  1. %~job設定群 ~LET %~realm に応じて ⇒# ~NULL ならば ~NULL / ~ELSE_ %~realm 用の`設定群~obj$rM ◎ If realm is not null, then let job settings be the settings object for realm. Otherwise, let job settings be null.

    注記: %~realm ~NEQ ~NULL の場合、 %~realm は走らすことになる作者~codeが属する`~realm$になる — それは, %~job が[ `NewPromiseReactionJob$jA から返されたなら,当の~promiseの~handler関数 / `NewPromiseResolveThenableJob$jA から返されたなら,~promiseの `then^c 関数 ]が属する~realmになる。 ◎ If realm is not null, it is the Realm of the author code that will run. When job is returned by NewPromiseReactionJob, it is the realm of the promise's handler function. When job is returned by NewPromiseResolveThenableJob, it is the realm of the then function.

    %~realm ~EQ ~NULL 場合、走らす作者~codeは無いか, 作者~codeは投出することが保証される。 前者は、作者が走らすものを~code内で渡さなかったからであろう — `promise.then(null, null)^c など。 後者は、廃止された `Proxy^jc が渡されたからである。 どちらの事例でも、以下において %~job設定群 を利用する段は,すべて飛ばされることになる。 ◎ If realm is null, either no author code will run or author code is guaranteed to throw. For the former, the author may not have passed in code to run, such as in promise.then(null, null). For the latter, it is because a revoked Proxy was passed. In both cases, all the steps below that would otherwise use job settings get skipped.

  2. %現任の設定群 ~LET `現任の設定群~obj$ ◎ Let incumbent settings be the incumbent settings object.
  3. %作動中の~script ~LET `作動中の~script$ ◎ Let active script be the active script.
  4. %~script実行~文脈 ~LET ~NULL ◎ Let script execution context be null.
  5. ~IF[ %作動中の~script ~NEQ ~NULL ] ⇒ %~script実行~文脈 ~SET 次のようにされた新たな`~JS実行~文脈$ ⇒# ~Function~field ~SET ~NULL, ~Realm~field ~SET %作動中の~script の`設定群~obj$sCの`~Realm$enV, ~ScriptOrModule成分 ~SET %作動中の~script の`~record$sC ◎ If active script is not null, set script execution context to a new JavaScript execution context, with its Function field set to null, its Realm field set to active script's settings object's Realm, and its ScriptOrModule set to active script's record.

    注記: 下に見られるように,これは、現在の`作動中の~script$を,後で~jobを実行する時点まで伝播するために利用される。 ◎ As seen below, this is used in order to propagate the current active script forward to the time when the job is executed.

    %作動中の~script ~NEQ ~NULL のときに,この仕方でそれを保存することは、次の事例で有用になる: ◎ A case where active script is non-null, and saving it in this way is useful, is the following:

    Promise.resolve('import(``^./example.mjs``^)').then(eval);
    

    この段(および,それを利用する下の手続き)が無い場合、 `import()$m 式を評価するときに`作動中の~script$は無いことになる — `eval()$m は特定0の`~script$を出自にしない組込みの関数なので。 ◎ Without this step (and the steps below that use it), there would be no active script when the import() expression is evaluated, since eval() is a built-in function that does not originate from any particular script.

    この段が在れば, %作動中の~script は 上の~codeから~jobの中へ伝播され、 `import()$m は,元の~scriptの`基底~URL$sCを適切に利用できるようになる。 ◎ With this step in place, the active script is propagated from the above code into the job, allowing import() to use the original script's base URL appropriately.

    %作動中の~script は、利用者が次のような~buttonを~clickした場合には, ~NULL になり得る: ◎ active script can be null if the user clicks on the following button:

    <button onclick="Promise.resolve('import(``^./example.mjs``^)').then(eval)">Click me</button>
    

    この事例では、`~event~handler$用の~JS関数は,`~event~handlerの現在の値を取得する$~algoにより作成され、それは[ `ScriptOrModule^sl が ~NULL 値にされた関数 ]を作成することになる。 したがって、~promise機構が `HostEnqueuePromiseJob$A を~callするときも,渡される`作動中の~script$は無いことになる。 ◎ In this case, the JavaScript function for the event handler will be created by the get the current value of the event handler algorithm, which creates a function with null [[ScriptOrModule]] value. Thus, when the promise machinery calls HostEnqueuePromiseJob, there will be no active script to pass along.

    その帰結として、このことは,[ `import()$m 式が評価される時点でも,`作動中の~script$は依然として無い ]ことを意味する。 幸いにも、それは,この仕様による[ `HostResolveImportedModule$A, `HostImportModuleDynamically$A ]の実装により取扱われる — `現在の設定群~obj$の`~API用~基底~URL$enVを利用するよう~fall-backすることにより。 ◎ As a consequence, this means that when the import() expression is evaluated, there will still be no active script. Fortunately that is handled by our implementations of HostResolveImportedModule and HostImportModuleDynamically, by falling back to using the current settings object's API base URL.

  6. `~surrounding~agent$の`~event~loop$aGの中で,次の手続きを走らす`小taskを~queueする$: ◎ Queue a microtask on the surrounding agent's event loop to perform the following steps:

    1. ~IF[ %~job設定群 ~NEQ ~NULL ]: ◎ ↓

      1. ~IF[ `~scriptは走れるかどうか検査する$( %~job設定群 ) ~EQ `走るな^i ] ⇒ ~RET ◎ If job settings is not null, then check if we can run script with job settings. If this returns "do not run" then return.
      2. `~scriptを走らすために準備する$( %~job設定群 ) ◎ If job settings is not null, then prepare to run script with job settings.

        注記: これは、当の~jobが走っている間,`入口~某$の概念に影響する。 ◎ This affects the entry concept while the job runs.

    2. `~callbackを走らすために準備する$( %現任の設定群 ) ◎ Prepare to run a callback with incumbent settings.

      注記: これは、当の~jobが走っている間,`現任の某$の概念に影響する。 ◎ This affects the incumbent concept while the job runs.

    3. ~IF[ %~script実行~文脈 ~NEQ ~NULL ] ⇒ `~JS実行~文脈~stack$に %~script実行~文脈 を`~push$する ◎ If script execution context is not null, then push script execution context onto the JavaScript execution context stack.

      注記: 上で説明したように、これは,当の~jobが走っている間に`作動中の~script$に影響する。 ◎ As explained above, this affects the active script while the job runs.

    4. %結果 ~LET %~job() ◎ Let result be job().

      注記: %~job は[ `NewPromiseReactionJob$jA / `NewPromiseResolveThenableJob$jA ]から返された`抽象-~closure$である。 ◎ job is an abstract closure returned by NewPromiseReactionJob or NewPromiseResolveThenableJob.

    5. ~IF[ %~script実行~文脈 ~NEQ ~NULL ] ⇒ `~JS実行~文脈~stack$から %~script実行~文脈 を`~pop$する ◎ If script execution context is not null, then pop script execution context from the JavaScript execution context stack.
    6. `走らせた~callbackを片付ける$( %現任の設定群 ) ◎ Clean up after running a callback with incumbent settings.
    7. ~IF[ %~job設定群 ~NEQ ~NULL ] ⇒ `走らせた~scriptを片付ける$( %~job設定群 ) ◎ If job settings is not null, then clean up after running script with job settings.
    8. ~IF[ %結果 は`中途完了$である ] ⇒ `例外を報告する$( 当の~script, %結果 . `Value^sl ) ◎ If result is an abrupt completion, then report the exception given by result.[[Value]].

8.1.5.2. `HostEnsureCanCompileStrings^jA( %callerRealm, %calleeRealm )

~JS `JAVASCRIPT$r は、その抽象-演算 `HostEnsureCanCompileStrings$jA を`実装定義$としている。 ~UAは、次の実装を利用するモノトスル: ◎ JavaScript contains an implementation-defined HostEnsureCanCompileStrings(callerRealm, calleeRealm) abstract operation. User agents must use the following implementation: [JAVASCRIPT]

  1. ~ABRUPT `EnsureCSPDoesNotBlockStringCompilation$jA( %callerRealm, %calleeRealm) `CSP$r ◎ Perform ? EnsureCSPDoesNotBlockStringCompilation(callerRealm, calleeRealm). [CSP]

8.1.5.3. `HostPromiseRejectionTracker^jA( %promise, %演算 )

~JS `JAVASCRIPT$r は、その抽象-演算 `HostPromiseRejectionTracker$jA を`実装定義$としている。 ~UAは、次の実装を利用するモノトスル: ◎ JavaScript contains an implementation-defined HostPromiseRejectionTracker(promise, operation) abstract operation. User agents must use the following implementation: [JAVASCRIPT]

  1. %~script ~LET `走っている~script$ ◎ Let script be the running script.

  2. ~IF[ %~script の`~errorは黙秘する$sC ~EQ ~T ] ⇒ ~RET ◎ If script's muted errors is true, terminate these steps.
  3. %設定群~obj ~LET %~script の`設定群~obj$sC ◎ Let settings object be script's settings object.
  4. %~list ~LET %設定群~obj の`通知待ちの却下-済み~promise~list$enV ◎ ↓
  5. %演算 に応じて:

    `reject^l ◎ If operation is "reject",
    %~list に %promise を追加する ◎ Add promise to settings object's about-to-be-notified rejected promises list.
    `handle^l ◎ If operation is "handle",
    1. ~IF[ %promise ~IN %~list ] ⇒# %~list から %promise を除去する; ~RET ◎ If settings object's about-to-be-notified rejected promises list contains promise, then remove promise from that list and return.
    2. %弱い参照の集合 ~LET %設定群~obj の`未決の却下-済み~promiseへの弱い参照の集合$enV ◎ ↓
    3. ~IF[ %promise ~NIN %弱い参照の集合 ] ⇒ ~RET ◎ If settings object's outstanding rejected promises weak set does not contain promise, then return.
    4. %弱い参照の集合 から %promise を除去する ◎ Remove promise from settings object's outstanding rejected promises weak set.
    5. %大域~obj ~LET %設定群~obj の`大域~obj$enV ◎ Let global be settings object's global object.
    6. 次を走らす`大域~taskを~queueする$( `~DOM操作~task源$, %大域~obj ) ⇒ %大域~obj に向けて,名前 `rejectionhandled$et の`~eventを発火する$ — `PromiseRejectionEvent$I を利用し,次のように初期化して ⇒# `promise$m ~SET %promise, `reason$m ~SET %promise の `PromiseResult^sl 内部~slotの値 ◎ Queue a global task on the DOM manipulation task source given global to fire an event named rejectionhandled at global, using PromiseRejectionEvent, with the promise attribute initialized to promise, and the reason attribute initialized to the value of promise's [[PromiseResult]] internal slot.

8.1.5.4 ~moduleに関係する~host~hook

~JS仕様は、~module用の構文, および その処理~modelにおける ~hostに不問な部分を定義する。 この仕様は、その処理~modelの残りの部分 — ~module~systemが[ `type$a 属性が `module^l に設定された `script$e 要素 ]を介して~bootstrapされる方法,および ~moduleが[ ~fetchされ, 解決され, 実行される ]方法 — を定義する。 `JAVASCRIPT$r ◎ The JavaScript specification defines a syntax for modules, as well as some host-agnostic parts of their processing model. This specification defines the rest of their processing model: how the module system is bootstrapped, via the script element with type attribute set to "module", and how modules are fetched, resolved, and executed. [JAVASCRIPT]

注記: ~JS仕様は,[ “script” vs. “module” ]の用語で記されているが、この仕様は,一般に[ `古典~script$ vs. `~module~script$ ]の用語で記される — 両者とも `script$e 要素を利用するので。 ◎ Although the JavaScript specification speaks in terms of "scripts" versus "modules", in general this specification speaks in terms of classic scripts versus module scripts, since both of them use the script element.

%modulePromise = `import(specifier)$m
%specifier により識別される`~module~script$用の~module名前空間~obj用の~promiseを返す。 この~module~scriptの実行時における動的な~import法を許容する — `import^c 文の形を利用して,静的に~importする代わりに。 指定子 %specifier は、`作動中の~script$の`基底~URL$sCに相対的に 解決されることになる。 ◎ Returns a promise for the module namespace object for the module script identified by specifier. This allows dynamic importing of module scripts at runtime, instead of statically using the import statement form. The specifier will be resolved relative to the active script's base URL.
返される~promiseは、所与の指定子が妥当でないか[ `~import_~script~graphを~fetchする$ / 結果の~module~graphを評価する ]間に失敗に遭遇した場合には,却下される。 ◎ The returned promise will be rejected if an invalid specifier is given, or if a failure is encountered while fetching or evaluating the resulting module graph.
この構文は、[ `古典~script$, `~module~script$ ]どちらの内側でも利用できる。 したがって、古典~scriptの世界から~module~scriptの世界への橋渡しを供する。 ◎ This syntax can be used inside both classic and module scripts. It thus provides a bridge into the module-script world, from the classic-script world.
%url = `import . meta . url^c
`作動中の~script$の`基底~URL$sCを返す。 ◎ Returns the active module script's base URL.
この構文は、`~module~script$の内側に限り利用できる。 ◎ This syntax can only be used inside module scripts.

`~module~map@ とは、`~URL~record$から[ 次のいずれかとして与えられる値 ]への`~map$である。

  • `~module~script$
  • ~NULL — 失敗した~fetchを表現するために利用される
  • `fetching^l — 【~fetch後に前 2 項のいずれかの値に確定される,】 仮入力~値
◎ A module map is a map of URL records to values that are either a module script, null (used to represent failed fetches), or a placeholder value "fetching".\

`~module~map$は、[ ~importされた~JS~moduleが[ ~fetchされ, 構文解析され, 評価される ]のは,[ `文書$/`~worker$ ]ごとに一度限りになる ]ことを確保するために利用される。 ◎ Module maps are used to ensure that imported JavaScript modules are only fetched, parsed, and evaluated once per Document or worker.

`~module~map$は ~URLを~keyとするので、次の~codeは, `~module~map$内に 3 個の別々の~entryを作成させることになる — それらの結果は 3 個の異なる~URLになるので: ◎ Since module maps are keyed by URL, the following code will create three separate entries in the module map, since it results in three different URLs:

import "https://example.com/module.mjs";
import "https://example.com/module.mjs#map-buster";
import "https://example.com/module.mjs?debug=true";

すなわち、~URLの[ `~query$url, `素片$url ]の違いは無視されず,`~module~map$内に別個の~entryを作成させる。 したがって、 3 回の別々の~fetch, 3 回の別々の~module評価が遂行されることになる。 ◎ That is, URL queries and fragments can be varied to create distinct entries in the module map; they are not ignored. Thus, three separate fetches and three separate module evaluations will be performed.

対照的に、次の~codeにより`~module~map$内に作成される~entryは 1 個だけになる — これらの入力を`~URL構文解析-$した結果の`~URL$は、互いに等しくなるので: ◎ In contrast, the following code would only create a single entry in the module map, since after applying the URL parser to these inputs, the resulting URL records are equal:

import "https://example.com/module2.mjs";
import "https:example.com/module2.mjs";
import "https://///example.com\\module2.mjs";
import "https://example.com/foo/../module2.mjs";

よって、この~codeにより生じる~fetch, および~module評価は 1 回だけになる。 ◎ So in this second example, only one fetch and one module evaluation will occur.

この挙動は、`共用~worker$が構文解析された`構築子~url$を~keyとするときと同じであることに注意。 ◎ Note that this behavior is the same as how shared workers are keyed by their parsed constructor url.

`~module指定子を解決する@ 手続きは、所与の ( `~URL$ %基底~URL, `文字列$ %指定子 ) に対し,次を走らす — これは[ `~URL~record$, `失敗^i ]のいずれかを返す: ◎ To resolve a module specifier given a URL base URL and a string specifier, perform the following steps. It will return either a URL record or failure.

  1. %~URL ~LET `~URL構文解析する$( %指定子 ) ◎ Apply the URL parser to specifier.\
  2. ~IF[ %~URL ~NEQ `失敗^i ] ⇒ ~RET %~URL ◎ If the result is not failure, return the result.
  3. ~IF[ %指定子 の頭部は[ `/^l, `./^l, `../^l ]のいずれにも一致しない(文字 `/^l は `002F^U `SOLIDUS^cn, 文字 `.^l は `002E^U `FULL STOP^cn ) ] ⇒ ~RET `失敗^i ◎ If specifier does not start with the character U+002F SOLIDUS (/), the two-character sequence U+002E FULL STOP, U+002F SOLIDUS (./), or the three-character sequence U+002E FULL STOP, U+002E FULL STOP, U+002F SOLIDUS (../), return failure.

    注記: この制約は、将来に,“~~名前のみの” ~import指定子 — import `jquery^limport `web/crypto^l の様な指定子 — に特別な意味を与えるような,~custom~module読込器を許容できるようにするためにある。 今の所は、そのような~importは,相対~URLとして扱われることなく失敗することになる。 ◎ This restriction is in place so that in the future we can allow custom module loaders to give special meaning to "bare" import specifiers, like import "jquery" or import "web/crypto". For now any such imports will fail, instead of being treated as relative URLs.

  4. ~RET `~URL構文解析する$( %指定子, %基底~URL ) ◎ Return the result of applying the URL parser to specifier with base URL as the base URL.

次のものは、上の~algoに則って妥当な~module指定子になる: ◎ The following are valid module specifiers according to the above algorithm:

  • `https://example.com/apples.mjs^l
  • `http:example.com\pears.js^l ( `http://example.com/pears.js^l になる — 段 1 は基底~URLなしで構文解析するので) ◎ http:example.com\pears.js (becomes http://example.com/pears.js as step 1 parses with no base URL)
  • `//example.com/bananas^l
  • `./strawberries.mjs.cgi^l
  • `../lychees^l
  • `/limes.jsx^l
  • `data:text/javascript,export default 'grapes';^l
  • `blob:https://whatwg.org/d0360e2f-caee-469f-9a2f-87d5b0456f6f^l

次のものは,上の~algoに則って妥当な~module指定子になるが、`単独の~module~scriptを~fetchする$ときには,常に失敗にされる: ◎ The following are valid module specifiers according to the above algorithm, but will invariably cause failures when they are fetched:

  • `javascript:export default 'artichokes';^l
  • `data:text/plain,export default 'kale';^l
  • `about:legumes^l
  • `wss://example.com/celery^l

次のものは、上の~algoに則って妥当な~module指定子にならない: ◎ The following are not valid module specifiers according to the above algorithm:

  • `https://eggplant:b/c^l
  • `pumpkins.js^l
  • `.tomato^l
  • `..zucchini.mjs^l
  • `.\yam.es^l
8.1.5.4.1. `HostGetImportMetaProperties^jA( %~module~record )

~JS `JAVASCRIPT$r は、その抽象-演算 `HostGetImportMetaProperties$jA を`実装定義$としている。 ~UAは、次の実装を利用するモノトスル: ◎ JavaScript contains an implementation-defined HostGetImportMetaProperties abstract operation. User agents must use the following implementation: [JAVASCRIPT]

  1. %~module~script ~LET %~module~record . `HostDefined^sl ◎ Let module script be moduleRecord.[[HostDefined]].
  2. %~URL文字列 ~LET `~URLを直列化する$( %~module~script の`基底~URL$sC ) ◎ Let urlString be module script's base URL, serialized.
  3. ~RET « `Record^js{ `Key^sl: `url^l, `Value^sl: %~URL文字列 } » ◎ Return « Record { [[Key]]: "url", [[Value]]: urlString } ».
8.1.5.4.2. `HostImportModuleDynamically^jA( %参照元~scriptまたは~module, %指定子, %~promise能力 )

~JS `JAVASCRIPT$r は、その抽象-演算 `HostImportModuleDynamically$jA を`実装定義$としている。 ~UAは、次の実装を利用するモノトスル: ◎ JavaScript contains an implementation-defined HostImportModuleDynamically abstract operation. User agents must use the following implementation: [JAVASCRIPT]

  1. %設定群~obj ~LET `現在の設定群~obj$ ◎ Let settings object be the current settings object.
  2. ~IF[ %設定群~obj の`大域~obj$enVは `WorkletGlobalScope$I を実装する ]: ◎ If settings object's global object implements WorkletGlobalScope, then:

    1. %completion ~LET `Completion^js{ `Type^sl: `throw^js, `Value^sl: 新たな `TypeError$jc, `Target^sl: `empty^js } ◎ Let completion be Completion { [[Type]]: throw, [[Value]]: a new TypeError, [[Target]]: empty }.
    2. `FinishDynamicImport$jA( %参照元~scriptまたは~module, %指定子, %~promise能力, %completion ) ◎ Perform FinishDynamicImport(referencingScriptOrModule, specifier, promiseCapability, completion).
    3. ~RET ◎ Return.
  3. %基底~URL ~LET %設定群~obj の`~API用~基底~URL$enV ◎ Let base URL be settings object's API base URL.
  4. %~fetch~options ~LET `既定の古典~script~fetch~options$ ◎ Let fetch options be the default classic script fetch options.
  5. ~IF[ %参照元~scriptまたは~module ~NEQ ~NULL, ]: ◎ If referencingScriptOrModule is not null, then:

    1. %参照元~script ~LET %参照元~scriptまたは~module . `HostDefined^sl ◎ Let referencing script be referencingScriptOrModule.[[HostDefined]].
    2. %設定群~obj ~SET %参照元~script の`設定群~obj$sC ◎ Set settings object to referencing script's settings object.
    3. %基底~URL ~SET %参照元~script の`基底~URL$sC ◎ Set base URL to referencing script's base URL.
    4. %~fetch~options ~SET `子孫~script~fetch~options$( %参照元~script の`~fetch~options$sC ) ◎ Set fetch options to the descendant script fetch options for referencing script's fetch options.

    注記: 上の `HostResolveImportedModule$A にて説明したように、共通的な事例では %参照元~scriptまたは~module ~NEQ ~NULL になる。 ◎ As explained above for HostResolveImportedModule, in the common case, referencingScriptOrModule is non-null.

  6. 次を与える下で,`~import_~script~graphを~fetchする$ ⇒# %指定子, %基底~URL, %設定群~obj, %~fetch~options ◎ Fetch an import() module script graph given specifier, base URL, settings object, and fetch options.\
  7. 前~段の~algoが %結果 を結果として`非同期に完了-$するまで待機する ◎ Wait until the algorithm asynchronously completes with result.
  8. %完了 ~LET 次の下位手続きを走らせた結果: ◎ ↓

    1. ~IF[ %結果 ~EQ ~NULL ] ⇒ ~RET `Completion^js{ `Type^sl: `throw^js, `Value^sl: 新たな `TypeError$jc, `Target^sl: `empty^js } ◎ If result is null, then: • Let completion be Completion { [[Type]]: throw, [[Value]]: a new TypeError, [[Target]]: empty }. • Perform FinishDynamicImport(referencingScriptOrModule, specifier, promiseCapability, completion). • Return.
    2. `~module~scriptを走らす$( %結果, ~T ) ◎ Run the module script result, with the rethrow errors boolean set to true.
    3. ~IF[ 前~段で走らせた~module~scriptから例外が投出された ] ⇒ ~RET 投出された例外~完了 ◎ If running the module script throws an exception, then perform FinishDynamicImport(referencingScriptOrModule, specifier, promiseCapability, the thrown exception completion).
    4. ~RET `NormalCompletion$jA( `undefined^jv ) ◎ Otherwise, perform FinishDynamicImport(referencingScriptOrModule, specifier, promiseCapability, NormalCompletion(undefined)).
  9. 次を遂行する ⇒ `FinishDynamicImport$jA( %参照元~scriptまたは~module, %指定子, %~promise能力, %完了 ) ◎ ↑
  10. ~RET `undefined^jv ◎ Return undefined.
8.1.5.4.3. `HostResolveImportedModule^jA( %参照元~scriptまたは~module, %指定子 )

~JS `JAVASCRIPT$r は、その抽象-演算 `HostResolveImportedModule$jA を`実装定義$としている。 ~UAは、次の実装を利用するモノトスル: ◎ JavaScript contains an implementation-defined HostResolveImportedModule abstract operation. User agents must use the following implementation: [JAVASCRIPT]

  1. %設定群~obj ~LET `現在の設定群~obj$ ◎ Let settings object be the current settings object.
  2. %基底~URL ~LET %設定群~obj の`~API用~基底~URL$enV ◎ Let base URL be settings object's API base URL.
  3. ~IF[ %参照元~scriptまたは~module ~NEQ ~NULL ]: ◎ If referencingScriptOrModule is not null, then:

    1. %参照元~script ~LET %参照元~scriptまたは~module . `HostDefined^sl ◎ Let referencing script be referencingScriptOrModule.[[HostDefined]].
    2. %設定群~obj ~SET %参照元~script の`設定群~obj$sC ◎ Set settings object to referencing script's settings object.
    3. %基底~URL ~SET %参照元~script の`基底~URL$sC ◎ Set base URL to referencing script's base URL.

    %参照元~scriptまたは~module は通例的には ~NULL でないが、`~event~handlerの現在の値を取得する$~algoにより,~event~handler用にはそうなる。 例えば,次が与えられた下で: ◎ referencingScriptOrModule is not usually null, but will be so for event handlers per the get the current value of the event handler algorithm. For example, given:

    <button onclick="import('./foo.mjs')">Click me</button>
    

    `click$et ~eventが生じた場合、 `import()$m 式が走る時点で, `GetActiveScriptOrModule$jA は ~NULL を返すことになる — それが この抽象-演算に渡されるのは、 `FinishDynamicImport$jA が `HostResolveImportedModule$jA を~callするときである。 ◎ If a click event occurs, then at the time the import() expression runs, GetActiveScriptOrModule will return null, which will be passed to this abstract operation when HostResolveImportedModule is called by FinishDynamicImport.

  4. %~module~map ~LET %設定群~obj の`~module~map$enV ◎ Let moduleMap be settings object's module map.
  5. %~url ~LET `~module指定子を解決する$( %基底~URL, %指定子 ) ◎ Let url be the result of resolving a module specifier given base URL and specifier.
  6. ~Assert: %~url ~NEQ `失敗^i — 以前にも、同じ引数で`~module指定子を解決する$のに成功しているので( 対応している~module~scriptを作成する間か, `~import_~script~graphを~fetchする$間に)。 ◎ Assert: url is never failure, because resolving a module specifier must have been previously successful with these same two arguments (either while creating the corresponding module script, or in fetch an import() module script graph).
  7. %解決-済み~module~script ~LET %~module~map[ %~url ] ◎ Let resolved module script be moduleMap[url].\
  8. ~Assert: %解決-済み~module~script は`~module~script$である(すなわち, %解決-済み~module~script ~NIN { ε, ~NULL, `fetching^l } ) ◎ (This entry must exist for us to have gotten to this point.) ◎ Assert: resolved module script is a module script (i.e., is not null or "fetching").
  9. ~Assert: %解決-済み~module~script の`~record$sC ~NEQ ~NULL ◎ Assert: resolved module script's record is not null.
  10. ~RET %解決-済み~module~script の`~record$sC ◎ Return resolved module script's record.

8.1.6. ~event~loop

8.1.6.1. 各種~定義

~UAは、この節に述べる `~event~loop@ を利用して,[ ~event, 利用者~対話, ~script, 描画, ~networking, 等々 ]を互いに協調させるモノトスル。 ◎ To coordinate events, user interaction, scripts, rendering, networking, and so forth, user agents must use event loops as described in this section.\

各`~agent$には、 `~event~loop@aG が,その~agentに一意な`~event~loop$として結付けられる: ◎ Each agent has an associated event loop, which is unique to that agent.

  • `生成元が類似な~window~agent$の`~event~loop$aGは、 `~window~event~loop@ と称される。 ◎ The event loop of a similar-origin window agent is known as a window event loop.\
  • [ `専用~worker~agent$/`共用~worker~agent$/`~sw~agent$ ]の`~event~loop$aGは、 `~worker~event~loop@ と総称される。 ◎ The event loop of a dedicated worker agent, shared worker agent, or service worker agent is known as a worker event loop.\
  • `~worklet~agent$の`~event~loop$aGは、 `~worklet~event~loop@ と称される。 ◎ And the event loop of a worklet agent is known as a worklet event loop.

注記: `~event~loop$は、実装の~threadに対応するとは限らない。 例えば、複数の`~window~event~loop$が,単独の~thread内で協力的に~scheduleされることもある。 ◎ Event loops do not necessarily correspond to implementation threads. For example, multiple window event loops could be cooperatively scheduled in a single thread.

しかしながら,各種~worker`~agent$のうち, `CanBlock^sl を ~T に設定して割振られたものに対しては、~JS仕様は 前方-進捗 に関する要件を設置している — その要件は,実質的に、そのような事例においては,~agentごとに専用な~threadを要求することに相当する。 ◎ However, for the various worker agents that are allocated with [[CanBlock]] set to true, the JavaScript specification does place requirements on them regarding forward progress, which effectively amount to requiring dedicated per-agent threads in those cases.


各`~event~loop$には、 1 個以上の `~task~queue@ がある。 各`~task~queue$は、 0 個以上の`~task$からなる`集合$である。 ◎ An event loop has one or more task queues. A task queue is a set of tasks.

注記: `~task~queue$は`集合$であり,`~queue$ではない。 ~event~loop処理~modelの最初の段は、選ばれた~queueから — 最初の~taskを`~dequeueする$ことに代えて — 最初の`可走な~task$を取り出すので。 【`~queue$に対しては、そのような演算は許容されないことが前提にある。】 ◎ Task queues are sets, not queues, because step one of the event loop processing model grabs the first runnable task from the chosen queue, instead of dequeuing the first task.

注記: `小task~queue$は`~task~queue$ではない。 ◎ The microtask queue is not a task queue.

各~taskは、次に挙げるような作業を担当する~algoを~encapsulateする: ◎ Tasks encapsulate algorithms that are responsible for such work as:

~event ◎ Events
特定0の `EventTarget$I ~objに向けて `Event$I ~objを`配送-$するときは、専用の~taskで行われることが多い。 ◎ Dispatching an Event object at a particular EventTarget object is often done by a dedicated task.
注記: すべての~eventが`~task~queue$を利用して配送されるわけではない。 他の~taskの中で配送されるものも多々ある。 ◎ Not all events are dispatched using the task queue; many are dispatched during other tasks.
構文解析 ◎ Parsing
`~HTML構文解析器$が,~byte列を~token化して結果の~token列を処理することは、概して~taskになる。 ◎ The HTML parser tokenizing one or more bytes, and then processing any resulting tokens, is typically a task.
~callback ◎ Callbacks
~callbackを~callすることは、専用の~taskで行われることが多い。 ◎ Calling a callback is often done by a dedicated task.
資源の利用 ◎ Using a resource
~algoが ある資源を`~fetch$するとき,その~fetchingが他を阻まずに行われる場合、[ 資源の一部または~~全部が可用になったときの処理 ]は,何らかの~taskにより遂行される。 ◎ When an algorithm fetches a resource, if the fetching occurs in a non-blocking fashion then the processing of the resource once some or all of the resource is available is performed by a task.
~DOM操作に対する反応ng ◎ Reacting to DOM manipulation
一部の要素には、要素が`文書の中へ挿入された$ときなど,~DOM操作に呼応して誘発されるような~taskがある。 ◎ Some elements have tasks that trigger in response to DOM manipulation, e.g. when that element is inserted into the document.

`~task@ とは、正式には,次に挙げるものからなる`構造体$である: ◎ Formally, a task is a struct which has:

`手続き@tK ◎ Steps
この~taskが行うことになる作業を指定している一連の段。 ◎ A series of steps specifying the work to be done by the task.
`源@tK ◎ A source
この~taskが属するとされる,いずれかの`~task源$。 互いに関係する~taskを~group化して直列化する【順序通りに走らす】ために利用される。 ◎ One of the task sources, used to group and serialize related tasks.
`文書@tK ◎ A document
この~taskに結付けられる`文書$, または、`~window~event~loop$に属さない~task用には ~NULL 。 ◎ A Document associated with the task, or null for tasks that are not in a window event loop.
`~script評価 環境~設定群~obj集合@tK ◎ A script evaluation environment settings object set
0 個以上の`環境~設定群~obj$からなる`集合$ — この~taskを走らす間に~script評価を追跡するために利用される。 ◎ A set of environment settings objects used for tracking script evaluation during the task.

`~task$のうち、その`文書$tKは[ ~NULL または`全部的に作動中$ ]であるものを, `可走な~task@ という。 ◎ A task is runnable if its document is either null or fully active.

どの`~task$も,その`源$tKが指す特定の `~task源@ から来るものとして定義される。 各`~event~loop$においては、`~task源$ごとに,特定の`~task~queue$が結付けられるモノトスル†。 ◎ Per its source field, each task is defined as coming from a specific task source. For each event loop, every task source must be associated with a specific task queue.

【† 言い換えれば、所与の~task源には,各~event~loopごとに対応する~task~queueが 1 個だけある — または無い(その~task源からの~taskは決して~queueされない~event~loopの場合)。 】

注記: `~task源$は、本質的には,[ ~UAが判別したいと望むであろう,相異なる型の~taskどうし ]を各種~標準の中で論理的に分離するために利用される。 `~task~queue$は、所与の`~event~loop$の中で~task源たちを合体するために,~UAにより利用される。 ◎ Essentially, task sources are used within standards to separate logically-different types of tasks, which a user agent might wish to distinguish between. Task queues are used by user agents to coalesce task sources within a given event loop.

例えば~UAは、[ ~mouse/~Key ]等の~UI~event用には,ある一つの(`利用者~対話~task源$が結付けられた)`~task~queue$をあてがい、他のすべてには,別の(他の`~task源$が結付けられた)それをあてがうこともできる。 その上で,`~event~loop処理~model$の最初の段に是認される自由度を利用して、~UI~event用に 他すべての~taskの 3 倍程度の時間をあてがうこともできる — ~UIを即応可能に保ちながら,他の~task~queueも放置しないよう。 この設定下においても、この処理~modelにより,~UAは[ どの`~task源$に対しても,それに属する各~eventは必ず順序通りに処理する ]ことを施行することに注意。 ◎ For example, a user agent could have one task queue for mouse and key events (to which the user interaction task source is associated), and another to which all other task sources are associated. Then, using the freedom granted in the initial step of the event loop processing model, it could give keyboard and mouse events preference over other tasks three-quarters of the time, keeping the interface responsive but not starving other task queues. Note that in this setup, the processing model still enforces that the user agent would never process events from any one task source out of order.


各`~event~loop$には、次に挙げるものが結付けられる: ◎ ↓

`現在~走っている~task@
`~task$または~NULL — 初期~時には~NULLとする。 ◎ Each event loop has a currently running task, which is either a task or null. Initially, this is null.\
これは、再入性を取扱うために利用される。 ◎ It is used to handle reentrancy.
`小task~queue@
0 個以上の`小task$からなる`~queue$ — 初期~時には空とする。 ◎ Each event loop has a microtask queue, which is a queue of microtasks, initially empty.\
`小task@ は、`小taskを~queueする$~algoを介して作成された`~task$を指す,平易な呼称である。 ◎ A microtask is a colloquial way of referring to a task that was created via the queue a microtask algorithm.
`小task~checkpoint遂行-中@
真偽値であり、初期~時は ~F とする。 ◎ Each event loop has a performing a microtask checkpoint boolean, which is initially false.\
これは、`小task~checkpointを遂行する$~algoが再入的に呼出されるのを防止するために利用される。 ◎ It is used to prevent reentrant invocation of the perform a microtask checkpoint algorithm.
8.1.6.2. ~taskの~queue法

`~taskを~queueする@ ときは、所与の ( %~task源, %手続き, %~event~loop, %文書 ) に対し…:

  • これは,次のような形の句で呼出されることもある ⇒ “%~task源 から( %~event~loop の中で) %手続き を走らす`~taskを~queueする$”
  • %~task源 は`~task源$である 【これは,省略されることもある — その場合、呼出した文脈の他所で指定される( “この節にて~queueされる~taskの~task源は … とする” のように)。】
  • %手続き は何かを遂行する一連の段からなる
  • %~event~loop は`~event~loop$であり、省略時は`暗黙の~event~loop$とする
  • %文書 は`文書$または ~NULL であり、省略時は`暗黙の文書$とする
◎ To queue a task on a task source source, which performs a series of steps steps, optionally given an event loop event loop and a document document: • If event loop was not given, set event loop to the implied event loop. • If document was not given, set document to the implied document.
  1. %~queue ~LET %~event~loop に属する`~task~queue$のうち, %~task源 に結付けられているもの ◎ ↓
  2. %~task ~LET 次のようにされた新たな`~task$ ⇒# `手続き$tK ~SET %手続き, `源$tK ~SET %~task源, `文書$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する@ ときは、所与の ( `~task源$ %~task源, `大域~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源, %~event~loop, %文書, %手続き ) ◎ Queue a task given source, event loop, document, and steps.

【表記上の都合により,この訳では、】 これは,次の形で呼出されることもある ⇒ 次を走らす`大域~taskを~queueする$( %~task源, %大域~obj ) ⇒ ( %手続き の内容)

`要素~taskを~queueする@ ときは、所与の ( `~task源$ %~task源, 要素 %要素, 何かを遂行する一連の段 %手続き ) に対し: ◎ 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源, %大域~obj, %手続き ) ◎ Queue a global task given source, global, and steps.

【表記上の都合により,この訳では、】 これは,次の形で呼出されることもある ⇒ 次を走らす`要素~taskを~queueする$( %~task源, %要素 ) ⇒ ( %手続き の内容)

`小taskを~queueする@ ときは、所与の ( %手続き, %~event~loop, %文書 ) に対し…:

  • ~taskを~queueするときと同様に、これは,次のような形で呼出されることもある ⇒ “( %~event~loop の中で) %手続き を走らす`小taskを~queueする$”
  • %手続き は何かを遂行する一連の段からなる
  • %~event~loop は`~event~loop$であり、省略時は`暗黙の~event~loop$とする
  • %文書 は`文書$または ~NULL であり、省略時は`暗黙の文書$とする
◎ To queue a microtask which performs a series of steps steps, optionally given an event loop event loop and a document document: • If event loop was not given, set event loop to the implied event loop. • If document was not given, set document to the implied document.
  1. %~event~loop の`小task~queue$に[ 次のようにされた新たな`~task$ ]を`~enqueueする$ ⇒# `手続き$tK ~SET %手続き, `源$tK ~SET `小task~task源@, `文書$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 task's script evaluation environment settings object set to an empty set. ◎ Enqueue task on event loop's microtask queue.

注記: `小task$は、定例の`~task~queue$に移動されることもある — その初期~実行の間に,それが`~event~loopを回す$場合には。 当の小taskの[ `源$tK, `文書$tK, `~script評価 環境~設定群~obj集合$tK ]がアタられるのは、これが唯一の事例である — これらは、`小task~checkpointを遂行する$~algoからは無視される。 ◎ It is possible for a microtask to be moved to a regular task queue, if, during its initial execution, it spins the event loop. This is the only case in which the source, document, and script evaluation environment settings object set of the microtask are consulted; they are ignored by the perform a microtask checkpoint algorithm.

`~taskを~queueする$ときの `暗黙の~event~loop@ は、~callしている~algoの文脈から演繹できる それである。 これは、一般に一義的になる — ほとんどの仕様の~algoは、単独の`~agent$(したがって単独の`~event~loop$)しか孕まないので。 例外は、~agent間をまたがる通信を[ 指定する/孕む ]~algoである(例:~windowと~workerの間) — そのような事例では、仕様は,[ `~taskを~queueする$/`小taskを~queueする$ ]ときには — `暗黙の~event~loop$の概念に依拠することなく — 明示的に`~event~loop$を供さなければナラナイ。 ◎ The implied event loop when queuing a task is the one that can deduced from the context of the calling algorithm. This is generally unambiguous, as most specification algorithms only ever involve a single agent (and thus a single event loop). The exception is algorithms involving or specifying cross-agent communication (e.g., between a window and a worker); for those cases, the implied event loop concept must not be relied upon and specifications must explicitly provide an event loop when queuing a task or microtask.

`~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の`担当の文書$enV ◎ If the task is being queued by or for a script, then return the script's settings object's responsible document.
  5. ~Assert: この段に達することは決してない — ここまでの条件いずれかが満たされるはずなので。 本当か? ◎ Assert: this step is never reached, because one of the previous conditions must be true. Really?

[ `暗黙の~event~loop$/`暗黙の文書$ ]は、漠然と定義されていたため,たくさんの `action-at-a-distance^en がある 【遠くの動作が挙動に影響する —“バタフライ~~効果” の様に:参考】 。 たぶん、もっと明示的な~architectureを — すべての~call元が~event~loopや文書を明示的に指定する必要も避けるように — 思いつけるであろう。 ◎ Both implied event loop and implied document are vaguely-defined and have a lot of action-at-a-distance. Perhaps we can come up with a more explicit architecture, while still avoiding all callers needing to explicitly specify the event loop and document.

8.1.6.3. 処理~model

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

  1. %~task ~LET [ %~event~loop に属する`~task~queue$であって,`可走な~task$を包含するもの ]は[ 無いならば ε / 在るならば 次の下位手続きに従って決定される~task ]:

    1. %~task~queue ~LET 該当する~task~queueのうち,`実装定義$な方式で選ばれるいずれか
    2. %~task~queue から `可走な~task$のうち最初のものを`除去する$
    3. ~RET 前~段で除去した~task

    注記: `小task~queue$は`~task~queue$ではないので、この段で選ばれることはない。 しかしながら、`小task~task源$が結付けられた`~task~queue$が,この段で選ばれることもある。 その事例では,この段で選ばれる`~task$は、元々は`小task$であったが,`~event~loopを回す$一部として移動されたものになる。

    ◎ Let taskQueue be one of the event loop's task queues, chosen in an implementation-defined manner, with the constraint that the chosen task queue must contain at least one runnable task. If there is no such task queue, then jump to the microtasks step below. ◎ 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. ◎ Let oldestTask be the first runnable task in taskQueue, and remove it from taskQueue.
  2. ~IF[ %~task ~NEQ ε ]: ◎ ↓

    1. %~event~loop の`現在~走っている~task$ ~SET %~task ◎ Set the event loop's currently running task to oldestTask.
    2. %~task開始-時刻 ~LET `現在の高分解能~時刻$ ◎ Let taskStartTime be the current high resolution time.
    3. %~task を走らす ◎ Perform oldestTask's steps.
    4. %~event~loop の`現在~走っている~task$ ~SET ~NULL ◎ Set the event loop's currently running task back to null.
  3. `小task~checkpointを遂行する$ ◎ Microtasks: Perform a microtask checkpoint.
  4. %描画~機会がある ~LET ~F ◎ Let hasARenderingOpportunity be false.
  5. %now ~LET `現在の高分解能~時刻$ `HRT$r ◎ Let now be the current high resolution time. [HRT]
  6. ~IF[ %~task ~NEQ ε ](この段は、`~task$の所要時間を報告する): ◎ Report the task's duration by performing the following steps:

    1. %~top-level閲覧文脈たち ~LET 新たな`集合$ ◎ Let top-level browsing contexts be an empty set.
    2. %~task の`~script評価 環境~設定群~obj集合$tKを成す ~EACH( `環境~設定群~obj$ %設定群 ) に対し ⇒ %~top-level閲覧文脈たち に %設定群 の`~top-level閲覧文脈$を`付加する$set ◎ For each environment settings object settings of oldestTask's script evaluation environment settings object set, append setting's top-level browsing context to top-level browsing contexts.
    3. `長い~taskを報告する$( 次に挙げる引数 ) ⇒# %~task開始-時刻, %now(~taskの終止-時刻), %~top-level閲覧文脈たち, %~task ◎ Report long tasks, passing in taskStartTime, now (the end time of the task), top-level browsing contexts, and oldestTask.
  7. `描画を更新する@: ◎ Update the rendering:\

    ~IF[ %~event~loop は`~window~event~loop$である ]: ◎ if this is a window event loop, then:

    1. %文書たち ~LET `文書$のうち[ それに`関連な~agent$の`~event~loop$aG ~EQ %~event~loop ]を満たすものからなる~list — ~list内のどの 2 つの`文書$ %D1, %D2 に対しても、それらの順序は,次の条件を満たすモノトスル(条件~以外は任意): ◎ Let docs be all Document objects whose relevant agent's event loop is this event loop, sorted arbitrarily except that the following conditions must be met:

      • %D2 が`属する閲覧文脈$の`容器~文書$ ~EQ %D1 ならば、 %D2 は %D1 より後になる。 ◎ Any Document B whose browsing context's container document is A must be listed after A in the list.
      • [ %D1, %D2 が`属する閲覧文脈$ %B1, %B2 はともに`子~閲覧文脈$である ]~AND[ %B1, %B2 の`容器~文書$は同じ`文書$ %D である ]ならば、 %D1, %D2 の順序は,[ %D の`~node~tree$における`~shadowも含む~tree順序$ ]による[ %B1 の`容器$bc, %B2 の`容器$bc ]の順序に合致する。 ◎ If there are two documents A and B whose browsing contexts are both child browsing contexts whose container documents are another Document C, then the order of A and B in the list must match the shadow-including tree order of their respective browsing context 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.

    2. `描画~機会^i ⇒ %文書たち から次を満たす`文書$をすべて除去する ⇒ 文書が`属する閲覧文脈$には,`描画~機会$は無い ◎ Rendering opportunities: Remove from docs all Document objects whose browsing context do not have a rendering opportunity.

      次に該当する`閲覧文脈$には、 `描画~機会@ が有るとされる ⇒ ~UAは、現在[ ~hardware更新率による拘束 / 処理能の理由による~UAによる減速 ]を織り込む下で,利用者に`閲覧文脈$を成す内容を【一部でも】呈示-可能である — 表示域の外側に呈示-可能な内容も考慮して。 ◎ A browsing context has a rendering opportunity if the user agent is currently able to present the contents of the browsing context to the user, accounting for hardware refresh rate constraints and user agent throttling for performance reasons, but considering content presentable even if it's outside the viewport.

      `閲覧文脈$の`描画~機会$は、表示-更新率などの~hardwareによる拘束, その他の要因 — ~pageの処理能, ~pageは背後に~~回されているかどうかなど — に基づいて決定される。 描画~機会は、概して~~定期的に生じる。 ◎ Browsing context rendering opportunities are determined based on hardware constraints such as display refresh rates and other factors such as page performance or whether the page is in the background. Rendering opportunities typically occur at regular intervals.

      注記: この仕様は、描画~機会を選定する特定0の~modelは何ら義務付けない。 例えば,~browserが更新率 60Hz を達成しようと試みている場合、描画~機会が生じるのは,最大でも毎秒 60 回( およそ 16.7ms ごと)になる。 ~browserは、ある`閲覧文脈$に対し この更新率を維持-不能と見出した場合には,その閲覧文脈~用には — ~frameを時々落とすのではなく — 描画~機会を より維持-可能な毎秒 30 回に落とすこともある。 同様に,`閲覧文脈$は可視でない場合、~UAは,その~pageの描画~機会をずっと低速な毎秒 4 回 または それ未満にすら落とすものと裁定することもある。 ◎ This specification does not mandate any particular model for selecting rendering opportunities. But for example, if the browser is attempting to achieve a 60Hz refresh rate, then rendering opportunities occur at a maximum of every 60th of a second (about 16.7ms). If the browser finds that a browsing context is not able to sustain this rate, it might drop to a more sustainable 30 rendering opportunities per second for that browsing context, rather than occasionally dropping frames. Similarly, if a browsing context is not visible, the user agent might decide to drop that page to a much slower 4 rendering opportunities per second, or even less.

    3. ~IF[ %文書たち は空でない ] ⇒ %描画~機会がある ~SET ~T ◎ If docs is not empty, then set hasARenderingOpportunity to true.
    4. `不必要な描画^i ⇒ %文書たち から次の両~条件を満たす`文書$をすべて除去する: ◎ Unnecessary rendering: Remove from docs all Document objects which meet both of the following conditions:

      • ~UAは、`文書$が`属する閲覧文脈$の描画を更新しても,可視な効果はないものと予見している ◎ The user agent believes that updating the rendering of the Document's browsing context would have no visible effect, and
      • `文書$の`~animation~frame~callback~map$は空である ◎ The Document'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 preferrable to skip updating the rendering for other reasons.

      注記:

      • `描画~機会^i 段は、新たな内容を利用者に呈示-不能なとき(`描画~機会$が無いとき)に,~UAが描画を更新するのを防止する。 ◎ The step labeled Rendering opportunities prevents the user agent from updating the rendering when it is unable to present new content to the user (there's no rendering opportunity).
      • `不必要な描画^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( %文書 ) ” は、 %文書たち を成す`文書$のうち,[ 当の段を走らす時点において,`全部的に作動中$である ]ものたちに対し,順に繰り~~返すものとする: ◎ ↓

      1. ~EACH( %文書 ) に対し ⇒ ~IF[ %文書 が`属する閲覧文脈$は`~top-level閲覧文脈$である ] ⇒ `自動focus候補たちを洗出す$( %文書 ) ◎ For each fully active Document in docs, flush autofocus candidates for that Document if its browsing context is a top-level browsing context.
      2. ~EACH( %文書 ) に対し ⇒ `文書の~resize手続き$( %文書, %now ) `CSSOMVIEW$r ◎ For each fully active Document in docs, run the resize steps for that Document, passing in now as the timestamp. [CSSOMVIEW]
      3. ~EACH( %文書 ) に対し ⇒ `文書の~scroll手続き$( %文書, %now ) `CSSOMVIEW$r ◎ For each fully active Document in docs, run the scroll steps for that Document, passing in now as the timestamp. [CSSOMVIEW]
      4. ~EACH( %文書 ) に対し ⇒ `文書~用の媒体~queryを評価して変化を報告する$( %文書, %now ) `CSSOMVIEW$r ◎ For each fully active Document in docs, evaluate media queries and report changes for that Document, passing in now as the timestamp. [CSSOMVIEW]
      5. ~EACH( %文書 ) に対し ⇒ `~animationを更新して~eventを送信する$( %文書, %now ) `WEBANIMATIONS$r ◎ For each fully active Document in docs, update animations and send events for that Document, passing in now as the timestamp. [WEBANIMATIONS]
      6. ~EACH( %文書 ) に対し ⇒ `全screen化~手続き$( %文書, %now ) `FULLSCREEN$r ◎ For each fully active Document in docs, run the fullscreen steps for that Document, passing in now as the timestamp. [FULLSCREEN]
      7. ~EACH( %文書 ) に対し ⇒ `各~animation~frame~callbackを走らす$( %文書, %now ) ◎ For each fully active Document in docs, run the animation frame callbacks for that Document, passing in now as the timestamp.
      8. ~EACH( %文書 ) に対し ⇒ `交差~観測nを更新する$( %文書, %now ) `INTERSECTIONOBSERVER$r ◎ For each fully active Document in docs, run the update intersection observations steps for that Document, passing in now as the timestamp. [INTERSECTIONOBSERVER]
      9. ~EACH( %文書 ) に対し ⇒ `塗り計時を刻む$( %文書, %now ) `PAINTTIMING$r ◎ Invoke the mark paint timing algorithm for each Document object in docs.
      10. ~EACH( %文書 ) に対し ⇒ [ %文書, および それが`属する閲覧文脈$ ]の描画や~UIを,現在の状態を反映するように更新する ◎ For each fully active Document in docs, update the rendering or user interface of that Document and its browsing context to reflect the current state.

      【 上に挙げられた手続きには %now 引数を明示的にとらないものもあるが、手続きが何らかの`~eventを発火する$場合,暗黙的に それに %now が渡される(その~eventの `timeStamp$m 属性に利用される)ことになろう。 】

  8. ~IF[ 次がすべて満たされる ]…: ◎ If all of the following are true

    • %~event~loop は`~window~event~loop$である ◎ this is a window event loop
    • %~event~loop の`~task~queue$を成すどの`~task$も,その`文書$tKは`全部的に作動中$でない ◎ there is no task in this event loop's task queues whose document is fully active
    • %~event~loop の`小task~queue$は`空$である ◎ this event loop's microtask queue is empty
    • %描画~機会がある ~EQ ~F ◎ hasARenderingOpportunity is false

    …ならば ⇒ `~window$のうち[ それに`関連な~agent$の`~event~loop$aG ~EQ %~event~loop ]を満たす ~EACH( %~window ) に対し ⇒ `遊休期間を開始する$( %~window ) `REQUESTIDLECALLBACK$r ◎ then for each Window object whose whose relevant agent's event loop is this event loop, run the start an idle period algorithm, passing the Window. [REQUESTIDLECALLBACK]

  9. ~IF[ %~event~loop は`~worker~event~loop$である ]: ◎ If this is a worker event loop, then:

    1. %~worker ~LET %~event~loop の`~agent$の単独の`~realm$の`大域~obj$rM ◎ ↓
    2. ~IF[ %~worker は ~supportされる `DedicatedWorkerGlobalScope$I である ]~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 `現在の高分解能~時刻$ `HRT$r ◎ Let now be the current high resolution time. [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.

    3. ~IF[ %~event~loop 内のどの`~task~queue$も空である ]~AND[ `WorkerGlobalScope$I ~objの`~close中~flag$ ~EQ ~T ]:

      1. この手続きは中止した上で, %~event~loop を破壊する
      2. § ~Web~worker に述べられる`~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.

`小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$ %設定群 ) に対し ⇒ ~IF[ %設定群 の`担当の~event~loop$enV ~EQ %~event~loop ] ⇒ %設定群 に対し,`却下-済み~promiseについて通知する$ ◎ For each environment settings object whose responsible event loop is this event loop, notify about rejected promises on that environment settings object.
  6. Indexed Database ~transactionを片付ける ◎ Cleanup Indexed Database transactions.
  7. %~event~loop の`小task~checkpoint遂行-中$ ~SET ~F ◎ Set the event loop's performing a microtask checkpoint to false.

~UAは、`並列的$に走っている %~algo において, `安定~状態を待受ける@ ときは、次の手続きを走らす`小taskを~queueする$と同時に, %~algo 自身の実行は いったん停止するモノトスル(その実行は、下の手続きに述べるように,小taskを走らせたとき再開される): ◎ 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):

  1. %~algo 内の `同期区間@ を走らす ◎ Run the algorithm's synchronous section.
  2. %~algo の記述にしたがって,適切になるなら、 %~algo の`並列的$な実行を再開する ◎ Resumes execution of the algorithm in parallel, if appropriate, as described in the algorithm's steps.

注記: %~algo 内の`同期区間$は、~~記号 ⌛ が付与される段として与えられる。 【が,和訳では、その~~記号に代えて,明示的な句の下で下位手続きに~group化して与えることもある。】 ◎ Steps in synchronous sections are marked with ⌛.


~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源 ~LET %~task の`源$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源 から 次を走らす`~taskを~queueする$: ◎ 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の挙動は,~programming言語の関数~callに類似するが、`~event~loopを回す$は,それと違って もっと~macroに~~近く、~~利用された箇所にて一連の[ 段/演算 ]に展開することにより~~字数と~~字下げを節約する。 ◎ Unlike other algorithms in this and other specifications, which behave similar to programming-language function calls, spin the event loop is more like a macro, which saves typing and indentation at the usage site by expanding into a series of steps and operations.

次の手続きが成す~algoは: ◎ An algorithm whose steps are:

  1. ~~動作 1 を行う ◎ Do something.
  2. スゴイことが起きるまで`~event~loopを回す$ ◎ Spin the event loop until awesomeness happens.
  3. ~~動作 2 を行う ◎ Do something else.

“~macro展開” の後は 次のようになる,略記である: ◎ is a shorthand which, after "macro expansion", becomes

  1. ~~動作 1 を行う ◎ Do something.
  2. %旧~stack ~LET `~JS実行~文脈~stack$の複製 ◎ Let old stack be a copy of the JavaScript execution context stack.
  3. `~JS実行~文脈~stack$を空にする ◎ Empty the JavaScript execution context stack.
  4. `小task~checkpointを遂行する$ ◎ Perform a microtask checkpoint.
  5. この段は`並列的$に走らす: ◎ In parallel:

    1. スゴイことが起きるまで待機する ◎ Wait until awesomeness happens.
    2. “~~動作 1 を行う” を行わせた ~task源から次を走らす`~taskを~queueする$: ◎ Queue a task on the task source in which "do something" was done to:

      1. `~JS実行~文脈~stack$を %旧~stack に置換する ◎ Replace the JavaScript execution context stack with old stack.
      2. ~~動作 2 を行う ◎ Do something else.

代用を成す もっと全部的な例を与える。 ここでは、~event~loopは[ 並列的な作業~内から~queueされた,ある~taskの内側 ]から回される。 まず、`~event~loopを回す$を利用する~version: ◎ Here is a more full example of the substitution, where the event loop is spun from inside a task that is queued from work in parallel. The version using spin the event loop:

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

    1. 並列的~~動作 1 を行う ◎ Do parallel thing 1.
    2. `~DOM操作~task源$から 次を走らす`~taskを~queueする$: ◎ Queue a task on the DOM manipulation task source to:

      1. ~task~~動作 1 を行う ◎ Do task thing 1.
      2. スゴイことが起きるまで`~event~loopを回す$ ◎ Spin the event loop until awesomeness happens.
      3. ~task~~動作 2 を行う ◎ Do task thing 2.
    3. 並列的~~動作 2 を行う ◎ Do parallel thing 2.

次に、全部的に展開された~version: ◎ The fully expanded version:

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

    1. 並列的~~動作 1 を行う ◎ Do parallel thing 1.
    2. %旧~stack ~LET ~NULL ◎ Let old stack be null.
    3. `~DOM操作~task源$から 次を走らす`~taskを~queueする$: ◎ Queue a task on the DOM manipulation task source to:

      1. ~task~~動作 1 を行う ◎ Do task thing 1.
      2. %旧~stack ~SET `~JS実行~文脈~stack$の複製 ◎ Set old stack to a copy of the JavaScript execution context stack.
      3. `~JS実行~文脈~stack$を空にする ◎ Empty the JavaScript execution context stack.
      4. `小task~checkpointを遂行する$ ◎ Perform a microtask checkpoint.
    4. スゴイことが起きるまで待機する ◎ Wait until awesomeness happens.
    5. `~DOM操作~task源$から 次を走らす`~taskを~queueする$: ◎ Queue a task on the DOM manipulation task source to:

      1. `~JS実行~文脈~stack$を %旧~stack に置換する ◎ Replace the JavaScript execution context stack with old stack.
      2. ~task~~動作 2 を行う ◎ Do task thing 2.
    6. 並列的~~動作 2 を行う ◎ Do parallel thing 2.

歴史的な理由から、この仕様の~algoのうち一部は,`~task$ %~task が走っている間,所与の %目標 が満たされるまで、~UAに `静止-@ することを要求する。 これは、次の手続きを走らすことを意味する: ◎ 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. 必要とされるなら、[ `文書$ / `閲覧文脈$ ]の描画や~UIを,現在の状態を反映するように更新する ◎ If necessary, update the rendering or user interface of any Document or browsing context to reflect the current state.
  2. %目標 が満たされるまで待機する — ~UAが %~task を`静止-$している間は:

    • %~task が属している`~event~loop$は、他の`~task$は走らせないモノトスル。
    • `現在~走っている~task$における~script実行は、阻まれるモノトスル。
    • ~UAは、利用者~入力に対しては即応可能であり続けるべきである — しかしながら、`~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.

`静止-$は、とりわけ,複数の文書が単独の`~event~loop$を共有している局面では、利用者~体験をひどく~~害する。 ~UAには、既存の内容との互換性を保全しつつアリなら,`静止-$の別法 — `~event~loopを回す$, あるいは単純に あらゆる種類の実行を休止させずに,続行するなど — を試験することが奨励される。 より円滑で~web互換な別法が発見されたなら、この仕様は,積極的にそれを取り入れることになる。 ◎ Pausing is highly detrimental to the user experience, especially in scenarios where a single event loop is shared among multiple documents. User agents are encouraged to experiment with alternatives to pausing, such as spinning the event loop or even simply proceeding without any kind of suspended execution at all, insofar as it is possible to do so while preserving compatibility with existing content. This specification will happily change if a less-drastic alternative is discovered to be web-compatible.

実装者は、~UAが試験し得る様々な別法が,`~event~loop$の挙動の微妙な側面 — `~task$や`小task$の時機も含め — を変更し得ることを,当分の間は自覚しておくべきである。 実装は、そうすることが `静止-$演算に含意される正確な意味論に違反するとしても,試験し続けるべきである。 ◎ In the interim, implementers should be aware that the variety of alternatives that user agents might experiment with can change subtle aspects of event loop behavior, including task and microtask timing. Implementations should continue experimenting even if doing so causes them to violate the exact semantics implied by the pause operation.

8.1.6.4. 汎用の~task源

次に挙げる`~task源$は、[ この/他の ]仕様における,互いにほぼ無関係な,いくつもの特能により利用される: ◎ The following task sources are used by a number of mostly unrelated features in this and other specifications.

`~DOM操作~task源@ ◎ The DOM manipulation task source
この`~task源$は、~DOM操作に反応する特能のために利用される — 要素が`文書の中へ挿入された$ときに,他を阻まずに起きるものなど。 ◎ This task source is used for features that react to DOM manipulations, such as things that happen in a non-blocking fashion when an element is inserted into the document.
`利用者~対話~task源@ ◎ The user interaction task source
この`~task源$は、利用者~対話に反応する特能のために利用される — 例えば[ ~keyboard/~mouse ]入力。 ◎ This task source is used for features that react to user interaction, for example keyboard or mouse input.
利用者~入力に呼応して送信される~event(例: `click$et ~event `UIEVENTS$r )は、`利用者~対話~task源$により`~queueされ$る`~task$を利用して発火するモノトスル。 ◎ Events sent in response to user input (e.g. click events) must be fired using tasks queued with the user interaction task source. [UIEVENTS]
`~network用~task源@ ◎ The networking task source
この`~task源$は、~network活動に呼応して誘発される特能のために利用される。 ◎ This task source is used for features that trigger in response to network activity.
`履歴~走査~task源@ ◎ The history traversal task source
この`~task源$は、 `history.back()$m や, それに類似する~APIへの~callを~queueするために利用される。 ◎ This task source is used to queue calls to history.back() and similar APIs.

8.1.6.5. 他の仕様における~event~loopの~~扱い方

`~event~loop$と正しくヤリトリするように仕様を書くことは、込み入ったものにもなり得る。 これは、この仕様による,同時並行的~modelに依存しない用語体系 — “~main~thread” / “~background~thread上で” の様な,その種の~modelに特有な馴染みの用語に代えて, “`~event~loop$”, “`並列的$” などの語 — の用-法により構成される。 ◎ Writing specifications that correctly interact with the event loop can be tricky. This is compounded by how this specification uses concurrency-model-independent terminology, so we say things like "event loop" and "in parallel" instead of using more familiar model-specific terms like "main thread" or "on a background thread".

既定では、仕様~textは,一般に`~event~loop$上で走る。 これは、正式な`~event~loop処理~model$から外へ出る — すなわち,ほとんどの~algoは、跡を辿れば,最終的には そこへ`~queueされ$る`~task$に戻る。 【!*】 ◎ By default, specification text generally runs on the event loop. This falls out from the formal event loop processing model, in that you can eventually trace most algorithms back to a task queued there.

どの~JS~methodも、その~algoを成す手続きは,作者~codeがその~methodを~callすることにより呼出される。 また、作者~codeが走れるのは,~queueされた~taskを介してのみであり、通例的に, `script^e 処理~model 内のどこかを出自にしている。 ◎ The algorithm steps for any JavaScript method will be invoked by author code calling that method. And author code can only be run via queued tasks, usually originating somewhere in the script processing model.

この出発点から上書きするときの指針は: 仕様が遂行する必要がある作業のうち[ `並列的$に遂行しなければ`~event~loop$を阻むことになる ]ものは、何であれ そのように遂行されなければナラナイ。 これには、少なくとも次が含まれる: ◎ From this starting point, the overriding guideline is that any work a specification needs to perform that would otherwise block the event loop must instead be performed in parallel with it. This includes (but is not limited to):

  • 重い計算を遂行するとき。 ◎ performing heavy computation;
  • 利用者に~promptを表示するとき。 ◎ displaying a user-facing prompt;
  • 外側の~systemも孕み得る(すなわち, “~UA処理-の外へ出る” )ような演算を遂行するとき。 ◎ performing operations which could require involving outside systems (i.e. "going out of process").

次に挙がる複雑問題は,~algoの`並列的$な区間であり、そこでは,特定の[ `~JS~realm$ / `大域~obj$ / `環境~設定群~obj$ ]に結付けられた~objを作成したり, 操作してはナラナイ(馴染みの用語で言明するなら、~main~threadによる遺物に,~background~threadから直に~accessしないモノトスル)。 そうすると,~JS~codeから観測-可能な~data競争が生じることになる — ~algoのそれ以降の手続きは、~JS~codeと`並列的$に走っているので。 ◎ The next complication is that, in algorithm sections that are in parallel, you must not create or manipulate objects associated to a specific JavaScript realm, global, or environment settings object. (Stated in more familiar terms, you must not directly access main-thread artifacts from a background thread.) Doing so would create data races observable to JavaScript code, since after all, your algorithm steps are running in parallel to the JavaScript code.

しかしながら,仕様~levelの~data構造 — `Infra^cite `INFRA$r にて定義されるものなど — は、操作できる。 それらは~realmに不問なので、~JSに直に公開されることは決してなく,特定の変換( Web IDL による`変換-$xを介するものが多い)がそこを占めることはないので。 `WEBIDL$r ◎ You can, however, manipulate specification-level data structures and values from Infra, as those are realm-agnostic. They are never directly exposed to JavaScript without a specific conversion taking place (often via Web IDL). [INFRA] [WEBIDL]

次に,観測-可能な~JS~objの世界に影響させるためには、次に従わなければナラナイ: ◎ To affect the world of observable JavaScript objects, then, you must\

  • そのような操作は、それを遂行する~taskとして`~queueする$こと。 これは、当の手続きが,`~event~loop$にて起こる他の~taskの合間に適正に差挟まれることを確保する。 ◎ queue a task to perform any such manipulations. This ensures your steps are properly interleaved with respect to other things happening on the event loop.\
  • 加えて,`~taskを~queueする$ときは`~task源$も選ぶこと。 これは、自他の手続きの相対的な遂行-順序を統治する。 どの`~task源$を利用するか定かでない場合は、 汎用の~task源 から,最も適用-可能と思しきものを~~選ぶこと。 ◎ Furthermore, you must choose a task source when queuing a task; this governs the relative order of your steps versus others. If you are unsure which task source to use, pick one of the generic task sources that sounds most applicable.

`~taskを~queueする$ほとんどの呼出nは、`暗黙の~event~loop$ — すなわち,文脈から明らかなもの — を利用する。 ~algoが複数の~event~loopを孕んでいる文脈から呼出されることは、ごく稀にしかないので。 例えば`~worker$の操作-法を~~扱う仕様を書いていない限り、この引数は,`~taskを~queueする$ときには省略できる(複数の大域~objを孕むような文脈と違って,それは あらゆるときに起きているので)。 ◎ Most invocations of queue a task use the implied event loop, i.e., the one that is obvious from context. That is because it is very rare for algorithms to be invoked in contexts involving multiple event loops. (Unlike contexts involving multiple global objects, which happen all the time!) So unless you are writing a specification which, e.g., deals with manipulating workers, you can omit this argument when queuing a task.

以上をまとめれば、非同期に作業する必要がある~algo用の代表的な雛形は,次のようになる: ◎ Putting this all together, we can provide a template for a typical algorithm that needs to do work asynchronously:

  1. 同期的に設定しておく作業があれば,まずそれを行う — 依然として`~event~loop$上にある間に。 これは、`~JS~realm$に特有な~JS値を,~realmに不問な仕様~levelの値に 変換することも含み得る。 ◎ Do any synchronous setup work, while still on the event loop. This may include converting realm-specific JavaScript values into realm-agnostic specification-level values.
  2. 高価にもなり得る,次を行うような一連の段を、`並列的$に遂行する ⇒ ~realmにまったく不問な値に演算して,~realmに不問な結果を生産する ◎ Perform a set of potentially-expensive steps in parallel, operating entirely on realm-agnostic values, and producing a realm-agnostic result.
  3. 指定された`~task源$から,次を走らす`~taskを~queueする$ ⇒ ~realmに不問な結果を変換して、`~event~loop$上の,~JS~objが成す観測-可能な世界における観測-可能な効果に戻す ◎ Queue a task, on a specified task source, to convert the realm-agnostic result back into observable effects on the observable world of JavaScript objects on the event loop.

渡された[ 0 個以上の`~scalar値~文字列$からなる`~list$ ] %入力 を,~URLとして構文解析した上で “暗号化する” ~algoの例: ◎ The following is an algorithm that "encrypts" a passed-in list of scalar value strings input, after parsing them as URLs:

  1. %~url~list ~LET 空`~list$ ◎ Let urls be an empty list.
  2. %入力 内の `~EACH$( %文字列 ) に対し: ◎ For each string of input:

    1. %解析済み ~LET %文字列 を`現在の設定群~obj$に`相対的に構文解析-$した結果 ◎ Let parsed be the result of parsing string relative to the current settings object.
    2. IF[ %解析済み ~EQ `失敗^i ] ⇒ ~RET `SyntaxError$E 例外で却下される~promise ◎ If parsed is failure, return a promise rejected with a "SyntaxError" DOMException.
    3. %直列形 ~LET `~URLを直列化する$( %解析済み ) ◎ Let serialized be the result of applying the URL serializer to parsed.
    4. %~url~list に %直列形 を`付加する$ ◎ Append serialized to urls.
  3. %~realm ~LET `現在の~Realm~Record$ ◎ Let realm be the current Realm Record.
  4. %p ~LET 新たな~promise ◎ Let p be a new promise.
  5. 次の手続きは`並列的$に走らす: ◎ Run the following steps in parallel:

    1. %暗号形~URL~list ~LET 空`~list$ ◎ Let encryptedURLs be an empty list.
    2. %~url~list 内の `~EACH$( %~url ) に対し: ◎ For each url of urls:

      1. 100 ~milli秒間~待機する — 暗号化の重い計算は、その間に行われるとする。 ◎ Wait 100 milliseconds, so that people think we're doing heavy-duty encryption.
      2. %暗号形 ~LET 前~段の間に %~url から導出された新たな`文字列$ 【! whose nth code unit is equal to url's nth code unit plus 13】 ◎ Let encrypted be a new string derived from url, whose nth code unit is equal to url's nth code unit plus 13.
      3. %暗号形~URL~list に %暗号形 を`付加する$ ◎ Append encrypted to encryptedURLs.
    3. `~network用~task源$から,次を走らす`~taskを~queueする$: ◎ Queue a task, on the networking task source, to perform the following steps:

      1. %配列 ~LET %暗号形~URL~list を %~realm 内の~JS配列に`変換-$xした結果 ◎ Let array be the result of converting encryptedURLs to a JavaScript array, in realm.
      2. %配列 で %p を解決する ◎ Resolve p with array.
  6. ~RET %p ◎ Return p.

この~algoには、注目すべき点がいくつかある: ◎ Here are several things to notice about this algorithm:

  • 前もって,`~event~loop$上で~URLの構文解析を行っている — `並列的$な手続きに入る前に。 これが必要とされるのは、構文解析が依存している`現在の設定群~obj$は,`並列的$に行った後における`現在の設定群~obj$ではなくなるためである。 ◎ It does its URL parsing up front, on the event loop, before going to the in parallel steps. This is necessary, since parsing depends on the current settings object, which would no longer be current after going in parallel.
  • 別法として、`現在の設定群~obj$の`~API用~基底~URL$enVへの参照を保存してから,`並列的$な手続きの間にそれを利用しても等価になる。 しかしながら,上の例が行なっているように、前もってアリな限り多くの作業を行うことが推奨される。 正しい値を保存しようと試みるのは、誤りを導き易くなりがちなので — 例えば、`~API用~基底~URL$enVに代えて,単に`現在の設定群~obj$を保存した場合、競争が生じ得ることになる。 ◎ Alternately, it could have saved a reference to the current settings object's API base URL and used it during the in parallel steps; that would have been equivalent. However, we recommend instead doing as much work as possible up front, as this example does. Attempting to save the correct values can be error prone; for example, if we'd saved just the current settings object, instead of its API base URL, there would have been a potential race.
  • `文字列$の`~list$を、初期~手続きから`並列的$な手続きに暗黙的に渡している。 `~list$, `文字列$とも,`~JS~realm$には不問なので、そうしても差し支えない。 ◎ It implicitly passes a list of strings from the initial steps to the in parallel steps. This is OK, as both lists and strings are realm-agnostic.
  • “高価な計算” は、`並列的$な手続きの間に遂行している(入力~URLごとに 100~milli秒間~待機して) — したがって~main`~event~loop$は阻んでいない。 ◎ It performs "expensive computation" (waiting for 100 milliseconds per input URL) during the in parallel steps, thus not blocking the main event loop.
  • `並列的$な手続きの間は、決して,観測-可能な~JS~objとしての~promiseを[ 作成-/操作- ]していない。 %p は,その手続きに入る前に作成され、当の目的で特定的に`~queueされ$た`~task$の中で操作されている。 ◎ Promises, as observable JavaScript objects, are never created and manipulated during the in parallel steps. p is created before entering those steps, and then is manipulated during a task that is queued specifically for that purpose.
  • ~JS配列~objの作成は,~queueされた~taskの中で行われ、その配列を どの~realm内に作成するかも注意深く指定している — ~realmはもはや、文脈からは明らかでないので。 ◎ The creation of a JavaScript array object also happens during the queued task, and is careful to specify which realm it creates the array in since that is no longer obvious from context.

(最後の 2 点については、 w3ctag/promises-guide issue #52, heycam/webidl issue #135, heycam/webidl issue #371 も見よ — 上述した~promiseの解決~patternの細部については、依然として思案中にある) ◎ (On these last two points, see also w3ctag/promises-guide issue #52, heycam/webidl issue #135, and heycam/webidl issue #371, where we are still mulling over the subtleties of the above promise-resolution pattern.)

上とは別に、この~algoが[ ~IDL sequence<`USVString$> 型~値を入力にとるような,~Web~IDLにより指定される演算 ]から~callされるときには、[ 作者から入力として供された`~JS~realm$に特有な~JS~obj ]から[ ~realmに不問な sequence<`USVString$> 型 ]への自動的な変換もあることに注意。 それは、入力を[ 0 個以上の`~scalar値~文字列$からなる`~list$ ]として扱うことになる。 なので、当の仕様の構造に依存して,[ `並列的$に走らすに準備済みにする処理-の一部を担うような,~main`~event~loop$上で起こる暗黙的な他の手続き ]もあり得る。 ◎ Another thing to note is that, in the event this algorithm was called from a Web IDL-specified operation taking a sequence<USVString>, there was an automatic conversion from realm-specific JavaScript objects provided by the author as input, into the realm-agnostic sequence<USVString> Web IDL type, which we then treat as a list of scalar value strings. So depending on how your specification is structured, there may be other implicit steps happening on the main event loop that play a part in this whole process of getting you ready to go in parallel.

8.1.7. ~event

8.1.7.1. ~event~handler

多くの~objには、何個かの `~event~handler@ を指定できる。 これらは、指定された~obj用の非~capture`~event~listener$として動作する。 `DOM$r ◎ Many objects can have event handlers specified. These act as non-capture event listeners for the object on which they are specified. [DOM]

`~event~handler$は、次の 2 つの`~item$からなる`構造体$である: ◎ An event handler is a struct with two items:

`値@eH
[ ~NULL, ~callback~obj, `内部的な生の未compileの~handler$ ]のいずれか — 初期~時には、~NULL にするモノトスル。 `EventHandler$I ~callback関数~型は、これが~scriptに どう公開されるかを述べる。 ◎ a value, which is either null, a callback object, or an internal raw uncompiled handler. The EventHandler callback function type describes how this is exposed to scripts. Initially, an event handler's value must be set to null.
`~listener@eH
[ ~NULL, `~event~listener$ ]のいずれか — 初期~時には、~NULL にするモノトスル。 ~event~listenerは、`~event~handler処理~algo$を走らすのを担当する。 ◎ a listener, which is either null or an event listener responsible for running the event handler processing algorithm. Initially, an event handler's listener must be set to null.

各~event~handlerは、 2 通りの仕方で公開される: ◎ Event handlers are exposed in two ways.

  • `~event~handler~IDL属性$として ⇒ この仕方は、すべての~event~handlerに共通する。 ◎ The first way, common to all event handlers, is as an event handler IDL attribute.
  • `~event~handler内容~属性$として ⇒ [ `~HTML要素$ / `~window$ ]上の~event~handlerのうち一部は、この仕方でも公開される。 ◎ The second way is as an event handler content attribute. Event handlers on HTML elements and some of the event handlers on Window objects are exposed in this way.

どちらの仕方でも,`~event~handler$は、 `名前@eH を通して公開される — それは、常に `on^l から開始され,~handlerに意図される~event名が後続する文字列である。 ◎ For both of these two ways, the event handler is exposed through a name, which is a string that always starts with "on" and is followed by the name of the event for which the handler is intended.


[ `~event~handler$を公開する~obj, 対応する`~event~listener$が追加される~obj ]は、ほとんどにおいては同じになる。 しかしながら,[ `body$e / `frameset$e ]要素は、要素の【`~node文書$を結付けている】 `~window$が存在するならば,それ上で動作する いくつかの`~event~handler$を公開する。 いずれにせよ、`~event~handler$は,自身の `~target@eH 【すなわち、次の手続きで決定される,後者の~obj】上で動作するという。 ◎ Most of the time, the object that exposes an event handler is the same as the object on which the corresponding event listener is added. However, the body and frameset elements expose several event handlers that act upon the element's Window object, if one exists. In either case, we call the object an event handler acts upon the target of that event handler.

`~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()$m を用いて)作成された `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.

各 `EventTarget$I ~objには、 `~event~handler~map@ が結付けられる† — それは、`~event~handler$の`名前$eHを表現する文字列を`~event~handler$に対応付ける`~map$である。 ◎ Each EventTarget object that has one or more event handlers specified has an associated event handler map, which is a map of strings representing names of event handlers to event handlers.

`EventTarget$I ~objの作成-時には、その`~event~handler~map$は,各[ ~obj上に指定された`~event~handler$のうち,~objを`~target$eHとするもの ]用の`~entry$を包含するように初期化するモノトスル — その`~event~handler$の各`~item$をそれぞれの初期~値に設定して。 ◎ When an EventTarget object that has one or more event handlers specified is created, its event handler map must be initialized such that it contains an entry for each event handler that has that object as target, with items in those event handlers set to their initial values.

【† 原文では, “`EventTarget^I ~objのうち, 1 個~以上の~event~handlerが指定されたものに結付けられる” と記されているが、この~mapが[ 空であること, 結付けられていないこと ]に[ 論理的/観測-可能 ]な差異はないので,この訳では どの `EventTarget^I にも結付けられるものと見なす。 】

注記: `~event~handler~map$を成す`~entry$たちの順序は、任意に~~選べる — その~map上で演算する どの~algoからも観測-可能にならないので。 ◎ The order of the entries of event handler map could be arbitrary. It is not observable through any algorithms that operate on the map.

注記: [ ~obj上に公開されるだけで,`~target$eHは他の~objになる`~event~handler$ ]用の`~entry$は、~objの`~event~handler~map$内には作成されない。 ◎ Entries are not created in the event handler map of an object for event handlers that are merely exposed on that object, but have some other object as their targets.


`~event~handler~IDL属性@ は、特定の`~event~handler$用の~IDL属性である。 ~IDL属性の名前は、`~event~handler$の`名前$eHと同じである。 ◎ An event handler IDL attribute is an IDL attribute for a specific event handler. The name of the IDL attribute is the same as the name of the event handler.

名前 %名前 の`~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~IDL属性$ — 特に `MessagePort$I ~objの `onmessage$m 属性 — には、追加的な要件がある。 ◎ Certain event handler IDL attributes have additional requirements, in particular the onmessage attribute of MessagePort objects.


`~event~handler内容~属性@ は、~obj上の特定の`~event~handler$に対応する,同じ~obj上の内容~属性である。 その名前は、`~event~handler$の名前と同じである。 ◎ An event handler content attribute is a content attribute for a specific event handler. The name of the content attribute is the same as the name of the event handler.

`~event~handler内容~属性$に指定する値は、[ `自動的~semicolon挿入$後に, `FunctionBody$js 生成規則に合致するように構文解析される ]ような,妥当な~JS~codeを包含していなければナラナイ。 ◎ Event handler content attributes, when specified, must contain valid JavaScript code which, when parsed, would match the FunctionBody production after automatic semicolon insertion.

`~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()$m を定義するために利用される。 ◎ 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$ ⇒# `type$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~listener登録が起こるのは、当の`~event~handler$ %~event~handler が,作動化-済みでない下で その`値$eHが非 ~NULL に設定されるときに限られる。 ~listenerは登録-順に~callされるので、非作動化は生じていないと見做すならば,特定0の~event型~用の~event~listenerたちは,常に次の順序で~callされる: ◎ The event listener registration happens only if the event handler's value is being set to non-null, and the event handler is not already activated. Since listeners are called in the order they were registered, assuming no deactivation occurred, the order of event listeners for a particular event type will always be:

  1. %~event~handler の`値$eHが最初に非 ~NULL に設定される前に, `addEventListener()$m で登録された~event~listenerたち ◎ the event listeners registered with addEventListener() before the first time the event handler's value was set to non-null
  2. 現在, %~event~handler に設定されている~callbackが在れば,その~listener ◎ then the callback to which it is currently set, if any
  3. %~event~handler の`値$eHが最初に非 ~NULL に設定された`後に^em, `addEventListener()$m で登録された~event~listenerたち ◎ and finally the event listeners registered with addEventListener() after the first time the event handler's value was set to non-null.

この例は、~event~listenerが呼出される順序をデモる。 利用者がこの例の~buttonを~clickしたとき、~pageは,順に~text[ `一^l, `二^l, `三^l, `四^l ]を伴う 4 回の~alertを示すことになる。 ◎ This example demonstrates the order in which event listeners are invoked. If the button in this example is clicked by the user, the page will show four alerts, with the text "ONE", "TWO", "THREE", and "FOUR" respectively.

<button id="test">Start Demo</button>
<script>
  var %button = document.getElementById('test');
  %button.addEventListener(
    'click', function(){ alert('一') }, false
  );
  %button.setAttribute(
    'onclick', "alert('この~alertは呼ばれない')"
  ); /* 
~event~handler~listenerはこの時点で登録される。
◎
event handler listener is registered here
 */

  %button.addEventListener(
    'click', function(){ alert('三') }, false
  );
  %button.onclick = function(){ alert('二'); };
  %button.addEventListener(
    'click', function(){ alert('四') }, false
  );
</script>

しかしながら,次の例では、~event~handlerは,初回の作動化の後(および,その~event~listenerが除去された後)に,非作動化され, その後に作動化し直されるので、~pageは,順に~text[ `一^l, `二^l, `三^l, `四^l, `五^l ]を伴う 5 回の~alertを示すことになる。 ◎ However, in the following example, the event handler is deactivated after its initial activation (and its event listener is removed), before being reactivated at a later time. The page will show five alerts with "ONE", "TWO", "THREE", "FOUR", and "FIVE" respectively, in order.

<%button id="test">Start Demo</%button>
<script>
  var %button = document.getElementById('test');
  %button.addEventListener(
    'click', function () { alert('一') }, false
  );
  %button.setAttribute(
    'onclick', "alert('この~alertは呼ばれない')"
  ); /* 
~event~handlerは、ここで作動化される
◎
event handler is activated here
 */
  %button.addEventListener(
    'click', function () { alert('二') }, false
  );
  %button.onclick = null;  /* 
が、ここで非作動化される
◎
but deactivated here
 */
  %button.addEventListener(
    'click', function () { alert('三') }, false
  );
  %button.onclick = function () {
    alert('四');
  }; /* 
ここで作動化し直される
◎
and re-activated here
 */
  %button.addEventListener(
    'click', function () { alert('五') }, false
  );
</script>

注記: ~event~objが実装する~interfaceは、`~event~handler$が誘発されるかどうかには波及しない。 ◎ The interfaces implemented by the event object do not influence whether an event handler is triggered or not.

`~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 [ 次が満たされるならば ~T / ~ELSE_ ~F ] ⇒ [ %~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. %引数~list ~LET « %~event » ◎ ↓
  6. ~IF[ %特別~error~event取扱い ~EQ ~T ] ⇒ %引数~list ~SET %~event の次に挙げる属性の値からなる同順の~list ⇒ `message$m, `filename$m, `lineno$m, `colno$m, `error$m ◎ ↓
  7. %返り値 ~LET `~callback関数を呼出す$( %~callback, %引数~list, %~event の `currentTarget$m 値 【!~callback this 値$】) ◎ Process the Event object event as follows: ◎ If special error event handling is true • Invoke callback with five arguments, the first one having the value of event's message attribute, the second having the value of event's filename attribute, the third having the value of event's lineno attribute, the fourth having the value of event's colno attribute, the fifth having the value of event's error attribute, and with the callback this value set to event's currentTarget. Let return value be the callback's return value. [WEBIDL] ◎ Otherwise • Invoke callback with one argument, the value of which is the Event object event, with the callback this value set to event's currentTarget. Let return value be the callback's return value. [WEBIDL]

    %~callback から例外が投出されたときは、そのまま伝播させるとする(したがって、この手続きも終える)。 (例外は、 ~DOM~event配送-~logic へ伝播し,その`例外を報告する$ことになる。) ◎ If an exception gets thrown by the callback, end these steps and allow the exception to propagate. (It will propagate to the DOM event dispatch logic, which will then report the exception.)

  8. ~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 の`取消d~flag$ ~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.
  9. ~ELIF[ %特別~error~event取扱い ~EQ ~T ] ⇒ ~IF[ %返り値 ~EQ ~T ] ⇒ %~event の`取消d~flag$ ~SET ~T ◎ If special error event handling is true • If return value is true, then set event's canceled flag.
  10. ~ELIF[ %返り値 ~EQ ~F ] ⇒ %~event の`取消d~flag$ ~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.


`EventHandler$I ~callback関数~型は、~event~handlerに利用される~callbackを表現する。 それは、次の~Web~IDLで表現される: ◎ The EventHandler callback function type represents a callback used for event handlers. It is represented in Web IDL as follows:

[`LegacyTreatNonObjectAsNull$]
callback `EventHandlerNonNull@I = any (`Event$I event);
typedef `EventHandlerNonNull$I? `EventHandler@I;

注記: ~JSにおいては、どの `Function$I ~objもこの~interfaceを実装する。 ◎ In JavaScript, any Function object implements this interface.

例えば、次の文書~片で: ◎ For example, the following document fragment:

<body onload="alert(this)" onclick="alert(this)">

文書が読込まれたときは `[object Window]^l が~alertされ、利用者が~page内のどこかを~clickしたなら `[object HTMLBodyElement]^l が~alertされる。 ◎ ...leads to an alert saying "[object Window]" when the document is loaded, and an alert saying "[object HTMLBodyElement]" whenever the user clicks something in the page.

注記: 関数の返り値は,~eventが取消されるかどうかに影響する — 上で述べたように、返り値 ~EQ ~F の場合,~eventは取消される。 ◎ The return value of the function affects whether the event is canceled or not: as described above, if the return value is false, the event is canceled.

歴史的な理由から、~platformには 2 つの例外がある ◎ There are two exceptions in the platform, for historical reasons:

  • 大域~obj上の `onerror$hd ~handlerは、 `true^jv を返した場合に~eventを取消すことになる。 ◎ The onerror handlers on global objects, where returning true cancels the event
  • `onbeforeunload$hd ~handlerは、 `null^jv でも `undefined^jv でもない値を返した場合に~eventを取消すことになる。 ◎ The onbeforeunload handler, where returning any non-null and non-undefined value will cancel the event.

歴史的な理由から、 `onerror$hd ~handlerは,異なる引数をとる: ◎ For historical reasons, the onerror handler has different arguments:

[`LegacyTreatNonObjectAsNull$]
callback `OnErrorEventHandlerNonNull@I = any (
    (`Event$I or DOMString) %event,
    optional DOMString %source,
    optional unsigned long %lineno,
    optional unsigned long %colno,
    optional any %error
);
typedef `OnErrorEventHandlerNonNull$I? `OnErrorEventHandler@I;
window.onerror = (message, source, lineno, colno, error) => { … };

同様に、 `onbeforeunload$hd ~handlerは,異なる値を返す: ◎ Similarly, the onbeforeunload handler has a different return value:

[`LegacyTreatNonObjectAsNull$]
callback `OnBeforeUnloadEventHandlerNonNull@I = DOMString? (`Event$I %event);
typedef `OnBeforeUnloadEventHandlerNonNull$I? `OnBeforeUnloadEventHandler@I;

`内部的な生の未compileの~handler@ は、次の情報の組である: ◎ An internal raw uncompiled handler is a tuple with the following information:

  • 未compileの~script本体 ◎ An uncompiled script body
  • ~script本体が出自にしている所在 — ~errorを報告する必要がある場合に限り。 ◎ A location where the script body originated, in case an error needs to be reported

~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$js として構文解析-可能でない ]~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が在れば それも 除去する。 ◎ This does not deactivate the event handler, which additionally removes the event handler's listener (if present).

    2. 次を与える下で,`~errorを報告する$ ⇒# ~script: 適切な `~script$ 【?】 問題箇所: %所在 における適切な問題箇所 ( 行番号, 列番号 ) 標的: %設定群~obj の`大域~obj$enV ◎ Report the error for the appropriate script and with the appropriate position (line number and column number) given by location, using settings object's global object.\
    3. ~IF[ ~errorの`取扱済み~flag$err ~EQ ~F ] ⇒ ~UAは、開発者~consoleに~errorを報告してもヨイ ◎ If the error is still not handled after this, then the error may be reported to a developer console.
    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が正しい`~JS~realm$に属するようにするため,必要とされる。 ◎ This is necessary so the subsequent invocation of OrdinaryFunctionCreate takes place in the correct JavaScript Realm.

  13. %onerror用? ~LET [ 次が満たされるならば ~T / ~ELSE_ ~F ] ⇒ [ %名前 ~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( %文書, %視野 ) ◎ If eventHandler is an element's event handler, then set scope to NewObjectEnvironment(document, 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所有者, %視野 ) ◎ If form owner is not null, then set scope to NewObjectEnvironment(form owner, scope).
    6. ~IF[ %要素 ~NEQ ~NULL ] ⇒ %視野 ~SET `NewObjectEnvironment$jA( %要素, %視野 ) ◎ If element is not null, then set scope to NewObjectEnvironment(element, 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 化することは、[ `HostResolveImportedModule$jA, `HostImportModuleDynamically$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 HostResolveImportedModule and HostImportModuleDynamically 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.

8.1.7.2. [ 要素 / 文書 / ~window ]上の各種~event~handler

以下に挙げる各種`~event~handler$, および 対応する各種`~event~handler~event型$は:

  • `~HTML要素$においては、[ `~event~handler内容~属性$, `~event~handler~IDL属性$ ]の両者として,~supportするモノトスル。
  • [ `文書$ / `~window$ ]においては、`~event~handler~IDL属性$として,~supportするモノトスル。
◎ The following are the event handlers (and their corresponding event handler event types) that must be supported by all HTML elements, as both event handler content attributes and event handler IDL attributes; and that must be supported by all Document and Window objects, as event handler IDL attributes:
`~event~handler$ `~event~handler~event型$
`onabort@hd `abort$et
`onauxclick@hd `auxclick$et
`oncancel@hd `cancel$et
`oncanplay@hd `canplay$et
`oncanplaythrough@hd `canplaythrough$et
`onchange@hd `change$et
`onclick@hd `click$et
`onclose@hd `close$et
`oncontextmenu@hd `contextmenu$et
`oncuechange@hd `cuechange$et
`ondblclick@hd `dblclick$et
`ondrag@hd `drag$et
`ondragend@hd `dragend$et
`ondragenter@hd `dragenter$et
`ondragleave@hd `dragleave$et
`ondragover@hd `dragover$et
`ondragstart@hd `dragstart$et
`ondrop@hd `drop$et
`ondurationchange@hd `durationchange$et
`onemptied@hd `emptied$et
`onended@hd `ended$et
`onformdata@hd `formdata$et
`oninput@hd `input$et
`oninvalid@hd `invalid$et
`onkeydown@hd `keydown$et
`onkeypress@hd `keypress$et
`onkeyup@hd `keyup$et
`onloadeddata@hd `loadeddata$et
`onloadedmetadata@hd `loadedmetadata$et
`onloadstart@hd `loadstart$et
`onmousedown@hd `mousedown$et
`onmouseenter@hd `mouseenter$et
`onmouseleave@hd `mouseleave$et
`onmousemove@hd `mousemove$et
`onmouseout@hd `mouseout$et
`onmouseover@hd `mouseover$et
`onmouseup@hd `mouseup$et
`onpause@hd `pause$et
`onplay@hd `play$et
`onplaying@hd `playing$et
`onprogress@hd `progress$et
`onratechange@hd `ratechange$et
`onreset@hd `reset$et
`onsecuritypolicyviolation@hd `securitypolicyviolation$et
`onseeked@hd `seeked$et
`onseeking@hd `seeking$et
`onselect@hd `select$et
`onslotchange@hd `slotchange$et
`onstalled@hd `stalled$et
`onsubmit@hd `submit$et
`onsuspend@hd `suspend$et
`ontimeupdate@hd `timeupdate$et
`ontoggle@hd `toggle$et
`onvolumechange@hd `volumechange$et
`onwaiting@hd `waiting$et
`onwebkitanimationend@hd `webkitAnimationEnd^et
`onwebkitanimationiteration@hd `webkitAnimationIteration^et
`onwebkitanimationstart@hd `webkitAnimationStart^et
`onwebkittransitionend@hd `webkitTransitionEnd^et
`onwheel@hd `wheel$et

以下に挙げる各種`~event~handler$, および 対応する各種`~event~handler~event型$は:

  • [ `body$e, `frameset$e ]要素を除く `~HTML要素$においては、[ `~event~handler内容~属性$, `~event~handler~IDL属性$ ]の両者として,~supportするモノトスル。
  • `文書$においては、`~event~handler~IDL属性$として,~supportするモノトスル。
  • `~window$においては、`~event~handler~IDL属性$として,~supportするモノトスル。 加えて、当の`~window$に`結付けられている文書$が所有する[ `body$e / `frameset$e ]要素においても,対応する[ `~event~handler内容~属性$, `~event~handler~IDL属性$ ]を公開するモノトスル。
◎ The following are the event handlers (and their corresponding event handler event types) that must be supported by all HTML elements other than body and frameset elements, as both event handler content attributes and event handler IDL attributes; that must be supported by all Document objects, as event handler IDL attributes; and that must be supported by all Window objects, as event handler IDL attributes on the Window objects themselves, and with corresponding event handler content attributes and event handler IDL attributes exposed on all body and frameset elements that are owned by that Window object's associated Document:
`~event~handler$ `~event~handler~event型$
`onblur@hd `blur$et
`onerror@hd `error$et
`onfocus@hd `focus$et
`onload@hd `load$et
`onresize@hd `resize$et
`onscroll@hd `scroll$et

上の 1 列目に挙げた`~event~handler$の`名前$eHが成す`集合$を指して, `~windowを反映する~body要素~event~handler集合@ と呼ぶ。 ◎ We call the set of the names of the event handlers listed in the first column of this table the Window-reflecting body element event handler set.


以下に挙げる各種`~event~handler$, および 対応する各種`~event~handler~event型$は:

  • `~window$においては,`~event~handler~IDL属性$として,~supportするモノトスル。
  • 前項に対応する[ `~event~handler内容~属性$, `~event~handler~IDL属性$ ]は、当の`~window$に`結付けられている文書$が所有する[ `body$e / `frameset$e ]要素において公開するモノトスル。
◎ The following are the event handlers (and their corresponding event handler event types) that must be supported by Window objects, as event handler IDL attributes on the Window objects themselves, and with corresponding event handler content attributes and event handler IDL attributes exposed on all body and frameset elements that are owned by that Window object's associated Document:
`~event~handler$ `~event~handler~event型$
`onafterprint@hd `afterprint$et
`onbeforeprint@hd `beforeprint$et
`onbeforeunload@hd `beforeunload$et
`onhashchange@hd `hashchange$et
`onlanguagechange@hd `languagechange$et
`onmessage@hd `message$et
`onmessageerror@hd `messageerror$et
`onoffline@hd `offline$et
`ononline@hd `online$et
`onpagehide@hd `pagehide$et
`onpageshow@hd `pageshow$et
`onpopstate@hd `popstate$et
`onrejectionhandled@hd `rejectionhandled$et
`onstorage@hd `storage$et
`onunhandledrejection@hd `unhandledrejection$et
`onunload@hd `unload$et

上に挙げた`~event~handler$は、 `WindowEventHandlers$I ~interface~mixinを通して,`~event~handler~IDL属性$として具象化される。 ◎ This list of event handlers is reified as event handler IDL attributes through the WindowEventHandlers interface mixin.


以下に挙げる各種`~event~handler$, および 対応する各種`~event~handler~event型$は:

  • `~HTML要素$においては、[ `~event~handler内容~属性$, `~event~handler~IDL属性$ ]の両者として,~supportするモノトスル。
  • `文書$においては、`~event~handler~IDL属性$として,~supportするモノトスル。
◎ The following are the event handlers (and their corresponding event handler event types) that must be supported by all HTML elements, as both event handler content attributes and event handler IDL attributes; and that must be supported by all Document objects, as event handler IDL attributes:
`~event~handler$ `~event~handler~event型$
`oncut@hd `cut$et
`oncopy@hd `copy$et
`onpaste@hd `paste$et

上に挙げた`~event~handler$は、 `DocumentAndElementEventHandlers$I ~interface~mixinを通して,`~event~handler~IDL属性$として具象化される。 ◎ This list of event handlers is reified as event handler IDL attributes through the DocumentAndElementEventHandlers interface mixin.


以下に挙げる各種`~event~handler$, および 対応する各種`~event~handler~event型$は:

  • `文書$においては、`~event~handler~IDL属性$として,~supportするモノトスル。
◎ The following are the event handlers (and their corresponding event handler event types) that must be supported on Document objects as event handler IDL attributes:
`~event~handler$ `~event~handler~event型$
`onreadystatechange@hd `readystatechange$et
8.1.7.2.1. IDL 定義
【!#handler-xxx】
interface mixin `GlobalEventHandlers@I {
  attribute EventHandler `onabort$hd;
  attribute EventHandler `onauxclick$hd;
  attribute EventHandler `onblur$hd;
  attribute EventHandler `oncancel$hd;
  attribute EventHandler `oncanplay$hd;
  attribute EventHandler `oncanplaythrough$hd;
  attribute EventHandler `onchange$hd;
  attribute EventHandler `onclick$hd;
  attribute EventHandler `onclose$hd;
  attribute EventHandler `oncontextmenu$hd;
  attribute EventHandler `oncuechange$hd;
  attribute EventHandler `ondblclick$hd;
  attribute EventHandler `ondrag$hd;
  attribute EventHandler `ondragend$hd;
  attribute EventHandler `ondragenter$hd;
  attribute EventHandler `ondragleave$hd;
  attribute EventHandler `ondragover$hd;
  attribute EventHandler `ondragstart$hd;
  attribute EventHandler `ondrop$hd;
  attribute EventHandler `ondurationchange$hd;
  attribute EventHandler `onemptied$hd;
  attribute EventHandler `onended$hd;
  attribute `OnErrorEventHandler$I `onerror$hd;
  attribute EventHandler `onfocus$hd;
  attribute EventHandler `onformdata$hd;
  attribute EventHandler `oninput$hd;
  attribute EventHandler `oninvalid$hd;
  attribute EventHandler `onkeydown$hd;
  attribute EventHandler `onkeypress$hd;
  attribute EventHandler `onkeyup$hd;
  attribute EventHandler `onload$hd;
  attribute EventHandler `onloadeddata$hd;
  attribute EventHandler `onloadedmetadata$hd;
  attribute EventHandler `onloadstart$hd;
  attribute EventHandler `onmousedown$hd;
  [`LegacyLenientThis$] attribute EventHandler `onmouseenter$hd;
  [`LegacyLenientThis$] attribute EventHandler `onmouseleave$hd;
  attribute EventHandler `onmousemove$hd;
  attribute EventHandler `onmouseout$hd;
  attribute EventHandler `onmouseover$hd;
  attribute EventHandler `onmouseup$hd;
  attribute EventHandler `onpause$hd;
  attribute EventHandler `onplay$hd;
  attribute EventHandler `onplaying$hd;
  attribute EventHandler `onprogress$hd;
  attribute EventHandler `onratechange$hd;
  attribute EventHandler `onreset$hd;
  attribute EventHandler `onresize$hd;
  attribute EventHandler `onscroll$hd;
  attribute EventHandler `onsecuritypolicyviolation$hd;
  attribute EventHandler `onseeked$hd;
  attribute EventHandler `onseeking$hd;
  attribute EventHandler `onselect$hd;
  attribute EventHandler `onslotchange$hd;
  attribute EventHandler `onstalled$hd;
  attribute EventHandler `onsubmit$hd;
  attribute EventHandler `onsuspend$hd;
  attribute EventHandler `ontimeupdate$hd;
  attribute EventHandler `ontoggle$hd;
  attribute EventHandler `onvolumechange$hd;
  attribute EventHandler `onwaiting$hd;
  attribute EventHandler `onwebkitanimationend$hd;
  attribute EventHandler `onwebkitanimationiteration$hd;
  attribute EventHandler `onwebkitanimationstart$hd;
  attribute EventHandler `onwebkittransitionend$hd;
  attribute EventHandler `onwheel$hd;
};
【! #handler-window-xxxx】
interface mixin `WindowEventHandlers@I {
  attribute EventHandler `onafterprint$hd;
  attribute EventHandler `onbeforeprint$hd;
  attribute `OnBeforeUnloadEventHandler$I `onbeforeunload$hd;
  attribute EventHandler `onhashchange$hd;
  attribute EventHandler `onlanguagechange$hd;
  attribute EventHandler `onmessage$hd;
  attribute EventHandler `onmessageerror$hd;
  attribute EventHandler `onoffline$hd;
  attribute EventHandler `ononline$hd;
  attribute EventHandler `onpagehide$hd;
  attribute EventHandler `onpageshow$hd;
  attribute EventHandler `onpopstate$hd;
  attribute EventHandler `onrejectionhandled$hd;
  attribute EventHandler `onstorage$hd;
  attribute EventHandler `onunhandledrejection$hd;
  attribute EventHandler `onunload$hd;
};

interface mixin `DocumentAndElementEventHandlers@I {
  attribute EventHandler `oncopy$hd;
  attribute EventHandler `oncut$hd;
  attribute EventHandler `onpaste$hd;
};

8.1.7.3. ~eventの発火-法

ある種の演算や~methodは、要素に向けて~eventを発火するものと定義される。 例えば, `HTMLElement$I 上の `click()$m ~methodは、要素に向けて `click$et ~eventを発火するものと定義される。 `UIEVENTS$r ◎ Certain operations and methods are defined as firing events on elements. For example, the click() method on the HTMLElement interface is defined as firing a click event on the element. [UIEVENTS]

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

  1. %~event ~LET `~eventを作成する$( `MouseEvent$I ) ◎ Let event be the result of creating an event using MouseEvent.
  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~flag$ ~SET ~T ◎ Set event's composed flag.
    5. ~IF[ %~trustされない~flag ~NEQ ε ] ⇒ `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 ]は、~Key入力~装置の現在の状態に則って初期化する(可用でない~Keyに対しては ~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 %標的 の`~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は、~Key入力~装置の現在の状態を適切に述べる値を返すようにする ◎ event's getModifierState() method is to return values appropriately describing the current state of the key input device.
  3. ~RET %標的 に向けて %~event を`配送-$した結果 ◎ Return the result of dispatching event at target.

%標的 に向けて `click ~eventを発火する@ ときは、次を走らす ⇒ `合成な~mouse~eventを発火する$( %標的, `click^et ) ◎ Firing a click event at target means firing a synthetic mouse event named click at target.