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 的 码点，包括在内。

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

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

2. 令 value 为从 list 中获取 name 的结果。

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

4. 令 result 为将 input_string 设置为 value 并将 header_type 设置为 type 后解析结构化字段的结果。

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

6. 返回 result。

获取结构化字段值 有意不区分标头不存在与其值无法解析为结构化字段值的情况。这确保了 Web 平台上的统一处理。

要在标头列表 list 中，根据给定的元组（标头名称 name， 结构化字段值 structuredValue）设置结构化字段值：

1. 令 serializedValue 为对 structuredValue 执行序列化结构化字段算法的结果。

2. 在 list 中设置 (name, serializedValue)。

结构化字段值被定义为 HTTP 可以（最终）以有趣且高效的方式序列化的对象。目前，Fetch 仅支持将标头值作为字节序列，这意味着这些对象只能通过序列化设置在标头列表中，并且只能通过解析从标头列表中获取它们。将来，它们作为对象的特性可能会被端到端保留。[RFC9651]

一个头列表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`是有效的范围。

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

要获取环境设置对象 environment 的 环境默认 `User-Agent` 值：

1. 令 userAgent 为 WebDriver BiDi 模拟的 User-Agent，对应 environment。

2. 如果 userAgent 非 null，则返回 userAgent， 同构编码。

3. 返回 默认 `User-Agent` 值。

要克隆一个主体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]

要计算 请求 request 的 重定向污染，执行以下步骤。返回值为 "same-origin"、"same-site" 或 "cross-site"。

1. 断言：request 的 origin 不为 "client"。

2. 令 lastURL 为 null。

3. 令 taint 为 "same-origin"。

4. 对于每个 url 属于 request 的 URL 列表：

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

   2. 如果 url 的 origin 与 lastURL 的 origin 不属于 同站点，且 request 的 origin 与 lastURL 的 origin 也不属于 同站点，则返回 "cross-site"。

   3. 如果 url 的 origin 与 lastURL 的 origin 不属于 同源，且 request 的 origin 与 lastURL 的 origin 也不属于 同源，则将 taint 设为 "same-site"。

   4. 将 lastURL 设为 url。

5. 返回 taint。

给定 请求 request， 序列化请求源 的步骤如下：

1. 断言： request 的 origin 不为 "client"。

2. 如果 request 的 重定向污染 不为 "same-origin"， 则返回 "null"。

3. 返回 request 的 origin， 序列化 后的结果。

给定一个请求 request，字节序列化请求源的步骤是返回使用 request 序列化请求源并进行同构编码的结果。

要克隆一个请求 request，请执行以下步骤：

1. 令 newRequest 为 request 的副本，但其主体除外。

2. 如果 request 的主体非 null，则将 newRequest 的主体设置为克隆 request 的主体的结果。

3. 返回 newRequest。

要向请求 request 添加范围标头，并带有整数 first 和可选整数 last，请执行以下步骤：

1. 断言：未给出 last，或者 first 小于或等于 last。

2. 令 rangeValue 为 `bytes=`。

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

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

5. 如果给出了 last，则序列化并同构编码它，并将结果追加到 rangeValue。

6. 将 (`Range`, rangeValue) 追加到 request 的标头列表。

范围标头表示一个包含性的字节范围。因此，first 为 0 且 last 为 500 的范围标头表示一个 501 字节的范围。

将多个响应组合成一个逻辑资源的特性在历史上是安全漏洞的来源。请为处理部分响应的特性寻求安全审查。

要序列化用于报告的响应 URL，给定一个响应 response，请执行以下步骤：

1. 断言：response 的URL 列表不为空。

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

   这不是 response 的URL，以避免泄露有关重定向目标的信息（另请参阅CSP 报告的类似注意事项）。[CSP]

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

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

5. 返回将排除片段设置为 true 的 url 的序列化结果。

要检查跨源嵌入器策略是否允许凭据，给定一个请求 request，请执行以下步骤：

1. 断言：request 的源不是 "client"。

2. 如果 request 的模式不是 "no-cors"，则返回 true。

3. 如果 request 的客户端为 null，则返回 true。

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

5. 如果 request 的 origin 与 request 的 当前 URL 的 origin 属于 同源，并且 request 的 重定向污染 不为 "same-origin"，则返回 true。

6. 返回 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 的方案是HTTP(S) 方案，则实现可能会为 HTTPS RR 执行 DNS 查询。[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. 返回允许。

要追加请求 `Cookie` 头，给定一个 请求 request：

1. 如果用户代理被配置为为 request 禁用 Cookie，则应返回。

2. 令 sameSite 为 确定 same-site 模式 的结果，参数为 request。

3. 令 isSecure 为 true，如果 request 的 当前 URL 的 scheme 为 "https"；否则为 false。

4. 令 httpOnlyAllowed 为 true。

   由于此步骤是由 fetch 触发的，而不是例如 document.cookie 的 getter 步骤，因此为 true。

5. 令 cookies 为运行 检索 Cookie 的结果，参数为 isSecure、request 的 当前 URL 的 host、request 的 当前 URL 的 path、httpOnlyAllowed 和 sameSite。

   Cookie 存储会返回一个有序的 Cookie 列表

6. 如果 cookies 为空，则返回。

7. 令 value 为运行 序列化 Cookie 的结果，参数为 cookies。

8. 追加 (`Cookie`, value) 到 request 的 头列表。

要解析并存储响应 `Set-Cookie` 头，给定一个 请求 request 和一个 响应 response：

1. 如果用户代理被配置为为 request 禁用 Cookie，则应返回。

2. 令 allowNonHostOnlyCookieForPublicSuffix 为 false。

3. 令 isSecure 为 true，如果 request 的 当前 URL 的 scheme 为 "https"；否则为 false。

4. 令 httpOnlyAllowed 为 true。

   由于此步骤是由 fetch 触发的，而不是例如 document.cookie 的 getter 步骤，因此为 true。

5. 令 sameSiteStrictOrLaxAllowed 为 true，如果 确定 same-site 模式 的结果为 "strict-or-less"，否则为 false。

6. 对于每个 header 属于 response 的 头列表：

   1. 如果 header 的 name 不是 `Set-Cookie`（不区分字节大小写匹配），则继续。

   2. 解析并存储一个 Cookie，参数为 header 的 value、isSecure、request 的 当前 URL 的 host、request 的 当前 URL 的 path、httpOnlyAllowed、allowNonHostOnlyCookieForPublicSuffix 和 sameSiteStrictOrLaxAllowed。

   3. 垃圾回收 Cookie，参数为 request 的 当前 URL 的 host。

   如其他地方所述，`Set-Cookie` 头不能合并，因此每个出现都要独立处理。其他头都不允许这样做。

要确定 same-site 模式，给定一个 请求 request：

1. 断言：request 的 method 为 "GET" 或 "POST"。

2. 如果 request 的 顶级导航发起者源 不为 null 且与 request 的 URL 的 origin 不属于 同站点，则返回 "unset-or-less"。

3. 如果 request 的 method 为 "GET" 且 request 的 destination 为 "document"，则返回 "lax-or-less"。

4. 如果 request 的 client 的 存在跨站点祖先 为 true，则返回 "unset-or-less"。

5. 如果 request 的 重定向污染 为 "cross-site"，则返回 "unset-or-less"。

6. 返回 "strict-or-less"。

为了获取一个序列化的 Cookie 默认路径，给定一个URL url：

1. 令cloneURL为url的一个副本。

2. 将cloneURL的路径设为 cloneURL的Cookie 默认路径。

3. 返回cloneURL的URL 路径序列化。

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

1. 断言：request 的源不是 "client"。

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

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

4. 否则，如果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.6.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、failure 或字节序列的算法。

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

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

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

   早期提示（响应，其状态为 103）的处理仅针对导航进行审查。

2. 令 taskDestination 为 null。

3. 令 crossOriginIsolatedCapability 为 false。

4. 给定 request，从客户端填充请求。

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

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

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

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

7. 令 timingInfo 为一个新的获取计时信息，其开始时间和重定向后开始时间是给定 crossOriginIsolatedCapability 的粗略共享当前时间，并且渲染阻塞设置为 request 的渲染阻塞。

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

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

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

    • request 的URL 的方案是一个HTTP(S) 方案

    • request 的模式是 "same-origin"、"cors" 或 "no-cors"

    • request 的客户端不为 null，并且 request 的客户端的全局对象是一个 Window 对象

    • request 的方法是 `GET`

    • 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"。

11. 如果 request 的标头列表不包含 `Accept`，则：

    1. 令 value 为 `*/*`。

    2. 如果 request 的发起者是 "prefetch"，则将 value 设置为文档 `Accept` 标头值。

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

       "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 的标头列表。

12. 如果 request 的标头列表不包含 `Accept-Language`，则用户代理应将 (`Accept-Language`, 一个适当的标头值) 追加到 request 的标头列表。

13. 如果 request 的内部优先级为 null，则以实现定义的方式使用 request 的优先级、发起者、目的地和渲染阻塞，将 request 的内部优先级设置为一个实现定义的对象。

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

14. 如果 request 是一个子资源请求，则：

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

    2. 追加 record 到 request 的 client 的 获取组的 获取记录中。

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

16. 返回 fetchParams 的控制器。

要从客户端填充请求，给定一个请求 request：

1. 如果 request 的用户提示可遍历对象是 "client"：

   1. 将 request 的用户提示可遍历对象设置为 "no-traversable"。

   2. 如果 request 的客户端非 null：

      1. 令 global 为 request 的客户端的全局对象。

      2. 如果 global 是一个 Window 对象并且 global 的可导航对象不为 null，则将 request 的用户提示可遍历对象设置为 global 的可导航对象的可遍历可导航对象。

2. 如果 request 的源是 "client"：

   1. 断言：request 的客户端非 null。

   2. 将 request 的源设置为 request 的客户端的源。

3. 如果 request 的策略容器是 "client"：

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

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

要执行主获取，给定获取参数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或 是否应由完整性策略阻止 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 的主机是一个域
    • request 的当前 URL 的主机的公共后缀不是 "localhost" 或 "localhost."
    • 根据已知 HSTS 主机域名匹配匹配 request 的当前 URL 的主机，结果为带有断言的 includeSubDomains 指令的超域匹配或一致匹配（带有或不带有断言的 includeSubDomains 指令）[HSTS]；或 请求的 DNS 解析根据第 9.5 节的[SVCB] 找到匹配的 HTTPS RR。[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. 返回运行覆盖抓取，参数为"scheme-fetch"和fetchParams的结果。

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

    request的模式为“same-origin”

    返回网络错误。

    request的模式为“no-cors”

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

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

    3. 返回运行覆盖抓取，参数为"scheme-fetch"和fetchParams的结果。

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

    返回网络错误。

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

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

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

    2. 令corsWithPreflightResponse为运行覆盖抓取，参数为"http-fetch"、fetchParams和true的结果。

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

    4. 返回corsWithPreflightResponse。

    否则

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

    2. 返回运行覆盖抓取，参数为"http-fetch"和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. 将 internalResponse 的 重定向污染 设置为 request 的 重定向污染。

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资源的范围。虽然这是无效媒体，但可以在Service Worker中保留响应的克隆。这可以稍后用作脚本元素获取的响应。如果部分响应是有效的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. 如果 fetchParams 的 request 的 destination 为 "document"，则将 fetchParams 的 controller 的 full timing info 设为 fetchParams 的 timing info。

4. 令processResponseEndOfBody为以下步骤：

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

   2. 将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 的 重定向污染 为 "same-origin"：

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

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

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

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

   3. 令processResponseEndOfBodyTask为以下步骤：

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

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

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

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

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

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

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

8. 否则：

   1. 令transformStream为一个新的TransformStream。

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

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

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

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

9. 如果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"或"http-fetch" type、抓取参数 fetchParams，以及可选布尔值 makeCORSPreflight（默认值为 false）：

1. 令 request 为 fetchParams 的 请求。

2. 令 response 为在 request 上执行 可能覆盖请求响应 的结果。

3. 如果 response 非空，则返回 response。

4. 根据 type 进行分支，并运行相应步骤：

   "scheme fetch"

   令 response 为运行 scheme 抓取，参数为 fetchParams 的结果。

   "HTTP fetch"

   令 response 为运行 HTTP 抓取，参数为 fetchParams 和 makeCORSPreflight 的结果。

5. 返回 response。

可能覆盖请求响应算法接收一个请求 request，返回一个响应或 null。其行为是 实现自定义，允许用户代理直接返回响应以干预 请求，或返回 null 以允许请求继续。

默认情况下，算法有如下简单实现：

1. 返回 null。

要Scheme抓取，给定一个 抓取参数 fetchParams：

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

2. 令 request 为 fetchParams 的请求。

3. 根据 request 的当前URL的scheme进行分支并执行相应步骤：

   "about"

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

   URL 如"about:config"会在 导航过程中处理，在抓取上下文中会导致网络错误。

   "blob"

   1. 令 blobURLEntry 为 request 的当前URL的 blob URL项。

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

      `GET`方法限制仅为实现一致性，不具备其他实际用途。

   3. 令 requestEnvironment 为 确定环境，参数为 request 的结果。

   4. 令 isTopLevelNavigation 为 true 如果 request 的 目标为"document"，否则为 false。

   5. 如果 isTopLevelNavigation 为 false 且 requestEnvironment 为 null， 则返回网络错误。

   6. 令 navigationOrEnvironment 为字符串"navigation"如果 isTopLevelNavigation为 true，否则为 requestEnvironment。

   7. 令 blob 为获取 blob 对象，参数为 blobURLEntry 和 navigationOrEnvironment 的结果。

   8. 如果 blob 不是 Blob 对象，则返回网络错误。

   9. 令 response 为新的响应。

   10. 令 fullLength 为 blob 的 size。

   11. 令 serializedFullLength 为 fullLength， 序列化并同构编码。

   12. 令 type 为 blob 的 type。

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

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

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

       3. 设置 response 的主体为 bodyWithType 的 body。

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

   14. 否则：

       1. 设置 response 的范围请求标志。

       2. 令 rangeHeader 为获取 `Range`自 request 的头列表。

       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 算法输入范围不包含终点。需要对 rangeEnd 增加 1。

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

       10. 设置 response 的主体为 slicedBodyWithType 的 body。

       11. 令 serializedSlicedLength 为 slicedBlob 的 size， 序列化并同构编码。

       12. 令 contentRange 为调用构建内容范围 参数为 rangeStart、rangeEnd、fullLength 的结果。

       13. 设置 response 的状态为 206。

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

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

   15. 返回 response。

   "data"

   1. 令 dataURLStruct 为运行 data:URL处理器， 参数为 request 的当前URL 的结果。

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

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

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

   "file"

   目前，遗憾的是，file: URL 暂留作读者练习。

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

   HTTP(S) scheme

   返回运行HTTP抓取，参数为 fetchParams 的结果。

4. 返回网络错误。

要确定环境，给定一个请求 request：

1. 如果 request 的保留客户端非 null，则返回 request 的保留客户端。

2. 如果 request 的客户端非 null，则返回 request 的客户端。

3. 返回 null。

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

1. 令request为fetchParams的请求。

2. 令response和internalResponse都为null。

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

   1. 令requestForServiceWorker为request的克隆。

   2. 如果requestForServiceWorker的主体非空，则：

      1. 令transformStream为新的TransformStream。

      2. 令transformAlgorithm，参数为chunk，步骤如下：

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

         2. 如果chunk不是Uint8Array 对象，则终止 fetchParams的 控制器。

         3. 否则，入队chunk到 transformStream。用户代理可以将chunk分割为实现自定义的实际大小并分别入队，也可以将多个chunk拼接成实现自定义的实际大小再入队。

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

      4. 设置requestForServiceWorker的主体的流为 requestForServiceWorker的主体的流 通过管道 transformStream后的结果。

   3. 令serviceWorkerStartTime为粗化共享当前时间，参数为fetchParams的跨域隔离能力。

   4. 设置response为调用处理抓取， 参数为requestForServiceWorker、fetchParams的 控制器和fetchParams的 跨域隔离能力。

   5. 如果response非空，则：

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

      2. 如果request的主体非空，则 取消 request的主体，参数为undefined。

      3. 如果response不是过滤响应，则设置internalResponse为response；否则设置为 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的方法对应的方法缓存项，且request的 方法不是CORS安全方法或 request的使用CORS预检标志被设置。

      • 在request的头列表中的CORS不安全请求头名 有至少一项，没有与其对应的头名缓存项。

      则：

      1. 令preflightResponse为运行CORS预检抓取 参数为request的结果。

      2. 如果preflightResponse为网络错误， 则返回preflightResponse。

      此步骤会检查CORS预检缓存，如果没有合适的缓存项则执行CORS预检抓取，并且如果成功则会填充缓存。CORS预检抓取的目的是确保抓取的资源 熟悉CORS协议。缓存的目的是最小化 CORS预检抓取的数量。

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

      来自网络的重定向（而不是来自service worker）不能暴露给service worker。

   3. 设置response和internalResponse为运行 HTTP网络或缓存抓取 参数为fetchParams的结果。

   4. 如果request的响应污染为 "cors"且对request和response执行CORS检查返回失败，则 返回网络错误。

      由于CORS检查不适用于响应状态为304或407，或来自service worker的响应，这里才做检查。

   5. 如果对request和response的TAO检查返回失败， 则设置request的时序许可失败标志。

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

   跨域资源策略检查会对来自网络和service worker的响应进行，这与CORS检查不同，因为request的客户端和service worker可以有不同的嵌入策略。

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

   1. 如果internalResponse的状态不是303，且request的 主体非空，且连接使用HTTP/2，则用户代理可以，甚至鼓励，发送RST_STREAM帧。

      303被排除，因为某些社区赋予其特殊含义。

   2. 根据request的 重定向模式分支：

      "error"

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

      "manual"

      1. 如果request的模式为 "navigate"，则设置 fetchParams的控制器的 下一个手动重定向步骤为运行HTTP重定向抓取， 参数为fetchParams和response。

      2. 否则，将response设置为一个不透明重定向过滤响应 其内部响应为internalResponse。

      "follow"

      1. 将response设置为运行HTTP重定向抓取 参数为 fetchParams和response的结果。

7. 返回response。通常internalResponse的 主体的流在返回后仍在入队。

要HTTP-重定向抓取，给定一个 fetch params fetchParams和一个response response，执行以下步骤：

1. 令 request 为 fetchParams 的 request。

2. 令 internalResponse 为 response（如果 response 不是filtered response）；否则令其为 response 的 internal response。

3. 令 locationURL 为 internalResponse 的 location URL，其基于 request 的 current URL 的 fragment。

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

5. 如果 locationURL 为 failure，则返回一个network error。

6. 如果 locationURL 的 scheme 不是 HTTP(S) scheme，则返回一个network error。

7. 如果 request 的 redirect count 为 20，则返回一个network error。

8. 将 request 的 redirect count 增加 1。

9. 如果 request 的 mode 为 "cors"，且 locationURL includes credentials，并且 request 的 origin 与 locationURL 的 origin 不是 same origin，则返回一个network error。

10. 如果 request 的 response tainting 为 "cors" 并且 locationURL includes credentials，则返回一个network error。

    此项用于捕获跨源资源重定向到同源 URL 的情况。

11. 如果 internalResponse 的 status 不是 303，且 request 的 body 非空，并且 request 的 body 的 source 为 null，则返回一个network error。

12. 如果下列任一为真：

    • internalResponse 的 status 为 301 或 302 且 request 的 method 为 `POST`。

    • internalResponse 的 status 为 303 且 request 的 method 既不是 `GET` 也不是 `HEAD`。

    则：

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

    2. 对每个 headerName（遍历 request-body-header name），从 request 的 header list 中 删除 该 headerName。

13. 如果 request 的 current URL 的 origin 与 locationURL 的 origin 不是 same origin，则对每个 headerName（遍历 CORS non-wildcard request-header name），从 request 的 header list 中 删除 该 headerName。

    即：一旦在初始请求之后看到另一个 origin，就会移除 `Authorization` 头。

14. 如果 request 的 body 非空，则将 request 的 body 设为对 request 的 safely extracting request 的 body 的 source 的结果的 body。

    已经检查过 request 的 body 的 source 的空性。

15. 令 timingInfo 为 fetchParams 的 timing info。

16. 将 timingInfo 的 redirect end time 和 post-redirect start time 设为 基于 fetchParams 的 coarsened shared current time。

17. 如果 timingInfo 的 redirect start time 为 0，则将 timingInfo 的 redirect start time 设为 timingInfo 的 start time。

18. Append locationURL 到 request 的 URL list。

19. 对 request 和 internalResponse 调用 set request 的 referrer policy on redirect。[REFERRER]

20. 令 recursive 为 true。

21. 如果 request 的 redirect mode 为 "manual"，则：

    1. Assert：request 的 mode 必须为 "navigate"。

    2. 将 recursive 设为 false。

22. 返回运行 main fetch，参数为 fetchParams 和 recursive 的结果。

    这必须调用 main fetch，以确保 request 的 response tainting 正确。