Service Workers Nightly

2.1. ~sw

`~sw@ は，`~web~worker$の一種であり、 それを登録している`~sw~client$の`生成元$cl【！`生成元$】において実行される。 ◎ A service worker is a type of web worker. A service worker executes in the registering service worker client's origin.

各`~sw$には、 以下に挙げるものが結付けられる： ◎ ↓

`状態@sw ◎ A service worker has an associated state,＼

次に挙げるいずれか 【括弧内は，この訳による補足】 ⇒＃ `parsed^l （構文解析-済み）／ `installing^l （~install中） ／ `installed^l （~install済み） ／ `activating^l （作動化-中） ／ `activated^l （作動化-済み）／ `redundant^l （冗長） ◎ which is one of "parsed", "installing", "installed", "activating", "activated", and "redundant".＼

初期~時は `parsed^l とする。 ◎ It is initially "parsed".

`~script~URL@sw ◎ A service worker has an associated script url＼

`~URL$。 ◎ (a URL).

`種別@sw ◎ A service worker has an associated type＼

次に挙げるいずれか ⇒＃ `classic^l ／ `module^l ◎ which is either "classic" or "module".＼

他が言明されない限り， `classic^l とする ◎ Unless stated otherwise, it is "classic".

`包含している~sw登録@sw ◎ A service worker has an associated containing service worker registration＼

この~swを包含している，`~sw登録$。 ◎ (a service worker registration), which contains itself.

【 これが具体的にどう［ 定義-／決定-／設定- ］されるかは、 この仕様には述べられていない。 この~swが，ある~sw登録の［ `~install中の~worker$swr／`待機-中な~worker$swr／`作動中な~worker$swr ］であるときの、 その~sw登録を指すように見受けられる （該当し得る記述は他に見当たらない）。 】

`大域~obj@sw ◎ A service worker has an associated global object＼

`ServiceWorkerGlobalScope$I ~obj／ ~NULL ◎ (a ServiceWorkerGlobalScope object or null).

【 ~accessされる前に，（この`~swを走らす$ときに）非 ~NULL に設定される （ ~NULL をとるのは初期~時に限られるようだ）。 】

`~script資源@sw ◎ A service worker has an associated script resource＼

`~script$／~NULL ◎ (a script),＼

この~swの自前の~script資源を表現する。 ◎ which represents its own script resource.＼

初期~時は ~NULL とする。 ◎ It is initially set to null.

各`~script資源$swには、 次に挙げるものが結付けられる： ◎ ↓

• `これまでに評価されたか@sw ⇒ 真偽値 — 初期~時は ~F とする。 ◎ A script resource has an associated has ever been evaluated flag.＼ It is initially unset.
• `施策~容器@sw ⇒ `施策~容器$ — 初期~時は新たな`施策~容器$とする。 ◎ A script resource has an associated policy container (a policy container).＼ It is initially a new policy container.

`~script資源~map@sw ◎ A service worker has an associated script resource map＼

`有順序~map$ — 各~entryは［ `~URL$ → `応答$ ］を与える。 ◎ which is an ordered map where the keys are URLs and the values are responses.

`利用した~scriptの集合@sw ◎ A service worker has an associated set of used scripts＼

`集合$ — 各`~item$は`~URL$を与える。 ◎ (a set) whose item is a URL.＼

初期~時は新たな`集合$とする。 ◎ It is initially a new set.

注記： `利用した~scriptの集合$swは、［ 更新~検査の間に旧~workerの~mapに基づいて拡充された，新たな~workerの~map ］から［ その~installation後に未利用な資源を刈り取る ］ために限り利用される。 ◎ Note: The set of used scripts is only used to prune unused resources from a new worker’s map after installation, that were populated based on the old worker’s map during the update check.

`待機を飛ばすか@sw ◎ A service worker has an associated skip waiting＼

真偽値 ◎ flag.＼

他が言明されない限り ~F とする。 ◎ Unless stated otherwise it is unset.

`古典~scriptは~import済みか@sw ◎ A service worker has an associated classic scripts imported＼

真偽値 ◎ flag.＼

初期~時は ~F とする。 ◎ It is initially unset.

`取扱う~event型の集合@sw ◎ A service worker has an associated set of event types to handle＼

`集合$ — 各`~item$は、 `~event~listener$の~event型を与える。 ◎ (a set) whose item is an event listener’s event type.＼

初期~時は新たな`集合$とする。 ◎ It is initially a new set.

`延長-済み~event集合@sw ◎ A service worker has an associated set of extended events＼

`集合$ — 各`~item$は、 `ExtendableEvent$I を与える。 ◎ (a set) whose item is an ExtendableEvent.＼

初期~時は新たな`集合$とする。 ◎ It is initially a new set.

`開始~状態@sw ◎ A service worker has an associated start status＼

~NULL ／ `Completion$ ◎ which can be null or a Completion.＼

初期~時は ~NULL とする。 ◎ It is initially null.

`すべての~fetch~listenerは空か@sw ◎ A service worker has an associated all fetch listeners are empty＼

真偽値 ◎ flag.＼

初期~時は ~F とする。 ◎ It is initially unset.

`~router規則~list@ ◎ A service worker has an associated list of router rules＼

`RouterRule$I たちが成す`~list$ ◎ (a list of RouterRules).＼

初期~時は新たな`~list$とする。 ◎ It is initially an empty list.

`~sw$は、 その`~event~loop$が走っているとき， `走っている@ という。 ◎ A service worker is said to be running if its event loop is running.

2.2. ~swの計時

各~swは、 ある種の時点を指す時刻を~markする — それらは、 `PerformanceNavigationTiming$I ~APIにより後で公開される。 ◎ Service workers mark certain points in time that are later exposed by the navigation timing API.

`~sw計時~報@ は、 次に挙げる`~item$sctからなる`構造体$である： ◎ A service worker timing info is a struct. It has the following items:

`開始~時刻@swT ◎ start time

`DOMHighResTimeStamp$I — 初期~時は 0 とする。 ◎ A DOMHighResTimeStamp, initially 0.

`~fetch~event配送-時刻@swT ◎ fetch event dispatch time

`DOMHighResTimeStamp$I — 初期~時は 0 とする。 ◎ A DOMHighResTimeStamp, initially 0.

2.3. ~sw登録

`~sw登録@ は、 `~scope~URL$swr, `~storage~key$, および一式の`~sw$ — `~install中の~worker$swr, `待機-中な~worker$swr, `作動中な~worker$swr — からなる~tupleである。 ◎ A service worker registration is a tuple of a scope url, a storage key, and a set of service workers, an installing worker, a waiting worker, and an active worker.＼

~UAは、 同じ生成元の中で，`~sw登録$を何個でも可能化してヨイ — それらの`~scope~URL$swrが，互いに相違する限りにおいて。 `~sw登録$は、 その`~scope~URL$swrが~UA内に既存の`~sw登録$のそれと一致するときには，既存の`~sw登録$を置換することになる。 ◎ A user agent may enable many service worker registrations at a single origin so long as the scope url of the service worker registration differs. A service worker registration of an identical scope url when one already exists in the user agent causes the existing service worker registration to be replaced.

各`~sw登録$には、 以下に挙げるものが結付けられる： ◎ ↓

`~storage~key@swr ◎ A service worker registration has an associated storage key＼

`~storage~key$。 ◎ (a storage key).

`~scope~URL@swr ◎ A service worker registration has an associated scope url＼

`~URL$。 ◎ (a URL).

`~install中の~worker@swr ◎ A service worker registration has an associated installing worker＼

~NULL ／次を満たす`~sw$ ⇒ `状態$sw ~EQ `installing^l ◎ (a service worker or null) whose state is "installing".＼

初期~時は ~NULL とする。 ◎ It is initially set to null.

`待機-中な~worker@swr ◎ A service worker registration has an associated waiting worker＼

~NULL ／次を満たす`~sw$ ⇒ `状態$sw ~EQ `installed^l ◎ (a service worker or null) whose state is "installed".＼

初期~時は ~NULL とする。 ◎ It is initially set to null.

`作動中な~worker@swr ◎ A service worker registration has an associated active worker＼

~NULL／次を満たす`~sw$ ⇒ `状態$sw ~IN { `activating^l, `activated^l } ◎ (a service worker or null) whose state is either "activating" or "activated".＼

初期~時は ~NULL とする。 ◎ It is initially set to null.

`最後の更新~検査-時刻@swr ◎ A service worker registration has an associated last update check time.＼

初期~時は ~NULL とする。 ◎ It is initially set to null.

`~sw登録$が `非新鮮@ であるとは、 この句が評価される時点で，次が満たされることを意味する ⇒ ［ `最後の更新~検査-時刻$swr ~NEQ ~NULL ］~AND［ 現在の時刻 ~GT `最後の更新~検査-時刻$swr ~PLUS 86400 秒 ］ ◎ A service worker registration is said to be stale if the registration’s last update check time is non-null and the time difference in seconds calculated by the current time minus the registration’s last update check time is greater than 86400.

`~cacheを介する更新~mode@swr ◎ A service worker registration has an associated update via cache mode,＼

次に挙げるいずれか ⇒＃ `imports^l, `all^l, `none^l ◎ which is "imports", "all", or "none".＼

初期~時は `imports^l とする。 ◎ It is initially set to "imports".

`~back-up~task~list@swr ◎ A service worker registration has one or more task queues＼

［ この`~sw登録$にて`作動中な~worker$swrの`~event~loop$ ］に属する`~task~queue$からの`~task$たちを，~back-upする。 この~listが~back-upするのは、［ `~fetchを取扱う~task~source$／`機能的~eventを取扱う~task~source$ ］から~queueされた~taskに限られる。 ◎ that back up the tasks from its active worker’s event loop’s corresponding task queues. (The target task sources for this back up operation are the handle fetch task source and the handle functional event task source.)＼

【 この用語は、 原文では “~task~sourceごとに仕分けられる，いくつかの~task~queue” として定義されているが、 この訳では，単独の~listに改めている — どの~taskも その`~source$tKが当の~task~sourceを保持するので，ここで仕分ける必要はないことに加え、 これは単なる~back-up用の~listであり，`~task~queue$ではないので。 （それに伴い，この用語が利用される箇所も 原文と等価になるよう変形している。） 】

~UAは、 `作動中な~worker$swrが`終了-$されたとき，~workerの`~task$たちを`~back-up~task~list$swrに~dumpした上で、 ~workerが再び立ち上がった（ `spin-off^en した）ときには，~dumpされた~taskたちを［ %~worker の`~event~loop$に属する，各~taskの`~source$tKに対応している`~task~queue$ ］に~queueし直すことになる。 【！ 不要 Unlike the task queues owned by event loops, ...】 ◎ The user agent dumps the active worker’s tasks to the service worker registration's task queues when the active worker is terminated and re-queues those tasks to the active worker’s event loop’s corresponding task queues when the active worker spins off. Unlike the task queues owned by event loops, the service worker registration's task queues are not processed by any event loops in and of itself.

`~NavigationPreloadManager@swr ◎ A service worker registration has an associated＼

`NavigationPreloadManager$I ~obj。 【各 `~sw登録$と一対一に対応する。】 ◎ NavigationPreloadManager object.

`~navi~preloadは可能化されるか@swr ◎ A service worker registration has an associated navigation preload enabled＼

真偽値をとり，初期~時は ~F とする。 ◎ flag. It is initially unset.

`~navi~preload~header値@swr ◎ A service worker registration has an associated navigation preload header value,＼

`~byte列$。 ◎ which is a byte sequence.＼

初期~時は `true^bl とする。 ◎ It is initially set to `true`.

`~sw登録$ %登録 は、 次を満たすならば， `未登録にされて@ いるとされる ⇒ `登録~map$[ ( %登録 の`~storage~key$swr, `~URLを直列化する$( %登録【！this が`表現する~sw登録$】 の`~scope~URL$swr ) ) ] ~NEQ %登録 ◎ A service worker registration is said to be unregistered if registration map[this service worker registration's (storage key, serialized scope url)] is not this service worker registration.

2.4. ~sw~client

`~sw~client@ は、 `環境$である。 ◎ A service worker client is an environment.

各`~sw~client$には、 真偽値をとる `破棄-済みか@ が結付けられる。 初期~時は ~F とする。 ◎ A service worker client has an associated discarded flag. It is initially unset.

`~sw~client$は、 その`大域~obj$enVに応じて： ◎ ↓

• `Window$I ~objであるならば `~window~client@ と称される。 ◎ A window client is a service worker client whose global object is a Window object.
• `DedicatedWorkerGlobalScope$I ~objであるならば `専用~worker~client@ と称される。 ◎ A dedicated worker client is a service worker client whose global object is a DedicatedWorkerGlobalScope object.
• `SharedWorkerGlobalScope$I ~objであるならば `共用~worker~client@ と称される。 ◎ A shared worker client is a service worker client whose global object is a SharedWorkerGlobalScope object.

`~worker~client@ は、［ `専用~worker~client$, `共用~worker~client$ ］の総称である。 ◎ A worker client is either a dedicated worker client or a shared worker client.

`~storage~keyが登録と同等な~client群@ とは、 次を満たす`~sw~client$ %~client たちが成す集合である ⇒ 次の 2 つは`同等な~storage~key$である ⇒＃ `~storage~keyを得する$( %~client ) の結果, %~client の`~sw$SWG【%~client を`制御-$している`~sw$？】を`包含している~sw登録$swの`~storage~key$swr

【 この用語は、 以下を簡潔に記すために，この訳に導入している。 この集合を成す~clientたちは、 何箇所かで反復されるが，その順序は定義されていない。 】

2.5. 制御と利用

`~sw~client$ %~client にて`作動中な~sw$enVは、 自前の読込ng, およびその下位資源を~serveする。 %~client にて`作動中な~sw$enVが ~NULL でないとき、 %~client は `作動中な~sw$enVにより `制御-@ されているという。 %~client が，ある`~sw$により`制御-$されているとき、 %~client は`~sw$を`包含している~sw登録$swを `利用して@ いるという。 %~client にて`作動中な~sw$enVは、 以下の各~下位節にて説明されるように決定される。 ◎ A service worker client has an active service worker that serves its own loading and its subresources. When a service worker client has a non-null active service worker, it is said to be controlled by that active service worker. When a service worker client is controlled by a service worker, it is said that the service worker client is using the service worker’s containing service worker registration. A service worker client's active service worker is determined as explained in the following subsections.

【 すなわち，次の 3 つの句は、 同じことを，主語と目的語を入れ替えて表している 】 ⇒＃ “%~sw は %~client を制御している”, “%~client は %登録 を利用している”, “%登録 は %~sw を包含している”

`この節の残りは規範的でない^em。 ◎ The rest of the section is non-normative.

この節における挙動は、 まだ全部的に指定されておらず， `~HTML標準＠https://html.spec.whatwg.org$ にて指定されることになる。 その作業は、 `765$issue, `pull request＠https://github.com/whatwg/html/pull/2809$ にて追跡されている。 ◎ The behavior in this section is not fully specified yet and will be specified in HTML Standard. The work is tracked by the issue and the pull request.

注記： `data:^c ~URL を伴う［ `~window~client$／`~worker~client$ ］に対しては、 その`生成元$は`不透明な生成元$になるので，`作動中な~sw$enVは ~NULL になる。 `~blob~URL$を伴う［ `~window~client$／`~worker~client$ ］は，その［ 作成元`文書$／所有者 ］から`作動中な~sw$enVを継承し得るが、 `要請$の`生成元$rqが［ 作成元`文書$／所有者 ］の`生成元$と`同一-生成元$でない場合，`作動中な~sw$enVは ~NULL に設定される。 ◎ Note: Window clients and worker clients with a data: URL result in having the active service worker value of null as their origin is an opaque origin. Window clients and worker clients with a blob URL can inherit the active service worker of their creator document or owner, but if the request's origin is not the same as the origin of their creator document or owner, the active service worker is set to null.

2.6. ~task~source

`~sw$は、 次の`~task~source$も追加的に利用する： ◎ The following additional task sources are used by service workers.

`~fetchを取扱う~task~source@ ◎ The handle fetch task source

この`~task~source$は、 `~sw$に向けて `fetch$et ~eventを`配送-$するときに利用される。 ◎ This task source is used for dispatching fetch events to service workers.

`機能的~eventを取扱う~task~source@ ◎ The handle functional event task source

この`~task~source$は、 他の`機能的~event$を`配送-$する特能~用に利用される — 例： `~sw$向けの `push$et ~event。 ◎ This task source is used for features that dispatch other functional events, e.g. push events, to service workers.

注記： ~UAは、 各~機能的~event型ごとに，別々な~task~sourceを利用してもヨイ — ある種の機能的~eventに対する `head-of-line blocking^en 現象†を避けるためとして。 【†長い~taskにより後続の~taskが~~渋滞する現象】 ◎ Note: A user agent may use a separate task source for each functional event type in order to avoid a head-of-line blocking phenomenon for certain functional events.

2.7. ~UA~shutdown

~UAは、 複数回の再始動にまたがって，自身が格納している`~sw登録$たちの状態を，次の規則の下で保守するモノトスル： ◎ A user agent must maintain the state of its stored service worker registrations across restarts with the following rules:

• `~install中の~worker$swrは、 持続することなく破棄する。 それが`~sw登録$用の唯一の`~sw$であった場合、 その登録も破棄する。 ◎ An installing worker does not persist but is discarded. If the installing worker was the only service worker for the service worker registration, the service worker registration is discarded.
• `待機-中な~worker$swrは、 `作動中な~worker$swrに~~昇格する。 ◎ A waiting worker promotes to an active worker.

これを成就するため，~UAは、 自身が終了するときには，次を呼出すモノトスル ⇒ `~UA~shutdownを取扱う$() ◎ To attain this, the user agent must invoke Handle User Agent Shutdown when it terminates.

3.1. `ServiceWorker^I

[`SecureContext$, `Exposed$=(Window,Worker)]
interface `ServiceWorker@I : `EventTarget$I {
  readonly attribute `USVString$ `scriptURL$m;
  readonly attribute `ServiceWorkerState$I `state$m;
  `undefined$ `postMessage$m(`any$ %message, `sequence$<`object$> %transfer);
  `undefined$ `~postMessageSW$n(`any$ %message, optional `StructuredSerializeOptions$I %options = {});

  // event
  attribute `EventHandler$I `onstatechange$m;
};
`ServiceWorker$I includes `AbstractWorker$I;

enum `ServiceWorkerState@I {
  "`parsed@m",
  "`installing@m",
  "`installed@m",
  "`activating@m",
  "`activated@m",
  "`redundant@m"
};

`ServiceWorker$I ~objは、 ある`~sw$を表現する。 いくつかの文書や~workerにまたがって，同時に複数の `ServiceWorker$I ~objが同じ`~sw$を表現し得る。 ◎ A ServiceWorker object represents a service worker. Each ServiceWorker object is associated with a service worker. Multiple separate objects implementing the ServiceWorker interface across documents and workers can all be associated with the same service worker simultaneously.

`ServiceWorkerState$I 列挙は、 `~sw$がとり得る`状態$swを表現し，`~workerの状態を更新する$ときに利用される。 ◎ A ServiceWorker object has an associated ServiceWorkerState object which is itself associated with service worker's state.

/* 
~page `https://example.com/app.html^c 上の~script
◎
Script on the page https://example.com/app.html
 */
navigator.`serviceWorker$n.`register$n("/service_worker.js");

3.2. `ServiceWorkerRegistration^I

[`SecureContext$, `Exposed$=(Window,Worker)]
interface `ServiceWorkerRegistration@I : `EventTarget$I {
  readonly attribute `ServiceWorker$I? `installing$m;
  readonly attribute `ServiceWorker$I? `waiting$m;
  readonly attribute `ServiceWorker$I? `active$m;
  [`SameObject$] readonly attribute `NavigationPreloadManager$I `navigationPreload$m;

  readonly attribute `USVString$ `scope$m;
  readonly attribute `ServiceWorkerUpdateViaCache$I `updateViaCache$m;

  [`NewObject$] `Promise$<`undefined$> `update$m();
  [`NewObject$] `Promise$<`boolean$> `unregister$m();

  // event
  attribute `EventHandler$I `onupdatefound$m;
};

enum `ServiceWorkerUpdateViaCache@I {
  "`imports@m",
  "`all@m",
  "`none@m"
};

各 `ServiceWorkerRegistration$I ~objは、 ある`~sw登録$を表現する。 それを指して，~objが `表現する~sw登録@ という。 ◎ A ServiceWorkerRegistration has a service worker registration (a service worker registration).

【 所与の~sw登録を表現する `ServiceWorkerRegistration^I ~objは， 1 つに限られないが、 同じ`~realm$gL（環境~設定群~obj）内では 1 つに限られる。 】

navigator.serviceWorker.ready.then(%registration => console.log(%registration.scope))

3.3. `serviceWorker^m

partial interface `Navigator$I {
  [`SecureContext$, `SameObject$] readonly attribute `ServiceWorkerContainer$I `serviceWorker$n;
};

partial interface `WorkerNavigator$I {
  [`SecureContext$, `SameObject$] readonly attribute `ServiceWorkerContainer$I `serviceWorker$n;
};

`serviceWorker@n 取得子~手続きは ⇒ ~RET コレに結付けられた `ServiceWorkerContainer$I ~obj ◎ The serviceWorker getter steps are to return the ServiceWorkerContainer object that is associated with this.

3.4. `ServiceWorkerContainer^I

[`SecureContext$, `Exposed$=(Window,Worker)]
interface `ServiceWorkerContainer@I : `EventTarget$I {
  readonly attribute `ServiceWorker$I? `controller$m;
  readonly attribute `Promise$<`ServiceWorkerRegistration$I> `ready$m;

  [`NewObject$] `Promise$<`ServiceWorkerRegistration$I> `register$m(`USVString$ %scriptURL, optional `RegistrationOptions$I %options = {});

  [`NewObject$] `Promise$<(`ServiceWorkerRegistration$I or `undefined$)> `getRegistration$m(optional `USVString$ %clientURL = "");
  [`NewObject$] `Promise$<`FrozenArray$<`ServiceWorkerRegistration$I>> `getRegistrations$m();

  `undefined$ `startMessages$m();

  // events
  attribute `EventHandler$I `oncontrollerchange$m;
  attribute `EventHandler$I `onmessage$m; /* 
`message$etC ~eventの `source^m 属性は `ServiceWorker$I ~objになる
◎
event.source of message events is ServiceWorker object
 */
  attribute `EventHandler$I `onmessageerror$m;
};

dictionary `RegistrationOptions@I {
  `USVString$ `scope@m;
  `WorkerType$I `type@m = `classic^l;
  `ServiceWorkerUpdateViaCache$I `updateViaCache@m = `imports^l;
};

~UAは、［ `Navigator$I ／ `WorkerNavigator$I ］~objを作成したときには、 `ServiceWorkerContainer$I ~objを作成して，前者に後者を結付けるモノトスル。 ◎ The user agent must create a ServiceWorkerContainer object when a Navigator object or a WorkerNavigator object is created and associate it with that object.

`ServiceWorkerContainer$I は、 `~sw登録$ %登録 を［ 登録する, 未登録にする, 更新する ］能力，および［ %登録 の状態, および %登録 に結付けられた`~sw$たち ］への~accessを供する。 ◎ A ServiceWorkerContainer provides capabilities to register, unregister, and update the service worker registrations, and provides access to the state of the service worker registrations and their associated service workers.

各 `ServiceWorkerContainer$I ~obj %容器 には、 以下に挙げるものが結付けられる： ◎ ↓

`~sw~client@SWC ◎ A ServiceWorkerContainer has an associated service worker client,＼

次を満たす`~sw~client$ %~client を指す ⇒ ［ %~client の`大域~obj$enVに結付けられた［ `Navigator$I ／ `WorkerNavigator$I ］~objに結付けられた `ServiceWorkerContainer$I ~obj ］ ~EQ %容器 ◎ which is a service worker client whose global object is associated with the Navigator object or the WorkerNavigator object that the ServiceWorkerContainer is retrieved from.

【 すなわち， 大域~obj . `navigator^n . `serviceWorker$n ~EQ %容器 】

`準備済み~promise@SWC ◎ A ServiceWorkerContainer object has an associated ready promise＼

`~promise$ ／ ~NULL ◎ (a promise or null).＼

初期~時は ~NULL とする ◎ It is initially null.

`~client~message~queue@SWC ◎ A ServiceWorkerContainer object has a task source called the client message queue,＼

`~task~source$ 【すなわち、`~task~queue$であると同時に，独立な~task~sourceを成す。】 ◎ ↑

初期~時は空とする。 ◎ initially empty.＼

この~queueは［ 可能化-／不能化- ］され得る — 初期~時は不能化されているとする。 可能化されたときは、 `~event~loop$は，それを自身の`~task~source$の一つとして利用するモノトスル。 【すなわち，可能化されている間に限り、~queueを成す~taskたちを~event~loopの中で走らす。】 ◎ A client message queue can be enabled or disabled, and is initially disabled. When a ServiceWorkerContainer object’s client message queue is enabled, the event loop must use it as one of its task sources.＼

［ %容器 に`関連な大域~obj$ %G が`~window$である ］ときは、 この~queueに`~queueされ$たすべての`~task$には， %G に`結付けられた文書$を結付けるモノトスル。 【すなわち、~taskの`文書$tK ~SET その文書】 ◎ When the ServiceWorkerContainer object’s relevant global object is a Window object, all tasks queued on its client message queue must be associated with its relevant settings object’s associated document.

3.5. ~event

3.6. `NavigationPreloadManager^I

[`SecureContext$, `Exposed$=(Window,Worker)]
interface `NavigationPreloadManager@I {
  `Promise$<`undefined$> `enable$m();
  `Promise$<`undefined$> `disable$m();
  `Promise$<`undefined$> `setHeaderValue$m(`ByteString$ %value);
  `Promise$<`NavigationPreloadState$I> `getState$m();
};

dictionary `NavigationPreloadState@I {
  `boolean$ `enabled@m = false;
  `ByteString$ `headerValue@m;
};

4.1. `ServiceWorkerGlobalScope^I

[`Global$=(`Worker$I,`ServiceWorker$I), `Exposed$=ServiceWorker, `SecureContext$]
interface `ServiceWorkerGlobalScope@I : `WorkerGlobalScope$I {
  [`SameObject$] readonly attribute `Clients$I `clients$m;
  [`SameObject$] readonly attribute `ServiceWorkerRegistration$I `registration$m;
  [`SameObject$] readonly attribute `ServiceWorker$I `serviceWorker$m;

  [`NewObject$] `Promise$<`undefined$> `skipWaiting$m();

  attribute `EventHandler$I `oninstall$m;
  attribute `EventHandler$I `onactivate$m;
  attribute `EventHandler$I `onfetch$m;

  attribute `EventHandler$I `onmessage$m;
  attribute `EventHandler$I `onmessageerror$m;
};

`ServiceWorkerGlobalScope$I ~objは、 `~sw$の大域~実行~文脈を表現する。 各 `ServiceWorkerGlobalScope$I ~objには、 次に挙げるものが結付けられる： ◎ A ServiceWorkerGlobalScope object represents the global execution context of a service worker.

• `~sw@SWG ⇒ ある`~sw$ ◎ A ServiceWorkerGlobalScope object has an associated service worker (a service worker).
• `~importする~script用には~cacheを迂回するよう強制するか@SWG ⇒ 真偽値をとり，初期~時は ~F とする。 ◎ A ServiceWorkerGlobalScope object has an associated force bypass cache for import scripts flag. It is initially unset.
• `競走~応答~map@SWG ⇒ `有順序~map$ — 各~entryは［ `要請$ → `競走~応答$ ］を与える。 ◎ A ServiceWorkerGlobalScope object has an associated race response map which is an ordered map where the keys are requests and the values are race response.

`競走~応答@ は、 次に挙げる~itemを伴う`構造体$であり，［ `race-network-and-fetch-handler$l を遂行するときに，当の~network応答を包含する ］ために利用される： ◎ A race response is a struct used to contain the network response when "race-network-and-fetch-handler" performs.＼

• `値@rV ⇒ ある`応答$／ `pending^l ／ ~NULL ◎ It has a value, which is a response, "pending", or null.

注記： `ServiceWorkerGlobalScope$I ~objは、 生成元の下で走らす［ 汎用な, ~event駆動な, 時間~制限付きな ］~script実行~文脈を供する。 成功裡に`登録-$されたなら、 `~sw$は，［ `~sw~client$ではなく，~event ］との関係性に基づいて 開始され, 生存し続け, ~killされる。 `~sw$の内側においては、 いかなる型の同期的な要請も，起動されてはナラナイ。 ◎ Note: ServiceWorkerGlobalScope object provides generic, event-driven, time-limited script execution contexts that run at an origin. Once successfully registered, a service worker is started, kept alive and killed by their relationship to events, not service worker clients. Any type of synchronous requests must not be initiated inside of a service worker.

4.2. `Client^I

[`Exposed$=ServiceWorker]
interface `Client@I {
  readonly attribute `USVString$ `url$m;
  readonly attribute `FrameType$I `frameType$m;
  readonly attribute `DOMString$ `id$m;
  readonly attribute `ClientType$I `type$m;
  `undefined$ `postMessage$m(`any$ %message, `sequence$<`object$> %transfer);
  `undefined$ `~postMessageClient$n(`any$ %message, optional `StructuredSerializeOptions$I %options = {});
};

[`Exposed$=ServiceWorker]
interface `WindowClient@I : `Client$I {
  readonly attribute `DocumentVisibilityState$I `visibilityState$m;
  readonly attribute `boolean$ `focused$m;
  [`SameObject$] readonly attribute `FrozenArray$<`USVString$> `ancestorOrigins$m;
  [`NewObject$] `Promise$<`WindowClient$I> `focus$m();
  [`NewObject$] `Promise$<`WindowClient$I?> `navigate$m(`USVString$ %url);
};

enum `FrameType@I {
  "`auxiliary@m",
  "`top-level@m",
  "`nested@m",
  "`none@m"
};

各 `Client$I ~objには、 以下に挙げるものが結付けられる： ◎ ↓

`~sw~client@cl

`~sw~client$。 ◎ A Client object has an associated service worker client (a service worker client).

`~frame種別@cl

`FrameType$I に挙げられたいずれかの文字列。 他が言明されない限り， `none^l とする。 【値の意味は、`~frame種別を取得する$を見よ。】 ◎ A Client object has an associated frame type, which is one of "auxiliary", "top-level", "nested", and "none". Unless stated otherwise it is "none".

各 `WindowClient$I ~objには、 以下に挙げるものも結付けられる： ◎ ↓

`閲覧~文脈@cl

自身の`~sw~client$clの`大域~obj$enVの`閲覧~文脈$を指す。 【すなわち、大域~obj（それは，`~window$である）に`対応する閲覧~文脈$】 ◎ A WindowClient object has an associated browsing context, which is its service worker client's global object's browsing context.

`可視性~状態@cl

`visibilityState$n 属性がとり得る いずれかの値。 ◎ A WindowClient object has an associated visibility state, which is one of visibilityState attribute value.

`~focus状態@cl

~T ／ ~F。 初期~時は ~F とする。 ◎ A WindowClient object has an associated focus state, which is either true or false (initially false).

`先祖~生成元~配列@cl

【`先祖~生成元~list$に設定されることになる。】 ◎ A WindowClient object has an associated ancestor origins array.

4.3. `Clients^I

[`Exposed$=ServiceWorker]
interface `Clients@I {
  /* 
返される~objは、
毎回~新たな~instanceになる
◎
The objects returned will be new instances every time
 */
  [`NewObject$] `Promise$<(`Client$I or `undefined$)> `get$m(`DOMString$ %id);
  [`NewObject$] `Promise$<`FrozenArray$<`Client$I>> `matchAll$m(optional `ClientQueryOptions$I %options = {});
  [`NewObject$] `Promise$<`WindowClient$I?> `openWindow$m(`USVString$ %url);
  [`NewObject$] `Promise$<`undefined$> `claim$m();
};

dictionary `ClientQueryOptions@I {
  `boolean$ `includeUncontrolled@m = false;
  `ClientType$I `type@m = "window";
};

enum `ClientType@I {
  "`window@m",
  "`worker@m",
  "`sharedworker@m",
  "`all@m"
};

~UAは，`ServiceWorkerGlobalScope$I ~obj %G の作成-時には、 `Clients$I ~obj %~client群 を作成して， %G に %~client群 を結付けるモノトスル。 以下における %~client群 の `~sw@cl は、 %G の`~sw$SWGを指すとする。 【この用語`~sw$clは、以下の記述を明確化するために，この訳に導入している。】 ◎ The user agent must create a Clients object when a ServiceWorkerGlobalScope object is created and associate it with that object.

4.4. `ExtendableEvent^I

[`Exposed$=ServiceWorker]
interface `ExtendableEvent@I : `Event$I {
  `constructor@mc(`DOMString$ %type, optional `ExtendableEventInit$I %eventInitDict = {});
  `undefined$ `waitUntil$m(`Promise$<`any$> %f);
};

dictionary `ExtendableEventInit@I : `EventInit$I {
  /* 
`ExtendableEvent^I から派生する~eventを前方-互換にするために定義される
◎
Defined for the forward compatibility across the derived events
 */
};

各 `ExtendableEvent$I0 ~objには、 以下に挙げるものが結付けられる： ◎ ↓

`存続期間を延長する~promise群@

`~promise$たちが成す配列。【！＊】 ◎ An ExtendableEvent object has an associated extend lifetime promises (an array of promises).＼

初期~時は空~配列とする。 ◎ It is initially an empty array.

`処理待ち~promise数@

`存続期間を延長する~promise群$内の処理待ち~promiseの個数を表す整数。 【実際の個数と正確には同期しないため、この定義が必要yである。】 ◎ An ExtendableEvent object has an associated pending promises count (the number of pending promises in the extend lifetime promises).＼

初期~時は 0 とする。 ◎ It is initially set to zero.

`時間切れか@

真偽値をとり，初期~時は ~F とする。 ［ `処理待ち~promise数$ ~GT 0 ］の場合に，~UAが任意選択で課す遅延~後に ~T にされる。 ◎ An ExtendableEvent object has an associated timed out flag. It is initially unset, and is set after an optional user agent imposed delay if the pending promises count is greater than zero.

`ExtendableEvent$I ~objは、 次を満たしている間は `作動中@eX であるとされる ⇒ ［ `時間切れか$ ~EQ ~F ］~AND［［ `処理待ち~promise数$ ~GT 0 ］~OR［ `配送-中か$ev ~EQ ~T ］］ ◎ An ExtendableEvent object is said to be active when its timed out flag is unset and either its pending promises count is greater than zero or its dispatch flag is set.

`~sw$には、 2 種の`~lifecycle~event$ — `install$et, `activate$et — がある。 `~sw$は、 これらの~event用に `ExtendableEvent$I ~interfaceを利用する。 ◎ Service workers have two lifecycle events, install and activate. Service workers use the ExtendableEvent interface for activate event and install event.

`~event~handlerを定義-$する`拡張$も、 `ExtendableEvent$I ~interfaceを利用したり拡張してもヨイ。 ◎ Service worker extensions that define event handlers may also use or extend the ExtendableEvent interface.

4.5. `InstallEvent^I

[`Exposed$=ServiceWorker]
interface `InstallEvent@I : `ExtendableEvent$I {
  `Promise$<`undefined$> `addRoutes$m((`RouterRule$I or `sequence$<`RouterRule$I>) %rules);
};

dictionary `RouterRule@I {
  required `RouterCondition$I `condition@m;
  required `RouterSource$I `source@m;
};

dictionary `RouterCondition@I {
  `URLPatternCompatible$I `urlPattern@m;
  `ByteString$ `requestMethod@m;
  `RequestMode$I `requestMode@m;
  `RequestDestination$I `requestDestination@m;
  `RunningStatus$I `runningStatus@m;

  `sequence$<`RouterCondition$I> _`or@m;
  `RouterCondition$I `not@m;
};

typedef (`RouterSourceDict$I or `RouterSourceEnum$I) `RouterSource@I;

dictionary `RouterSourceDict@I {
  `DOMString$ `cacheName@m;
};

enum `RunningStatus@I {
  "`running@m",
  "`not-running@m"
};
enum `RouterSourceEnum@I {
  "`cache@m",
  "`fetch-event@m",
  "`network@m",
  "`race-network-and-fetch-handler@m"
};

4.6. `FetchEvent^I

[`Exposed$=ServiceWorker]
interface `FetchEvent@I : `ExtendableEvent$I {
  `constructor@mc(`DOMString$ %type, `FetchEventInit$I %eventInitDict);
  [`SameObject$] readonly attribute `Request$I `request$m;
  readonly attribute `Promise$<`any$> `preloadResponse$m;
  readonly attribute `DOMString$ `clientId$m;
  readonly attribute `DOMString$ `resultingClientId$m;
  readonly attribute `DOMString$ `replacesClientId$m;
  readonly attribute `Promise$<`undefined$> `handled$m;

  `undefined$ `respondWith$m(`Promise$<`Response$I> %r);
};

dictionary `FetchEventInit@I : `ExtendableEventInit$I {
  required `Request$I `request@m;
  `Promise$<`any$> `preloadResponse@m;
  `DOMString$ `clientId@m = "";
  `DOMString$ `resultingClientId@m = "";
  `DOMString$ `replacesClientId@m = "";
  `Promise$<`undefined$> `handled@m;
};

`~sw$に~~不可欠な`機能的~event$には、 `fetch$et ~eventがある。 `~sw$は、 `FetchEvent$I ~interfaceを `fetch$et ~eventに利用する — それは、 `ExtendableEvent$I ~interfaceを拡張する。 ◎ Service workers have an essential functional event fetch. For fetch event, service workers use the FetchEvent interface which extends the ExtendableEvent interface.

4.7. `ExtendableMessageEvent^I

[`Exposed$=ServiceWorker]
interface `ExtendableMessageEvent@I : `ExtendableEvent$I {
  `constructor@mc(`DOMString$ %type, optional `ExtendableMessageEventInit$I %eventInitDict = {});
  readonly attribute `any$ `data$m;
  readonly attribute `USVString$ `origin$m;
  readonly attribute `DOMString$ `lastEventId$m;
  [`SameObject$] readonly attribute (`Client$I or `ServiceWorker$I or `MessagePort$I)? `source$m;
  readonly attribute `FrozenArray$<`MessagePort$I> `ports$m;
};

dictionary `ExtendableMessageEventInit@I : `ExtendableEventInit$I {
  `any$ `data@m = null;
  `USVString$ `origin@m = "";
  `DOMString$ `lastEventId@m = "";
  (`Client$I or `ServiceWorker$I or `MessagePort$I)? `source@m = null;
  `sequence$<`MessagePort$I> `ports@m = [];
};

`~sw$は、 `拡張-可能＠#dom-extendableevent-waituntil$な `message$et ~eventを定義して， ~eventの存続期間を延長するのを許容する。 `~sw$は、 `message$et ~event用に `ExtendableMessageEvent$I ~interfaceを利用する — それは `ExtendableEvent$I ~interfaceを拡張する。 ◎ Service workers define the extendable message event to allow extending the lifetime of the event. For the message event, service workers use the ExtendableMessageEvent interface which extends the ExtendableEvent interface.

4.8. ~event

以下に挙げる~eventは、 `~sw~event$と呼ばれ， `ServiceWorkerGlobalScope$I ~objに向けて配送される — 以下に現れる %~sw は、 ~objの`~sw$SWGを表すとする： ◎ The following events, called service worker events, are dispatched on ServiceWorkerGlobalScope object:

5.1. 構成子

`要請~応答~list@ は、 0 個~以上の［ ( `要請$, `応答$ ) が成す`~tuple$ ］たちが成す`~list$である。 ◎ A request response list is a list of tuples consisting of a request (a request) and a response (a response).

~obj %O に `関連な要請~応答~list@ は、 %O が表現する`要請~応答~list$を指す。 【 %O に該当するものは、この仕様においては `Cache$I ~objしかない。】 ◎ The relevant request response list is the instance that this represents.

`名前から~cacheへの~map@ は、 `有順序~map$であり，それを成す各`~entry$mapは［ `要請~応答~list$の名前を表現する文字列 → `要請~応答~list$ ］を与える。 ◎ A name to cache map is an ordered map whose entry consists of a key (a string that represents the name of a request response list) and a value (a request response list).

各`~storage~key$には、 ある`名前から~cacheへの~map$が結付けられる。 ◎ Each storage key has an associated name to cache map.

~obj %O に `関連な名前から~cacheへの~map@ は、 次の結果に結付けられた`名前から~cacheへの~map$を指す。 ⇒ `~storage~keyを得する$( %O に`関連な設定群~obj$【！%O に結付けられた`大域~obj$の`環境~設定群~obj$】 ) ◎ The relevant name to cache map is the name to cache map associated with the storage key obtained from this's associated global object's environment settings object.

【 %O に該当するものは、 この仕様においては `CacheStorage$I ~objしかない。 】

5.2. ~cacheの存続期間を理解する

`Cache$I ~instanceは、 ~browserの~HTTP~cacheの一部を成さない。 作者~自身が、 `Cache$I ~objを管理する必要がある： ◎ The Cache instances are not part of the browser’s HTTP cache. The Cache objects are exactly what authors have to manage themselves.＼

• 作者が明示的に要請しない限り，更新されない。 ◎ The Cache objects do not get updated unless authors explicitly request them to be.＼
• それを成す各~entryは、 作者が削除しない限り失効しない。 ◎ The Cache objects do not expire unless authors delete the entries.＼
• `~sw$~scriptを更新するだけで消失することはない — すなわち、 ~cacheは自動的には更新されず，その更新-は手動で管理しなければナラナイ。 ◎ The Cache objects do not disappear just because the service worker script is updated. That is, caches are not updated automatically. Updates must be manually managed.＼

したがって作者は、 自身の~cacheに名前†により~versionを付与した上で、 それを利用するのは，安全に運用できる~versionの`~sw$に限るようにするべきである。 ◎ This implies that authors should version their caches by name and make sure to use the caches only from the version of the service worker that can safely operate on.

【† `CacheStorage$I 上の各種~methodの %cacheName 引数 ／ `MultiCacheQueryOptions$I の `cacheName^m ~memberを指す。 】

5.3. `self.caches^m

partial interface mixin `WindowOrWorkerGlobalScope$I {
  [`SecureContext$, `SameObject$] readonly attribute `CacheStorage$I `caches$n;
};

5.4. `Cache^I

[`SecureContext$, `Exposed$=(Window,Worker)]
interface `Cache@I {
  [`NewObject$] `Promise$<(`Response$I or `undefined$)> `match$m(`RequestInfo$I %request, optional `CacheQueryOptions$I %options = {});
  [`NewObject$] `Promise$<`FrozenArray$<`Response$I>> `matchAll$m(optional `RequestInfo$I %request, optional `CacheQueryOptions$I %options = {});
  [`NewObject$] `Promise$<`undefined$> `add$m(`RequestInfo$I %request);
  [`NewObject$] `Promise$<`undefined$> `addAll$m(`sequence$<`RequestInfo$I> %requests);
  [`NewObject$] `Promise$<`undefined$> `put$m(`RequestInfo$I %request, `Response$I %response);
  [`NewObject$] `Promise$<`boolean$> `delete$m(`RequestInfo$I %request, optional `CacheQueryOptions$I %options = {});
  [`NewObject$] `Promise$<`FrozenArray$<`Request$I>> `keys$m(optional `RequestInfo$I %request, optional `CacheQueryOptions$I %options = {});
};

dictionary `CacheQueryOptions@I {
  `boolean$ `ignoreSearch@m = false;
  `boolean$ `ignoreMethod@m = false;
  `boolean$ `ignoreVary@m = false;
};

`Cache$I ~objは、 `要請~応答~list$を表現する。 いくつかの文書や~workerにまたがって、 同時に複数の `Cache$I ~objが 同じ`要請~応答~list$を表現し得る。 【同じ文書や~worker上でも，複数あり得る（ `CacheStorage^I1 `open()$m1 を見よ）。】 ◎ A Cache object represents a request response list. Multiple separate objects implementing the Cache interface across documents and workers can all be associated with the same request response list simultaneously.

5.5. `CacheStorage^I

[`SecureContext$, `Exposed$=(Window,Worker)]
interface `CacheStorage@I {
  [`NewObject$] `Promise$<(`Response$I or `undefined$)> `match$m(`RequestInfo$I %request, optional `MultiCacheQueryOptions$I %options = {});
  [`NewObject$] `Promise$<`boolean$> `has$m(`DOMString$ %cacheName);
  [`NewObject$] `Promise$<`Cache$I> `open$m(`DOMString$ %cacheName);
  [`NewObject$] `Promise$<`boolean$> `delete$m(`DOMString$ %cacheName);
  [`NewObject$] `Promise$<`sequence$<`DOMString$>> `keys$m();
};

dictionary `MultiCacheQueryOptions@I : `CacheQueryOptions$I {
  DOMString `cacheName@m;
};

注記： `CacheStorage$I ~interfaceは `ECMAScript 6 Map object＠~TC39#sec-map-objects$ に幅広く適合するよう設計されているが、 全体的に非同期cであり，追加的な便利~methodも伴う。 ［ `clear()^m ／ `forEach()^m ／ `entries()^m ／ `values()^m ］~methodは、 最初の~versionの視野からは，意図的に除外されている — TC39 による非同期cな反復についての進行中な論点に委ねられているので。 ◎ Note: CacheStorage interface is designed to largely conform to ECMAScript 6 Map objects but entirely async, and with additional convenience methods. The methods, clear, forEach, entries and values, are intentionally excluded from the scope of the first version resorting to the ongoing discussion about the async iteration by TC39.

~UAは，［ `Window$I ／ `WorkerGlobalScope$I ］大域~obj %G を作成したときは、 `CacheStorage$I ~obj %C を作成して，それに %G を結付けるモノトスル。 この %G を指して，単に %C の `大域~obj@ と称される。 ◎ The user agent must create a CacheStorage object when a Window object or a WorkerGlobalScope object is created and associate it with that global object.

`CacheStorage$I ~objは、 その`大域~obj$の`環境~設定群~obj$†の`生成元$enVに属する`名前から~cacheへの~map$††を表現する。 いくつかの文書や~workerにまたがって、 同時に複数の `CacheStorage$I ~objが 同じ`名前から~cacheへの~map$を表現し得る†††。 ◎ A CacheStorage object represents a name to cache map of its associated global object's environment settings object’s origin. Multiple separate objects implementing the CacheStorage interface across documents and workers can all be associated with the same name to cache map simultaneously.

【† すなわち、 `関連な設定群~obj$。 】【†† すなわち、 `関連な名前から~cacheへの~map$。 】【††† が、 各 `大域~obj$enVごとに， 1 個に限られる — この~objを返す `caches$n 属性は [SameObject] なので。 】

6.1. ~secureな文脈

注記： これは実質的に、 `~sw$とその`~sw~client$は，~HTTPS越しに~hostする必要があることを意味する。 ~UAは、 開発~目的に［ `localhost^c （ `要件＠~SECURE-CONTEXT#localhost$を見よ）, `127.0.0.0/8^c ／ `::1/128^c ］を許容できる。 この制約の首な理由は、 `~secureでない文脈に結付けられる~risk＠~SECURE-CONTEXT#threat-risks$から利用者を保護することである。 ◎ Note: This effectively means that service workers and their service worker clients need to be hosted over HTTPS. A user agent can allow localhost (see the requirements), 127.0.0.0/8, and ::1/128 for development purposes. The primary reason for this restriction is to protect users from the risks associated with insecure contexts.

6.2. ~CSP

~UAは、 `~swを走らす$とき，当の~swに送達されてきた`~script資源$swに次に挙げる~HTTP ~headerが伴われている場合は： ◎ Whenever a user agent invokes the Run Service Worker algorithm with a service worker serviceWorker:

• `Content-Security-Policy$h ⇒ その値が与える施策を`施行-＠~CSP3#enforced$するモノトスル。 【！https://wicg.github.io/csp-next/scripting-policy.html#scripting-policy-pair-enforced】 ◎ If serviceWorker’s script resource was delivered with a Content-Security-Policy HTTP header containing the value policy, the user agent must enforce policy for serviceWorker.
• `Content-Security-Policy-Report-Only$h ⇒ その値が与える施策を`監視-＠~CSP3#monitored$するモノトスル。 【！https://w3c.github.io/mediacapture-screen-share/#dfn-monitor$】 ◎ If serviceWorker’s script resource was delivered with a Content-Security-Policy-Report-Only HTTP header containing the value policy, the user agent must monitor policy for serviceWorker.

この制約の首な理由は、 ~XSSなどの［ 内容~注入に対する脆弱性が成す~~広範な~class ］を軽減するためである。 ◎ The primary reason for this restriction is to mitigate a broad class of content injection vulnerabilities, such as cross-site scripting (XSS).

6.3. 生成元との相対性

6.4. 非同一-生成元に属する資源と~CORS

~appは、 ~CDNや他の`生成元$enVから来た~itemを~cacheする傾向にある。 それらの多くは、［ `script^e ／ `img^e ／ `video^e ／ `link^e ］要素を利用して，直に要請する可能性もある。 この類の稼働時における協同は、 ~offline時に壊れた場合，著しく制限されることになる。 同様に，適切な~CORS~headerが設定されているときは、 `生成元$enV外にある【すなわち同一-生成元でない】多様な資源を`~fetch$する可能性もある。 `~sw$は、［ `Cache$I が，生成元~外にある~itemを`~fetch$して~cacheできる ］ようにすることで，これを可能化する。 しかしながら，いくつかの制約も適用される： ◎ Applications tend to cache items that come from a CDN or other origin. It is possible to request many of them directly using <script>, <img>, <video> and <link> elements. It would be hugely limiting if this sort of runtime collaboration broke when offline. Similarly, it is possible to fetch many sorts of off-origin resources when appropriate CORS headers are set. Service workers enable this by allowing Caches to fetch and cache off-origin items. Some restrictions apply, however.＼

• 先ず，［ 所与の資源~用に `Cache$I 内で管理され, 格納される `Response$I ~obj ］に対応する`応答$Rsは、 同一-生成元に属する資源に対しては`基本~絞込み応答$になる一方で，生成元~外にある資源に対しては［ `~CORS絞込み応答$ ／ `不透明な絞込み応答$ ］になる。 ◎ First, unlike same-origin resources which are managed in the Cache as Response objects whose corresponding responses are basic filtered response, the objects stored are Response objects whose corresponding responses are either CORS filtered responses or opaque filtered responses.＼
• 次に，生成元~外にある資源~用の `Response$I ~objは、 同一-生成元に属する資源~用のそれと同じ方式で %event . `respondWith()$n ~methodに渡せるが，そのような~objを~program的に作成することはできない。 ◎ They can be passed to event.respondWith(r) method in the same manner as the Response objects whose corresponding responses are basic filtered responses, but cannot be meaningfully created programmatically.＼

これらの制限は、 ~platformの~security不変則を保全するために必要yである。 `Cache$I にそれらを格納できるようにすることにより、 ほとんどの事例では，~appを改築し直さずに済むようになる。 ◎ These limitations are necessary to preserve the security invariants of the platform. Allowing Caches to store them allows applications to avoid re-architecting in most cases.

6.5. ~path制約

`生成元~制約＠#origin-restriction$に加えて、 ~swは，~sw~scriptの`~path$urlにより制約される。 例えば， `https://~example-bob/sw.js^c にある~sw~scriptは、 `~scope~URL$swr `https://~example-bob/^c 用には登録できるが，~scope［ `https://www.example.com/^c ／ `https://~example-alice/^c ］用には登録できない。 これは、 同じ生成元に属するが互いに別々な~directory内に複数~利用者の内容を~hostする~site用に，いくぶんの保護を供する。 しかしながら，この~path制約は、 硬い~security境界とは見なされない — それを成すのは生成元に限られる。 ~siteは、 適切になるならば，［ ~siteを成す各区分に、 異なる生成元を利用して，~secureに隔離する ］ことが奨励される。 ◎ In addition to the origin restriction, service workers are restricted by the path of the service worker script. For example, a service worker script at https://www.example.com/~bob/sw.js can be registered for the scope url https://www.example.com/~bob/ but not for the scope https://www.example.com/ or https://www.example.com/~alice/. This provides some protection for sites that host multiple-user content in separated directories on the same origin. However, the path restriction is not considered a hard security boundary, as only origins are. Sites are encouraged to use different origins to securely isolate segments of the site if appropriate.

~serverは、 ~sw~scriptに対し `Service-Worker-Allowed$h ~headerを設定することにより，この~path制約を除去できる。 ◎ Servers can remove the path restriction by setting a Service-Worker-Allowed header on the service worker script.

6.6. ~sw~script要請

~site上の~swの悪意的な登録に抗して，更に防御するため、 この仕様は次を要求する： ◎ To further defend against malicious registration of a service worker on a site, this specification requires that:

• ~sw~script要請には、 `Service-Worker$h ~headerを伴わせること。 ◎ The Service-Worker header is present on service worker script requests, and
• ~sw~scriptを~serveするときは、 `~JS~MIME型$を伴わせること。 ◎ Service worker scripts are served with a JavaScript MIME type.

6.7. 実装者~向けの懸念点

実装者は、 次に留意しておくことが奨励される： ◎ The implementers are encouraged to note:

• `~sw$を介して~pluginを読込むベキでない。 ~pluginは，自前の~URLから~security生成元を取得することもあり、 埋込んでいる`~sw$はそれを取扱えないので。 この理由から，`~fetchを取扱う$~algoは、［ `embed^e ／ `object^e ］による要請に対しては，［ `fetch$et ~eventを配送することなく，即時に~networkへ~fallbackする ］ようにする。 ◎ Plug-ins should not load via service workers. As plug-ins may get their security origins from their own urls, the embedding service worker cannot handle it. For this reason, the Handle Fetch algorithm makes <embed> and <object> requests immediately fallback to the network without dispatching fetch event.
• 旧来の~network用~stack~codeの一部は、 `~sw$との相互作用における細分化を解するため，注意深く聴取する必要があるかもしれない。 ◎ Some of the legacy networking stack code may need to be carefully audited to understand the ramifications of interactions with service workers.

6.8. ~privacy

`~sw$は、 次を含む新たな持続的~storage特能を導入する ⇒＃ （`~sw登録$とその`~sw$用の）`登録~map$, （~cache用の）`要請~応答~list$と`名前から~cacheへの~map$, （~script資源~用の）`~script資源~map$sw ◎ Service workers introduce new persistent storage features including registration map (for service worker registrations and their service workers), request response list and name to cache map (for caches), and script resource map (for script resources).＼

`追跡し放題になり得る脅威＠#biblio-unsanctioned-tracking$から利用者を保護するため、 これらの持続的~storageは，利用者が~clearするよう意図したときは~clearされるベキであり、 また，既存の利用者-制御 — 既存の持続的~storageをすべて一掃するなど — と相互運用できるよう保守されるベキである。 ◎ In order to protect users from any potential unsanctioned tracking threat, these persistent storages should be cleared when users intend to clear them and should maintain and interoperate with existing user controls e.g. purging all existing persistent storages.

7.1. ~sw登録に束縛される~APIを定義する

仕様は、 `ServiceWorkerRegistration$I ~interfaceの`部分的~interface$定義を利用して，そこに仕様に特有な属性や~methodを定義して，`~sw登録$に束ねられる~APIを定義してもヨイ： ◎ Specifications may define an API tied to a service worker registration by using partial interface definition to the ServiceWorkerRegistration interface where it may define the specification specific attributes and methods:

partial interface ServiceWorkerRegistration {
  /* 
~API名前空間を定義する例：
◎
e.g. define an API namespace
 */
  readonly attribute APISpaceType APISpace;
  /* 
~methodを定義する例：
◎
e.g. define a method
 */
  Promise<T> methodName(/* 引数~list */);
};

7.2. 機能的~eventを定義する

各~仕様は、 `ExtendableEvent$I ~interfaceを拡張することにより，`機能的~event$を定義してもヨイ。 ◎ Specifications may define a functional event by extending ExtendableEvent interface:

/* 
`FunctionalEvent^I ~interfaceを定義する例：
◎
e.g. define FunctionalEvent interface
 */
interface FunctionalEvent : ExtendableEvent {
  /* 
機能的~eventの自前の属性や~methodを追加する
◎
add a functional event’s own attributes and methods
 */
};

7.3. ~event~handlerを定義する

各~仕様は、 `ServiceWorkerGlobalScope$I ~interface用の`部分的~interface$定義を利用して，対応している`機能的~event$用に~event~handler属性を定義してもヨイ： ◎ Specifications may define an event handler attribute for the corresponding functional event using partial interface definition to the ServiceWorkerGlobalScope interface:

partial interface ServiceWorkerGlobalScope {
  attribute EventHandler onfunctionalevent;
};

7.4. 機能的~eventの発火-法

各~仕様は、 `~sw登録$にて`作動中な~worker$swrに向けて `機能的~event$を配送するよう要請するときは，`機能的~eventを発火する$べきである。 ◎ To request a functional event dispatch to the active worker of a service worker registration, specifications should invoke Fire Functional Event.

`~jobを作成する@

• 入力 ⇒＃ %~job種別 — `~job種別$job, %~storage~key — `~storage~key$, %~scope~URL — `~URL$, %~script~URL — `~URL$, %~promise — `~promise$, %~client — `~sw~client$ ◎ Input • jobType, a job type • storage key, a storage key • scopeURL, a URL • scriptURL, a URL • promise, a promise • client, a service worker client
• 出力 ⇒＃ %~job — `~job$ ◎ Output • job, a job

1. %~job ~LET 新たな`~job$ ◎ Let job be a new job.
2. %~job の ⇒＃ `~job種別$job ~SET %~job種別, `~storage~key$job ~SET %~storage~key, `~scope~URL$job ~SET %~scope~URL, `~script~URL$job ~SET %~script~URL, `~job~promise$job ~SET %~promise, `~client$job ~SET %~client ◎ Set job’s job type to jobType. ◎ Set job’s storage key to storage key. ◎ Set job’s scope url to scopeURL. ◎ Set job’s script url to scriptURL. ◎ Set job’s job promise to promise. ◎ Set job’s client to client.
3. ~IF［ %~client ~NEQ ~NULL ］ ⇒ %~job の`~referrer$job ~SET %~client の`作成時の~URL$enV ◎ If client is not null, set job’s referrer to client’s creation URL.
4. ~RET %~job ◎ Return job.

`~jobを~scheduleする@

• 入力 ⇒＃ %~job — `~job$ ◎ Input • job, a job
• 出力 ⇒＃ ~none ◎ Output • none

1. %~job~queue ~LET ~NULL ◎ Let jobQueue be null.
2. %~job~scope ~LET `~URLを直列化する$( %~job の`~scope~URL$job ) ◎ Let jobScope be job’s scope url, serialized.
3. ~IF［ `~scopeから~job~queueへの~map$[ %~job~scope ] ~EQ ε ］ ⇒ `~scopeから~job~queueへの~map$[ %~job~scope ] ~SET 新たな`~job~queue$ ◎ If scope to job queue map[jobScope] does not exist, set scope to job queue map[jobScope] to a new job queue.
4. %~job~queue ~SET `~scopeから~job~queueへの~map$[ %~job~scope ] ◎ Set jobQueue to scope to job queue map[jobScope].

5. ~IF［ %~job~queue は`空$である ］： ◎ If jobQueue is empty, then:

   1. %~job を`包含している~job~queue$job ~SET %~job~queue ◎ Set job’s containing job queue to jobQueue, and＼
   2. %~job~queue に %~job を`~enqueueする$ ◎ enqueue job to jobQueue.
   3. `~jobを走らす$( %~job~queue ) ◎ Invoke Run Job with jobQueue.

6. ~ELSE： ◎ Else:

   1. %最後の~job ~LET %~job~queue の最後の`~item$ 【！＊the element at the back of】 ◎ Let lastJob be the element at the back of jobQueue.
   2. ~IF［ `等価である$job( %~job, %最後の~job ) ］~AND［ %最後の~job の`~job~promise$jobはまだ決着してない ］ ⇒ %最後の~job の`等価~job~list$jobに %~job を付加する ◎ If job is equivalent to lastJob and lastJob’s job promise has not settled, append job to lastJob’s list of equivalent jobs.
   3. ~ELSE ⇒＃ %~job を`包含している~job~queue$job ~SET %~job~queue； %~job~queue に %~job を`~enqueueする$ ◎ Else, set job’s containing job queue to jobQueue, and enqueue job to jobQueue.

`~jobを走らす@

• 入力 ⇒＃ %~job~queue — `~job~queue$ ◎ Input • jobQueue, a job queue
• 出力 ⇒＃ ~none ◎ Output • none

1. ~Assert： %~job~queue は`空$でない ◎ Assert: jobQueue is not empty.

2. `~taskを~queueする$(【どの~task~sourceか指定されていない】, 次の手続き ) ◎ Queue a task to run these steps:

   手続きは：

   1. %~job ~LET %~job~queue の最初の`~item$ ◎ Let job be the first item in jobQueue.
   2. %~job種別 ~LET %~job の`~job種別$job ◎ ↓

   3. この段は`並列的$に走らす ⇒ %~job種別 に応じて：

      • `登録する^i ⇒ `登録する$( %~job )
      • `更新する^i ⇒ `更新する$( %~job )
      • `未登録にする^i ⇒ `未登録にする$( %~job )

      注記： %~job の［ 登録-／更新- ］に対しては、 ~UAは，［ %~job を走らす~task ］を~queueするのを［［ %~job を起動した文書 ］に向けて， `DOMContentLoaded$I ~eventを配送した後 ］まで遅延する。

      ◎ If job’s job type is register, run Register with job in parallel. ◎ Else if job’s job type is update, run Update with job in parallel. ◎ Note: For a register job and an update job, the user agent delays queuing a task for running the job until after a DOMContentLoaded event has been dispatched to the document that initiated the job. ◎ Else if job’s job type is unregister, run Unregister with job in parallel.

`~jobを完遂する@

• 入力 ⇒＃ %~job — `~job$ ◎ Input • job, a job
• 出力 ⇒＃ ~none ◎ Output • none

1. %~job~queue ~LET %~job を`包含している~job~queue$job ◎ Let jobQueue be job’s containing job queue.
2. ~Assert： %~job~queue の最初の`~item$ ~EQ %~job ◎ Assert: the first item in jobQueue is job.
3. %~job~queue から`~dequeueする$ ◎ Dequeue from jobQueue.
4. ~IF［ %~job~queue は`空$でない ］ ⇒ `~jobを走らす$( %~job~queue ) ◎ If jobQueue is not empty, invoke Run Job with jobQueue.

`~job~promiseを解決する@

• 入力 ⇒＃ %~job — `~job$, %値 — 任意の値 ◎ Input • job, a job • value, any
• 出力 ⇒＃ ~none ◎ Output • none

1. %~job~promiseを内部的に解決する ~LET 所与の ( %入力~job ) に対し，次を走らす手続き：

   1. %~client ~LET %入力~job の`~client$job
   2. ~IF［ %~client ~EQ ~NULL ］ ⇒ ~RET
   3. %O ~LET ε

   4. ~IF［ %入力~job の`~job種別$job ~IN { `登録する^i, `更新する^i } ］：

      1. ~Assert： %値 は`~sw登録$である
      2. %O ~SET `~sw登録~objを取得する$( %値, %~client )
   5. ~ELSE ⇒ %O ~SET %~client の`~realm$enV 内で %値 を表現する値

   6. `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~client の`担当の~event~loop$enV )

      手続きは ⇒ %O で %入力~job の`~job~promise$jobを解決する
   ◎ ↓
2. %~job~promiseを内部的に解決する( %~job ) ◎ If job’s client is not null, queue a task, on job’s client's responsible event loop using the DOM manipulation task source, to run the following substeps: • Let convertedValue be null. • If job’s job type is either register or update, set convertedValue to the result of getting the service worker registration object that represents value in job’s client. • Else, set convertedValue to value, in job’s client's Realm. • Resolve job’s job promise with convertedValue.
3. %~job の`等価~job~list$jobを成す ~EACH( %等価な~job ) に対し ⇒ %~job~promiseを内部的に解決する( %等価な~job ) ◎ For each equivalentJob in job’s list of equivalent jobs: • If equivalentJob’s client is null, continue to the next iteration of the loop. • Queue a task, on equivalentJob’s client's responsible event loop using the DOM manipulation task source, to run the following substeps: •• Let convertedValue be null. •• If equivalentJob’s job type is either register or update, set convertedValue to the result of getting the service worker registration object that represents value in equivalentJob’s client. •• Else, set convertedValue to value, in equivalentJob’s client's Realm. •• Resolve equivalentJob’s job promise with convertedValue.

`~job~promiseを却下する@

• 入力 ⇒＃ %~job — `~job$, %~error~data — `新たな例外$を作成するために必要yな情報 ◎ Input • job, a job • errorData, the information necessary to create an exception
• 出力 ⇒＃ ~none ◎ Output • none

1. %~job~promiseを内部的に却下する ~LET 所与の ( %入力~job ) に対し，次を走らす手続き：

   1. %~client ~LET %入力~job の`~client$job
   2. ~IF［ %~client ~EQ ~NULL ］ ⇒ ~RET
   3. %例外 ~LET %~client の`~realm$enV内に作成される`新たな例外$( %~error~data, ~UAにより定義される`~message^ )

   4. `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~client の`担当の~event~loop$enV )

      手続きは ⇒ `~promiseを却下する$( %入力~job の`~job~promise$job, %例外 )
   ◎ ↓
2. %~job~promiseを内部的に却下する( %~job ) ◎ If job’s client is not null, queue a task, on job’s client's responsible event loop using the DOM manipulation task source, to reject job’s job promise with a new exception with errorData and a user agent-defined message, in job’s client's Realm.
3. %~job の`等価~job~list$jobを成す ~EACH( %等価な~job ) に対し ⇒ %~job~promiseを内部的に却下する( %等価な~job ) ◎ For each equivalentJob in job’s list of equivalent jobs: • If equivalentJob’s client is null, continue. • Queue a task, on equivalentJob’s client's responsible event loop using the DOM manipulation task source, to reject equivalentJob’s job promise with a new exception with errorData and a user agent-defined message, in equivalentJob’s client's Realm.

`登録を開始する@

• 入力 ⇒＃ %~scope~URL — `~URL$ ／ `失敗^i ／ ~NULL, %~script~URL — `~URL$ ／ `失敗^i, %~promise — `~promise$, %~client — `~sw~client$, %~referrer — `~URL$, %~worker種別 — `~worker種別$job, %~cacheを介する更新 — `~cacheを介する更新~mode$swr ◎ Input • scopeURL, a URL or failure or null • scriptURL, a URL or failure • promise, a promise • client, a service worker client • referrer, a URL • workerType, a worker type • updateViaCache, an update via cache mode
• 出力 ⇒＃ ~none ◎ Output • none

1. ~IF［ %~script~URL ~EQ `失敗^i ］ ⇒＃ `~promiseを却下する$( %~promise, `TypeError^E )； ~RET ◎ If scriptURL is failure, reject promise with a TypeError and abort these steps.

2. %~script~URL の`素片$url ~SET ~NULL ◎ Set scriptURL’s fragment to null.

   注記： ~UAは~scriptの~URLの`素片$urlは格納しない。 これは、 `素片$urlにより`~sw$を識別する効果は無いことを意味する。 ◎ Note: The user agent does not store the fragment of the script’s url. This means that the fragment does not have an effect on identifying service workers.

3. ~IF［ ~OR↓ ］…

   • %~script~URL の`~scheme$url ~NIN { `http^l , `https^l }
   • %~script~URL の`~path$url内のある文字列は、 `~ASCII大小無視$で［ `%2f^l か `%5c^l ］を包含する

   …ならば ⇒＃ `~promiseを却下する$( %~promise, `TypeError^E )； ~RET

   ◎ If scriptURL’s scheme is not one of "http" and "https", reject promise with a TypeError and abort these steps. ◎ If any of the strings in scriptURL’s path contains either ASCII case-insensitive "%2f" or ASCII case-insensitive "%5c", reject promise with a TypeError and abort these steps.

4. ~IF［ %~scope~URL ~EQ ~NULL ］ ⇒ %~scope~URL ~SET `~URL構文解析する$( 文字列 `./^l , %~script~URL ) ◎ If scopeURL is null, set scopeURL to the result of parsing the string "./" with scriptURL.

   注記： すなわち，既定では、 登録~用の~scope~URLは ~sw~scriptの所在に設定される。 ◎ Note: The scope url for the registration is set to the location of the service worker script by default.

5. ~IF［ %~scope~URL ~EQ `失敗^i ］ ⇒＃ `~promiseを却下する$( %~promise, `TypeError^E )； ~RET ◎ If scopeURL is failure, reject promise with a TypeError and abort these steps.

6. %~scope~URL の`素片$url ~SET ~NULL ◎ Set scopeURL’s fragment to null.

   注記： ~UAは %~scope~URL の`素片$urlは格納しない。 これは、 `素片$urlにより`~sw登録$を識別する効果は無いことを意味する。 ◎ Note: The user agent does not store the fragment of the scope url. This means that the fragment does not have an effect on identifying service worker registrations.

7. ~IF［ ~OR↓ ］…

   • %~scope~URL の`~scheme$url ~NIN { `http^l , `https^l }
   • %~scope~URL の`~path$url内のある文字列は、 `~ASCII大小無視$で［ `%2f^l か `%5c^l ］を包含する

   …ならば ⇒＃ `~promiseを却下する$( %~promise, `TypeError^E )； ~RET

   ◎ If scopeURL’s scheme is not one of "http" and "https", reject promise with a TypeError and abort these steps. ◎ If any of the strings in scopeURL’s path contains either ASCII case-insensitive "%2f" or ASCII case-insensitive "%5c", reject promise with a TypeError and abort these steps.
8. %~storage~key ~LET `~storage~keyを得する$( %~client ) ◎ Let storage key be the result of running obtain a storage key given client.
9. %~job ~LET `~jobを作成する$( ↓ ) ⇒＃ `登録する^i, %~storage~key, %~scope~URL, %~script~URL, %~promise, %~client ◎ Let job be the result of running Create Job with register, storage key, scopeURL, scriptURL, promise, and client.
10. %~job の ⇒＃ `~worker種別$job ~SET %~worker種別, `~cacheを介する更新~mode$job ~SET %~cacheを介する更新, `~referrer$job ~SET %~referrer ◎ Set job’s worker type to workerType. ◎ Set job’s update via cache mode to updateViaCache. ◎ Set job’s referrer to referrer.
11. `~jobを~scheduleする$( %~job ) ◎ Invoke Schedule Job with job.

`登録する@

• 入力 ⇒＃ %~job — `~job$ ◎ Input • job, a job
• 出力 ⇒＃ ~none ◎ Output • none

1. ~IF［ ~OR↓ ］…

   • `信用に価し得る生成元か？$( %~job の`~script~URL$jobの`生成元$url【！`生成元$enV】 ) ~EQ `価しない^i
   • %~job の`~script~URL$jobの`生成元$url ~NEQ`生成元$sub %~job の`~referrer$jobの`生成元$url
   • %~job の`~scope~URL$jobの`生成元$url ~NEQ`生成元$sub %~job の`~referrer$jobの`生成元$url

   …ならば：

   1. `~job~promiseを却下する$( %~job, `SecurityError$E 例外 )
   2. `~jobを完遂する$( %~job )
   3. ~RET
   ◎ If the result of running potentially trustworthy origin with the origin of job’s script url as the argument is Not Trusted, then: • Invoke Reject Job Promise with job and "SecurityError" DOMException. • Invoke Finish Job with job and abort these steps. ◎ If job’s script url's origin and job’s referrer's origin are not same origin, then: • Invoke Reject Job Promise with job and "SecurityError" DOMException. • Invoke Finish Job with job and abort these steps. ◎ If job’s scope url's origin and job’s referrer's origin are not same origin, then: • Invoke Reject Job Promise with job and "SecurityError" DOMException. • Invoke Finish Job with job and abort these steps.
2. %登録 ~LET `登録を取得する$( %~job の`~storage~key$job, %~job の`~scope~URL$job ) ◎ Let registration be the result of running Get Registration given job’s storage key and job’s scope url.

3. ~IF［ %登録 ~NEQ ~NULL ］： ◎ If registration is not null, then:

   1. %最新~worker ~LET `最新な~workerを取得する$( %登録 ) ◎ Let newestWorker be the result of running the Get Newest Worker algorithm passing registration as the argument.

   2. ~IF［ %最新~worker ~NEQ ~NULL ］~AND［ ( %~job の`~script~URL$job, %最新~worker の`~script~URL$sw ) は`同等な~URL$である ］~AND［ %~job の`~worker種別$job ~EQ %最新~worker の`種別$sw ］~AND［ %~job の`~cacheを介する更新~mode$job ~EQ %登録 の`~cacheを介する更新~mode$swr ］： ◎ If newestWorker is not null, job’s script url equals newestWorker’s script url, job’s worker type equals newestWorker’s type, and job’s update via cache mode's value equals registration’s update via cache mode, then:

      1. `~job~promiseを解決する$( %~job, %登録 ) ◎ Invoke Resolve Job Promise with job and registration.
      2. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
      3. ~RET ◎ abort these steps.

4. ~ELSE ⇒ `登録を設定する$( %~job の`~storage~key$job, %~job の`~scope~URL$job, %~job の`~cacheを介する更新~mode$job ) ◎ Else: • Invoke Set Registration algorithm with job’s storage key, job’s scope url, and job’s update via cache mode.

5. `更新する$( %~job ) ◎ Invoke Update algorithm passing job as the argument.

`更新する@

• 入力 ⇒＃ %~job — `~job$ ◎ Input • job, a job
• 出力 ⇒＃ ~none ◎ Output • none

1. %登録 ~LET `登録を取得する$( %~job の`~storage~key$job, %~job の`~scope~URL$job ) ◎ Let registration be the result of running Get Registration given job’s storage key and job’s scope url.

2. ~IF［ %登録 ~EQ ~NULL ］： ◎ If registration is null, then:

   1. `~job~promiseを却下する$( %~job, `TypeError^E ) ◎ Invoke Reject Job Promise with job and TypeError.
   2. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
   3. ~RET ◎ abort these steps.
3. %最新~worker ~LET `最新な~workerを取得する$( %登録 ) ◎ Let newestWorker be the result of running Get Newest Worker algorithm passing registration as the argument.

4. ~IF［ %~job の`~job種別$job ~EQ `更新する^i ］~AND［ %最新~worker ~NEQ ~NULL ］~AND［ ( %最新~worker の`~script~URL$sw, %~job の`~script~URL$job ) は`同等な~URL$でない ］： ◎ If job’s job type is update, and newestWorker is not null and its script url does not equal job’s script url, then:

   1. `~job~promiseを却下する$( %~job, `TypeError^E ) ◎ Invoke Reject Job Promise with job and TypeError.
   2. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
   3. ~RET ◎ abort these steps.
5. %~URL ~LET `~URLを直列化する$( %~job の`~script~URL$job ) ◎ ↓
6. %資源を更新したか ~LET ~F ◎ Let hasUpdatedResources be false.
7. %更新-済み資源~map ~LET 新たな`有順序~map$ （この~mapは、 `~script資源~map$swを与えることになる） ◎ Let updatedResourceMap be an ordered map where the keys are URLs and the values are responses.

8. 【 この訳では、 `HTML$r の更新に整合させるため， 原文における この段の中の一部の記述を改めている — それは、 `この仕様に期待される更新＠https://github.com/w3c/ServiceWorker/pull/1658$に基づく （処理~modelに対する本質的な変更は無い） （特に、［ %完了-時の手続き, %~fetchを遂行する ］を導入するとともに， 原文にて `Asynchronously complete^en （ “非同期に完了する” ）と記された箇所を %~custom~fetch応答の処理n（および ~RET）に置換している）。 】

   %~job の`~worker種別$jobに応じて： ◎ Switching on job’s worker type, run these substeps with the following options:

   `classic^l

   `~worker用~古典~scriptを~fetchする$( ↓ ) ⇒＃ %~URL, %~job の`~client$job, `serviceworker^l, 設定群† %完了-時の手続き（以下に定義される）, %~fetchを遂行する（以下に定義される） ◎ Fetch a classic worker script given job’s serialized script url, job’s client, "serviceworker", and the to-be-created environment settings object for this service worker.

   `module^l

   `~module~worker~script~graphを~fetchする$( ↓ ) ⇒＃ %~URL, %~job の`~client$job, `serviceworker^l, `omit^l, 設定群† %完了-時の手続き（以下に定義される）, %~fetchを遂行する（以下に定義される）【この引数は不要？】 ◎ Fetch a module worker script graph given job’s serialized script url, job’s client, "serviceworker", "omit", and the to-be-created environment settings object for this service worker.

   † 上に与えた設定群は、 この~sw用に【必要になった時点で】`作成されることになる^em`環境~設定群~obj$を与える。 【例えば~fetchに失敗した場合、作成されないであろう。】 ◎ ↑

   具象的な`環境~設定群~obj$ではなく，作成されることになる`環境~設定群~obj$を利用しているのは、 ~swの処理~modelが，他の`~web~worker$の処理~modelに比較して，独特であることに因る。 ~HTML標準の~scriptを~fetchする~algoは、 元々は他の`~web~worker$用に設計されており，実行~環境の`環境~設定群~obj$を要求するが、 ~swは，~scriptを — 後で，`~swを走らす$~algoを通して複数回~走らす前に — `更新する$~algo内で別々に~fetchするので。 ◎ Using the to-be-created environment settings object rather than a concrete environment settings object. This is used due to the unique processing model of service workers compared to the processing model of other web workers. The script fetching algorithms of HTML standard originally designed for other web workers require an environment settings object of the execution environment, but service workers fetch a script separately in the Update algorithm before the script later runs multiple times through the Run Service Worker algorithm.

   ~HTMLにおける［ `~worker用~古典~scriptを~fetchする$／ `~module~worker~script~graphを~fetchする$ ］~algoは、 %~job の`~client$jobを引数にとる。 %~job の`~client$jobは、 `~soft更新する$~algoから渡されるときは ~NULL になる。 ◎ The fetch a classic worker script algorithm and the fetch a module worker script graph algorithm in HTML take job’s client as an argument. job’s client is null when passed from the Soft Update algorithm.

   %~fetchを遂行する は、 `~fetchを遂行する~hook$であり， 所与の ( %要請, %~top-levelか, %~custom~fetch応答の処理n ) に対し，次を走らす： 【！In both cases, let performFetch be the following asynchronous perform the fetch hook given request, isTopLevel and processCustomFetchResponse:】 ◎ To perform the fetch given request, run the following steps:

   1. %要請 の`~header~list$rq に`~headerを付加する$( ( `Service-Worker^h, `script^bl ) ) ◎ Append `Service-Worker`/`script` to request’s header list.

      注記： `§ 拡張された~HTTP~header＠#extended-http-headers$ における `Service-Worker^h ~headerの定義を見よ。 ◎ Note: See the definition of the Service-Worker header in Appendix B: Extended HTTP headers.

   2. ~IF［ ~OR↓ ］… ◎ Set request’s cache mode to "no-cache" if any of the following are true:

      • %登録 の`~cacheを介する更新~mode$swr ~NEQ `all^l ◎ registration’s update via cache mode is not "all".
      • %~job の`~cacheを迂回するよう強制するか$job ~EQ ~T ◎ job’s force bypass cache flag is set.
      • ［ %最新~worker ~NEQ ~NULL ］~AND［ %登録 は`非新鮮$である ］ ◎ newestWorker is not null and registration is stale.

      …ならば ⇒ %要請 の`~cache~mode$rq ~SET `no-cache^l ◎ ↑

      注記： ［ ~cache~mode ~NEQ `no-cache^l ］の場合でも、 ~UAは，［ ~browser~cacheを迂回するべきかどうか ］を決定するため［ ~network層における `Cache-Control$h ~headerの `max-age^dir 値 ］を順守する。 ◎ Note: Even if the cache mode is not set to "no-cache", the user agent obeys Cache-Control header’s max-age value in the network layer to determine if it should bypass the browser cache.

   3. %要請 の`~sw~mode$rq ~SET `none^l ◎ Set request’s service-workers mode to "none".

   4. ~IF［ %~top-levelか ~EQ ~F ］：

      1. ~RET %要請 を`~fetchする$ — 次を与える下で ⇒ `応答の本体を消費する処理n^i ~SET %~custom~fetch応答の処理n
      2. ； ~RET
      【！If isTopLevel is false fetch request with processCustomFetchResponse as processResponseConsumeBody, and abort these steps.】 ◎ If the isTopLevel flag is unset, then return the result of fetching request.
   5. %要請 の`~redirect~mode$rq ~SET `error^l ◎ Set request’s redirect mode to "error".

   6. %要請 を`~fetchする$ — 次を与える下で ⇒ `応答の処理n^i ~SET 次に定義する手続き ◎ Fetch request, and asynchronously wait to run the remaining steps as part of fetch’s processResponse for the response response.

      手続きは，所与の ( `応答$ %応答 ) に対し，次を走らす： ◎ ↑

      1. %~MIME型 ~LET `~header~listから~MIME型を抽出する$( %応答 の`~header~list$rs ) ◎ Extract a MIME type from the response’s header list.＼

      2. ~IF［ %~MIME型 は`~JS~MIME型$でない【！不要：(ignoring parameters)】 ］： ◎ If this MIME type (ignoring parameters) is not a JavaScript MIME type, then:

         1. `~job~promiseを却下する$( %~job, `SecurityError$E 例外 ) ◎ Invoke Reject Job Promise with job and "SecurityError" DOMException.
         2. %~custom~fetch応答の処理n( `~network~error$ ) 【！Invoke processCustomFetchResponse with a network error and abort these steps.】 ◎ Asynchronously complete these steps with a network error.
         3. ~RET

      3. %許容される~sw ~LET `~header~listから値を抽出する$( %応答 の`~header~list$rs, `Service-Worker-Allowed^h ) ◎ Let serviceWorkerAllowed be the result of extracting header list values given `Service-Worker-Allowed` and response’s header list.

         注記： `§ 拡張された~HTTP~header＠#extended-http-headers$ における `Service-Worker-Allowed$h ~headerの定義を見よ。 ◎ Note: See the definition of the Service-Worker-Allowed header in Appendix B: Extended HTTP headers.

      4. %施策~容器 ~SET `~fetch応答から施策~容器を作成する$( %応答 ) ◎ Set policyContainer to the result of creating a policy container from a fetch response given response.
      5. ~IF［ %許容される~sw ~EQ `失敗^i ］ ⇒＃ %~custom~fetch応答の処理n( `~network~error$ )； ~RET【！If serviceWorkerAllowed is failure, then: Invoke processCustomFetchResponse with a network error and abort these steps.】 ◎ If serviceWorkerAllowed is failure, then: • Asynchronously complete these steps with a network error.

      6. %合致したか ~LET 次の手続きを走らせた結果 ◎ ↓↓

         1. %最大-~scope ~LET ε ◎ ↓↓ Let scopeURL be registration’s scope url. ◎ ↓↓ Let maxScopeString be null.

         2. ~IF［ %許容される~sw ~EQ ~NULL ］ ⇒ %最大-~scope ~LET `~URL構文解析する$( `./^l, %~job の`~script~URL$job ) ◎ If serviceWorkerAllowed is null, then: • Let resolvedScope be the result of parsing "./" using job’s script url as the base URL. • Set maxScopeString to "/", followed by the strings in resolvedScope’s path (including empty strings), separated from each other by "/".

            注記： %最大-~scope の`~path$urlの最後の~itemは，常に空~文字列になるので、 下の %最大-~scope文字列 の末尾は `/^l になる。 ◎ Note: The final item in resolvedScope’s path will always be an empty string, so maxScopeString will have a trailing "/".

         3. ~ELSE： ◎ Else:

            1. %最大-~scope ~LET `~URL構文解析する$( %許容される~sw, %~job の`~script~URL$job ) ◎ Let maxScope be the result of parsing serviceWorkerAllowed using job’s script url as the base URL.
            2. ~IF［ %最大-~scope の`生成元$url ~NEQ`生成元$sub %~job の`~script~URL$jobの`生成元$url ］ ⇒ ~RET ~F ◎ If maxScope’s origin is job’s script url's origin, then: • Set maxScopeString to "/", followed by the strings in maxScope’s path (including empty strings), separated from each other by "/".
         4. %最大-~scope文字列 ~LET 次の結果を `/^l で`連結する$ ⇒ « 空~文字列 » を %最大-~scope の`~path$urlで`拡張する$ ◎ ↑
         5. %~scope文字列 ~LET 次の結果を `/^l で`連結する$ ⇒ « 空~文字列 » を［ %登録 の`~scope~URL$swrの`~path$url ］で`拡張する$ ◎ Let scopeString be "/", followed by the strings in scopeURL’s path (including empty strings), separated from each other by "/".
         6. ~IF［ %最大-~scope文字列 は %~scope文字列 の`符号単位~接頭辞$でない【！not start with】 ］ ⇒ ~RET ~F ◎ ↓
         7. ~RET ~T ◎ ↓

      7. ~IF［ %合致したか ~EQ ~F ］： ◎ If maxScopeString is null or scopeString does not start with maxScopeString, then:

         1. `~job~promiseを却下する$( %~job, `SecurityError$E 例外 ) ◎ Invoke Reject Job Promise with job and "SecurityError" DOMException.
         2. %~custom~fetch応答の処理n( `~network~error$ ) 【！】 ◎ Asynchronously complete these steps with a network error.
         3. ~RET
      8. %~URL ~LET %要請 の`~URL$rq ◎ Let url be request’s url.
      9. %更新-済み資源~map[ %~URL ] ~SET %応答 ◎ Set updatedResourceMap[url] to response.
      10. ~IF［ %応答 の`~cache状態$ ~NEQ `local^l ］ ⇒ %登録 の`最後の更新~検査-時刻$swr ~SET 現在の時刻 ◎ If response’s cache state is not "local", set registration’s last update check time to the current time.

      11. ~IF［ ~OR↓ ］…

          • %最新~worker ~EQ ~NULL
          • ［ %最新~worker の`~script~URL$sw ~NEQ %~URL【！＊】 ］~OR［ %最新~worker の`種別$sw ~NEQ %~job の`~worker種別$job ］
          • ［ %最新~worker の`~script資源~map$sw[ %~URL ] の`本体$rs, %応答 の`本体$rs ］は、 ~byte列として一致しない

          …ならば ⇒ %資源を更新したか ~SET ~T

          ◎ Set hasUpdatedResources to true if any of the following are true: • newestWorker is null. • newestWorker’s script url is not url or newestWorker’s type is not job’s worker type. • newestWorker’s script resource map[url]'s body is not byte-for-byte identical with response’s body.

      12. ~IF［ %資源を更新したか ~EQ ~F ］~AND［ %最新~worker の`古典~scriptは~import済みか$sw ~EQ ~T ］： ◎ If hasUpdatedResources is false and newestWorker’s classic scripts imported flag is set, then:

          注記： この段は、 ~importした~scriptが更新されたかどうかを検査する — ~main~scriptは変化しなかった【ことが前~段から判明した】ので。 ◎ Note: The following checks to see if an imported script has been updated, since the main script has not changed.

          1. %最新~worker の`~script資源~map$swを成す ~EACH( %~import~URL → %格納-済み応答 ) に対し： ◎ For each importUrl → storedResponse of newestWorker’s script resource map:

             1. ~IF［ %~import~URL ~EQ %~URL【！＊】 ］ ⇒ ~CONTINUE ◎ If importUrl is url, then continue.
             2. %~import要請 ~LET 新たな`要請$ — その ⇒＃ `~URL$rq~SET %~import~URL, `~client$rq~SET %~job の`~client$job, `行先$rq~SET `script^l, `構文解析器~metadata$rq~SET `not parser-inserted^l, 同期~flag【廃された】 ~SET ~T, `~URL資格証を利用するか$rq~SET ~T ◎ Let importRequest be a new request whose url is importUrl, client is job’s client, destination is "script", parser metadata is "not parser-inserted", synchronous flag is set, and whose use-URL-credentials flag is set.

             3. ~IF［ ~OR↓ ］… ◎ Set importRequest’s cache mode to "no-cache" if any of the following are true:

                • %登録 の`~cacheを介する更新~mode$swr ~EQ `none^l ◎ registration’s update via cache mode is "none".
                • %~job の`~cacheを迂回するよう強制するか$job ~EQ ~T ◎ job’s force bypass cache flag is set.
                • %登録 は`非新鮮$である ◎ registration is stale.

                …ならば ⇒ %~import要請 の`~cache~mode$rq ~SET `no-cache^l ◎ ↑

             4. %~fetchした応答 ~LET %~import要請 を`~fetchする$ ◎ Let fetchedResponse be the result of fetching importRequest.
             5. %更新-済み資源~map[ %~import要請 の`~URL$rq ] ~SET %~fetchした応答 ◎ Set updatedResourceMap[importRequest’s url] to fetchedResponse.
             6. %~fetchした応答 ~SET %~fetchした応答 の`安全でない応答$ ◎ Set fetchedResponse to fetchedResponse’s unsafe response.
             7. ~IF［ %~fetchした応答 の`~cache状態$ ~NEQ `local^l ］ ⇒ %登録 の`最後の更新~検査-時刻$swr ~SET 現在の時刻 ◎ If fetchedResponse’s cache state is not "local", set registration’s last update check time to the current time.

             8. ~IF［ %~fetchした応答 は`不良な~import~script応答$である ］ ⇒ ~CONTINUE ◎ If fetchedResponse is a bad import script response, continue.

                注記： `importScripts()$c に対する不良な応答は、 ~byte列として検査する目的（次の段）においては無視される。 ［ 現任な~worker ／ 更新~workerになり得るもの【！potential＊】 ］に対する不良でない応答に限り考慮される。 その根拠のいくつかは， `1374$issue を見よ。 ◎ Note: Bad responses for importScripts() are ignored for the purpose of the byte-to-byte check. Only good responses for the incumbent worker and good responses for the potential update worker are considered. See issue #1374 for some rationale.

             9. ~IF［［ %~fetchした応答 の`本体$rs ］と［ %格納-済み応答 の`安全でない応答$の`本体$rs ］は、 ~byte列として一致しない ］ ⇒ %資源を更新したか ~SET ~T ◎ If fetchedResponse’s body is not byte-for-byte identical with storedResponse’s unsafe response's body, set hasUpdatedResources to true.

             注記： ~importしたすべての~scriptで~cacheを拡充するため、 ~loopはこの段で ~BREAK することなく ~CONTINUE する。 【！The control】 ◎ Note: The control does not break the loop in this step to continue with all the imported scripts to populate the cache.

      13. %~custom~fetch応答の処理n( %応答 ) 【！Invoke processCustomFetchResponse with response.】 ◎ Asynchronously complete these steps with response.

   %完了-時の手続き は、 所与の( %~script ) に対し： 【！In both cases, let onComplete given script the following algorithm:】 ◎ When the algorithm asynchronously completes, continue the rest of these steps, with script being the asynchronous completion value.

   1. ~IF［ %~script ~EQ ~NULL ］~OR［ `非同期c~moduleか？$( %~script の`~record$sC, 【引数が足らない】, %~script の`基底~URL$sC, « » ) ~EQ ~T ］： ◎ If script is null or Is Async Module with script’s record, script’s base URL, and « » is true, then:

      1. `~job~promiseを却下する$( %~job, `TypeError^E ) ◎ Invoke Reject Job Promise with job and TypeError.

         注記： これは、 以前に `~job~promiseを却下する$( `SecurityError$E 例外 ) が呼出されていた場合は何もしない。 ◎ Note: This will do nothing if Reject Job Promise was previously invoked with "SecurityError" DOMException.

      2. ~IF［ %最新~worker ~EQ ~NULL ］ ⇒ `登録~map$[ ( %登録 の`~storage~key$swr, `~URLを直列化する$( %登録 の`~scope~URL$swr ) ) ] ~SET ε 【！原文の %scopeURL は定義されていない】 ◎ If newestWorker is null, then remove registration map[(registration’s storage key, serialized scopeURL)].
      3. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
      4. ~RET ◎ abort these steps.

   2. ~IF［ %資源を更新したか ~EQ ~F ］： ◎ If hasUpdatedResources is false, then:

      1. %登録 の`~cacheを介する更新~mode$swr ~SET %~job の`~cacheを介する更新~mode$job ◎ Set registration’s update via cache mode to job’s update via cache mode.
      2. `~job~promiseを解決する$( %~job, %登録 ) ◎ Invoke Resolve Job Promise with job and registration.
      3. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
      4. ~RET ◎ abort these steps.
   3. %~worker ~LET 新たな`~sw$ — その ⇒＃ `~script~URL$sw ~SET %~job の`~script~URL$job, `種別$sw ~SET %~job の`~worker種別$job, `~script資源$sw ~SET %~script, `~script資源~map$sw ~SET %更新-済み資源~map ◎ Let worker be a new service worker. ◎ Set worker’s script url to job’s script url, worker’s script resource to script, worker’s type to job’s worker type, and worker’s script resource map to updatedResourceMap.
   4. %~worker の`利用した~scriptの集合$swに %~URL を付加する ◎ Append url to worker’s set of used scripts.
   5. %~worker の`~script資源$swの`施策~容器$sw ~SET %施策~容器 ◎ Set worker’s script resource’s policy container to policyContainer.
   6. %走らせた結果 ~LET `~swを走らす$( %~worker, %~job の`~cacheを迂回するよう強制するか$job ) ◎ Let forceBypassCache be true if job’s force bypass cache flag is set, and false otherwise. ◎ Let runResult be the result of running the Run Service Worker algorithm with worker and forceBypassCache.

   7. ~IF［ %走らせた結果 ~EQ `失敗^i ］~OR［ %走らせた結果 は`中途完了$である ］： ◎ If runResult is failure or an abrupt completion, then:

      1. `~job~promiseを却下する$( %~job, `TypeError^E ) ◎ Invoke Reject Job Promise with job and TypeError.
      2. ~IF［ %最新~worker ~EQ ~NULL ］ ⇒ `登録~map$[ ( %登録 の`~storage~key$swr, `~URLを直列化する$( %登録 の`~scope~URL$swr ) ) ] ~SET ε ◎ If newestWorker is null, then remove registration map[(registration’s storage key, serialized scopeURL)].
      3. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job.
   8. ~ELSE ⇒ `~installする$( %~job, %~worker, %登録 ) ◎ Else, invoke Install algorithm with job, worker, and registration as its arguments.

`~soft更新する@

~UAは、 これを何度でも~callして，更新-を検査してヨイ。 ◎ The user agent may call this as often as it likes to check for updates.

• 入力 ⇒＃ %登録 — `~sw登録$, %~cacheを迂回するよう強制するか — 真偽値（省略時は ~F ） ◎ Input • registration, a service worker registration • forceBypassCache, an optional boolean, false by default

  注記： 実装者は、 ~debugし易くなるよう %~cacheを迂回するよう強制するか を利用してもヨイ（例：開発者~toolから呼出すなど）。 また、 ~swを拡張する他の仕様も，自前の必要に応じてこの~flagを利用してもヨイ。 ◎ Note: Implementers may use forceBypassCache to aid debugging (e.g. invocations from developer tools), and other specifications that extend service workers may also use the flag on their own needs.

• 出力 ⇒＃ ~none ◎ Output • None

1. %最新~worker ~LET `最新な~workerを取得する$( %登録 ) ◎ Let newestWorker be the result of running Get Newest Worker algorithm passing registration as its argument.
2. ~IF［ %最新~worker ~EQ ~NULL ］ ⇒ ~RET ◎ If newestWorker is null, abort these steps.
3. %~job ~LET `~jobを作成する$( ↓ ) ⇒＃ `更新する^i, %登録 の`~storage~key$swr, %登録 の`~scope~URL$swr, %最新~worker の`~script~URL$sw, ~NULL, ~NULL ◎ Let job be the result of running Create Job with update, registration’s storage key, registration’s scope url, newestWorker’s script url, null, and null.
4. %~job の`~worker種別$job ~SET %最新~worker の`種別$sw ◎ Set job’s worker type to newestWorker’s type.
5. %~job の`~cacheを迂回するよう強制するか$job ~SET %~cacheを迂回するよう強制するか ◎ Set job’s force bypass cache flag if forceBypassCache is true.
6. `~jobを~scheduleする$( %~job ) ◎ Invoke Schedule Job with job.

`~installする@

• 入力 ⇒＃ %~job — `~job$, %~worker — `~sw$, %登録 — `~sw登録$ ◎ Input • job, a job • worker, a service worker • registration, a service worker registration
• 出力 ⇒＃ ~none ◎ Output • none

1. %~installに失敗したか ~LET ~F ◎ Let installFailed be false.
2. %最新~worker ~LET `最新な~workerを取得する$( %登録 ) ◎ Let newestWorker be the result of running Get Newest Worker algorithm passing registration as its argument.
3. %登録 の`~cacheを介する更新~mode$swr ~SET %~job の`~cacheを介する更新~mode$job ◎ Set registration’s update via cache mode to job’s update via cache mode.
4. `登録の状態を更新する$( %登録, `installing^l, %~worker ) ◎ Run the Update Registration State algorithm passing registration, "installing" and worker as the arguments.
5. `~workerの状態を更新する$( %登録 にて`~install中の~worker$swr, `installing^l ) ◎ Run the Update Worker State algorithm passing registration’s installing worker and "installing" as the arguments.
6. ~Assert： %~job の`~job~promise$job ~NEQ ~NULL ◎ Assert: job’s job promise is not null.
7. `~job~promiseを解決する$( %~job, %登録 ) ◎ Invoke Resolve Job Promise with job and registration.
8. %設定群~obj群 ~LET 次を満たす`環境~設定群~obj$すべてからなる集合 ⇒ `生成元$enV ~EQ`生成元$sub %登録 の`~scope~URL$swrの`生成元$url ◎ Let settingsObjects be all environment settings objects whose origin is registration’s scope url's origin.

9. %設定群~obj群 を成す ~EACH( %設定群~obj ) に対し ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %設定群~obj の`担当の~event~loop$enV ) ◎ For each settingsObject of settingsObjects, queue a task on settingsObject’s responsible event loop in the DOM manipulation task source to run the following steps:

   手続きは：

   1. %登録~obj群 ~LET %設定群~obj の`~realm$enV内の `ServiceWorkerRegistration$I ~objのうち［ `表現する~sw登録$ ~EQ %登録 ］を満たすもの ◎ Let registrationObjects be every ServiceWorkerRegistration object in settingsObject’s realm, whose service worker registration is registration.
   2. %登録~obj群 を成す ~EACH( %登録~obj ) に対し ⇒ `~eventを発火する$( %登録~obj, `updatefound$et ) ◎ For each registrationObject of registrationObjects, fire an event on registrationObject named updatefound.
10. %~install中の~worker ~LET %登録 にて`~install中の~worker$swr ◎ Let installingWorker be registration’s installing worker.

11. ~IF［ `~eventを飛ばすべきか？$( `install^l, %~install中の~worker ) ~EQ ~F ］： ◎ If the result of running the Should Skip Event algorithm with installingWorker and "install" is false, then:

    1. %~cacheを迂回するよう強制するか ~LET %~job の`~cacheを迂回するよう強制するか$job ◎ Let forceBypassCache be true if job’s force bypass cache flag is set, and false otherwise.
    2. ~IF［ `~swを走らす$( %~install中の~worker, %~cacheを迂回するよう強制するか ) ~EQ `失敗^i ］ ⇒ %~installに失敗したか ~SET ~T ◎ If the result of running the Run Service Worker algorithm with installingWorker and forceBypassCache is failure, then: • Set installFailed to true.

    3. ~ELSE： ◎ Else:

       1. %~task ~LET `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~install中の~worker の`~event~loop$ ) ◎ Queue a task task on installingWorker’s event loop using the DOM manipulation task source to run the following steps:

          手続きは：

          1. %~event ~LET `~eventを作成する$( `InstallEvent$I ) ◎ Let e be the result of creating an event with InstallEvent.
          2. %~event の`type$n 属性 ~SET `install$et に初期化する ◎ Initialize e’s type attribute to install.
          3. `~eventを配送する$( %~install中の~worker の`大域~obj$sw, %~event ) ◎ Dispatch e at installingWorker’s global object.

          4. `非同期~拡張を待機する^i — この段は`並列的$に走らす： ◎ WaitForAsynchronousExtensions: Run the following substeps in parallel:

             1. 次が満たされるまで待機する ⇒ %~event は`作動中$eXでない ◎ Wait until e is not active.
             2. ~IF［ %~event の`時間切れか$ ~EQ ~T ］ ⇒ %~installに失敗したか ~SET ~T ◎ If e’s timed out flag is set, set installFailed to true.
             3. %~promise ~LET `すべてを待機する~promiseを取得する$( %~event の`存続期間を延長する~promise群$ ) ◎ Let p be the result of getting a promise to wait for all of e’s extend lifetime promises.
             %~promise の`却下-時$には ⇒ %~installに失敗したか ~SET ~T ◎ Upon rejection of p, set installFailed to true.

          %~task が破棄されたときは ⇒ %~installに失敗したか ~SET ~T ◎ If task is discarded, set installFailed to true.

       2. %~task が実行されるか破棄されるまで待機する ◎ Wait for task to have executed or been discarded.
       3. `非同期~拡張を待機する^i 段が完了するまで待機する ◎ Wait for the step labeled WaitForAsynchronousExtensions to complete.

12. ~IF［ %~installに失敗したか ~EQ ~T ］： ◎ If installFailed is true, then:

    1. `~workerの状態を更新する$( %登録 にて`~install中の~worker$swr, `redundant^l ) ◎ Run the Update Worker State algorithm passing registration’s installing worker and "redundant" as the arguments.
    2. `登録の状態を更新する$( %登録, `installing^l, ~NULL ) ◎ Run the Update Registration State algorithm passing registration, "installing" and null as the arguments.
    3. ~IF［ %最新~worker ~EQ ~NULL ］ ⇒ `登録~map$[ ( %登録 の`~storage~key$swr, `~URLを直列化する$( %登録 の`~scope~URL$swr ) ) ] ~SET ε ◎ If newestWorker is null, then remove registration map[(registration’s storage key, serialized registration’s scope url)].
    4. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
    5. ~RET ◎ abort these steps.
13. %~map ~LET %登録 にて`~install中の~worker$swrの`~script資源~map$sw ◎ Let map be registration’s installing worker's script resource map.
14. %利用した~script群 ~LET %登録 にて`~install中の~worker$swrの`利用した~scriptの集合$sw ◎ Let usedSet be registration’s installing worker's set of used scripts.
15. %~map を成す ~EACH( %~URL ) に対し ⇒ ~IF［ %~URL ~NIN %利用した~script群 ］ ⇒ %~map[ %~URL ] ~SET ε ◎ For each url of map: • If usedSet does not contain url, then remove map[url].

16. ~IF［ %登録 にて`待機-中な~worker$swr ~NEQ ~NULL ］： ◎ If registration’s waiting worker is not null, then:

    1. `~swを終了する$( %登録 にて`待機-中な~worker$swr ) ◎ Terminate registration’s waiting worker.
    2. `~workerの状態を更新する$( %登録 にて`待機-中な~worker$swr, `redundant^l ) ◎ Run the Update Worker State algorithm passing registration’s waiting worker and "redundant" as the arguments.
17. `登録の状態を更新する$( %登録, `waiting^l, %登録 にて`~install中の~worker$swr ) ◎ Run the Update Registration State algorithm passing registration, "waiting" and registration’s installing worker as the arguments.
18. `登録の状態を更新する$( %登録, `installing^l, ~NULL ) ◎ Run the Update Registration State algorithm passing registration, "installing" and null as the arguments.
19. `~workerの状態を更新する$( %登録 にて`待機-中な~worker$swr, `installed^l ) ◎ Run the Update Worker State algorithm passing registration’s waiting worker and "installed" as the arguments.
20. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job.
21. ［ この~algoにより呼出された`~workerの状態を更新する$ ］により`~queueされ$たすべての`~task$ が実行されるまで待機する ◎ Wait for all the tasks queued by Update Worker State invoked in this algorithm to have executed.

22. `作動化しようと試行する$( %登録 ) ◎ Invoke Try Activate with registration.

    注記： ここで`作動化しようと試行する$() が`作動化する$() を誘発しない場合、 `作動化する$() は，次のとき再度~試行される：

    • 既存の`作動中な~worker$swrにより制御されている最後の~clientが，`~unload$されたとき。
    • `ServiceWorkerGlobalScope^I1`skipWaiting()$m1 が非同期的に~callされたとき。
    • 既存の`作動中な~worker$swr用の`存続期間を延長する~promise群$が決着したとき。

    ◎ Note: If Try Activate does not trigger Activate here, Activate is tried again when the last client controlled by the existing active worker is unloaded, skipWaiting() is asynchronously called, or the extend lifetime promises for the existing active worker settle.

`作動化する@

• 入力 ⇒＃ %登録 — `~sw登録$ ◎ Input • registration, a service worker registration
• 出力 ⇒＃ ~none ◎ Output • None

1. ~IF［ %登録 にて`待機-中な~worker$swr ~EQ ~NULL ］ ⇒ ~RET ◎ If registration’s waiting worker is null, abort these steps.

2. ~IF［ %登録 にて`作動中な~worker$swr ~NEQ ~NULL ］： ◎ If registration’s active worker is not null, then:

   1. `~swを終了する$( %登録 にて`作動中な~worker$swr ) ◎ Terminate registration’s active worker.
   2. `~workerの状態を更新する$( %登録 にて`作動中な~worker$swr, `redundant^l ) ◎ Run the Update Worker State algorithm passing registration’s active worker and "redundant" as the arguments.
3. `登録の状態を更新する$( %登録, `active^l, %登録 にて`待機-中な~worker$swr ) ◎ Run the Update Registration State algorithm passing registration, "active" and registration’s waiting worker as the arguments.
4. `登録の状態を更新する$( %登録, `waiting^l, ~NULL ) ◎ Run the Update Registration State algorithm passing registration, "waiting" and null as the arguments.

5. `~workerの状態を更新する$( %登録 にて`作動中な~worker$swr, `activating^l ) ◎ Run the Update Worker State algorithm passing registration’s active worker and "activating" as the arguments.

   注記： 作動中な~workerが作動化-中（ `activating^l ）になって以降は、［ 稼働時の~script~error, 作動中な~workerの強制-終了n ］のいずれも，作動中な~workerが作動化されるのを防止しない。 ◎ Note: Once an active worker is activating, neither a runtime script error nor a force termination of the active worker prevents the active worker from getting activated.

   注記： 作動化~handlerは、 （片付け~などの様な）本質的でない作業を行うよう設計すること。 作動化~handlerは — とりわけ，作動化の間に~browserが終了する事例では — 完了まで走らないこともあるので。 ~swは、 作動化~handlerが成功裡に完了しないものがあっても，適正に機能するよう設計されるベキである。 ◎ Note: Make sure to design activation handlers to do non-essential work (like cleanup). This is because activation handlers may not all run to completion, especially in the case of browser termination during activation. A Service Worker should be designed to function properly, even if the activation handlers do not all complete successfully.

6. %合致した~client群 ~LET 次を満たす`~sw~client$ %~client すべてからなる~list 【順序は述べられていない】 ⇒ `合致する~sw登録$( %登録 の`~storage~key$swr, %~client の`作成時の~URL$enV ) ~EQ %登録 【！の`~scope~URL$swr】 ◎ Let matchedClients be a list of service worker clients whose creation URL matches registration’s storage key and registration’s scope url.

7. %合致した~client群 を成す ~EACH( %~client ) に対し ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~client に`関連な設定群~obj$の`担当の~event~loop$enV ) ◎ For each client of matchedClients, queue a task on client’s responsible event loop, using the DOM manipulation task source, to run the following substeps:

   手続きは：

   1. %準備済み~promise ~LET %~client の`大域~obj$enVの `ServiceWorkerContainer$I の`準備済み~promise$SWC ◎ Let readyPromise be client’s global object's ServiceWorkerContainer object’s ready promise.
   2. ~IF［ %準備済み~promise ~EQ ~NULL ］ ⇒ ~CONTINUE ◎ If readyPromise is null, then continue.
   3. ~IF［ %準備済み~promise は決着していない ］ ⇒ 次の結果で %準備済み~promise を解決する ⇒ `~sw登録~objを取得する$( %登録, %準備済み~promise に`関連な設定群~obj$ ) ◎ If readyPromise is pending, resolve readyPromise with the the result of getting the service worker registration object that represents registration in readyPromise’s relevant settings object.

8. %登録 を`利用して$いる ~EACH( `~sw~client$ %~client ) に対し： ◎ For each service worker client client who is using registration:

   1. %~client にて`作動中な~sw$enV【！`作動中な~worker$swrは誤記】 ~SET %登録 にて`作動中な~worker$swr ◎ Set client’s active worker to registration’s active worker.
   2. `制御器の変化を通知する$( %~client ) ◎ Invoke Notify Controller Change algorithm with client as the argument.
9. %作動中な~worker ~LET %登録 にて`作動中な~worker$swr ◎ Let activeWorker be registration’s active worker.

10. ~IF［ `~eventを飛ばすべきか？$( `activate^l, %作動中な~worker ) ~EQ ~F ］： ◎ If the result of running the Should Skip Event algorithm with activeWorker and "activate" is false, then:

    1. ~IF［ `~swを走らす$( %作動中な~worker ) ~NEQ `失敗^i ］： ◎ If the result of running the Run Service Worker algorithm with activeWorker is not failure, then:

       1. %~task ~LET `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %作動中な~worker の`~event~loop$ ) ◎ Queue a task task on activeWorker’s event loop using the DOM manipulation task source to run the following steps:

          手続きは：

          1. %~event ~LET `~eventを作成する$( `ExtendableEvent$I ) ◎ Let e be the result of creating an event with ExtendableEvent.
          2. %~event の `type$n 属性 ~SET "`activate$et" に初期化する ◎ Initialize e’s type attribute to activate.
          3. `~eventを配送する$( %作動中な~worker の`大域~obj$sw, %~event ) ◎ Dispatch e at activeWorker’s global object.
          4. `非同期~拡張を待機する^i ⇒ %~event が`作動中$eXでなくなるまで`並列的$に待機する ◎ WaitForAsynchronousExtensions: Wait, in parallel, until e is not active.
       2. %~task が実行されるか破棄されるまで待機する ◎ Wait for task to have executed or been discarded.
       3. `非同期~拡張を待機する^i 段が完了するまで待機する ◎ Wait for the step labeled WaitForAsynchronousExtensions to complete.
11. `~workerの状態を更新する$( %登録 にて`作動中な~worker$swr, `activated^l ) ◎ Run the Update Worker State algorithm passing registration’s active worker and "activated" as the arguments.

`作動化しようと試行する@

• 入力 ⇒＃ %登録 — `~sw登録$ ◎ Input • registration, a service worker registration
• 出力 ⇒＃ ~none ◎ Output • None

1. ~IF［ %登録 にて`待機-中な~worker$swr ~EQ ~NULL ］ ⇒ ~RET ◎ If registration’s waiting worker is null, return.

2. ~IF［ %登録 にて`作動中な~worker$swr ~NEQ ~NULL ］~AND［ %登録 にて`作動中な~worker$swrの`状態$sw ~EQ `activating^l ］ ⇒ ~RET ◎ If registration’s active worker is not null and registration’s active worker's state is "activating", return.

   注記： 既存の作動中な~workerの状態が依然として作動化-中（ `activating^l ）にある場合、 待機-中な~workerの作動化は遅延される。 ◎ Note: If the existing active worker is still in activating state, the activation of the waiting worker is delayed.

3. ~IF［ %登録 にて`作動中な~worker$swr ~EQ ~NULL ］~OR［ ~AND↓ ］… ◎ Invoke Activate with registration if either of the following is true: • registration’s active worker is null.

   • `~swには処理待ち~eventは無いか？$( %登録 にて`作動中な~worker$swr ) ~EQ ~T ◎ The result of running Service Worker Has No Pending Events with registration’s active worker is true, and＼
   • ［ %登録 を`利用して$いる`~sw~client$はない ］~OR［ %登録 にて`待機-中な~worker$swrの`待機を飛ばすか$sw ~EQ ~T ］ ◎ no service worker client is using registration or registration’s waiting worker's skip waiting flag is set.

   …ならば ⇒ `作動化する$( %登録 ) ◎ ↑

`~ServiceWorkerGlobalScopeを設定しておく@

• 入力 ⇒＃ %~sw — `~sw$ ◎ Input • serviceWorker, a service worker
• 出力 ⇒ `ServiceWorkerGlobalScope$I ~obj ／ ~NULL ◎ Output • a ServiceWorkerGlobalScope object or null

注記： この~algoは、［ ~NULL／ ~CSP検査-用に利用-可能な `ServiceWorkerGlobalScope$I ］を返す。 %~sw は作動中な `ServiceWorkerGlobalScope$I を有する場合、 それが返される — 他の場合 当の~objが新たに作成されることになる。 ◎ Note: This algorithm returns a ServiceWorkerGlobalScope usable for a CSP check, or null. If serviceWorker has an active ServiceWorkerGlobalScope, then it is returned. Otherwise, the object will be newly created.

1. %安全でない作成~時刻 ~LET `安全でない共有される現在の時刻$ ◎ Let unsafeCreationTime be the unsafe shared current time.
2. ~IF［ %~sw は`走っている$ ］ ⇒ ~RET %~sw の`大域~obj$sw ◎ If serviceWorker is running, then return serviceWorker’s global object.
3. ~IF［ %~sw の`状態$sw ~EQ `redundant^l ］ ⇒ ~RET ~NULL ◎ If serviceWorker’s state is "redundant", then return null.
4. ~IF［ %~sw の`大域~obj$sw ~NEQ ~NULL ］ ⇒ ~RET %~sw の`大域~obj$sw ◎ If serviceWorker’s global object is not null, then return serviceWorker’s global object.
5. ~Assert： %~sw の`開始~状態$sw ~EQ ~NULL ◎ Assert: serviceWorker’s start status is null.
6. %設定upに失敗したか ~LET ~F ◎ Let setupFailed be false.
7. %大域~obj ~LET ~NULL ◎ Let globalObject be null.
8. %~agent ~LET `~sw~agentを得する$() ◎ Let agent be the result of obtaining a service worker agent,＼

9. %~agent の文脈~内で次の手続きを走らす： ◎ and run the following steps in that context:

   1. %~worker大域~scope ~LET 新たな `ServiceWorkerGlobalScope$I ~obj ◎ ↓
   2. %~realm実行~文脈 ~LET 次のように~custom化する下で、 %~agent 内で`新たな~realmを作成する$ ⇒ 大域~obj用には %~worker大域~scope を利用する ◎ Let realmExecutionContext be the result of creating a new realm given agent and the following customizations: • For the global object, create a new ServiceWorkerGlobalScope object. Let workerGlobalScope be the created object.

   3. %設定群~obj ~LET 新たな`環境~設定群~obj$ — その各種~algoは、 次に従って定義される： ◎ Let settingsObject be a new environment settings object whose algorithms are defined as follows:

      • `~realm実行~文脈$enV ⇒ ~RET %~realm実行~文脈 ◎ The realm execution context • Return realmExecutionContext.
      • `~module~map$enV ⇒ ~RET %~worker大域~scope の`~module~map$wG ◎ The module map • Return workerGlobalScope’s module map.
      • `~API用~基底~URL$enV ⇒ ~RET %~sw の`~script~URL$sw ◎ The API base URL • Return serviceWorker’s script url.
      • `生成元$enV ⇒ ~RET %~sw を登録している`~sw~client$【！＊】の`生成元$cl【！`生成元$enV】 ◎ The origin • Return its registering service worker client's origin.
      • `施策~容器$enV ⇒ ~RET %~worker大域~scope の`施策~容器$wG ◎ The policy container • Return workerGlobalScope’s policy container.
      • `時刻~起点$enV ⇒ ~RET `時刻を粗化する$( %安全でない作成~時刻, %~worker大域~scope の`非同一-生成元~能力は隔離されるか$wG ) ◎ The time origin • Return the result of coarsening unsafeCreationTime given workerGlobalScope’s cross-origin isolated capability.
   4. %設定群~obj の ⇒＃ `~ID$enV ~SET 新たな一意かつ不透明な文字列, `作成時の~URL$enV ~SET %~sw の`~script~URL$sw, `~top-level作成時の~URL$enV ~SET ~NULL, `~top-level生成元$enV ~SET `実装定義$な値, `~target閲覧~文脈$enV ~SET ~NULL, `作動中な~sw$enV ~SET ~NULL ◎ Set settingsObject’s id to a new unique opaque string, creation URL to serviceWorker’s script url, top-level creation URL to null, top-level origin to an implementation-defined value, target browsing context to null, and active service worker to null.
   5. %~worker大域~scope の ⇒＃ `~URL$wG ~SET %~sw の`~script~URL$sw, `施策~容器$wG ~SET %~sw の`~script資源$swの`施策~容器$sw, `種別$wG ~SET %~sw の`種別$sw ◎ Set workerGlobalScope’s url to serviceWorker’s script url. ◎ Set workerGlobalScope’s policy container to serviceWorker’s script resource’s policy container. ◎ Set workerGlobalScope’s type to serviceWorker’s type.
   6. %~worker大域~scope に，新たな `WorkerLocation$I ~objを結付ける ◎ Create a new WorkerLocation object and associate it with workerGlobalScope.
   7. ~IF［ `大域~obj用に~CSP初期化を走らす$( %~worker大域~scope ) ~EQ `阻止される^i ］ ⇒＃ %設定upに失敗したか ~SET ~T； ~RET ◎ If the run CSP initialization for a global object algorithm returns "Blocked" when executed upon workerGlobalScope, set setupFailed to true and abort these steps.
   8. %大域~obj ~SET %~worker大域~scope ◎ Set globalObject to workerGlobalScope.
10. 次が満たされるまで待機する ⇒ ［ %大域~obj ~NEQ ~NULL ］~OR［ %設定upに失敗したか ~EQ ~T ］ ◎ Wait for globalObject is not null, or for setupFailed to be true.
11. ~IF［ %設定upに失敗したか ~EQ ~T ］ ⇒ ~RET ~NULL ◎ If setupFailed is true, then return null.
12. ~RET %大域~obj ◎ Return globalObject.

`~swを走らす@

• 入力 ⇒＃ %~sw — `~sw$, %~cacheを迂回するよう強制するか — 真偽値（省略時は ~F ） ◎ Input • serviceWorker, a service worker • forceBypassCache, an optional boolean, false by default
• 出力 ⇒＃ `Completion$ ／ `失敗^i ◎ Output • a Completion or failure

注記： この~algoは、［ 当の~swが`走っている$ようになるか，開始に失敗する ］まで他を阻む。 ◎ Note: This algorithm blocks until the service worker is running or fails to start.

1. ~IF［ %~sw は`走っている$ ］ ⇒ ~RET %~sw の`開始~状態$sw ◎ If serviceWorker is running, then return serviceWorker’s start status.
2. ~IF［ %~sw の`状態$sw ~EQ `redundant^l ］ ⇒ ~RET `失敗^i ◎ If serviceWorker’s state is "redundant", then return failure.
3. ~Assert： %~sw の`開始~状態$sw ~EQ ~NULL ◎ Assert: serviceWorker’s start status is null.
4. %~script ~LET %~sw の`~script資源$sw ◎ Let script be serviceWorker’s script resource.
5. ~Assert： %~script ~NEQ ~NULL ◎ Assert: script is not null.
6. %開始に失敗したか ~LET ~F ◎ Let startFailed be false.
7. %~worker大域~scope ~LET %~sw の`大域~obj$sw ◎ Let workerGlobalScope be serviceWorker’s global object.

8. ~IF［ %~worker大域~scope ~EQ ~NULL ］： ◎ If workerGlobalScope is null:

   1. %~worker大域~scope ~SET `~ServiceWorkerGlobalScopeを設定しておく$( %~sw ) ◎ Set workerGlobalScope to be the result of running the Setup ServiceWorkerGlobalScope algorithm with serviceWorker.
   2. ~IF［ %~worker大域~scope ~EQ ~NULL ］ ⇒ ~RET `失敗^i ◎ If workerGlobalScope is null, then return failure.
   3. %~sw の`大域~obj$sw ~SET %~worker大域~scope ◎ Set serviceWorker’s global object to workerGlobalScope.
9. %~agent ~LET %~worker大域~scope の`~realm実行~文脈$enV用の~agentを得する ◎ Obtain agent for workerGlobalScope’s realm execution context,＼

10. %~agent の文脈~内で次の手続きを走らす： ◎ and run the following steps in that context:

    1. ~IF［ %~cacheを迂回するよう強制するか ~EQ ~T ］ ⇒ %~worker大域~scope の`~importする~script用には~cacheを迂回するよう強制するか$SWG ~SET %~cacheを迂回するよう強制するか ◎ Set workerGlobalScope’s force bypass cache for import scripts flag if forceBypassCache is true.

    2. ~IF［ %~sw は`作動中な~worker$swrである ］：

       1. ［ %~sw を`包含している~sw登録$swの`~back-up~task~list$swr ］を成す ~EACH( `~task$ %~task ) に対し，順に ⇒ `~taskを~queueする$( %~task の`~source$tK, %~task の`手続き$tK, %~sw の`~event~loop$ )

       2. `~back-up~task~list$swrを空にする

          【 この段は、 この訳による補完 — さもなければ，この~listは肥大する一方になり、 ここ以外に，~listから除去し得る~~機会はないので。 】

       ◎ If serviceWorker is an active worker, and there are any tasks queued in serviceWorker’s containing service worker registration’s task queues, queue them to serviceWorker’s event loop’s task queues in the same order using their original task sources.
    3. %評価~状態s ~LET ~NULL ◎ Let evaluationStatus be null.

    4. ~IF［ %~script は`古典~script$である ］： ◎ If script is a classic script, then:

       1. %評価~状態s ~SET `古典~scriptを走らす$( %~script ) ◎ Set evaluationStatus to the result of running the classic script script.
       2. ~IF［ %評価~状態s .`Value^sl は空である （すなわち、 ~scriptは，まだ評価されていない） ］ ⇒＃ %開始に失敗したか ~SET ~T； ~RET ◎ If evaluationStatus.[[Value]] is empty, this means the script was not evaluated. Set startFailed to true and abort these steps.

    5. ~ELIF［ %~script は`~module~script$である ］： ◎ Otherwise, if script is a module script, then:

       1. %評価~promise ~LET `~module~scriptを走らす$( %~script 【！, with report errors set to false】) ◎ Let evaluationPromise be the result of running the module script script, with report errors set to false.
       2. ~Assert： %評価~promise . `PromiseState^sl ~NEQ `pending^l ◎ Assert: evaluationPromise.[[PromiseState]] is not "pending".
       3. ~IF［ %評価~promise . `PromiseState^sl ~EQ `rejected^l ］ ⇒ %評価~状態s ~SET `ThrowCompletion$jA( %評価~promise . `PromiseResult^sl ) ◎ If evaluationPromise.[[PromiseState]] is "rejected": • Set evaluationStatus to ThrowCompletion(evaluationPromise.[[PromiseResult]]).
       4. ~ELSE ⇒ %評価~状態s ~SET `NormalCompletion$jA( `undefined^jv ) ◎ Otherwise: • Set evaluationStatus to NormalCompletion(undefined).
    6. ~IF［ 当の~scriptは`~swを終了する$~algoにより中止された ］ ⇒＃ %開始に失敗したか ~SET ~T； ~RET ◎ If the script was aborted by the Terminate Service Worker algorithm, set startFailed to true and abort these steps.
    7. %~sw の`開始~状態$sw ~SET %評価~状態s ◎ Set serviceWorker’s start status to evaluationStatus.

    8. ~IF［ %~script の`これまでに評価されたか$sw ~EQ ~F ］： ◎ If script’s has ever been evaluated flag is unset, then:

       1. %設定群~obj の`大域~obj$enVに結付けられた【！＊？】 ~EACH( `~event~listener$ %~listener ) に対し ⇒ %~worker大域~scope の`~sw$SWGが`取扱う~event型の集合$swに %~listener の~event型 を`付加する$set ◎ For each eventType of settingsObject’s global object's associated list of event listeners' event types: • Append eventType to workerGlobalScope’s associated service worker's set of event types to handle.

          注記： この時点に［ 大域~objに結付けられた~event~listener ］が追加されてない場合、 当の`~sw$SWGが`取扱う~event型の集合$swは，空~集合であり続ける。 ◎ Note: If the global object’s associated list of event listeners does not have any event listener added at this moment, the service worker’s set of event types to handle remains an empty set.

       2. %~script の`これまでに評価されたか$sw ~SET ~T ◎ Set script’s has ever been evaluated flag.
       3. %~sw の`すべての~fetch~listenerは空か$sw ~SET ~F ◎ Unset the serviceWorker’s all fetch listeners are empty flag.
       4. 任意選択で ⇒ ~IF［ `すべての~fetch~listenerは空か？$( %~worker大域~scope ) ~EQ ~T ］ ⇒ %~sw の`すべての~fetch~listenerは空か$sw ~SET ~T ◎ The user agent may, if the All Fetch Listeners Are Empty algorithm with workerGlobalScope returns true, set serviceWorker’s all fetch listeners are empty flag.
    9. %設定群~obj により指定される`担当の~event~loop$enVを，破壊されるまで走らす ◎ Run the responsible event loop specified by settingsObject until it is destroyed.
    10. %~worker大域~scope の`作動中な~timer群が成す~map$を`~clearする$map ◎ Clear workerGlobalScope’s map of active timers.
11. 次が満たされるまで待機する ⇒ ［ %~sw は`走っている$ ］~OR［ %開始に失敗したか ~EQ ~T ］ ◎ Wait for serviceWorker to be running, or for startFailed to be true.
12. ~IF［ %開始に失敗したか ~EQ ~T ］ ⇒ ~RET `失敗^i ◎ If startFailed is true, then return failure.
13. ~RET %~sw の`開始~状態$sw ◎ Return serviceWorker’s start status.

`すべての~fetch~listenerは空か？@

• 入力 ⇒＃ %~worker大域~scope — `大域~obj$sw ◎ Input • workerGlobalScope, a global object.
• 出力 ⇒ 真偽値 ◎ Output • a boolean

1. ~IF［ `fetch^l ~NIN %~worker大域~scope が`取扱う~event型の集合$sw ］ ⇒ ~RET ~T ◎ If workerGlobalScope’s set of event types to handle does not contain fetch, then return true.
2. %~event~handler ~LET %~worker大域~scope の`~event~handler~map$[ `onfetch^l ] ◎ Let eventHandler be workerGlobalScope’s event handler map["onfetch"]'s value.
3. %~event~listener~callback群 ~LET `~sw~fetch~event~listener~callback群を得する旧来の手続き$( %~worker大域~scope ) ◎ Let eventListenerCallbacks be the result of calling legacy-obtain service worker fetch event listener callbacks given workerGlobalScope.

4. %~event~listener~callback群 を成す ~EACH( %~event~listener~callback ) に対し： ◎ For each eventListenerCallback of eventListenerCallbacks:

   1. %~callback ~LET ~NULL ◎ Let callback be null.
   2. ~IF［ %~event~handler ~NEQ ~NULL ］~AND［ %~event~listener~callback ~EQ %~event~handler の`~listener$eHの`~callback$evL ］ ⇒ %~callback ~SET `~JS値に変換する$( %~event~handler の`値$eH ) ◎ If eventHandler is not null and eventListenerCallback equals eventHandler’s listener's callback, then set callback to the result of converting to an ECMAScript value eventHandler’s value.
   3. ~ELSE ⇒ %~callback ~SET `~JS値に変換する$( %~event~listener~callback ) ◎ Otherwise, set callback to the result of converting to an ECMAScript value eventListenerCallback.

   4. ~IF［ `IsCallable$jA( %~callback ) ~EQ ~F ］ ⇒ ~RET ~F ◎ If IsCallable(callback) is false, then return false.

      注記： `Callback^c ~obj 【`~callback~interface$を実装する~obj】 のうち， `handleEvent^c を利用するものは、 【次の段と同じく】空でないものと見做される。 この段は、 `handleEvent^c 取得子 （それは、 この検査の間に当の~event~listenerを改変し得る） が~callされるのを避ける。 ◎ Note: Callback objects that use handleEvent are assumed to be non-empty. This avoids calling the handleEvent getters, which could modify the event listeners during this check.

   5. ~IF［ %~callback の`関数~本体$は空でない （すなわち［ `statement, declaration＠~TC39#sec-ecmascript-language-statements-and-declarations$en ］いずれかは存在する） ］ ⇒ ~RET ~F ◎ If callback’s function body is not empty (i.e. either a statement or declaration exist), then return false.

      注記： これは、 `() => {}^c の様な `fetch^l ~listenerを検出する。 一部の~siteは、 自身が［ Chromium から PWA（ `progressive web application^en ）として認識される ］よう，本体が空な~fetch~event~listenerを有する。 ◎ Note: This detects "fetch" listeners like () => {}. Some sites have a fetch event listener with empty body to make them recognized by Chromium as a progressive web application (PWA).

5. ~RET ~T ◎ Return true.

注記： ~UAには、 次を指示する警告を示すことが奨励される ⇒ 空な `fetch^l ~listenerは不必要であり、 処理能に負な影響iを及ぼし得る。 ◎ Note: User agents are encouraged to show a warning indicating that empty "fetch" listeners are unnecessary, and may have a negative performance impact.

`~swを終了する@

• 入力 ⇒＃ %~sw — `~sw$ ◎ Input • serviceWorker, a service worker
• 出力 ⇒＃ ~none ◎ Output • None

以下は、 %~sw の~main~loopとは`並列的$に走らす： ◎ Run the following steps in parallel with serviceWorker’s main loop:

1. %~sw大域~scope ~LET %~sw の`大域~obj$sw ◎ Let serviceWorkerGlobalScope be serviceWorker’s global object.
2. %~sw大域~scope の`~close中か$wG ~SET ~T ◎ Set serviceWorkerGlobalScope’s closing flag to true.
3. %~sw の`延長-済み~event集合$swを`空にする$ ◎ Remove all the items from serviceWorker’s set of extended events.
4. %~back-up ~LET %~sw を`包含している~sw登録$swの`~back-up~task~list$swr ◎ ↓
5. ~EACH( %~task~source ~IN { `~fetchを取扱う~task~source$, `機能的~eventを取扱う~task~source$ } ) に対し ⇒ %~sw大域~scope の`~event~loop$に属する［ %~task~source に結付けられた`~task~queue$ ］を成す ~EACH( %~task ) に対し ⇒ %~back-up に %~task を`付加する$set ◎ If there are any tasks, whose task source is either the handle fetch task source or the handle functional event task source, queued in serviceWorkerGlobalScope’s event loop’s task queues, queue them to serviceWorker’s containing service worker registration’s corresponding task queues in the same order using their original task sources, and＼

6. %~sw大域~scope の`~event~loop$に属する ~EACH( `~task~queue$ %~queue ) に対し ⇒ %~queue を`空にする$ ◎ discard all the tasks (including tasks whose task source is neither the handle fetch task source nor the handle functional event task source) from serviceWorkerGlobalScope’s event loop’s task queues without processing them.

   注記： これは実質的に， `fetch$et やその他の`機能的~event$（ `push$et ~eventなど）に限り~back-upされ、 他の~task（ `message$et ~eventなど）は処理することなく破棄されることを意味する。 ◎ Note: This effectively means that the fetch events and the other functional events such as push events are backed up by the registration’s task queues while the other tasks including message events are discarded.

7. %~sw 内で現在`走っている~scriptを中止する$ ◎ Abort the script currently running in serviceWorker.
8. %~sw の`開始~状態$sw ~SET ~NULL ◎ Set serviceWorker’s start status to null.

`~fetchを取扱う@

この~algoは、［ `~sw$文脈に手渡される，`~fetch$の取扱い ］用の入口である。 【`~HTTP~fetch$から利用される。】 ◎ The Handle Fetch algorithm is the entry point for the fetch handling handed to the service worker context.

• 入力 ⇒＃ %要請 — `要請$, %制御器 — `~fetch制御器$, %高分解能な処理能~timerを利用するか — 真偽値 ◎ Input • request, a request • controller, a fetch controller • useHighResPerformanceTimers, a boolean
• 出力 ⇒＃ %応答 — `応答$ 【または ~NULL 】 ◎ Output • a response

1. %登録 ~LET ~NULL ◎ Let registration be null.
2. %~client ~LET %要請 の`~client$rq ◎ Let client be request’s client.
3. %予約-済み~client ~LET %要請 の`予約-済み~client$rq ◎ Let reservedClient be request’s reserved client.
4. %~preload応答~promise ~LET `新たな~promise$ ◎ Let preloadResponse be a new promise.
5. %~worker~realm ~LET ~NULL ◎ Let workerRealm be null.
6. %計時~報 ~LET 新たな`~sw計時~報$ ◎ Let timingInfo be a new service worker timing info.
7. ~Assert： %要請 の`行先$rq ~NEQ `serviceworker^l ◎ Assert: request’s destination is not "serviceworker".
8. ~IF［ %要請 の`行先$rq ~IN { `embed^l, `object^l } ］ ⇒ ~RET ~NULL ◎ If request’s destination is either "embed" or "object", then: • Return null.

9. ~IF［ %要請 は`非~下位資源~要請$である ］： ◎ Else if request is a non-subresource request, then:

   1. ~IF［ ~OR↓ ］…

      • ［ %予約-済み~client は`環境~設定群~obj$である ］~AND［ %予約-済み~client は`~secureな文脈$enVでない ］
      • ［ %予約-済み~client は`環境~設定群~obj$でない ］~AND［ %要請 の`~URL$rq は`信用に価し得る~URL$でない ］
      • ［ %要請 は`~navi要請$である ］~AND［ それを誘発している`~navi$は、 shift+reload 等により起動された 【実際には何を意味する？ `952$issue】 ］

      …ならば ⇒ ~RET ~NULL

      ◎ If reservedClient is not null and is an environment settings object, then: • If reservedClient is not a secure context, return null. ◎ Else: • If request’s url is not a potentially trustworthy URL, return null. ◎ If request is a navigation request and the navigation triggering it was initiated with a shift+reload or equivalent, return null.
   2. ~Assert： %予約-済み~client ~NEQ ~NULL ◎ Assert reservedClient is not null.
   3. %~storage~key ~LET `~storage~keyを得する$( %予約-済み~client ) ◎ Let storage key be the result of running obtain a storage key given reservedClient.
   4. %登録 ~SET `合致する~sw登録$( %~storage~key, %要請 の`~URL$rq ) ◎ Set registration to the result of running Match Service Worker Registration given storage key and request’s url.
   5. ~IF［ %登録 ~EQ ~NULL ］~OR［ %登録 にて`作動中な~worker$swr ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If registration is null or registration’s active worker is null, return null.
   6. ~IF［ %要請 の`行先$rq ~NEQ `report$l ］ ⇒ %予約-済み~client にて`作動中な~sw$enV ~SET %登録 にて`作動中な~worker$swr ◎ If request’s destination is not "report", set reservedClient’s active service worker to registration’s active worker.

   注記： この時点から、 `~sw~client$は，［ その`作動中な~sw$enVを`包含している~sw登録$sw ］の`利用＠#dfn-use$を開始する。 ◎ Note: From this point, the service worker client starts to use its active service worker’s containing service worker registration.

10. ~ELIF［ %要請 は`下位資源~要請$である ］：

    1. ~IF［ %~client にて`作動中な~sw$enV ~EQ ~NULL ］ ⇒ ~RET ~NULL
    2. %登録 ~SET %~client にて`作動中な~sw$enV を`包含している~sw登録$sw
    ◎ Else if request is a subresource request, then: • If client’s active service worker is non-null, set registration to client’s active service worker’s containing service worker registration. • Else, return null.
11. %作動中な~worker ~LET %登録 にて`作動中な~worker$swr ◎ Let activeWorker be registration’s active worker.
12. %~soft更新すべきか ~LET ~IS［ %要請 は`非~下位資源~要請$である ］~OR［［ %要請 は`下位資源~要請$である ］~AND［ %登録 は`非新鮮$である ］］ ◎ Let shouldSoftUpdate be true if any of the following are true, and false otherwise: • request is a non-subresource request. • request is a subresource request and registration is stale.

13. ~IF［ %作動中な~worker の`~router規則~list$は`空$である ］： ◎ If activeWorker’s list of router rules is not empty:

    1. %~source ~LET `~router~sourceを取得する$( %登録 にて`作動中な~worker$swr, %要請 ) ◎ Let source be the result of running the Get Router Source algorithm with registration’s active worker and request.

    2. ~IF［ %~source ~EQ `network$l ］： ◎ If source is "network":

       1. ~IF［ %~soft更新すべきか ~EQ ~T ］ ⇒ 次の手続きを`並列的$に走らす ◎ If shouldSoftUpdate is true, then in parallel run＼

          手続きは ⇒ `~soft更新する$( %登録 ) ◎ the Soft Update algorithm with registration.
       2. ~RET ~NULL ◎ Return null.

    3. ~ELIF［ %~source ~EQ `cache$l ］~OR［ %~source[ `RouterSourceDict^I1"`cacheName$m1" ] ~NEQ ε ］： ◎ Else if source is "cache", or source["cacheName"] exists, then:

       1. ~IF［ %~soft更新すべきか ~EQ ~T ］ ⇒ 次の手続きを`並列的$に走らす ◎ If shouldSoftUpdate is true, then in parallel run＼

          手続きは ⇒ `~soft更新する$( %登録 ) ◎ the Soft Update algorithm with registration.

       2. %登録 の`~storage~key$swrの`名前から~cacheへの~map$を成す ~EACH( %~cache名 → %~cache ) に対し： ◎ For each cacheName → cache of the registration’s storage key's name to cache map.

          1. ~IF［ %~source[ `RouterSourceDict^I1"`cacheName$m1" ] ~NIN { ε, %~cache名 } ］ ⇒ ~CONTINUE ◎ If source["cacheName"] exists and source["cacheName"] is not cacheName, continue.
          2. %要請~応答~list ~LET `~cacheを~queryする$( %要請, 新たな `CacheQueryOptions$I, %~cache ) ◎ Let requestResponses be the result of running Query Cache with request, a new CacheQueryOptions, and cache.
          3. ~IF［ %要請~応答~list は`空$である ］ ⇒ ~RET ~NULL ◎ If requestResponses is an empty list, return null.

          4. ~ELSE： ◎ Else:

             1. %要請~応答 ~LET %要請~応答~list[ 0 ] ◎ Let requestResponse be the first element of requestResponses.
             2. %応答 ~LET %要請~応答 を成す応答 ◎ Let response be requestResponse’s response.
             3. %大域~obj ~LET %作動中な~worker の`大域~obj$sw ◎ Let globalObject be activeWorker’s global object.
             4. ~IF［ %大域~obj ~EQ ~NULL ］ ⇒ %大域~obj ~SET `~ServiceWorkerGlobalScopeを設定しておく$( %作動中な~worker ) ◎ If globalObject is null: • Set globalObject to the result of running Setup ServiceWorkerGlobalScope with activeWorker.
             5. ~IF［ %大域~obj ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If globalObject is null, return null.

             注記： ここで `ServiceWorkerGlobalScope$I を作成される `ServiceWorkerGlobalScope$I は、 ~CORS検査にしか要求されない — 実装は、 実際に それを作成することは期待されない。 ◎ Note: This only creates a ServiceWorkerGlobalScope because CORS checks require that. It is not expected that implementations will actually create a ServiceWorkerGlobalScope here.

             1. ~IF［ %応答 の`種別$rs ~EQ `opaque^l ］： ◎ If response’s type is "opaque",＼

                1. %検査~結果 ~LET `非同一-生成元~資源~施策~検査$( ↓ ) ⇒＃ %大域~obj の`生成元$enV, %大域~obj, 空~文字列, %応答 の`内部~応答$ ◎ and cross-origin resource policy check with globalObject’s origin, globalObject, "", and response’s internal response returns＼
                2. ~IF［ %検査~結果 ~EQ `阻止される^i ］ ⇒ ~RET ~NULL ◎ blocked, then return null.
             2. ~RET %応答 ◎ Return response.
       3. ~RET ~NULL ◎ Return null.

    4. ~ELIF［ %~source ~EQ `race-network-and-fetch-handler$l ］~AND［ %要請 の`~method$rq ~EQ `GET^bl ］： ◎ Else if source is "race-network-and-fetch-handler", and request’s method is `GET` then:

       1. ~IF［ %~soft更新すべきか ~EQ ~T ］ ⇒ 次の手続きを`並列的$に走らす ◎ If shouldSoftUpdate is true, then in parallel run＼

          手続きは ⇒ `~soft更新する$( %登録 ) ◎ the Soft Update algorithm with registration.
       2. %~queue ~LET 新たな`~queue$ ◎ Let queue be an empty queue of response.
       3. %競走~fetch制御器 ~LET ~NULL ◎ Let raceFetchController be null.
       4. %競走~応答 ~LET 新たな`競走~応答$ — その ⇒＃ `値$rV ~SET `pending^l ◎ Let raceResponse be a race response whose value is "pending".

       5. この段は`並列的$に走らすが、［ %制御器 の`状態$fC ~IN { `terminated^l, `aborted^l } ］になった`ときは中止する$ ⇒ %競走~fetch制御器 ~SET %要請 を`~fetchする$ — 次を与える下で： ◎ Run the following substeps in parallel, but abort when controller’s state is "terminated" or "aborted": • Set raceFetchController to the result of calling fetch given request, with＼

          • `応答の処理n^i ~SET 所与の ( `応答$ %競走~network要請に対する応答 ) に対し，次を走らす手続き： ◎ processResponse set to the following steps given a response raceNetworkRequestResponse:

            1. ~IF［ %競走~network要請に対する応答 の`状態s$rsは`~ok状態s$である ］： ◎ If raceNetworkRequestResponse’s status is ok status, then:

               1. %競走~応答 の`値$rV ~SET %競走~network要請に対する応答 ◎ Set raceResponse’s value to raceNetworkRequestResponse.
               2. %~queue に %競走~network要請に対する応答 を`~enqueueする$ ◎ Enqueue raceNetworkRequestResponse to queue.
            2. ~ELSE ⇒ %競走~応答 の`値$rV ~SET `~network~error$ ◎ Otherwise, set raceResponse’s value to a network error.

          `中止されたときは$： ◎ If aborted＼

          1. ~IF［ %競走~fetch制御器 ~NEQ ~NULL ］： ◎ and raceFetchController is not null, then:

             1. `~fetchを中止する$( %競走~fetch制御器 ) ◎ Abort raceFetchController.
             2. %競走~応答 ~SET 新たな`競走~応答$ — その ⇒＃ `値$rV ~SET ~NULL ◎ Set raceResponse to a race response whose value is null.
       6. `~promiseを解決する$( %~preload応答~promise ) ◎ Resolve preloadResponse with undefined.

       7. この段は`並列的$に走らす： ◎ Run the following substeps in parallel:

          1. %~fetch~handler応答 ~LET `~fetch~eventを作成して配送する$( ↓ ) ⇒＃ %要請, %登録, %高分解能な処理能~timerを利用するか, %計時~報, %~worker~realm, %予約-済み~client, %~preload応答~promise, %競走~応答 ◎ Let fetchHandlerResponse be the result of Create Fetch Event and Dispatch with request, registration, useHighResPerformanceTimers, timingInfo, workerRealm, reservedClient, preloadResponse, and raceResponse.

          2. ~IF［ ~AND↓ ］…

             • %~fetch~handler応答 ~NEQ ~NULL
             • %~fetch~handler応答 は`~network~error$でない
             • %競走~fetch制御器 ~NEQ ~NULL

             …ならば ⇒ `~fetchを中止する$( %競走~fetch制御器 )

             ◎ If fetchHandlerResponse is not null and not a network error, and raceFetchController is not null, abort raceFetchController.
          3. %~queue に %~fetch~handler応答 を`~enqueueする$ ◎ Enqueue fetchHandlerResponse to queue.
       8. 次が満たされるまで待機する ⇒ %~queue は`空$でない ◎ Wait until queue is not empty.
       9. ~RET %~queue から`~dequeueする$ ◎ Return the result of dequeue queue.
    5. ~Assert： %~source ~EQ `fetch-event$l ◎ Assert: source is "fetch-event"

14. ~IF［ ~AND↓ ］… ◎ If＼

    • %要請 は`~navi要請$である ◎ request is a navigation request,＼
    • %登録 の`~navi~preloadは可能化されるか$swr ~EQ ~T ◎ registration’s navigation preload enabled flag is set,＼
    • %要請 の`~method$rq ~EQ `GET^bl ◎ request’s method is `GET`,＼
    • `fetch$et ~IN %登録 にて`作動中な~worker$swrが`取扱う~event型の集合$sw ※ ◎ registration’s active worker's set of event types to handle contains fetch,＼
    • %登録 にて`作動中な~worker$swrの`すべての~fetch~listenerは空か$sw ~EQ ~F ◎ and registration’s active worker's all fetch listeners are empty flag is not set then:

    注記： これらの条件が， ※ を除いて満たされる場合、 開発者の意図は明瞭でないので，~UAは~consoleに警告を示したいと望むかもしれない。 ◎ Note: If the above is true except registration’s active worker's set of event types to handle does not contain fetch, then the user agent may wish to show a console warning, as the developer’s intent isn’t clear.

    …ならば：

    1. %~preload要請 ~LET `要請を~cloneする$( %要請 ) ◎ Let preloadRequest be the result of cloning the request request.
    2. %~preload要請~header群 ~LET %~preload要請 の`~header~list$rq ◎ Let preloadRequestHeaders be preloadRequest’s header list.

    3. %~preload応答~obj ~LET `~Response~objを作成する$( 新たな`応答$†, `immutable^l, %~worker~realm )

       【† 入力に渡す応答は、 形式上必要なものでしかなく，以下で置換されることになる。 】

       ◎ Let preloadResponseObject be a new Response object associated with a new Headers object whose guard is "immutable".
    4. %~preload要請~header群 に`~headerを付加する$( ( `Service-Worker-Navigation-Preload^h, %登録 の`~navi~preload~header値$swr ) ) ◎ Append to preloadRequestHeaders a new header whose name is `Service-Worker-Navigation-Preload` and value is registration’s navigation preload header value.
    5. %~preload要請 の`~sw~mode$rq ~SET `none^l ◎ Set preloadRequest’s service-workers mode to "none".
    6. %~preload~fetch制御器 ~LET ~NULL ◎ Let preloadFetchController be null.

    7. この段は`並列的$に走らすが、［ %制御器 の`状態$fC ~IN { `terminated^l, `aborted^l } ］になった`ときは中止する$ ⇒ %~preload~fetch制御器 ~SET %~preload要請 を`~fetchする$ — 次を与える下で： ◎ Run the following substeps in parallel, but abort when controller’s state is "terminated" or "aborted": • Set preloadFetchController to the result of fetching preloadRequest.

       • `応答の処理n^i ~SET 所与の ( `応答$ %~navi~preload応答 ) に対し，次を走らす手続き： ◎ To processResponse for navigationPreloadResponse, run these substeps:

         1. ~IF［ %~navi~preload応答 の`種別$rs ~EQ `error^l ］ ⇒ `~promiseを却下する$( %~preload応答~promise, `TypeError^E ) ◎ If navigationPreloadResponse’s type is "error", reject preloadResponse with a TypeError＼

         2. ~ELSE： ◎ and terminate these substeps.

            1. %~preload応答~obj の`応答$Rs ~SET %~navi~preload応答 ◎ Associate preloadResponseObject with navigationPreloadResponse.
            2. `~promiseを解決する$( %~preload応答~promise, %~preload応答~obj ) ◎ Resolve preloadResponse with preloadResponseObject.

       `中止されたときは$： ◎ If aborted, then:

       1. %逆直列化された~error ~LET `直列化された中止-事由を逆直列化する$( ~NULL, %~worker~realm ) ◎ Let deserializedError be the result of deserialize a serialized abort reason given null and workerRealm.
       2. `~fetchを中止する$( %~preload~fetch制御器, %逆直列化された~error ) ◎ Abort preloadFetchController with deserializedError.
15. ~ELSE ⇒ `~promiseを解決する$( %~preload応答~promise ) ◎ Else, resolve preloadResponse with undefined.
16. `~fetch~eventを作成して配送する$( ↓ ) ⇒＃ %要請, %登録, %高分解能な処理能~timerを利用するか, %計時~報, %~worker~realm, %予約-済み~client, %~preload応答~promise, ~NULL ◎ Return the result of Create Fetch Event and Dispatch with request, registration, useHighResPerformanceTimers, timingInfo, workerRealm, reservedClient, preloadResponse, and null.

`~fetch~eventを作成して配送する@

• 入力 ⇒＃ %要請 — `要請$, %登録 — `~sw登録$, %高分解能な処理能~timerを利用するか — 真偽値, %計時~報 — `~sw計時~報$, %~worker~realm — ある`大域~obj$swに`関連な~realm$, %予約-済み~client — `予約-済み~client$rq, %~preload応答~promise — `~promise$, %競走~応答 — `競走~応答$／~NULL ◎ Input • request, a request • registration, a service worker registration • useHighResPerformanceTimers, a boolean • timingInfo, a service worker timing info • workerRealm, a relevant realm of the global object • reservedClient, a reserved client • preloadResponse, a promise • raceResponse, a race response or null
• 出力 ⇒ `応答$ ◎ Output • a response

1. %応答 ~LET ~NULL ◎ Let response be null.
2. %~eventは取消されたか ~LET ~F ◎ Let eventCanceled be false.
3. %~client ~LET %要請 の`~client$rq ◎ Let client be request’s client.
4. %作動中な~worker ~LET %登録 にて`作動中な~worker$swr ◎ Let activeWorker be registration’s active worker.
5. %取扱った~event ~LET ~NULL ◎ Let eventHandled be null.
6. %~fetchを取扱うのに失敗したか ~LET ~F ◎ Let handleFetchFailed be false.
7. %~enteredで応答するか ~LET ~F ◎ Let respondWithEntered be false.
8. %~soft更新すべきか ~LET ~IS［ %要請 は`非~下位資源~要請$である ］~OR［［ %要請 は`下位資源~要請$である ］~AND［ %登録 は`非新鮮$である ］］ ◎ Let shouldSoftUpdate be true if any of the following are true, and false otherwise: • request is a non-subresource request. • request is a subresource request and registration is stale.

9. ~IF［ `~eventを飛ばすべきか？$( `fetch^l, %作動中な~worker ) ~EQ ~T ］： ◎ If the result of running the Should Skip Event algorithm with "fetch" and activeWorker is true, then:

   1. ~IF［ %~soft更新すべきか ~EQ ~T ］ ⇒ 次の手続きを`並列的$に走らす ◎ If shouldSoftUpdate is true, then in parallel run＼

      手続きは ⇒ `~soft更新する$( %登録 ) ◎ the Soft Update algorithm with registration.
   2. ~RET ~NULL ◎ Return null.

10. ~IF［ %作動中な~worker の`すべての~fetch~listenerは空か$sw ~EQ ~T ］： ◎ If activeWorker’s all fetch listeners are empty flag is set:

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

       1. ~IF［ %作動中な~worker の`状態$sw ~EQ `activating^l ］ ⇒ 次が満たされるまで待機する ⇒ %作動中な~worker の`状態$sw ~EQ `activated^l ◎ If activeWorker’s state is "activating", then wait for activeWorker’s state to become "activated".
       2. `~swを走らす$( %作動中な~worker ) ◎ Run the Run Service Worker algorithm with activeWorker.
       3. ~IF［ %~soft更新すべきか ~EQ ~T ］ ⇒ `~soft更新する$( %登録 ) ◎ If shouldSoftUpdate is true, then run the Soft Update algorithm with registration.
    2. ~RET ~NULL ◎ Return null.
11. ~IF［ %高分解能な処理能~timerを利用するか ~EQ ~T ］ ⇒ %高分解能な処理能~timerを利用するか ~SET %作動中な~worker の`大域~obj$swの`非同一-生成元~能力は隔離されるか$wG ◎ If useHighResPerformanceTimers is true, then set useHighResPerformanceTimers to activeWorker’s global object's cross-origin isolated capability.
12. %計時~報 の`開始~時刻$swT ~LET `粗化した共有される現在の時刻$( %高分解能な処理能~timerを利用するか ) ◎ Let timingInfo’s start time be the coarsened shared current time given useHighResPerformanceTimers.
13. ~IF［ %作動中な~worker の`状態$sw ~EQ `activating^l ］ ⇒ %作動中な~worker の`状態$sw ~EQ `activated^l になるまで待機する ◎ If activeWorker’s state is "activating", wait for activeWorker’s state to become "activated".
14. ~IF［ `~swを走らす$( %作動中な~worker ) ~EQ `失敗^i ］ ⇒ %~fetchを取扱うのに失敗したか ~SET ~T ◎ If the result of running the Run Service Worker algorithm with activeWorker is failure, then set handleFetchFailed to true.

15. ~ELSE： ◎ Else:

    1. %~worker~realm ~SET %作動中な~worker の`大域~obj$swに`関連な~realm$ ◎ Set workerRealm to the relevant realm of the activeWorker’s global object.
    2. %取扱った~event ~SET %~worker~realm 内の`新たな~promise$ ◎ Set eventHandled to a new promise in workerRealm.
    3. ~IF［ %競走~応答 ~NEQ ~NULL ］ ⇒ %作動中な~worker の`大域~obj$swの`競走~応答~map$SWG[ %要請 ] ~SET %競走~応答 ◎ If raceResponse is not null, set activeWorker’s global object's race response map[request] to raceResponse.

    4. %~task ~LET `~taskを~queueする$( `~fetchを取扱う~task~source$, 次の手続き, %作動中な~worker の`~event~loop$ ) ◎ Queue a task task to run the following substeps:

       手続きは：

       1. %~event ~LET `~eventを作成する$( `FetchEvent$I ) ◎ Let e be the result of creating an event with FetchEvent.
       2. %制御器 ~LET %~worker~realm 内の`新たな$ `AbortController$I ~obj ◎ Let controller be a new AbortController object with workerRealm.
       3. %要請~obj ~LET `~Request~objを作成する$( %要請, `immutable^l, %制御器 の`通達$aC, %~worker~realm ) ◎ Let requestObject be the result of creating a Request object, given request, a new Headers object’s guard which is "immutable", controller’s signal, and workerRealm.
       4. %~event の各種~属性を次のように初期化する ⇒＃ `type$n 属性 ~SET `fetch$et, `cancelable$n 属性 ~SET ~T, `FetchEvent^I1`request$m1 属性 ~SET %要請~obj, `preloadResponse$m1 ~SET %~preload応答~promise, `clientId$m1 属性 ~SET %~client の`~ID$enV, `resultingClientId$m1 属性 ~SET 空~文字列, `replacesClientId$m1 属性 ~SET 空~文字列, `handled$m1 属性 ~SET %取扱った~event ◎ Initialize e’s type attribute to fetch. ◎ Initialize e’s cancelable attribute to true. ◎ Initialize e’s request attribute to requestObject. ◎ Initialize e’s preloadResponse to preloadResponse. ◎ Initialize e’s clientId attribute to client’s id. ◎ ↓
       5. ~IF［ %要請 は`非~下位資源~要請$である ］~AND［ %要請 の`行先$rq ~NEQ `report^l【！TODO `report$l】 ］ ⇒ %~event の `resultingClientId$m1 属性 ~SET %予約-済み~client の`~ID$enV ◎ If request is a non-subresource request and request’s destination is not "report", initialize e’s resultingClientId attribute to reservedClient’s id,＼ ↑ and to the empty string otherwise.
       6. ~IF［ %要請 は`~navi要請$である ］ ⇒ %~event の `replacesClientId$m1 属性 ~SET %要請 の`置換する~client~ID$rq ◎ If request is a navigation request, initialize e’s replacesClientId attribute to request’s replaces client id,＼ ↑ and to the empty string otherwise. ◎ ↑ Initialize e’s handled to eventHandled.
       7. %計時~報 の`~fetch~event配送-時刻$swT ~LET `粗化した共有される現在の時刻$( %高分解能な処理能~timerを利用するか ) ◎ Let timingInfo’s fetch event dispatch time to the coarsened shared current time given useHighResPerformanceTimers.
       8. `~eventを配送する$( %作動中な~worker の`大域~obj$sw, %~event ) ◎ Dispatch e at activeWorker’s global object.
       9. `~sw延長-済み~event集合を更新する$( %作動中な~worker, %~event ) ◎ Invoke Update Service Worker Extended Events Set with activeWorker and e.
       10. ~IF［ %~event の`~enteredで応答するか$FE ~EQ ~T ］ ⇒ %~enteredで応答するか ~SET ~T ◎ If e’s respond-with entered flag is set, set respondWithEntered to true.

       11. ~IF［ %~event の`応答するまで待機-中か$FE ~EQ ~T ］： ◎ If e’s wait to respond flag is set, then:

           1. 次が満たされるまで待機する ⇒ %~event の`応答するまで待機-中か$FE ~EQ ~F ◎ Wait until e’s wait to respond flag is unset.
           2. ~IF［ %~event の`~errorで応答するか$FE ~EQ ~T ］ ⇒ %~fetchを取扱うのに失敗したか ~SET ~T ◎ If e’s respond-with error flag is set, set handleFetchFailed to true.
           3. ~ELSE ⇒ %応答 ~SET %~event の`応答になり得る$FE ◎ Else, set response to e’s potential response.

       12. ~IF［ %応答 ~EQ ~NULL ］~AND［ %要請 の`本体$rq ~NEQ ~NULL ］~AND［ %要請 の`本体$rqの`~source$bd ~EQ ~NULL ］： ◎ If response is null, request’s body is not null, and request’s body's source is null, then:

           1. ~IF［ %要請 の`本体$rqは`利用-不能$Bdである ］ ⇒ %~fetchを取扱うのに失敗したか ~SET ~T ◎ If request’s body is unusable, set handleFetchFailed to true.
           2. ~ELSE ⇒ %要請 の`本体$rqを`取消す$RS( `undefined^jv ) ◎ Else, cancel request’s body with undefined.
       13. ~IF［ %応答 ~NEQ ~NULL ］ ⇒ %応答 の`~sw計時~報$rs ~SET %計時~報 ◎ If response is not null, then set response’s service worker timing info to timingInfo.
       14. ~IF［ %~event の`取消されたか$ev ~EQ ~T ］ ⇒ %~eventは取消されたか ~SET ~T ◎ If e’s canceled flag is set, set eventCanceled to true.

       15. ~IF［ %制御器 の`状態$fC ~IN { `terminated^l, `aborted^l } ］： ◎ If controller state is "terminated" or "aborted", then:

           1. %逆直列化された~error ~LET `AbortError$E 例外 ◎ Let deserializedError be a "AbortError" DOMException.

           2. ~IF［ %制御器 の`直列化された中止-事由$ ~NEQ ~NULL ］：

              1. %~error ~LET `StructuredDeserialize$jA( %制御器 の`直列化された中止-事由$, %~worker~realm )

                 例外が投出されたときは，~catchして ⇒ %~error ~SET `undefined^jv

              2. ~IF［ %~error ~NEQ `undefined^jv ］ ⇒ %逆直列化された~error ~SET %~error
              ◎ If controller’s serialized abort reason is non-null, set deserializedError to the result of calling StructuredDeserialize with controller’s serialized abort reason and workerRealm. If that threw an exception or returns undefined, then set deserializedError to a "AbortError" DOMException.

           3. `~taskを~queueする$( `~fetchを取扱う~task~source$, 次の手続き, %作動中な~worker の`~event~loop$ )

              手続きは ⇒ `中止-を通達する$aC( %制御器, %逆直列化された~error )
              ◎ Queue a task to signal abort on controller with deserializedError.
       %~task が破棄されたときは ⇒ %~fetchを取扱うのに失敗したか ~SET ~T ◎ If task is discarded, set handleFetchFailed to true. ◎ ↑↑ The task must use activeWorker’s event loop and the handle fetch task source.
16. %~task が実行されるか次が満たされるまで待機する ⇒ %~fetchを取扱うのに失敗したか ~EQ ~T ◎ Wait for task to have executed or for handleFetchFailed to be true.

17. ~IF［ %~soft更新すべきか ~EQ ~T ］ ⇒ 次の手続きを`並列的$に走らす ◎ If shouldSoftUpdate is true, then in parallel run＼

    手続きは ⇒ `~soft更新する$( %登録 ) ◎ the Soft Update algorithm with registration.
18. %作動中な~worker の`大域~obj$swの`競走~応答~map$SWG[ %要請 ] ~SET ε ◎ If activeWorker’s global object's race response map[request] exists, remove activeWorker’s global object's race response map[request].

19. ~IF［ %~enteredで応答するか ~EQ ~F ］： ◎ If respondWithEntered is false, then:

    1. ~IF［ %~eventは取消されたか ~EQ ~T ］： ◎ If eventCanceled is true, then:

       1. ~IF［ %取扱った~event ~NEQ ~NULL ］ ⇒ `~promiseを却下する$( %取扱った~event, %~worker~realm 内の `NetworkError$E 例外 ) ◎ If eventHandled is not null, then reject eventHandled with a "NetworkError" DOMException in workerRealm.
       2. ~RET `~network~error$ ◎ Return a network error.
    2. ~IF［ %取扱った~event ~NEQ ~NULL ］ ⇒ `~promiseを解決する$( %取扱った~event ) ◎ If eventHandled is not null, then resolve eventHandled.

    3. ~IF［ %競走~応答 の`値$rV ~NEQ ~NULL ］： ◎ If raceResponse’s value is not null, then:

       1. 次が満たされるまで待機する ⇒ %競走~応答 の`値$rV ~NEQ `pending^l ◎ Wait until raceResponse’s value is not "pending".
       2. ~IF［ %競走~応答 の`値$rVは`応答$である ］ ⇒ ~RET %競走~応答 の`値$rV ◎ If raceResponse’s value is a response, return raceResponse’s value.
    4. ~RET ~NULL ◎ Return null.

20. ~IF［ %~fetchを取扱うのに失敗したか ~EQ ~T ］： ◎ If handleFetchFailed is true, then:

    1. ~IF［ %取扱った~event ~NEQ ~NULL ］ ⇒ `~promiseを却下する$( %取扱った~event, %~worker~realm 内の `NetworkError$E 例外 ) ◎ If eventHandled is not null, then reject eventHandled with a "NetworkError" DOMException in workerRealm.
    2. ~RET `~network~error$ ◎ Return a network error.
21. ~IF［ %取扱った~event ~NEQ ~NULL ］ ⇒ `~promiseを解決する$( %取扱った~event ) ◎ If eventHandled is not null, then resolve eventHandled.
22. ~RET %応答 ◎ Return response.

`~URL~patternを構文解析する@

• 入力 ⇒＃ %ナマ~pattern — `URLPatternCompatible$I %~sw — `~sw$ ◎ Input • rawPattern, a URLPatternCompatible • serviceWorker, a service worker
• 出力 ⇒ `~URL~pattern$ ◎ Output • A URL pattern

1. %基底~URL ~LET %~sw の`~script~URL$sw ◎ Let baseURL be serviceWorker’s script url.
2. ~RET `~Web~IDL値から~URL~patternを築く$( %ナマ~pattern, %基底~URL ) ◎ Return the result of building a URL pattern from a Web IDL value rawPattern given baseURL.

`~router条件を検証yする@

• 入力 ⇒＃ %条件 — `RouterCondition$I %~sw `~sw$ ◎ Input • condition, a RouterCondition • serviceWorker, a service worker
• 出力 ⇒ 真偽値 ◎ Output • a boolean

1. %条件は在るか ~LET ~F ◎ Let hasCondition be false.
2. %ナマ~pattern ~LET %条件[ "`urlPattern$m1" ] ◎ ↓

3. ~IF［ %ナマ~pattern ~NEQ ε ］： ◎ If condition["urlPattern"] exists, then: • Let rawPattern be condition["urlPattern"].

   1. %~pattern ~LET `~URL~patternを構文解析する$( %ナマ~pattern, %~sw )

      例外が投出されたときは、 ~catchして ⇒ ~RET ~F

      ◎ Let pattern be the result of running the Parse URL Pattern algorithm passing rawPattern and serviceWorker. If this throws an exception, catch it and return false.

   2. ~IF［ %~pattern は`正規表現-~groupを有して$いる ］ ⇒ ~RET ~F ◎ If pattern has regexp groups, then return false.

      注記： 利用者~定義な正規表現は、 禁制される — それを走らすことには、 ~securityの懸念があるので。 ◎ Note: Since running a user-defined regular expression has a security concern, it is prohibited.

   3. %条件は在るか ~SET ~T ◎ Set hasCondition to true.

4. ~IF［ ~OR↓ ］…

   • %条件[ "`requestMethod$m1" ] ~NEQ ε
   • %条件[ "`requestMode$m1" ] ~NEQ ε
   • %条件[ "`requestDestination$m1" ] ~NEQ ε
   • %条件[ "`runningStatus$m1" ] ~NEQ ε

   …ならば ⇒ %条件は在るか ~SET ~T

   ◎ If condition["requestMethod"] exists, set hasCondition to true. ◎ If condition["requestMode"] exists, set hasCondition to true. ◎ If condition["requestDestination"] exists, set hasCondition to true. ◎ If condition["runningStatus"] exists, set hasCondition to true.
5. %~or条件~群 ~LET %条件[ "`or$m1" ] ◎ ↓

6. ~IF［ %~or条件~群 ~NEQ ε ］： ◎ If condition["_or"] exists, then:

   1. ~IF［ %条件は在るか ~EQ ~T ］ ⇒ ~RET ~F ◎ If hasCondition is true, return false.

      注記： ~router規則を理解し易くするため、 %~or条件~群 と他の条件は，互いに排他的である。 【言い換えれば、両者が在る場合，当の規則は無視される。】 ◎ Note: For ease of understanding the router rule, the "or" condition is mutually exclusive with other conditions.

   2. %~or条件~群 を成す ~EACH( %~or条件 ) に対し ⇒ ~IF［ `~router条件を検証yする$( %~or条件, %~sw ) ~EQ ~F ］ ⇒ ~RET ~F ◎ Let orConditions be condition["_or"]. ◎ For each orCondition of orConditions: • If running the Verify Router Condition algorithm with orCondition and serviceWorker returns false, return false.
   3. %条件は在るか ~SET ~T ◎ Set hasCondition to true.
7. %~not条件 ~LET %条件[ "`not$m1" ] ◎ ↓

8. ~IF［ %~not条件 ~NEQ ε ］： ◎ If condition["not"] exists, then:

   1. ~IF［ %条件は在るか ~EQ ~T ］ ⇒ ~RET ~F ◎ If hasCondition is true, return false.

      注記： ~router規則を理解し易くするため、 %~not条件 と他の条件は，互いに排他的である。 【言い換えれば、両者が在る場合，当の規則は無視される。】 ◎ Note: For ease of understanding the router rule, the "not" condition is mutually exclusive with other conditions.

   2. ~IF［ `~router条件を検証yする$( %~not条件, %~sw ) ~EQ ~F ］ ⇒ ~RET ~F ◎ If running the Verify Router Condition algorithm with condition["not"] and serviceWorker returns false, return false.
   3. %条件は在るか ~SET ~T ◎ Set hasCondition to true.
9. ~RET %条件は在るか ◎ Return hasCondition.

`~router条件を照合する@

• 入力 ⇒＃ %条件 — `RouterCondition$I, %~sw — `~sw$, %要請 — `要請$ ◎ Input • condition, a RouterCondition • serviceWorker, a service worker • request, a request
• 出力 ⇒ 真偽値 ◎ Output • a boolean

注記： 複数の条件が在る場合 （例： `urlPattern$m1, `runningStatus$m1, `requestMethod$m1 が設定された）、 照合されるすべての条件が ~T を返す必要がある。 ◎ Note: if there are multiple conditions (e.g. urlPattern, runningStatus, and requestMethod are set), all conditions need to match for true to be returned.

1. %~or条件~群 ~LET %条件[ "`or$m1" ] ◎ ↓

2. ~IF［ %~or条件~群 ~NEQ ε ］： ◎ If condition["or"] exists, then: • Let orConditions be condition["or"].

   1. %~or条件~群 を成す ~EACH( %~or条件 ) に対し ⇒ ~IF［ `~router条件を照合する$( %~or条件, %~sw, %要請 ) ~EQ ~T ］ ⇒ ~RET ~T ◎ For each orCondition of orConditions: • If running the Match Router Condition algorithm with orCondition, serviceWorker and request returns true, then return true.
   2. ~RET ~F ◎ Return false.
3. %~not条件 ~LET %条件[ "`not$m1" ] ◎ ↓

4. ~IF［ %~not条件 ~NEQ ε ］ ⇒ ~RET ~IS［ `~router条件を照合する$( %~not条件, %~sw, %要請 ) ~EQ ~F ］ ◎ If condition["not"] exists, then: • If running the Match Router Condition algorithm with condition["not"], serviceWorker and request returns true, then return false. • Return true.

5. ~ELSE： ◎ Else:

   注記： `~router条件を検証yする$ ~algoにより，［ `or$m1【, `not$m1】, 他の条件 ］は、 【この~algoを呼出すに先立って】 互いに排他的になることが保証される。 ◎ Note: The Verify Router Condition algorithm guarantees that or and other conditions are mutual exclusive.

   1. %ナマ~pattern ~LET %条件[ "`urlPattern$m1" ] ◎ ↓

   2. ~IF［ %ナマ~pattern ~NEQ ε ］： ◎ If condition["urlPattern"] exists, then: • Let rawPattern be condition["urlPattern"].

      1. %~pattern ~LET `~URL~patternを構文解析する$( %ナマ~pattern, %~sw ) ◎ Let pattern be the result of running the Parse URL Pattern algorithm passing rawPattern and serviceWorker.
      2. ~IF［ `~patternを照合する$( %~pattern, %要請 の`~URL$rq ) ~EQ ~NULL ］ ⇒ ~RET ~F ◎ If running match with pattern and request’s URL returns null, return false.
   3. %~method ~LET %条件[ "`requestMethod$m1" ] ◎ ↓
   4. ~IF［ %~method ~NEQ ε ］~AND［ %要請 の`~method$rq ~NEQ %~method ］ ⇒ ~RET ~F ◎ If condition["requestMethod"] exists, then: • Let method be condition["requestMethod"]. • If request’s method is not method, return false.
   5. %~mode ~LET %条件[ "`requestMode$m1" ] ◎ ↓
   6. ~IF［ %~mode ~NEQ ε ］~AND［ %要請 の`~mode$rq ~NEQ %~mode ］ ⇒ ~RET ~F ◎ If condition["requestMode"] exists, then: • Let mode be condition["requestMode"]. • If request’s mode is not mode, return false.
   7. %行先 ~LET %条件[ "`requestDestination$m1" ] ◎ ↓
   8. ~IF［ %行先 ~NEQ ε ］~AND［ %要請 の`行先$rq ~NEQ %行先 ］ ⇒ ~RET ~F ◎ If condition["requestDestination"] exists, then: • Let destination be condition["requestDestination"]. • If request’s destination is not destination, return false.
   9. %走っているか否か ~LET %条件[ "`runningStatus$m1" ] ◎ ↓

   10. ~IF［ %走っているか否か ~NEQ ε ］：

       1. ~IF［ %走っているか否か ~EQ `running$l ］~AND［ ~NOT %~sw は`走っている$ ］ ⇒ ~RET ~F
       2. ~IF［ %走っているか否か ~EQ `not-running$l ］~AND［ %~sw は`走っている$ ］ ⇒ ~RET ~F
       ◎ If condition["runningStatus"] exists, then: • Let runningStatus be condition["runningStatus"]. • If runningStatus is "running", and serviceWorker is not running, return false. • If runningStatus is "not-running", and serviceWorker is running, return false.
   11. ~RET ~T ◎ Return true.

`~router~sourceを取得する@

• 入力 ⇒＃ %~sw — `~sw$, %要請 — `要請$ ◎ Input • serviceWorker, a service worker • request, a request
• 出力 ⇒ `RouterSource$I ／ ~NULL ◎ Output • RouterSource or null

1. %~sw の`~router規則~list$を成す ~EACH( %規則 ) に対し ⇒ ~IF［ `~router条件を照合する$( %規則[ "`condition$m1" ], %~sw, %要請 ) ~EQ ~T ］ ⇒ ~RET %規則[ "`source$m1" ] ◎ For each rule of serviceWorker’s list of router rules: • If running the Match Router Condition algorithm with rule["condition"], serviceWorker and request returns true, then return rule["source"].
2. ~RET ~NULL ◎ Return null.

`~eventを飛ばすべきか？@

• 入力 ⇒＃ %~event名 — 文字列, %~sw — `~sw$ ◎ Input • eventName, a string • serviceWorker, a service worker
• 出力 ⇒＃ 真偽値 ◎ Output • a boolean

注記： 不必要な遅延を避けるため、 この仕様は，次を許可する ⇒ 次が決定可能ならば，［ %~event名 用の~event配送- ］を飛ばす ⇒ ~script実行の最初期の間に， %~sw の大域~objに追加された［ %~event名 用の~event~listener ］は無い ◎ Note: To avoid unnecessary delays, this specification permits skipping event dispatch when no event listeners for the event have been deterministically added in the service worker’s global during the very first script execution.

1. ~IF［ %~event名 ~IN %~sw が`取扱う~event型の集合$sw ］ ⇒ ~RET ~F ◎ ↓
2. ~UAは次をしても`ヨイ^em ⇒ ~RET ~T ◎ If serviceWorker’s set of event types to handle does not contain eventName, then the user agent may return true.
3. ~RET ~F ◎ Return false.

`機能的~eventを発火する@

• 入力 ⇒＃ %登録 — `~sw登録$, %~event名 — 文字列, %~event構築子 — `ExtendableEvent$I を拡張する~event構築子, %初期化 — %~event構築子 で構築される~event用の~propを初期化する~~指示書き（省略時は ε ）, %配送-後~手続き — 構築された~eventを引数に`作動中な~worker$swrの~event~loopを走らす手続き ◎ Input • eventName, a string • eventConstructor, an event constructor that extends ExtendableEvent • registration, a service worker registration • initialization, optional property initialization for event, constructed from eventConstructor • postDispatchSteps, optional steps to run on the active worker's event loop, with dispatchedEvent set to the instance of eventConstructor that was dispatched.
• 出力 ⇒＃ ~none ◎ Output • None

1. ~Assert： %登録 にて`作動中な~worker$swr ~NEQ ~NULL ◎ Assert: registration’s active worker is not null.
2. %作動中な~worker ~LET %登録 にて`作動中な~worker$swr ◎ Let activeWorker be registration’s active worker.

3. `(A)^i：

   1. ~IF［ `~eventを飛ばすべきか？$( %~event名, %作動中な~worker ) ~EQ ~T ］ ⇒ ~BREAK `(A)^i ◎ If the result of running Should Skip Event with eventName and activeWorker is true, then: • If registration is stale, then in parallel run the Soft Update algorithm with registration. • Return.
   2. ~IF［ %作動中な~worker の`状態$sw ~EQ `activating^l ］ ⇒ 次が満たされるまで待機する ⇒ %作動中な~worker の`状態$sw ~EQ `activated^l ◎ If activeWorker’s state is "activating", wait for activeWorker’s state to become "activated".

   3. ~IF［ `~swを走らす$( %作動中な~worker ) ~EQ `失敗^i ］ ⇒ ~BREAK `(A)^i ◎ If the result of running the Run Service Worker algorithm with activeWorker is failure, then: • If registration is stale, then in parallel run the Soft Update algorithm with registration. • Return.

   4. %~task ~LET `~taskを~queueする$( `機能的~eventを取扱う~task~source$, 次の手続き, %作動中な~worker の`~event~loop$ ) ◎ Queue a task task to run these substeps:

      手続きは：

      1. %~event ~LET `~eventを作成する$( %~event構築子, %作動中な~worker の`大域~obj$swに`関連な~realm$ ) ◎ Let event be the result of creating an event with eventConstructor and the relevant realm of activeWorker’s global object.
      2. ~IF［ %初期化 ~NEQ ε ］ ⇒ %初期化 に従って %~event を初期化する ◎ If initialization is not null, then initialize event with initialization.
      3. `~eventを配送する$( %作動中な~worker の`大域~obj$sw, %~event ) ◎ Dispatch event on activeWorker’s global object.
      4. `~sw延長-済み~event集合を更新する$( %作動中な~worker, %~event ) ◎ Invoke Update Service Worker Extended Events Set with activeWorker and event.
      5. ~IF［ %配送-後~手続き ~NEQ ε ］ ⇒ %~event を渡して， %配送-後~手続き を走らす ◎ If postDispatchSteps is not null, then run postDispatchSteps passing event as dispatchedEvent.
   5. %~task が実行されるか破棄されるまで待機する ◎ ↑The task must use activeWorker’s event loop and the handle functional event task source. ◎ Wait for task to have executed or been discarded.

4. ~IF［ %登録 は`非新鮮$である ］ ⇒ 次の手続きを`並列的$に走らす

   手続きは ⇒ `~soft更新する$( %登録 )
   ◎ If registration is stale, then in parallel run the Soft Update algorithm with registration.

`~sw~clientを~unloadする@

~UAは、［ `文書~unload時の片付け手続き$／~swの`終了n$ ］を介して`~sw~client$を~unloadするときは、 この手続きを走らすモノトスル。 ◎ The user agent must run these steps as part of when a service worker client unloads via unloading document cleanup steps or termination.

• 入力 ⇒＃ %~client — `~sw~client$ ◎ Input • client, a service worker client
• 出力 ⇒＃ ~none ◎ Output • None

この手続きは不可分に走らすとする： ◎ Run the following steps atomically.

1. %登録 ~LET %~client が`利用して$いる`~sw登録$ ◎ Let registration be the service worker registration used by client.
2. ~IF［ %登録 ~EQ ~NULL ］ ⇒ ~RET ◎ If registration is null, abort these steps.
3. ~IF［ %~client 以外に， %登録 を`利用して$いる`~sw~client$はある ］ ⇒ ~RET ◎ If any other service worker client is using registration, abort these steps.
4. ~IF［ %登録 は`未登録にされて$いる ］ ⇒ `登録を~clearしようと試行する$( %登録 ) ◎ If registration is unregistered, invoke Try Clear Registration with registration.
5. `作動化しようと試行する$( %登録 ) ◎ Invoke Try Activate with registration.

`~UA~shutdownを取扱う@

• 入力 ⇒＃ ~none ◎ Input • None
• 出力 ⇒＃ ~none ◎ Output • None

1. %登録~list ~LET `登録~map$の`値~群$map ◎ ↓

2. %登録~list を成す ~EACH( %登録 ) に対し： ◎ For each registration of registration map's values:

   1. ~IF［ %登録 にて`~install中の~worker$swr ~NEQ ~NULL ］： ◎ If registration’s installing worker is not null, then:

      1. ~IF［ %登録 にて`待機-中な~worker$swr ~EQ ~NULL ］~AND［ %登録 にて`作動中な~worker$swr ~EQ ~NULL ］ ⇒ `登録を~clearする$( %登録 ) ◎ If registration’s waiting worker is null and registration’s active worker is null, invoke Clear Registration with registration and continue to the next iteration of the loop.
      2. ~ELSE ⇒ %登録 にて`~install中の~worker$swr ~SET ~NULL ◎ Else, set registration’s installing worker to null.

   2. ~IF［ %登録 にて`待機-中な~worker$swr ~NEQ ~NULL ］ ⇒ 次の手続きを`並列的$に走らす

      手続きは ⇒ `作動化する$( %登録 )
      ◎ If registration’s waiting worker is not null, then in parallel: • Invoke Activate with registration.

`~sw延長-済み~event集合を更新する@

• 入力 ⇒＃ %~worker — `~sw$, %~event — `~event$ ◎ Input • worker, a service worker • event, an event
• 出力 ⇒＃ ~none ◎ Output • None

1. ~Assert： %~event の`配送-中か$ev ~EQ ~F ◎ Assert: event’s dispatch flag is unset.

2. %~worker の`延長-済み~event集合$swを成す ~EACH( %~item ) に対し ⇒ ~IF［ %~item は`作動中$eXでない ］ ⇒ %~worker の`延長-済み~event集合$swから %~item を`除去する$ ◎ For each item of worker’s set of extended events: • If item is not active, remove item from worker’s set of extended events.

3. ~IF［ %~event は`作動中$eXである ］ ⇒ %~worker の`延長-済み~event集合$swに %~event を`付加する$set ◎ If event is active, append event to worker’s set of extended events.

`未登録にする@

• 入力 ⇒＃ %~job — `~job$ ◎ Input • job, a job
• 出力 ⇒＃ ~none ◎ Output • None

1. ~IF［ %~job の`~scope~URL$jobの`生成元$url ~NEQ`生成元$sub %~job の`~client$jobの`生成元$cl【！`生成元$enV】 ］： ◎ If the origin of job’s scope url is not job’s client's origin, then:

   1. `~job~promiseを却下する$( %~job, `SecurityError$E 例外 ) ◎ Invoke Reject Job Promise with job and "SecurityError" DOMException.
   2. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
   3. ~RET ◎ abort these steps.
2. %登録 ~LET `登録を取得する$( %~job の`~storage~key$job, %~job の`~scope~URL$job ) ◎ Let registration be the result of running Get Registration given job’s storage key and job’s scope url.

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

   1. `~job~promiseを解決する$( %~job, ~F ) ◎ Invoke Resolve Job Promise with job and false.
   2. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job and＼
   3. ~RET ◎ abort these steps.
4. `登録~map$[ ( %登録 の`~storage~key$swr, %~job の`~scope~URL$job ) ] ~SET ε ◎ Remove registration map[(registration’s storage key, job’s scope url)].
5. `~job~promiseを解決する$( %~job, ~T ) ◎ Invoke Resolve Job Promise with job and true.

6. `登録を~clearしようと試行する$( %登録 ) ◎ Invoke Try Clear Registration with registration.

   注記： この`登録を~clearしようと試行する$() が，`登録を~clearする$() を誘発しなかった場合、 次に該当するときに再度，誘発するよう試行することになる ⇒＃ %登録 を`利用して$いる最後の~clientが`~unload$されたとき ／ %登録 の~sw用の`存続期間を延長する~promise群$が決着したとき ◎ Note: If Try Clear Registration does not trigger Clear Registration here, Clear Registration is tried again when the last client using the registration is unloaded or the extend lifetime promises for the registration’s service workers settle.

7. `~jobを完遂する$( %~job ) ◎ Invoke Finish Job with job.

`登録を設定する@

• 入力 ⇒＃ %~storage~key — `~storage~key$, %~scope — `~URL$, %~cacheを介する更新 — `~cacheを介する更新~mode$swr ◎ Input • storage key, a storage key • scope, a URL • updateViaCache, an update via cache mode
• 出力 ⇒＃ %登録 — `~sw登録$ ◎ Output • registration, a service worker registration

この手続きは不可分に走らすとする： ◎ Run the following steps atomically.

1. %~scope文字列 ~LET `~URLを直列化する$( %~scope, `素片は除外する^i ) ◎ Let scopeString be serialized scope with the exclude fragment flag set.
2. %登録 ~LET 新たな`~sw登録$ — その ⇒＃ `~storage~key$swr ~SET %~storage~key, `~scope~URL$swr ~SET %~scope, `~cacheを介する更新~mode$swr ~SET %~cacheを介する更新 ◎ Let registration be a new service worker registration whose storage key is set to storage key, scope url is set to scope, and update via cache mode is set to updateViaCache.
3. `登録~map$[ ( %~storage~key, %~scope文字列 ) ] ~SET %登録 ◎ Set registration map[(storage key, scopeString)] to registration.
4. ~RET %登録 ◎ Return registration.

`登録を~clearする@

• 入力 ⇒＃ %登録 — `~sw登録$ ◎ Input • registration, a service worker registration
• 出力 ⇒＃ ~none ◎ Output • None

この手続きは不可分に走らすとする： ◎ Run the following steps atomically.

1. 次の表tを成す ~EACH( 行 ) に対し，順に：

   %登録 にて`~install中の~worker$swr	`installing^l
   %登録 にて`待機-中な~worker$swr	`waiting^l
   %登録 にて`作動中な~worker$swr	`active^l

   1. ( %~worker, %~target ) ~LET 行の ( 1 列目, 2 列目 ) に挙げる値
   2. ~IF［ %~worker ~EQ ~NULL ］ ⇒ ~CONTINUE
   3. `~swを終了する$( %~worker )
   4. `~workerの状態を更新する$( %~worker, `redundant^l )
   5. `登録の状態を更新する$( %登録, %~target, ~NULL )
   ◎ If registration’s installing worker is not null, then: • Terminate registration’s installing worker. • Run the Update Worker State algorithm passing registration’s installing worker and "redundant" as the arguments. • Run the Update Registration State algorithm passing registration, "installing" and null as the arguments. ◎ If registration’s waiting worker is not null, then: • Terminate registration’s waiting worker. • Run the Update Worker State algorithm passing registration’s waiting worker and "redundant" as the arguments. • Run the Update Registration State algorithm passing registration, "waiting" and null as the arguments. ◎ If registration’s active worker is not null, then: • Terminate registration’s active worker. • Run the Update Worker State algorithm passing registration’s active worker and "redundant" as the arguments. • Run the Update Registration State algorithm passing registration, "active" and null as the arguments.

`登録を~clearしようと試行する@

• 入力 ⇒＃ %登録 — `~sw登録$ ◎ Input • registration, a service worker registration
• 出力 ⇒＃ ~none ◎ Output • None

1. ~IF［ ~AND↓ ］…

   • %登録 を`利用して$いる`~sw~client$はない
   • `~swには処理待ち~eventは無いか？$( %登録 にて`~install中の~worker$swr ) ~EQ ~T
   • `~swには処理待ち~eventは無いか？$( %登録 にて`待機-中な~worker$swr ) ~EQ ~T
   • `~swには処理待ち~eventは無いか？$( %登録 にて`作動中な~worker$swr ) ~EQ ~T

   …ならば ⇒ `登録を~clearする$( %登録 )

   ◎ Invoke Clear Registration with registration if no service worker client is using registration and all of the following conditions are true: • registration’s installing worker is null or the result of running Service Worker Has No Pending Events with registration’s installing worker is true. • registration’s waiting worker is null or the result of running Service Worker Has No Pending Events with registration’s waiting worker is true. • registration’s active worker is null or the result of running Service Worker Has No Pending Events with registration’s active worker is true.

`登録の状態を更新する@

• 入力 ⇒＃ %登録 — `~sw登録$, %~target ~IN { `installing^l , `waiting^l , `active^l } %~source — `~sw$ ／ ~NULL ◎ Input • registration, a service worker registration • target, a string (one of "installing", "waiting", and "active") • source, a service worker or null
• 出力 ⇒＃ ~none ◎ Output • None

1. %登録~obj群 ~LET %登録 を表現している すべての `ServiceWorkerRegistration$I ~objからなる集合 【順序は指定されていない】 ◎ Let registrationObjects be an array containing all the ServiceWorkerRegistration objects associated with registration.

2. %~target に応じて：

   `installing^l ◎ If target is "installing", then:

   1. %登録 にて`~install中の~worker$swr ~SET %~source ◎ Set registration’s installing worker to source.

   2. %登録~obj群 を成す ~EACH( %登録~obj ) に対し ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %登録~obj に`関連な設定群~obj$の`担当の~event~loop$enV )

      手続きは ⇒ %登録~obj の `installing$m 属性 ~SET %登録 の`~install中の~worker$swrに応じて ⇒＃ ~NULL ならば ~NULL ／ ~ELSE_ `~sw~objを取得する$( %登録 の`~install中の~worker$swr, %登録~obj に`関連な設定群~obj$ )
      ◎ For each registrationObject in registrationObjects: • Queue a task to set the installing attribute of registrationObject to null if registration’s installing worker is null, or the result of getting the service worker object that represents registration’s installing worker in registrationObject’s relevant settings object.

   `waiting^l ◎ Else if target is "waiting", then:

   1. %登録 にて`待機-中な~worker$swr ~SET %~source ◎ Set registration’s waiting worker to source.

   2. %登録~obj群 を成す ~EACH( %登録~obj ) に対し ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %登録~obj に`関連な設定群~obj$の`担当の~event~loop$enV )

      手続きは ⇒ %登録~obj の `waiting$m 属性 ~SET %登録 の`待機-中な~worker$swrに応じて ⇒＃ ~NULL ならば ~NULL ／ ~ELSE_ `~sw~objを取得する$( %登録 の`待機-中な~worker$swr, %登録~obj に`関連な設定群~obj$ )
      ◎ For each registrationObject in registrationObjects: • Queue a task to set the waiting attribute of registrationObject to null if registration’s waiting worker is null, or the result of getting the service worker object that represents registration’s waiting worker in registrationObject’s relevant settings object.

   `active^l ◎ Else if target is "active", then:

   1. %登録 にて`作動中な~worker$swr ~SET %~source ◎ Set registration’s active worker to source.

   2. %登録~obj群 を成す ~EACH( %登録~obj ) に対し ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %登録~obj に`関連な設定群~obj$の`担当の~event~loop$enV )

      手続きは ⇒ %登録~obj の `active$m 属性 ~SET ［ %登録 の`作動中な~worker$swr ~EQ ~NULL ならば ~NULL ／ ~ELSE_ `~sw~objを取得する$( %登録 の`作動中な~worker$swr, %登録~obj に`関連な設定群~obj$ ) ］
      ◎ For each registrationObject in registrationObjects: • Queue a task to set the active attribute of registrationObject to null if registration’s active worker is null, or the result of getting the service worker object that represents registration’s active worker in registrationObject’s relevant settings object.

   ◎ ↑ The task must use registrationObject’s relevant settings object's responsible event loop and the DOM manipulation task source.

`~workerの状態を更新する@

• 入力 ⇒＃ %~worker — `~sw$, %状態 — `~sw$の`状態$sw ◎ Input • worker, a service worker • state, a service worker state
• 出力 ⇒＃ ~none ◎ Output • None

1. ~Assert： %状態 ~NEQ `parsed^l ◎ Assert: state is not "parsed".

   注記： `parsed^l は初期~状態である。 この状態にある`~sw$が更新されることは、 決してない。 ◎ Note: "parsed" is the initial state. A service worker is never updated to this state.

2. %~worker の`状態$sw ~SET %状態 ◎ Set worker’s state to state.
3. %設定群~obj群 ~LET 次を満たす`環境~設定群~obj$すべてからなる集合 ⇒ `生成元$enV ~EQ`生成元$sub %~worker の`~script~URL$swの`生成元$url ◎ Let settingsObjects be all environment settings objects whose origin is worker’s script url's origin.

4. %設定群~obj群 を成す ~EACH( %設定群~obj ) に対し ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %設定群~obj の`担当の~event~loop$enV ) ◎ For each settingsObject of settingsObjects, queue a task on settingsObject’s responsible event loop in the DOM manipulation task source＼

   手続きは、 次を走らす： ◎ to run the following steps:

   1. %~obj~map ~LET %設定群~obj の`~sw~obj~map$enV ◎ Let objectMap be settingsObject’s service worker object map.
   2. %~worker~obj ~LET %~obj~map[ %~worker ] ◎ ↓
   3. ~IF［ %~worker~obj ~EQ ε ］ ⇒ ~RET ◎ If objectMap[worker] does not exist, then abort these steps. ◎ Let workerObj be objectMap[worker].
   4. %~worker~obj の `ServiceWorker^I1`state$m1 ~SET %状態 ◎ Set workerObj’s state to state.
   5. `~eventを発火する$( %~worker~obj, `statechange$et ) ◎ Fire an event named statechange at workerObj.

`制御器の変化を通知する@

• 入力 ⇒＃ %~client — `~sw~client$ ◎ Input • client, a service worker client
• 出力 ⇒＃ ~none ◎ Output • None

1. ~Assert： %~client ~NEQ ~NULL ◎ Assert: client is not null.

2. ~IF［ %~client は`環境~設定群~obj$である ］ ⇒ `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~client の`担当の~event~loop$enV )

   手続きは：

   1. %O ~LET 次を満たす `ServiceWorkerContainer$I ~obj ⇒ その`~sw~client$SWC ~EQ %~client
   2. `~eventを発火する$( %O, `controllerchange$etC )
   ◎ If client is an environment settings object, queue a task to fire an event named controllerchange at the ServiceWorkerContainer object that client is associated with. ◎ The task must use client’s responsible event loop and the DOM manipulation task source.

`合致する~sw登録@

• 入力 ⇒＃ %~storage~key — `~storage~key$, %~client~URL — `~URL$ ◎ Input • storage key, a storage key • clientURL, a URL
• 出力 ⇒＃ `~sw登録$【または ~NULL】 ◎ Output • A service worker registration

この手続きは不可分に走らすとする： ◎ Run the following steps atomically.

1. %~client~URL文字列 ~LET `~URLを直列化する$( %~client~URL ) ◎ Let clientURLString be serialized clientURL. ◎ ↓Let matchingScopeString be the empty string.
2. %~scope文字列~集合 ~LET 新たな`~list$ ◎ Let scopeStringSet be an empty list.
3. `登録~map$の`~key群$mapを成す ~EACH( %~key ) に対し ⇒ ~IF［［ %~storage~key, %~key[ 0 ] ］は`同等な~storage~key$である ］ ⇒ %~scope文字列~集合 に %~key[ 1 ] を`付加する$ ◎ For each (entry storage key, entry scope) of registration map's keys: • If storage key equals entry storage key, then append entry scope to the end of scopeStringSet.

4. %合致している~scope文字列 ~LET %~scope文字列~集合 内に次を満たすものが［ 在るならば，それらのうち最長の文字列 ／ 無いならば，空~文字列 ］ ⇒ %~client~URL文字列 の`符号単位~接頭辞$である【！starts with】 ◎ Set matchingScopeString to the longest value in scopeStringSet which the value of clientURLString starts with, if it exists.

   注記： この段で合致している~URL文字列は、 接頭辞に基づき，~path構造は~~加味されない。 例えば~client~URL文字列 `https://example.com/prefix-of/resource.html^l は、 `https://example.com/prefix^l を伴う~scope用の登録に合致することになる。 このような~URL文字列の比較は、 同一-生成元~security用には安全である — ［ ~HTTP／~HTTPS ］`~URLを直列化する$ときには、 生成元~~成分は，常に末尾に~slashを伴うように直列化されるので。 ◎ Note: The URL string matching in this step is prefix-based rather than path-structural. E.g. a client URL string with "https://example.com/prefix-of/resource.html" will match a registration for a scope with "https://example.com/prefix". The URL string comparison is safe for the same-origin security as HTTP(S) URLs are always serialized with a trailing slash at the end of the origin part of the URLs.

5. %合致している~scope ~LET ~NULL ◎ Let matchingScope be null.

6. ~IF［ %合致している~scope文字列 ~NEQ 空~文字列 ］： ◎ If matchingScopeString is not the empty string, then:

   1. %合致している~scope ~SET `~URL構文解析する$( %合致している~scope文字列 ) ◎ Set matchingScope to the result of parsing matchingScopeString.
   2. ~Assert： %合致している~scope の`生成元$url ~EQ`生成元$sub %~client~URL の`生成元$url ◎ Assert: matchingScope’s origin and clientURL’s origin are same origin.
7. ~RET `登録を取得する$( %~storage~key, %合致している~scope ) ◎ Return the result of running Get Registration given storage key and matchingScope.

`登録を取得する@

• 入力 ⇒＃ %~storage~key — `~storage~key$, %~scope — `~URL$【または ~NULL】 ◎ Input • storage key, a storage key • scope, a URL
• 出力 ⇒＃ `~sw登録$【または ~NULL】 ◎ Output • A service worker registration

この手続きは不可分に走らすとする： ◎ Run the following steps atomically.

1. %~scope文字列 ~LET 空~文字列 ◎ Let scopeString be the empty string.
2. ~IF［ %~scope ~NEQ ~NULL ］ ⇒ %~scope文字列 ~SET `~URLを直列化する$( %~scope, `素片は除外する^i ) ◎ If scope is not null, set scopeString to serialized scope with the exclude fragment flag set.
3. `登録~map$を成す ~EACH( %~key → %登録 ) に対し ⇒ ~IF［［ %~storage~key, %~key[ 0 ] ］は`同等な~storage~key$である ］~AND［ %~scope文字列 ~EQ【！match】 %~key[ 1 ] ］ ⇒ ~RET %登録 ◎ For each (entry storage key, entry scope) → registration of registration map: • If storage key equals entry storage key and scopeString matches entry scope, then return registration.
4. ~RET ~NULL ◎ Return null.

`最新な~workerを取得する@

• 入力 ⇒＃ %登録 — `~sw登録$ ◎ Input • registration, a service worker registration
• 出力 ⇒＃ `~sw$【または ~NULL】 ◎ Output • newestWorker, a service worker

この手続きは不可分に走らすとする： ◎ Run the following steps atomically. • Let newestWorker be null.

1. ~IF［ %登録 にて`~install中の~worker$swr ~NEQ ~NULL ］ ⇒ ~RET %登録 にて`~install中の~worker$swr ◎ If registration’s installing worker is not null, set newestWorker to registration’s installing worker.
2. ~IF［ %登録 にて`待機-中な~worker$swr ~NEQ ~NULL ］ ⇒ ~RET %登録 にて`待機-中な~worker$swr ◎ Else if registration’s waiting worker is not null, set newestWorker to registration’s waiting worker.
3. ~IF［ %登録 にて`作動中な~worker$swr ~NEQ ~NULL ］ ⇒ ~RET %登録 にて`作動中な~worker$swr ◎ Else if registration’s active worker is not null, set newestWorker to registration’s active worker.
4. ~RET ~NULL ◎ Return newestWorker.

`~swには処理待ち~eventは無いか？@

• 入力 ⇒＃ %~worker — `~sw$／~NULL 【この ~NULL と~algoの最初の段は、他所の記述を簡潔にするための，この訳による追加。】 ◎ Input • worker, a service worker
• 出力 ⇒＃ 真偽値 ◎ Output • True or false, a boolean

1. ~IF［ %~worker ~EQ ~NULL ］ ⇒ ~RET ~T ◎ ↑

2. %~worker の`延長-済み~event集合$swを成す ~EACH( %~event ) に対し ⇒ ~IF［ %~event は`作動中$eXである ］ ⇒ ~RET ~F ◎ For each event of worker’s set of extended events: • If event is active, return false.

3. ~RET ~T ◎ Return true.

`~clientを作成する@

• 入力 ⇒＃ %~client — `~sw~client$ ◎ Input • client, a service worker client
• 出力 ⇒＃ `Client$I ~obj ◎ Output • clientObject, a Client object

1. ~RET 新たな `Client$I ~obj — その ⇒＃ `~sw~client$cl ~SET %~client ◎ Let clientObject be a new Client object. ◎ Set clientObject’s service worker client to client. ◎ Return clientObject.

`~window~clientを作成する@

• 入力 ⇒＃ %~client — `~sw~client$, %~frame種別 — 文字列【 `FrameType$I 値】, %可視性~状態 — 文字列 【 `DocumentVisibilityState$I 値】, %~focus状態 — 真偽値, %先祖~生成元~list — 【文字列の】~list ◎ Input • client, a service worker client • frameType, a string • visibilityState, a string • focusState, a boolean • ancestorOriginsList, a list
• 出力 ⇒＃ `WindowClient$I ~obj ◎ Output • windowClient, a WindowClient object

1. ~RET 新たな `WindowClient$I ~obj — その ⇒＃ `~sw~client$cl ~SET %~client, `~frame種別$cl ~SET %~frame種別, `可視性~状態$cl ~SET %可視性~状態, `~focus状態$cl ~SET %~focus状態, `先祖~生成元~配列$cl ~SET `凍結d配列を作成する$( %先祖~生成元~list ) 【 %~client に`関連な~realm$内で？】 ◎ Let windowClient be a new WindowClient object. • Set windowClient’s service worker client to client. • Set windowClient’s frame type to frameType. • Set windowClient’s visibility state to visibilityState. • Set windowClient’s focus state to focusState. • Set windowClient’s ancestor origins array to a frozen array created from ancestorOriginsList. ◎ Return windowClient.

`~frame種別を取得する@

• 入力 ⇒＃ %~navigable — `~navigable$ ◎ Input • navigable, a navigable
• 出力 ⇒＃ %~frame種別 — 文字列 ◎ Output • frameType, a string

1. ~IF［ %~navigable の`親$nav ~NEQ ~NULL ］ ⇒ ~RET `nested^l ◎ If navigable’s parent is not null, then return "nested".
2. ~IF［ %~navigable にて`作動中な閲覧~文脈$navは`補助~閲覧~文脈$である ］ ⇒ ~RET `auxiliary^l ◎ If navigable’s active browsing context is an auxiliary browsing context, then return "auxiliary".
3. ~RET `top-level^l ◎ Return "top-level".

`~clientを取得する~promiseを解決する@

• 入力 ⇒＃ %~client — `~sw~client$, %~promise — `~promise$ ◎ Input • client, a service worker client • promise, a promise
• 出力 ⇒＃ ~none ◎ Output • None

1. ~IF［ ~OR↓ ］…

   • ［ %~client は`環境~設定群~obj$である ］~AND［ %~client は`~secureな文脈$enVでない ］
   • ［ %~client は`環境~設定群~obj$でない ］~AND［ %~client の`作成時の~URL$enV は`信用に価し得る~URL$でない ］

   …ならば：

   1. `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~promise に`関連な設定群~obj$の`担当の~event~loop$enV )

      手続きは ⇒ `~promiseを却下する$( %~promise, `SecurityError$E 例外 )
   2. ~RET
   ◎ If client is an environment settings object, then: • If client is not a secure context, queue a task to reject promise with a "SecurityError" DOMException, on promise’s relevant settings object's responsible event loop using the DOM manipulation task source, and abort these steps. ◎ Else: • If client’s creation URL is not a potentially trustworthy URL, queue a task to reject promise with a "SecurityError" DOMException, on promise’s relevant settings object's responsible event loop using the DOM manipulation task source, and abort these steps.

2. ~IF［ %~client は`環境~設定群~obj$である ］~AND［ %~client は`~window~client$でない ］： ◎ If client is an environment settings object and is not a window client, then:

   1. %~client~obj ~LET `~clientを作成する$( %~client ) ◎ Let clientObject be the result of running Create Client algorithm with client as the argument.

   2. `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %~promise に`関連な設定群~obj$の`担当の~event~loop$enV )

      手続きは ⇒ `~promiseを解決する$( %~promise, %~client~obj )
      ◎ Queue a task to resolve promise with clientObject, on promise’s relevant settings object's responsible event loop using the DOM manipulation task source,＼
   3. ~RET ◎ and abort these steps.
3. %閲覧~文脈 ~LET［ %~client は`環境~設定群~obj$であるならば %~client の`大域~obj$enVに`対応する閲覧~文脈$【！`閲覧~文脈$】 ／ ~ELSE_ %~client の`~target閲覧~文脈$enV ］ ◎ Else: ◎ Let browsingContext be null. ◎ If client is an environment settings object, set browsingContext to client’s global object's browsing context. ◎ Else, set browsingContext to client’s target browsing context.
4. %~navigable ~LET %閲覧~文脈 に`対応する~navigable$bc 【！`作動中な閲覧~文脈$navに %閲覧~文脈 を伴う`~navigable$】 ◎ Let navigable be the navigable with a active browsing context of browsingContext.

5. `~taskを~queueする$( `利用者~対話~task~source$, 次の手続き, %閲覧~文脈 の`~event~loop$ ) ◎ Queue a task to run the following steps on browsingContext’s event loop using the user interaction task source:

   手続きは：

   1. %~frame種別 ~LET `~frame種別を取得する$( %~navigable ) ◎ Let frameType be the result of running Get Frame Type with navigable.
   2. %作動中な文書 ~LET %~navigable にて`作動中な文書$nav ◎ ↓
   3. %可視性~状態 ~LET %作動中な文書 の`visibilityState$n 属性~値 ◎ Let visibilityState be browsingContext’s active document's visibilityState attribute value.
   4. %~focus状態 ~SET `~focusを得ている$( %作動中な文書 ) ◎ Let focusState be the result of running the has focus steps with browsingContext’s active document as the argument.
   5. %先祖~生成元~list ~LET 空~list ◎ Let ancestorOriginsList be the empty list.
   6. ~IF［ %~client は`~window~client$である ］ ⇒ %先祖~生成元~list ~SET %作動中な文書 の`先祖~生成元~文字列~list$ ◎ If client is a window client, set ancestorOriginsList to browsingContext’s active document's relevant global object's Location object’s ancestor origins list's associated list.

   7. `~taskを~queueする$( `~DOM操作~task~source$, 次の手続き, %promise に`関連な設定群~obj$の`担当の~event~loop$enV ) ◎ Queue a task to run the following steps on promise’s relevant settings object's responsible event loop using the DOM manipulation task source:

      手続きは：

      1. %結果 ~LET `undefined^jv ◎ ↓
      2. ~IF［ %~client の`破棄-済みか$ ~EQ ~F ］ ⇒ %結果 ~SET `~window~clientを作成する$( ↓ ) ⇒＃ %~client, %~frame種別, %可視性~状態, %~focus状態, %先祖~生成元~list ◎ If client’s discarded flag is set, resolve promise with undefined and abort these steps. ◎ Let windowClient be the result of running Create Window Client with client, frameType, visibilityState, focusState, and ancestorOriginsList.
      3. `~promiseを解決する$( %~promise, %結果 ) ◎ Resolve promise with windowClient.

`~cacheを~queryする@

• 入力 ⇒＃ %要請~query — `要請$, %~storage — `要請~応答~list$†, %~option群 — `CacheQueryOptions$I ~obj（省略時は ε ）, ◎ Input • requestQuery, a request • options, a CacheQueryOptions object, optional • targetStorage, a request response list, optional
• 出力 ⇒＃ %結果~list — `要請~応答~list$ ◎ Output • resultList, a request response list

【† %~storage は、 原文では省略可能とされているが、 この訳では，常に明示的に与えて呼出すよう改めている。 原文では，省略時には `関連な要請~応答~list$ になるものとされているが、 どの~objに関連なそれなのか明らかでなく，呼出す箇所で与える方が明確になるので。 それに伴い、 引数の順序も改めている。 】

1. %結果~list ~LET 新たな`~list$ ◎ Let resultList be an empty list.

2. %~storage を成す ~EACH( %要請~応答 ) に対し： ◎ Let storage be null. ◎ If the optional argument targetStorage is omitted, set storage to the relevant request response list. ◎ Else, set storage to targetStorage. ◎ For each requestResponse of storage:

   1. %要請 ~LET %要請~応答 を成す要請 ◎ Let cachedRequest be requestResponse’s request.
   2. %応答 ~LET %要請~応答 を成す応答 ◎ Let cachedResponse be requestResponse’s response.
   3. ~IF［ `要請は~cache済み~itemに合致するか？$( %要請~query, %要請, %応答, %~option群 ) ~EQ ~T ］ ⇒ %結果~list に ( %要請 の複製, %応答 の複製 ) を`付加する$ ◎ If Request Matches Cached Item with requestQuery, cachedRequest, cachedResponse, and options returns true, then: • Let requestCopy be a copy of cachedRequest. • Let responseCopy be a copy of cachedResponse. • Add requestCopy/responseCopy to resultList.
3. ~RET %結果~list ◎ Return resultList.

`要請は~cache済み~itemに合致するか？@

• 入力 ⇒＃ %要請~query — `要請$ %要請 — `要請$ %応答 — `応答$または ~NULL （省略時は ~NULL ） %~option群 — `CacheQueryOptions$I ~obj（省略時は ε ） ◎ Input • requestQuery, a request • request, a request • response, a response or null, optional, defaulting to null • options, a CacheQueryOptions object, optional
• 出力 ⇒＃ 真偽値 ◎ Output • a boolean

1. ~IF［ %~option群 ~EQ ε ］ ⇒ %~option群 ~SET 新たな `CacheQueryOptions$I 辞書 【この段は、この訳による補完】
2. ~IF［ %~option群[ `CacheQueryOptions^I1"`ignoreMethod$m1" ] ~EQ ~F ］~AND［ %要請~query の`~method$rq ~NEQ `GET^bl ］ ⇒ ~RET ~F ◎ If options["ignoreMethod"] is false and request’s method is not `GET`, return false.
3. %~query~URL ~LET %要請~query の`~URL$rq ◎ Let queryURL be requestQuery’s url.
4. %~cache済み~URL ~LET %要請 の`~URL$rq ◎ Let cachedURL be request’s url.

5. ~IF［ %~option群[ "`ignoreSearch$m1" ] ~EQ ~T ］： ◎ If options["ignoreSearch"] is true, then:

   1. %~cache済み~URL の`~query$url ~SET 空~文字列 ◎ Set cachedURL’s query to the empty string.
   2. %~query~URL の`~query$url ~SET 空~文字列 ◎ Set queryURL’s query to the empty string.
6. ~IF［ ( %~query~URL, %~cache済み~URL ) は `素片は除外する^i 下で`同等な~URL$でない ］ ⇒ ~RET ~F ◎ If queryURL does not equal cachedURL with the exclude fragment flag set, then return false.
7. ~IF［ %応答 ~EQ ~NULL ］~OR［ %~option群[ "`ignoreVary$m1" ] ~EQ ~T ］ ⇒ ~RET ~T ◎ If response is null, options["ignoreVary"] is true, or＼ ↓response’s header list does not contain `Vary`,＼ then return true.
8. %Vary ~SET `~header~listから値を取得して復号して分割する$( %応答 の`~header~list$rs, `Vary$h ) ◎ Let fieldValues be the list containing the elements corresponding to the field-values of the Vary header for the value of the header with name `Vary`.
9. ~IF［ %Vary ~EQ ~NULL ］ ⇒ ~RET ~T ◎ ↑

10. %Vary を成す ~EACH( %~field値 ) に対し： ◎ For each fieldValue in fieldValues:

    1. %~field値 ~SET `同型に符号化する$( %~field値 ) ◎ ↓
    2. ~IF［ %~field値 ~EQ `*^bl ］ ⇒ ~RET ~F ◎ If fieldValue matches "*", or＼
    3. ~IF［ `~header~listから値を取得する$( %要請 の`~header~list$rq, %~field値 ) ~NEQ `~header~listから値を取得する$( %要請~query の`~header~list$rq, %~field値 ) 【！原文 “combined value” ~FETCH#concept-header-list-combine は、~header~listを改変するので不適切】 ］ ⇒ ~RET ~F ◎ the combined value given fieldValue and request’s header list does not match the combined value given fieldValue and requestQuery’s header list, then return false.
11. ~RET ~T ◎ Return true.

`~cache演算を~batchする@

• 入力 ⇒＃ %演算~群 — `~cache~batch演算$ ~objの`~list$, %O — `要請~応答~list$を表現する~obj【この訳による補完】 ◎ Input • operations, a list of cache batch operation objects
• 出力 ⇒＃ %結果~list — `要請~応答~list$ ◎ Output • resultList, a request response list

1. %~cache ~LET %O に`関連な要請~応答~list$ ◎ Let cache be the relevant request response list.
2. %予備~cache ~LET %~cache を`~cloneする$ ◎ Let backupCache be a new request response list that is a copy of cache.
3. %追加される~item群 ~LET 新たな`~list$ ◎ Let addedItems be an empty list.

4. この段は不可分に走らす — ただし、 手続きの中で例外が投出されたときは，この段の次の段へ進む： ◎ Try running the following substeps atomically:

   1. %結果~list ~LET 空~list ◎ Let resultList be an empty list.

   2. %演算~群 を成す ~EACH( %演算 ) に対し： ◎ For each operation in operations:

      1. ( %要請, %応答, %種別, %~option群 ) ~LET %演算 の ( `要請$cbo, `応答$cbo, `種別$cbo, `~option群$cbo ) ◎ ↓
      2. ~IF［ %種別 ~NIN { `delete^l, `put^l } ］ ⇒ ~THROW `TypeError^E ◎ If operation’s type matches neither "delete" nor "put", throw a TypeError.
      3. ~IF［ %種別 ~NEQ `delete^l ］~AND［ %応答 ~NEQ ~NULL ］ ⇒ ~THROW `TypeError^E ◎ If operation’s type matches "delete" and operation’s response is not null, throw a TypeError.
      4. ~IF［ `~cacheを~queryする$( %要請, %追加される~item群, %~option群 ) の結果は`空$でない ］ ⇒ ~THROW `InvalidStateError$E ◎ If the result of running Query Cache with operation’s request, operation’s options, and addedItems is not empty, throw an "InvalidStateError" DOMException.
      5. %要請~応答~list ~LET 新たな`~list$ ◎ Let requestResponses be an empty list.

      6. ~IF［ %種別 ~EQ `delete^l ］： ◎ If operation’s type matches "delete", then:

         1. %要請~応答~list ~SET `~cacheを~queryする$( %要請, %~cache, %~option群 ) ◎ Set requestResponses to the result of running Query Cache with operation’s request and operation’s options.
         2. %~cache から次を満たす`~item$たちを`除去する$ ⇒ `~item$ ~IN %要請~応答~list ◎ For each requestResponse in requestResponses: • Remove the item whose value matches requestResponse from cache.

      7. ~ELIF［ %種別 ~EQ `put^l ］： ◎ Else if operation’s type matches "put", then:

         1. ~IF［ %応答 ~EQ ~NULL ］ ⇒ ~THROW `TypeError^E ◎ If operation’s response is null, throw a TypeError.
         2. 【！ 's associated `要請$Rq 】 ~IF［ %要請 の`~URL$rqの`~scheme$url ~NIN { `http^l , `https^l } ］ ⇒ ~THROW `TypeError^E ◎ ↑↑Let r be operation’s request's associated request. （'s associated request は余計） ◎ If r’s url's scheme is not one of "http" and "https", throw a TypeError.
         3. ~IF［ %要請 の`~method$rq ~NEQ `GET^bl ］ ⇒ ~THROW `TypeError^E ◎ If r’s method is not `GET`, throw a TypeError.
         4. ~IF［ %演算 の`~option群$cbo ~NEQ ~NULL ］ ⇒ ~THROW `TypeError^E ◎ If operation’s options is not null, throw a TypeError.
         5. %要請~応答~list ~SET `~cacheを~queryする$( %要請, %~cache ) ◎ Set requestResponses to the result of running Query Cache with operation’s request.
         6. %~cache から次を満たす`~item$たちを`除去する$ ⇒ `~item$ ~IN %要請~応答~list ◎ For each requestResponse of requestResponses: • Remove the item whose value matches requestResponse from cache.
         7. %cache に ( %要請, %応答 ) を`付加する$ ◎ Append operation’s request/operation’s response to cache.
         8. ~IF［ 【！previous two steps？】 前~段の~cache書込n演算は、 是認されている~quota上限を超過することにより失敗した ］ ⇒ ~THROW `QuotaExceededError$E ◎ If the cache write operation in the previous two steps failed due to exceeding the granted quota limit, throw a "QuotaExceededError" DOMException.
         9. %追加される~item群 に ( %要請, %応答 ) を`付加する$ ◎ Append operation’s request/operation’s response to addedItems.
      8. %結果~list に ( %要請, %応答 ) を`付加する$ ◎ Append operation’s request/operation’s response to resultList.
   3. ~RET %結果~list ◎ Return resultList.

5. 前~段にて %例外 が投出されたときは： ◎ And then, if an exception was thrown, then:

   1. %~cache を`空にする$ ◎ Remove all the items from the relevant request response list.
   2. %予備~cache を成す ~EACH( %要請~応答 ) に対し ⇒ %~cache に %要請~応答 を`付加する$ ◎ For each requestResponse of backupCache: • Append requestResponse to the relevant request response list.
   3. ~THROW %例外 ◎ Throw the exception.

注記： 例外が投出されたときには、 実装は，［ ~batch演算~jobの間に~cache~storageに加えられた変更 ］を巻戻すことになる。 ◎ Note: When an exception is thrown, the implementation does undo (roll back) any changes made to the cache storage during the batch operation job.

`非同期c~moduleか？@

• 入力 ⇒＃ %~record — `~module~record$, %~module~map — `~module~map$, %基底 — `~URL$, %seen — `~URL$の`有順序~集合$【 ~URLの比較は、`同等な~URL$に基づくことになろう】 ◎ Input • record, a Module Record • moduleMap, a module map • base, a URL • seen, a set of URLs
• 出力 ⇒ 真偽値 ◎ Output • a boolean

1. ~IF［ %~record は`循環な~module~record$でない ］ ⇒ ~RET ~F ◎ If record is not a Cyclic Module Record, then: • Return false.
2. ~IF［ %~record . `Async^sl ~EQ ~T ］ ⇒ ~RET ~T ◎ If record.[[Async]] is true, then: • Return true.

3. %~record . `RequestedModules^sl を成す ~EACH( 文字列 %要請された~module ) に対し： ◎ For each string requested of record.[[RequestedModules]]:

   1. %~URL ~LET `~module指定子を解決する$( %基底, %要請された~module ) ◎ Let url be the result of resolving a module specifier given base and requested.
   2. ~Assert： %~URL ~NEQ `失敗^i — 前~段は、 同じ 2 個の引数で以前に成功したはずなので ◎ Assert: url is never failure, because resolving a module specifier must have been previously successful with these same two arguments.

   3. ~IF［ %~URL ~NIN %seen ］： ◎ If seen does not contain url, then:

      1. %seen に %~URL を`付加する$set ◎ Append url to seen.
      2. ~IF［ %~module~map[ %~URL ] の`~record$sC ~EQ ~NULL【！does not have】 ］ ⇒ ~RET ~F ◎ If moduleMap[url] does not have a record, then: • Return false.
      3. ~IF［ `非同期c~moduleか？$( %~module~map[ %~URL ] の`~record$sC, %~module~map, %基底, %seen ) ~EQ ~T ］ ⇒ ~RET ~T ◎ If Is Async Module for moduleMap[url]'s record, moduleMap, base, and seen is true, then: • Return true.
4. ~RET ~F ◎ Return false.

`競走~応答を検索する@

• 入力 ⇒＃ %要請 — `要請$ ◎ Input • request, a request
• 出力 ⇒ `応答$／~NULL ◎ Output • a response or null

1. %登録 ~LET ~NULL ◎ Let registration be null.

2. ~IF［ %要請 は`非~下位資源~要請$である ］： ◎ If request is a non-subresource request, then:

   1. ~IF［ %要請 の`予約-済み~client$rq ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If request’s reserved client is null, return null.
   2. %~storage~key ~LET `~storage~keyを得する$( %要請 の`予約-済み~client$rq ) ◎ Let storage key be the result of running obtain a storage key given request’s reserved client.
   3. %登録 ~SET `合致する~sw登録$( %~storage~key, %要請 の`~URL$rq ) ◎ Set registration to the result of running Match Service Worker Registration given storage key and request’s url.

3. ~ELIF［ %要請 は`下位資源~要請$である ］： ◎ Else if request is a subresource request, then:

   1. %~client ~LET %要請 の`~client$rq ◎ Let client be request’s client.
   2. ~IF［ %~client にて`作動中な~sw$enV ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If client’s active service worker is null, return null.
   3. %登録 ~SET %~client にて`作動中な~sw$enVを`包含している~sw登録$sw ◎ Set registration to client’s active service worker's containing service worker registration.
4. ~ELSE ⇒ ~RET ~NULL ◎ Otherwise, return null.
5. %作動中な~worker ~LET %登録 にて`作動中な~worker$swr ◎ Let activeWorker be registration’s active worker.
6. %~map ~LET %作動中な~worker の`大域~obj$swの`競走~応答~map$SWG ◎ Let map be activeWorker’s global object's race response map.

7. ~IF［ %~map[ %要請 ] ~NEQ ε ］： ◎ If map[request] exists, then:

   1. %競走~応答 ~LET %~map[ %要請 ] ◎ Let entry be map[request].
   2. %~map[ %要請 ] ~SET ε ◎ Remove map[request].
   3. 次が満たされるまで待機する ⇒ %競走~応答 の`値$rV ~NEQ `pending^l ◎ Wait until entry’s value is not "pending"
   4. ~IF［ %競走~応答 の`値$rVは`応答$である ］ ⇒ ~RET %競走~応答 の`値$rV ◎ If entry’s value is response, return entry’s value.
8. ~RET ~NULL ◎ Return null.

~sw~script要請

`~sw$の`~script資源$swを`~fetch$する~HTTP要請は、 次の`~header$を含めることになる： ◎ An HTTP request to fetch a service worker's script resource will include the following header:

`Service-Worker@h

この要請は`~sw$の`~script資源$sw要請であることを指示する。 ◎ Indicates this request is a service worker's script resource request.

注記： この~headerは、 ~administratorが要請を~logして，脅威を検出するのを助ける。 ◎ Note: This header helps administrators log the requests and detect threats.

~sw~script応答

`~sw$の`~script資源$sw要請に対する~HTTP応答は、 次に挙げる`~header$を含ませれる： ◎ An HTTP response to a service worker's script resource request can include the following header:

`Service-Worker-Allowed@h

~path制約を上書きするよう~UAに指示する — これは、 ~scriptに`制御-$することが許容される最大な`~scope~URL$swrを，所与の値に制限する。 ◎ Indicates the user agent will override the path restriction, which limits the maximum allowed scope url that the script can control, to the given value.

注記： この値は~URLである。 相対的~URLが与えられた場合、 それは~scriptの~URLに基づいて構文解析される。 ◎ Note: The value is a URL. If a relative URL is given, it is parsed against the script’s URL.

/* 
許容される最大な~scopeは、
既定では，~scriptが座している~path
— 次の例では `/js/^l —
になる：
◎
Maximum allowed scope defaults to the path the script sits in "/js/" in this example
 */
navigator.serviceWorker.register("/js/sw.js").then(() => {
  console.log("既定の~scope '/js/' で~installに成功しました。");
});

/* 
`Response^I に `Service-Worker-Allowed^h ~headerがないときに，~scopeを~scriptの所在の上位pathに設定する：
◎
Set the scope to an upper path of the script location Response has no Service-Worker-Allowed header
 */
navigator.serviceWorker.register("/js/sw.js", { scope: "/" }).catch(() => {
  console.error("~path制約に違反しているため、
~installに失敗しました。");
});

/* 
`Response^I に `Service-Worker-Allowed : /^bl が含まれているときに，~scopeを~script所在の上位pathに設定する：
◎
Set the scope to an upper path of the script location Response included "Service-Worker-Allowed : /"
 */
navigator.serviceWorker.register("/js/sw.js", { scope: "/" }).then(() => {
  console.log("許容される最大な~scopeは '/' に上書きされたので、
~installに成功しました。");
});

/* 
`Response^I に
`Service-Worker-Allowed : /foo^bl
が含まれているときに，~scopeを~script所在の上位pathに設定する：
◎
Set the scope to an upper path of the script location Response included "Service-Worker-Allowed : /foo"
 */
navigator.serviceWorker.register("/foo/bar/sw.js", { scope: "/" }).catch(() => {
  console.log("許容される最大な~scopeは上書きされましたが，まだ~scopeはその外にあるので、
~installに失敗しました。");
});

構文

`~sw$の`~script資源$swへの［ 要請と, 対する応答 ］により利用される~headerに与える値の `ABNF$r は： ◎ ABNF for the values of the headers used by the service worker's script resource requests and responses:

Service-Worker
	= `%x73.63.72.69.70.74^_ ; "script", 文字大小区別

注記： `Service-Worker-Allowed^h ~headerの値を検証するときには、 この~ABNFは利用されない — 検証は、 （更新-~algo内で）~URL構文解析~algoが行う。 ◎ Note: The validation of the Service-Worker-Allowed header’s values is done by URL parsing algorithm (in Update algorithm) instead of using ABNF.