Fetch

要为一个 Fetch 控制器 controller 执行 报告时序 ，给定一个 全局对象 global：

1. 断言：controller 的 报告时序步骤 不为 null。

2. 调用 controller 的 报告时序步骤 并传入 global。

要为一个 Fetch 控制器 controller 执行 处理下一个手动重定向：

1. 断言：controller 的 下一个手动重定向步骤 不为 null。

2. 调用 controller 的 下一个手动重定向步骤。

要提取 Fetch 控制器 controller 的 完整时序信息：

1. 断言：controller 的 完整时序信息 不为 null。

2. 返回 controller 的 完整时序信息。

要中止一个fetch 控制器 controller，可选error：

1. 将 controller 的 状态 设置为 "aborted"。

2. 将 fallbackError 设置为 "AbortError" DOMException。

3. 如果未给定 error，则将其设置为 fallbackError。

4. 将 serializedError 设置为 结构化序列化(error)。 如果抛出异常，则捕获并将 serializedError 设置为 结构化序列化(fallbackError)。

5. 将 controller 的 序列化的中止原因 设置为 serializedError。

要反序列化一个序列化的中止原因，给定 null 或 记录 abortReason 及 realm realm：

1. 将 fallbackError 设置为 "AbortError" DOMException。

2. 将 deserializedError 设置为 fallbackError。

3. 如果 abortReason 不为 null，则将 deserializedError 设置为 结构化反序列化(abortReason, realm)。如果抛出异常或返回 undefined，则将 deserializedError 设置为 fallbackError。

4. 返回 deserializedError。

要终止一个fetch 控制器 controller，将controller的状态设置为 "terminated"。

要 创建不透明时序信息，给定一个 Fetch 时序信息 timingInfo，返回一个新的 Fetch 时序信息，其 开始时间 和 重定向后开始时间 与 timingInfo 的 开始时间 相同。

要 排队一个 Fetch 任务，给定一个算法 algorithm，全局对象 或 并行队列 taskDestination，执行以下步骤：

1. 如果 taskDestination 是 并行队列，则将 algorithm 排入 taskDestination。

2. 否则，在 网络任务源 上为 taskDestination 和 algorithm 排队一个全局任务。

要 收集 HTTP 引号字符串，从 字符串 input 中，给定一个 位置变量 position 及一个可选的布尔值 extract-value（默认为 false）：

1. 将 positionStart 设为 position。

2. 将 value 设为空字符串。

3. 断言：input 中 position 处的 码点 是 U+0022 (")。

4. 将 position 前移 1。

5. 执行如下操作，直到结束：

   1. 将从 input 中 position 处的 收集到的序列码点，若不为 U+0022 (") 或 U+005C (\) 则附加到 value。

   2. 如果 position 超过 input 末尾，则 终止。

   3. 将 quoteOrBackslash 设为 input 中 position 处的 码点。

   4. 将 position 前移 1。

   5. 如果 quoteOrBackslash 是 U+005C (\)，则执行以下操作：

      1. 如果 position 超过 input 末尾，则将 U+005C (\) 附加到 value 并 终止。

      2. 将 position 处 input 中的 码点 附加到 value。

      3. 将 position 前移 1。

   6. 否则：

      1. 断言：quoteOrBackslash 是 U+0022 (")。

      2. 终止。

6. 如果 extract-value 为 true，则返回 value。

7. 返回 input 中从 positionStart 到 position 的 码点，包括在内。

要获取结构化字段值，给定头名name和字符串type，从头列表list中，执行以下步骤。它们返回null或结构化字段值。

1. 断言：type是"dictionary"、"list"或"item"之一。

2. 让value成为从listname获得的结果。

3. 如果value为null，则返回null。

4. 让result成为解析结构化字段的结果，input_string设置为value，header_type设置为type。

5. 如果解析失败，则返回null。

6. 返回result。

获取结构化字段值有意不区分头是否存在，以及其值是否解析为结构化字段值失败。这确保了Web平台的一致处理。

要设置结构化字段值，给定一个元组(头名name，结构化字段值structuredValue），在头列表list中：

1. 让serializedValue成为执行序列化结构化字段算法得到的structuredValue的结果。

2. 设置（name，serializedValue）在list中。

结构化字段值定义为HTTP最终可以以有趣和有效的方式序列化的对象。目前，Fetch仅支持作为头值的字节序列，这意味着这些对象只能通过序列化设置在头列表中，且只能通过解析从头列表中获得。在未来，它们作为对象的事实可能会被端到端地保留。[RFC8941]

一个头列表list包含一个头名name，如果list包含一个头，其名字是与name字节不区分大小写匹配的。

要获取一个头名name从头列表list中，运行这些步骤。它们返回null或头值。

1. 如果list不包含name，则返回null。

2. 返回list中所有头的值，其名字是与name字节不区分大小写匹配的，彼此之间用0x2C 0x20分隔，按顺序排列。

要获取、解码和拆分一个头名name从头列表list中，运行这些步骤。它们返回null或字符串列表。

1. 让value成为获取name从list的结果。

2. 如果value为null，则返回null。

3. 返回获取、解码和拆分value的结果。

要获取、解码和拆分一个头值value，运行这些步骤。它们返回字符串列表。

1. 让input成为等同解码value的结果。

2. 让position成为input的位置变量，初始指向input的开头。

3. 让values成为一个字符串列表，初始为« »。

4. 让temporaryValue为空字符串。

5. 当为真时：

   1. 将结果收集的代码点序列（不是U+0022（"）或U+002C（,））从input中，给定position，添加到temporaryValue。

      结果可能是空字符串。

   2. 如果 position 没有超出 input 的末尾，且 input 中 position 位置的 代码点 是 U+0022 (")：

      1. 将从 input 中，基于 position，收集到的 HTTP 引号字符串 结果追加到 temporaryValue。

      2. 如果 position 没有超出 input 的末尾，则 继续。

   3. 移除 temporaryValue 开头和结尾的所有HTTP 制表符或空格。

   4. 将 temporaryValue 追加到 values。

   5. 将 temporaryValue 设为空字符串。

   6. 如果 position 超出 input 的末尾，则返回 values。

   7. 断言：input 中 position 位置的 代码点 是 U+002C (,)。

   8. 将 position 前进 1。

除了特别指定的调用点，以上算法不得直接调用。应使用 获取、解码并拆分 代替。

要追加一个头（name，value）到一个头列表list中：

1. 如果list包含name，则将name设置为第一个匹配的头的名字。

   这重用了list中已存在的头的名字的大小写。如果有多个匹配的头，它们的名字都将相同。

2. 追加（name，value）到list。

要删除一个头名name从一个头列表list中，移除所有头，其名字与name字节不区分大小写匹配，从list中。

要设置一个头（name，value）在头列表list中：

1. 如果list包含name，则将第一个匹配的头的值设置为value并移除其他的。

2. 否则，追加（name，value）到list。

要合并一个头（name，value）在头列表list中：

1. 如果list包含name，则将第一个匹配的头值设置为value，并在其后追加0x2C 0x20，再追加value。

2. 否则，追加（name，value）到list。

合并由XMLHttpRequest和WebSocket协议握手使用。

要将头名称转换为排序的小写集合，给定名称列表headerNames，执行这些步骤。它们返回一个有序集合的头名。

1. 让headerNamesSet成为一个新的有序集合。

2. 对于每一个headerNames的name，追加结果字节小写name到headerNamesSet。

3. 返回结果排序headerNamesSet按升序排序，并使用字节小于。

要排序并合并一个头列表list，执行这些步骤。它们返回一个头列表。

1. 让headers成为一个头列表。

2. 让names成为结果将头名称转换为排序的小写集合与所有的名字在list的头中。

3. 对于每一个names的name：

   1. 如果name是`set-cookie`，则：

      1. 让values成为一个列表，包含所有值的头在list中，其名字是与name字节不区分大小写匹配的，按顺序排列。

      2. 对于每一个values的value：

         1. 追加（name，value）到headers。

   2. 否则：

      1. 让value成为结果获取name从list中。

      2. 断言：value非null。

      3. 追加（name，value）到headers。

4. 返回headers。

要规范化一个字节序列potentialValue，移除任何前导和尾随HTTP空白字节从potentialValue。

要确定是否一个头（name，value）是一个CORS安全列出的请求头，运行这些步骤：

1. 如果value的长度大于128，则返回false。

2. 字节小写name并根据结果切换：

   `accept`

   如果value包含一个CORS不安全的请求头字节，则返回false。

   `accept-language`

   `content-language`

   如果value包含一个不在范围0x30（0）到0x39（9）之间的字节，不在范围0x41（A）到0x5A（Z）之间的字节，不在范围0x61（a）到0x7A（z）之间的字节，并且不是0x20（SP），0x2A（*），0x2C（,），0x2D（-），0x2E（.），0x3B（;），或0x3D（=）的字节，则返回false。

   `content-type`

   1. 如果value包含一个CORS不安全的请求头字节，则返回false。

   2. 让mimeType成为结果解析 的结果，解析value的结果。

   3. 如果mimeType解析失败，则返回false。

   4. 如果mimeType的本质不是"application/x-www-form-urlencoded"，"multipart/form-data"，或"text/plain"，则返回false。

   这故意不使用提取MIME类型，因为该算法相对宽容，而服务器并不期望实现它。

   如果使用了提取MIME类型，以下请求将不会导致CORS预检，服务器上的简单解析器可能会将请求体视为JSON：

   fetch("https://victim.example/naïve-endpoint", {
   method: "POST",
   headers: [
         ["Content-Type", "application/json"],
         ["Content-Type", "text/plain"]
   ], 
   credentials: "include",
   body: JSON.stringify(exerciseForTheReader) 
   }); 
   

   `range`

   1. 让rangeValue成为结果解析单个范围头值给定value和false。

   2. 如果rangeValue解析失败，则返回false。

   3. 如果rangeValue[0]为null，则返回false。

      由于网络浏览器历史上没有发出类似`bytes=-500`的范围，本算法不将它们列入白名单。

   其他情况

   返回false。

3. 返回true。

对于`Content-Type`头的安全列表，有有限的例外，如在CORS协议例外中记录的那样。

一个CORS不安全的请求头字节是一个字节byte，满足以下任一条件：

• byte小于0x20且不是0x09 HT

• byte是0x22（"），0x28（左括号），0x29（右括号），0x3A（:），0x3C（<），0x3E（>），0x3F（?），0x40（@），0x5B（[），0x5C（\），0x5D（]），0x7B（{），0x7D（}），或0x7F DEL。

CORS不安全的请求头名称，给定头列表headers，确定如下：

1. 让unsafeNames成为一个新的列表。

2. 让potentiallyUnsafeNames成为一个新的列表。

3. 让safelistValueSize为0。

4. 对于每一个headers的header：

   1. 如果header不是CORS安全列出的请求头，则追加header的名字到unsafeNames。

   2. 否则，追加header的名字到potentiallyUnsafeNames，并增加safelistValueSize的header的值的长度。

5. 如果safelistValueSize大于1024，则对于每一个potentiallyUnsafeNames的name，追加name到unsafeNames。

6. 返回使用unsafeNames进行的将头名称转换为排序的小写集的结果。

要确定是否一个头（name，value）是一个no-CORS安全列出的请求头，运行这些步骤：

1. 如果name不是一个no-CORS安全列出的请求头名，则返回false。

2. 返回是否（name，value）是一个CORS安全列出的请求头。

一个头（name，value）是禁止的请求头，如果这些步骤返回true：

1. 如果name是一个字节不区分大小写匹配的：

   • `Accept-Charset`
   • `Accept-Encoding`
   • `Access-Control-Request-Headers`
   • `Access-Control-Request-Method`
   • `Connection`
   • `Content-Length`
   • `Cookie`
   • `Cookie2`
   • `Date`
   • `DNT`
   • `Expect`
   • `Host`
   • `Keep-Alive`
   • `Origin`
   • `Referer`
   • `Set-Cookie`
   • `TE`
   • `Trailer`
   • `Transfer-Encoding`
   • `Upgrade`
   • `Via`

   则返回true。

2. 如果name在字节小写化后以`proxy-`或`sec-`开头，则返回true。

3. 如果name是一个字节不区分大小写匹配的：

   • `X-HTTP-Method`
   • `X-HTTP-Method-Override`
   • `X-Method-Override`

   则：

   1. 让parsedValues成为结果获取，解码和拆分value。

   2. 对于每一个parsedValues的method：如果method的同构编码是一个禁止的方法，则返回true。

4. 返回false。

要提取头值，给定头header，运行这些步骤：

1. 如果解析header的值，根据header的ABNF为header的名字失败，则返回失败。

2. 返回一个或多个值，结果来自解析header的值，根据header的ABNF为header的名字。

要提取头列表值，给定头名name和头列表list，运行这些步骤：

1. 如果list不包含name，则返回null。

2. 如果name允许单个头，并且list包含多于一个，则返回失败。

   如果需要不同的错误处理，请先提取所需的头。

3. 让values成为一个空的列表。

4. 对于每一个头header，list包含其name是name：

   1. 让extract成为结果提取头值从header。

   2. 如果extract失败，则返回失败。

   3. 依次将extract中的每个值追加到values中。

5. 返回values。

要构建内容范围，给定一个整数rangeStart，一个整数rangeEnd，和一个整数fullLength，运行这些步骤：

1. 让contentRange成为`bytes `。

2. 追加rangeStart，序列化并且同构编码，到contentRange。

3. 追加0x2D（-）到contentRange。

4. 追加rangeEnd，序列化并且同构编码到contentRange。

5. 追加0x2F（/）到contentRange。

6. 追加fullLength，序列化并且同构编码到contentRange。

7. 返回contentRange。

要解析单个范围头值从字节序列value和一个布尔值allowWhitespace，运行这些步骤：

1. 让data成为同构解码的value。

2. 如果data不以"bytes"开头，则返回失败。

3. 让position成为位置变量的data，初始指向data的第5个代码点。

4. 如果allowWhitespace为true，收集一个代码点序列，这些是HTTP制表符或空格，来自data给定position。

5. 如果position内data的代码点不是U+003D（=），则返回失败。

6. 将position前进1。

7. 如果allowWhitespace为true，收集一个代码点序列，这些是HTTP制表符或空格，来自data给定position。

8. 让rangeStart成为结果收集一个代码点序列，这些是ASCII数字，来自data给定position。

9. 让rangeStartValue成为rangeStart，解释为十进制数，如果rangeStart不是空字符串；否则为null。

10. 如果allowWhitespace为true，收集一个代码点序列，这些是HTTP制表符或空格，来自data给定position。

11. 如果position内data的代码点不是U+002D（-），则返回失败。

12. 将position前进1。

13. 如果allowWhitespace为true，收集一个代码点序列，这些是HTTP制表符或空格，来自data给定position。

14. 让rangeEnd成为结果收集一个代码点序列，这些是ASCII数字，来自data给定position。

15. 让rangeEndValue成为rangeEnd，解释为十进制数，如果rangeEnd不是空字符串；否则为null。

16. 如果position不是data的末尾，则返回失败。

17. 如果rangeEndValue和rangeStartValue是null，则返回失败。

18. 如果rangeStartValue和rangeEndValue是数字，并且rangeStartValue大于rangeEndValue，则返回失败。

19. 返回（rangeStartValue，rangeEndValue）。

    范围结束或起始可以省略，例如`bytes=0-`或`bytes=-500`是有效的范围。

解析单个范围头值对于允许的范围头值子集是成功的，但它是用户代理在请求媒体或恢复下载时使用的最常见形式。这种格式的范围头值可以使用添加范围头设置。

要克隆一个主体body，请执行以下步骤：

1. 让« out1，out2 »成为双路分流body的流的结果。

2. 将body的流设置为out1。

3. 返回一个主体，其流为out2，其他成员从body复制。

要获取一个字节序列bytes作为主体，请返回主体，其结果为安全提取bytes的结果。

要逐步读取一个主体body，给定一个算法processBodyChunk、一个算法processEndOfBody、一个算法processBodyError，以及一个可选的null、并行队列或全局对象taskDestination（默认为null），请执行以下步骤。processBodyChunk必须是接受字节序列的算法。processEndOfBody必须是接受无参数的算法。processBodyError必须是接受异常的算法。

1. 如果taskDestination为null，则将taskDestination设置为启动新并行队列的结果。

2. 让reader成为获取一个读取器的结果，针对body的流。

   此操作不会抛出异常。

3. 执行逐步读取循环，给定reader、taskDestination、processBodyChunk、processEndOfBody和processBodyError。

要执行逐步读取循环，给定一个ReadableStreamDefaultReader对象reader、并行队列或全局对象taskDestination、算法processBodyChunk、算法processEndOfBody和算法processBodyError：

1. 让readRequest成为以下读取请求：

   块步骤，给定chunk

   1. 将continueAlgorithm设为null。

   2. 如果chunk不是Uint8Array对象，则将continueAlgorithm设置为以下步骤：给定TypeError，运行processBodyError。

   3. 否则：

      1. 让bytes成为chunk的副本。

         强烈建议实现尽可能采用避免此副本的策略。

      2. 将continueAlgorithm设置为以下步骤：

         1. 给定bytes，运行processBodyChunk。

         2. 给定reader、taskDestination、processBodyChunk、processEndOfBody和processBodyError，执行逐步读取循环。

   4. 给定continueAlgorithm和taskDestination，将获取任务排队。

   关闭步骤

   1. 给定processEndOfBody和taskDestination，将获取任务排队。

   错误步骤，给定e

   1. 给定processBodyError和taskDestination，将获取任务排队，运行processBodyError并给定e。

2. 从reader读取一个块，给定readRequest。

要完全读取一个主体body，给定一个算法processBody、一个算法processBodyError，以及一个可选的null、并行队列或全局对象taskDestination（默认为null），请执行以下步骤。processBody必须是接受字节序列的算法。processBodyError必须是一个可选的接受异常的算法。

1. 如果taskDestination为null，则将taskDestination设置为启动新并行队列的结果。

2. 给定一个字节序列bytes，让successSteps成为bytes，将获取任务排队，运行processBody并给定bytes，并使用taskDestination。

3. 给定一个可选的异常exception，让errorSteps成为exception，将获取任务排队，运行processBodyError并给定exception，并使用taskDestination。

4. 让reader成为获取一个读取器的结果，针对body的流。如果抛出异常，则使用该异常运行errorSteps并返回。

5. 给定successSteps和errorSteps，从reader读取所有字节。

要处理内容编码，给定codings和bytes，请执行以下步骤：

1. 如果codings不受支持，则返回bytes。

2. 返回使用codings解码bytes的结果，如HTTP中所述，如果解码未导致错误，则返回结果，否则失败。[HTTP]

一个请求 请求如果满足以下步骤返回true，则具有一个重定向污染来源：

1. 令lastURL为null。

2. 对 请求的URL列表中的每个url：

   1. 如果lastURL是null，则将lastURL设置为url并继续。

   2. 如果url的来源与lastURL的来源不同源，并且请求的来源与lastURL的来源不同源，则返回true。

   3. 设置lastURL为url。
3. 返回false。

序列化请求来源，给定一个请求 请求，运行以下步骤：

1. 如果请求有重定向污染来源，则返回"null"。

2. 返回请求的来源，序列化。

字节序列化请求来源，给定一个请求 请求， 运行以下步骤来返回序列化请求来源的结果，同构编码。

为了克隆一个请求 请求，运行以下步骤：

1. 令newRequest是请求的副本，但不包括它的正文。

2. 如果请求的正文非空，将newRequest的正文设置为克隆请求的正文的结果。

3. 返回newRequest。

为了添加范围标头到一个请求 请求，并带有一个整数first和一个可选的整数last，运行以下步骤：

1. 断言：未提供last，或first小于或等于last。

2. 令rangeValue为`bytes=`。

3. 序列化并同构编码first，并将结果附加到rangeValue。

4. 将0x2D (-)附加到rangeValue。

5. 如果提供了last，则序列化并同构编码它，并将结果附加到rangeValue。

6. 附加(`Range`，rangeValue)到请求的标头列表。

范围标头表示一个包含的字节范围。这里一个范围标头first是0而last是500，表示一个501字节的范围。

将多个响应组合成一个逻辑资源的功能历来是安全漏洞的来源。请为涉及部分响应的功能寻求安全审查。

为了序列化响应URL以进行报告，给定一个响应 响应，运行以下步骤：

1. 断言：响应的URL列表非空。

2. 令url为响应的URL列表[0]的副本。

   这不是响应的URL，以避免泄露关于重定向目标的信息（请参见CSP报告中的类似考虑）。[CSP]

3. 设置用户名给定url和空字符串。

4. 设置密码给定url和空字符串。

5. 返回url的序列化，并设置排除片段为true。

为了检查跨源嵌入策略是否允许凭证，给定一个请求请求，运行以下步骤：

1. 如果请求的模式不是"no-cors"，则返回true。

2. 如果请求的客户端是null，则返回true。

3. 如果请求的客户端的策略容器的嵌入策略的值不是"credentialless"，则返回true。

4. 如果请求的来源与请求的当前URL的来源同源，并且请求没有重定向污染来源，则返回true。

5. 返回false。

要根据fetch 参数 fetchParams创建合适的网络错误：

1. 断言：fetchParams已取消。

2. 如果fetchParams已中止，则返回一个中止的网络错误；否则，返回一个网络错误。

要克隆一个响应 response，运行以下步骤：

1. 如果response是一个过滤响应，则返回一个新的相同的过滤响应，其内部响应是克隆的response的内部响应。

2. 让newResponse成为response的一个副本，除去其正文。

3. 如果response的正文不为null，则将newResponse的正文设置为克隆 response的正文的结果。

4. 返回newResponse。

给定null或一个ASCII 字符串 requestFragment，一个响应 response的位置 URL是以下步骤返回的值。它们返回null、失败或一个URL。

1. 如果response的状态不是重定向状态，则返回null。

2. 将location设置为给定`Location`和response的标头列表提取标头列表值的结果。

3. 如果location是一个标头值，则将location设置为使用response的URL解析location的结果。

   如果response是通过Response构造函数构造的，则response的URL将为null，这意味着只有它是一个带片段的绝对 URL 字符串时，location才会成功解析。

4. 如果location是一个URL，其片段为null，则将location的片段设置为requestFragment。

   这确保了合成响应（实际上是所有响应）遵循 HTTP 定义的重定向处理模型。[HTTP]

5. 返回location。

位置 URL算法仅用于该标准中的重定向处理以及手动处理重定向的HTML导航算法。[HTML]

要转换potentialDestination的潜在目的地，运行以下步骤：

1. 如果potentialDestination为“fetch”，则返回空字符串。

2. 断言：potentialDestination是目的地。

3. 返回potentialDestination。

要解析一个来源，给定一个网络分区密钥key和一个来源origin：

1. 如果origin的host是一个IP地址，则返回« origin的host »。

2. 如果origin的host的公共后缀是"localhost"或"localhost."，则返回« ::1，127.0.0.1 »。

3. 执行一个实现定义的操作，将origin转换为一个或多个IP地址的集合。

   还可以实现定义的其他操作，以获取连接信息，而不仅仅是IP地址。例如，如果origin的scheme是一个HTTP(S) scheme，实现可能会执行DNS查询以获取HTTPS RRs。[SVCB]

   如果此操作成功，则返回集合，其中包括IP地址和任何额外的实现定义的信息。

4. 返回失败。

解析来源的结果可以被缓存。如果它们被缓存，则应使用key作为缓存密钥的一部分。

要限制和粗化连接时间信息，给定一个连接时间信息timingInfo、一个DOMHighResTimeStampdefaultStartTime和一个布尔值crossOriginIsolatedCapability，运行以下步骤：

1. 如果timingInfo的连接开始时间小于defaultStartTime，则返回一个新的连接时间信息，其中域名查找开始时间为defaultStartTime，域名查找结束时间为defaultStartTime，连接开始时间为defaultStartTime，连接结束时间为defaultStartTime，安全连接开始时间为defaultStartTime，以及ALPN 协商协议为timingInfo的ALPN 协商协议。

2. 返回一个新的连接时序信息，其中域名查询开始时间是给定timingInfo的域名查询开始时间和 crossOriginIsolatedCapability的粗化时间的结果，域名查询结束时间是给定timingInfo的域名查询结束时间和 crossOriginIsolatedCapability的粗化时间的结果，连接开始时间是给定timingInfo的连接开始时间和 crossOriginIsolatedCapability的粗化时间的结果，连接结束时间是给定timingInfo的连接结束时间和 crossOriginIsolatedCapability的粗化时间的结果，安全连接开始时间 是给定timingInfo的连接结束时间和 crossOriginIsolatedCapability的粗化时间的结果，ALPN 协议协商是 timingInfo的ALPN 协议协商。

要获取一个连接，给定一个网络分区密钥key、URLurl、布尔值credentials、一个可选的新连接设置new（默认值为"no"），以及一个可选的布尔值requireUnreliable（默认值为false），运行以下步骤：

1. 如果new为"no"，则：

   1. 令connections为用户代理的连接池中连接的集合，其中key为密钥，origin为url的来源，凭据为credentials。

   2. 如果connections不为空且requireUnreliable为false，则返回connections中的一个。

   3. 如果在connections中有支持不可靠传输的连接，例如HTTP/3，则返回该连接。

2. 令proxies为以实现定义的方式找到的用于url的代理的结果。如果没有代理，则令proxies为«"DIRECT"»。

   这是非标准技术（如Web Proxy Auto-Discovery Protocol (WPAD)和proxy auto-config (PAC)）发挥作用的地方。"DIRECT"值意味着对于这个特定的url不使用代理。

3. 令timingInfo为新的连接时间信息。

4. 对于每个proxies中的proxy：

   1. 将timingInfo的域名查找开始时间设置为不安全共享当前时间。

   2. 令hosts为«url的来源的host»。

   3. 如果proxy为"DIRECT"，则将hosts设置为运行解析一个origin给定key和url的来源的结果。

   4. 如果hosts为失败，则继续。

   5. 将timingInfo的域名查找结束时间设置为不安全共享当前时间。

   6. 令connection为运行以下步骤的结果：运行创建一个连接给定key、url的来源、credentials、proxy、从hosts中以实现定义的方式获取的host、timingInfo、和requireUnreliable，以实现定义的次数彼此并行运行，并等待至少1个返回一个值。在实现定义的方式中，从返回的值中选择一个值并返回它。任何其他返回的为连接的值可能会被关闭。

      本质上，这允许实现从解析一个origin的返回值中选择一个或多个IP地址（假设proxy为"DIRECT"）并让它们彼此竞争，优先选择IPv6地址，在超时的情况下重试等。

   7. 如果connection失败，则继续。

   8. 如果new不是"yes-and-dedicated"，则追加connection到用户代理的连接池。

   9. 返回connection。

5. 返回失败。

这故意有点模糊，因为连接管理有很多细微差别，最好由实现者自行决定。描述这一点有助于解释<link rel=preconnect>功能，并明确规定连接 以凭证为关键。这后一部分澄清了，例如，TLS会话标识符不会在凭证为假的连接与凭证为真的连接之间复用。

要创建一个连接，给定一个网络分区密钥key、来源origin、布尔值credentials、字符串proxy、hosthost、连接时间信息timingInfo和布尔值requireUnreliable，运行以下步骤：

1. 将timingInfo的连接开始时间设置为不安全共享当前时间。

2. 令connection为新的连接，其中key为密钥，origin为origin，credentials为凭据，timingInfo为时间信息。记录连接时间信息，给定connection，并使用connection建立一个到host的HTTP连接，考虑proxy和origin，具有以下警告：[HTTP][HTTP1][TLS]

   • 如果requireUnreliable为true，则建立一个支持不可靠传输的连接，例如一个HTTP/3连接。[HTTP3]

   • 在建立一个支持不可靠传输的连接时，启用WebTransport所需的选项。对于HTTP/3，这意味着在初始SETTINGS帧中包括SETTINGS_ENABLE_WEBTRANSPORT，值为1，以及H3_DATAGRAM，值为1。[WEBTRANSPORT-HTTP3][HTTP3-DATAGRAM]

   • 如果credentials为false，则不要发送TLS客户端证书。

   • 如果建立连接不成功（例如，UDP、TCP或TLS错误），则返回失败。

3. 将timingInfo的ALPN 协商协议设置为connection的ALPN协议ID，具有以下警告：[RFC7301]

   • 当配置了代理时，如果建立了隧道连接，则这必须是隧道协议的ALPN协议ID，否则必须是到代理的第一跳的ALPN协议ID。

   • 如果用户代理使用了实验性、未注册的协议，则用户代理必须使用使用的ALPN协议ID（如果有）。如果没有使用ALPN进行协议协商，则用户代理可以使用另一个描述性字符串。

     timingInfo的ALPN 协商协议旨在标识使用的网络协议，无论它实际上是如何协商的；即使ALPN未用于协商网络协议，这也是表示使用的协议的ALPN协议ID。

   IANA维护ALPN协议ID列表。

4. 返回connection。

要记录连接时间信息，给定一个连接connection，令timingInfo为connection的时间信息，并遵守以下要求：

• timingInfo的连接结束时间应为在建立与服务器或代理的连接后立即的不安全共享当前时间，如下所示：

  • 返回的时间必须包括建立传输连接的时间间隔，以及其他时间间隔，例如SOCKS身份验证时间。它还必须包括完成足够的TLS握手以请求资源所需的时间间隔。

  • 如果用户代理在此连接中使用了TLS False Start，则此时间间隔不应包括接收服务器Finished消息所需的时间。[RFC7918]

  • 如果用户代理在未等待完整握手完成的情况下发送了带有早期数据的请求，则此时间间隔不应包括接收服务器ServerHello消息所需的时间。[RFC8470]

  • 如果用户代理等待完整握手完成后发送请求，则此时间间隔包括完整的TLS握手，即使其他请求是使用早期数据在connection上发送的。

  假设用户代理通过TLS 1.3建立HTTP/2连接以发送GET请求和POST请求。它在时间t1发送ClientHello，然后使用早期数据发送GET请求。POST请求不安全（[HTTP]，第9.2.1节），所以用户代理在时间t2等待完成握手后才发送它。虽然两个请求都使用了相同的连接，但GET请求报告的连接结束时间是t1，而POST请求报告的是t2。

• 如果使用了安全传输，则timingInfo的安全连接开始时间应为在开始握手过程以安全connection之前调用不安全共享当前时间的结果。[TLS]

• 如果connection是HTTP/3连接，则timingInfo的连接开始时间和timingInfo的安全连接开始时间必须相等。（在HTTP/3中，安全传输握手过程是初始连接设置的一部分。）[HTTP3]

限制和粗化连接时间信息算法确保了重用连接的细节不会暴露，并且时间值被粗化。

要确定网络分区密钥，给定一个环境environment:

1. 令topLevelOrigin为environment的顶级来源。

2. 如果topLevelOrigin为null，则将topLevelOrigin设置为environment的顶级创建URL的来源。

3. 断言：topLevelOrigin是一个来源。

4. 令topLevelSite为给定topLevelOrigin 获取站点的结果。

5. 令secondKey为null或实现定义的值。

   第二个密钥故意有些模糊，因为细节仍在发展中。请参见问题#1035。

6. 返回(topLevelSite, secondKey)。

要确定网络分区密钥，给定一个请求request:

1. 如果request的保留客户端非null，则返回给定request的确定网络分区密钥的结果。

2. 如果request的客户端非null，则返回给定request的确定网络分区密钥的结果。

3. 返回null。

要确定HTTP缓存分区，给定一个请求 request:

1. 令key为给定request确定网络分区密钥的结果。

2. 如果key为null，则返回null。

3. 返回与key关联的唯一HTTP缓存。[HTTP-CACHING]

要确定是否由于使用了不良端口而阻止获取一个请求request:

1. 令url为request的当前URL。

2. 如果url的scheme是HTTP(S) scheme，并且url的端口是不良端口，则返回阻止。

3. 返回允许。

2.10. 是否应因MIME类型阻止response对request的响应?

运行以下步骤：

1. 将mimeType设为从response的标头列表中提取的MIME类型的结果。

2. 如果mimeType为失败，则返回允许。

3. 将destination设为request的目的地。

4. 如果destination是script-like，并且以下任意一项为真，则返回阻止：

   • mimeType的本质 以 "audio/"、"image/" 或 "video/" 开头。
   • mimeType的本质是 "text/csv"。

5. 返回允许。

为了附加请求的`Origin`标头， 给定request， request，请运行以下步骤：

1. 将serializedOrigin设为使用request 字节序列化请求来源的结果。

2. 如果request的response tainting为`cors`或 request的模式为`websocket`，则将(``Origin``, serializedOrigin)附加到request的标头列表中。

3. 否则，如果request的method既不是`GET`也不是`HEAD`，则：

   1. 如果request的模式不是`cors`， 则根据request的引用者策略进行切换：

      "no-referrer"

      将serializedOrigin设置为`null`。

      "no-referrer-when-downgrade"

      "strict-origin"

      "strict-origin-when-cross-origin"

      如果request的来源是元组来源，其scheme为 `"https"`，且request的当前URL的scheme不是 `"https"`，则将serializedOrigin设置为`null`。

      "same-origin"

      如果request的来源与request的当前URL的来源不同源，则将serializedOrigin设置为 `"null"`。

      否则

      什么也不做。

   2. 将 (`Origin`， serializedOrigin) 附加到request的标头列表中。

所有fetches中，request的 引用者策略都会被考虑在内，而fetcher没有明确选择与服务器共享其来源， 例如通过使用CORS协议。

要从 头列表 headers 中提取长度，请按以下步骤操作：

1. 让 values 是 获取、解码并分割自 headers 的 `Content-Length` 的结果。

2. 如果 values 为 null，则返回 null。

3. 让 candidateValue 为 null。

4. 对于每个 values 中的 value：

   1. 如果 candidateValue 为 null，则将 candidateValue 设置为 value。

   2. 否则，如果 value 不是 candidateValue，则返回失败。

5. 如果 candidateValue 是空字符串或具有非 ASCII 数字的码点，则返回 null。

6. 返回解释为十进制数字的 candidateValue。

要从 头列表 headers 中提取 MIME 类型，请运行以下步骤。它们将返回失败或MIME 类型。

1. 让 charset 为 null。

2. 让 essence 为 null。

3. 让 mimeType 为 null。

4. 让 values 是 获取、解码并分割自 headers 的 `Content-Type` 的结果。

5. 如果 values 为 null，则返回失败。

6. 对于每个 values 中的 value：

   1. 让 temporaryMimeType 是 解析 value 的结果。

   2. 如果 temporaryMimeType 是失败或其本质为"*/*"，则继续。

   3. 将 mimeType 设置为 temporaryMimeType。

   4. 如果 mimeType 的本质不为 essence，则：

      1. 将 charset 设置为 null。

      2. 如果 mimeType 的参数["charset"] 存在，则将 charset 设置为 mimeType 的参数["charset"]。

      3. 将 essence 设置为 mimeType 的本质。

   5. 否则，如果 mimeType 的参数["charset"]不存在，且 charset 非 null，则将 mimeType 的参数["charset"]设置为 charset。

7. 如果 mimeType 为 null，则返回失败。

8. 返回 mimeType。

在失败或给定MIME 类型 mimeType 和 编码 fallbackEncoding 时，传统提取编码，请运行以下步骤：

1. 如果 mimeType 为失败，则返回 fallbackEncoding。

2. 如果 mimeType["charset"]不存在，则返回 fallbackEncoding。

3. 让 tentativeEncoding 是 获取编码自 mimeType["charset"] 的结果。

4. 如果 tentativeEncoding 为失败，则返回 fallbackEncoding。

5. 返回 tentativeEncoding。

为了确定 nosniff，给定一个标头列表list，请执行以下步骤：

1. 令 values 为 获取、解码和分割`X-Content-Type-Options` 自 list的结果。

2. 如果 values 为 null，则返回 false。

3. 如果 values[0] 是 ASCII 不区分大小写的匹配 "nosniff"，则返回 true。

4. 返回 false。

3.5.1. 是否应因 nosniff 而阻止 response 到 request？

执行以下步骤：

1. 如果确定 nosniff并且response的标头列表为 false，则返回allowed。

2. 将mimeType设置为从response的提取 MIME 类型的结果。

3. 将destination设置为request的目标。

4. 如果destination是类似脚本，并且mimeType为失败或不是JavaScript MIME 类型，则返回blocked。

5. 如果destination是"style"并且mimeType失败或其本质不是"text/css"，则返回blocked。

6. 返回allowed。

只有请求目标是类似脚本或"style"的才被考虑，因为任何漏洞都与它们有关。此外，考虑到"image"与已部署的内容不兼容。

要执行跨源资源策略检查，给定源 origin，一个环境设置对象settingsObject，一个字符串destination，一个响应 response，以及一个可选的布尔值forNavigation，请执行以下步骤：

1. 如果未给定forNavigation，将其设置为 false。

2. 将embedderPolicy设置为settingsObject的策略容器的嵌入者策略。

3. 如果origin，"unsafe-none"，response和 forNavigation一起执行跨源资源策略内部检查返回blocked，则返回blocked。

   此步骤是必要的，因为我们不希望报告与下面的 Cross-Origin Embedder Policy 无关的违规行为。

4. 如果origin，embedderPolicy的仅报告值，response和forNavigation一起执行的跨源资源策略内部检查返回blocked，则排队一个跨源嵌入者策略 CORP 违规报告与response，settingsObject，destination和 true 一起执行。

5. 如果origin，embedderPolicy的值，response和forNavigation一起执行的跨源资源策略内部检查返回allowed，则返回allowed。

6. 排队一个跨源嵌入者策略 CORP 违规报告与response，settingsObject，destination和 false 一起执行。

7. 返回blocked。

只有 HTML 的导航算法在forNavigation设置为 true 时才会使用此检查，并且总是用于嵌套导航。否则，response要么是内部响应的不透明过滤响应或响应，将成为内部响应的不透明过滤响应。[HTML]

要执行跨源资源策略内部检查，给定源 origin，一个嵌入者策略值embedderPolicyValue，一个响应response，以及一个布尔值forNavigation，请执行以下步骤：

1. 如果forNavigation为 true，并且embedderPolicyValue为"unsafe-none"，则返回allowed。

2. 将policy设置为从response的获取`Cross-Origin-Resource-Policy`。

   这意味着`Cross-Origin-Resource-Policy: same-site, same-origin`在下方作为allowed出现，因为只要embedderPolicyValue是"unsafe-none"，它将永远不会匹配任何内容。两个或多个`Cross-Origin-Resource-Policy`标头将具有相同效果。

3. 如果policy既不是`same-origin`，`same-site`，也不是`cross-origin`，则将policy设置为 null。

4. 如果policy为 null，则根据embedderPolicyValue切换：

   "unsafe-none"

   什么都不做。

   "credentialless"

   在以下情况下，将policy设置为`same-origin`：

   • response的请求包含凭据为 true，或者
   • forNavigation为 true。

   "require-corp"

   将policy设置为`same-origin`。

5. 根据policy切换：

   null

   `cross-origin`

   返回allowed。

   `same-origin`

   如果origin与response的URL的源为同源，则返回allowed。

   否则，返回blocked。

   `same-site`

   如果以下所有条件都为真：

   • origin与response的URL的源schemelessly same site；

   • origin的scheme为"https"或 response的URL的scheme不为"https"

   则返回allowed。

   否则，返回blocked。

   `Cross-Origin-Resource-Policy: same-site` 不会考虑通过安全传输传递的响应与非安全请求源匹配，即使它们的 hosts 是相同站点。安全传输的响应只会匹配安全传输的发起者。

要排队一个跨源嵌入者策略 CORP 违规报告，给定一个响应response，一个环境设置对象settingsObject，一个字符串destination，以及一个布尔值reportOnly，请执行以下步骤：

1. 将endpoint设置为settingsObject的策略容器的嵌入者策略的仅报告的报告终端，如果reportOnly为 true，并且settingsObject的策略容器的嵌入者策略的报告终端。

2. 将serializedURL设置为通过序列化响应 URL 以进行报告与response执行的结果。

3. 将disposition设置为"reporting"，如果reportOnly为 true；否则为"enforce"。

4. 将body设置为一个包含以下属性的新对象：

   键	值
   "type"	"corp"
   "blockedURL"	serializedURL
   "destination"	destination
   "disposition"	disposition

5. 为settingsObject的全局对象生成并排队一个报告，给定"coep" 报告类型，endpoint和body。[REPORTING]

为了获取，给定一个请求 request，一个可选的算法processRequestBodyChunkLength，一个 可选的算法processRequestEndOfBody， 一个可选的算法processEarlyHintsResponse，一个可选的 算法processResponse， 一个可选的算法processResponseEndOfBody，一个可选的算法processResponseConsumeBody， 和一个可选的布尔值useParallelQueue（默认false），运行 以下步骤。如果给定，processRequestBodyChunkLength必须是一个接受表示传输字节数的整数的算法。如果给定，processRequestEndOfBody必须 是一个不接受参数的算法。如果给定，processEarlyHintsResponse必须是一个接受响应的算法。 如果给定，processResponse必须是一个接受响应的算法。如果 给定，processResponseEndOfBody必须是一个接受响应的算法。如果 给定，processResponseConsumeBody必须是一个接受响应和 null、失败或字节序列的算法。

用户代理可能会被要求挂起正在进行的获取。 用户代理可以接受或忽略挂起请求。挂起的获取可以恢复。如果正在进行的获取正在更新 请求的HTTP缓存中的响应，用户代理应 忽略挂起请求。

如果请求的缓存模式为“no-store”或响应中出现`Cache-Control: no-store`标头， 用户代理不会更新HTTP缓存中的条目。[HTTP-CACHING]

1. 断言： request的模式是“navigate”或 processEarlyHintsResponse为null。

   仅对导航验证早期提示（响应 的状态为103的响应）。

2. 令taskDestination为null。

3. 令crossOriginIsolatedCapability为false。

4. 如果request的客户端非null，则：

   1. 将taskDestination设置为request的客户端的全局对象。

   2. 将crossOriginIsolatedCapability设置为request的客户端的跨源隔离能力。

5. 如果useParallelQueue为true，则将taskDestination设置为启动新并行队列的结果。

6. 令timingInfo为新的获取时序信息，其开始时间和重定向后开始时间是给定 crossOriginIsolatedCapability的粗化共享当前时间，渲染阻塞设置为request的渲染阻塞。

7. 令fetchParams为新的获取参数，其请求为request，时序信息为timingInfo，处理请求体块长度为 processRequestBodyChunkLength，处理请求体结束为 processRequestEndOfBody，处理早期提示响应为 processEarlyHintsResponse，处理响应为processResponse，处理响应体消耗为 processResponseConsumeBody，处理响应体结束为 processResponseEndOfBody，任务目标为taskDestination，跨源隔离能力为 crossOriginIsolatedCapability。

8. 如果request的主体是字节序列，则将request的主体设置为request的主体作为主体。

9. 如果request的窗口为“client”，则将 request的窗口设置为request的客户端， 如果request的客户端的全局对象是Window对象； 否则为“no-window”。

10. 如果request的来源为“client”，则将 request的来源设置为request的客户端的来源。

11. 如果以下所有条件为真：

    • request的URL的scheme是HTTP(S) scheme

    • request的模式为“same-origin”、“cors”或“no-cors”

    • request的窗口为环境设置对象

    • request的方法为“GET”

    • request的unsafe-request 标志未设置或request的头列表为空

    则：

    1. 断言：request的来源与request的客户端的同源。

    2. 令onPreloadedResponseAvailable为一个给定响应response时运行以下步骤的算法：将fetchParams的预加载响应候选设置为 response。

    3. 令foundPreloadedResource为调用消耗预加载资源的结果，给定request的窗口、request的URL、request的目标、request的模式、request的凭证模式、request的完整性元数据， 和onPreloadedResponseAvailable。

    4. 如果foundPreloadedResource为true并且fetchParams的预加载响应候选为null，则将fetchParams的预加载响应候选设置为"pending"。

12. 如果request的策略容器为“client”，则：

    1. 如果request的客户端非null，则将request的策略容器设置为request的客户端的策略容器的克隆。[HTML]

    2. 否则，将request的策略容器设置为新的策略容器。

13. 如果request的头列表不包含“Accept”，则：

    1. 令value为“*/*”。

    2. 如果request的启动器为“prefetch”，则将value设置为文档“Accept”头的值。

    3. 否则，用户代理应将value设置为第一个匹配的语句（如果有），根据request的目标：

       “document”

       “frame”

       “iframe”

       文档“Accept”头的值

       “image”

       “image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5”

       “json”

       “application/json,*/*;q=0.5”

       “style”

       “text/css,*/*;q=0.1”

    4. 附加（“Accept”，value） 到request的头列表。

14. 如果request的头列表不包含“Accept-Language”，则用户代理应附加（“Accept-Language”，适当的头值）到request的头列表。

15. 如果request的内部优先级为null，则使用request的优先级、启动器、目标和渲染阻塞以实现定义的方式将request的内部优先级设置为实现定义的对象。

    实现定义的对象可以包含HTTP/2的流权重和 依赖性，在适用的传输层（包括HTTP/3）中用于优先级的HTTP的可扩展优先级方案中的优先级，以及用于优先级调度和处理HTTP/1获取的等效信息。[RFC9218]

16. 如果request是子资源请求，则：

    1. 令record为新的获取记录，其请求为request，控制器为fetchParams的控制器。

    2. 将record附加到request的客户端的获取组的获取记录列表中。

17. 给定fetchParams，运行主获取。

18. 返回fetchParams的控制器。

要执行主获取，给定获取参数fetchParams和一个可选的布尔值recursive（默认为false），执行以下步骤：

1. 令request为fetchParams的请求。

2. 令response为null。

3. 如果request的仅本地URL标志已设置且request的当前URL不是本地，则将response设置为网络错误。

4. 运行报告请求的内容安全策略违规。

5. 如果适用，将request升级为可能可信的URL。

6. 如果适用，将混合内容的request升级为可能可信的URL。

7. 如果应该由于不良端口阻止request，应该将request阻止为混合内容，或应该被内容安全策略阻止的request返回已阻止，则将response设置为网络错误。

8. 如果request的引用策略为空字符串，则将request的引用策略设置为request的策略容器的引用策略。

9. 如果request的引用不是“no-referrer”，则将request的引用设置为调用确定request的引用的结果。[REFERRER]

   如在引用策略中所述，用户代理可以为最终用户提供覆盖request的引用为“no-referrer”或暴露较少敏感信息的选项。

10. 如果所有以下条件为真，则将request的当前URL的方案设置为“https”：

    • request的当前URL的方案是“http”
    • request的当前URL的host是一个域
    • 匹配request的当前URL的host根据已知的HSTS主机域名匹配结果产生超级域匹配并包含includeSubDomains指令或一致匹配（有无includeSubDomains指令均可）[HSTS]；或为请求的DNS解析找到匹配的HTTPS RR，参见第9.5节和[SVCB]。[HSTS] [SVCB]

    由于所有DNS操作通常都是实现定义的，如何确定DNS解析是否包含HTTPS RR也是实现定义的。由于传统上DNS操作不会在尝试获取连接之前执行，用户代理可能需要提前执行DNS操作，查询本地DNS缓存，或在获取算法的后期等待并可能在发现需要更改request的当前URL的方案时撤销逻辑。

11. 如果recursive为false，则request的以下步骤并行执行。

12. 如果response为null，则将response设置为运行以下第一个匹配语句对应步骤的结果：

    fetchParams的预加载响应候选项不为null

    1. 等待fetchParams的预加载响应候选项不为“pending”。

    2. 断言：fetchParams的预加载响应候选项为响应。

    3. 返回fetchParams的预加载响应候选项。

    request的当前URL的来源与request的同源，且request的响应污染为“basic”

    request的当前URL的方案为“data”

    request的模式为“navigate”或“websocket”

    1. 将request的响应污染设置为“basic”。

    2. 返回运行方案获取给定fetchParams的结果。

    HTML分配从URL创建的任何文档和工作者，其方案为“data”一个唯一的不透明来源。仅可以从URL创建服务工作者，其方案为HTTP(S)方案。

    request的模式为“same-origin”

    返回网络错误。

    request的模式为“no-cors”

    1. 如果request的重定向模式不为“follow”，则返回网络错误。

    2. 将request的响应污染设置为“opaque”。

    3. 返回运行方案获取给定fetchParams的结果。

    request的当前URL的方案不是HTTP(S)方案

    返回网络错误。

    request的use-CORS-preflight标志已设置

    request的unsafe-request标志已设置，且request的方法不是CORS-safelisted方法或CORS-unsafe请求标头名称中request的标头列表不为空

    1. 将request的响应污染设置为“cors”。

    2. 将corsWithPreflightResponse设置为运行HTTP获取给定fetchParams和true的结果。

    3. 如果corsWithPreflightResponse为网络错误，则使用request运行清除缓存条目。

    4. 返回corsWithPreflightResponse。

    否则

    1. 将request的响应污染设置为“cors”。

    2. 返回运行HTTP获取给定fetchParams的结果。

13. 如果recursive为true，则返回response。

14. 如果response不是网络错误且response不是过滤响应，则：

    1. 如果request的响应污染为“cors”，则：

       1. 将headerNames设置为从提取的结果标头列表值给定 `Access-Control-Expose-Headers`和response的标头列表。

       2. 如果request的凭据模式不是“include”且headerNames包含`*`，则将response的CORS公开标头名称列表设置为response的标头名称中所有唯一的值response的标头列表。

       3. 否则，如果headerNames不为null或失败，则将response的CORS公开标头名称列表设置为headerNames。

          此时headerNames中的一个仍可以为`*`，但只会匹配一个标头，其名称为`*`。

    2. 根据request的响应污染设置response为以下过滤响应，将response作为其内部响应：

       “basic”

       基本过滤响应

       “cors”

       CORS过滤响应

       “opaque”

       不透明过滤响应

15. 令internalResponse为response，如果response是网络错误；否则response的内部响应。

16. 如果internalResponse的URL列表为空，则将其设置为request的URL列表的克隆。

    例如，响应的URL列表可以为空，例如当获取“about:”URL时。

17. 如果request有重定向污染的来源，则将internalResponse的跨来源重定向标志设置为true。

18. 如果request的计时允许失败标志未设置，则将internalResponse的计时允许通过标志设置。

19. 如果response不是网络错误，且以下任何返回已阻止：

    • 应该将internalResponse对request阻止为混合内容

    • 应该将internalResponse对request阻止为内容安全策略

    • 应该将internalResponse对request阻止为由于其MIME类型

    • 应该将internalResponse对request阻止为nosniff

    则将response和internalResponse设置为网络错误。

20. 如果response的类型为“opaque”，internalResponse的状态为206，internalResponse的range-requested标志已设置，且request的标头列表不包含`Range`，则将response和internalResponse设置为网络错误。

    传统上，即使未请求范围，API也接受范围响应。这可以防止先前范围请求的部分响应被提供给未发出范围请求的API。

    进一步详情

    上述步骤防止以下攻击：

    使用媒体元素请求跨源HTML资源的范围。虽然这是无效媒体，但可以在服务工作者中保留响应的克隆。这可以稍后用作脚本元素获取的响应。如果部分响应是有效的JavaScript（即使整个资源不是），执行它将泄露私人数据。

21. 如果response不是网络错误，且request的方法为`HEAD`或`CONNECT`，或internalResponse的状态为空体状态，则将internalResponse的主体设置为null并忽略向其进行的任何入队（如果有）。

    这标准化了对违反HTTP的服务器的错误处理。

22. 如果request的完整性元数据不为空字符串，则：

    1. 令processBodyError为此步骤：运行获取响应交接给定fetchParams和网络错误。

    2. 如果response的主体为null，则运行processBodyError并中止这些步骤。

    3. 令processBody给定bytes为这些步骤：

       1. 如果bytes不匹配request的完整性元数据，则运行processBodyError并中止这些步骤。[SRI]

       2. 将response的主体设置为bytes作为主体。

       3. 运行获取响应交接给定fetchParams和response。

    4. 完全读取response的主体给定processBody和processBodyError。

23. 否则，运行获取响应交接给定fetchParams和response。

给定获取响应交接，给定获取参数fetchParams和响应response，执行以下步骤：

1. 令timingInfo为fetchParams的计时信息。

2. 如果response不是网络错误，且fetchParams的请求的客户端是一个安全上下文，则将timingInfo的服务器计时标头设置为获取、解码和拆分`Server-Timing`的结果 来自response的内部响应的标头列表。

   使用_response_的内部响应是安全的，因为通过`Timing-Allow-Origin`标头保护暴露`Server-Timing`标头数据。

   用户代理也可以决定将`Server-Timing`标头暴露给非安全上下文的请求。

3. 令processResponseEndOfBody为以下步骤：

   1. 令unsafeEndTime为不安全共享当前时间。

   2. 如果fetchParams的请求的目的地为“document”，则将fetchParams的控制器的完整计时信息设置为fetchParams的计时信息。

   3. 将fetchParams的控制器的报告计时步骤设置为以下步骤，给定全局对象global：

      1. 如果fetchParams的请求的URL的方案不是HTTP(S)方案，则返回。

      2. 将timingInfo的结束时间设置为相对高分辨率时间，给定unsafeEndTime和global。

      3. 令cacheState为response的缓存状态。

      4. 令bodyInfo为response的主体信息。

      5. 如果response的计时允许通过标志未设置，则将timingInfo设置为创建一个不透明计时信息的结果，并将cacheState设置为空字符串。

         这包括response为网络错误的情况。

      6. 将responseStatus设置为0。

      7. 如果fetchParams的请求的模式不是“navigate”或response的跨来源重定向标志为false：

         1. 将responseStatus设置为response的状态。

         2. 令mimeType为从response的标头列表中提取的MIME类型的结果。

         3. 如果mimeType不是失败，则将bodyInfo的内容类型设置为最小化的受支持MIME类型的结果，给定mimeType。

      8. 如果fetchParams的请求的启动者类型不为null，则标记资源计时给定timingInfo，fetchParams的请求的URL，fetchParams的请求的启动者类型，global，cacheState，bodyInfo和responseStatus。

   4. 令processResponseEndOfBodyTask为以下步骤：

      1. 将fetchParams的请求的已完成标志设置为已完成。

      2. 如果fetchParams的处理响应结束不为null，则给定response运行fetchParams的处理响应结束。

      3. 如果fetchParams的请求的启动者类型不为null且fetchParams的请求的客户端的全局对象为fetchParams的任务目标，则给定fetchParams的控制器的报告计时步骤，运行fetchParams的请求的客户端的全局对象。

   5. 排队一个获取任务以运行processResponseEndOfBodyTask，以fetchParams的任务目标。

4. 如果fetchParams的处理响应不为null，则排队一个获取任务以运行fetchParams的处理响应给定response，以fetchParams的任务目标。

5. 令internalResponse为response，如果response是网络错误；否则response的内部响应。

6. 如果internalResponse的主体为null，则运行processResponseEndOfBody。

7. 否则：

   1. 令transformStream为一个新的TransformStream。

   2. 令identityTransformAlgorithm为一个算法，该算法给定chunk，入队chunk到transformStream。

   3. 设置transformStream，将transformAlgorithm设置为identityTransformAlgorithm，并将flushAlgorithm设置为processResponseEndOfBody。

   4. 将internalResponse的主体的流设置为internalResponse的主体的流的管道传输transformStream的结果。

   此TransformStream是为了在流到达终点时接收通知的目的，并且是一个身份转换流。

8. 如果fetchParams的处理响应消耗主体不为null，则：

   1. 令processBody给定nullOrBytes为此步骤：运行fetchParams的处理响应消耗主体给定response和nullOrBytes。

   2. 令processBodyError为此步骤：运行fetchParams的处理响应消耗主体给定response和失败。

   3. 如果internalResponse的主体为null，则排队一个获取任务以运行processBody给定null，以fetchParams的任务目标。

   4. 否则，完全读取internalResponse的主体给定processBody、processBodyError和fetchParams的任务目标。

要执行scheme fetch，给定fetch 参数 fetchParams：

1. 如果fetchParams被取消，则为fetchParams返回适当的网络错误。

2. 让request成为fetchParams的请求。

3. 根据request的当前URL的scheme切换并运行相关步骤：

   "about"

   如果request的当前URL的路径 是字符串 "blank"，则返回一个新的响应，其状态消息为`OK`，头列表为« (`Content-Type`, `text/html;charset=utf-8`) »，并且body是空字节序列作为body。

   类似 "about:config" 的URL 在导航过程中处理，并在fetch的上下文中导致网络错误。

   "blob"

   1. 让blobURLEntry成为request的当前URL的blob URL条目。

   2. 如果request的方法不是`GET`， blobURLEntry为null，或者blobURLEntry的对象不是一个Blob对象，则返回一个网络错误。[FILEAPI]

      `GET` 方法限制除了具有互操作性外没有其他有用的目的。

   3. 让blob成为blobURLEntry的对象。

   4. 让response成为一个新的响应。

   5. 让fullLength成为blob的大小。

   6. 让serializedFullLength成为fullLength，序列化并同构编码。

   7. 让type成为blob的类型。

   8. 如果request的头列表不包含 `Range`：

      1. 让bodyWithType成为安全提取blob的结果。

      2. 将response的状态消息设置为`OK`。

      3. 将response的body设置为bodyWithType的body。

      4. 将response的头列表设置为« (`Content-Length`, serializedFullLength), (`Content-Type`, type) »。

   9. 否则：

      1. 设置response的range-requested 标志。

      2. 让rangeHeader成为从request的头列表中获取`Range`的结果。

      3. 让rangeValue成为解析单个范围头值时给定rangeHeader和true的结果。

      4. 如果rangeValue失败，则返回一个网络错误。

      5. 让(rangeStart, rangeEnd)为rangeValue。

      6. 如果rangeStart为null：

         1. 将rangeStart设置为fullLength − rangeEnd。

         2. 将rangeEnd设置为rangeStart + rangeEnd − 1。

      7. 否则：

         1. 如果rangeStart大于或等于fullLength，则返回一个网络错误。

         2. 如果rangeEnd为null或rangeEnd大于或等于fullLength，则将rangeEnd设置为fullLength − 1。

      8. 让slicedBlob成为调用切片blob并给定blob、rangeStart、rangeEnd + 1和type的结果。

         一个范围头表示一个包含的字节范围，而切片blob算法输入范围则不然。要使用切片blob算法，我们必须增加rangeEnd。

      9. 让slicedBodyWithType成为安全提取slicedBlob的结果。

      10. 将response的body设置为slicedBodyWithType的body。

      11. 让serializedSlicedLength成为slicedBlob的大小，序列化并同构编码。

      12. 让contentRange成为调用构建内容范围并给定rangeStart、rangeEnd和fullLength的结果。

      13. 将response的状态设置为206。

      14. 将response的状态消息设置为`Partial Content`。

      15. 将response的头列表设置为« (`Content-Length`, serializedSlicedLength), (`Content-Type`, type)，(`Content-Range`， contentRange) »。

   10. 返回response。

   "data"

   1. 让dataURLStruct成为在request的当前URL上运行data:URL处理器的结果。

   2. 如果dataURLStruct失败，则返回一个网络错误。

   3. 让mimeType成为dataURLStruct的MIME类型，序列化。

   4. 返回一个新的响应，其状态消息为 `OK`，头列表为« (`Content-Type`, mimeType) »，并且body是dataURLStruct的body 作为body。

   "file"

   目前，虽然不幸的是，file: URL被留作读者的练习。

   如果有疑问，返回一个网络错误。

   HTTP(S) scheme

   返回运行HTTP fetch并给定fetchParams的结果。

4. 返回一个网络错误。

要执行HTTP fetch，给定fetch 参数 fetchParams和一个可选的布尔值makeCORSPreflight（默认值为false），执行以下步骤：

1. 让request成为fetchParams的request。

2. 让response和internalResponse为null。

3. 如果request的service-workers 模式为"all"，那么：

   1. 让requestForServiceWorker成为request的克隆。

   2. 如果requestForServiceWorker的body为非空， 那么：

      1. 让transformStream成为一个新的TransformStream。

      2. 让transformAlgorithm给定chunk时，执行以下步骤：

         1. 如果fetchParams被取消，则中止这些步骤。

         2. 如果chunk不是一个Uint8Array对象，则终止fetchParams的controller。

         3. 否则，在transformStream中入队chunk。用户代理可以将chunk分割成实现定义的实用大小，并且入队它们。用户代理也可以将chunk合并为一个实现定义的实用大小，并且入队它。

      3. 设置transformStream，其中transformAlgorithm设置为transformAlgorithm。

      4. 将requestForServiceWorker的body的stream设置为requestForServiceWorker的body的stream 通过transformStream传递的结果。

   3. 让serviceWorkerStartTime成为给定fetchParams的粗化的共享当前时间。

   4. 将response设置为调用handle fetch并给定requestForServiceWorker、fetchParams的controller和fetchParams的跨源隔离能力的结果。[HTML] [SW]

   5. 如果response非空，那么：

      1. 将fetchParams的时间信息的最终的service worker开始时间设置为serviceWorkerStartTime。

      2. 如果request的body为非空，则取消request的body，原因未定义。

      3. 如果response不是过滤后的响应，则将internalResponse设置为response；否则将internalResponse设置为response的内部响应。

      4. 如果以下条件之一为真：

         • response的类型是"error"

         • request的模式是"same-origin"，且response的类型是"cors"

         • request的模式不是"no-cors"，且response的类型是"opaque"

         • request的重定向模式不是"manual"，且response的类型是"opaqueredirect"
         • request的重定向模式不是"follow"，且response的URL列表有多个项目。

         则返回一个网络错误。

4. 如果response为null，那么：

   1. 如果makeCORSPreflight为true并且以下条件之一为真：

      • 对于request的method，没有方法缓存条目匹配，并且request的method既不是CORS-安全列出的方法，也不是request的use-CORS-preflight 标志已设置。

      • 在request的头列表中，在CORS-不安全请求头名称中至少有一个项没有使用request的头名称缓存条目匹配。

      那么：

      1. 让preflightResponse成为运行CORS-preflight fetch并给定request的结果。

      2. 如果preflightResponse是一个网络错误，则返回preflightResponse。

      此步骤检查CORS-preflight缓存，如果没有合适的条目，它会执行一个CORS-preflight fetch，如果成功，它将填充缓存。执行CORS-preflight fetch的目的是确保获取的资源熟悉CORS协议。缓存的目的是减少CORS-preflight fetch的数量。

   2. 如果request的重定向模式为"follow"，则将request的service-workers 模式设置为"none"。

      来自网络的重定向（与来自服务工作者的不同）不应暴露给服务工作者。

   3. 将response和internalResponse设置为运行HTTP-network-or-cache fetch并给定fetchParams的结果。

   4. 如果request的响应污染为"cors"，并且CORS检查对于request和response返回失败，那么返回一个网络错误。

      由于CORS检查不适用于其状态为304或407的响应，也不适用于来自服务工作者的响应，因此在此应用。

   5. 如果TAO检查对于request和response返回失败，那么设置request的时间允许失败标志。

5. 如果request的响应污染或response的类型为"opaque"，并且对于request的源、request的客户端、request的目的地和internalResponse的跨源资源策略检查返回阻止，那么返回一个网络错误。

   跨源资源策略检查适用于来自网络和服务工作者的响应。这与CORS检查不同，因为request的客户端和服务工作者可能有不同的嵌入者策略。

6. 如果internalResponse的状态是重定向状态：

   1. 如果internalResponse的状态不是303，request的body为非空，并且连接使用的是HTTP/2，则鼓励用户代理传输RST_STREAM帧。

      303被排除在外，因为某些社区赋予其特殊地位。

   2. 切换request的重定向模式：

      "error"

      1. 将response设置为一个网络错误。

      "manual"

      1. 如果request的模式为"navigate"，则将fetchParams的controller的下一步手动重定向步骤设置为运行HTTP-redirect fetch并给定fetchParams和response。

      2. 否则，将response设置为一个opaque-redirect过滤后的响应，其内部响应为internalResponse。

      "follow"

      1. 将response设置为运行HTTP-redirect fetch并给定fetchParams和response的结果。

7. 返回response。通常，internalResponse的body的stream在返回后仍在入队。

要执行HTTP-redirect fetch，给定fetch 参数 fetchParams和响应 response，请运行以下步骤：

1. 将request设为fetchParams的请求。

2. 如果response不是过滤的响应，则将internalResponse设为response；否则设为response的内部响应。

3. 将locationURL设为给定request的当前 URL的片段的internalResponse的位置 URL。

4. 如果locationURL为 null，则返回response。

5. 如果locationURL为失败，则返回一个网络错误。

6. 如果locationURL的scheme不是HTTP(S) scheme，则返回一个网络错误。

7. 如果request的重定向计数为20，则返回一个网络错误。

8. 将request的重定向计数增加1。

9. 如果request的模式为"cors"，locationURL 包含凭证，且request的源与locationURL的源不同源，则返回一个网络错误。

10. 如果request的响应污染为"cors"且locationURL 包含凭证，则返回一个网络错误。

    此步骤捕捉跨源资源重定向到同源URL的情况。

11. 如果internalResponse的状态不是303，request的body为非空，且request的body的source为 null，则返回一个网络错误。

12. 如果以下任一条件为真：

    • internalResponse的状态为301或302，且request的方法为`POST`

    • internalResponse的状态为303，且request的方法不是`GET`或`HEAD`

    则：

    1. 将request的方法设为`GET`，并将request的body设为 null。

    2. 对于headerName，即属于request-body-header 名称的每个值，删除headerName自request的header 列表。

13. 如果request的当前 URL的源与locationURL的源不同源，则对于属于CORS 非通配符请求头名称的每个headerName，删除自request的header 列表。

    即，当初始请求之后遇到不同的源时，`Authorization` 头会被删除。

14. 如果request的body为非空，则将request的body设为运行安全提取request的body的source的body的结果。

    request的body的source是否为 null 已经检查过。

15. 将timingInfo设为fetchParams的timing 信息。

16. 将timingInfo的重定向结束时间和重定向后开始时间设为给定fetchParams的粗化共享当前时间。

17. 如果timingInfo的重定向开始时间为0，则将timingInfo的重定向开始时间设为timingInfo的开始时间。

18. 追加locationURL到request的URL 列表。

19. 调用在重定向时设置request的referrer策略给request和internalResponse。[REFERRER]

20. 将recursive设为true。

21. 如果request的重定向模式为"manual"，则：

    1. 断言：request的模式为"navigate"。

    2. 将recursive设为false。

22. 返回运行main fetch给定fetchParams和recursive的结果。

    这必须调用main fetch以正确设置request的响应污染。

要执行HTTP-网络或缓存获取，给定fetch 参数 fetchParams，一个可选的布尔值isAuthenticationFetch（默认为 false），以及一个可选的布尔值isNewConnectionFetch（默认为 false），执行以下步骤：

某些实现可能支持部分内容的缓存，如 HTTP 缓存 中所述。然而，这在浏览器缓存中并不广泛支持。[HTTP-CACHING]

1. 将request设为fetchParams的请求。

2. 将httpFetchParams设为 null。

3. 将httpRequest设为 null。

4. 将response设为 null。

5. 将storedResponse设为 null。

6. 将httpCache设为 null。

7. 取消设置revalidatingFlag。

8. 运行以下步骤，但在中止时如果fetchParams为已取消：

   1. 如果request的window为"no-window"且request的重定向模式为"error"，则将httpFetchParams设为fetchParams，并将httpRequest设为request。

   2. 否则：

      1. 将httpRequest设为request的克隆。

         建议实现避免在request的body的流为 null 时对其进行分流，因为在这种情况下只需要一个 body。例如，当request的body的源为 null 时，重定向和身份验证将导致获取失败。

      2. 将httpFetchParams设为fetchParams的副本。

      3. 将httpFetchParams的请求设为httpRequest。

   3. 将includeCredentials设为 true，如果以下任一条件为 true：

      • request的凭证模式为"include"
      • request的凭证模式为"same-origin"，且request的响应污染为"basic"

      否则为 false。

   4. 如果Cross-Origin-Embedder-Policy 允许凭证返回 false，则将includeCredentials设为 false。

   5. 将contentLength设为httpRequest的body的长度，如果httpRequest的body非空；否则设为 null。

   6. 将contentLengthHeaderValue设为 null。

   7. 如果httpRequest的body为 null，且httpRequest的方法是`POST`或`PUT`，则将contentLengthHeaderValue设为`0`。

   8. 如果contentLength非空，则将contentLengthHeaderValue设为contentLength，序列化并等形编码。

   9. 如果contentLengthHeaderValue非空，则附加(`Content-Length`，contentLengthHeaderValue)到httpRequest的header 列表。

   10. 如果contentLength非空，且httpRequest的keepalive为 true，则：

       1. 将inflightKeepaliveBytes设为 0。

       2. 将group设为httpRequest的client的fetch 组。

       3. 将inflightRecords设为group中fetch 记录的集合，这些记录的请求的keepalive为 true，且done 标志未设置。

       4. 遍历inflightRecords中的每个fetchRecord：

          1. 将inflightRequest设为fetchRecord的请求。

          2. 将inflightKeepaliveBytes增加inflightRequest的body的长度。

       5. 如果contentLength和inflightKeepaliveBytes的总和超过 64 KiB，则返回网络错误。

       上述限制确保了允许在httpRequest包含 body 的情况下，request 的大小是有界的，不允许无限期保持活动。

   11. 如果httpRequest的referrer是一个URL，则：

       1. 将referrerValue设为httpRequest的referrer，序列化并等形编码。

       2. 附加(`Referer`，referrerValue)到httpRequest的header 列表。

   12. 附加一个请求`Origin`header给httpRequest。

   13. 附加 Fetch metadata headers给httpRequest。[FETCH-METADATA]

   14. 如果httpRequest的initiator为"prefetch"，则设置结构化字段值，给定(`Sec-Purpose`，tokenprefetch`)到httpRequest的header 列表。

   15. 如果httpRequest的header 列表中不包含`User-Agent`，则用户代理应附加(`User-Agent`，默认`User-Agent`值)到httpRequest的header 列表。

   16. 如果httpRequest的缓存模式为"default"且httpRequest的header 列表中包含`If-Modified-Since`， `If-None-Match`， `If-Unmodified-Since`， `If-Match`，或 `If-Range`，则将httpRequest的缓存模式设为"no-store"。

   17. 如果httpRequest的缓存模式为"no-cache"，httpRequest的防止 no-cache cache-control header 修改标志未设置，且httpRequest的header 列表中不包含`Cache-Control`，则附加(`Cache-Control`，`max-age=0`)到httpRequest的header 列表。

   18. 如果httpRequest的缓存模式为"no-store"或"reload"，则：

       1. 如果httpRequest的header 列表中不包含`Pragma`，则附加(`Pragma`，`no-cache`)到httpRequest的header 列表。

       2. 如果httpRequest的header 列表中不包含`Cache-Control`，则附加(`Cache-Control`，`no-cache`)到httpRequest的header 列表。

   19. 如果httpRequest的header 列表中包含`Range`，则附加(`Accept-Encoding`，`identity`)到httpRequest的header 列表。

       这可以避免在使用部分编码的处理内容编码时发生故障。

       此外，许多服务器错误地忽略了`Range`header，如果接受非身份编码。

   20. 根据 HTTP 修改httpRequest的header 列表。如果httpRequest的header 列表中包含该header的名称，则不要附加。

       最好能让这一点更具规范性。在这个阶段，headers如 `Accept-Encoding`， `Connection`， `DNT`，和 `Host`， 应该在必要时附加。

       `Accept`， `Accept-Charset`，和 `Accept-Language`不应在此时包含。

       `Accept`和`Accept-Language`已经包含 （除非使用fetch()，默认情况下不包含后者），`Accept-Charset`则是浪费字节。详见HTTP header 层次划分的更多细节。

   21. 如果includeCredentials为 true，则：

       1. 如果用户代理未配置为阻止httpRequest的 cookies（参见第7节的[COOKIES]），则：

          1. 将cookies设为使用用户代理的 cookie 存储和httpRequest的当前 URL运行"cookie-string"算法的结果（参见第5.4节的[COOKIES]）。

          2. 如果cookies不为空字符串，则附加(`Cookie`，cookies)到httpRequest的header 列表。

       2. 如果httpRequest的header 列表中不包含`Authorization`，则：

          1. 将authorizationValue设为 null。

          2. 如果存在httpRequest的身份验证条目，并且httpRequest的use-URL-credentials 标志未设置或httpRequest的当前 URL不包含凭证，则将authorizationValue设为身份验证条目。

          3. 否则，如果httpRequest的当前 URL确实包含凭证且isAuthenticationFetch为 true，则将authorizationValue设为httpRequest的当前 URL，转换为`Authorization`值。

          4. 如果authorizationValue非空，则附加(`Authorization`，authorizationValue)到httpRequest的header 列表。

   22. 如果存在代理身份验证条目，则根据需要使用它。

       这故意不依赖于httpRequest的凭证模式。

   23. 将httpCache设为确定 HTTP 缓存分区的结果，给定httpRequest。

   24. 如果httpCache为 null，则将httpRequest的缓存模式设为"no-store"。

   25. 如果httpRequest的缓存模式既不是"no-store"也不是"reload"，则：

       1. 将storedResponse设为从httpCache中选择响应的结果，可能需要验证，如HTTP 缓存的"从缓存构建响应"一章中所述，如果有的话。[HTTP-CACHING]

          根据 HTTP 的要求，这仍然会考虑`Vary`header。

       2. 如果storedResponse非空，则：

          1. 如果缓存模式为"default"，storedResponse为stale-while-revalidate 响应，且httpRequest的client非空，则：

             1. 将response设为storedResponse。

             2. 将response的缓存状态设为"local"。

             3. 将revalidateRequest设为request的克隆。

             4. 将revalidateRequest的缓存模式设为"no-cache"。

             5. 设置revalidateRequest的防止 no-cache cache-control header 修改标志。

             6. 将revalidateRequest的service-workers 模式设为"none"。

             7. 并行运行，给定新的fetch 参数，其中revalidateRequest为request。

                此获取仅用于更新httpCache的状态，响应将在下一次缓存访问前未使用。陈旧的响应将用作当前请求的响应。此获取是在 client 的上下文中发出的，因此如果它消失，请求将被终止。

          2. 否则：

             1. 如果storedResponse为陈旧响应，则设置revalidatingFlag。

             2. 如果revalidatingFlag已设置，且httpRequest的缓存模式既不是"force-cache"也不是"only-if-cached"，则：

                1. 如果storedResponse的header 列表中包含`ETag`，则附加(`If-None-Match`，`ETag`的值)到httpRequest的header 列表。

                2. 如果storedResponse的header 列表中包含`Last-Modified`，则附加(`If-Modified-Since`，`Last-Modified`的值)到httpRequest的header 列表。

                另见HTTP 缓存的"发送验证请求"一章。[HTTP-CACHING]

             3. 否则，将response设为storedResponse，并将response的缓存状态设为"local"。

9. 如果中止，则返回fetchParams的适当网络错误。

10. 如果response为 null，则：

    1. 如果httpRequest的缓存模式为"only-if-cached"，则返回网络错误。

    2. 将forwardResponse设为运行HTTP-网络获取的结果，给定httpFetchParams，includeCredentials，以及isNewConnectionFetch。

    3. 如果httpRequest的方法为不安全的且forwardResponse的状态在 200 到 399 范围内，则使httpCache中的适当存储的响应失效，如HTTP 缓存的"使存储的响应失效"一章中所述，并将storedResponse设为 null。[HTTP-CACHING]

    4. 如果revalidatingFlag已设置，且forwardResponse的状态为 304，则：

       1. 使用forwardResponse的header 列表更新storedResponse的header 列表，如HTTP 缓存的"验证时刷新存储的响应"一章中所述。[HTTP-CACHING]

          这还会更新缓存中的存储响应。

       2. 将response设为storedResponse。

       3. 将response的缓存状态设为"validated"。

    5. 如果response为 null，则：

       1. 将response设为forwardResponse。

       2. 将httpRequest和forwardResponse存储在httpCache中，如HTTP 缓存的"存储响应到缓存"一章中所述。[HTTP-CACHING]

          如果forwardResponse是网络错误，这实际上缓存了网络错误，有时称为"负缓存"。

          相关的body 信息与响应一起存储在缓存中。

11. 将response的URL 列表设为httpRequest的URL 列表的克隆。

12. 如果httpRequest的header 列表中包含`Range`，则设置response的range-requested 标志。

13. 将response的请求包含凭证设为includeCredentials。

14. 如果response的状态为 401，httpRequest的响应污染不为"cors"，includeCredentials为 true，且request的window为环境设置对象，则：

    1. 需要测试：多个`WWW-Authenticate` headers，缺失，解析问题。

    2. 如果request的body非空，则：

       1. 如果request的body的源为空，则返回网络错误。

       2. 将request的body设为body的结果，来自安全提取request的body的源。

    3. 如果request的use-URL-credentials 标志未设置或isAuthenticationFetch为 true，则：

       1. 如果fetchParams为已取消，则返回fetchParams的适当网络错误。

       2. 将username和password设为在request的window中提示最终用户输入的用户名和密码，分别。

       3. 设置用户名，给定request的当前 URL和username。

       4. 设置密码，给定request的当前 URL和password。

    4. 将response设为运行HTTP-网络或缓存获取的结果，给定fetchParams并为 true。

15. 如果response的状态为 407，则：

    1. 如果request的window为"no-window"，则返回网络错误。

    2. 需要测试：多个`Proxy-Authenticate` headers，缺失，解析问题。

    3. 如果fetchParams为已取消，则返回fetchParams的适当网络错误。

    4. 在request的window中适当提示最终用户，并将结果存储为代理身份验证条目。[HTTP]

       代理身份验证的剩余细节由 HTTP 定义。

    5. 将response设为运行HTTP-网络或缓存获取的结果，给定fetchParams。

16. 如果所有以下条件为 true：

    • response的状态为 421

    • isNewConnectionFetch为 false

    • request的body为空，或request的body非空且request的body的源非空

    则：

    1. 如果fetchParams为已取消，则返回fetchParams的适当网络错误。

    2. 将response设为运行HTTP-网络或缓存获取的结果，给定fetchParams，isAuthenticationFetch，并为 true。

17. 如果isAuthenticationFetch为 true，则为request创建一个身份验证条目和给定的域。

18. 返回response。通常，在返回后，response的body的stream仍在排队中。