Fetch

`~HTTP引用符付き文字列を収集する@ ~algoは、 所与の ( `文字列$ %入力, `位置~変数$ %位置, %値を抽出するか ~IN { `値を抽出する^i, ε } ~DF ε ) に対し： ◎ To collect an HTTP quoted string from a string input, given a position variable position and an optional boolean extract-value (default false):

1. %開始~位置 ~LET %位置 ◎ Let positionStart be position.
2. %値 ~LET 空~文字列 ◎ Let value be the empty string.
3. ~Assert： %位置↗ ~EQ `0022^U `"^smb ◎ Assert: the code point at position within input is U+0022 (").
4. %位置 ~INCBY 1 ◎ Advance position by 1.

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

   1. %値 に次の結果を付加する ⇒ %入力 内の %位置 から { `0022^U `"^smb, `005C^U `\^smb } 以外の`符号位置~並びを収集する$ ◎ Append the result of collecting a sequence of code points that are not U+0022 (") or U+005C (\) from input, given position, to value.
   2. ~Assert： %位置↗ ~IN { ε, `0022^U `"^smb, `005C^U `\^smb } ◎ If position is past the end of input, then break.

   3. ~IF［ %位置↗ ~EQ `005C^U `\^smb ］：

      1. %位置 ~INCBY 1
      2. ~IF［ %位置↗ ~NEQ ε ］ ⇒＃ %値 に %位置↗ を付加する； %位置 ~INCBY 1； ~CONTINUE
      3. %値 に `005C^U `\^smb を付加する
      ◎ Let quoteOrBackslash be the code point at position within input. ◎ Advance position by 1. ◎ If quoteOrBackslash is U+005C (\), then: • If position is past the end of input, then append U+005C (\) to value and break. • Append the code point at position within input to value. • Advance position by 1.
   4. ~IF［ %位置↗ ~NEQ ε ］ ⇒ %位置 ~INCBY 1 ◎ ↑↓
   5. ~BREAK ◎ Otherwise: • Assert: quoteOrBackslash is U+0022 ("). • Break.
6. ~IF［ %値を抽出するか ~EQ `値を抽出する^i ］ ⇒ ~RET %値 ◎ If extract-value is true, then return value.
7. ~RET %入力 の中の［ %開始~位置 から ( %位置 ~MINUS 1 ) まで ］を成す`符号位置$並び 【！inclusive は先頭のみ（例：この時点で %位置↗ は ε かもしれない）】 ◎ Return the code points from positionStart to position, inclusive, within input.

`~fetch~groupを終了する@ ~algoは、 所与の ( `~fetch~group$ %G ) に対し ⇒ %G を成す ~EACH( `~fetch記録$ %記録 ) に対し ⇒ ~IF［ %記録 の`制御器$fR ~NEQ ~NULL ］ ⇒ ~IF［ %記録 の`要請$fRは［［ `済んだか$rq ~EQ ~F ］~OR［ `~keepaliveか$rq ~EQ ~F ］］を満たす ］ ⇒ `~fetchを終了する$( %記録 の`制御器$fR ) ◎ When a fetch group is terminated, for each associated fetch record whose fetch record’s controller is non-null, and whose request’s done flag is unset or keepalive is false, terminate the fetch record’s controller.

◎追跡路 `生成元を解決する@ ~algoは、 所与の ( `~network区分~key$ %~key, `生成元$ %生成元 ) に対し： ◎ (This is a tracking vector.) To resolve an origin, given a network partition key key and an origin origin:

1. %~host ~LET %生成元 の`~host$o ◎ ↓
2. ~IF［ %~host は`~IP~address$である ］ ⇒ ~RET « %~host » ◎ If origin’s host is an IP address, then return « origin’s host ».
3. ~IF［ %~host の`公共~接尾辞$ ~IN { `localhost^l, `localhost.^l } ］ ⇒ ~RET « `::1^c, `127.0.0.1^c » 【順に，~IPv6, ~IPv4用の~loopback~address】 ◎ If origin’s host’s public suffix is "localhost" or "localhost.", then return « ::1, 127.0.0.1 ».

4. %生成元 を［ 1 個~以上の`~IP~address$たちが成す`集合$ ］に転換する`実装定義$な演算を遂行する ◎ Perform an implementation-defined operation to turn origin into a set of one or more IP addresses.

   加えて、 `~IP~address$を超える接続~情報を取得するために，他の`実装定義$な演算を遂行してもよい。 例えば， %生成元 の`~scheme$oは`~HTTP_S~scheme$である場合、 実装は，~HTTPS-RR【~HTTPS資源~record】 `SVCB$r 用の~DNS~queryを遂行することもあろう。 ◎ It is also implementation-defined whether other operations might be performed to get connection information beyond just IP addresses. For example, if origin’s scheme is an HTTP(S) scheme, the implementation might perform a DNS query for HTTPS RRs. [SVCB]

5. ~IF［ 前~段の演算は成功した ］ ⇒ ~RET 結果の集合と追加的な`実装定義$な情報 ◎ If this operation succeeds, return the set of IP addresses and any additional implementation-defined information.
6. ~RET `失敗^i ◎ Return failure.

`生成元を解決-$した結果は~cacheしてもヨイ — ~cacheした場合、 %~key を~cache~keyの一部として利用するベキである。 ◎ The results of resolve an origin may be cached. If they are cached, key should be used as part of the cache key.

`接続~計時~報を切詰めて粗化する@ ~algoは、 所与の ( `接続~計時~報$ %計時~報, `DOMHighResTimeStamp$I %既定の開始~時刻, 真偽値 %非同一-生成元~能力は隔離されるか ) に対し： ◎ To clamp and coarsen connection timing info, given a connection timing info timingInfo, a DOMHighResTimeStamp defaultStartTime, and a boolean crossOriginIsolatedCapability, run these steps:

1. ~IF［ %計時~報 の`接続~開始~時刻$cT ~LT %既定の開始~時刻 ］ ⇒ ~RET 新たな`接続~計時~報$ — その ⇒＃ `~domain検索~開始~時刻$cT ~SET %既定の開始~時刻, `~domain検索~終了~時刻$cT ~SET %既定の開始~時刻, `接続~開始~時刻$cT ~SET %既定の開始~時刻, `接続~終了~時刻$cT ~SET %既定の開始~時刻, `~secure接続~開始~時刻$cT ~SET %既定の開始~時刻, `折衝した~ALPN~protocol~ID$cT ~SET %計時~報 の`折衝した~ALPN~protocol~ID$cT ◎ If timingInfo’s connection start time is less than defaultStartTime, then return a new connection timing info whose domain lookup start time is defaultStartTime, domain lookup end time is defaultStartTime, connection start time is defaultStartTime, connection end time is defaultStartTime, secure connection start time is defaultStartTime, and ALPN negotiated protocol is timingInfo’s ALPN negotiated protocol.
2. ~RET 新たな`接続~計時~報$ — その ⇒＃ `~domain検索~開始~時刻$cT ~SET `時刻を粗化する$( %計時~報 の`~domain検索~開始~時刻$cT, %非同一-生成元~能力は隔離されるか ), `~domain検索~終了~時刻$cT ~SET `時刻を粗化する$( %計時~報 の`~domain検索~終了~時刻$cT, %非同一-生成元~能力は隔離されるか ), `接続~開始~時刻$cT ~SET `時刻を粗化する$( %計時~報 の`接続~開始~時刻$cT, %非同一-生成元~能力は隔離されるか ), `接続~終了~時刻$cT ~SET `時刻を粗化する$( %計時~報 の`接続~終了~時刻$cT, %非同一-生成元~能力は隔離されるか ), `~secure接続~開始~時刻$cT ~SET `時刻を粗化する$( %計時~報 の`接続~終了~時刻$cT, %非同一-生成元~能力は隔離されるか ), `折衝した~ALPN~protocol~ID$cT ~SET %計時~報 の`折衝した~ALPN~protocol~ID$cT ◎ Return a new connection timing info whose domain lookup start time is the result of coarsen time given timingInfo’s domain lookup start time and crossOriginIsolatedCapability, domain lookup end time is the result of coarsen time given timingInfo’s domain lookup end time and crossOriginIsolatedCapability, connection start time is the result of coarsen time given timingInfo’s connection start time and crossOriginIsolatedCapability, connection end time is the result of coarsen time given timingInfo’s connection end time and crossOriginIsolatedCapability, secure connection start time is the result of coarsen time given timingInfo’s connection end time and crossOriginIsolatedCapability, and ALPN negotiated protocol is timingInfo’s ALPN negotiated protocol.

`接続を得する@ ~algoは、 所与の ⇒＃ `~network区分~key$ %~key, `~URL$ %~URL, 真偽値 %資格証を伴うか, `新たな接続~用の設定$ %新たな ~DF `no^l, 真偽値 `不依拠-可能を要求するか@i ~DF ~F ◎終 に対し： ◎ To obtain a connection, given a network partition key key, URL url, boolean credentials, an optional new connection setting new (default "no"), and an optional boolean requireUnreliable (default false), run these steps:

1. ~IF［ %新たな ~EQ `no^l ］： ◎ If new is "no", then:

   1. %接続~群 ~LET ~UAの`接続~pool$を成す`接続$のうち，次を満たすものたちが成す集合 ⇒ ( `~key$cN, `生成元$cN, `資格証を伴うか$cN ) ~EQ ( %~key, %~URL の`生成元$url, %資格証を伴うか ) ◎ Let connections be a set of connections in the user agent’s connection pool whose key is key, origin is url’s origin, and credentials is credentials.

   2. ~IF［ %接続~群 は空でない ］：

      1. ~IF［ %不依拠-可能を要求するか ~EQ ~F ］ ⇒ ~RET %接続~群 の中の どれか一つ
      2. ~IF［ %接続~群 を成す ある`接続$は、 `不依拠-可能$な~transportを~supportする能力がある （例：~HTTP3） ］ ⇒ ~RET そのようないずれかの`接続$
      ◎ If connections is not empty and requireUnreliable is false, then return one of connections. ◎ If there is a connection capable of supporting unreliable transport in connections, e.g., HTTP/3, then return that connection.

2. %~proxy群 ~LET %~URL 用の~proxyたちを`実装定義$な方式で見出した結果 — 無い場合は « `DIRECT^l » ◎ Let proxies be the result of finding proxies for url in an implementation-defined manner. If there are no proxies, let proxies be « "DIRECT" ».

   注記： ここは、 標準でない技術 — `Web Proxy Auto-Discovery Protocol (WPAD)＠~WIKIPEDIA/Web_Proxy_Auto-Discovery_Protocol$en, `proxy auto-config (PAC)＠~WIKIPEDIA/Proxy_auto-config$en など — が絡んでくる所である。 `DIRECT^l 値は、 この特定0の %~URL 用には~proxyを利用しないことを意味する。 ◎ This is where non-standard technology such as Web Proxy Auto-Discovery Protocol (WPAD) and proxy auto-config (PAC) come into play. The "DIRECT" value means to not use a proxy for this particular url.

3. %計時~報 ~LET 新たな`接続~計時~報$ ◎ Let timingInfo be a new connection timing info.

4. %~proxy群 を成す ~EACH( %~proxy ) に対し： ◎ For each proxy of proxies:

   1. %計時~報 の`~domain検索~開始~時刻$cT ~SET `安全でない共有される現在の時刻$ ◎ Set timingInfo’s domain lookup start time to the unsafe shared current time.
   2. %~host群 ~LET « %~URL の`生成元$urlの`~host$o » ◎ Let hosts be « url’s origin’s host ».
   3. ~IF［ %~proxy ~EQ `DIRECT^l ］ ⇒ %~host群 ~SET `生成元を解決する$( %~key, %~URL の`生成元$url ) ◎ If proxy is "DIRECT", then set hosts to the result of running resolve an origin given key and url’s origin.
   4. ~IF［ %~host群 ~EQ `失敗^i ］ ⇒ ~CONTINUE ◎ If hosts is failure, then continue.
   5. %計時~報 の`~domain検索~終了~時刻$cT ~SET `安全でない共有される現在の時刻$ ◎ Set timingInfo’s domain lookup end time to the unsafe shared current time.

   6. %接続 ~LET 次に従って得られる`接続$： ◎ Let connection be the result of running this step:＼

      • 次を — `実装定義$な回数だけ，互いに`並列的$に — 走らす ⇒ `接続を作成する$( ↓ ) ⇒＃ %~key, %~URL の`生成元$url, %資格証, %~proxy, %~host群 の中から`実装定義$に選ばれた`~host$, %計時~報, %不依拠-可能を要求するか ◎ run create a connection given key, url’s origin, credentials, proxy, an implementation-defined host from hosts, timingInfo, and requireUnreliable an implementation-defined number of times, in parallel from each other,＼
      • 前項にて走らせた 少なくとも一つが値を返すまで待機した上で、 返された値たちから，`実装定義$な方式で一つを選定する — 他の値のうち`接続$である（ `失敗^i でない）ものは、 ~closeしてもヨイ。 ◎ and wait for at least 1 to return a value.＼ In an implementation-defined manner, select a value to return from the returned values and return it.＼ Any other returned values that are connections may be closed.

      注記： この段は、 本質的には，［ `生成元を解決-$した結果から， 1 個以上の`~IP~address$を選び取ること ］を実装に許容する （ %~proxy ~EQ `DIRECT^l と見做すなら） — ［ それらを互いに競争させる, `~IPv6~address$を選り好む, 時間切れの事例では試行し直す, 等々 ］の下で。 ◎ Essentially this allows an implementation to pick one or more IP addresses from the return value of resolve an origin (assuming proxy is "DIRECT") and race them against each other, favor IPv6 addresses, retry in case of a timeout, etc.

   7. ~IF［ %接続 ~EQ `失敗^i ］ ⇒ ~CONTINUE ◎ If connection is failure, then continue.
   8. ~IF［ %新たな ~NEQ `yes-and-dedicated^l ］ ⇒ ~UAの`接続~pool$に %接続 を`付加する$set ◎ If new is not "yes-and-dedicated", then append connection to the user agent’s connection pool.
   9. ~RET %接続 ◎ Return connection.
5. ~RET `失敗^i ◎ Return failure.

注記： これは，意図的にやや曖昧にされている — 接続~管理に関して，たくさんの意味合いがあり、 実装者の裁量に委ねるのが最善なので。 これを述べることは、 `link rel=preconnect^e による特能を説明する助けになることに加え， `接続$は `資格証を伴うか$cN 別に分けられることを明瞭に~~規定する。 後者は、 例えば，~TLS~session識別子が［ `資格証を伴うか$cNが互いに異なる`接続$たち ］にまたがって再利用されないことを明確化する。 ◎ This is intentionally a little vague as there are a lot of nuances to connection management that are best left to the discretion of implementers. Describing this helps explain the <link rel=preconnect> feature and clearly stipulates that connections are keyed on credentials. The latter clarifies that, e.g., TLS session identifiers are not reused across connections whose credentials are false with connections whose credentials are true.

`接続を作成する@ ~algoは、 所与の ⇒＃ `~network区分~key$ %~key, `生成元$ %生成元, 真偽値 %資格証, 文字列 %~proxy, `~host$ %~host, `接続~計時~報$ %計時~報, 真偽値 %不依拠-可能を要求するか, ◎終 に対し： ◎ To create a connection, given a network partition key key, origin origin, boolean credentials, string proxy, host host, connection timing info timingInfo, and boolean requireUnreliable, run these steps:

1. %計時~報 の`接続~開始~時刻$cT ~SET `安全でない共有される現在の時刻$ ◎ Set timingInfo’s connection start time to the unsafe shared current time.
2. %接続 ~LET 新たな`接続$ — その ⇒＃ `~key$cN ~SET %~key, `生成元$cN ~SET %生成元, `資格証を伴うか$cN ~SET %資格証, `計時~報$ ~SET %計時~報 ◎ Let connection be a new connection whose key is key, origin is origin, credentials is credentials, and timing info is timingInfo.＼

3. 次に挙げる各~条項に従う下で、 %接続 を利用して, ［ %~proxy, %生成元 ］も織り込んで, %~host への~HTTP接続を確立する `HTTP$r `HTTP1$r `TLS$r — それに伴い、 %接続 に対し`接続~計時~報を記録する$： ◎ Record connection timing info given connection and use connection to establish an HTTP connection to host, taking proxy and origin into account, with the following caveats: [HTTP] [HTTP1] [TLS]

   • ［ %不依拠-可能を要求するか ~EQ ~T ］の場合、 `不依拠-可能$な~transport能力がある接続（例：~HTTP3 `HTTP3$r ）を確立する — そうするときは、 ~WebTransport用に必要yな~optionを可能化する ◎ If requireUnreliable is true, then establish a connection capable of unreliable transport, e.g., an HTTP/3 connection. [HTTP3] ◎ When establishing a connection capable of unreliable transport, enable options that are necessary for WebTransport.＼

     ~HTTP3用には、 このことは，初期 `SETTINGS＠~HTTPv3#frame-settings$ft ~frame内に次を内包することを意味する：

     • 1 を値に伴う `SETTINGS_ENABLE_WEBTRANSPORT^sp `WEBTRANSPORT-HTTP3$r 【 `SETTINGS_WEBTRANSPORT_MAX_SESSIONS^sp に`置換され＠https://github.com/ietf-wg-webtrans/draft-ietf-webtrans-http3/commit/36d915d36e5abf568f4a6cf6e92c8fa8151602a5$，その後 `SETTINGS_WT_MAX_SESSIONS＠~WT-HTTP3#SETTINGS_WT_MAX_SESSIONS$sp に改称された。】
     • 1 を値に伴う `SETTINGS_H3_DATAGRAM＠~HTTPdatagram#setting$sp【！H3_DATAGRAM】 `HTTP3-DATAGRAM$r

     ◎ For HTTP/3, this means including SETTINGS_ENABLE_WEBTRANSPORT with a value of 1 and H3_DATAGRAM with a value of 1 in the initial SETTINGS frame. [WEBTRANSPORT-HTTP3] [HTTP3-DATAGRAM]
   • ［ %資格証を伴うか ~EQ ~F ］の場合、 ~TLS~client証明書は送信しない ◎ If credentials is false, then do not send a TLS client certificate.
4. ~IF［ 前~段にて接続を確立するのに失敗した （例：［ ~UDP／~TCP／~TLS ］の~error） ］ ⇒ ~RET `失敗^i ◎ If establishing a connection does not succeed (e.g., a UDP, TCP, or TLS error), then return failure.

5. %計時~報 の`折衝した~ALPN~protocol~ID$cT ~SET 次に挙げる各~条項に従う下で得られた %接続 の~ALPN~protocol~ID `RFC7301$r： ◎ Set timingInfo’s ALPN negotiated protocol to connection’s ALPN Protocol ID, with the following caveats: [RFC7301]

   • ~proxyが環境設定されているときは ⇒＃ ~tunnel接続が確立された場合、~tunnelされた~protocolの~ALPN~protocol~IDになるモノトスル／ 他の場合、~proxyへの最初の~hopの~ALPN~protocol~IDになるモノトスル ◎ When a proxy is configured, if a tunnel connection is established then this must be the ALPN Protocol ID of the tunneled protocol, otherwise it must be the ALPN Protocol ID of the first hop to the proxy.

   • ~UAが試験的な未登録な~protocolを利用している事例では、 ~protocol折衝~用に~ALPN~protocol~IDが ⇒＃ 利用されたならば、それを利用するモノトスル／ 利用されなかったならば、別の記述的な文字列を利用してもヨイ ◎ In case the user agent is using an experimental, non-registered protocol, the user agent must use the used ALPN Protocol ID, if any. If ALPN was not used for protocol negotiations, the user agent may use another descriptive string.

     注記： %計時~報 の`折衝した~ALPN~protocol~ID$cTは、 利用-中にある~network~protocolを識別するために意図される — それが実際にどう折衝されたかに関わらず。 すなわち，~ALPNが当の~network~protocolを折衝するために利用されていない場合でも、 これは，利用-中にある~protocolを指示する~ALPN~protocol~IDになる。 ◎ timingInfo’s ALPN negotiated protocol is intended to identify the network protocol in use regardless of how it was actually negotiated; that is, even if ALPN is not used to negotiate the network protocol, this is the ALPN Protocol IDs that indicates the protocol in use.

   注記： ~IANAは、 `~ALPN~protocol~IDたちが成す~list＠~IANA-a/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids$を保守する。 ◎ IANA maintains a list of ALPN Protocol IDs.

6. ~RET %接続 ◎ Return connection.

`~network区分~keyを決定する@ ~algoは、 所与の ( `環境$ %環境 ) に対し： ◎ To determine the network partition key, given an environment environment:

1. %~top-level生成元 ~LET %環境 の`~top-level生成元$enV ◎ Let topLevelOrigin be environment’s top-level origin.
2. ~IF［ %~top-level生成元 ~EQ ~NULL ］ ⇒ %~top-level生成元 ~SET %環境 の`~top-level作成時の~URL$enVの`生成元$url ◎ If topLevelOrigin is null, then set topLevelOrigin to environment’s top-level creation URL’s origin.
3. ~Assert： %~top-level生成元 は`生成元$である ◎ Assert: topLevelOrigin is an origin.
4. %~top-level~site ~LET `~siteを得する$( %~top-level生成元 ) ◎ Let topLevelSite be the result of obtaining a site, given topLevelOrigin.

5. %第二~key ~LET ~NULL または`実装定義$な値 ◎ Let secondKey be null or an implementation-defined value.

   第二~keyは、 意図的に少し曖昧にされている — より精緻な点で、 依然として発展しているので。 `課題 #1035＠https://github.com/whatwg/fetch/issues/1035$ を見よ。 ◎ The second key is intentionally a little vague as the finer points are still evolving. See issue #1035.

6. ~RET ( %~top-level~site, %第二~key ) ◎ Return (topLevelSite, secondKey).

`要請の~network区分~keyを決定する@ ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To determine the network partition key, given a request request:

1. ~IF［ %要請 の`予約-済み~client$rq ~NEQ ~NULL ］ ⇒ ~RET `~network区分~keyを決定する$( %要請 の`予約-済み~client$rq ) ◎ If request’s reserved client is non-null, then return the result of determining the network partition key given request’s reserved client.
2. ~IF［ %要請 の`~client$rq ~NEQ ~NULL ］ ⇒ ~RET `~network区分~keyを決定する$( %要請 の`~client$rq ) ◎ If request’s client is non-null, then return the result of determining the network partition key given request’s client.
3. ~RET ~NULL ◎ Return null.

`~HTTP~cache区分を決定する@ ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To determine the HTTP cache partition, given a request request:

1. %~key ~LET `要請の~network区分~keyを決定する$( %要請 ) ◎ Let key be the result of determining the network partition key given request.
2. ~IF［ %~key ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If key is null, then return null.
3. ~RET %~key に結付けられた一意な~HTTP~cache `HTTP-CACHING$r ◎ Return the unique HTTP cache associated with key. [HTTP-CACHING]

`要請の~fetchingは，不良~portに因り阻止されるべきか？@ どうか決定するときは、 所与の ( `要請$ %要請 ) に対し： ◎ To determine whether fetching a request request should be blocked due to a bad port:

1. %~URL ~LET %要請 の`現在の~URL$rq ◎ Let url be request’s current URL.
2. ~IF［ %~URL の`~scheme$urlは`~HTTP_S~scheme$である ］~AND［ %~URL の`~port$urlは`不良~port$である ］ ⇒ ~RET `阻止される^i ◎ If url’s scheme is an HTTP(S) scheme and url’s port is a bad port, then return blocked.
3. ~RET `許容される^i ◎ Return allowed.

この~algoは、 所与の ( `要請$ %要請, `応答$ %応答 ) に対し： ◎ Run these steps:

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

2. ~RET［ ~AND↓ が満たされるならば `阻止される^i ／ ~ELSE_ `許容される^i ］：

   • %要請 の`行先$rqは`~scriptに類する$
   • %~MIME型 ~NEQ `失敗^i
   • %~MIME型 の`~essence$ %~essence は、 次を満たす ⇒ ［ %~essence は［ `audio/^l, `image/^l, `video/^l ］いずれか`から開始して$いる ］~OR［ %~essence ~EQ `text/csv^l ］
   ◎ If mimeType is failure, then return allowed. ◎ Let destination be request’s destination. ◎ If destination is script-like and one of the following is true, then return blocked: • mimeType’s essence starts with "audio/", "image/", or "video/". • mimeType’s essence is "text/csv". ◎ Return allowed.

`要請~Origin~headerを付加する@ ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To append a request `Origin` header, given a request request, run these steps:

1. ~Assert： %要請 の`生成元$rq ~NEQ `client^l ◎ Assert: request’s origin is not "client".
2. %直列化した生成元 ~LET `要請の生成元を~byte直列化する$( %要請 ) ◎ Let serializedOrigin be the result of byte-serializing a request origin with request.

3. ~IF［ %要請 の`応答~tainting$rq ~EQ `cors^l ］~OR［ %要請 の`~mode$rq ~EQ `websocket^l ］：

   1. %要請 の`~header~list$rqに`~headerを付加する$( ( `Origin^h, %直列化した生成元 ) )
   2. ~RET
   ◎ If request’s response tainting is "cors" or request’s mode is "websocket", then append (`Origin`, serializedOrigin) to request’s header list.
4. ~IF［ %要請 の`~method$rq ~IN { `GET$hm, `HEAD$hm } ］ ⇒ ~RET ◎ Otherwise, if request’s method is neither `GET` nor `HEAD`, then:

5. ~IF［ %要請 の`~mode$rq ~NEQ `cors^l ］： ◎ If request’s mode is not "cors",＼

   1. %要請 の`~referrer施策$rqに応じて： ◎ then switch on request’s referrer policy:

      `no-referrer^l

      %直列化した生成元 ~SET `null^bl ◎ Set serializedOrigin to `null`.

      `no-referrer-when-downgrade^l

      `strict-origin^l

      `strict-origin-when-cross-origin^l

      ~IF［ %要請 の`生成元$rqは`成分組~生成元$である ］~AND［ %要請 の`生成元$rqの`~scheme$o【！ its %~scheme】 ~EQ `https^l ］~AND［ %要請 の`現在の~URL$rqの`~scheme$url【！%~scheme】 ~NEQ `https^l ］ ⇒ %直列化した生成元 ~SET `null^bl ◎ If request’s origin is a tuple origin, its scheme is "https", and request’s current URL’s scheme is not "https", then set serializedOrigin to `null`.

      `same-origin^l

      ~IF［ %要請 の`生成元$rq ~NEQ`生成元$sub %要請 の`現在の~URL$rqの`生成元$url ］ ⇒ %直列化した生成元 ~SET `null^bl ◎ If request’s origin is not same origin with request’s current URL’s origin, then set serializedOrigin to `null`.

      その他 ◎ Otherwise

      何もしない ◎ Do nothing.

6. %要請 の`~header~list$rqに`~headerを付加する$( ( `Origin^h, %直列化した生成元 ) ) ◎ Append (`Origin`, serializedOrigin) to request’s header list.

注記： `要請$の`~referrer施策$rqは、 すべての~fetchに織り込まれる — ~fetch側が明示的に自身の`生成元$を~serverと共有するよう （例えば`~CORS~protocol$の利用を介して）~opt-inしていなくとも。 ◎ A request’s referrer policy is taken into account for all fetches where the fetcher did not explicitly opt into sharing their origin with the server, e.g., via using the CORS protocol.

`~header~listから長さを抽出する@ ~algoは、 所与の ( `~header~list$ %~header群 ) に対し： ◎ To extract a length from a header list headers, run these steps:

1. %値~群 ~LET `~header~listから値を取得して復号して分割する$( %~header群, `Content-Length^h ) ◎ Let values be the result of getting, decoding, and splitting `Content-Length` from headers.
2. ~IF［ %値~群 ~EQ ~NULL ］ ⇒ ~RET ~NULL ◎ If values is null, then return null.
3. %候補~値 ~LET ~NULL ◎ Let candidateValue be null.

4. %値~群 を成す ~EACH( %値 ) に対し： ◎ For each value of values:

   1. ~IF［ %候補~値 ~EQ ~NULL ］ ⇒ %候補~値 ~SET %値 ◎ If candidateValue is null, then set candidateValue to value.
   2. ~ELIF［ %値 ~NEQ %候補~値 ］ ⇒ ~RET `失敗^i ◎ Otherwise, if value is not candidateValue, return failure.
5. ~IF［ %候補~値 ~EQ 空~文字列 ］~OR［ %候補~値 内に`~ASCII数字$でない`文字$がある ］ ⇒ ~RET ~NULL ◎ If candidateValue is the empty string or has a code point that is not an ASCII digit, then return null.
6. ~RET %候補~値 を 10 進数として解釈した結果 ◎ Return candidateValue, interpreted as decimal number.

`~header~listから~MIME型を抽出する@ ~algoは、 所与の ( `~header~list$ %~headerたち ) に対し，［ `失敗^i ／`~MIME型$ ］を返す： ◎ To extract a MIME type from a header list headers, run these steps. They return failure or a MIME type.

1. %~charset ~LET ~NULL ◎ Let charset be null.
2. %~essence ~LET ~NULL ◎ Let essence be null.
3. %~MIME型 ~LET ~NULL ◎ Let mimeType be null.
4. %値~群 ~LET `~header~listから値を取得して復号して分割する$( %~headerたち, `Content-Type$h ) ◎ Let values be the result of getting, decoding, and splitting `Content-Type` from headers.
5. ~IF［ %値~群 ~EQ ~NULL ］ ⇒ ~RET `失敗^i ◎ If values is null, then return failure.

6. %値~群 を成す ~EACH( %値 ) に対し： ◎ For each value of values:

   1. %一時的~MIME型 ~LET `~MIME型を構文解析する$( %値 ) ◎ Let temporaryMimeType be the result of parsing value.
   2. ~IF［ %一時的~MIME型 ~EQ `失敗^i ］~OR［ %一時的~MIME型 の`~essence$ ~EQ `*/*^l ］ ⇒ ~CONTINUE ◎ If temporaryMimeType is failure or its essence is "*/*", then continue.
   3. %~MIME型 ~SET %一時的~MIME型 ◎ Set mimeType to temporaryMimeType.
   4. %~parameter群 ~LET %~MIME型 の`~parameter群$ ◎ ↓

   5. ~IF［ %~MIME型 の`~essence$ ~NEQ %~essence ］： ◎ If mimeType’s essence is not essence, then:

      1. %~charset ~SET ~NULL ◎ Set charset to null.
      2. ~IF［ %~parameter群[ `charset^l ] ~NEQ ε ］ ⇒ %~charset ~SET %~parameter群[ `charset^l ] ◎ If mimeType’s parameters["charset"] exists, then set charset to mimeType’s parameters["charset"].
      3. %~essence ~SET %~MIME型 の`~essence$ ◎ Set essence to mimeType’s essence.
   6. ~ELIF［ %~parameter群[ `charset^l ] ~EQ ε ］~AND［ %~charset ~NEQ ~NULL ］ ⇒ %~parameter群[ `charset^l ] ~SET %~charset ◎ Otherwise, if mimeType’s parameters["charset"] does not exist, and charset is non-null, set mimeType’s parameters["charset"] to charset.
7. ~IF［ %~MIME型 ~EQ ~NULL ］ ⇒ ~RET `失敗^i ◎ If mimeType is null, then return failure.
8. ~RET %~MIME型 ◎ Return mimeType.

`~header~listから~MIME型を抽出する$から返された結果が［ `失敗^i の場合／ `~MIME型$であって， その`~essence$は所与の内容形式~用には不正である場合 ］、 致命的な~errorとして扱う。 既存の~web~platform特能は、 この~patternに常に従ってはいなかった — それは、 長年にわたり，それらの特能における~security脆弱性を成す大多数の~sourceであった。 対照的に，`~MIME型$の`~parameter群$は、 概して安全に無視できる。 ◎ When extract a MIME type returns failure or a MIME type whose essence is incorrect for a given format, treat this as a fatal error. Existing web platform features have not always followed this pattern, which has been a major source of security vulnerabilities in those features over the years. In contrast, a MIME type’s parameters can typically be safely ignored.

`旧来~用に符号化法を抽出する@ ~algoは、 所与の ( ［ `失敗^i ／`~MIME型$ ］ %~MIME型, `符号化法$ %~fallback符号化法 ) に対し： ◎ To legacy extract an encoding given failure or a MIME type mimeType and an encoding fallbackEncoding, run these steps:

1. ~IF［ %~MIME型 ~EQ `失敗^i ］ ⇒ ~RET %~fallback符号化法 ◎ If mimeType is failure, then return fallbackEncoding.
2. %~label ~LET %~MIME型 【の`~parameter群$】[ `charset^l ] ◎ ↓
3. ~IF［ %~label ~EQ ε ］ ⇒ ~RET %~fallback符号化法 ◎ If mimeType["charset"] does not exist, then return fallbackEncoding.
4. %符号化法 ~LET `~labelから符号化法を取得する$( %~label ) ◎ Let tentativeEncoding be the result of getting an encoding from mimeType["charset"].
5. ~IF［ %符号化法 ~EQ `失敗^i ］ ⇒ ~RET %~fallback符号化法 ◎ If tentativeEncoding is failure, then return fallbackEncoding.
6. ~RET %符号化法 ◎ Return tentativeEncoding.

注記： この~algoは、 `~header~listから~MIME型を抽出する$~algoと容易に組合できるよう， %~MIME型 として `失敗^i も許容する。 “旧来” と表記されているのは、 現代の形式は，`~UTF-8$encを排他的に利用するからである。 ◎ This algorithm allows mimeType to be failure so it can be more easily combined with extract a MIME type. ◎ It is denoted as legacy as modern formats are to exclusively use UTF-8.

`~nosniffかどうか決定する@ ~algoは、 所与の ( `~header~list$ %~list ) に対し： ◎ To determine nosniff, given a header list list, run these steps:

1. %値~群 ~LET `~header~listから値を取得して復号して分割する$( %~list, `X-Content-Type-Options$h ) ◎ Let values be the result of getting, decoding, and splitting `X-Content-Type-Options` from list.
2. ~IF［ %値~群 ~EQ ~NULL ］ ⇒ ~RET ~F ◎ If values is null, then return false.
3. ~IF［ %値~群[ 0 ] は `nosniff^l に`~ASCII大小無視$で合致する ］ ⇒ ~RET ~T ◎ If values[0] is an ASCII case-insensitive match for "nosniff", then return true.
4. ~RET ~F ◎ Return false.

`非同一-生成元~資源~施策~検査@ を遂行する ~algoは、 所与の ⇒＃ `生成元$【！`生成元$url】 %生成元, `環境~設定群~obj$ %設定群~obj, 文字列 %行先, `応答$ %応答, 真偽値 %~navi用か ~DF ~F ◎終 に対し： ◎ To perform a cross-origin resource policy check, given an origin origin, an environment settings object settingsObject, a string destination, a response response, and an optional boolean forNavigation, run these steps: • Set forNavigation to false if it is not given.

1. %埋込元~施策 ~LET %設定群~obj の`施策~容器$enVの`埋込元~施策$pC ◎ Let embedderPolicy be settingsObject’s policy container’s embedder policy.

2. ~IF［ `非同一-生成元~資源~施策~内部~検査$( %生成元, `unsafe-none$l, %応答, %~navi用か ) ~EQ `阻止される^i ］ ⇒ ~RET `阻止される^i ◎ If the cross-origin resource policy internal check with origin, "unsafe-none", response, and forNavigation returns blocked, then return blocked.

   注記： この段が必要になるのは、 下に与える非同一-生成元~埋込元~施策に関係しない違反は， 報告するよう求まれないからである。 ◎ This step is needed because we don’t want to report violations not related to Cross-Origin Embedder Policy below.

3. ~IF［ `非同一-生成元~資源~施策~内部~検査$( %生成元 , %埋込元~施策 の`報告のみの値$embP, %応答, %~navi用か ) ~EQ `阻止される^i ］ ⇒ `非同一-生成元~埋込元~施策~CORP違反~報告を~queueする$( %応答, %設定群~obj, %行先, ~T ) ◎ If the cross-origin resource policy internal check with origin, embedderPolicy’s report only value, response, and forNavigation returns blocked, then queue a cross-origin embedder policy CORP violation report with response, settingsObject, destination, and true.
4. ~IF［ `非同一-生成元~資源~施策~内部~検査$( %生成元, %埋込元~施策 の`値$embP, %応答, %~navi用か ) ~EQ `許容される^i ］ ⇒ ~RET `許容される^i ◎ If the cross-origin resource policy internal check with origin, embedderPolicy’s value, response, and forNavigation returns allowed, then return allowed.
5. `非同一-生成元~埋込元~施策~CORP違反~報告を~queueする$( %応答, %設定群~obj, %行先, ~F ) ◎ Queue a cross-origin embedder policy CORP violation report with response, settingsObject, destination, and false.
6. ~RET `阻止される^i ◎ Return blocked.

注記： ~HTMLの`~navi~algo$に限り，この検査を %~navi用か に ~T を与える下で利用する — それはまた、 入子な【`子~navigable$に対する】~navi用には，常に この検査を利用する。 他の場合、 %応答 は［ `不透明な絞込み応答$の`内部~応答$か，そうなるもの ］になる。 `HTML$r ◎ Only HTML’s navigate algorithm uses this check with forNavigation set to true, and it’s always for nested navigations. Otherwise, response is either the internal response of an opaque filtered response or a response which will be the internal response of an opaque filtered response. [HTML]

`非同一-生成元~資源~施策~内部~検査@ を遂行する ~algoは、 所与の ⇒＃ `生成元$【！`生成元$url】 %生成元, `埋込元~施策~値$ %埋込元~施策~値, `応答$ %応答, 真偽値 %~navi用か ◎終 に対し： ◎ To perform a cross-origin resource policy internal check, given an origin origin, an embedder policy value embedderPolicyValue, a response response, and a boolean forNavigation, run these steps:

1. ~IF［ %~navi用か ~EQ ~T ］~AND［ %埋込元~施策~値 ~EQ `unsafe-none$l ］ ⇒ ~RET `許容される^i ◎ If forNavigation is true and embedderPolicyValue is "unsafe-none", then return allowed.

2. %施策 ~LET `~header~listから値を取得する$( %応答 の`~header~list$rs, `Cross-Origin-Resource-Policy$h ) ◎ Let policy be the result of getting `Cross-Origin-Resource-Policy` from response’s header list.

   注記： `Cross-Origin-Resource-Policy: same-site, same-origin^bl にされた場合、［ %埋込元~施策~値 ~EQ `unsafe-none$l【すなわち ~NEQ `require-corp$l 】 ］である限り，以下において %施策 が何かに合致することは決してないので， `許容される^i を返すことになる。 `Cross-Origin-Resource-Policy$h ~headerが複数個ある場合も同じ効果になる。 【すなわち，`~field値$が複数個の~tokenを含む場合、~headerが無かったときと同じになる。】 ◎ This means that `Cross-Origin-Resource-Policy: same-site, same-origin` ends up as allowed below as it will never match anything, as long as embedderPolicyValue is "unsafe-none". Two or more `Cross-Origin-Resource-Policy` headers will have the same effect.

3. ~IF［ %施策 ~NIN { `same-origin^bl, `same-site^bl, `cross-origin^bl } ］ ⇒ %施策 ~SET ~NULL ◎ If policy is neither `same-origin`, `same-site`, nor `cross-origin`, then set policy to null.

4. ~IF［ %施策 ~EQ ~NULL ］~AND［ ~OR↓ ］…

   • ［ %埋込元~施策~値 ~EQ `credentialless$l ］~AND［［ %応答 の`要請は資格証を含むか$rs ~EQ ~T ］~OR［ %~navi用か ~EQ ~T ］］
   • %埋込元~施策~値 ~EQ `require-corp$l

   …ならば ⇒ %施策 ~SET `same-origin^bl

   ◎ If policy is null, then switch on embedderPolicyValue: ◎ "unsafe-none" • Do nothing. ◎ "credentialless" • Set policy to `same-origin` if: •• response’s request-includes-credentials is true, or •• forNavigation is true. ◎ "require-corp" • Set policy to `same-origin`.

5. %施策 に応じて： ◎ Switch on policy:

   ~NULL

   `cross-origin^bl

   ~RET `許容される^i ◎ Return allowed.

   `same-origin^bl

   ~RET ［ 次が満たされるならば `許容される^i ／ ~ELSE_ `阻止される^i ］ ⇒ %生成元 ~EQ`生成元$sub %応答 の`~URL$rsの`生成元$url ◎ If origin is same origin with response’s URL’s origin, then return allowed. ◎ Otherwise, return blocked.

   `same-site^bl

   ~RET ［ ~AND↓ が満たされるならば `許容される^i ／ ~ELSE_ `阻止される^i ］：

   • ( %生成元, %応答 の`~URL$rsの`生成元$url ) は、 `~scheme無しで同じ~site$である
   • ［ %生成元 の`~scheme$url ~EQ `https^l ］~OR［ %応答 の`~URL$rsの`~scheme$url ~NEQ `https^l ］

   ◎ If all of the following are true • origin is schemelessly same site with response’s URL’s origin • origin’s scheme is "https" or response’s URL’s scheme is not "https" then return allowed. ◎ Otherwise, return blocked.

   注記： `Cross-Origin-Resource-Policy: same-site^bl は、 要請している生成元【 %生成元 】が~secureでない場合， ~secureな~transportを介して送達された応答は【条件に】合致すると見なさない — それらの~hostが~secureか否かを除けば【すなわち，~scheme無しで】同じ~siteであっても。 ~secureに~transportされた応答が合致するのは、 【要請の】起動元が~secureに~transportされた場合に限られることになる。 ◎ `Cross-Origin-Resource-Policy: same-site` does not consider a response delivered via a secure transport to match a non-secure requesting origin, even if their hosts are otherwise same site. Securely-transported responses will only match a securely-transported initiator.

`非同一-生成元~埋込元~施策~CORP違反~報告を~queueする@ ~algoは、 所与の ⇒＃ `応答$ %応答, `環境~設定群~obj$ %設定群~obj, 文字列 %行先, 真偽値 %報告のみ ◎終 に対し： ◎ To queue a cross-origin embedder policy CORP violation report, given a response response, an environment settings object settingsObject, a string destination, and a boolean reportOnly, run these steps:

1. %施策 ~LET %設定群~obj の`施策~容器$enVの`埋込元~施策$pC ◎ ↓
2. %報告先 ~LET %報告のみ に応じて ⇒＃ ~T ならば %施策 の`報告のみの報告先$embP／ ~F ならば %施策 の`報告先$embP ◎ Let endpoint be settingsObject’s policy container’s embedder policy’s report only reporting endpoint if reportOnly is true and settingsObject’s policy container’s embedder policy’s reporting endpoint otherwise.
3. %直列化した~URL ~LET `応答~URLを報告-用に直列化する$( %応答 ) ◎ Let serializedURL be the result of serializing a response URL for reporting with response.
4. %処置 ~LET %報告のみ に応じて ⇒＃ ~T ならば `reporting^l ／ ~F ならば `enforce^l ◎ Let disposition be "reporting" if reportOnly is true; otherwise "enforce".

5. %本体 ~LET 次に挙げる~propを包含している新たな `Object^jt：

   ~key	値
   `type^l	`corp^l
   `blockedURL^l	%直列化した~URL
   `destination^l	%行先
   `disposition^l	%処置

   ◎ Let body be a new object containing the following properties: ◎ key｜value "type"｜"corp" "blockedURL"｜serializedURL "destination"｜destination "disposition"｜disposition
6. `報告を生成して~queueする$( %設定群~obj の`大域~obj$enV, `~COEP報告~種別$i, %報告先, %本体 ) `REPORTING$r ◎ Generate and queue a report for settingsObject’s global object given the "coep" report type, endpoint, and body. [REPORTING]

`~main~fetch@ を遂行する ~algoは、 所与の ( `~fetch~params$ %~fetch~params, 真偽値 %再帰的か ~DF ~F ) に対し： ◎ To main fetch, given a fetch params fetchParams and an optional boolean recursive (default false), run these steps:

1. %要請 ~LET %~fetch~params の`要請$fP ◎ Let request be fetchParams’s request.
2. %応答 ~LET ~NULL ◎ Let response be null.
3. ~IF［ %要請 の`局所~URLに限るか$rq ~EQ ~T ］~AND［ %要請 の`現在の~URL$rqは`局所的$でない ］ ⇒ %応答 ~SET `~network~error$ ◎ If request’s local-URLs-only flag is set and request’s current URL is not local, then set response to a network error.
4. %要請 に対する `~CSP違反を報告する＠~CSP3#report-for-request$ ◎ Run report Content Security Policy violations for request.
5. `適切になるなら，要請を信用に価し得る~URLに昇格する＠~UPGRADE1#upgrade-request$( %要請 ) `UPGRADE$r ◎ Upgrade request to a potentially trustworthy URL, if appropriate.
6. `適切になるなら，混在d内容への要請を信用に価し得る~URLに昇格する＠~MIXED-CONTENT#upgrade-algorithm$( %要請 ) `MIX$r ◎ Upgrade a mixed content request to a potentially trustworthy URL, if appropriate.

7. ~IF［ 次に挙げるいずれかの結果 ~EQ `阻止される^i ］…

   • `要請の~fetchingは，不良~portに因り阻止されるべきか？$( %要請 )
   • `要請の~fetchingは，混在d内容として阻止されるべきか？＠~MIXED-CONTENT#should-block-fetch$( %要請 )
   • `要請は~CSPにより阻止されるべきか？＠~CSP3#should-block-request$( %要請 )
   • `要請は完全性~施策により阻止されるべきか？＠~SRI#should-request-be-blocked-by-integrity-policy$( %要請 )

   …ならば ⇒ %応答 ~SET `~network~error$

   ◎ If＼ should request be blocked due to a bad port,＼ should fetching request be blocked as mixed content,＼ should request be blocked by Content Security Policy,＼ or should request be blocked by Integrity Policy Policy＼ returns blocked,＼ then set response to a network error.
8. ~IF［ %要請 の`~referrer施策$rq ~EQ 空~文字列 ］ ⇒ %要請 の`~referrer施策$rq ~SET %要請 の`施策~容器$rqの`~referrer施策$pC ◎ If request’s referrer policy is the empty string, then set request’s referrer policy to request’s policy container’s referrer policy.

9. ~IF［ %要請 の`~referrer$rq ~NEQ `no-referrer^l ］ ⇒ %要請 の`~referrer$rq ~SET %要請 の`~referrerを決定-$した結果 `REFERRER$r ◎ If request’s referrer is not "no-referrer", then set request’s referrer to the result of invoking determine request’s referrer. [REFERRER]

   注記： `~referrer施策^cite 仕様にて言明されたとおり、 ~UAは，%要請 の`~referrer$rqに対し［ それを常に `no-referrer^l で上書きする／ そこには より敏感でない情報を公開する ］~optionを末端-利用者に供せる。 ◎ As stated in Referrer Policy, user agents can provide the end user with options to override request’s referrer to "no-referrer" or have it expose less sensitive information.

10. ~IF［ ~AND↓ ］… ◎ Set request’s current URL’s scheme to "https" if all of the following conditions are true:

    • %要請 の`現在の~URL$rqの`~scheme$url ~EQ `http^l ◎ request’s current URL’s scheme is "http"
    • %要請 の`現在の~URL$rqの`~host$urlは`~domain$urlである ◎ request’s current URL’s host is a domain
    • %要請 の`現在の~URL$rqの`~host$urlの`公共~接尾辞$ ~NIN { `localhost^l, `localhost.^l } ◎ request’s current URL’s host’s public suffix is not "localhost" or "localhost."

    • ~OR↓： ◎ ↓

      • %要請 の`現在の~URL$rqの`~host$urlを `HSTS$r `§ Known HSTS Host Domain Name Matching＠~RFCx/rfc6797#section-8.2$en に従って照合した結果は、 次に挙げるいずれかである：

        • superdomain match with an asserted `includeSubDomains^dir directive
        • congruent match (with or without an asserted `includeSubDomains^dir directive)
        ◎ Matching request’s current URL’s host per Known HSTS Host Domain Name Matching results in either a superdomain match with an asserted includeSubDomains directive or a congruent match (with or without an asserted includeSubDomains directive) [HSTS];＼

      • %要請 用の~DNS解決は、 `SVCB$r `§ HTTP Strict Transport Security＠https://datatracker.ietf.org/doc/html/draft-ietf-dnsop-svcb-https#section-9.5$en に従って，合致している~HTTPS-RR【~HTTPS資源~record】を見出した ◎ or DNS resolution for the request finds a matching HTTPS RR per section 9.5 of [SVCB]. [HSTS] [SVCB]

        注記： すべての~DNS演算は，一般に`実装定義$なので、 ~DNS解決が~HTTPS-RRを包含するか否かが どう決定されるかも`実装定義$になる。 ~DNS演算は，伝統的に`接続を得する$よう試みるまで遂行されないので、 ~UAは，~DNS演算を［ もっと早くに遂行する／ 局所~DNS~cacheに諮る／ ~fetch~algo内の後の方まで待機する ］必要があるかもしれない — その結果， %要請 の`現在の~URL$rqの`~scheme$urlを変更する必要を発見した際には、 ~logicを遡って解きほぐすことにもなり得る。 ◎ As all DNS operations are generally implementation-defined, how it is determined that DNS resolution contains an HTTPS RR is also implementation-defined. As DNS operations are not traditionally performed until attempting to obtain a connection, user agents might need to perform DNS operations earlier, consult local DNS caches, or wait until later in the fetch algorithm and potentially unwind logic on discovering the need to change request’s current URL’s scheme.

    …ならば ⇒ %要請 の`現在の~URL$rqの`~scheme$url ~SET `https^l ◎ ↑

11. ~IF［ %再帰的か ~EQ ~F ］：

    1. この段は、 `並列的$に走らす ⇒ ~GOTO `~main~fetchの継続^i
    2. ~RET
    ◎ If recursive is false, then run the remaining steps in parallel.

12. `~main~fetchの継続^i ◎ ↑

    ~IF［ %応答 ~EQ ~NULL ］ ⇒ %応答 ~SET 次の手続きを走らせた結果 ◎ If response is null, then set response to the result of running＼

    手続きは： ◎ the steps corresponding to the first matching statement:

    1. ~IF［ %~fetch~params の`~preloadされる応答の候補$fP ~NEQ ~NULL ］： ◎ fetchParams’s preloaded response candidate is non-null

       1. 次が満たされるまで待機する ⇒ %~fetch~params の`~preloadされる応答の候補$fP ~NEQ `pending^l ◎ Wait until fetchParams’s preloaded response candidate is not "pending".
       2. ~Assert： %~fetch~params の`~preloadされる応答の候補$fPは`応答$である ◎ Assert: fetchParams’s preloaded response candidate is a response.
       3. ~RET %~fetch~params の`~preloadされる応答の候補$fP ◎ Return fetchParams’s preloaded response candidate.

    2. ~IF［ ~OR↓ ］…

       • ［ %要請 の`現在の~URL$rqの`生成元$ ~EQ`生成元$sub %要請 の`生成元$rq ］~AND［ %要請 の`応答~tainting$rq ~EQ `basic^l ］ ◎ request’s current URL’s origin is same origin with request’s origin, and request’s response tainting is "basic"
       • %要請 の`現在の~URL$rqの`~scheme$url ~EQ `data^l ◎ request’s current URL’s scheme is "data"
       • %要請 の`~mode$rq ~IN { `navigate^l, `websocket^l } ◎ request’s mode is "navigate" or "websocket"

       …ならば：

       1. %要請 の`応答~tainting$rq ~SET `basic^l ◎ Set request’s response tainting to "basic".
       2. ~RET `~scheme~fetch$( %~fetch~params ) ◎ Return the result of running scheme fetch given fetchParams.

       注記： ~HTMLは、［ `~scheme$url ~EQ `data^l ］なる`~URL$から作成された どの［ 文書 ／ ~worker ］に対しても，一意かつ`不透明な生成元$をアテガう。 ~swは、［ `~scheme$url ~IN `~HTTP_S~scheme$ ］なる`~URL$からのみ作成される。 `HTML$r `SW$r ◎ HTML assigns any documents and workers created from URLs whose scheme is "data" a unique opaque origin. Service workers can only be created from URLs whose scheme is an HTTP(S) scheme. [HTML] [SW]

    3. ~IF［ %要請 の`~mode$rq ~EQ `same-origin^l ］ ⇒ ~RET `~network~error$ ◎ request’s mode is "same-origin" • Return a network error.

    4. ~IF［ %要請 の`~mode$rq ~EQ `no-cors^l ］： ◎ request’s mode is "no-cors"

       1. ~IF［ %要請 の`~redirect~mode$rq ~NEQ `follow^l ］ ⇒ ~RET `~network~error$ ◎ If request’s redirect mode is not "follow", then return a network error.
       2. %要請 の`応答~tainting$rq ~SET `opaque^l ◎ Set request’s response tainting to "opaque".
       3. ~RET `~scheme~fetch$( %~fetch~params ) ◎ Return the result of running scheme fetch given fetchParams.
    5. ~IF［ %要請 の`現在の~URL$rqの`~scheme$urlは`~HTTP_S~scheme$でない ］ ⇒ ~RET `~network~error$ ◎ request’s current URL’s scheme is not an HTTP(S) scheme • Return a network error.

    6. ~IF［ ~OR↓ ］…

       • %要請 の`~CORS予行を利用するか$rq ~EQ ~T ◎ request’s use-CORS-preflight flag is set
       • ［ %要請 の`安全でない要請か$rq ~EQ ~T ］~AND［［ %要請 の`~method$rqは `~CORS安全とされる~method$でない ］~OR［ `~CORS安全でない要請~header名たち$( %要請 の`~header~list$rq ) は空でない ］］ ◎ request’s unsafe-request flag is set and either request’s method is not a CORS-safelisted method or CORS-unsafe request-header names with request’s header list is not empty

       …ならば：

       1. %要請 の`応答~tainting$rq ~SET `cors^l ◎ Set request’s response tainting to "cors".
       2. %~CORS予行~付き応答 ~LET `~HTTP~fetch$( %~fetch~params, ~T ) ◎ Let corsWithPreflightResponse be the result of running HTTP fetch given fetchParams and true.
       3. ~IF［ %~CORS予行~付き応答 は`~network~error$である ］ ⇒ `~cache~entryを~clearする$( %要請 ) ◎ If corsWithPreflightResponse is a network error, then clear cache entries using request.
       4. ~RET %~CORS予行~付き応答 ◎ Return corsWithPreflightResponse.
    7. %要請 の`応答~tainting$rq ~SET `cors^l ◎ Otherwise • Set request’s response tainting to "cors".
    8. ~RET `~HTTP~fetch$( %~fetch~params ) ◎ • Return the result of running HTTP fetch given fetchParams.
13. ~IF［ %再帰的か ~EQ ~T ］ ⇒ ~RET %応答 ◎ If recursive is true, then return response.

14. ~IF［ %応答 は`~network~error$でない ］~AND［ %応答 は`絞込み応答$でない ］： ◎ If response is not a network error and response is not a filtered response, then:

    1. ~IF［ %要請 の`応答~tainting$rq ~EQ `cors^l ］： ◎ If request’s response tainting is "cors", then:

       1. %~header名~群 ~LET `~header~listから値を抽出する$( %応答 の`~header~list$rs, `Access-Control-Expose-Headers$h ) ◎ Let headerNames be the result of extracting header list values given `Access-Control-Expose-Headers` and response’s header list.

       2. ~IF［ %~header名~群 ~NIN { ~NULL, `失敗^i } ］： ◎ ↓

          1. ~IF［ %要請 の`資格証~mode$rq ~NEQ `include^l ］~AND［ `*^bl ~IN %~header名~群 ］ ⇒ %応答 の`~CORSに公開される~header名~list$rs ~SET %応答 の`~header~list$rs内の各`~header$の`名前$hdたちが成す~list — ここで、 各~名前は，~list内で一意にする ◎ If request’s credentials mode is not "include" and headerNames contains `*`, then set response’s CORS-exposed header-name list to all unique header names in response’s header list.

          2. ~ELSE ⇒ %応答 の`~CORSに公開される~header名~list$rs ~SET %~header名~群 ◎ Otherwise, if headerNames is non-null or failure, then set response’s CORS-exposed header-name list to headerNames.

             注記： この時点でも， %~header名~群 のいずれかは `*^bl であり得るが、 合致する`~header$は［ `名前$hd ~EQ `*^bl ］を満たすものに限られることになる。 ◎ One of the headerNames can still be `*` at this point, but will only match a header whose name is `*`.

    2. %応答 ~SET %応答 を`内部~応答$とする`絞込み応答$であって， %要請 の`応答~tainting$rqに応じて 次で与えられるもの： ◎ Set response to the following filtered response with response as its internal response, depending on request’s response tainting:

       `basic^l

       `基本~絞込み応答$ ◎ basic filtered response

       `cors^l

       `~CORS絞込み応答$ ◎ CORS filtered response

       `opaque^l

       `不透明な絞込み応答$ ◎ opaque filtered response

15. %内部~応答 ~LET %応答 に応じて ⇒＃ `~network~error$であるならば %応答 ／ ~ELSE_ %応答 の`内部~応答$ ◎ Let internalResponse be response, if response is a network error; otherwise response’s internal response.

16. ~IF［ %内部~応答 の`~URL~list$rsは`空$である ］ ⇒ %内部~応答 の`~URL~list$rs ~SET %要請 の`~URL~list$rqを`~cloneする$ ◎ If internalResponse’s URL list is empty, then set it to a clone of request’s URL list.

    注記： `応答$の`~URL~list$rsは、 空になり得る — 例： `about:^c ~URLを~fetchするとき。 ◎ A response’s URL list can be empty, e.g., when fetching an about: URL.

17. ~IF［ `要請の生成元は~taintされたか？$( %要請 ) ~EQ ~T ］ ⇒ %内部~応答 の`非同一-生成元~redirectはあるか$rs ~SET ~T ◎ If request has a redirect-tainted origin, then set internalResponse’s has-cross-origin-redirects to true.
18. ~IF［ %要請 の`計時許容に失敗したか$rq ~EQ ~F ］ ⇒ %内部~応答 の`計時許容に合格したか$rs ~SET ~T ◎ If request’s timing allow failed flag is unset, then set internalResponse’s timing allow passed flag.

19. ~IF［ %応答 は`~network~error$でない ］~AND［ 次に挙げるいずれかの結果 ~EQ `阻止される^i ］… ◎ If response is not a network error and any of the following returns blocked

    • `要請に対する応答は，混在d内容として阻止されるべきか？＠~MIXED-CONTENT#should-block-response$( %要請, %内部~応答 ) ◎ should internalResponse to request be blocked as mixed content
    • `要請に対する応答は，~CSPにより阻止されるべきか？＠~CSP3#should-block-response$( %要請, %内部~応答 ) ◎ should internalResponse to request be blocked by Content Security Policy
    • `要請に対する応答は，~MIME型に因り阻止されるべきか？＠#should-response-to-request-be-blocked-due-to-mime-type?$( %要請, %内部~応答 ) ◎ should internalResponse to request be blocked due to its MIME type
    • `要請に対する応答は，~nosniffに因り阻止されるべきか？＠#should-response-to-request-be-blocked-due-to-nosniff?$( %要請, %内部~応答 ) ◎ should internalResponse to request be blocked due to nosniff

    …ならば ⇒ ( %応答, %内部~応答 ) ~SET ( `~network~error$, `~network~error$ ) 【！同一の個？ 】 ◎ then set response and internalResponse to a network error.

20. ~IF［ %応答 の`種別$rs ~EQ `opaque^l ］~AND［ %内部~応答 の`状態s$rs ~EQ `206$st ］~AND［ %内部~応答 の`範囲が要請されたか$rs ~EQ ~T ］~AND［ %要請 の`~header~list$rq内に［ `Range$h を`名前に持つ~header$ ］は無い ］ ⇒＃ %応答 ~SET `~network~error$； %内部~応答 ~SET `~network~error$ ◎ If response’s type is "opaque", internalResponse’s status is 206, internalResponse’s range-requested flag is set, and request’s header list does not contain `Range`, then set response and internalResponse to a network error.

    注記： 伝統的に，~APIは、 範囲が要請されなかった場合でも範囲~付き応答を受容する。 この段は、［ 過去の範囲~付き要請からの部分的~応答 ］が，範囲~要請を為さなかった~APIに供されることを防止する。 ◎ Traditionally, APIs accept a ranged response even if a range was not requested. This prevents a partial response from an earlier ranged request being provided to an API that did not make a range request.

    この段は、 次のような攻撃を防止する： ◎ Further details ◎ The above steps prevent the following attack:

    ~media要素を利用して，非同一-生成元~HTML資源のある範囲が要請されたとする。 これは妥当でない~mediaになるが、 応答の~cloneへの参照は，~sw内に維持され得る。 これは、 後で~script要素の~fetchに対する応答として利用され得る。 部分的~応答が妥当な~JSであった場合（一体としての資源はそうでなくとも）、 それを実行すると私的~dataが漏洩されることになる。 ◎ A media element is used to request a range of a cross-origin HTML resource. Although this is invalid media, a reference to a clone of the response can be retained in a service worker. This can later be used as the response to a script element’s fetch. If the partial response is valid JavaScript (even though the whole resource is not), executing it would leak private data.

21. ~IF［ %応答 は`~network~error$でない ］~AND［［ %要請 の`~method$rq ~IN { `HEAD$hm, `CONNECT$hm } ］~OR［ %内部~応答 の`状態s$rs は `~null本体~状態s$である ］］ ⇒ %内部~応答 の`本体$rs ~SET ~NULL — 以降、 本体への~enqueueはすべて~~無視する ◎ If response is not a network error and either request’s method is `HEAD` or `CONNECT`, or internalResponse’s status is a null body status, set internalResponse’s body to null and disregard any enqueuing toward it (if any).

    注記： これは、 ~HTTPに違反する~server用に ~errorの取扱いを標準~化する。 ◎ This standardizes the error handling for servers that violate HTTP.

22. ~IF［ %要請 の`完全性~metadata$rq ~NEQ 空~文字列 ］： ◎ If request’s integrity metadata is not the empty string, then:

    1. %本体~errorの処理n ~LET 次を走らす手続き ⇒ `~fetch応答を引渡す$( %~fetch~params, `~network~error$ ) ◎ Let processBodyError be this step: run fetch response handover given fetchParams and a network error.
    2. ~IF［ %応答 の`本体$rs ~EQ ~NULL ］ ⇒＃ %本体~errorの処理n()； ~RET ◎ If response’s body is null, then run processBodyError and abort these steps.

    3. %本体の処理n ~LET 所与の ( %~byte列 ) に対し，次を走らす手続き： ◎ Let processBody given bytes be these steps:

       1. ~IF［ `応答は~metadata~listに合致するか？$( %~byte列, %要請 の`完全性~metadata$rq ) ~EQ ~F `SRI$r ］ ⇒＃ %本体~errorの処理n()； ~RET ◎ If bytes do not match request’s integrity metadata, then run processBodyError and abort these steps. [SRI]
       2. %応答 の`本体$rs ~SET `~byte列を本体として取得する$( %~byte列 ) ◎ Set response’s body to bytes as a body.
       3. `~fetch応答を引渡す$( %~fetch~params, %応答 ) ◎ Run fetch response handover given fetchParams and response.
    4. `本体を全部的に読取る$( ↓ ) ⇒＃ %応答 の`本体$rs, %本体の処理n, %本体~errorの処理n ◎ Fully read response’s body given processBody and processBodyError.
23. ~ELSE ⇒ `~fetch応答を引渡す$( %~fetch~params, %応答 ) ◎ Otherwise, run fetch response handover given fetchParams and response.

`~fetch応答を引渡す@ ~algoは、 所与の ( `~fetch~params$ %~fetch~params, `応答$ %応答 ) に対し： ◎ The fetch response handover, given a fetch params fetchParams and a response response, run these steps:

1. %計時~報 ~LET %~fetch~params の`計時~報$fP ◎ Let timingInfo be fetchParams’s timing info.

2. ~IF［ %応答 は`~network~error$でない ］~AND［ %~fetch~params の`要請$fPの`~client$rqは`~secureな文脈$enVである ］ ⇒ %計時~報 の`~server計時~header群$fT ~SET `~header~listから値を取得して復号して分割する$( %応答 の`内部~応答$の`~header~list$rs, `Server-Timing$h ) ◎ If response is not a network error and fetchParams’s request’s client is a secure context, then set timingInfo’s server-timing headers to the result of getting, decoding, and splitting `Server-Timing` from response’s internal response’s header list.

   注記： %応答 の`内部~応答$を利用することは、 安全である — `Server-Timing$h ~headerの~dataを公開すること【するか否か】は、 `Timing-Allow-Origin$h ~headerを通して防護されるので。 ◎ Using _response_’s internal response is safe as exposing `Server-Timing` header data is guarded through the `Timing-Allow-Origin` header.

   ~UAは、 `Server-Timing$h ~headerを~secureでない文脈からの要請にも公開するものと裁定してもヨイ。 ◎ The user agent may decide to expose `Server-Timing` headers to non-secure contexts requests as well.

3. ~IF［ %~fetch~params の`要請$fPの`行先$rq ~EQ `document^l ］ ⇒ %~fetch~params の`制御器$fPの`全部的な計時~報$fC ~SET %~fetch~params の`計時~報$fP ◎ If fetchParams’s request’s destination is "document", then set fetchParams’s controller’s full timing info to fetchParams’s timing info.

4. %応答の本体~終了~時の処理n ~LET 次を走らす手続き： ◎ Let processResponseEndOfBody be the following steps:

   1. %安全でない終了~時刻 ~LET `安全でない共有される現在の時刻$ ◎ Let unsafeEndTime be the unsafe shared current time.

   2. %~fetch~params の`制御器$fPの`計時を報告する手続き$fC ~SET 所与の ( `大域~obj$ %大域~obj ) に対し，次を走らす手続き： ◎ Set fetchParams’s controller’s report timing steps to the following steps given a global object global:

      1. ~IF［ %~fetch~params の`要請$fPの`~URL$rqの`~scheme$urlは`~HTTP_S~scheme$でない ］ ⇒ ~RET ◎ If fetchParams’s request’s URL’s scheme is not an HTTP(S) scheme, then return.
      2. %計時~報 の`終了~時刻$fT ~SET `相対的な高分解能~時刻$( %安全でない終了~時刻, %大域~obj ) ◎ Set timingInfo’s end time to the relative high resolution time given unsafeEndTime and global.
      3. %~cache状態 ~LET %応答 の`~cache状態$rs ◎ Let cacheState be response’s cache state.
      4. %本体~報 ~LET %応答 の`本体~報$rs ◎ Let bodyInfo be response’s body info.

      5. ~IF［ %応答 の`計時許容に合格したか$rs ~EQ ~F ］ ⇒＃ %計時~報 ~SET `不透明な計時~報を作成する$( %計時~報 ), %~cache状態 ~SET 空~文字列 ◎ If response’s timing allow passed flag is not set, then set timingInfo to the result of creating an opaque timing info for timingInfo and set cacheState to the empty string.

         注記： この段は、 %応答 が`~network~error$である事例を受持つ。 ◎ This covers the case of response being a network error.

      6. %要請 ~LET %~fetch~params の`要請$fP ◎ ↓
      7. %応答~状態s ~LET 0 ◎ Let responseStatus be 0.

      8. ~IF［ %要請 の`~mode$rq ~NEQ `navigate^l ］~OR［ %応答 の`非同一-生成元~redirectはあるか$rs ~EQ ~F ］： ◎ If fetchParams’s request’s mode is not "navigate" or response’s has-cross-origin-redirects is false:

         1. %応答~状態s ~SET %応答 の`状態s$rs ◎ Set responseStatus to response’s status.
         2. %~MIME型 ~LET `~header~listから~MIME型を抽出する$( %応答 の`~header~list$rs ) ◎ Let mimeType be the result of extracting a MIME type from response’s header list.
         3. ~IF［ %~MIME型 ~NEQ `失敗^i ］ ⇒ %本体~報 の`内容~型$fT ~SET `~supportされる~MIME型を最小~化する$( %~MIME型 ) ◎ If mimeType is not failure, then set bodyInfo’s content type to the result of minimizing a supported MIME type given mimeType.
      9. ~IF［ %要請 の`起動元~種別$rq ~NEQ ~NULL ］ ⇒ `資源~計時を~markする$( ↓ ) ⇒＃ %計時~報, %要請 の`~URL$rq, %要請 の`起動元~種別$rq, %大域~obj, %~cache状態, %本体~報, %応答~状態s ◎ If fetchParams’s request’s initiator type is non-null, then mark resource timing given timingInfo, fetchParams’s request’s URL, fetchParams’s request’s initiator type, global, cacheState, bodyInfo, and responseStatus.

   3. %応答の本体~終了~時の処理n用の~task ~LET 次の手続き： ◎ Let processResponseEndOfBodyTask be the following steps:

      1. %要請 ~LET %~fetch~params の`要請$fP ◎ ↓
      2. %要請 の`済んだか$rq ~SET ~T ◎ Set fetchParams’s request’s done flag.
      3. ~IF［ %~fetch~params の`応答の本体~終了~時の処理n$fP ~NEQ ~NULL ］ ⇒ %~fetch~params の`応答の本体~終了~時の処理n$fP( %応答 ) ◎ If fetchParams’s process response end-of-body is non-null, then run fetchParams’s process response end-of-body given response.
      4. ~IF［ %要請 の`起動元~種別$rq ~NEQ ~NULL ］~AND［ %要請 の`~client$rqの`大域~obj$enV ~EQ %~fetch~params の`~taskの行先$fP ］ ⇒ %~fetch~params の`制御器$fPの`計時を報告する手続き$fC( %要請 の`~client$rqの`大域~obj$enV ) ◎ If fetchParams’s request’s initiator type is non-null and fetchParams’s request’s client’s global object is fetchParams’s task destination, then run fetchParams’s controller’s report timing steps given fetchParams’s request’s client’s global object.
   4. `~fetch~taskを~queueする$( %応答の本体~終了~時の処理n用の~task, %~fetch~params の`~taskの行先$fP ) ◎ Queue a fetch task to run processResponseEndOfBodyTask with fetchParams’s task destination.

5. ~IF［ %~fetch~params の`応答の処理n$fP ~NEQ ~NULL ］ ⇒ `~fetch~taskを~queueする$( 次の手続き, %~fetch~params の`~taskの行先$fP )

   手続きは ⇒ %~fetch~params の`応答の処理n$fP( %応答 )
   ◎ If fetchParams’s process response is non-null, then queue a fetch task to run fetchParams’s process response given response, with fetchParams’s task destination.
6. %内部~応答 ~LET %応答 に応じて ⇒＃ `~network~error$であるならば %応答 ／ ~ELSE_ %応答 の`内部~応答$ ◎ Let internalResponse be response, if response is a network error; otherwise response’s internal response.
7. ~IF［ %内部~応答 の`本体$rs ~EQ ~NULL ］ ⇒ %応答の本体~終了~時の処理n() ◎ If internalResponse’s body is null, then run processResponseEndOfBody.

8. ~ELSE： ◎ Otherwise:

   1. %形式変換~stream ~LET 新たな `TransformStream$I ◎ Let transformStream be a new TransformStream.
   2. %恒等変換~algo ~LET 所与の ( %~chunk ) に対し，次を走らす~algo ⇒ %形式変換~stream に`~chunkを~enqueueする$TS( %~chunk ) ◎ Let identityTransformAlgorithm be an algorithm which, given chunk, enqueues chunk in transformStream.
   3. %形式変換~stream を`設定しておく$TS — 次を与える下で ⇒＃ `形式変換~algo^i ~SET %恒等変換~algo, `書出n~algo^i ~SET %応答の本体~終了~時の処理n ◎ Set up transformStream with transformAlgorithm set to identityTransformAlgorithm and flushAlgorithm set to processResponseEndOfBody.
   4. %内部~応答 の`本体$rsの`~stream$bd ~SET %内部~応答 の`本体$rs の`~stream$bdを %形式変換~stream を`通して~pipeする$RS ◎ Set internalResponse’s body’s stream to the result of internalResponse’s body’s stream piped through transformStream.

   注記： この `TransformStream$I は、 当の~streamが終端に達したとき通知を受信する目的に必要になる — それ以外については`恒等変換~stream$になる。 ◎ This TransformStream is needed for the purpose of receiving a notification when the stream reaches its end, and is otherwise an identity transform stream.

9. ~IF［ %~fetch~params の`応答の本体を消費する処理n$fP ~NEQ ~NULL ］： ◎ If fetchParams’s process response consume body is non-null, then:

   1. %本体の処理n ~LET 所与の ( %~NULLまたは~byte列 ) に対し，次を走らす手続き ⇒ %~fetch~params の`応答の本体を消費する処理n$fP( %応答, %~NULLまたは~byte列 ) ◎ Let processBody given nullOrBytes be this step: run fetchParams’s process response consume body given response and nullOrBytes.
   2. %本体~errorの処理n ~LET 次を走らす手続き ⇒ %~fetch~params の`応答の本体を消費する処理n$fP( %応答, `失敗^i ) ◎ Let processBodyError be this step: run fetchParams’s process response consume body given response and failure.

   3. ~IF［ %内部~応答 の`本体$rs ~EQ ~NULL ］ ⇒ `~fetch~taskを~queueする$( 次の手続き, %~fetch~params の`~taskの行先$fP )

      手続きは ⇒ %本体の処理n( ~NULL )
      ◎ If internalResponse’s body is null, then queue a fetch task to run processBody given null, with fetchParams’s task destination.
   4. ~ELSE ⇒ `本体を全部的に読取る$( ↓ ) ⇒＃ %内部~応答 の`本体$rs, %本体の処理n, %本体~errorの処理n, %~fetch~params の`~taskの行先$fP ◎ Otherwise, fully read internalResponse’s body given processBody, processBodyError, and fetchParams’s task destination.

`~scheme~fetch@ を遂行する ~algoは、 所与の ( `~fetch~params$ %~fetch~params ) に対し： ◎ To scheme fetch, given a fetch params fetchParams:

1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET `適切な~network~error$( %~fetch~params ) ◎ If fetchParams is canceled, then return the appropriate network error for fetchParams.
2. %要請 ~LET %~fetch~params の`要請$fP ◎ Let request be fetchParams’s request.

3. %要請 の`現在の~URL$rq の`~scheme$urlに応じて： ◎ Switch on request’s current URL’s scheme and run the associated steps:

   `about^l

   ~IF［ %要請 の`現在の~URL$rqの`~path$url ~EQ 文字列 `blank^l ］ ⇒ ~RET 新たな`応答$ — その ⇒＃ `状態s~message$rs ~SET `OK^bl, `~header~list$rs ~SET « ( `Content-Type$h, `text/html;charset=utf-8^bl ) », `本体$rs ~SET `~byte列を本体として取得する$( 空な~byte列 ) ◎ If request’s current URL’s path is the string "blank", then return a new response whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) », and body is the empty byte sequence as a body.

   注記： `about:config^l に類する`~URL$は、 `~navi$の間に取扱われ，`~fetch$の文脈~下では`~network~error$になる。 ◎ URLs such as "about:config" are handled during navigation and result in a network error in the context of fetching.

   `blob^l

   1. %~blob~URL~entry ~LET %要請 の`現在の~URL$rqの`~blob~URL~entry$url `FILEAPI$r ◎ Let blobURLEntry be request’s current URL’s blob URL entry.

   2. ~IF［ %要請 の`~method$rq ~NEQ `GET$hm ］~OR［ %~blob~URL~entry ~EQ ~NULL ］ ⇒ ~RET `~network~error$ ◎ If request’s method is not `GET` or blobURLEntry is null, then return a network error. [FILEAPI]

      注記： `GET^hm `~method$に制約することには、 相互運用可能にする以外に有用な目的はない。 ◎ The `GET` method restriction serves no useful purpose other than being interoperable.

   3. %要請~環境 ~LET `要請~環境を決定する$( %要請 ) ◎ Let requestEnvironment be the result of determining the environment given request.
   4. %~top-levelの~naviか ~LET ~IS［ %要請 の`行先$rq ~EQ `document^l ］ ◎ Let isTopLevelNavigation be true if request’s destination is "document"; otherwise, false.
   5. ~IF［ %~top-levelの~naviか ~EQ ~F ］~AND［ %要請~環境 ~EQ ~NULL ］ ⇒ ~RET `~network~error$ ◎ If isTopLevelNavigation is false and requestEnvironment is null, then return a network error.
   6. %~naviまたは環境 ~LET %~top-levelの~naviか に応じて ⇒＃ ~T ならば `navigation^l ／ ~F ならば %要請~環境 ◎ Let navigationOrEnvironment be the string "navigation" if isTopLevelNavigation is true; otherwise, requestEnvironment.
   7. %~blob ~LET `~blob~objを得する$( %~blob~URL~entry, %~naviまたは環境 ) ◎ Let blob be the result of obtaining a blob object given blobURLEntry and navigationOrEnvironment.
   8. ~IF［ %~blob は `Blob$I ~objでない ］ ⇒ ~RET `~network~error$ ◎ If blob is not a Blob object, then return a network error.
   9. %応答 ~LET 新たな`応答$ ◎ Let response be a new response.
   10. %全部的な長さ ~LET %~blob の `size$mF ◎ Let fullLength be blob’s size.
   11. %直列化した全部的な長さ ~LET `同型に符号化する$( `整数を直列化する$( %全部的な長さ ) ) ◎ Let serializedFullLength be fullLength, serialized and isomorphic encoded.
   12. %型 ~LET %~blob の `type$mF ◎ Let type be blob’s type.

   13. ~IF［ %要請 の`~header~list$rq内に `Range$h を`名前に持つ~header$は在る ］： ◎ If request’s header list does not contain `Range`:

       1. %本体と型 ~LET `本体と型を安全に抽出する$( %~blob ) ◎ Let bodyWithType be the result of safely extracting blob.
       2. %応答 の`状態s~message$rs ~SET `OK^bl ◎ Set response’s status message to `OK`.
       3. %応答 の`本体$rs ~SET %本体と型 の`本体$bwT ◎ Set response’s body to bodyWithType’s body.
       4. %応答 の`~header~list$rs ~SET « 次に挙げる~header » ⇒＃ ( `Content-Length$h, %直列化した全部的な長さ ), ( `Content-Type$h, %型 ) ◎ Set response’s header list to « (`Content-Length`, serializedFullLength), (`Content-Type`, type) ».

   14. ~ELSE： ◎ Otherwise:

       1. %応答 の`範囲が要請されたか$rs ~SET ~T ◎ Set response’s range-requested flag.
       2. %範囲~header値 ~LET `~header~listから値を取得する$( %要請 の`~header~list$rq, `Range$h ) ◎ Let rangeHeader be the result of getting `Range` from request’s header list.
       3. %範囲~値 ~LET `単純な範囲~header値を構文解析する$( %範囲~header値, ~T ) ◎ Let rangeValue be the result of parsing a single range header value given rangeHeader and true.
       4. ~IF［ %範囲~値 ~EQ `失敗^i ］ ⇒ ~RET `~network~error$ ◎ If rangeValue is failure, then return a network error.
       5. ( %範囲~始端, %範囲~終端 ) ~LET %範囲~値 ◎ Let (rangeStart, rangeEnd) be rangeValue.

       6. ~IF［ %範囲~始端 ~EQ ~NULL ］： ◎ If rangeStart is null:

          1. %範囲~始端 ~SET %全部的な長さ ~MINUS %範囲~終端 ◎ Set rangeStart to fullLength − rangeEnd.
          2. %範囲~終端 ~SET %範囲~始端 ~PLUS %範囲~終端 ~MINUS 1 ◎ Set rangeEnd to rangeStart + rangeEnd − 1.

       7. ~ELSE： ◎ Otherwise:

          1. ~IF［ %範囲~始端 ~GTE %全部的な長さ ］ ⇒ ~RET `~network~error$ ◎ If rangeStart is greater than or equal to fullLength, then return a network error.
          2. ~IF［ %範囲~終端 ~EQ ~NULL ］~OR［ %範囲~終端 ~GTE %全部的な長さ ］ ⇒ %範囲~終端 ~SET %全部的な長さ ~MINUS 1 ◎ If rangeEnd is null or rangeEnd is greater than or equal to fullLength, then set rangeEnd to fullLength − 1.

       8. %切出した~blob ~LET `~blobを切出す$( %~blob, %範囲~始端, %範囲~終端 ~PLUS 1, %型 ) ◎ Let slicedBlob be the result of invoking slice blob given blob, rangeStart, rangeEnd + 1, and type.

          注記： `Range$h【！range】 ~header用の`~byte範囲＠~HTTPsem#byte-range$は，終端を含むが、 `~blobを切出す$ ~algoの入力~範囲は，そうでない — %範囲~終端 に 1 を加えているのは、 そのためである。 ◎ A range header denotes an inclusive byte range, while the slice blob algorithm input range does not. To use the slice blob algorithm, we have to increment rangeEnd.

       9. %切出した本体と型 ~LET `本体と型を安全に抽出する$( %切出した~blob ) ◎ Let slicedBodyWithType be the result of safely extracting slicedBlob.
       10. %応答 の`本体$rs ~SET %切出した本体と型 の`本体$bwT ◎ Set response’s body to slicedBodyWithType’s body.
       11. %直列化した切出した長さ ~LET `同型に符号化する$( `整数を直列化する$( %切出した~blob の `size$mF ) ) ◎ Let serializedSlicedLength be slicedBlob’s size, serialized and isomorphic encoded.
       12. %内容~範囲 ~LET `内容~範囲を築く$( %範囲~始端, %範囲~終端, %全部的な長さ ) ◎ Let contentRange be the result of invoking build a content range given rangeStart, rangeEnd, and fullLength.
       13. %応答 の`状態s$rs ~SET `206$st ◎ Set response’s status to 206.
       14. %応答 の`状態s~message$rs ~SET `Partial Content^bl ◎ Set response’s status message to `Partial Content`.
       15. %応答 の`~header~list$rs ~SET « 次に挙げる~header » ⇒＃ ( `Content-Length$h, %直列化した切出した長さ ), ( `Content-Type$h, %型 ), ( `Content-Range$h, %内容~範囲 ) ◎ Set response’s header list to « (`Content-Length`, serializedSlicedLength), (`Content-Type`, type), (`Content-Range`, contentRange) ».
   15. ~RET %応答 ◎ Return response.

   `data^l

   1. %~dataURL構造体 ~LET `~data_URL処理器$( %要請 の`現在の~URL$rq ) ◎ Let dataURLStruct be the result of running the data: URL processor on request’s current URL.
   2. ~IF［ %~dataURL構造体 ~EQ `失敗^i ］ ⇒ ~RET `~network~error$ ◎ If dataURLStruct is failure, then return a network error.
   3. %~MIME型 ~LET `~MIME型を~byte列に直列化する$( %~dataURL構造体 の`~MIME型$dU ) ◎ Let mimeType be dataURLStruct’s MIME type, serialized.
   4. ~RET 新たな`応答$ — その ⇒＃ `状態s~message$rs ~SET `OK^bl, `~header~list$rs ~SET « ( `Content-Type$h, %~MIME型 ) », `本体$rs ~SET `~byte列を本体として取得する$( %~dataURL構造体 の`本体$dU ) ◎ Return a new response whose status message is `OK`, header list is « (`Content-Type`, mimeType) », and body is dataURLStruct’s body as a body.

   `file^l

   今の所、 あいにく `file:^c `~URL$については，読者への宿題として残される。 ◎ For now, unfortunate as it is, file: URLs are left as an exercise for the reader.

   疑わしい場合は`~network~error$を返すこと。 ◎ When in doubt, return a network error.

   `~HTTP_S~scheme$

   ~RET `~HTTP~fetch$( %~fetch~params ) ◎ Return the result of running HTTP fetch given fetchParams.

4. ~RET `~network~error$ ◎ Return a network error.

`要請~環境を決定する@ ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To determine the environment, given a request request:

1. ~IF［ %要請 の`予約-済み~client$rq ~NEQ ~NULL ］ ⇒ ~RET %要請 の`予約-済み~client$rq ◎ If request’s reserved client is non-null, then return request’s reserved client.
2. ~IF［ %要請 の`~client$rq ~NEQ ~NULL ］ ⇒ ~RET %要請 の`~client$rq ◎ If request’s client is non-null, then return request’s client.
3. ~RET ~NULL ◎ Return null.

`~HTTP~fetch@ を遂行する ~algoは、 所与の ( `~fetch~params$ %~fetch~params, 真偽値 %~CORS予行を為すか ~DF ~F ) に対し： ◎ To HTTP fetch, given a fetch params fetchParams and an optional boolean makeCORSPreflight (default false), run these steps:

1. %要請 ~LET %~fetch~params の`要請$fP ◎ Let request be fetchParams’s request.
2. %応答 ~LET ~NULL ◎ Let response and internalResponse be null.
3. %内部~応答 ~LET ~NULL ◎ ↑

4. ~IF［ %要請 の`~sw~mode$rq ~EQ `all^l ］： ◎ If request’s service-workers mode is "all", then:

   1. %~sw用の要請 ~LET `要請を~cloneする$( %要請 ) ◎ Let requestForServiceWorker be a clone of request.

   2. ~IF［ %~sw用の要請 の`本体$ ~NEQ ~NULL ］： ◎ If requestForServiceWorker’s body is non-null, then:

      1. %形式変換~stream ~LET 新たな `TransformStream$I ◎ Let transformStream be a new TransformStream.

      2. %形式変換~algo ~LET 所与の ( %~chunk ) に対し，次を走らす手続き： ◎ Let transformAlgorithm given chunk be these steps:

         1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET ◎ If fetchParams is canceled, then abort these steps.
         2. ~IF［ %~chunk は `Uint8Array$I ~objでない ］ ⇒ `~fetchを終了する$( %~fetch~params の`制御器$fP ) ◎ If chunk is not a Uint8Array object, then terminate fetchParams’s controller.

         3. ~ELSE ⇒ %形式変換~stream に`~chunkを~enqueueする$RS( %~chunk ) ◎ Otherwise, enqueue chunk in transformStream.＼

            この段においては、 ~UAは，次を行ってもヨイ ⇒＃ ~chunkを`実装定義$な実用的な~sizeに分割した上で，結果の各`~chunkを~enqueueする$RS／ ~chunkたちを`実装定義$な実用的な~sizeに連結した上で，結果の`~chunkを~enqueueする$RS ◎ The user agent may split the chunk into implementation-defined practical sizes and enqueue each of them.＼ The user agent also may concatenate the chunks into an implementation-defined practical size and enqueue it.

      3. %形式変換~stream を`設定しておく$TS — 次を与える下で ⇒＃ `形式変換~algo^i ~SET %形式変換~algo ◎ Set up transformStream with transformAlgorithm set to transformAlgorithm.
      4. %~sw用の要請 の`本体$の`~stream$bd ~SET ［ %~sw用の要請 の`本体$の`~stream$bd ］を %形式変換~stream を`通して~pipeする$RS ◎ Set requestForServiceWorker’s body’s stream to the result of requestForServiceWorker’s body’s stream piped through transformStream.
   3. %~sw開始~時刻 ~LET `粗化した共有される現在の時刻$( %~fetch~params の`非同一-生成元~能力は隔離されるか$fP ) ◎ Let serviceWorkerStartTime be the coarsened shared current time given fetchParams’s cross-origin isolated capability.
   4. %応答 ~SET `~fetchを取扱う$( %~sw用の要請, %~fetch~params の`制御器$fP, %~fetch~params の`非同一-生成元~能力は隔離されるか$fP ) `HTML$r `SW$r ◎ Set response to the result of invoking handle fetch for requestForServiceWorker, with fetchParams’s controller and fetchParams’s cross-origin isolated capability. [HTML] [SW]

   5. ~IF［ %応答 は`応答$でない ］ ⇒ %応答 ~SET ~NULL

      【 この段は、 この訳による補完。 ~fetchを取扱う~algoは、 ~NULL を返す事例で，代わりに`~sw計時~報$を返すよう更新されたので （本当は、 その事例に対し何らかの処理を追加するべきかもしれない）。 】

   6. ~IF［ %応答 ~NEQ ~NULL ］： ◎ If response is non-null, then:

      1. %~fetch~params の`計時~報$fPの`最終-~sw開始~時刻$fT ~SET %~sw開始~時刻 ◎ Set fetchParams’s timing info’s final service worker start time to serviceWorkerStartTime.
      2. ~IF［ %要請 の`本体$rq ~NEQ ~NULL ］ ⇒ %要請 の`本体$rqを`取消す$RS( `undefined^jv ) ◎ If request’s body is non-null, then cancel request’s body with undefined.
      3. %内部~応答 ~SET %応答 に応じて ⇒＃ `絞込み応答$でないならば %応答 ／ ~ELSE_ %応答 の`内部~応答$ ◎ Set internalResponse to response, if response is not a filtered response; otherwise to response’s internal response.

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

         • %応答 の`種別$rs ~EQ `error^l ◎ response’s type is "error"
         • ［ %要請 の`~mode$rq ~EQ `same-origin^l ］~AND［ %応答 の`種別$rs ~EQ `cors^l ］ ◎ request’s mode is "same-origin" and response’s type is "cors"
         • ［ %要請 の`~mode$rq ~NEQ `no-cors^l ］~AND［ %応答 の`種別$rs ~EQ `opaque^l ］ ◎ request’s mode is not "no-cors" and response’s type is "opaque"
         • ［ %要請 の`~redirect~mode$rq ~NEQ `manual^l ］~AND［ %応答 の`種別$rs ~EQ `opaqueredirect^l ］ ◎ request’s redirect mode is not "manual" and response’s type is "opaqueredirect"
         • ［ %要請 の`~redirect~mode$rq ~NEQ `follow^l ］~AND［ %応答 の`~URL~list$rsの`~size$ ~GT 1 ］ ◎ request’s redirect mode is not "follow" and response’s URL list has more than one item.

         …ならば ⇒ ~RET `~network~error$： ◎ then return a network error.

5. ~IF［ %応答 ~EQ ~NULL ］： ◎ If response is null, then:

   1. ~IF［ %~CORS予行を為すか ~EQ ~T ］~AND［ ~OR↓ ］… ◎ If makeCORSPreflight is true and one of these conditions is true:

      • ［ `~methodも合致している~cache~entry$( %要請, %要請 の`~method$rq ) は空である ］~AND［ ~OR↓ ］：

        • %要請 の`~method$rqは `~CORS安全とされる~method$でない
        • %要請 の`~CORS予行を利用するか$rq ~EQ ~T
        ◎ There is no method cache entry match for request’s method using request, and either request’s method is not a CORS-safelisted method or request’s use-CORS-preflight flag is set.
      • `~CORS安全でない要請~header名たち$( %要請 の`~header~list$rq ) 内のある名前に対し ⇒ `~header名も合致している~cache~entry$( %要請, 名前 ) は空である ◎ There is at least one item in the CORS-unsafe request-header names with request’s header list for which there is no header-name cache entry match using request.

      …ならば： ◎ Then:

      1. %予行~応答 ~LET `~CORS予行~fetch$( %要請 ) ◎ Let preflightResponse be the result of running CORS-preflight fetch given request.
      2. ~IF［ %予行~応答 は`~network~error$である ］ ⇒ ~RET %予行~応答 ◎ If preflightResponse is a network error, then return preflightResponse.

      注記： この段は、 `~CORS予行~cache$を検査した上で，相応しい~entryがなければ`~CORS予行~fetch$を遂行し、 成功したならば この~cacheを拡充する。 `~CORS予行~fetch$の目的は、 `~fetch$された資源が`~CORS~protocol$下に~~置かれることを確保することである。 この~cacheは、 `~CORS予行~fetch$の回数を最小限にするためにある。 ◎ This step checks the CORS-preflight cache and if there is no suitable entry it performs a CORS-preflight fetch which, if successful, populates the cache. The purpose of the CORS-preflight fetch is to ensure the fetched resource is familiar with the CORS protocol. The cache is there to minimize the number of CORS-preflight fetches.

   2. ~IF［ %要請 の`~redirect~mode$rq ~EQ `follow^l ］ ⇒ %要請 の`~sw~mode$rq ~SET `none^l ◎ If request’s redirect mode is "follow", then set request’s service-workers mode to "none".

      注記： （~swとは~~対照的に）~networkから来る~redirectは、 ~swには公開されない。 ◎ Redirects coming from the network (as opposed to from a service worker) are not to be exposed to a service worker.

   3. %内部~応答 ~SET `~HTTP~network-or-cache~fetch$( %~fetch~params ) ◎ Set response and internalResponse to the result of running HTTP-network-or-cache fetch given fetchParams.
   4. %応答 ~SET %内部~応答 ◎ ↑

   5. ~IF［ %要請 の`応答~tainting$rq ~EQ `cors^l ］~AND［ `~CORS検査$( %要請, %応答 ) ~EQ `失敗^i ］ ⇒ ~RET `~network~error$ ◎ If request’s response tainting is "cors" and a CORS check for request and response returns failure, then return a network error.

      注記： `~CORS検査$は、［ `状態s$rs ~IN { `304$st, `407$st } なる`応答$ ／ それが問われる~swからの`応答$ ］には適用されないので、 ここで適用される。 ◎ As the CORS check is not to be applied to responses whose status is 304 or 407, or responses from a service worker for that matter, it is applied here.

   6. ~IF［ `~TAO検査$( %要請, %応答 ) ~EQ `失敗^i ］ ⇒ %要請 の`計時許容に失敗したか$rq ~SET ~T ◎ If the TAO check for request and response returns failure, then set request’s timing allow failed flag.

6. ~IF［ `opaque^l ~IN { %要請 の`応答~tainting$rq, %応答 の`種別$rs } ］~AND［ `非同一-生成元~資源~施策~検査$( %要請 の`生成元$rq, %要請 の`~client$rq, %要請 の`行先$rq, %内部~応答 ) ~EQ `阻止される^i ］ ⇒ ~RET `~network~error$ ◎ If either request’s response tainting or response’s type is "opaque", and the cross-origin resource policy check with request’s origin, request’s client, request’s destination, and internalResponse returns blocked, then return a network error.

   注記： `非同一-生成元~資源~施策~検査$は、［ ~network／~sw ］から来た応答~用に走る。 これは、 `~CORS検査$とは異なる — ［ %要請 の`~client$rq, ~sw ］の埋込元~施策は異なり得るので。 ◎ The cross-origin resource policy check runs for responses coming from the network and responses coming from the service worker. This is different from the CORS check, as request’s client and the service worker can have different embedder policies.

7. ~IF［ %内部~応答 の`状態s$rsは`~redirect状態s$である ］： ◎ If internalResponse’s status is a redirect status:

   1. ~IF［ %内部~応答 の`状態s$rs ~NEQ `303$st ］~AND［ %要請 の`本体$rq ~NEQ ~NULL ］~AND［ `接続$は~HTTP2を利用している ］ ⇒ ~UAは `RST_STREAM^c ~frameを伝送してもヨイ — また，そうすることが奨励される。 ◎ If internalResponse’s status is not 303, request’s body is non-null, and the connection uses HTTP/2, then user agents may, and are even encouraged to, transmit an RST_STREAM frame.

      注記： ある種の~communityにおいては、 `303$st は特別な状態sに帰するとみなされ，除外される。 ◎ 303 is excluded as certain communities ascribe special status to it.

   2. %要請 の`~redirect~mode$rq に応じて： ◎ Switch on request’s redirect mode:

      • `error^l ⇒ %応答 ~SET `~network~error$ ◎ "error" • Set response to a network error.

      • `manual^l ： ◎ "manual"

        1. ~IF［ %要請 の`~mode$rq ~EQ `navigate^l ］： %~fetch~params の`制御器$fPの`次回の手動~redirect手続き$fC ~SET 次を走らす手続き ⇒ `~HTTP~redirect~fetch$( %~fetch~params, %応答 ) ◎ If request’s mode is "navigate", then set fetchParams’s controller’s next manual redirect steps to run HTTP-redirect fetch given fetchParams and response.
        2. ~ELSE ⇒ %応答 ~SET %内部~応答 を`内部~応答$とする，`不透明~redirect絞込み応答$ ◎ Otherwise, set response to an opaque-redirect filtered response whose internal response is internalResponse.
      • `follow^l ⇒ %応答 ~SET `~HTTP~redirect~fetch$( %~fetch~params, %応答 ) ◎ "follow" • Set response to the result of running HTTP-redirect fetch given fetchParams and response.

8. ~RET %応答 ◎ Return response.＼

   注記： 手続きはここで終わるが、 その後も概して， %内部~応答 の`本体$rsの`~stream$bdには ~byte列が~enqueueされ続ける。 ◎ Typically internalResponse’s body’s stream is still being enqueued to after returning.

`~HTTP~redirect~fetch@ を遂行する ~algoは、 所与の ( `~fetch~params$ %~fetch~params, `応答$ %応答 ) に対し： ◎ To HTTP-redirect fetch, given a fetch params fetchParams and a response response, run these steps:

1. %要請 ~LET %~fetch~params の`要請$fP ◎ Let request be fetchParams’s request.
2. %内部~応答 ~LET %応答 に応じて ⇒＃ `絞込み応答$でないならば %応答 ／ ~ELSE_ %応答 の`内部~応答$ ◎ Let internalResponse be response, if response is not a filtered response; otherwise response’s internal response.
3. %~Location~URL ~LET `応答の~Location~URLを得る$( %内部~応答, %要請 の`現在の~URL$rqの`素片$url ) ◎ Let locationURL be internalResponse’s location URL given request’s current URL’s fragment.
4. ~IF［ %~Location~URL ~EQ ~NULL ］ ⇒ ~RET %応答 ◎ If locationURL is null, then return response.
5. ~IF［ %~Location~URL ~EQ `失敗^i ］ ⇒ ~RET `~network~error$ ◎ If locationURL is failure, then return a network error.
6. ~IF［ %~Location~URL の`~scheme$urlは`~HTTP_S~scheme$でない ］ ⇒ ~RET `~network~error$ ◎ If locationURL’s scheme is not an HTTP(S) scheme, then return a network error.
7. ~IF［ %要請 の`~redirect回数$rq ~EQ 20 ］ ⇒ ~RET `~network~error$ ◎ If request’s redirect count is 20, then return a network error.
8. %要請 の`~redirect回数$rq ~INCBY 1 ◎ Increase request’s redirect count by 1.
9. ~IF［ %要請 の`~mode$rq ~EQ `cors^l ］~AND［ %~Location~URL は`資格証を含んで$いる ］~AND［ %要請 の`生成元$rq ~NEQ`生成元$sub %~Location~URL の`生成元$url ］ ⇒ ~RET `~network~error$ ◎ If request’s mode is "cors", locationURL includes credentials, and request’s origin is not same origin with locationURL’s origin, then return a network error.

10. ~IF［ %要請 の`応答~tainting$rq ~EQ `cors^l ］~AND［ %~Location~URL は`資格証を含んで$いる ］ ⇒ ~RET `~network~error$ ◎ If request’s response tainting is "cors" and locationURL includes credentials, then return a network error.

    注記： これは、 非同一-生成元~資源による同一-生成元~URLへの~redirectを捕える。 ◎ This catches a cross-origin resource redirecting to a same-origin URL.

11. ~IF［ %内部~応答 の`状態s$rs ~NEQ `303$st ］~AND［ %要請 の`本体$rq ~NEQ ~NULL ］~AND［ %要請 の`本体$rqの`~source$bd ~EQ ~NULL ］ ⇒ ~RET `~network~error$ ◎ If internalResponse’s status is not 303, request’s body is non-null, and request’s body’s source is null, then return a network error.

12. ~IF［［ %内部~応答 の`状態s$rs ~IN { `301$st, `302$st } ］~AND［ %要請 の`~method$rq ~EQ `POST$hm ］］~OR［［ %内部~応答 の`状態s$rs ~EQ `303$st ］~AND［ %要請 の`~method$rq ~NIN { `GET$hm, `HEAD$hm } ］］： ◎ If one of the following is true • internalResponse’s status is 301 or 302 and request’s method is `POST` • internalResponse’s status is 303 and request’s method is not `GET` or `HEAD` ◎ then:

    1. %要請 の ⇒＃ `~method$rq ~SET `GET$hm； `本体$rq ~SET ~NULL ◎ Set request’s method to `GET` and request’s body to null.
    2. `要請~本体~header名$を成す ~EACH( %~header名 ) に対し ⇒ %要請 の`~header~list$rqから`~headerを削除する$( %~header名 ) ◎ For each headerName of request-body-header name, delete headerName from request’s header list.

13. ~IF［ %要請 の`現在の~URL$rqの`生成元$url ~NEQ`生成元$sub %~Location~URL の`生成元$url ］ ⇒ `~CORS非~wildcard要請~header名$を成す ~EACH( %~header名 ) に対し ⇒ %要請 の`~header~list$rqから`~headerを削除する$( %~header名 ) ◎ If request’s current URL’s origin is not same origin with locationURL’s origin, then for each headerName of CORS non-wildcard request-header name, delete headerName from request’s header list.

    注記： すなわち、 初期~要請より後に別の生成元に出くわしたときには， `Authorization$h ~headerは除去される。 ◎ I.e., the moment another origin is seen after the initial request, the `Authorization` header is removed.

14. ~IF［ %要請 の`本体$rq ~NEQ ~NULL ］ ⇒ %要請 の`本体$rq ~SET 次の結果の`本体$bwT ⇒ `本体と型を安全に抽出する$( %要請 の`本体$rqの`~source$bd ) ◎ If request’s body is non-null, then set request’s body to the body of the result of safely extracting request’s body’s source.

    注記： `~source$bdが ~NULL でないことは、 すでに検査~済み。 ◎ request’s body’s source’s nullity has already been checked.

15. %計時~報 ~LET %~fetch~params の`計時~報$fP ◎ Let timingInfo be fetchParams’s timing info.
16. %終了~時刻 ~LET `粗化した共有される現在の時刻$( %~fetch~params の`非同一-生成元~能力は隔離されるか$fP ) ◎ ↓
17. %計時~報 の ⇒＃ `~redirect終了~時刻$fT ~SET %終了~時刻, `~redirect後からの開始~時刻$fT ~SET %終了~時刻 ◎ Set timingInfo’s redirect end time and post-redirect start time to the coarsened shared current time given fetchParams’s cross-origin isolated capability.
18. ~IF［ %計時~報 の`~redirect開始~時刻$fT ~EQ 0 ］ ⇒ %計時~報 の`~redirect開始~時刻$fT ~SET %計時~報 の`開始~時刻$fT ◎ If timingInfo’s redirect start time is 0, then set timingInfo’s redirect start time to timingInfo’s start time.
19. %要請 の`~URL~list$rqに %~Location~URL を付加する ◎ Append locationURL to request’s URL list.
20. `~referrer施策を設定する$( %要請, %内部~応答 ) `REFERRER$r ◎ Invoke set request’s referrer policy on redirect on request and internalResponse. [REFERRER]
21. %再帰的か ~LET ~T ◎ Let recursive be true.

22. ~IF［ %要請 の`~redirect~mode$rq ~EQ `manual^l ］： ◎ If request’s redirect mode is "manual", then:

    1. ~Assert： %要請 の`~mode$rq ~EQ `navigate^l ◎ Assert: request’s mode is "navigate".
    2. %再帰的か ~SET ~F ◎ Set recursive to false.

23. ~RET `~main~fetch$( %~fetch~params, %再帰的か ) ◎ Return the result of running main fetch given fetchParams and recursive.

    注記： %要請 の`応答~tainting$rqが正しくなるよう、 `~main~fetch$を呼出す必要がある。 ◎ This has to invoke main fetch to get request’s response tainting correct.

`~HTTP~network-or-cache~fetch@ を遂行する ~algoは、 所与の ( `~fetch~params$ %~fetch~params, 真偽値 %認証~fetchか ~DF ~F, 真偽値 %新たな接続~fetchか ~DF ~F ) に対し： ◎ To HTTP-network-or-cache fetch, given a fetch params fetchParams, an optional boolean isAuthenticationFetch (default false), and an optional boolean isNewConnectionFetch (default false), run these steps:

注記： `HTTP-CACHING$r に従って， `部分的な内容＠~HTTPsem#status.206$の~cache法を~supportする実装もあるが、 ~browser~cacheからは広く~supportされていない。 ◎ Some implementations might support caching of partial content, as per HTTP Caching. However, this is not widely supported by browser caches. [HTTP-CACHING]

1. %要請 ~LET %~fetch~params の`要請$fP ◎ Let request be fetchParams’s request.
2. %~HTTP~fetch~params ~LET ~NULL ◎ Let httpFetchParams be null.
3. %~HTTP要請 ~LET ~NULL ◎ Let httpRequest be null.
4. %応答 ~LET ~NULL ◎ Let response be null.
5. %格納-済み応答 ~LET ~NULL ◎ Let storedResponse be null.
6. %~HTTP~cache ~LET ~NULL ◎ Let httpCache be null.
7. %再検証-中か ~LET ~F ◎ Let the revalidatingFlag be unset.

8. この段の中は、 %~fetch~params が`取消された$fP`ときは中止する$： ◎ Run these steps, but abort when fetchParams is canceled:

   1. ~IF［ %要請 の`利用者~prompt用の辿可能$rq ~EQ `no-traversable^l ］~AND［ %要請 の`~redirect~mode$rq ~EQ `error^l ］：

      1. %~HTTP~fetch~params ~SET %~fetch~params
      2. %~HTTP要請 ~SET %要請
      ◎ If request’s traversable for user prompts is "no-traversable" and request’s redirect mode is "error", then set httpFetchParams to fetchParams and httpRequest to request.

   2. ~ELSE： ◎ Otherwise:

      1. %~HTTP要請 ~SET `要請を~cloneする$( %要請 ) ◎ Set httpRequest to a clone of request.

         注記： 実装は、［ %要請 の`本体$rq の`~source$bd ~EQ ~NULL ］のときは，［ %要請 の`本体$rq の`~stream$bdを二叉化するのを避ける ］ことが奨励される — その事例では、 必要になる本体は 1 個だけなので （例えば、~redirectや認証は，~fetchを失敗させることになる）。 ◎ Implementations are encouraged to avoid teeing request’s body’s stream when request’s body’s source is null as only a single body is needed in that case. E.g., when request’s body’s source is null, redirects and authentication will end up failing the fetch.

      2. %~HTTP~fetch~params ~SET %~fetch~params の複製 ◎ Set httpFetchParams to a copy of fetchParams.
      3. %~HTTP~fetch~params の`要請$fP ~SET %~HTTP要請 ◎ Set httpFetchParams’s request to httpRequest.

      注記： ［ 利用者~prompt／~redirect ］が生じ得る場合、 ~UAは，［ 利用者が~promptに回答した後／~redirectの所在が決定された後 ］に当の要請を新たな一群の~headerを伴わせて送信し直す必要があるかもしれない。 その時点では，元の要請の本体は すでに部分的に送信されたかもしれないので、 要請を事前に（その本体も含めて）~cloneして，予備の複製を可用にする必要がある。 ◎ If user prompts or redirects are possible, then the user agent might need to re-send the request with a new set of headers after the user answers the prompt or the redirect location is determined. At that time, the original request body might have been partially sent already, so we need to clone the request (including the body) beforehand so that we have a spare copy available.

   3. %資格証を含めるか ~LET ~IS ~OR↓：

      • %要請 の`資格証~mode$rq ~EQ `include^l
      • ［ %要請 の`資格証~mode$rq ~EQ `same-origin^l ］~AND［ `応答~tainting$rq ~EQ `basic^l ］
      ◎ Let includeCredentials be true if one of • request’s credentials mode is "include" • request’s credentials mode is "same-origin" and request’s response tainting is "basic" ◎ is true; otherwise false.
   4. ~IF［ `~Cross-Origin-Embedder-Policyは資格証を許容するか？$( %要請 ) ~EQ ~F ］ ⇒ %資格証を含めるか ~SET ~F ◎ If Cross-Origin-Embedder-Policy allows credentials with request returns false, then set includeCredentials to false.
   5. %内容~長さ ~LET %~HTTP要請 の`本体$rqに応じて ⇒＃ ~NULL ならば ~NULL ／ ~ELSE_ その`長さ$bd ◎ Let contentLength be httpRequest’s body’s length, if httpRequest’s body is non-null; otherwise null.
   6. %Content-Length~header値 ~LET ~NULL ◎ Let contentLengthHeaderValue be null.
   7. ~IF［ %~HTTP要請 の`本体$rq ~EQ ~NULL ］~AND［ %~HTTP要請 の`~method$rq ~IN { `POST$hm, `PUT$hm } ］ ⇒ %Content-Length~header値 ~SET `0^bl ◎ If httpRequest’s body is null and httpRequest’s method is `POST` or `PUT`, then set contentLengthHeaderValue to `0`.
   8. ~IF［ %内容~長さ ~NEQ ~NULL ］ ⇒ %Content-Length~header値 ~SET `同型に符号化する$( `整数を直列化する$( %内容~長さ ) ) ◎ If contentLength is non-null, then set contentLengthHeaderValue to contentLength, serialized and isomorphic encoded.
   9. ~IF［ %Content-Length~header値 ~NEQ ~NULL ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Content-Length$h, %Content-Length~header値 ) ) ◎ If contentLengthHeaderValue is non-null, then append (`Content-Length`, contentLengthHeaderValue) to httpRequest’s header list.

   10. ~IF［ %内容~長さ ~NEQ ~NULL ］~AND［ %~HTTP要請 の`~keepaliveか$rq ~EQ ~T ］： ◎ If contentLength is non-null and httpRequest’s keepalive is true, then:

       1. %~inflight~keepalive~byte数 ~LET 0 ◎ Let inflightKeepaliveBytes be 0.
       2. %~group ~LET %~HTTP要請 の`~client$rqの`~fetch~group$ ◎ Let group be httpRequest’s client’s fetch group.
       3. %~inflight記録~list ~LET ［ %~group 内の`~fetch記録$のうち，その`要請$fRが次を満たすもの ］たちが成す同順の~list ⇒ ［ `~keepaliveか$rq ~EQ ~T ］~AND［ `済んだか$rq ~EQ ~F ］ ◎ Let inflightRecords be the set of fetch records in group whose request’s keepalive is true and done flag is unset.

       4. %~inflight記録~list を成す ~EACH( %~fetch記録 ) に対し： ◎ For each fetchRecord of inflightRecords:

          1. %~inflight要請 ~LET %~fetch記録 の`要請$fR ◎ Let inflightRequest be fetchRecord’s request.
          2. %~inflight~keepalive~byte数 ~INCBY %~inflight要請 の`本体$rqの`長さ$bd ◎ Increment inflightKeepaliveBytes by inflightRequest’s body’s length.

       5. ~IF［ ( %内容~長さ ~PLUS %~inflight~keepalive~byte数 ) ~GT 64 KiB ］ ⇒ ~RET `~network~error$ ◎ If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.

          注記： この~~上限 64 KiB 【 `kibibyte^en — 1024 ~byte単位】は、［ `環境~設定群~obj$の外で残存することが許容され, 本体を包含する要請 【~CSP違反~報告など】 ］に対し、 その~sizeには上限があり，要請が不定期に残り続けないことを確保するためにある。 ◎ The above limit ensures that requests that are allowed to outlive the environment settings object and contain a body, have a bounded size and are not allowed to stay alive indefinitely.

   11. ~IF［ %~HTTP要請 の`~referrer$rqは`~URL$である ］： ◎ If httpRequest’s referrer is a URL, then:

       1. %~referrer値 ~LET `同型に符号化する$( `~URLを直列化する$( %~HTTP要請 の`~referrer$rq ) ) ◎ Let referrerValue be httpRequest’s referrer, serialized and isomorphic encoded.
       2. %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Referer$h, %~referrer値 ) ◎ Append (`Referer`, referrerValue) to httpRequest’s header list.
   12. `要請~Origin~headerを付加する$( %~HTTP要請 ) ◎ Append a request `Origin` header for httpRequest.
   13. `~fetch~metadata~headerたちを付加する$( %~HTTP要請 ) `FETCH-METADATA$r ◎ Append the Fetch metadata headers for httpRequest. [FETCH-METADATA]
   14. ~IF［ %~HTTP要請 の`起動元$rq ~EQ `prefetch^l ］ ⇒ %~HTTP要請 の`~header~list$rq内で`有構造~field値を設定する$( `Sec-Purpose$h, `~sf~token$型の値 `prefetch^l ) ◎ If httpRequest’s initiator is "prefetch", then set a structured field value given (`Sec-Purpose`, the token prefetch) in httpRequest’s header list.
   15. ~IF［ %~HTTP要請 の`~header~list$rq内に［ `User-Agent$h を`名前に持つ~header$ ］は無い ］ ⇒ ~UAは、 次を行うベキである ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `User-Agent$h, `既定の User-Agent 値$ ) ) ◎ If httpRequest’s header list does not contain `User-Agent`, then user agents should append (`User-Agent`, default `User-Agent` value) to httpRequest’s header list.
   16. ~IF［ %~HTTP要請 の`~cache~mode$rq ~EQ `default^l ］~AND［ %~HTTP要請 の`~header~list$rq内に［ `If-Modified-Since$h ／ `If-None-Match$h ／ `If-Unmodified-Since$h ／ `If-Match$h ／ `If-Range$h ］を`名前に持つ~header$は在る ］ ⇒ %要請 の`~cache~mode$rq ~SET `no-store^l ◎ If httpRequest’s cache mode is "default" and httpRequest’s header list contains `If-Modified-Since`, `If-None-Match`, `If-Unmodified-Since`, `If-Match`, or `If-Range`, then set httpRequest’s cache mode to "no-store".
   17. ~IF［ %~HTTP要請 の`~cache~mode$rq ~EQ `no-cache^l ］~AND［ %~HTTP要請 の`~no-cache時には~cache制御~headerを改変しないか$rq ~EQ ~F ］~AND［ %~HTTP要請 の`~header~list$rq内に［ `Cache-Control$h を`名前に持つ~header$ ］は無い ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Cache-Control$h, `max-age=0^bl ) ) ◎ If httpRequest’s cache mode is "no-cache", httpRequest’s prevent no-cache cache-control header modification flag is unset, and httpRequest’s header list does not contain `Cache-Control`, then append (`Cache-Control`, `max-age=0`) to httpRequest’s header list.

   18. ~IF［ %~HTTP要請 の`~cache~mode$rq ~IN { `no-store^l, `reload^l } ］： ◎ If httpRequest’s cache mode is "no-store" or "reload", then:

       1. ~IF［ %~HTTP要請 の`~header~list$rq内に［ `Pragma$h を`名前に持つ~header$ ］は無い ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Pragma$h, `no-cache^bl ) ) ◎ If httpRequest’s header list does not contain `Pragma`, then append (`Pragma`, `no-cache`) to httpRequest’s header list.
       2. ~IF［ %~HTTP要請 の`~header~list$rq内に［ `Cache-Control$h を`名前に持つ~header$ ］は無い ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Cache-Control$h, `no-cache^bl ) ) ◎ If httpRequest’s header list does not contain `Cache-Control`, then append (`Cache-Control`, `no-cache`) to httpRequest’s header list.

   19. ~IF［ %~HTTP要請 の`~header~list$rq内に［ `Range$h を`名前に持つ~header$ ］は在る ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Accept-Encoding$h, `identity^bl ) ) ◎ If httpRequest’s header list contains `Range`, then append (`Accept-Encoding`, `identity`) to httpRequest’s header list.

       注記： これは、 符号化された`応答$の ある部位に対し `内容~符号法sを取扱う$ときの失敗を避ける。 ◎ This avoids a failure when handling content codings with a part of an encoded response.

       加えて， `多くの~server＠https://jakearchibald.github.io/accept-encoding-range-test/$は、［ `identity^bl 以外の符号化法を受容する場合には、 `Range$h ~headerは無視する ］ものと誤認している。 ◎ Additionally, many servers mistakenly ignore `Range` headers if a non-identity encoding is accepted.

   20. ~HTTPに則って %~HTTP要請 の`~header~list$rqを改変する — %~HTTP要請 の`~header~list$rq内に［ 所与の`~header$の`名前$hdを`名前に持つ~header$ ］が在る場合には、 それを`付加-＠#concept-header-list-append$しないこと。 ◎ Modify httpRequest’s header list per HTTP. Do not append a given header if httpRequest’s header list contains that header’s name.

       注記： この段は、 何かもっと規範的な~~形にしたい。 次に挙げる`~header$などは、 必要yなら，この時点で`付加-＠#concept-header-list-append$される ⇒ `Accept-Encoding$h, `Connection$h, `DNT^h, `Host$h ◎ It would be great if we could make this more normative somehow. At this point headers such as `Accept-Encoding`, `Connection`, `DNT`, and `Host`, are to be appended if necessary.

       この時点では、 次に挙げる`~header$は内包しないモノトスル ⇒ `Accept$h, `Accept-Charset$h, `Accept-Language$h ◎ `Accept`, `Accept-Charset`, and `Accept-Language` must not be included at this point.

       注記： ［ `Accept$h, `Accept-Language$h ］は、 すでに内包されている （ `fetch()$m が利用されていない限り — それは、 既定では後者を内包しない）。 また， `Accept-Charset$h は、 内包しても，~byte列を浪費するだけである。 詳細は、 `~HTTP~header層の~~区分＠#http-header-layer-division$を見よ。 ◎ `Accept` and `Accept-Language` are already included (unless fetch() is used, which does not include the latter by default), and `Accept-Charset` is a waste of bytes. See HTTP header layer division for more details.

   21. `(A)^i：
       ~IF［ %資格証を含めるか ~EQ ~T ］： ◎ If includeCredentials is true, then:

       1. ~IF［ ~UAは %~HTTP要請 用の~cookieを阻止するように環境設定されていない （ `COOKIES$r `§ ~privacyの考慮点＠~HTTPcookie#privacy-considerations$ を見よ） ］： ◎ If the user agent is not configured to block cookies for httpRequest (see section 7 of [COOKIES]), then:

          1. %~cookie ~LET 次を与える下で， `"cookie-string" ~algo＠~HTTPcookie#cookie$ `COOKIES$r を走らせた結果 ⇒ ( ~UAの~cookie保管庫, %~HTTP要請 の`現在の~URL$rq ) ◎ Let cookies be the result of running the "cookie-string" algorithm (see section 5.4 of [COOKIES]) with the user agent’s cookie store and httpRequest’s current URL.
          2. ~IF［ %~cookie ~NEQ 空~文字列 ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Cookie$h, %~cookie ) ) ◎ If cookies is not the empty string, then append (`Cookie`, cookies) to httpRequest’s header list.
       2. ~IF［ %~HTTP要請 の`~header~list$rq内に［ `Authorization$h を`名前に持つ~header$ ］は在る ］ ⇒ ~BREAK `(A)^i ◎ If httpRequest’s header list does not contain `Authorization`, then:
       3. %権限付与~値 ~LET ~NULL ◎ Let authorizationValue be null.
       4. ~IF［ %~HTTP要請 用の`認証~entry$は在る ］~AND［［ %~HTTP要請 の`~URL資格証を利用するか$rq ~EQ ~F ］~OR［ %~HTTP要請 の`現在の~URL$rqは`資格証を含んで$いない ］］ ⇒ %権限付与~値 ~SET `認証~entry$ ◎ If there’s an authentication entry for httpRequest and either httpRequest’s use-URL-credentials flag is unset or httpRequest’s current URL does not include credentials, then set authorizationValue to authentication entry.
       5. ~ELIF［ %~HTTP要請 の`現在の~URL$rqは`資格証を含んで$いる ］~AND［ %認証~fetchか ~EQ ~T ］ ⇒ %権限付与~値 ~SET %~HTTP要請 の`現在の~URL$rqを `Authorization$h 値に変換- した結果 ◎ Otherwise, if httpRequest’s current URL does include credentials and isAuthenticationFetch is true, set authorizationValue to httpRequest’s current URL, converted to an `Authorization` value.
       6. ~IF［ %権限付与~値 ~NEQ ~NULL ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `Authorization$h, %権限付与~値 ) ) ◎ If authorizationValue is non-null, then append (`Authorization`, authorizationValue) to httpRequest’s header list.

   22. `~proxy認証~entry$がある場合、 それを適切に利用する ◎ If there’s a proxy-authentication entry, use it as appropriate.

       注記： ここでは意図的に %~HTTP要請 の`資格証~mode$rqに依存しないようにされている。 ◎ This intentionally does not depend on httpRequest’s credentials mode.

   23. %~HTTP~cache ~SET `~HTTP~cache区分を決定する$( %~HTTP要請 ) ◎ Set httpCache to the result of determining the HTTP cache partition, given httpRequest.
   24. ~IF［ %~HTTP~cache ~EQ ~NULL ］ ⇒ %~HTTP要請 の`~cache~mode$rq~SET `no-store^l ◎ If httpCache is null, then set httpRequest’s cache mode to "no-store".

   25. `(B)^i：
       ~IF［ %~HTTP要請 の`~cache~mode$rq ~NIN { `no-store^l, `reload^l } ］： ◎ If httpRequest’s cache mode is neither "no-store" nor "reload", then:

       1. %格納-済み応答 ~SET `HTTP-CACHING$r `§ ~cache からの応答の構築-法＠~HTTPcache#constructing.responses.from.caches$に従って， %~HTTP~cache から応答を選定した結果 ⇒ ~IF［ 該当する応答はない ］ ⇒ ~BREAK `(B)^i

          注記： ~HTTPにより義務付けられたとおり、 これには，依然として `Vary$h `~header$も織り込まれる。

          ◎ Set storedResponse to the result of selecting a response from the httpCache, possibly needing validation, as per the "Constructing Responses from Caches" chapter of HTTP Caching, if any. [HTTP-CACHING] ◎ As mandated by HTTP, this still takes the `Vary` header into account. ◎ If storedResponse is non-null, then:

       2. ~IF［ `~cache~mode$rq ~EQ `default^l ］~AND［ %格納-済み応答 は`~stale-while-revalidate応答$である ］~AND［ %~HTTP要請 の`~client$rq ~NEQ ~NULL ］： ◎ If cache mode is "default", storedResponse is a stale-while-revalidate response, and httpRequest’s client is non-null, then:

          1. %応答 ~SET %格納-済み応答 ◎ Set response to storedResponse.
          2. %応答 の`~cache状態$rs ~SET `local^l ◎ Set response’s cache state to "local".
          3. %再検証-要請 ~LET `要請を~cloneする$( %要請 ) ◎ Let revalidateRequest be a clone of request.
          4. %再検証-要請 の ⇒＃ `~cache~mode$rq ~SET `no-cache^l, `~no-cache時には~cache制御~headerを改変しないか$rq ~SET ~T, `~sw~mode$rq ~SET `none^l ◎ Set revalidateRequest’s cache mode set to "no-cache". ◎ Set revalidateRequest’s prevent no-cache cache-control header modification flag. ◎ Set revalidateRequest’s service-workers mode set to "none".
          5. %再検証-~fetch~params ~LET 新たな`~fetch~params$ — その ⇒＃ `要請$fP ~SET %再検証-要請 ◎ ↓

          6. この段は、 `並列的$に遂行する ⇒ `~main~fetch$( %再検証-~fetch~params ) ◎ In parallel, run main fetch given a new fetch params whose request is revalidateRequest.

             注記： この~fetchに意味されるのは， %~HTTP~cache の状態を更新することに限られ、 対する応答は，別の~cache~accessまで利用されないことになる。 現在の要請に対する応答には、 `非新鮮な応答$が利用されることになる。 この~fetchは，~clientの文脈で発行されるので、 消え去った場合，当の要請（ %再検証-要請 ）は終了されることになる。 ◎ This fetch is only meant to update the state of httpCache and the response will be unused until another cache access. The stale response will be used as the response to current request. This fetch is issued in the context of a client so if it goes away the request will be terminated.

       3. ~ELSE： ◎ Otherwise:

          1. ~IF［ %格納-済み応答 は`非新鮮な応答$である ］ ⇒ %再検証-中か ~SET ~T ◎ If storedResponse is a stale response, then set the revalidatingFlag.

          2. ~IF［ %再検証-中か ~EQ ~T ］~AND［ %~HTTP要請 の`~cache~mode$rq ~NIN { `force-cache^l, `only-if-cached^l } ］： ◎ If the revalidatingFlag is set and httpRequest’s cache mode is neither "force-cache" nor "only-if-cached", then:

             1. ~IF［ %格納-済み応答 の`~header~list$rs内に［ `ETag$h を`名前に持つ~header$ %~header ］は在る† ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `If-None-Match$h, %~header の`値$hd ) ) ◎ If storedResponse’s header list contains `ETag`, then append (`If-None-Match`, `ETag`'s value) to httpRequest’s header list.
             2. ~IF［ %格納-済み応答 の`~header~list$rs内に［ `Last-Modified$h を`名前に持つ~header$ %~header ］は在る† ］ ⇒ %~HTTP要請 の`~header~list$rqに`~headerを付加する$( ( `If-Modified-Since$h, %~header の`値$hd ) ) ◎ If storedResponse’s header list contains `Last-Modified`, then append (`If-Modified-Since`, `Last-Modified`'s value) to httpRequest’s header list.

             【† 該当する`~header$は、 1 つしかないものと見做されている。 】

             注記： `HTTP-CACHING$r `§ 検証~要請の送信-法＠~HTTPcache#validation.sent$ も見よ。 ◎ See also the "Sending a Validation Request" chapter of HTTP Caching. [HTTP-CACHING]

          3. ~ELSE ⇒＃ %応答 ~SET %格納-済み応答； %応答 の`~cache状態$rs ~SET `local^l ◎ Otherwise, set response to storedResponse and set response’s cache state to "local".
9. 前~段が`中止されたときは$ ⇒ ~RET `適切な~network~error$( %~fetch~params ) ◎ If aborted, then return the appropriate network error for fetchParams.

10. ~IF［ %応答 ~EQ ~NULL ］： ◎ If response is null, then:

    1. ~IF［ %~HTTP要請 の`~cache~mode$rq ~EQ `only-if-cached^l ］ ⇒ ~RET `~network~error$ ◎ If httpRequest’s cache mode is "only-if-cached", then return a network error.
    2. %回送-応答 ~LET `~HTTP~network~fetch$( %~HTTP~fetch~params, %資格証を含めるか, %新たな接続~fetchか ) ◎ Let forwardResponse be the result of running HTTP-network fetch given httpFetchParams, includeCredentials, and isNewConnectionFetch.

    3. ~IF［ %~HTTP要請 の`~method$rqは`安全$でない ］~AND［ %回送-応答 の`状態s$rs ~IN { `200^st 〜 `399^st } ］：

       1. `HTTP-CACHING$r `§ 格納-済み応答の無効化-法＠~HTTPcache#invalidation$ に従って， %~HTTP~cache 内の適切な格納-済み応答たちを無効化する
       2. %格納-済み応答 ~SET ~NULL
       ◎ If httpRequest’s method is unsafe and forwardResponse’s status is in the range 200 to 399, inclusive, invalidate appropriate stored responses in httpCache, as per the "Invalidating Stored Responses" chapter of HTTP Caching, and set storedResponse to null. [HTTP-CACHING]

    4. ~IF［ %再検証-中か ~EQ ~T ］~AND［ %回送-応答 の`状態s$rs ~EQ `304$st ］： ◎ If the revalidatingFlag is set and forwardResponse’s status is 304, then:

       1. `HTTP-CACHING$r `§ 検証に際しての，格納-済み応答の新鮮化-法＠~HTTPcache#freshening.responses$ に従って， %回送-応答 の`~header~list$rsを利用して %格納-済み応答 の`~header~list$rsを更新する ◎ Update storedResponse’s header list using forwardResponse’s header list, as per the "Freshening Stored Responses upon Validation" chapter of HTTP Caching. [HTTP-CACHING]

          注記： これは、 ~cache内の格納-済み応答も更新する。 ◎ This updates the stored response in cache as well.

       2. %応答 ~SET %格納-済み応答 ◎ Set response to storedResponse.
       3. %応答 の`~cache状態$rs ~SET `validated^l ◎ Set response’s cache state to "validated".

    5. ~IF［ %応答 ~EQ ~NULL ］： ◎ If response is null, then:

       1. %応答 ~SET %回送-応答 ◎ Set response to forwardResponse.

       2. `HTTP-CACHING$r `§ ~cache内への応答の格納-法＠~HTTPcache#response.cacheability$ に従って， %~HTTP~cache 内に［ %~HTTP要請, %回送-応答 ］を格納する ◎ Store httpRequest and forwardResponse in httpCache, as per the "Storing Responses in Caches" chapter of HTTP Caching. [HTTP-CACHING]

          注記： %回送-応答 が`~network~error$である場合、 これは実質的に，その~network~errorを~cacheする — それは “否定的~cache法（ `negative caching^en ）” と称されることもある。 ◎ If forwardResponse is a network error, this effectively caches the network error, which is sometimes known as "negative caching".

          注記： 結付けられた`本体~報$rsは、 当の応答と併せて~cache内に格納される。 ◎ The associated body info is stored in the cache alongside the response.

11. %応答 の`~URL~list$rs ~SET %~HTTP要請 の`~URL~list$rqを`~cloneする$ ◎ Set response’s URL list to a clone of httpRequest’s URL list.
12. ~IF［ %~HTTP要請 の`~header~list$rq内に［ `Range$h を`名前に持つ~header$ ］は在る ］ ⇒ %応答 の`範囲が要請されたか$rs ~SET ~T ◎ If httpRequest’s header list contains `Range`, then set response’s range-requested flag.
13. %応答 の`要請は資格証を含むか$rs ~SET %資格証を含めるか ◎ Set response’s request-includes-credentials to includeCredentials.

14. ~IF［ %応答 の`状態s$rs ~EQ `401$st ］~AND［ %~HTTP要請 の`応答~tainting$rq ~NEQ `cors^l ］~AND［ %資格証を含めるか ~EQ ~T ］~AND［ %要請 の`利用者~prompt用の辿可能$rqは`辿可能な~navigable$である ］： ◎ If response’s status is 401, httpRequest’s response tainting is not "cors", includeCredentials is true, and request’s traversable for user prompts is a traversable navigable:

    1. 課題： `WWW-Authenticate$h ~header が複数個ある場合, 与えられていない場合, その構文解析, についてのテスト ◎ Needs testing: multiple `WWW-Authenticate` headers, missing, parsing issues.

    2. ~IF［ %要請 の`本体$rq ~NEQ ~NULL ］： ◎ If request’s body is non-null, then:

       1. ~IF［ %要請 の`本体$rqの`~source$bd ~EQ ~NULL ］ ⇒ ~RET `~network~error$ ◎ If request’s body’s source is null, then return a network error.
       2. %要請 の`本体$rq ~SET 次の結果の`本体$bwT ⇒ `本体と型を安全に抽出する$( %要請 の`本体$rqの`~source$bd ) ◎ Set request’s body to the body of the result of safely extracting request’s body’s source.

    3. ~IF［ %要請 の`~URL資格証を利用するか$rq ~EQ ~F ］~OR［ %認証~fetchか ~EQ ~T ］： ◎ If request’s use-URL-credentials flag is unset or isAuthenticationFetch is true, then:

       1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET `適切な~network~error$( %~fetch~params ) ◎ If fetchParams is canceled, then return the appropriate network error for fetchParams.
       2. ( %~username, %~password ) ~LET %要請 の`利用者~prompt用の辿可能$rqにおいて，末端-利用者に ( ~username, ~password ) の~~入力を促して得られた結果 【~~入力が拒否された場合について言及されていない。`中止~network~error$を返す？】 ◎ Let username and password be the result of prompting the end user for a username and password, respectively, in request’s traversable for user prompts.
       3. `~URLの~usernameを設定する$( %要請 の`現在の~URL$rq, %~username ) ◎ Set the username given request’s current URL and username.
       4. `~URLの~passwordを設定する$( %要請 の`現在の~URL$rq, %~password ) ◎ Set the password given request’s current URL and password.
    4. %応答 ~SET `~HTTP~network-or-cache~fetch$( %~fetch~params, ~T ) ◎ Set response to the result of running HTTP-network-or-cache fetch given fetchParams and true.

15. ~IF［ %応答 の`状態s$rs ~EQ `407$st ］： ◎ If response’s status is 407, then:

    1. ~IF［ %要請 の`利用者~prompt用の辿可能$rq ~EQ `no-traversable^l ］ ⇒ ~RET `~network~error$ ◎ If request’s traversable for user prompts is "no-traversable", then return a network error.
    2. 課題： `Proxy-Authenticate$h ~header が複数個ある場合, 与えられていない場合, その構文解析, についてのテスト ◎ Needs testing: multiple `Proxy-Authenticate` headers, missing, parsing issues.
    3. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET `適切な~network~error$( %~fetch~params ) ◎ If fetchParams is canceled, then return the appropriate network error for fetchParams.

    4. %要請 の`利用者~prompt用の辿可能$rqにおいて、 末端-利用者に対し適切に【認証に関する手続きを】促して， その結果を`~proxy認証~entry$として保存する `HTTP$r ◎ Prompt the end user as appropriate in request’s traversable for user prompts and store the result as a proxy-authentication entry. [HTTP]

       注記： ~proxy認証~周辺の詳細は~HTTPにて定義される。 ◎ Remaining details surrounding proxy authentication are defined by HTTP.

    5. %応答 ~SET `~HTTP~network-or-cache~fetch$( %~fetch~params ) ◎ Set response to the result of running HTTP-network-or-cache fetch given fetchParams.

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

    • %応答 の`状態s$rs ~EQ `421$st ◎ response’s status is 421
    • %新たな接続~fetchか ~EQ ~F ◎ isNewConnectionFetch is false
    • ［ %要請 の`本体$rq ~EQ ~NULL ］~OR［［ %要請 の`本体$rq ~NEQ ~NULL ］~AND［ %要請 の`本体$rqの`~source$bd ~NEQ ~NULL ］］ ◎ request’s body is null, or request’s body is non-null and request’s body’s source is non-null

    …ならば： ◎ then:

    1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET `適切な~network~error$( %~fetch~params ) ◎ If fetchParams is canceled, then return the appropriate network error for fetchParams.
    2. %応答 ~SET `~HTTP~network-or-cache~fetch$( %~fetch~params, %認証~fetchか, ~T ) ◎ Set response to the result of running HTTP-network-or-cache fetch given fetchParams, isAuthenticationFetch, and true.
17. ~IF［ %認証~fetchか ~EQ ~T ］ ⇒ ［ %要請, および所与の~realm ］用の`認証~entry$を作成する ◎ If isAuthenticationFetch is true, then create an authentication entry for request and the given realm.

18. ~RET %応答

    注記： 手続きはここで終わるが、 その後も概して， %応答 の`本体$rsの`~stream$bdには~enqueueされ続ける。

    ◎ Return response. Typically response’s body’s stream is still being enqueued to after returning.

`~HTTP~network~fetch@ を遂行する ~algoは、 所与の ( `~fetch~params$ %~fetch~params, 真偽値 %資格証を含めるか ~DF ~F, 真偽値 %新たな接続を強制するか ~DF ~F ) に対し： ◎ To HTTP-network fetch, given a fetch params fetchParams, an optional boolean includeCredentials (default false), and an optional boolean forceNewConnection (default false), run these steps:

1. %要請 ~LET %~fetch~params の`要請$fP ◎ Let request be fetchParams’s request.
2. %応答 ~LET ~NULL ◎ Let response be null.
3. %計時~報 ~LET %~fetch~params の`計時~報$fP ◎ Let timingInfo be fetchParams’s timing info.
4. %~network区分~key ~LET `要請の~network区分~keyを決定する$( %要請 ) ◎ Let networkPartitionKey be the result of determining the network partition key given request.
5. %新たな接続 ~LET %新たな接続を強制するか に応じて ⇒＃ ~T ならば `yes^l ／ ~F ならば `no^l ◎ Let newConnection be "yes" if forceNewConnection is true; otherwise "no".

6. %接続 ~LET %要請 の`~mode$rqに応じて，次を遂行した結果： ◎ Switch on request’s mode:

   • `websocket^l ⇒ `~WebSocket接続を得する$( %要請 の`現在の~URL$rq ) ◎ "websocket" • Let connection be the result of obtaining a WebSocket connection, given request’s current URL.
   • ~ELSE_ ⇒ `接続を得する$( %~network区分~key, %要請 の`現在の~URL$rq, %資格証を含めるか, %新たな接続 ) ◎ Otherwise • Let connection be the result of obtaining a connection, given networkPartitionKey, request’s current URL, includeCredentials, and newConnection.

7. この段の中は、 %~fetch~params が`取消された$fP`ときは中止する$： ◎ Run these steps, but abort when fetchParams is canceled:

   1. ~IF［ %接続 ~EQ `失敗^i ］ ⇒ ~RET `~network~error$ ◎ If connection is failure, then return a network error.
   2. %計時~報 の`最終-接続~計時~報$fT ~SET `接続~計時~報を切詰めて粗化する$( %接続 の`計時~報$, %計時~報 の`~redirect後からの開始~時刻$fT, %~fetch~params の`非同一-生成元~能力は隔離されるか$fP ) ◎ Set timingInfo’s final connection timing info to the result of calling clamp and coarsen connection timing info with connection’s timing info, timingInfo’s post-redirect start time, and fetchParams’s cross-origin isolated capability.
   3. ~IF［ %接続 は~HTTP1x接続である ］~AND［ %要請 の`本体$rq ~NEQ ~NULL ］~AND［ %要請 の`本体$rqの`~source$bd ~EQ ~NULL ］ ⇒ ~RET `~network~error$ ◎ If connection is an HTTP/1.x connection, request’s body is non-null, and request’s body’s source is null, then return a network error.
   4. %計時~報 の`最終-~network要請~開始~時刻$fT ~SET `粗化した共有される現在の時刻$( %~fetch~params の`非同一-生成元~能力は隔離されるか$fP ) ◎ Set timingInfo’s final network-request start time to the coarsened shared current time given fetchParams’s cross-origin isolated capability.

   5. %応答 ~SET 次に挙げる各~条項に従う下で、 %要請 を利用して, %接続 越しに`~HTTP要請$を為した結果： ◎ Set response to the result of making an HTTP request over connection using request with the following caveats:

      • ~HTTPによる関連な要件に従うこと。 `HTTP$r `HTTP-CACHING$r ◎ Follow the relevant requirements from HTTP. [HTTP] [HTTP-CACHING]

      • ［ %要請 の`本体$rq ~NEQ ~NULL ］かつ［ %要請 の`本体$rqの`~source$bd ~EQ ~NULL ］の場合、 64 KiB 以下の~bufferを用意して， %要請 の`本体$rqの一部を その~buffer内に格納してもヨイ。 ~UAは、［ その~bufferの~sizeを超えて %要請 の`本体$rqを読取る ］かつ［ %要請 を送信し直す必要がある ］場合には，代わりに`~network~error$を返すこと。 ◎ If request’s body is non-null, and request’s body’s source is null, then the user agent may have a buffer of up to 64 kibibytes and store a part of request’s body in that buffer. If the user agent reads from request’s body beyond that buffer’s size and the user agent needs to resend request, then instead return a network error.

        注記： 送信し直すのは、 例えば，接続が時間~切れになったときに必要になる。 %要請 の`本体$rqの`~source$bdが： ◎ The resending is needed when the connection is timed out, for example.

        • ~NULL でないときは、 ~bufferは必要ない — %要請 の`本体$rqは，~sourceから作成し直せるので。 ◎ The buffer is not needed when request’s body’s source is non-null, because request’s body can be recreated from it.
        • ~NULL のときは、 `本体$rqは `ReadableStream$I ~objから作成されたこと， したがって作成し直せないことを意味する — ~bufferが必要になるわけは、 それである。 ◎ When request’s body’s source is null, it means body is created from a ReadableStream object, which means body cannot be recreated and that is why the buffer is needed.

      • ~WHILE 無条件： 【すなわち、~HTTP~serverから`最終-応答$が返されるか接続が~errorになるまで，各`~HTTP応答$に対し以下の手続きを繰返す】 ： ◎ While true:

        1. %計時~報 の`最終-~network応答~開始~時刻$fT ~SET ［ ~UAの~HTTP構文解析器が当の応答を成す最初の~byte （例：~HTTP2用の~frame~header~byte列／~HTTP1x用の応答~状態s行l） を受信した直後 ］における， `粗化した共有される現在の時刻$( %~fetch~params の`非同一-生成元~能力は隔離されるか$fP ) ◎ Set timingInfo’s final network-response start time to the coarsened shared current time given fetchParams’s cross-origin isolated capability, immediately after the user agent’s HTTP parser receives the first byte of the response (e.g., frame header bytes for HTTP/2 or response status line for HTTP/1.x).
        2. 当の~HTTP応答の`~header節$全体が伝送されるまで待機する ◎ Wait until all the HTTP response headers are transmitted.
        3. %状態s ~LET 当の~HTTP応答の`状態s~code$ ◎ Let status be the HTTP response’s status code.

        4. ~IF［ %状態s ~IN { `100^st 〜 `199^st } ］： ◎ If status is in the range 100 to 199, inclusive:

           1. ~IF［ %計時~報 の`最初の非最終-~network応答~開始~時刻$fT ~EQ 0 ］ ⇒ %計時~報 の`最初の非最終-~network応答~開始~時刻$fT ~SET %計時~報 の`最終-~network応答~開始~時刻$fT ◎ If timingInfo’s first interim network-response start time is 0, then set timingInfo’s first interim network-response start time to timingInfo’s final network-response start time.
           2. ~IF［ %要請 の`~mode$rq ~EQ `websocket^l ］~AND［ %状態s ~EQ `101$st ］ ⇒ ~BREAK ◎ If request’s mode is "websocket" and status is 101, then break.

           3. ~IF［ %状態s ~EQ `103$st ］~AND［ %~fetch~params の`応答の早期~hintの処理n$fP ~NEQ ~NULL ］ ⇒ `~fetch~taskを~queueする$( 次の手続き, †)

              手続きは ⇒ %~fetch~params の`応答の早期~hintの処理n$fP( `応答$†† )

              【† 2 個目の引数が指定されていない — %~fetch~params の`~taskの行先$fP ？ 】【†† どの応答を指すのか指定されていない — 当の~HTTP応答を表現する`応答$？ 】

              ◎ If status is 103 and fetchParams’s process early hints response is non-null, then queue a fetch task to run fetchParams’s process early hints response, with response.
           4. ~CONTINUE ◎ Continue.

           注記： この種類の`~HTTP応答$【`非最終-応答$】には、 最終的に， “最終” ~HTTP応答【`最終-応答$】が後続する。 ◎ These kind of HTTP responses are eventually followed by a "final" HTTP response.

        5. ~BREAK ◎ Break.

      注記： ~Fetch層と~HTTP層の正確な重ね方は、 依然として~~整理される必要がある。 したがって、 ここでの %応答 は，`応答$と`~HTTP応答$の両者を表現する。 ◎ The exact layering between Fetch and HTTP still needs to be sorted through and therefore response represents both a response and an HTTP response here.

      • `~HTTP要請$による結果，~TLS~client証明書~dialogになるときは： ◎ If the HTTP request results in a TLS client certificate dialog, then:

        1. ~IF［ %要請 の`利用者~prompt用の辿可能$rqは`辿可能な~navigable$である ］ ⇒ %要請 の`利用者~prompt用の辿可能$rqにおいて当の~dialogを可用にする ◎ If request’s traversable for user prompts is a traversable navigable, then make the dialog available in request’s traversable for user prompts.
        2. ~ELSE ⇒ ~RET `~network~error$ ◎ Otherwise, return a network error.

      • %要請 の`本体$rq %本体 を伝送する~algoは： ◎ To transmit request’s body body, run these steps:

        1. ~IF［ %本体 ~EQ ~NULL ］：

           1. %要請の本体~終了~時の処理n ~LET %~fetch~params の`要請の本体~終了~時の処理n$fP
           2. ~IF［ %要請の本体~終了~時の処理n ~NEQ ~NULL ］ ⇒ `~fetch~taskを~queueする$( %要請の本体~終了~時の処理n, %~fetch~params の`~taskの行先$fP )
           3. ~RET
           ◎ If body is null and fetchParams’s process request end-of-body is non-null, then queue a fetch task given fetchParams’s process request end-of-body and fetchParams’s task destination. ◎ Otherwise, if body is non-null:

        2. %本体~chunkの処理n ~LET 所与の ( %~byte列 ) に対し，次を走らす手続き： ◎ Let processBodyChunk given bytes be these steps:

           1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET ◎ If fetchParams is canceled, then abort these steps.
           2. この段は、 `並列的$に走らす ⇒ %~byte列 を伝送する 【この段は具体的に何をする？】 ◎ Run this step in parallel: transmit bytes.
           3. %要請の本体~chunk長さの処理n ~LET %~fetch~params の`要請の本体~chunk長さの処理n$fP ◎ ↓
           4. ~IF［ %要請の本体~chunk長さの処理n ~NEQ ~NULL ］ ⇒ %要請の本体~chunk長さの処理n( %~byte列 の`長さ$ ) ◎ If fetchParams’s process request body chunk length is non-null, then run fetchParams’s process request body chunk length given bytes’s length.

        3. %本体~終了~時の処理n ~LET 次を走らす手続き： ◎ Let processEndOfBody be these steps:

           1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET ◎ If fetchParams is canceled, then abort these steps.
           2. %要請の本体~終了~時の処理n ~LET %~fetch~params の`要請の本体~終了~時の処理n$fP ◎ ↓
           3. ~IF［ %要請の本体~終了~時の処理n ~NEQ ~NULL ］ ⇒ %要請の本体~終了~時の処理n() ◎ If fetchParams’s process request end-of-body is non-null, then run fetchParams’s process request end-of-body.

        4. %本体~errorの処理n ~LET 所与の ( %~error ) に対し，次を走らす手続き： ◎ Let processBodyError given e be these steps:

           1. ~IF［ %~fetch~params は`取消された$fP ］ ⇒ ~RET ◎ If fetchParams is canceled, then abort these steps.
           2. ~IF［ %~error は `AbortError$E 例外である ］ ⇒ `~fetchを中止する$( %~fetch~params の`制御器$fP ) ◎ If e is an "AbortError" DOMException, then abort fetchParams’s controller.
           3. ~ELSE ⇒ `~fetchを終了する$( %~fetch~params の`制御器$fP ) ◎ Otherwise, terminate fetchParams’s controller.
        5. `本体を増分的に読取る$( ↓ ) ⇒＃ %要請 の`本体$rq, %本体~chunkの処理n, %本体~終了~時の処理n, %本体~errorの処理n, %~fetch~params の`~taskの行先$fP ◎ Incrementally read request’s body given processBodyChunk, processEndOfBody, processBodyError, and fetchParams’s task destination.

8. 前~段が`中止されたときは$： ◎ If aborted, then:

   1. ~IF［ %接続 は~HTTP2を利用している ］ ⇒ `RST_STREAM^c ~frameを伝送する ◎ If connection uses HTTP/2, then transmit an RST_STREAM frame.
   2. ~RET `適切な~network~error$( %~fetch~params ) ◎ Return the appropriate network error for fetchParams.

9. %~buffer ~LET 空な`~byte列$ ◎ Let buffer be an empty byte sequence.

   注記： これは、［ ~UAの~network層の内側にある内部~buffer ］を表現する。 ◎ This represents an internal buffer inside the network layer of the user agent.

10. %~stream ~LET `新たな~obj$( `ReadableStream$I ) ◎ Let stream be a new ReadableStream.

11. %~pull~algo ~LET 次の手続き ◎ Let pullAlgorithm be the following steps:

    手続きは： ◎ ↑

    1. %~promise ~LET `新たな~promise$ ◎ Let promise be a new promise.

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

       1. ~IF［ %~buffer の~size ~LT ~UAが選ぶ下限 ］~AND［ 進行中な~fetchは`休止-$している ］ ⇒ 当の~fetchを`再開-$する ◎ If the size of buffer is smaller than a lower limit chosen by the user agent and the ongoing fetch is suspended, resume the fetch.
       2. 次が満たされるまで待機する ⇒ %~buffer は空でない ◎ Wait until buffer is not empty.

       3. `~fetch~taskを~queueする$( 次の手続き, %~fetch~params の`~taskの行先$fP ) ◎ Queue a fetch task to run the following steps, with fetchParams’s task destination.

          手続きは： ◎ ↑

          1. %~stream の中へ`~byte列から~pullする$RS( %~buffer ) ◎ Pull from bytes buffer into stream.
          2. ~IF［ %~stream は`~errorした$RS ］ ⇒ `~fetchを終了する$( %~fetch~params の`制御器$fP ) ◎ If stream is errored, then terminate fetchParams’s controller.
          3. `~promiseを解決する$( %~promise, `undefined^jv ) ◎ Resolve promise with undefined.
    3. ~RET %~promise ◎ Return promise.

12. %取消~algo ~LET 次の手続き

    手続きは、 所与の ( %事由 ) に対し ⇒ `~fetchを中止する$( %~fetch~params の`制御器$fP, %事由 )
    ◎ Let cancelAlgorithm be an algorithm that aborts fetchParams’s controller with reason, given reason.
13. %~stream を`~byte読取り~support付きで設定しておく$RS — 次を与える下で ⇒＃ `~pull~algo^i ~SET %~pull~algo, `取消~algo^i ~SET %取消~algo ◎ Set up stream with byte reading support with pullAlgorithm set to pullAlgorithm, cancelAlgorithm set to cancelAlgorithm.
14. %応答 の`本体$rs ~SET 新たな`本体$ — その ⇒ `~stream$bd ~SET %~stream ◎ Set response’s body to a new body whose stream is stream.
15. ◎追跡路 ~IF［ %資格証を含めるか ~EQ ~T ］~AND［ ~UAは %要請 用の~cookieを阻止するように環境設定されていない （ `COOKIES$r `§ ~privacyの考慮点＠~HTTPcookie#privacy-considerations$を見よ） ］ ⇒ %応答 の`~header~list$rsを成す ~EACH( `Set-Cookie$h を`名前に持つ~header$ %~header ) に対し ⇒ 次を与える下で， `COOKIES$r の `"set-cookie-string" 構文解析~algo＠~HTTPcookie#set-cookie$を走らす ⇒ ( %~header の`値$hd, %要請 の`現在の~URL$rq ) ◎ (This is a tracking vector.) If includeCredentials is true and the user agent is not configured to block cookies for request (see section 7 of [COOKIES]), then run the "set-cookie-string" parsing algorithm (see section 5.2 of [COOKIES]) on the value of each header whose name is a byte-case-insensitive match for `Set-Cookie` in response’s header list, if any, and request’s current URL.

16. この段は、 `並列的$に走らす： ◎ Run these steps in parallel:

    1. この段の中は、 %~fetch~params が`取消された$fP`ときは中止する$： ◎ Run these steps, but abort when fetchParams is canceled:

       ~WHILE 無条件： ◎ While true:

       1. ~IF［ %応答 の`内容$から 1 個 以上の~byteが伝送された ］： ◎ If one or more bytes have been transmitted from response’s message body, then:

          1. %~byte列 ~LET 伝送された~byte列 ◎ Let bytes be the transmitted bytes.
          2. %符号法s ~LET `~header~listから値を抽出する$( %応答 の`~header~list$rs, `Content-Encoding$h ) ◎ Let codings be the result of extracting header list values given `Content-Encoding` and response’s header list.

          3. %応答 の`本体~報$rsの`内容~符号化法$fT ~SET 次の手続きを遂行した結果：

             手続きは：

             1. ~IF［ %符号法s ~IN { ~NULL, `失敗^i } ］ ⇒ ~RET 空~文字列
             2. ~IF［ %符号法s の`~size$ ~GT 1 ］ ⇒ ~RET `multiple^l
             3. %符号法 ~LET %符号法s[ 0 ]
             4. ~IF［ %符号法 の`長さ$ ~EQ 0 ］ ⇒ ~RET 空~文字列

             5. ~IF［ ~AND↓ ］…

                • %符号法 は`~HTTP内容~符号法~registry＠~IANA-a/http-parameters/#content-coding$cite `IANA-HTTP-PARAMS$r 内に挙げられた ある~entryに`~byte大小無視$で合致する
                • ~UAは %符号法 を~supportする

                …ならば：

                1. %符号法 ~SET `~byte小文字~化する$( %符号法 )
                2. ~RET `同型に復号する$( %符号法 )

                【 “同型に復号する” は、 この訳による補完。 】

             6. ~RET `@unknown^l
             ◎ Let filteredCoding be "@unknown". ◎ If codings is null or failure, then set filteredCoding to the empty string. ◎ Otherwise, if codings’s size is greater than 1, then set filteredCoding to "multiple". ◎ Otherwise, if codings[0] is the empty string, or it is supported by the user agent, and is a byte-case-insensitive match for an entry listed in the HTTP Content Coding Registry, then set filteredCoding to the result of byte-lowercasing codings[0]. [IANA-HTTP-PARAMS] ◎ Set response’s body info’s content encoding to filteredCoding.
          4. %応答 の`本体~報$rsの`符号化された~size$fT ~INCBY %~byte列 の`長さ$ ◎ Increase response’s body info’s encoded size by bytes’s length.

          5. %~byte列 ~SET `内容~符号法sを取扱う$( %符号法s, %~byte列 ) ◎ Set bytes to the result of handling content codings given codings and bytes.

             注記： これは、 依拠-可能であった `Content-Length^h `~header$を依拠-不能にする。 ◎ This makes the `Content-Length` header unreliable to the extent that it was reliable to begin with.

          6. %応答 の`本体~報$rsの`復号した~size$fT ~INCBY %~byte列 の`長さ$ ◎ Increase response’s body info’s decoded size by bytes’s length.
          7. ~IF［ %~byte列 ~EQ `失敗^i ］ ⇒ `~fetchを終了する$( %~fetch~params の`制御器$fP ) ◎ If bytes is failure, then terminate fetchParams’s controller.
          8. %~buffer に %~byte列 を付加する ◎ Append bytes to buffer.
          9. ~IF［ %~buffer の~size ~GT ~UAが選ぶ上限 ］ ⇒ 進行中な~fetchを`休止-$するよう，~UAに依頼する ◎ If the size of buffer is larger than an upper limit chosen by the user agent, ask the user agent to suspend the ongoing fetch.
       2. ~ELIF［ %応答 の`内容$用の~byte列の伝送は，正常に終えられた ］ ⇒ ~IF［ %~stream は`読取n可能$RSである ］ ⇒＃ %~stream を`~closeする$RS()； ~BREAK ◎ Otherwise, if the bytes transmission for response’s message body is done normally and stream is readable, then close stream, and abort these in-parallel steps.

    2. 前~段が`中止されたときは$： ◎ If aborted, then:

       1. ~IF［ %~fetch~params は`中止された$fP ］： ◎ If fetchParams is aborted, then:

          1. %応答 の`中止されたか$rs ~SET ~T ◎ Set response’s aborted flag.

          2. ~IF［ %~stream は`読取n可能$RSである ］：

             1. %~error ~LET `直列化された中止-事由を逆直列化する$( %~fetch~params の`制御器$fPの`直列化された中止-事由$, `実装定義$な`~realm$ )
             2. %~stream を`~errorにする$RS( %~error )
             ◎ If stream is readable, then error stream with the result of deserialize a serialized abort reason given fetchParams’s controller’s serialized abort reason and an implementation-defined realm.
       2. ~ELIF［ %~stream は`読取n可能$RSである ］ ⇒ %~stream を`~errorにする$RS( `TypeError$E ) ◎ Otherwise, if stream is readable, error stream with a TypeError.
       3. ~IF［ %接続 は~HTTP2を利用している ］ ⇒ `RST_STREAM^c ~frameを伝送する ◎ If connection uses HTTP/2, then transmit an RST_STREAM frame.

       4. ~ELSE ⇒ ~UAは接続を~closeするベキである — そうすると処理能が悪化するときは除いて ◎ Otherwise, the user agent should close connection unless it would be bad for performance to do so.

          注記： 一例として，~UAは、 再利用-可能な接続にて，伝送する~byte数が残りわずかしかないと知るならば、 接続を~openしたまま保つこともできる。 この事例では、 接続を~closeして 次の~fetch用に~handshake処理-をやり直すと，悪化することもあるので。 ◎ For instance, the user agent could keep the connection open if it knows there’s only a few bytes of transfer remaining on a reusable connection. In this case it could be worse to close the connection and go through the handshake process again for the next fetch.

    注記： この段を`並列的$に走らせているのは、 この時点では， %応答 の`本体$rsが関連するかどうか明瞭でないためである （ %応答 は~redirectかもしれない）。 ◎ These are run in parallel as at this point it is unclear whether response’s body is relevant (response might be a redirect).

17. ~RET %応答

    注記： 手続きはここで終わるが、 その後も概して， %応答 の`本体$rsの`~stream$bdには~enqueueされ続ける。

    ◎ Return response. Typically response’s body’s stream is still being enqueued to after returning.

`~CORS予行~fetch@ を遂行する ~algoは、 所与の ( `要請$ %要請 ) に対し： ◎ To CORS-preflight fetch, given a request request, run these steps:

1. %予行 ~LET 新たな`要請$ — その ⇒＃ `~method$rq ~SET `OPTIONS$hm, `~URL~list$rq ~SET %要請 の`~URL~list$rqを`~cloneする$, `起動元$rq ~SET %要請 の`起動元$rq, `行先$rq ~SET %要請 の`行先$rq, `生成元$rq ~SET %要請 の`生成元$rq, `~referrer$rq ~SET %要請 の`~referrer$rq, `~referrer施策$rq ~SET %要請 の`~referrer施策$rq, `~mode$rq ~SET `cors^l, `応答~tainting$rq ~SET `cors^l ◎ Let preflight be a new request whose method is `OPTIONS`, URL list is a clone of request’s URL list, initiator is request’s initiator, destination is request’s destination, origin is request’s origin, referrer is request’s referrer, referrer policy is request’s referrer policy, mode is "cors", and response tainting is "cors".

   注記： %予行 の`~sw~mode$rqは問われない — この~algoは、 `~HTTP~fetch$ではなく， `~HTTP~network-or-cache~fetch$を利用するので。 ◎ The service-workers mode of preflight does not matter as this algorithm uses HTTP-network-or-cache fetch rather than HTTP fetch.

2. %予行 の`~header~list$rqに`~headerを付加する$( ( `Accept$h, `*/*^bl ) ) ◎ Append (`Accept`, `*/*`) to preflight’s header list.
3. %予行 の`~header~list$rqに`~headerを付加する$( ( `Access-Control-Request-Method$h, %要請 の`~method$rq ) ) ◎ Append (`Access-Control-Request-Method`, request’s method) to preflight’s header list.
4. %~header群 ~LET `~CORS安全でない要請~header名たち$( %要請 の`~header~list$rq ) ◎ Let headers be the CORS-unsafe request-header names with request’s header list.

5. ~IF［ %~header群 は`空$でない ］： ◎ If headers is not empty, then:

   1. %値 ~LET %~header群 を成す各~itemを順に， `,^bl で分離して~~連結した結果 ◎ Let value be the items in headers separated from each other by `,`.
   2. %予行 の`~header~list$rqに`~headerを付加する$( ( `Access-Control-Request-Headers$h, %値 ) ) ◎ Append (`Access-Control-Request-Headers`, value) to preflight’s header list.

   注記： ここで`~headerを結合する$を利用しないのは意図的である。 これは［ `2C^X `20^X ］並びによる仕方で実装されてはいないので — 功罪はあれど。 ◎ This intentionally does not use combine, as 0x20 following 0x2C is not the way this was implemented, for better or worse.

6. %予行~fetch~params ~LET 新たな`~fetch~params$ — その ⇒＃ `要請$fP ~SET %予行 ◎ ↓
7. %応答 ~LET `~HTTP~network-or-cache~fetch$( %予行~fetch~params ) ◎ Let response be the result of running HTTP-network-or-cache fetch given a new fetch params whose request is preflight.

8. ~IF［ `~CORS検査$( %要請, %応答 ) ~EQ `成功^i ］~AND［ %応答 の`状態s$rs は`~ok状態s$である ］： ◎ If a CORS check for request and response returns success and response’s status is an ok status, then:

   注記： 正しい`資格証~mode$rqの利用を確保するため、 `~CORS検査$は， %予行 ではなく %要請 に対して行う。 ◎ The CORS check is done on request rather than preflight to ensure the correct credentials mode is used.

   1. %~method群 ~LET `~header~listから値を抽出する$( %応答 の`~header~list$rs, `Access-Control-Allow-Methods$h ) ◎ Let methods be the result of extracting header list values given `Access-Control-Allow-Methods` and response’s header list.
   2. %~header名~群 ~LET `~header~listから値を抽出する$( %応答 の`~header~list$rs, `Access-Control-Allow-Headers$h ) ◎ Let headerNames be the result of extracting header list values given `Access-Control-Allow-Headers` and response’s header list.
   3. ~IF［ %~method群 ~EQ `失敗^i ］~OR［ %~header名~群 ~EQ `失敗^i ］ ⇒ ~RET `~network~error$ ◎ If either methods or headerNames is failure, return a network error.

   4. ~IF［ %~method群 ~EQ ~NULL ］~AND［ `~CORS予行を利用するか$rq ~EQ ~T ］ ⇒ %~method群 ~SET « %要請 の`~method$rq » ◎ If methods is null and request’s use-CORS-preflight flag is set, then set methods to a new list containing request’s method.

      注記： これにより、 単に［ %要請 の`~CORS予行を利用するか$rq ~EQ ~T ］であることに因り生じる`~CORS予行~fetch$も，`~cacheされる＠#concept-cache$。 ◎ This ensures that a CORS-preflight fetch that happened due to request’s use-CORS-preflight flag being set is cached.

   5. ~IF［ %要請 の`~method$rq ~NIN %~method群 ］~AND［ %要請 の`~method$rqは`~CORS安全とされる~method$でない ］~AND［［ %要請 の`資格証~mode$rq ~EQ `include^l ］~OR［ `*^bl ~NIN %~method群 ］］ ⇒ ~RET `~network~error$ ◎ If request’s method is not in methods, request’s method is not a CORS-safelisted method, and request’s credentials mode is "include" or methods does not contain `*`, then return a network error.

   6. %要請 の`~header~list$rqを成す ~EACH( %~header ) に対し：

      1. ~IF［ %~header は %~header名~群 を成すある名前を`名前に持つ~header$である ］ ⇒ ~CONTINUE
      2. ~IF［ %~header は ある`~CORS非~wildcard要請~header名$を`名前に持つ~header$である ］ ⇒ ~RET `~network~error$
      ◎ If one of request’s header list’s names is a CORS non-wildcard request-header name and is not a byte-case-insensitive match for an item in headerNames, then return a network error.
   7. ~IF［ %要請 の`資格証~mode$rq ~EQ `include^l ］~OR［ `*^bl ~NIN %~header名~群 ］ ⇒ `~CORS安全でない要請~header名たち$( %要請 の`~header~list$rq ) を成す ~EACH( %安全でない~header名 ) に対し ⇒ %~header名~群 を成す ~EACH( %~header名 ) に対し ⇒ ~IF［ ( %安全でない~header名, %~header名 ) は`~byte大小無視$で合致する ］ ⇒ ~RET `~network~error$ ◎ For each unsafeName of the CORS-unsafe request-header names with request’s header list, if unsafeName is not a byte-case-insensitive match for an item in headerNames and request’s credentials mode is "include" or headerNames does not contain `*`, return a network error.
   8. %寿命 ~LET `~header~listから値を抽出する$( %応答 の`~header~list$rs, `Access-Control-Max-Age$h ) ◎ Let max-age be the result of extracting header list values given `Access-Control-Max-Age` and response’s header list.
   9. ~IF［ %寿命 ~IN { `失敗^i, ~NULL } ］ ⇒ %寿命 ~SET 5 ◎ If max-age is failure or null, then set max-age to 5.
   10. ~IF［ %寿命 ~GT 環境により課される`寿命$ccの上限 ］ ⇒ %寿命 ~SET その上限 ◎ If max-age is greater than an imposed limit on max-age, then set max-age to the imposed limit.
   11. ~IF［ ~UAは`~CORS予行~cache$を供していない ］ ⇒ ~RET %応答 ◎ If the user agent does not provide for a cache, then return response.

   12. %~method群 を成す ~EACH( %~method ) に対し：

       1. %~entry群 ~LET `~methodも合致している~cache~entry$( %要請, %~method )
       2. ~IF［ %~entry群 は空でない ］ ⇒ %~entry群 を成す ~EACH( %~entry ) に対し ⇒ %~entry の`寿命$cc ~SET %寿命
       3. ~ELSE ⇒ `新たな~cache~entryを作成する$( %要請, %寿命, %~method, ~NULL )
       ◎ For each method in methods for which there is a method cache entry match using request, set matching entry’s max-age to max-age. ◎ For each method in methods for which there is no method cache entry match using request, create a new cache entry with request, max-age, method, and null.

   13. %~header名~群 を成す ~EACH( %~header名 ) に対し：

       1. %~entry群 ~LET `~header名も合致している~cache~entry$( %要請, %~header名 )
       2. ~IF［ %~entry群 ~NEQ ε ］ ⇒ %~entry群 を成す ~EACH( %~entry ) に対し ⇒ %~entry の`寿命$cc ~SET %寿命

       3. ~ELSE ⇒ `新たな~cache~entryを作成する$( %要請, %寿命, ~NULL, %~header名 )

       ◎ For each headerName in headerNames for which there is a header-name cache entry match using request, set matching entry’s max-age to max-age. ◎ For each headerName in headerNames for which there is no header-name cache entry match using request, create a new cache entry with request, max-age, null, and headerName.
   14. ~RET %応答 ◎ Return response.
9. ~ELSE ⇒ ~RET `~network~error$ ◎ Otherwise, return a network error.

`新たな~cache~entryを作成する@ ~algoは、 所与の ( %要請, %寿命, %~method, %~header名 ) に対し： ◎ To create a new cache entry, given request, max-age, method, and headerName, run these steps:

1. %~entry ~LET 新たな`~cache~entry$ — その ⇒＃ `~key$cc ~SET `要請の~network区分~keyを決定する$( %要請 ), `~byte直列化した生成元$cc ~SET `要請の生成元を~byte直列化する$( %要請 ), `~URL$cc ~SET %要請 の`現在の~URL$rq, `寿命$cc ~SET %寿命, `資格証の有無$cc ~SET ［%要請 の`資格証~mode$rq ~EQ `include^l ならば `有り^i ／ ~ELSE_ `無し^i ］, `~method$cc ~SET %~method, `~header名$cc ~SET %~header名 ◎ Let entry be a cache entry, initialized as follows: ◎ key • The result of determining the network partition key given request byte-serialized origin • The result of byte-serializing a request origin with request URL • request’s current URL max-age • max-age credentials • True if request’s credentials mode is "include", and false otherwise method • method header name • headerName
2. `~CORS予行~cache$に［ 新たな`~cache~entry$ ］を`付加する$ ◎ Append entry to the user agent’s CORS-preflight cache.

`~cache~entryを~clearする@ ~algoは、 所与の ( %要請 ) に対し：

1. ~UAの`~CORS予行~cache$から， ~AND↓ を満たす`~cache~entry$をすべて除去する：

   • `~key$cc ~EQ `要請の~network区分~keyを決定する$( %要請 )
   • `~byte直列化した生成元$cc ~EQ `要請の生成元を~byte直列化する$( %要請 )
   • `~URL$cc ~EQ %要請 の`現在の~URL$rq

`~methodも合致している~cache~entry@ は、 所与の ( %要請, %~method ) に対し，~UAの`~CORS予行~cache$内にある，次を満たす`~cache~entry$たちが成す集合を返す ⇒ ［ %要請 に`~cache合致する$ ］~AND［ `~method$cc ~IN { %~method, `*^bl } ］ ◎ There is a method cache entry match for method using request when there is a cache entry in the user agent’s CORS-preflight cache for which there is a cache entry match with request and its method is method or `*`.

【† 原文からは、 該当する~entryは高々 1 個のように解釈できそうだが， 複数あり得るかもしれない — はっきりしないので、 この用語を利用している箇所も含め，複数あり得るとみなして訳している。 次の用語も同様。 】

`~header名も合致している~cache~entry@ は、 所与の ( %要請, %~header名 ) に対し，~UAの`~CORS予行~cache$内にある，次を満たす`~cache~entry$たちが成す集合を返す ⇒ ［ %要請 に`~cache合致する$ ］~AND［ ( ~entryの`~header名$cc %名前, %~header名 ) は ~OR↓ を満たす ］： ◎ There is a header-name cache entry match for headerName using request when there is a cache entry in the user agent’s CORS-preflight cache for which there is a cache entry match with request and＼

`~CORS検査@ を遂行する ~algoは、 所与の ( %要請, %応答 ) に対し： ◎ To perform a CORS check for a request and response, run these steps:

1. %生成元 ~LET `~header~listから値を取得する$( %応答 の`~header~list$rs, `Access-Control-Allow-Origin$h ) ◎ Let origin be the result of getting `Access-Control-Allow-Origin` from response’s header list.

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

   注記： ~NULL は `null^bl でないことに注意。 ◎ Null is not `null`.

3. ~IF［ %要請 の`資格証~mode$rq ~NEQ `include^l ］~AND［ %生成元 ~EQ `*^bl ］ ⇒ ~RET `成功^i ◎ If request’s credentials mode is not "include" and origin is `*`, then return success.
4. ~IF［ `要請の生成元を~byte直列化する$( %要請 ) ~NEQ %生成元 ］ ⇒ ~RET `失敗^i ◎ If the result of byte-serializing a request origin with request is not origin, then return failure.
5. ~IF［ %要請 の`資格証~mode$rq ~NEQ `include^l ］ ⇒ ~RET `成功^i ◎ If request’s credentials mode is not "include", then return success.
6. %資格証を伴うか ~LET `~header~listから値を取得する$( %応答 の`~header~list$rs, `Access-Control-Allow-Credentials$h ) ◎ Let credentials be the result of getting `Access-Control-Allow-Credentials` from response’s header list.
7. ~IF［ %資格証を伴うか ~EQ `true^bl ］ ⇒ ~RET `成功^i ◎ If credentials is `true`, then return success.
8. ~RET `失敗^i ◎ Return failure.

`~guardで検証する@ ~algoは、 所与の ( `~byte列$ %名前, `~byte列$ %値, `Headers$I ~obj %headers ) に対し： ◎ To validate a header (name, value) for a Headers object headers:

1. ~IF［ %名前 は`~header名$でない ］~OR［ %値 は`~header値$でない ］ ⇒ ~THROW `TypeError$E ◎ If name is not a header name or value is not a header value, then throw a TypeError.

2. %headers の`~guard$Hlに応じて：

   • `immutable^l ⇒ ~THROW `TypeError$E
   • `request^l ⇒ ~IF［ ( %名前, %値 ) は`禁止~要請~header$を成す ］ ⇒ ~RET ~F
   • `response^l ⇒ ~IF［ %名前 は`禁止~応答~header名$である ］ ⇒ ~RET ~F
   • `request-no-cors^l ⇒ 何もしない† ◎ ↓
   ◎ If headers’s guard is "immutable", then throw a TypeError. ◎ If headers’s guard is "request" and (name, value) is a forbidden request-header, then return false. ◎ If headers’s guard is "response" and name is a forbidden response-header name, then return false.
3. ~RET ~T ◎ Return true.

† 注記： `request-no-cors^l に対しては、 この~algoとは別々に検証される — 事例ごとに処理法が異なるので。 ◎ Steps for "request-no-cors" are not shared as you cannot have a fake value (for delete()) that always succeeds in CORS-safelisted request-header.

`Headers$I ~obj %headers に `~headerを付加する@Hl ~algoは、 所与の ( `~byte列$ %名前, `~byte列$ %値 ) に対し： ◎ To append a header (name, value) to a Headers object headers, run these steps:

1. %値 ~SET `値を正規化する$( %値 ) ◎ Normalize value.
2. ~IF［ `~guardで検証する$( %名前, %値, %headers ) ~EQ ~F ］ ⇒ ~RET ◎ If validating (name, value) for headers returns false, then return.

3. ~IF［ %headers の`~guard$Hl ~EQ `request-no-cors^l ］： ◎ If headers’s guard is "request-no-cors":

   1. %一時的な値 ~LET `~header~listから値を取得する$( %headers の`~header~list$Hl, %名前 ) ◎ Let temporaryValue be the result of getting name from headers’s header list.
   2. ~IF［ %一時的な値 ~EQ ~NULL ］ ⇒ %一時的な値 ~SET %値 ◎ If temporaryValue is null, then set temporaryValue to value.
   3. ~ELSE ⇒ %一時的な値 に次を順に付加する ⇒＃ `2C^X, `20^X, %値 ◎ Otherwise, set temporaryValue to temporaryValue, followed by 0x2C 0x20, followed by value.
   4. ~IF［ ( %名前, %一時的な値 ) は`~CORSなしで安全とされる要請~header$を成さない ］ ⇒ ~RET ◎ If (name, temporaryValue) is not a no-CORS-safelisted request-header, then return.
4. %headers の`~header~list$Hlに`~headerを付加する$( ( %名前, %値 ) ) ◎ Append (name, value) to headers’s header list.
5. ~IF［ %headers の`~guard$Hl ~EQ `request-no-cors^l ］ ⇒ %headers から`特権的~CORSなし要請~headerを除去する$ ◎ If headers’s guard is "request-no-cors", then remove privileged no-CORS request-headers from headers.

`Headers$I ~obj %headers を `~objで埋める@ ~algoは、 所与の ( ~obj %~obj ) に対し： ◎ To fill a Headers object headers with a given object object, run these steps:

1. ~IF［ %~obj は~IDL`連列~型$である ］： ◎ ↓

   1. %~obj を成す ~EACH( %~header ) に対し： ◎ If object is a sequence, then for each header of object:

      1. ~IF［ %~header の`~size$ ~NEQ 2 ］ ⇒ ~THROW `TypeError$E ◎ If header’s size is not 2, then throw a TypeError.
      2. %headers に`~headerを付加する$Hl( %~header[ 0 ], %~header[ 1 ] ) ◎ Append (header[0], header[1]) to headers.
2. ~ELSE （ %~obj は~IDL`~record型$【！`~Record$】である ） ⇒ %~obj を成す ~EACH( %~key → %値 ) に対し ⇒ %headers に`~headerを付加する$Hl( %~key, %値 ) ◎ Otherwise, object is a record, then for each key → value of object, append (key, value) to headers.

`Headers$I ~obj %headers から `特権的~CORSなし要請~headerを除去する@ ~algoは： ◎ To remove privileged no-CORS request-headers from a Headers object (headers), run these steps:

1. `特権的~CORSなし要請~header名$を成す ~EACH( %~header名 ) に対し ⇒ %headers の`~header~list$Hlから`~headerを削除する$( %~header名 ) ◎ For each headerName of privileged no-CORS request-header names: • Delete headerName from headers’s header list.

注記： これは、 %headers が特権的でない~codeにより改変されたときに~callされる。 ◎ This is called when headers are modified by unprivileged code.

`new Headers(init)@m 構築子~手続きは： ◎ The new Headers(init) constructor steps are:

1. コレの`~guard$Hl ~SET `none^l ◎ Set this’s guard to "none".
2. ~IF［ %init ~NEQ ε ］ ⇒ コレ を`~objで埋める$( %init ) ◎ If init is given, then fill this with init.

`delete(name)@m ~method手続きは： ◎ The delete(name) method steps are:

1. ~IF［ `~guardで検証する$( %name, 空な`~byte列$, コレ ) ~EQ ~F ］ ⇒ ~RET ◎ If validating (name, ``) for this returns false, then return.

   注記： 形式上必要な空な~byte列を渡すことによる否定的な~~影響は無い。 ◎ Passing a dummy header value ought not to have any negative repercussions.

2. ~IF［ コレの`~guard$Hl ~EQ `request-no-cors^l ］~AND［ %name は`~CORSなしで安全とされる要請~header名$でない ］~AND［ %name は`特権的~CORSなし要請~header名$でない ］ ⇒ ~RET ◎ If this’s guard is "request-no-cors", name is not a no-CORS-safelisted request-header name, and name is not a privileged no-CORS request-header name, then return.
3. ~IF［ コレの`~header~list$Hl内に［ %name を`名前に持つ~header$ ］は無い ］ ⇒ ~RET ◎ If this’s header list does not contain name, then return.
4. コレの`~header~list$Hlから`~headerを削除する$( %name ) ◎ Delete name from this’s header list.
5. ~IF［ コレの`~guard$Hl ~EQ `request-no-cors^l ］ ⇒ コレから`特権的~CORSなし要請~headerを除去する$ ◎ If this’s guard is "request-no-cors", then remove privileged no-CORS request-headers from this.

`get(name)@m ~method手続きは： ◎ The get(name) method steps are:

1. ~IF［ %name は`~header名$でない ］ ⇒ ~THROW `TypeError$E ◎ If name is not a header name, then throw a TypeError.
2. ~RET `~header~listから値を取得する$( コレの`~header~list$Hl, %name ) ◎ Return the result of getting name from this’s header list.

`getSetCookie()@m ~method手続きは：

1. %値~群 ~LET 新たな`~list$
2. コレの`~header~list$Hlを成す ~EACH( `Set-Cookie$h を`名前に持つ~header$ %~header ) に対し ⇒ %値~群 に %~header の`値$hdを`付加する$
3. ~RET %値~群

`has(name)@m ~method手続きは： ◎ The has(name) method steps are:

1. ~IF［ %name は`~header名$でない ］ ⇒ ~THROW `TypeError$E ◎ If name is not a header name, then throw a TypeError.
2. ~RET ~IS［ コレの`~header~list$Hl内に［ %name を`名前に持つ~header$ ］は在る ］ ◎ Return true if this’s header list contains name; otherwise false.

`set(name, value)@m ~method手続きは： ◎ The set(name, value) method steps are:

1. %value ~SET `値を正規化する$( %value ) ◎ Normalize value.
2. ~IF［ `~guardで検証する$( %name, %value, コレ ) ~EQ ~F ］ ⇒ ~RET ◎ If validating (name, value) for this returns false, then return.
3. ~IF［ コレの`~guard$Hl ~EQ `request-no-cors^l ］~AND［ ( %name, %value ) は`~CORSなしで安全とされる要請~header$を成さない ］ ⇒ ~RET ◎ If this’s guard is "request-no-cors" and (name, value) is not a no-CORS-safelisted request-header, then return.
4. コレの`~header~list$Hl内で`~headerを設定する$( ( %name, %value ) ) ◎ Set (name, value) in this’s header list.
5. ~IF［ `~guard$Hl ~EQ `request-no-cors^l ］ ⇒ コレから`特権的~CORSなし要請~headerを除去する$ ◎ If this’s guard is "request-no-cors", then remove privileged no-CORS request-headers from this.

`本体と型を安全に抽出する@ ~algoは、 所与の ( %~obj ) に対し，`本体と型$を返す： ◎ To safely extract a body with type from a byte sequence or BodyInit object object, run these steps:

1. ~Assert： %~obj は［ `~byte列$ ／ `BodyInit$I ~obj ］である。 ◎ ↑
2. ~IF［ %~obj は `ReadableStream$I ~objである ］ ⇒ ~Assert： %~obj は次を満たしていない ⇒ ［ `妨げられている$RS ］~OR［ `~lockされている$RS ］ ◎ If object is a ReadableStream object, then: • Assert: object is neither disturbed nor locked.
3. ~RET `本体と型を抽出する$( %~obj ) ◎ Return the result of extracting object.

注記： `本体と型を安全に抽出する$演算は、 例外を投出しないことが保証される，`本体と型を抽出する$演算である。 ◎ The safely extract operation is a subset of the extract operation that is guaranteed to not throw an exception.

`本体と型を抽出する@ ~algoは、 所与の ( %~obj, %~keepaliveか ~IN { `~keepalive@i, ε } ~DF ε 【！boolean keepalive (default false)】 ) に対し，`本体と型$を返す： ◎ To extract a body with type from a byte sequence or BodyInit object object, with an optional boolean keepalive (default false), run these steps:

1. ~Assert： %~obj は［ `~byte列$ ／ `BodyInit$I ~obj ］である。 ◎ ↑
2. %~stream ~LET ~NULL ◎ Let stream be null.
3. ~IF［ %~obj は `ReadableStream$I ~objである ］ ⇒ %~stream ~SET %~obj ◎ If object is a ReadableStream object, then set stream to object.
4. ~ELIF［ %~obj は `Blob$I ~objである ］ ⇒ %~stream ~SET %~obj の`~streamを取得する$() ◎ Otherwise, if object is a Blob object, set stream to the result of running object’s get stream.
5. ~ELSE ⇒＃ %~stream ~SET `新たな~obj$( `ReadableStream$I )； %~stream を`~byte読取り~support付きで設定しておく$RS ◎ Otherwise, set stream to a new ReadableStream object, and set up stream with byte reading support.
6. ~Assert： %~stream は `ReadableStream$I ~objである。 ◎ Assert: stream is a ReadableStream object.
7. %動作 ~LET ~NULL ◎ Let action be null.
8. %~source ~LET ~NULL ◎ Let source be null.
9. %長さ ~LET ~NULL ◎ Let length be null.
10. %型 ~LET ~NULL ◎ Let type be null.

11. %~obj に応じて： ◎ Switch on object:

    `Blob$I

    1. %~source ~SET %~obj ◎ Set source to object.
    2. %長さ ~SET %~obj の `size$mF ◎ Set length to object’s size.
    3. ~IF［ %~obj の `type$mF 属性 ~NEQ 空な~byte列 ］ ⇒ %型 ~SET その属性~値 ◎ If object’s type attribute is not the empty byte sequence, set type to its value.

    `~byte列$ ◎ byte sequence

    %~source ~SET %~obj ◎ Set source to object.

    `BufferSource$I

    %~source ~SET %~obj に`保持された~byte列の複製を取得する$ ◎ Set source to a copy of the bytes held by object.

    `FormData$I

    1. %動作 ~SET 次を走らす手続き ⇒ ~RET `~mp_form_dataとして符号化する$( %~obj の`~entry~list$fD, `~UTF-8$enc ) ◎ Set action to this step: run the multipart/form-data encoding algorithm, with object’s entry list and UTF-8.
    2. %~source ~SET %~obj ◎ Set source to object.
    3. %長さ ~SET 不明瞭 — これを改善することについては、 `~HTML 課題 #6424＠~HTMLissue/6424$ を見よ ◎ Set length to unclear, see html/6424 for improving this.
    4. %型 ~SET `multipart/form-data; boundary=^bl ◎ Set type to `multipart/form-data; boundary=`,＼
    5. %型 に次を付加する ⇒ %動作 により生成されることになる `~mp_form_data境界~文字列$ ◎ followed by the multipart/form-data boundary string generated by the multipart/form-data encoding algorithm.

    `URLSearchParams$I

    1. %~source ~SET `~form_urlencoded直列化器$( %~obj の`~parameter~list$ ) ◎ Set source to the result of running the application/x-www-form-urlencoded serializer with object’s list.
    2. %型 ~SET `application/x-www-form-urlencoded;charset=UTF-8^bl ◎ Set type to `application/x-www-form-urlencoded;charset=UTF-8`.

    `~scalar値~文字列$

    1. %~source ~SET `~UTF-8符号化する$( %~obj ) ◎ Set source to the UTF-8 encoding of object.
    2. %型 ~SET `text/plain;charset=UTF-8^bl ◎ Set type to `text/plain;charset=UTF-8`.

    `ReadableStream$I

    1. ~IF［ %~keepaliveか ~EQ `~keepalive$i ］~OR［ %~obj は`妨げられている$RS ］~OR［ %~obj は`~lockされている$RS ］ ⇒ ~THROW `TypeError$E ◎ If keepalive is true, then throw a TypeError. ◎ If object is disturbed or locked, then throw a TypeError.

12. ~IF［ %~source は`~byte列$である ］ ⇒ %動作 ~SET 次の手続き

    手続きは ⇒ ~RET %~source `and length to source’s length^en 【意図不明。 %長さ ~SET %~source の`長さ$？】
    ◎ If source is a byte sequence, then set action to a step that returns source and length to source’s length.

13. ~IF［ %動作 ~NEQ ~NULL ］： ◎ If action is non-null, then run these steps in parallel:

    1. 次に従う下で %動作 を`並列的$に走らす： ◎ Run action.

       • 【 %動作 の途中結果から】 1 個以上の~byte %~byte列 が可用になるたびに：

         1. %~chunk ~LET `~buffer~sourceを作成する$( `Uint8Array$I, %~byte列【, ここに必要な~realm引数はまだ指定されていない】 )
         2. %~stream に`~chunkを~enqueueする$RS( %~chunk )
         ◎ Whenever one or more bytes are available and stream is not errored, enqueue the result of creating a Uint8Array from the available bytes into stream.
       • 前項により %~stream が`~errorした$RSときは ⇒ この段を終える 【この場合、次項を飛ばしても同じ結果になると見受けられる。】 ◎ ↑
       • %動作 を走らせ終えたときは ⇒ %~stream を`~closeする$RS() ◎ When running action is done, close stream.
14. %本体 ~LET 新たな`本体$ — その ⇒＃ `~stream$bd ~SET %~stream, `~source$bd ~SET %~source, `長さ$bd ~SET %長さ ◎ Let body be a body whose stream is stream, source is source, and length is length.
15. ~RET ( %本体, %型 ) ◎ Return (body, type).

`~MIME型を取得する@ ~algoは、 所与の ( ［ `Request$I ／ `Response$I ］~obj %要請または応答 ) に対し： ◎ To get the MIME type, given a Request or Response object requestOrResponse:

1. %~header群 ~LET %要請または応答 に応じて ⇒＃ `Request$I ~objであるならば %要請または応答 の`要請$Rqの`~header~list$rq ／ `Response$I ~objであるならば %要請または応答 の`応答$Rsの`~header~list$rs ◎ Let headers be null. ◎ If requestOrResponse is a Request object, then set headers to requestOrResponse’s request’s header list. ◎ Otherwise, set headers to requestOrResponse’s response’s header list.
2. %~MIME型 ~LET `~header~listから~MIME型を抽出する$( %~header群 ) ◎ Let mimeType be the result of extracting a MIME type from headers.
3. ~IF［ %~MIME型 ~EQ `失敗^i ］ ⇒ ~RET ~NULL ◎ If mimeType is failure, then return null.
4. ~RET %~MIME型 ◎ Return mimeType.

`本体を消費する@ ~algoは、 所与の ( `Body$I を`内包-$している~obj %~obj, ~algo %~byte列を~JS値に変換する ) に対し： ◎ The consume body algorithm, given an object that includes Body object and an algorithm that takes a byte sequence and returns a JavaScript value or throws an exception convertBytesToJSValue, runs these steps:

1. ~Assert： %~byte列を~JS値に変換する は、 所与の`~byte列$に対し，~JS値を返すか例外を投出する。 ◎ ↑
2. ~IF［ %~obj は`利用-不能$Bdである ］ ⇒ ~RET `却下される~promise$( `TypeError$E 例外 ) ◎ If object is unusable, then return a promise rejected with a TypeError.
3. %~promise ~LET `新たな~promise$ ◎ Let promise be a new promise.
4. %~error手続き ~LET 所与の ( %~error ) に対し，次を走らす手続き ⇒ `~promiseを却下する$( %~promise, %~error ) ◎ Let errorSteps given error be to reject promise with error.

5. %成功~手続き ~LET 所与の ( `~byte列$ %~data ) に対し，次を走らす手続き：

   1. %結果 ~LET %~byte列を~JS値に変換する( %~data )

      例外 %e が投出されたときは、 ~catchして ⇒＃ %~error手続き( %e )； ~RET

   2. `~promiseを解決する$( %~promise, %結果 )
   ◎ Let successSteps given a byte sequence data be to resolve promise with the result of running convertBytesToJSValue with data. If that threw an exception, then run errorSteps with that exception.
6. ~IF［ %~obj の`本体$Bd ~EQ ~NULL ］ ⇒ %成功~手続き( 空な`~byte列$ ) ◎ If object’s body is null, then run successSteps with an empty byte sequence.
7. ~ELSE ⇒ `本体を全部的に読取る$( ↓ ) ⇒＃ %~obj の`本体$Bd, %成功~手続き, %~error手続き, %~obj に`関連な大域~obj$ ◎ Otherwise, fully read object’s body given successSteps, errorSteps, and object’s relevant global object.
8. ~RET %~promise ◎ Return promise.

`arrayBuffer()@m ~method手続きは ⇒ ~RET `本体を消費する$( コレ, 次の手続き ) ◎ The arrayBuffer() method steps are to return the result of running consume body with this and the following step＼

手続きは、 所与の ( `~byte列$ %~byte列 ) に対し ⇒ ~RET `~buffer~sourceを作成する$( `ArrayBuffer$I, %~byte列, コレに`関連な~realm$ ) ◎ given a byte sequence bytes: return the result of creating an ArrayBuffer from bytes in this’s relevant realm.

注記： この~methodは、 `RangeError$E で却下され得る。 ◎ The above method can reject with a RangeError.

`blob()@m ~method手続きは ⇒ ~RET `本体を消費する$( コレ, 次の手続き ) ◎ The blob() method steps are to return the result of running consume body with this and the following step＼

手続きは、 所与の ( `~byte列$ %~byte列 ) に対し ⇒ ~RET 新たな `Blob$I — その ⇒＃ 内容【`~byte列~data＠~FILEAPI#_ref-bytes$】 ~SET %~byte列, `type$mF 属性 ~SET `~MIME型を取得する$( コレ ) ◎ given a byte sequence bytes:＼ return a Blob whose contents are bytes and whose type attribute is the result of get the MIME type with this.

`bytes()@m ~method手続きは ⇒ ~RET `本体を消費する$( コレ, 次の手続き ) ◎ The bytes() method steps are to return the result of running consume body with this and the following step＼

手続きは、 所与の ( `~byte列$ %~byte列 ) に対し ⇒ ~RET `~buffer~sourceを作成する$( `Uint8Array$I, %~byte列, コレに`関連な~realm$ ) ◎ given a byte sequence bytes:＼ return the result of creating a Uint8Array from bytes in this’s relevant realm.

`formData()@m ~method手続きは ⇒ ~RET `本体を消費する$( コレ, 次の手続き ) ◎ The formData() method steps are to return the result of running consume body with this and the following steps＼

`json()@m ~method手続きは ⇒ ~RET `本体を消費する$( コレ, `~JSON~byte列を~JS値に構文解析する$ ) ◎ The json() method steps are to return the result of running consume body with this and parse JSON from bytes.

注記： この~methodは、 `SyntaxError$E で却下され得る。 ◎ The above method can reject with a SyntaxError.

`text()@m ~method手続きは ⇒ ~RET `本体を消費する$( コレ, `~UTF-8復号する$ ) ◎ The text() method steps are to return the result of running consume body with this and UTF-8 decode.

`~Request~objを作成する@ ~algoは、 所与の ( `要請$ %要請, `~Headers用の~guard$ %~guard, `AbortSignal$I ~obj %通達, `~realm$ %~realm ) に対し： ◎ To create a Request object, given a request request, headers guard guard, AbortSignal object signal, and realm realm:

1. %headers ~LET `新たな~obj$( `Headers$I, %~realm ) — その ⇒＃ `~header~list$Hl ~SET %要請 の`~header~list$rq, `~guard$Hl ~SET %~guard ◎ ↓
2. %~Request~obj ~LET `新たな~obj$( `Request$I, %~realm ) — その ⇒＃ `要請$Rq ~SET %要請, `~Headers$Rq ~SET %headers, `通達$Rq ~SET %通達 ◎ Let requestObject be a new Request object with realm. ◎ Set requestObject’s request to request. ◎ Set requestObject’s headers to a new Headers object with realm, whose headers list is request’s headers list and guard is guard. ◎ Set requestObject’s signal to signal.
3. ~RET %~Request~obj ◎ Return requestObject.

`new Request(input, init)@m 構築子~手続きは： ◎ The new Request(input, init) constructor steps are:

1. %要請 ~LET ~NULL ◎ Let request be null.
2. %~fallback~mode ~LET ~NULL ◎ Let fallbackMode be null.
3. %基底~URL ~LET コレに`関連な設定群~obj$の`~API用~基底~URL$enV ◎ Let baseURL be this’s relevant settings object’s API base URL.
4. %通達 ~LET ~NULL ◎ Let signal be null.

5. ~IF［ %input は文字列である ］： ◎ If input is a string, then:

   1. %構文解析した~URL ~LET `~URL構文解析する$( %input, %基底~URL ) ◎ Let parsedURL be the result of parsing input with baseURL.
   2. ~IF［ %構文解析した~URL ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parsedURL is failure, then throw a TypeError.
   3. ~IF［ %構文解析した~URL は`資格証を含んで$いる ］ ⇒ ~THROW `TypeError$E ◎ If parsedURL includes credentials, then throw a TypeError.
   4. %要請 ~SET 新たな`要請$ — その ⇒ `~URL$rq ~SET %構文解析した~URL ◎ Set request to a new request whose URL is parsedURL.
   5. %~fallback~mode ~SET `cors^l ◎ Set fallbackMode to "cors".

6. ~ELSE： ◎ Otherwise:

   1. ~Assert： %input は `Request$I ~objである。 ◎ Assert: input is a Request object.
   2. %要請 ~SET %input の`要請$Rq ◎ Set request to input’s request.
   3. %通達 ~SET %input の`通達$Rq ◎ Set signal to input’s signal.
7. %生成元 ~LET コレに`関連な設定群~obj$の`生成元$enV ◎ Let origin be this’s relevant settings object’s origin.
8. %利用者~prompt用の辿可能 ~LET %要請 の`利用者~prompt用の辿可能$rq ◎ ↓

9. ~IF［ ~NOT ~AND↓ ］…

   • %利用者~prompt用の辿可能 は`環境~設定群~obj$である【？】
   • %利用者~prompt用の辿可能 の`生成元$enV ~EQ`生成元$sub %生成元

   …ならば ⇒ %利用者~prompt用の辿可能 ~SET `client^l

   ◎ Let traversableForUserPrompts be "client". ◎ If request’s traversable for user prompts is an environment settings object and its origin is same origin with origin, then set traversableForUserPrompts to request’s traversable for user prompts.

10. ~IF［ %init[ "`window$RqI" ] ~NEQ ε ］：

    1. ~IF［ %init[ "`window$RqI" ] ~NEQ ~NULL ］ ⇒ ~THROW `TypeError$E
    2. %利用者~prompt用の辿可能 ~SET `no-traversable^l
    ◎ If init["window"] exists and is non-null, then throw a TypeError. ◎ If init["window"] exists, then set traversableForUserPrompts to "no-traversable".

11. %要請 ~SET 新たな`要請$ — その ⇒＃ `~URL$rq ~SET %要請 の`~URL$rq, `~method$rq ~SET %要請 の`~method$rq, `~header~list$rq ~SET %要請 の`~header~list$rqの複製, `安全でない要請か$rq ~SET ~T, `~client$rq ~SET コレに`関連な設定群~obj$, `利用者~prompt用の辿可能$rq ~SET %利用者~prompt用の辿可能, `内部的な優先度$rq ~SET %要請 の`内部的な優先度$rq, `生成元$rq ~SET %要請 の`生成元$rq†, `~referrer$rq ~SET %要請 の`~referrer$rq, `~referrer施策$rq ~SET %要請 の`~referrer施策$rq, `~mode$rq ~SET %要請 の`~mode$rq, `資格証~mode$rq ~SET %要請 の`資格証~mode$rq, `~cache~mode$rq ~SET %要請 の`~cache~mode$rq, `~redirect~mode$rq ~SET %要請 の`~redirect~mode$rq, `完全性~metadata$rq ~SET %要請 の`完全性~metadata$rq, `~keepaliveか$rq ~SET %要請 の`~keepaliveか$rq, `再読込み~naviか$rq ~SET %要請 の`再読込み~naviか$rq, `履歴~naviか$rq ~SET %要請 の`履歴~naviか$rq, `~URL~list$rq ~SET %要請 の`~URL~list$rqを`~cloneする$, `起動元~種別$rq ~SET `fetch^l

    注記†： `生成元$の伝播が有意になるのは、［ ~swにより取扱われている~navi要請 ］用に限られる。 この局面においては、 要請の生成元は，現在の~clientのそれとは異なり得る。

    ◎ Set request to a new request with the following properties: ◎ URL • request’s URL. method • request’s method. header list • A copy of request’s header list. unsafe-request flag • Set. client • This’s relevant settings object. traversable for user prompts • traversableForUserPrompts. internal priority • request’s internal priority. origin • request’s origin.＼ The propagation of the origin is only significant for navigation requests being handled by a service worker. In this scenario a request can have an origin that is different from the current client. referrer • request’s referrer. referrer policy • request’s referrer policy. mode • request’s mode. credentials mode • request’s credentials mode. cache mode • request’s cache mode. redirect mode • request’s redirect mode. integrity metadata • request’s integrity metadata. keepalive • request’s keepalive. reload-navigation flag • request’s reload-navigation flag. history-navigation flag • request’s history-navigation flag. URL list • A clone of request’s URL list. initiator type • "fetch".

12. ~IF［ %init は`空$mapでない ］： ◎ If init is not empty, then:

    1. ~IF［ %要請 の`~mode$rq ~EQ `navigate^l ］ ⇒ %要請 の`~mode$rq ~SET `same-origin^l ◎ If request’s mode is "navigate", then set it to "same-origin".
    2. %要請 の ⇒＃ `再読込み~naviか$rq ~SET ~F, `履歴~naviか$rq ~SET ~F, `生成元$rq ~SET `client^l, `~referrer$rq ~SET `client^l, `~referrer施策$rq ~SET 空~文字列, `~URL$rq ~SET %要請 の`現在の~URL$rq, `~URL~list$rq ~SET « %要請 の`~URL$rq » ◎ Unset request’s reload-navigation flag. ◎ Unset request’s history-navigation flag. ◎ Set request’s origin to "client". ◎ Set request’s referrer to "client". ◎ Set request’s referrer policy to the empty string. ◎ Set request’s URL to request’s current URL. ◎ Set request’s URL list to « request’s URL ».

    注記： これは、 ~swが要請 — 例えば，非同一-生成元~stylesheetからの画像 — を “~redirect” して 改変を加えたときに、 元の~source（すなわち，非同一-生成元~stylesheet）から来たのでなく， その~swから来たように現れることを確保するために行われる。 元の~sourceは，~swと同じ種類の要請~すら生成できないかもしれないので、 このことは重要になる。 これが行われないと、 元の~sourceを信用する~serviceは，悪用されかねない — そこまで行き着くことは まず無さそうだが。 ◎ This is done to ensure that when a service worker "redirects" a request, e.g., from an image in a cross-origin style sheet, and makes modifications, it no longer appears to come from the original source (i.e., the cross-origin style sheet), but instead from the service worker that "redirected" the request. This is important as the original source might not even be able to generate the same kind of requests as the service worker. Services that trust the original source could therefore be exploited were this not done, although that is somewhat farfetched.

13. %~referrer ~LET %init[ "`referrer$RqI" ] ◎ ↓

14. ~IF［ %~referrer ~NEQ ε ］： ◎ If init["referrer"] exists, then: • Let referrer be init["referrer"].

    1. ~IF［ %~referrer ~EQ 空~文字列 ］ ⇒＃ %要請 の`~referrer$rq ~SET `no-referrer^l ◎ If referrer is the empty string, then set request’s referrer to "no-referrer".

    2. ~ELSE： ◎ Otherwise:

       1. %構文解析した~referrer ~LET `~URL構文解析する$( %~referrer, %基底~URL ) ◎ Let parsedReferrer be the result of parsing referrer with baseURL.
       2. ~IF［ %構文解析した~referrer ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parsedReferrer is failure, then throw a TypeError.

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

          • %構文解析した~referrer は次を満たす ⇒ ［ `~scheme$url ~EQ `about^l ］~AND［ `~path$url ~EQ 文字列 `client^l ］ ◎ parsedReferrer’s scheme is "about" and path is the string "client"
          • %構文解析した~referrer の`生成元$url ~NEQ`生成元$sub %生成元 ◎ parsedReferrer’s origin is not same origin with origin

          …ならば ⇒ %要請 の`~referrer$rq ~SET `client^l ◎ then set request’s referrer to "client".

       4. ~ELSE ⇒ %要請 の`~referrer$rq ~SET %構文解析した~referrer ◎ Otherwise, set request’s referrer to parsedReferrer.

15. ~IF［ %init[ "`referrerPolicy$RqI" ] ~NEQ ε ］ ⇒ %要請 の`~referrer施策$rq ~SET その値 ◎ If init["referrerPolicy"] exists, then set request’s referrer policy to it.

16. %~mode ~LET ［ %init[ "`mode$RqI" ] ~NEQ ε ならば その値 ／ ~ELSE_ %~fallback~mode ］ ◎ Let mode be init["mode"] if it exists, and fallbackMode otherwise.
17. ~IF［ %~mode ~EQ `navigate^l ］ ⇒ ~THROW `TypeError$E ◎ If mode is "navigate", then throw a TypeError.
18. ~IF［ %~mode ~NEQ ~NULL ］ ⇒ %要請 の`~mode$rq ~SET %~mode ◎ If mode is non-null, set request’s mode to mode.
19. ~IF［ %init[ "`credentials$RqI" ] ~NEQ ε ］ ⇒ %要請 の`資格証~mode$rq ~SET その値 ◎ If init["credentials"] exists, then set request’s credentials mode to it.
20. ~IF［ %init[ "`cache$RqI" ] ~NEQ ε ］ ⇒ %要請 の`~cache~mode$rq ~SET その値 ◎ If init["cache"] exists, then set request’s cache mode to it.
21. ~IF［ %要請 の`~cache~mode$rq ~EQ `only-if-cached^l ］~AND［ %要請 の`~mode$rq ~NEQ `same-origin^l ］ ⇒ ~THROW `TypeError$E ◎ If request’s cache mode is "only-if-cached" and request’s mode is not "same-origin", then throw a TypeError.
22. ~IF［ %init[ "`redirect$RqI" ] ~NEQ ε ］ ⇒ %要請 の`~redirect~mode$rq ~SET その値 ◎ If init["redirect"] exists, then set request’s redirect mode to it.
23. ~IF［ %init[ "`integrity$RqI" ] ~NEQ ε ］ ⇒ %要請 の`完全性~metadata$rq ~SET その値 ◎ If init["integrity"] exists, then set request’s integrity metadata to it.
24. %要請 の`~keepaliveか$rq ~SET ~IS［ %init[ "`keepalive$RqI" ] ~EQ ~T 【！init["keepalive"] exists】 ］ ◎ If init["keepalive"] exists, then set request’s keepalive to it.
25. %~method ~LET %init[ "`method$RqI" ] ◎ ↓

26. ~IF［ %~method ~NEQ ε ］： ◎ If init["method"] exists, then: • Let method be init["method"].

    1. ~IF［ %~method は`~method$でない ］~OR［ %~method は`禁止~method$である ］ ⇒ ~THROW `TypeError$E ◎ If method is not a method or method is a forbidden method, then throw a TypeError.
    2. %要請 の`~method$rq ~SET `~methodを正規化する$( %~method ) ◎ Normalize method. ◎ Set request’s method to method.
27. ~IF［ %init[ "`signal$RqI" ] ~NEQ ε ］ ⇒ %通達 ~SET その値 ◎ If init["signal"] exists, then set signal to it.

28. ~IF［ %init[ "`priority$RqI" ] ~NEQ ε ］： ◎ If init["priority"] exists, then:

    1. ~IF［ %要請 の`内部的な優先度$rq ~NEQ ~NULL ］ ⇒ %要請 の`内部的な優先度$rqを`実装定義$な方式で更新する ◎ If request’s internal priority is not null, then update request’s internal priority in an implementation-defined manner.
    2. ~ELSE ⇒ %要請 の`優先度$rq ~SET %init[ "`priority$RqI" ] ◎ Otherwise, set request’s priority to init["priority"].
29. コレの`要請$Rq ~SET %要請 ◎ Set this’s request to request.
30. %通達~群 ~LET ［ %通達 ~NEQ ~NULL ならば « %通達 » ／ ~ELSE_ « » ］ ◎ Let signals be « signal » if signal is non-null; otherwise « ».
31. コレの`通達$Rq ~SET `依存~中止-通達を作成する$( %通達~群, `AbortSignal$I, コレに`関連な~realm$ ) ◎ Set this’s signal to the result of creating a dependent abort signal from signals, using AbortSignal and this’s relevant realm.
32. コレの`~Headers$Rq ~SET `新たな~obj$( `Headers$I, コレに`関連な~realm$ ) — その ⇒＃ `~header~list$Hl ~SET %要請 の`~header~list$rq, `~guard$Hl ~SET `request^l ◎ Set this’s headers to a new Headers object with this’s relevant realm, whose header list is request’s header list and guard is "request".

33. ~IF［ コレの`要請$Rqの`~mode$rq ~EQ `no-cors^l ］： ◎ If this’s request’s mode is "no-cors", then:

    1. ~IF［ コレの`要請$Rqの`~method$rqは `~CORS安全とされる~method$でない ］ ⇒ ~THROW `TypeError$E ◎ If this’s request’s method is not a CORS-safelisted method, then throw a TypeError.
    2. コレの`~Headers$Rqの`~guard$Hl ~SET `request-no-cors^l ◎ Set this’s headers’s guard to "request-no-cors".

34. ~IF［ %init は`空$mapでない ］： ◎ If init is not empty, then:

    注記： %headers は，この~mode【 %~mode ？】では許容されない~headerを包含するかもしれないので、 この段で無毒化される。 他の場合、 それは以前に無毒化されたか，特権的~APIによる設定-時から改変されてない。 ◎ The headers are sanitized as they might contain headers that are not allowed by this mode. Otherwise, they were previously sanitized or are unmodified since they were set by a privileged API.

    1. %headers ~LET %init[ "`headers$RqI" ] ◎ ↓
    2. ~IF［ %headers ~EQ ε ］ ⇒ %headers ~SET コレの`~Headers$Rqの複製 — `~header~list$Hlも含めて複製する ◎ Let headers be a copy of this’s headers and its associated header list. ◎ If init["headers"] exists, then set headers to init["headers"].
    3. コレの`~Headers$Rqの`~header~list$Hlを空にする ◎ Empty this’s headers’s header list.
    4. ~IF［ %headers は `Headers$I ~objである ］ ⇒ %headers の`~header~list$Hlを成す ~EACH( %~header ) に対し ⇒ コレの`~Headers$Rqに`~headerを付加する$Hl( %~header の`名前$hd, %~header の`値$hd ) ◎ If headers is a Headers object, then for each header of its header list, append header to this’s headers.
    5. ~ELSE ⇒ コレの`~Headers$Rqを`~objで埋める$( %headers ) ◎ Otherwise, fill this’s headers with headers.
35. %入力~本体 ~LET %input に応じて ⇒＃ `Request$I ~objであるならば %input の`要請$Rqの`本体$rq ／ ~ELSE_ ~NULL ◎ Let inputBody be input’s request’s body if input is a Request object; otherwise null.
36. %本体~member ~LET %init[ "`body$RqI" ] ◎ ↓
37. ~IF［ %本体~member ~EQ ε ］ ⇒ %本体~member ~SET ~NULL ◎ ↓
38. ~IF［［ %本体~member ~NEQ ~NULL ］~OR［ %入力~本体 ~NEQ ~NULL ］］~AND［ %要請 の`~method$rq ~IN { `GET$hm, `HEAD$hm } ］ ⇒ ~THROW `TypeError$E ◎ If either init["body"] exists and is non-null or inputBody is non-null, and request’s method is `GET` or `HEAD`, then throw a TypeError.
39. %初期~本体 ~LET ~NULL ◎ Let initBody be null.

40. ~IF［ %本体~member ~NEQ ~NULL ］： ◎ If init["body"] exists and is non-null, then:

    1. %本体と型 ~LET %要請 の`~keepaliveか$rq に応じて ⇒＃ ~T ならば `本体と型を抽出する$( %本体~member, `~keepalive$i ) ／ ~F ならば `本体と型を抽出する$( %本体~member ) ◎ Let bodyWithType be the result of extracting init["body"], with keepalive set to request’s keepalive.
    2. %初期~本体 ~SET %本体と型 の`本体$bwT ◎ Set initBody to bodyWithType’s body.
    3. %型 ~LET %本体と型 の`型$bwT ◎ Let type be bodyWithType’s type.
    4. ~IF［ %型 ~NEQ ~NULL ］~AND［［ コレの`~Headers$Rqの`~header~list$Hl ］内に［ `Content-Type$h を`名前に持つ~header$ ］は無い ］ ⇒ コレの`~Headers$Rqに`~headerを付加する$Hl( `Content-Type$h, %型 ) ◎ If type is non-null and this’s headers’s header list does not contain `Content-Type`, then append (`Content-Type`, type) to this’s headers.
41. %最終-本体【！inputOrInitBody（不要）】 ~LET ［ %初期~本体 ~NEQ ~NULL ならば %初期~本体 ／ ~ELSE_ %入力~本体 ］ ◎ Let inputOrInitBody be initBody if it is non-null; otherwise inputBody.

42. ~IF［ %最終-本体 ~NEQ ~NULL ］~AND［ %最終-本体 の`~source$bd ~EQ ~NULL ］： ◎ If inputOrInitBody is non-null and inputOrInitBody’s source is null, then:

    1. ~IF［ %初期~本体 ~NEQ ~NULL ］~AND［ %init[ "`duplex$RqI" ] ~EQ ε ］ ⇒ ~THROW `TypeError$E ◎ If initBody is non-null and init["duplex"] does not exist, then throw a TypeError.
    2. ~IF［ コレの`要請$Rqの`~mode$rq ~NIN { `same-origin^l, `cors^l } ］ ⇒ ~THROW `TypeError$E ◎ If this’s request’s mode is neither "same-origin" nor "cors", then throw a TypeError.
    3. コレの`要請$Rqの`~CORS予行を利用するか$rq ~SET ~T ◎ Set this’s request’s use-CORS-preflight flag.

43. ~IF［ %初期~本体 ~EQ ~NULL ］~AND［ %入力~本体 ~NEQ ~NULL ］： ◎ ↑Let finalBody be inputOrInitBody. ◎ If initBody is null and inputBody is non-null, then:

    1. ~IF［ %input は`利用-不能$Bdである ］ ⇒ ~THROW `TypeError$E ◎ If input is unusable, then throw a TypeError.
    2. %最終-本体 ~SET `~proxyを作成する$RS( %入力~本体 ) ◎ Set finalBody to the result of creating a proxy for inputBody.
44. コレの`要請$Rqの`本体$rq ~SET %最終-本体 ◎ Set this’s request’s body to finalBody.

`clone()@m ~method手続きは： ◎ The clone() method steps are:

1. ~IF［ コレは`利用-不能$Bdである ］ ⇒ ~THROW `TypeError$E ◎ If this is unusable, then throw a TypeError.
2. %~cloneした要請 ~LET `要請を~cloneする$( コレの`要請$Rq ) ◎ Let clonedRequest be the result of cloning this’s request.
3. ~Assert： コレの`通達$Rq ~NEQ ~NULL ◎ Assert: this’s signal is non-null.
4. %~cloneした通達 ~LET `依存~中止-通達を作成する$( « コレの`通達$Rq », `AbortSignal$I, コレに`関連な~realm$ ) ◎ Let clonedSignal be the result of creating a dependent abort signal from « this’s signal », using AbortSignal and this’s relevant realm.
5. %~cloneした~Request~obj ~LET `~Request~objを作成する$( %~cloneした要請, コレの`~Headers$Rqの`~guard$Hl, %~cloneした通達, コレに`関連な~realm$ ) ◎ Let clonedRequestObject be the result of creating a Request object, given clonedRequest, this’s headers’s guard, clonedSignal and this’s relevant realm.
6. ~RET %~cloneした~Request~obj ◎ Return clonedRequestObject.

`~Response~objを作成する@ ~algoは、 所与の ( `応答$ %応答, `~Headers用の~guard$ %~guard, `~realm$ %~realm ) に対し： ◎ To create a Response object, given a response response, headers guard guard, and realm realm, run these steps:

1. %headers ~LET `新たな~obj$( `Headers$I, %~realm ) — その ⇒＃ `~header~list$Hl ~SET %応答 の`~header~list$rs, `~guard$Hl ~SET %~guard ◎ ↓
2. %~Response~obj ~LET `新たな~obj$( `Response$I, %~realm ) — その ⇒＃ `応答$Rs ~SET %応答, `~Headers$Rs ~SET %headers ◎ Let responseObject be a new Response object with realm. ◎ Set responseObject’s response to response. ◎ Set responseObject’s headers to a new Headers object with realm, whose headers list is response’s headers list and guard is guard.
3. ~RET %~Response~obj ◎ Return responseObject.

`~Response~objを初期化する@ ~algoは、 所与の ( `Response$I ~obj %~Response~obj【！response】, `ResponseInit$I %init, ［ ~NULL ／ `本体と型$ ］ %本体と型【！body】 ) に対し： ◎ To initialize a response, given a Response object response, ResponseInit init, and null or a body with type body:

1. ~IF［ %init[ "`status$RsI" ] ~NIN { `200^st 〜 `599^st } ］ ⇒ ~THROW `RangeError$E ◎ If init["status"] is not in the range 200 to 599, inclusive, then throw a RangeError.
2. ~IF［ %init[ "`statusText$RsI" ] ~NEQ 空~文字列 ］~AND［ %init[ "`statusText$RsI" ] は `reason-phrase$p ~token生成規則に合致しない ］ ⇒ ~THROW `TypeError$E ◎ If init["statusText"] is not the empty string and does not match the reason-phrase token production, then throw a TypeError.
3. %応答 ~LET %~Response~obj の`応答$Rs ◎ ↓
4. %応答 の ⇒＃ `状態s$rs ~SET %init[ "`status$RsI" ], `状態s~message$rs ~SET %init[ "`statusText$RsI" ] ◎ Set response’s response’s status to init["status"]. ◎ Set response’s response’s status message to init["statusText"].
5. ~IF［ %init[ "`headers$RsI" ] ~NEQ ε ］ ⇒ %~Response~obj の`~Headers$Rsを`~objで埋める$( %init[ "`headers$RsI" ] ) ◎ If init["headers"] exists, then fill response’s headers with init["headers"].

6. ~IF［ %本体と型 ~NEQ ~NULL ］： ◎ If body is non-null, then:

   1. ~IF［ %応答 の`状態s$rsは`~null本体~状態s$である ］ ⇒ ~THROW `TypeError$E ◎ If response’s status is a null body status, then throw a TypeError.

      注記： `101$st, `103$st は、 この段には影響しない — それは、 他所におけるその利用に因り，`~null本体~状態s$に含まれているので。 ◎ 101 and 103 are included in null body status due to their use elsewhere. They do not affect this step.

   2. %応答 の`本体$rs ~SET %本体と型 の`本体$bwT ◎ Set response’s body to body’s body.
   3. %型 ~LET %本体と型 の`型$bwT ◎ ↓
   4. ~IF［ %型 ~NEQ ~NULL ］~AND［ %応答 の`~header~list$rs内に［ `Content-Type$h を`名前に持つ~header$ ］は無い ］ ⇒ %応答 の`~header~list$rsに`~headerを付加する$( ( `Content-Type$h, %型 ) ) ◎ If body’s type is non-null and response’s header list does not contain `Content-Type`, then append (`Content-Type`, body’s type) to response’s header list.

`new Response(body, init)@m 構築子~手続きは： ◎ The new Response(body, init) constructor steps are:

1. %応答 ~LET 新たな`応答$ ◎ ↓
2. コレの`応答$Rs ~SET %応答 ◎ Set this’s response to a new response.
3. コレの`~Headers$Rs ~SET `新たな~obj$( `Headers$I, コレに`関連な~realm$ ) — その ⇒＃ `~header~list$Hl ~SET %応答 の`~header~list$rs, `~guard$Hl ~SET `response^l ◎ Set this’s headers to a new Headers object with this’s relevant realm, whose header list is this’s response’s header list and guard is "response".
4. %本体と型 ~LET %body に応じて ⇒＃ ~NULL ならば ~NULL ／ ~ELSE_ `本体と型を抽出する$( %body ) ◎ Let bodyWithType be null. ◎ If body is non-null, then set bodyWithType to the result of extracting body.
5. `~Response~objを初期化する$( コレ, %init, %本体と型 ) ◎ Perform initialize a response given this, init, and bodyWithType.

`redirect(url, status)@m 静的~method手続きは： ◎ The static redirect(url, status) method steps are:

1. %構文解析した~URL ~LET `~URL構文解析する$( %url, `現在の設定群~obj$の`~API用~基底~URL$enV ) ◎ Let parsedURL be the result of parsing url with current settings object’s API base URL.
2. ~IF［ %構文解析した~URL ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parsedURL is failure, then throw a TypeError.
3. ~IF［ %status は `~redirect状態s$でない ］ ⇒ ~THROW `RangeError$E ◎ If status is not a redirect status, then throw a RangeError.
4. %~Response~obj ~LET `~Response~objを作成する$( 新たな`応答$, `immutable^l, `現在の~realm$ ) ◎ Let responseObject be the result of creating a Response object, given a new response, "immutable", and the current realm.
5. %~Response~obj の`応答$Rsの`状態s$rs ~SET %status ◎ Set responseObject’s response’s status to status.
6. %値 ~LET `同型に符号化する$( `~URLを直列化する$( %構文解析した~URL ) ) ◎ Let value be parsedURL, serialized and isomorphic encoded.
7. %~Response~obj の`応答$Rsの`~header~list$rsに`~headerを付加する$( ( `Location$h, %値 ) ) ◎ Append (`Location`, value) to responseObject’s response’s header list.
8. ~RET %~Response~obj ◎ Return responseObject.

`json(data, init)@m 静的~method手続きは： ◎ The static json(data, init) method steps are:

1. %~byte列 ~LET `~JS値を~JSON~byte列に直列化する$( %data ) ◎ Let bytes the result of running serialize a JavaScript value to JSON bytes on data.
2. %本体と型【！body】 ~LET `本体と型を抽出する$( %~byte列 ) ◎ Let body be the result of extracting bytes.
3. %~Response~obj ~LET `~Response~objを作成する$( 新たな`応答$, `response^l, `現在の~realm$ ) ◎ Let responseObject be the result of creating a Response object, given a new response, "response", and the current realm.
4. %本体と型 の`型$bwT ~SET `application/json^l ◎ ↓
5. `~Response~objを初期化する$( %~Response~obj, %init, %本体と型 ) ◎ Perform initialize a response given responseObject, init, and (body, "application/json").
6. ~RET %~Response~obj ◎ Return responseObject.

`redirected@m 取得子~手続きは ⇒ ~RET ~IS［ コレの`応答$Rsの`~URL~list$rsの`~size$ ~GT 1 ］ ◎ The redirected getter steps are to return true if this’s response’s URL list’s size is greater than 1; otherwise false.

注記： ~redirectの結果による`応答$をはじくときは、 ~APIを通して直に行う — 例えば `fetch(url, { redirect:"error" })^c のように。 こうすれば、 安全でないものにもなり得る`応答$が不用意に漏洩されるのを~~防げる。 ◎ To filter out responses that are the result of a redirect, do this directly through the API, e.g., fetch(url, { redirect:"error" }). This way a potentially unsafe response cannot accidentally leak.

`clone()@m ~method手続きは： ◎ The clone() method steps are:

1. ~IF［ コレは`利用-不能$Bdである ］ ⇒ ~THROW `TypeError$E ◎ If this is unusable, then throw a TypeError.
2. %~cloneした応答 ~LET `応答を~cloneする$( コレの`応答$Rs ) ◎ Let clonedResponse be the result of cloning this’s response.
3. ~RET `~Response~objを作成する$( %~cloneした応答, コレの`~Headers$Rsの`~guard$Hl, コレに`関連な~realm$ ) ◎ Return the result of creating a Response object, given clonedResponse, this’s headers’s guard, and this’s relevant realm.

`fetch(input, init)@m ~method手続きは： ◎ The fetch(input, init) method steps are:

1. %~promise ~LET `新たな~promise$ ◎ Let p be a new promise.
2. %~Request~obj ~LET 新たな `Request$I ~obj ◎ ↓
3. %~Request~obj 上の `new Request$m 構築子~手続き( %input, %init ) 【！構築子の初期~値を呼出した結果】 ⇒ 例外が投出された場合は ⇒＃ `~promiseを却下する$( %~promise, その例外 )； ~RET %~promise ◎ Let requestObject be the result of invoking the initial value of Request as constructor with input and init as arguments. If this throws an exception, reject p with it and return p.
4. %要請 ~LET %~Request~obj の`要請$Rq ◎ Let request be requestObject’s request.

5. ~IF［ %~Request~obj の`通達$Rqは`中止-済み$aBである ］： ◎ If requestObject’s signal is aborted, then:

   1. `~fetch_~callを中止する$( %~promise, %要請, ~NULL, %~Request~obj の`通達$Rqの`中止-事由$aB ) ◎ Abort the fetch() call with p, request, null, and requestObject’s signal’s abort reason.
   2. ~RET %~promise ◎ Return p.
6. %大域~obj ~LET %要請 の`~client$rqの`大域~obj$enV ◎ Let globalObject be request’s client’s global object.
7. ~IF［ %大域~obj は `ServiceWorkerGlobalScope$I ~objである ］ ⇒ %要請 の`~sw~mode$rq ~SET `none^l ◎ If globalObject is a ServiceWorkerGlobalScope object, then set request’s service-workers mode to "none".
8. %~Response~obj ~LET ~NULL ◎ Let responseObject be null.
9. %関連な~realm ~LET コレに`関連な~realm$ ◎ Let relevantRealm be this’s relevant realm.

10. %局所的に中止されたか ~LET ~F ◎ Let locallyAborted be false.

    注記： これは、 ~fetchの~callと同じ~threadから中止するよう要請されたとき， ~promiseを却下する時機を予測-可能にするためにある。 ◎ This lets us reject promises with predictable timing, when the request to abort comes from the same thread as the call to fetch.

11. %制御器 ~LET ~NULL ◎ Let controller be null.

12. `通達に~algoを追加する$( %~Request~obj の`通達$Rq, 次の手続き ) ◎ Add the following abort steps to requestObject’s signal:

    手続きは： ◎ ↑

    1. %局所的に中止されたか ~SET ~T ◎ Set locallyAborted to true.
    2. ~Assert： %制御器 ~NEQ ~NULL ◎ Assert: controller is non-null.
    3. %中止-事由 ~LET %~Request~obj の`通達$Rqの`中止-事由$aB ◎ ↓
    4. `~fetchを中止する$( %制御器, %中止-事由 ) ◎ Abort controller with requestObject’s signal’s abort reason.
    5. `~fetch_~callを中止する$( %~promise, %要請, %~Response~obj, %中止-事由 ) ◎ Abort the fetch() call with p, request, responseObject, and requestObject’s signal’s abort reason.

13. %制御器 ~SET %要請 を`~fetchする$ — 次を与える下で： ◎ Set controller to the result of calling fetch given request＼

    • `応答の処理n$i ~SET 所与の ( %応答 ) に対し，次を走らす手続き： ◎ and processResponse given response being these steps:

      1. ~IF［ %局所的に中止されたか ~EQ ~T ］ ⇒ ~RET ◎ If locallyAborted is true, then abort these steps.

      2. ~IF［ %応答 の`中止されたか$rs ~EQ ~T ］： ◎ If response’s aborted flag is set, then:

         1. %逆直列化した~error ~LET `直列化された中止-事由を逆直列化する$( %制御器 の`直列化された中止-事由$, %関連な~realm ) ◎ Let deserializedError be the result of deserialize a serialized abort reason given controller’s serialized abort reason and relevantRealm.
         2. `~fetch_~callを中止する$( %~promise, %要請, %~Response~obj, %逆直列化した~error ) ◎ Abort the fetch() call with p, request, responseObject, and deserializedError.
         3. ~RET ◎ Abort these steps.
      3. ~IF［ %応答 は`~network~error$である ］ ⇒＃ `~promiseを却下する$( %~promise, `TypeError$E )； ~RET ◎ If response is a network error, then reject p with a TypeError and abort these steps.
      4. %~Response~obj ~SET `~Response~objを作成する$( %応答, `immutable^l, %関連な~realm ) ◎ Set responseObject to the result of creating a Response object, given response, "immutable", and relevantRealm.
      5. `~promiseを解決する$( %~promise, %~Response~obj ) ◎ Resolve p with responseObject.
14. ~RET %~promise ◎ Return p.

`~fetch_~callを中止する@ ~algoは、 所与の ( %~promise, %要請, %~Response~obj, %~error ) に対し： ◎ To abort a fetch() call with a promise, request, responseObject, and an error:

1. `~promiseを却下する$( %~promise, %~error ) ◎ Reject promise with error.

   注記： %~promise がすでに充足されていた場合、 これは何もしない。 ◎ This is a no-op if promise has already fulfilled.

2. ~IF［ %要請 の`本体$rq ~NEQ ~NULL ］~AND［ %要請 の`本体$rqは`読取n可能$RSである ］ ⇒ %要請 の`本体$rqを`取消す$RS( %~error ) ◎ If request’s body is non-null and is readable, then cancel request’s body with error.
3. ~IF［ %~Response~obj ~EQ ~NULL ］ ⇒ ~RET ◎ If responseObject is null, then return.
4. %応答 ~LET %~Response~obj の`応答$Rs ◎ Let response be responseObject’s response.
5. ~IF［ %応答 の`本体$rs ~NEQ ~NULL ］~AND［ %応答 の`本体$rsは`読取n可能$RSである ］ ⇒ %応答 の`本体$rsを`~errorにする$RS( %~error ) ◎ If response’s body is non-null and is readable, then error response’s body with error.