URL

要百分比编码一个字节byte，返回由U+0025 (%)，后跟表示byte的两个ASCII大写十六进制数字组成的字符串。

要百分比解码一个字节序列input，请按以下步骤操作：

当input包含非ASCII字节时，使用除UTF-8解码，无BOM外的任何内容都可能不安全，不推荐使用。

1. 让output为一个空的字节序列。

2. 对于input中的每个字节byte：

   1. 如果byte不是0x25 (%)，则将byte附加到output。

   2. 否则，如果byte是0x25 (%)，并且input中byte之后的两个字节不在0x30 (0)到0x39 (9)，0x41 (A)到0x46 (F)，以及0x61 (a)到0x66 (f)的范围内，则将byte附加到output。

   3. 否则：

      1. 让bytePoint为input中byte之后的两个字节，解码后，解释为十六进制数。

      2. 将值为bytePoint的字节附加到output。

      3. 跳过input中的下两个字节。

3. 返回output。

要百分比解码一个标量值字符串input：

1. 让bytes为input的UTF-8编码。

2. 返回bytes的百分比解码结果。

通常，百分比编码会产生包含更多U+0025 (%)代码点的字符串，而百分比解码则会产生包含较少0x25 (%)字节的字节序列。

要进行编码后百分比编码，给定一个编码encoding，一个标量值字符串input，一个percentEncodeSet，以及一个可选的布尔值spaceAsPlus（默认值为false）：

1. 让encoder成为从encoding中获取编码器的结果。

2. 将input转换为I/O队列，并称之为inputQueue。

3. 让output为空字符串。

4. 让potentialError为0。

   这需要是一个非null的值，以启动后续的循环。

5. 当potentialError不为null时：

   1. 让encodeOutput为空的I/O队列。

   2. 将potentialError设置为运行编码或失败的结果，使用inputQueue、encoder和encodeOutput。

   3. 对于encodeOutput中的每个转换为字节序列的byte：

      1. 如果spaceAsPlus为true并且byte是0x20 (SP)，则将U+002B (+)附加到output并继续。

      2. 让isomorph成为一个代码点，其值为byte的值。

      3. 断言：percentEncodeSet包含所有非ASCII代码点。

      4. 如果isomorph不在percentEncodeSet中，则将isomorph附加到output。

      5. 否则，百分比编码byte并将结果附加到output。

   4. 如果potentialError不为null，则附加"%26%23"，后跟表示potentialError的以十进制表示的ASCII数字的最短序列，再附加"%3B"到output。

      当encoding不是UTF-8时，这可能发生。

6. 返回output。

对于percentEncodeSet参数的可能值中，只有两个会对U+0025 (%)进行编码，从而产生“可往返的数据”：组件百分比编码集和application/x-www-form-urlencoded百分比编码集。其他用于percentEncodeSet参数的值（如用于URL解析器的）将保持U+0025 (%)不变，因此首先需要对其进行UTF-8百分比编码以正确表示。

要UTF-8百分比编码一个标量值scalarValue，使用一个percentEncodeSet，返回运行编码后百分比编码的结果，使用UTF-8、scalarValue作为字符串，以及percentEncodeSet。

要UTF-8百分比编码一个标量值字符串input，使用一个percentEncodeSet，返回运行编码后百分比编码的结果，使用UTF-8、input，以及percentEncodeSet。

要获取 主机 host 的公共后缀，请运行以下步骤。这些步骤返回 null 或表示 host 的一部分域名，该部分包含在公共后缀列表中。[PSL]

1. 如果 host 不是域名，则返回 null。

2. 如果 host以“.”结尾，则让 trailingDot 为“.”；否则为空字符串。

3. 通过运行公共后缀列表算法，以 host 作为域名，确定 publicSuffix。[PSL]

4. 断言：publicSuffix 是不以“.”结尾的ASCII 字符串。

5. 返回 publicSuffix 和 trailingDot 连接的结果。

要获取 主机 host 的可注册域名，请运行以下步骤。这些步骤返回 null 或由 host 的公共后缀及其前面的域标签（如果有）构成的域名。

1. 如果 host 的公共后缀为 null 或 host 的公共后缀等于 host，则返回 null。

2. 如果 host以“.”结尾，则让 trailingDot 为“.”；否则为空字符串。

3. 通过运行公共后缀列表算法，以 host 作为域名，确定 registrableDomain。[PSL]

4. 断言：registrableDomain 是不以“.”结尾的ASCII 字符串。

5. 返回 registrableDomain 和 trailingDot 连接的结果。

域名到 ASCII算法，在给定字符串domain和布尔值beStrict的情况下，执行以下步骤：

1. 运行Unicode ToASCII，domain_name设为domain，UseSTD3ASCIIRules设为beStrict，CheckHyphens设为 false，CheckBidi设为 true，CheckJoiners设为 true，Transitional_Processing设为 false，VerifyDnsLength设为beStrict，并将结果赋值给result。[UTS46]

   如果beStrict为 false，domain是ASCII 字符串，并且严格分割 domain上的 U+002E (.) 不会产生任何项，且该项不会以ASCII 不区分大小写的"xn--"开头，那么该步骤等价于对domain进行ASCII 小写化。

2. 如果result是失败值，触发域名到 ASCII的验证错误，并返回失败。

3. 如果result是空字符串，触发域名到 ASCII的验证错误，并返回失败。

4. 返回result。

本文档和整个 Web 平台使用的是Unicode IDNA 兼容性处理，而不是 IDNA2008。例如，☕.example变成xn--53h.example，而不是失败。[UTS46][RFC5890]

域名到 Unicode算法，在给定域名domain和布尔值beStrict的情况下，执行以下步骤：

1. 运行Unicode ToUnicode，domain_name设为domain，CheckHyphens设为 false，CheckBidi设为 true，CheckJoiners设为 true，UseSTD3ASCIIRules设为beStrict，Transitional_Processing设为 false，并将结果赋值给result。[UTS46]

2. 标记域名到 Unicode的验证错误，然后返回result。

主机解析器接受一个标量值字符串 input，并带有可选的布尔值isOpaque（默认为 false），然后执行以下步骤。它们返回失败或主机。

1. 如果input以 U+005B ([) 开始，那么：

   1. 如果input不以 U+005D (]) 结束，IPv6 未关闭 验证错误，返回失败。

   2. 返回运行IPv6 解析的结果，移除其前导的 U+005B ([) 和尾随的 U+005D (])。

2. 如果isOpaque为 true，则返回运行不透明主机解析 input的结果。

3. 断言：input不是空字符串。

4. 运行无 BOM 的 UTF-8 解码，对input进行百分号解码的结果，得到domain。

   或者，可以使用无 BOM 的 UTF-8 解码或失败，加上早期返回失败的操作，因为域名到 ASCII在遇到 U+FFFD (�) 时会失败。

5. 运行域名到 ASCII算法，使用domain和 false，得到asciiDomain。

6. 如果asciiDomain为失败，则返回失败。

7. 如果asciiDomain包含禁止的域名代码点，域名无效代码点 验证错误，返回失败。

8. 如果asciiDomain以数字结尾，则返回运行IPv4 解析 asciiDomain的结果。

9. 返回asciiDomain。

结尾为数字检查器接受一个ASCII 字符串input，然后运行以下步骤。它们返回一个布尔值。

1. 让parts是input通过 U+002E (.) 严格分割的结果。

2. 如果parts中的最后一个项是空字符串，则：

   1. 如果parts的大小为1，则返回false。

   2. 移除parts的最后一项。

3. 让last是parts中的最后一个项。

4. 如果last非空且仅包含ASCII 数字，则返回 true。

   错误输入"09"将在稍后的IPv4 解析器中捕获。

5. 如果将last解析为IPv4 数字不返回失败，则返回 true。

   这相当于检查last是否为"0X"或"0x"，后跟零个或多个ASCII 十六进制数字。

6. 返回 false。

IPv4 解析器接受一个ASCII 字符串input，然后运行以下步骤。它们返回失败或一个IPv4 地址。

不要直接调用IPv4 解析器。而是检查主机解析器的返回值是否为IPv4 地址。

1. 让parts是input通过 U+002E (.) 严格分割的结果。

2. 如果parts的最后一项是空字符串，则：

   1. IPv4 空项 验证错误。

   2. 如果parts的大小大于1，则移除parts的最后一项。

3. 如果parts的大小大于4，IPv4 过多项 验证错误，返回失败。

4. 让numbers成为一个空的列表。

5. 对每个part的parts：

   1. 让result是解析part的结果。

   2. 如果result是失败，IPv4 非数字项 验证错误，返回失败。

   3. 如果result[1]为 true，IPv4 非十进制项 验证错误。

   4. 将result[0] 添加到numbers。

6. 如果numbers中的任何项大于255，IPv4 超出范围项 验证错误。

7. 如果numbers中除了最后一项之外的任何项大于255，则返回失败。

8. 如果numbers中的最后一项大于等于 256^{(5 − numbers的大小)}，则返回失败。

9. 让ipv4成为numbers中的最后一项。

10. 移除numbers中的最后一项。

11. 让counter为0。

12. 对每个numbers的n：

    1. 通过n × 256^{(3 − counter)}增加ipv4。

    2. 将counter加1。

13. 返回ipv4。

IPv4 数字解析器接受一个ASCII 字符串input，然后运行以下步骤。它们返回失败或一个元组，包含一个数字和一个布尔值。

1. 如果input是空字符串，则返回失败。

2. 让validationError为 false。

3. 让R为10。

4. 如果input包含至少两个代码点，并且前两个代码点是"0X"或"0x"，则：

   1. 将validationError设置为 true。

   2. 从input中移除前两个代码点。

   3. 将R设置为16。

5. 否则，如果input包含至少两个代码点，并且第一个代码点是 U+0030 (0)，则：

   1. 将validationError设置为 true。

   2. 从input中移除第一个代码点。

   3. 将R设置为8。

6. 如果input是空字符串，则返回(0, true)。

7. 如果input包含不是基数R的数字的代码点，则返回失败。

8. 让output为input表示的基数R记数法中的整数值，使用ASCII 十六进制数字表示0到15之间的数字。

9. 返回(output, validationError)。

IPv6 解析器接受一个标量值字符串input，然后运行以下步骤。它们返回失败或一个IPv6 地址。

IPv6 解析器理论上可以直接调用，但请先与本文件的编辑讨论。

1. 让address成为一个新的IPv6 地址，其IPv6 片段均为0。

2. 让pieceIndex为0。

3. 让compress为null。

4. 让pointer成为input的指针。

5. 如果c是 U+003A (:)，则：

   1. 如果剩余部分不以 U+003A (:) 开始，IPv6-无效压缩 验证错误，返回失败。

   2. 将pointer增加2。

   3. 将pieceIndex增加1，然后将compress设置为pieceIndex。

6. 当c不是EOF 代码点时：

   1. 如果pieceIndex为8，IPv6 片段过多 验证错误，返回失败。

   2. 如果c是 U+003A (:)，则：

      1. 如果compress非空，IPv6 多重压缩 验证错误，返回失败。

      2. 将pointer和pieceIndex分别增加1，将compress设置为pieceIndex，然后继续。

   3. 让value和length为0。

   4. 当length小于4并且c是ASCII 十六进制数字时，将value设置为value × 0x10 + c作为十六进制数解释，并将pointer和length分别增加1。

   5. 如果c是 U+002E (.)，则：

      1. 如果length为0，IPv4 在 IPv6 中无效代码点 验证错误，返回失败。

      2. 将pointer减少length。

      3. 如果pieceIndex大于6，IPv4 在 IPv6 中片段过多 验证错误，返回失败。

      4. 让numbersSeen为0。

      5. 当c不是EOF 代码点时：

         1. 让ipv4Piece为null。

         2. 如果numbersSeen大于0，则：

            1. 如果c是 U+002E (.) 并且numbersSeen小于4，则将pointer增加1。

            2. 否则，IPv4 在 IPv6 中无效代码点 验证错误，返回失败。

         3. 如果c不是ASCII 数字，IPv4 在 IPv6 中无效代码点 验证错误，返回失败。

         4. 当c是ASCII 数字时：

            1. 让number成为c作为十进制数解释。

            2. 如果ipv4Piece为 null，则将ipv4Piece设置为number。

               否则，如果ipv4Piece为0，IPv4 在 IPv6 中无效代码点 验证错误，返回失败。

               否则，将ipv4Piece设置为ipv4Piece × 10 + number。

            3. 如果ipv4Piece大于255，IPv4 在 IPv6 中超出范围的片段 验证错误，返回失败。

            4. 将pointer增加1。

         5. 将address[pieceIndex]设置为address[pieceIndex] × 0x100 + ipv4Piece。

         6. 将numbersSeen增加1。

         7. 如果numbersSeen为2或4，则将pieceIndex增加1。

      6. 如果numbersSeen不是4，IPv4 在 IPv6 中片段过少 验证错误，返回失败。

      7. 跳出。

   6. 否则，如果c是 U+003A (:)：

      1. 将pointer增加1。

      2. 如果c是EOF 代码点，IPv6 无效代码点 验证错误，返回失败。

   7. 否则，如果c不是EOF 代码点，IPv6 无效代码点 验证错误，返回失败。

   8. 将address[pieceIndex]设置为value。

   9. 将pieceIndex增加1。

7. 如果compress非空，则：

   1. 让swaps为pieceIndex − compress。

   2. 将pieceIndex设置为7。

   3. 当pieceIndex不为0且swaps大于0时，交换address[pieceIndex]与address[compress + swaps − 1]，然后将pieceIndex和swaps均减少1。

8. 否则，如果compress为空并且pieceIndex不为8，IPv6 片段过少 验证错误，返回失败。

9. 返回address。

不透明主机解析器接受一个标量值字符串input，然后运行以下步骤。它们返回失败或一个不透明主机。

1. 如果input包含禁止的主机代码点，主机无效代码点验证错误，返回失败。

2. 如果input包含一个不是URL代码点且不是U+0025 (%) 的代码点，无效URL单位验证错误。

3. 如果input包含一个U+0025 (%) 且其后的两个代码点不是ASCII十六进制数字，无效URL单位验证错误。

4. 返回使用C0控制百分比编码集对input运行UTF-8百分比编码的结果。

主机序列化器接受一个主机host，然后运行以下步骤。它们返回一个ASCII字符串。

1. 如果host是一个IPv4地址，返回对host运行IPv4序列化器的结果。

2. 否则，如果host是一个IPv6地址，返回U+005B ([)，后跟对host运行IPv6序列化器的结果，最后跟U+005D (])。

3. 否则，host是一个域名、不透明主机或空主机，返回host。

IPv4序列化器接受一个IPv4地址address，然后运行以下步骤。它们返回一个ASCII字符串。

1. 让output为空字符串。

2. 让n为address的值。

3. 对于每个在范围1到4（含）的i：

   1. 将n % 256，序列化的值，前置到output。

   2. 如果i不是4，则将U+002E (.)前置到output。

   3. 将n设置为floor(n / 256)。

4. 返回output。

IPv6序列化器接受一个IPv6地址address，然后运行以下步骤。它们返回一个ASCII字符串。

1. 让output为空字符串。

2. 让compress为指向address中第一段0最长序列的第一个IPv6片段的索引。

   在0:f:0:0:f:f:0:0中，它指向第二个0。

3. 如果address中没有比长度为1更长的0序列，则将compress设置为null。

4. 让ignore0为false。

5. 对于每个在范围0到7（含）的pieceIndex：

   1. 如果ignore0为true且address[pieceIndex]为0，则继续。

   2. 否则，如果ignore0为true，设置ignore0为false。

   3. 如果compress是pieceIndex，则：

      1. 让separator为"::"，如果pieceIndex为0，否则为U+003A (:)。

      2. 将separator追加到output。

      3. 设置ignore0为true，然后继续。

   4. 将address[pieceIndex]表示为最短的小写十六进制数，追加到output。

   5. 如果pieceIndex不是7，则将U+003A (:)追加到output。

6. 返回output。

该算法需要遵循[RFC5952]中的建议。

要确定主机A是否等于主机B，如果A是B，则返回true，否则返回false。

要缩短 url 的路径：

1. 断言：url 没有不透明路径。

2. 令 path 为 url 的 路径。

3. 如果 url 的 方案是 "file"，path 的大小为1，并且 path[0] 是规范化的 Windows 驱动器号，则返回。

4. 移除 path 的最后一项（如果有）。

URL 解析器 接受一个标量值字符串 input，带有可选的 null 或 基本 URL base（默认为 null）和可选的 编码 encoding（默认为 UTF-8），并运行以下步骤：

非网页浏览器的实现只需实现基本 URL 解析器。

本标准不包括浏览器地址栏中用户输入转换为URL 记录的过程。标准确实包含了 URL 渲染要求，因为它们涉及信任决策。

1. 让 url 为在 input 上使用 base 和 encoding 运行 基本 URL 解析器 的结果。

2. 如果 url 为失败，返回失败。

3. 如果 url 的 方案 不是 "blob"，返回 url。

4. 将 url 的 blob URL 条目 设置为 解析 blob URL url 的结果， 如果未返回失败，则为 null。

5. 返回 url。

基本 URL 解析器 接受一个标量值字符串 input，带有可选的 null 或基本 URL base（默认为 null），可选的 编码 encoding （默认为 UTF-8）， 可选的 URL url， 以及一个可选的状态覆盖 state override， 然后运行以下步骤：

1. 如果没有给出 url：

   1. 将 url 设置为一个新的 URL。

   2. 如果 input 包含任何前导或尾随的C0 控制或空格，则触发 无效的 URL 单元 验证错误。

   3. 从 input 中移除任何前导和尾随的 C0 控制或空格。

2. 如果 input 包含任何ASCII 制表符或换行符，则触发 无效的 URL 单元 验证错误。

3. 从 input 中移除所有 ASCII 制表符或换行符。

4. 将 state 设置为 state override（如果给定），否则为 scheme start state。

5. 将 encoding 设置为从 encoding 中获取输出编码的结果。

6. 将 buffer 设为空字符串。

7. 将 atSignSeen、insideBrackets 和 passwordTokenSeen 设置为 false。

8. 为 input 创建一个 指针 pointer。

9. 通过切换 state 来持续运行以下状态机。如果在运行之后 pointer 指向EOF 码点，进入下一步。否则，增加 pointer 的值 1，并继续状态机。

   方案开始状态

   1. 如果 c 是 ASCII 字母，将小写后的 c 追加到 buffer，并将 state 设置为 方案状态。

   2. 否则，如果没有给定 state override，将 state 设置为 无方案状态，并将 pointer 减少 1。

   3. 否则，返回失败。

      此失败仅供 Location 对象的 protocol setter 使用。

   方案状态

   1. 如果 c 是 ASCII 字母或数字，U+002B (+)、U+002D (-) 或 U+002E (.)，将小写后的 c 追加到 buffer。

   2. 否则，如果 c 是 U+003A (:)，那么：

      1. 如果给定了 state override，则：

         1. 如果 url 的 方案 是 特殊方案，并且 buffer 不是 特殊方案，则返回。

         2. 如果 url 的 方案 不是 特殊方案，并且 buffer 是 特殊方案，则返回。

         3. 如果 url 包含凭证 或者有非空的 端口，并且 buffer 是 "file"，则返回。

         4. 如果 url 的 方案 是 "file"，并且它的 主机 是一个 空主机，则返回。

      2. 将 url 的 方案 设置为 buffer。

      3. 如果给定了 state override，则：

         1. 如果 url 的 端口 是 url 的 方案 的 默认端口，则将 url 的 端口 设置为 null。

         2. 返回。

      4. 将 buffer 设为空字符串。

      5. 如果 url 的 方案 是 "file"，那么：

         1. 如果 剩余 不以 "//" 开头，触发 特殊方案缺少后续斜杠 验证错误。

         2. 将 state 设置为 文件状态。

      6. 否则，如果 url 是特殊的，base 非空，并且 base 的 方案 与 url 的方案相同：

         1. 断言：base 是特殊的（因此它没有 不透明路径）。

         2. 将 state 设置为 特殊相对或权限状态。

      7. 否则，如果 url 是特殊的，将 state 设置为 特殊权限斜杠状态。

      8. 否则，如果 剩余 以 U+002F (/) 开头，设置 state 为 路径或权限状态，并将 pointer 增加 1。

      9. 否则，将 url 的 路径 设置为空字符串，并将 state 设置为 不透明路径状态。

   3. 否则，如果没有给定 state override，将 buffer 设为空字符串，state 设为 无方案状态，并重新开始（从 input 中的第一个字符开始）。

   4. 否则，返回失败。

      此失败仅供 Location 对象的 protocol setter 使用。此外，方案状态中定义的非失败退出是专门为了定义 setter。

   无方案状态

   1. 如果 base 为空，或者 base 有一个 不透明路径，并且 c 不是 U+0023 (#)，触发 缺少方案的非相对URL 验证错误，返回失败。

   2. 否则，如果 base 有一个 不透明路径，并且 c 是 U+0023 (#)，将 url 的 方案 设置为 base 的 方案，将 url 的 路径 设置为 base 的 路径，将 url 的 查询 设置为 base 的 查询，将 url 的 片段 设置为空字符串，并 将 state 设置为 片段状态。

   3. 否则，如果 base 的 方案 不是 "file"，将 state 设置为 相对状态， 并将 pointer 减少 1。

   4. 否则，将 state 设置为 文件状态， 并将 pointer 减少 1。

   特殊相对或权限状态

   1. 如果 c 是 U+002F (/) 并且 剩余 以 U+002F (/) 开头，将 state 设置为 特殊权限忽略斜杠状态，并将 pointer 增加 1。

   2. 否则，触发 特殊方案缺少后续斜杠 验证错误，将 state 设置为 相对状态，并将 pointer 减少 1。

   路径或权限状态

   1. 如果 c 是 U+002F (/) ，则将 state 设置为 权限状态。

   2. 否则，将 state 设置为 路径状态， 并将 pointer 减少 1。

   相对状态

   1. 断言：base 的 方案 不是 "file"。

   2. 将 url 的 方案 设置为 base 的 方案。

   3. 如果 c 是 U+002F (/) ，则将 state 设置为 相对斜杠状态。

   4. 否则，如果 url 是特殊的， 并且 c 是 U+005C (\)，则触发 无效反斜杠 验证错误，将 state 设置为 相对斜杠状态。

   5. 否则：

      1. 将 url 的 用户名 设置为 base 的 用户名，url 的 密码 设置为 base 的 密码，将 url 的 主机 设置为 base 的 主机，将 url 的 端口 设置为 base 的 端口，将 url 的 路径 设置为 base 的 路径 的克隆，将 url 的 查询 设置为 base 的 查询。

      2. 如果 c 是 U+003F (?) ，将 url 的 查询 设置为空字符串， 并将 state 设置为 查询状态。

      3. 否则，如果 c 是 U+0023 (#)，将 url 的 片段 设置为空字符串， 并将 state 设置为 片段状态。

      4. 否则，如果 c 不是 EOF 代码点：

         1. 将 url 的 查询 设置为 null。

         2. 缩短 url 的 路径。

         3. 将 state 设置为 路径状态， 并将 pointer 减少 1。

   相对斜杠状态

   1. 如果 url 是特殊的，并且 c 是 U+002F (/) 或 U+005C (\)，则：

      1. 如果 c 是 U+005C (\)，触发 无效反斜杠 验证错误。

      2. 将 state 设置为 特殊权限忽略斜杠状态。

   2. 否则，如果 c 是 U+002F (/) ，则将 state 设置为 权限状态。

   3. 否则，将 url 的 用户名 设置为 base 的 用户名，url 的 密码 设置为 base 的 密码，url 的 主机 设置为 base 的 主机，url 的 端口 设置为 base 的 端口，将 state 设置为 路径状态，然后减少 pointer 1。

   特殊权限斜杠状态

   1. 如果 c 是 U+002F (/) 并且 剩余部分 以 U+002F (/) 开头，将 state 设置为 特殊权限忽略斜杠状态，并将 pointer 增加 1。

   2. 否则，触发 特殊方案缺少后续斜杠 验证错误，将 state 设置为 特殊权限忽略斜杠状态，并减少 pointer 1。

   特殊权限忽略斜杠状态

   1. 如果 c 既不是 U+002F (/) 也不是 U+005C (\)，则将 state 设置为 权限状态，并减少 pointer 1。

   2. 否则，触发 特殊方案缺少后续斜杠 验证错误。

   权限状态

   1. 如果 c 是 U+0040 (@)，则：

      1. 触发 无效凭证 验证错误。

      2. 如果 atSignSeen 为 true，则在 buffer 前面添加 "%40"。

      3. 将 atSignSeen 设置为 true。

      4. 对于 buffer 中的每个 codePoint：

         1. 如果 codePoint 是 U+003A (:) 且 passwordTokenSeen 为 false， 则将 passwordTokenSeen 设置为 true，并 继续。

         2. 将 codePoint 运行 UTF-8 百分号编码，使用 用户信息百分号编码集。

         3. 如果 passwordTokenSeen 为 true，则将 encodedCodePoints 添加到 url 的 密码。

         4. 否则，将 encodedCodePoints 添加到 url 的 用户名。

      5. 将 buffer 设置为空字符串。

   2. 否则，如果以下之一为 true：

      • c 是 EOF 代码点、U+002F (/)、U+003F (?) 或 U+0023 (#)

      • url 是特殊的 并且 c 是 U+005C (\)

      那么：

      1. 如果 atSignSeen 为 true 且 buffer 为空字符串，触发 缺少主机 验证错误，返回失败。

      2. 将 pointer 减少 buffer 的 代码点长度 + 1，将 buffer 设置为空字符串，并将 state 设置为 主机状态。

   3. 否则，将 c 添加到 buffer。

   主机状态

   主机名状态

   1. 如果提供了 state override 并且 url 的 scheme 是 "file"，则将 pointer 减少 1，并将 state 设置为 文件主机状态。

   2. 否则，如果 c 是 U+003A (:) 且 insideBrackets 为 false，则：

      1. 如果 buffer 为空字符串，主机缺失 验证错误，返回失败。

      2. 如果提供了 state override 且 state override 是 主机名状态，则返回。

      3. 将 host 设置为使用 url 非特殊 情况下对 buffer 进行的 主机解析 的结果。

      4. 如果 host 是失败，则返回失败。

      5. 将 url 的 主机 设置为 host，将 buffer 设置为空字符串， 并将 state 设置为 端口状态。

   3. 否则，如果以下任意条件为真：

      • c 是 EOF 代码点，U+002F (/)，U+003F (?) 或 U+0023 (#)

      • url 是特殊的 并且 c 是 U+005C (\)

      那么减少 pointer 1，然后：

      1. 如果 url 是特殊的 并且 buffer 为空字符串，主机缺失 验证错误，返回失败。

      2. 否则，如果提供了 state override，buffer 为空字符串，且 url 包含凭证 或 url 的 端口 不为 null，则返回。

      3. 将 host 设置为使用 url 非特殊 情况下对 buffer 进行的 主机解析 的结果。

      4. 如果 host 是失败，则返回失败。

      5. 将 url 的 主机 设置为 host，将 buffer 设置为空字符串， 并将 state 设置为 路径起始状态。

      6. 如果提供了 state override，则返回。

   4. 否则：

      1. 如果 c 是 U+005B ([)，则将 insideBrackets 设置为 true。

      2. 如果 c 是 U+005D (])，则将 insideBrackets 设置为 false。

      3. 将 c 添加到 buffer。

   端口状态

   1. 如果 c 是 ASCII 数字，则将 c 附加到 buffer。

   2. 否则，如果以下任一条件为真：

      • c 是 EOF 代码点，U+002F (/)，U+003F (?) 或 U+0023 (#)

      • url 是特殊的 并且 c 是 U+005C (\)

      • 提供了 state override

      那么：

      1. 如果 buffer 不为空字符串，则：

         1. 将 port 设置为由 buffer 在基数 10 中表示的数学整数值，使用 ASCII 数字 表示 0 到 9 的值。

         2. 如果 port 大于 2¹⁶ − 1，端口超出范围 验证错误，返回失败。

         3. 将 url 的 端口 设置为 null，如果 port 是 url 的 scheme 的 默认端口；否则将其设置为 port。

         4. 将 buffer 设置为空字符串。

      2. 如果提供了 state override，则返回。

      3. 将 state 设置为 路径起始状态，并将 pointer 减少 1。

   3. 否则，端口无效 验证错误，返回失败。

   文件状态

   1. 将 url 的 scheme 设置为 "file"。

   2. 将 url 的 主机 设置为空字符串。

   3. 如果 c 是 U+002F (/) 或 U+005C (\)，则：

      1. 如果 c 是 U+005C (\)，无效反斜杠 验证错误。

      2. 将 state 设置为 文件斜杠状态。

   4. 否则，如果 base 非空且 base 的 scheme 是 "file"：

      1. 将 url 的 主机 设置为 base 的 主机，url 的 路径 设置为 base 的 路径 的 克隆，并将 url 的 查询 设置为 base 的 查询。

      2. 如果 c 是 U+003F (?)，则将 url 的 查询 设置为空字符串，并将 state 设置为 查询状态。

      3. 否则，如果 c 是 U+0023 (#)，则将 url 的 片段 设置为空字符串，并将 state 设置为 片段状态。

      4. 否则，如果 c 不是 EOF 代码点，则：

         1. 将 url 的 查询 设置为 null。

         2. 如果从 pointer 到 input 末尾的 代码点子字符串 不以 Windows 驱动器字母 开头，则 缩短 url 的 路径。

         3. 否则：

            1. 文件无效 Windows 驱动器字母 验证错误。

            2. 将 url 的 路径 设置为 « »。

            这是一个（平台无关的）Windows 驱动器字母怪癖。

         4. 将 state 设置为 路径状态，并将 pointer 减少 1。

   5. 否则，将 state 设置为 路径状态，并将 pointer 减少 1。

   文件斜杠状态

   1. 如果 c 是 U+002F (/) 或 U+005C (\)，则：

      1. 如果 c 是 U+005C (\)，无效反斜杠 验证错误。

      2. 将 state 设置为 文件主机状态。

   2. 否则：

      1. 如果 base 非空且 base 的 scheme 是 "file"，则：

         1. 将 url 的 主机 设置为 base 的 主机。

         2. 如果从 pointer 到 input 末尾的 代码点子字符串 不以 Windows 驱动器字母 开头，且 base 的 路径[0] 是 标准化 Windows 驱动器字母，则 追加 base 的 路径[0] 到 url 的 路径。

            这是一个（平台无关的）Windows 驱动器字母怪癖。

      2. 将 state 设置为 路径状态，并将 pointer 减少 1。

   文件主机状态

   1. 如果 c 是 EOF 代码点、U+002F (/)、 U+005C (\)、U+003F (?) 或 U+0023 (#)，则将 pointer 减少 1，然后：

      1. 如果没有给出 state override 且 buffer 是 Windows 驱动器字母，则 文件无效的 Windows 驱动器字母主机 验证错误， 将 state 设置为 路径状态。

         这是一个（平台无关的）Windows 驱动器字母怪癖。buffer 在此处未重置，而是在 路径状态 中使用。

      2. 否则，如果 buffer 是空字符串，则：

         1. 将 url 的 主机 设置为空字符串。

         2. 如果给出了 state override，则返回。

         3. 将 state 设置为 路径开始状态。

      3. 否则，执行以下步骤：

         1. 让 host 成为通过 主机解析 buffer 与 url 非特殊。

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

         3. 如果 host 是 "localhost"，则将 host 设置为空字符串。

         4. 将 url 的 主机 设置为 host。

         5. 如果给出了 state override，则返回。

         6. 将 buffer 设置为空字符串，并将 state 设置为 路径开始状态。

   2. 否则，将 c 追加到 buffer。

   路径开始状态

   1. 如果 url 是特殊的，则：

      1. 如果 c 是 U+005C (\)，无效反斜杠 验证错误。

      2. 将 state 设置为 路径状态。

      3. 如果 c 既不是 U+002F (/) 也不是 U+005C (\)，则将 pointer 减少 1。

   2. 否则，如果未给出 state override 且 c 是 U+003F (?)，则将 url 的 查询 设置为空字符串，并将 state 设置为 查询状态。

   3. 否则，如果未给出 state override 且 c 是 U+0023 (#)，则将 url 的 片段 设置为空字符串，并将 state 设置为 片段状态。

   4. 否则，如果 c 不是 EOF 代码点：

      1. 将 state 设置为 路径状态。

      2. 如果 c 不是 U+002F (/) 则将 pointer 减少 1。

   5. 否则，如果给出了 state override 且 url 的 主机 为空，则 追加空字符串到 url 的 路径。

   路径状态

   1. 如果以下情况之一为真：

      • c 是 EOF 代码点 或 U+002F (/)

      • url 是特殊的 且 c 是 U+005C (\)

      • 没有给出 state override 且 c 是 U+003F (?) 或 U+0023 (#)

      那么：

      1. 如果 url 是特殊的 且 c 是 U+005C (\)，无效反斜杠 验证错误。

      2. 如果 buffer 是 双点 URL 路径段，那么：

         1. 缩短 url 的 路径。

         2. 如果 c 既不是 U+002F (/)， 也不是 url 特殊的 且 c 是 U+005C (\)，追加空字符串到 url 的 路径。

            这意味着对于输入 /usr/..，结果是 /，而不是没有路径。

      3. 否则，如果 buffer 是 单点 URL 路径段，且 c 既不是 U+002F (/)，也不是 url 特殊的 且 c 是 U+005C (\)，则 追加空字符串到 url 的 路径。

      4. 否则，如果 buffer 不是 单点 URL 路径段，那么：

         1. 如果 url 的 方案 是 "file"， url 的 路径 为空，且 buffer 是 Windows 驱动器字母，则将 buffer 的第二个代码点替换为 U+003A (:)。

            这是一个（平台无关的）Windows 驱动器字母怪癖。

         2. 追加 buffer 到 url 的 路径。

      5. 将 buffer 设置为空字符串。

      6. 如果 c 是 U+003F (?)，则将 url 的 查询 设置为空字符串，并将 state 设置为 查询状态。

      7. 如果 c 是 U+0023 (#)，则将 url 的 片段 设置为空字符串，并将 state 设置为 片段状态。

   2. 否则，执行以下步骤：

      1. 如果 c 不是 URL 代码点 且不是 U+0025 (%)，则 无效 URL 单元 验证错误。

      2. 如果 c 是 U+0025 (%) 且 剩余部分 不是以两个 ASCII 十六进制数字 开头，无效 URL 单元 验证错误。

      3. UTF-8 百分比编码 c 使用 路径百分比编码集 并将结果追加到 buffer。

   不透明路径状态

   1. 如果 c 是 U+003F (?)，则将 url 的 查询 设置为空字符串，并将 state 设置为 查询状态。

   2. 否则，如果 c 是 U+0023 (#)，则将 url 的 片段 设置为空字符串，并将 state 设置为 片段状态。

   3. 否则：

      1. 如果 c 不是 EOF 代码点，不是 URL 代码点，也不是 U+0025 (%)，则 无效 URL 单元 验证错误。

      2. 如果 c 是 U+0025 (%) 且 剩余部分 不是以两个 ASCII 十六进制数字 开头，无效 URL 单元 验证错误。

      3. 如果 c 不是 EOF 代码点，则 UTF-8 百分比编码 c 使用 C0 控制百分比编码集 并将结果追加到 url 的 路径。

   查询状态

   1. 如果 encoding 不是 UTF-8 且以下情况之一为真：

      • url 不是特殊的

      • url 的 方案 是 "ws" 或 "wss"

      则将 encoding 设置为 UTF-8。

   2. 如果以下情况之一为真：

      • 没有给出 state override 且 c 是 U+0023 (#)

      • c 是 EOF 代码点

      那么：

      1. 设 queryPercentEncodeSet 为 特殊查询百分比编码集 如果 url 是特殊的；否则为 查询百分比编码集。

      2. 百分比编码后编码，使用 encoding、 buffer 和 queryPercentEncodeSet，并将结果追加到 url 的 查询。

         由于有状态的 ISO-2022-JP 编码器，该操作不能逐代码点调用。

      3. 将 buffer 设置为空字符串。

      4. 如果 c 是 U+0023 (#)，则将 url 的 片段 设置为空字符串，并将 状态设置为 片段状态。

   3. 否则，如果 c 不是 EOF 代码点：

      1. 如果 c 不是 URL 代码点 且不是 U+0025 (%)，则 无效 URL 单元 验证错误。

      2. 如果 c 是 U+0025 (%) 且 剩余部分 不是以两个 ASCII 十六进制数字 开头，则 无效 URL 单元 验证错误。

      3. 将 c 追加到 buffer。

   片段状态

   1. 如果 c 不是 EOF 代码点，则：

      1. 如果 c 不是 URL 代码点 且不是 U+0025 (%)，则 无效 URL 单元 验证错误。

      2. 如果 c 是 U+0025 (%) 且 剩余部分 不是以两个 ASCII 十六进制数字 开头，则 无效 URL 单元 验证错误。

      3. UTF-8 百分比编码 c，使用 片段百分比编码集，并将结果追加到 url 的 片段。

10. 返回 url。

要给定 url 和 username 设置用户名，将 url 的 用户名 设置为运行 UTF-8 百分比编码 在 username 上，并使用 用户信息百分比编码集 的结果。

要给定 url 和 password 设置密码，将 url 的 密码 设置为运行 UTF-8 百分比编码 在 password 上，并使用 用户信息百分比编码集 的结果。

URL 序列化器 接收一个 URL url，以及一个可选的布尔值 exclude fragment（默认为 false），然后执行以下步骤。它们返回一个 ASCII 字符串。

1. 让 output 为 url 的 scheme 和 U+003A (:) 连接后的结果。

2. 如果 url 的 主机 非空：

   1. 将 "//" 添加到 output。

   2. 如果 url 包含凭据，则：

      1. 将 url 的 用户名 添加到 output。

      2. 如果 url 的 密码 不是空字符串，则将 U+003A (:) 和 url 的 密码 添加到 output。

      3. 将 U+0040 (@) 添加到 output。

   3. 将 url 的 主机，序列化后的结果，添加到 output。

   4. 如果 url 的 端口 非空，则添加 U+003A (:) 和 url 的 端口，序列化后的结果，到 output。

3. 如果 url 的 主机 为空，url 没有 不透明路径，url 的 路径的 大小 大于 1，且 url 的 路径[0] 是空字符串，则添加 U+002F (/) 和 U+002E (.) 到 output。

   这可以防止 web+demo:/.//not-a-host/ 或 web+demo:/path/..//not-a-host/ 在 解析然后 序列化后，最终变成 web+demo://not-a-host/（它们最终会变成 web+demo:/.//not-a-host/）。

4. 将 URL 路径序列化 url 的结果添加到 output。

5. 如果 url 的 查询 非空，则添加 U+003F (?), 后接 url 的 查询，到 output。

6. 如果 exclude fragment 为 false 且 url 的 片段 非空，则添加 U+0023 (#)，后接 url 的 片段，到 output。

7. 返回 output。

URL 路径序列化器 接收一个 URL url，然后执行以下步骤。它们返回一个 ASCII 字符串。

1. 如果 url 有一个 不透明路径，则返回 url 的 路径。

2. 让 output 为空字符串。

3. 对每个 segment 在 url 的 路径中，添加 U+002F (/) 和 segment 到 output。

4. 返回 output。

要确定 URL A 是否 等于 URL B，可选的布尔值 排除片段（默认为 false），请执行以下步骤：

1. 让 serializedA 为序列化 A 的结果，排除片段 设置为 排除片段。

2. 让 serializedB 为序列化 B 的结果，排除片段 设置为 排除片段。

3. 如果 serializedA 等于 serializedB，则返回 true；否则返回 false。

URL 的源是通过以下步骤，根据 url 的 方案 切换得出的：

"blob"

1. 如果 url 的 blob URL 项 非空，则返回 url 的 blob URL 项 的 环境 的 源。

2. 将 pathURL 设为解析 url 的 URL 路径序列化 结果的结果。

3. 如果 pathURL 失败，则返回一个新的不透明源。

4. 如果 pathURL 的 方案是 "http"、"https" 或 "file"，则返回 pathURL 的 源。

5. 返回一个新的不透明源。

blob:https://whatwg.org/d0360e2f-caee-469f-9a2f-87d5b0456f6f 的源是元组源 ("https"、"whatwg.org"、null、null)。

"ftp"

"http"

"https"

"ws"

"wss"

返回元组源(url 的 方案、url 的 主机、url 的 端口、null)。

"file"

尽管令人遗憾，这个问题留给读者自行解决。当不确定时，返回一个新的不透明源。

其他

返回一个新的不透明源。

这确实意味着这些URL无法与自身成为同源。

application/x-www-form-urlencoded 解析器 接受一个字节序列 input，然后运行以下步骤：

1. 将 sequences 设为通过 0x26 (&) 拆分 input 的结果。

2. 将 output 设为一个最初为空的名称-值元组的 列表，其中名称和值都存储为字符串。

3. 对每个 字节序列 bytes 在 sequences 中：

   1. 如果 bytes 是空字节序列，则 继续。

   2. 如果 bytes 包含 0x3D (=)，则将 name 设为从 bytes 开头到其第一个 0x3D (=)（不包括）的字节，value 设为（如果有）从第一个 0x3D (=) 之后到 bytes 结尾的字节。如果 0x3D (=) 是第一个字节，则 name 将为空字节序列。如果是最后一个字节，则 value 将为空字节序列。

   3. 否则，将 name 设为 bytes 的值，并将 value 设为空字节序列。

   4. 将 name 和 value 中的任何 0x2B (+) 替换为 0x20 (SP)。

   5. 将 nameString 和 valueString 设为分别对 name 和 value 进行无 BOM 的 UTF-8 解码并 百分比解码 的结果。

   6. 将 (nameString, valueString) 附加到 output。

4. 返回 output。

application/x-www-form-urlencoded 序列化器 接受一个名称-值元组的列表 tuples，可选地带有一个编码 encoding（默认 UTF-8），然后运行以下步骤。它们返回一个ASCII 字符串。

1. 将 encoding 设置为通过 获取输出编码 获得的结果。

2. 将 output 设为空字符串。

3. 对每个 tuple 在 tuples 中：

   1. 断言：tuple 的名称和 tuple 的值都是 标量值字符串。

   2. 将 name 设为运行 百分比编码后编码，使用 encoding、tuple 的名称、application/x-www-form-urlencoded 百分比编码集，并且为 true。

   3. 将 value 设为运行 百分比编码后编码，使用 encoding、tuple 的值、application/x-www-form-urlencoded 百分比编码集，并且为 true。

   4. 如果 output 不是空字符串，则附加 U+0026 (&) 到 output。

   5. 将 name，接着 U+003D (=)，接着 value，附加到 output。
4. 返回 output。

为了 可能从不透明路径中去除尾随空格，给定一个 URL 对象 url：

1. 如果 url 的 URL 没有 不透明路径，则返回。

2. 如果 url 的 URL 的 片段 不为 null，则返回。

3. 如果 url 的 URL 的 查询 不为 null，则返回。

4. 从 url 的 URL 的 路径 中移除所有尾随的 U+0020 空格 码点。

API URL 解析器 接受一个 标量值字符串 url 和一个可选的 null 或 标量值字符串 base（默认为 null），然后运行以下步骤：

1. 让 parsedBase 为 null。

2. 如果 base 不为 null：

   1. 将 parsedBase 设置为运行 基本 URL 解析器 在 base 上的结果。

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

3. 返回运行 基本 URL 解析器 在 url 和 parsedBase 上的结果。

为了 初始化 一个 URL 对象 url，给定一个 URL urlRecord：

1. 让 query 为 urlRecord 的 查询，如果它不是 null；否则为空字符串。

2. 将 url 的 URL 设置为 urlRecord。

3. 将 url 的 查询对象 设置为一个新的 URLSearchParams 对象。

4. 初始化 url 的 查询对象 使用 query。

5. 将 url 的 查询对象 的 URL 对象 设置为 url。

new URL(url, base) 构造函数的步骤如下：

1. 将 parsedURL 设置为运行 API URL 解析器 在 url 和 base 上的结果，如果有提供 base。

2. 如果 parsedURL 失败，则 抛出一个 TypeError。

3. 初始化 this 使用 parsedURL。

静态方法 parse(url, base) 的步骤如下：

1. 将 parsedURL 设置为运行 API URL 解析器 在 url 和 base 上的结果，如果有提供 base。

2. 如果 parsedURL 失败，则返回 null。

3. 让 url 成为一个新的 URL 对象。

4. 初始化 url，使用 parsedURL。

5. 返回 url。

静态方法 canParse(url, base) 的步骤如下：

1. 将 parsedURL 设置为运行 API URL 解析器 在 url 和 base 上的结果，如果有提供 base。

2. 如果 parsedURL 失败，则返回 false。

3. 返回 true。

步骤 href 获取器 和 toJSON() 方法的步骤是返回 序列化 this 的 URL。

步骤 href 设置器如下：

1. 让 parsedURL 成为在给定值上运行 基本 URL 解析器 的结果。

2. 如果 parsedURL 失败，则 抛出一个 TypeError。

3. 设置 this 的 URL 为 parsedURL。

4. 清空 this 的 查询对象 的 列表。

5. 让 query 成为 this 的 URL 的 查询。

6. 如果 query 非空，则将 this 的 查询对象 的 列表 设置为 解析 query 的结果。

步骤 origin 获取器 是返回 序列化 this 的 URL 的 来源。[HTML]

步骤 protocol 获取器 是返回 this 的 URL 的 协议，后跟 U+003A (:)。

步骤 protocol 设置器 是使用 基本 URL 解析 进行设置，给定值后跟 U+003A (:)，并将 this 的 URL 作为 url，以及 scheme start state 作为 状态覆盖。

步骤 username 获取器是返回 this 的 URL 的 用户名。

步骤 username 设置器如下：

1. 如果 this 的 URL 不能有用户名/密码/端口，则返回。

2. 给定 this 的 URL 和给定的值，设置用户名。

步骤 password 获取器是返回 this 的 URL 的 密码。

步骤 password 设置器如下：

1. 如果 this 的 URL 不能有用户名/密码/端口，则返回。

2. 给定 this 的 URL 和给定的值，设置密码。

步骤 host 获取器如下：

1. 让 url 成为 this 的 URL。

2. 如果 url 的 主机 为 null，则返回空字符串。

3. 如果 url 的 端口 为 null，则返回 url 的 主机，序列化后的结果。

4. 返回 url 的 主机，序列化后的结果，后跟 U+003A (:) 和 url 的 端口，序列化后的结果。

步骤 host 设置器如下：

1. 如果 this 的 URL 有 不透明路径，则返回。

2. 使用 基本 URL 解析器 对给定值进行解析，传递 this 的 URL 作为 url 和 主机状态 作为 状态覆盖。

如果设置器的给定值没有 端口，那么 this 的 URL 的 端口 将不会改变。这可能会让人感到意外，因为 host 获取器返回 URL-端口字符串，因此可能有人认为设置器会始终“重置”两者。

步骤 hostname 获取器如下：

1. 如果 this 的 URL 的 主机 为 null，则返回空字符串。

2. 返回 this 的 URL 的 主机，序列化后的结果。

步骤 hostname 设置器如下：

1. 如果 this 的 URL 有 不透明路径，则返回。

2. 使用 基本 URL 解析器 对给定值进行解析，传递 this 的 URL 作为 url 和 主机名状态 作为 状态覆盖。

步骤 port 获取器如下：

1. 如果 this 的 URL 的 端口 为 null，则返回空字符串。

2. 返回 this 的 URL 的 端口，序列化后的结果。

步骤 port 设置器如下：

1. 如果 this 的 URL 不能有用户名/密码/端口，则返回。

2. 如果给定的值是空字符串，则将 this 的 URL 的 端口 设置为 null。

3. 否则，使用 基本 URL 解析器 对给定值进行解析，传递 this 的 URL 作为 url 和 端口状态 作为 状态覆盖。

步骤 pathname 获取器是返回URL 路径序列化的结果 this 的 URL。

步骤 pathname 设置器如下：

1. 如果 this 的 URL 有 不透明路径，则返回。

2. 清空 this 的 URL 的 路径。

3. 使用 基本 URL 解析器 对给定值进行解析，传递 this 的 URL 作为 url 和 路径启动状态 作为 状态覆盖。

步骤 search 获取器如下：

1. 如果 this 的 URL 的 查询 是 null 或者为空字符串，则返回空字符串。

2. 返回 U+003F (?)，后跟 this 的 URL 的 查询。

步骤 search 设置器如下：

1. 让 url 成为 this 的 URL。

2. 如果给定值是空字符串：

   1. 将 url 的 查询 设置为 null。

   2. 清空 this 的 查询对象 的 列表。

   3. 使用 可能从不透明路径中去除尾随空格 来处理 this。

   4. 返回。

3. 将给定值中的单个前导 U+003F (?) 移除（如果存在），然后让 input 成为结果。

4. 将 url 的 查询 设置为空字符串。

5. 使用 基本 URL 解析器 对 input 进行解析，传递 url 作为 url 和 查询状态 作为 状态覆盖。

6. 将 this 的 查询对象 的 列表 设置为 解析 input 的结果。

该 search 设置器可能会从 this 的 URL 的 路径 中移除尾随 U+0020 空格 码位。这是为了确保对 URL 序列化器 输出运行 URL 解析器 后不会得到一个与 URL 不 相等 的结果。

步骤 searchParams 获取器如下：返回 this 的 查询对象。

步骤 hash 获取器如下：

1. 如果 this 的 URL 的 片段 是 null 或者为空字符串，则返回空字符串。

2. 返回 U+0023 (#)，后跟 this 的 URL 的 片段。

步骤 hash 设置器如下：

1. 如果给定值是空字符串：

   1. 将 this 的 URL 的 片段 设置为 null。

   2. 使用 可能从不透明路径中去除尾随空格 来处理 this。

   3. 返回。

2. 将给定值中的单个前导 U+0023 (#) 移除（如果存在），然后让 input 成为结果。

3. 将 this 的 URL 的 片段 设置为空字符串。

4. 使用 基本 URL 解析器 对 input 进行解析，传递 this 的 URL 作为 url 和 片段状态 作为 状态覆盖。

该 hash 设置器可能会像 search 设置器一样更改 this 的 URL 的 路径。

要 初始化 一个 URLSearchParams 对象 query 使用 init:

1. 如果 init 是一个 序列，则 对于每个 innerSequence 在 init 中：

   1. 如果 innerSequence 的 大小 不是 2，则 抛出 一个 TypeError。

   2. 追加 (innerSequence[0], innerSequence[1]) 到 query 的 列表。

2. 否则，如果 init 是一个 记录，则 对于每个 name → value 在 init 中，追加 (name, value) 到 query 的 列表。

3. 否则：

   1. 断言：init 是一个字符串。

   2. 将 query 的 列表 设置为 解析 init 的结果。

要 更新 一个 URLSearchParams 对象 query：

1. 如果 query 的 URL 对象 为 null，则返回。

2. 令 serializedQuery 为 序列化 query 的 列表 的结果。

3. 如果 serializedQuery 是空字符串，则将 serializedQuery 设置为 null。

4. 将 query 的 URL 对象 的 URL 的 查询 设置为 serializedQuery。

5. 如果 serializedQuery 是 null，则 可能去除不透明路径中的尾随空格，并使用 query 的 URL 对象。

new URLSearchParams(init) 构造函数步骤是：

1. 如果 init 是字符串并且以 U+003F (?) 开始，则删除 init 的第一个码点。

2. 初始化 this 使用 init。

size 获取步骤是返回 this 的 列表 的 大小。

append(name, value) 方法步骤是：

1. 追加 (name, value) 到 this 的 列表。

2. 更新 this。

delete(name, value) 方法步骤是：

1. 如果给定 value，则删除所有 元组，其名称是 name，且值是 value， 从 this 的 列表中。

2. 否则，删除所有 元组，其名称是 name，从 this 的 列表中。

3. 更新 this。

get(name) 方法步骤是返回 第一个名称为 name 的 this 的 列表中的值， 如果有此类元组；否则返回 null。

getAll(name) 方法步骤是返回 所有名称为 name 的 this 的 列表中的值， 按列表顺序；否则返回空序列。

has(name, value) 方法步骤是：

1. 如果给定 value 并且存在一个 元组， 其名称为 name，值为 value 在 this 的 列表中，则返回 true。

2. 如果未给定 value 并且存在一个 元组， 其名称为 name 在 this 的 列表中，则返回 true。

3. 返回 false。

set(name, value) 方法步骤是：

1. 如果 this 的 列表 包含 任何 元组，其名称为 name，则将第一个此类 元组 的值设置为 value 并 删除其他。

2. 否则，追加 (name, value) 到 this 的 列表。

3. 更新 this。

sort() 方法步骤是：

1. 对 this 的 列表 中的所有 元组 按其名称进行排序。排序必须按代码单元比较进行。对于具有相同名称的元组，其相对顺序必须保持不变。

2. 更新 this。