URL 模式

运行 initialize，给定 this，input，baseURL，以及 options。

运行 initialize，给定 this，input，null，以及 options。

将 this 的 关联的URL模式 设置为根据 input，baseURL 和 options 生成的结果。

返回 this 的 关联的URL模式 的 协议组件 的 模式字符串。

返回 this 的 关联的URL模式 的 用户名组件 的 模式字符串。

返回 this 的 关联的URL模式 的 密码组件 的 模式字符串。

返回 this 的 关联的URL模式 的 主机名组件 的 模式字符串。

返回 this 的 关联的URL模式 的 端口组件 的 模式字符串。

返回 this 的 关联的URL模式 的 路径名组件 的 模式字符串。

返回 this 的 关联的URL模式 的 搜索组件 的 模式字符串。

返回 this 的 关联的URL模式 的 哈希组件 的 模式字符串。

如果 this 的 关联的URL模式 的 正则表达式组 存在，则返回 true。

返回 false。

让 result 为 匹配的结果，给定 this 的 关联的URL模式，input，以及（如果有）baseURL。

如果 result 为 null，返回 false。

返回 true。

返回 匹配的结果，给定 this 的 关联的URL模式，input，以及（如果有）baseURL。

将 init 设为 null。

如果 input 是一个 标量值字符串，则：

1. 将 init 设置为运行 解析构造字符串 后的结果，并给定 input。

2. 如果 baseURL 为 null 且 init["protocol"] 不 存在，则抛出一个 TypeError。

3. 如果 baseURL 不为 null，则 设置 init["baseURL"] 为 baseURL。

否则：

1. 断言：input 是 URLPatternInit。

2. 如果 baseURL 不为 null，则抛出一个 TypeError。

3. 将 init 设置为 input。

将 processedInit 设置为 处理 URLPatternInit 的结果，并给定 init、"pattern"、null、null、null、null、null、null、null 和 null。

对每个 « "protocol", "username", "password", "hostname", "port", "pathname", "search", "hash" » 的 componentName：

1. 如果 processedInit[componentName] 不 存在，则 设置 processedInit[componentName] 为 "*"。

如果 processedInit["protocol"] 是一个 特殊方案，且 processedInit["port"] 是一个表示其对应 默认端口 的字符串，使用 ASCII 数字 表示，则将 processedInit["port"] 设置为空字符串。

将 urlPattern 设为一个新的 URL 模式。

将 urlPattern 的 协议组件 设置为 编译组件 的结果，给定 processedInit["protocol"]，规范化协议 和 默认选项。

将 urlPattern 的 用户名组件 设置为 编译组件 的结果，给定 processedInit["username"]，规范化用户名 和 默认选项。

将 urlPattern 的 密码组件 设置为 编译组件 的结果，给定 processedInit["password"]，规范化密码 和 默认选项。

如果运行 主机名模式是 IPv6 地址 的结果，给定 processedInit["hostname"] 为真，则将 urlPattern 的 主机名组件 设置为 编译组件 的结果，给定 processedInit["hostname"]，规范化 IPv6 主机名 和 主机名选项。

否则，将 urlPattern 的 主机名组件 设置为 编译组件 的结果，给定 processedInit["hostname"]，规范化主机名 和 主机名选项。

将 urlPattern 的 端口组件 设置为 编译组件 的结果，给定 processedInit["port"]，规范化端口 和 默认选项。

将 compileOptions 设置为 默认选项 的副本，忽略大小写 属性设置为 options["ignoreCase"]。

如果运行 协议组件匹配特殊方案 的结果为真，给定 urlPattern 的 协议组件，则：

1. 将 pathCompileOptions 设置为 路径名选项 的副本，忽略大小写 属性设置为 options["ignoreCase"]。

2. 将 urlPattern 的 路径名组件 设置为 编译组件 的结果，给定 processedInit["pathname"]，规范化路径名 和 pathCompileOptions。

否则，将 urlPattern 的 路径名组件 设置为 编译组件 的结果，给定 processedInit["pathname"]，规范化不透明路径名 和 compileOptions。

将 urlPattern 的 查询组件 设置为 编译组件 的结果，给定 processedInit["search"]，规范化查询 和 compileOptions。

将 urlPattern 的 哈希组件 设置为 编译组件 的结果，给定 processedInit["hash"]，规范化哈希 和 compileOptions。

返回 urlPattern。

将 protocol 设为空字符串。

将 username 设为空字符串。

将 password 设为空字符串。

将 hostname 设为空字符串。

将 port 设为空字符串。

将 pathname 设为空字符串。

将 search 设为空字符串。

将 hash 设为空字符串。

将 inputs 设为空 列表。

将 input 添加到 inputs 中。

如果 input 是 URLPatternInit，则：

1. 如果提供了 baseURLString，则抛出 TypeError。

2. 将 applyResult 设为 处理 URLPatternInit 的结果，给定 input、"url"、protocol、username、password、hostname、port、pathname、search 和 hash。如果抛出异常，捕获并返回 null。

3. 将 protocol 设为 applyResult["protocol"]。

4. 将 username 设为 applyResult["username"]。

5. 将 password 设为 applyResult["password"]。

6. 将 hostname 设为 applyResult["hostname"]。

7. 将 port 设为 applyResult["port"]。

8. 将 pathname 设为 applyResult["pathname"]。

9. 将 search 设为 applyResult["search"]。

10. 将 hash 设为 applyResult["hash"]。

否则：

1. 将 url 设为 input。

2. 如果 input 是 USVString：

   1. 将 baseURL 设为 null。

   2. 如果提供了 baseURLString，则：

      1. 将 baseURL 设置为 解析 baseURLString 的结果。

      2. 如果 baseURL 解析失败，返回 null。

      3. 将 baseURLString 添加到 inputs 中。

   3. 将 url 设置为 解析 input 的结果，给定 baseURL。

   4. 如果 url 解析失败，返回 null。

3. 断言：url 是一个 URL。

4. 将 protocol 设为 url 的 scheme。

5. 将 username 设为 url 的 username。

6. 将 password 设为 url 的 password。

7. 将 hostname 设为 url 的 host，序列化，或为空字符串如果值为 null。

8. 将 port 设为 url 的 port，序列化，或为空字符串如果值为 null。

9. 将 pathname 设置为 URL 路径序列化 url 的结果。

10. 将 search 设为 url 的 query 或为空字符串如果值为 null。

11. 将 hash 设为 url 的 fragment 或为空字符串如果值为 null。

将 protocolExecResult 设为 RegExpBuiltinExec(urlPattern 的 协议组件 的 正则表达式，protocol）。

将 usernameExecResult 设为 RegExpBuiltinExec(urlPattern 的 用户名组件 的 正则表达式，username）。

将 passwordExecResult 设为 RegExpBuiltinExec(urlPattern 的 密码组件 的 正则表达式，password）。

将 hostnameExecResult 设为 RegExpBuiltinExec(urlPattern 的 主机名组件 的 正则表达式，hostname）。

将 portExecResult 设为 RegExpBuiltinExec(urlPattern 的 端口组件 的 正则表达式，port）。

将 pathnameExecResult 设为 RegExpBuiltinExec(urlPattern 的 路径名组件 的 正则表达式，pathname）。

将 searchExecResult 设为 RegExpBuiltinExec(urlPattern 的 查询组件 的 正则表达式，search）。

将 hashExecResult 设为 RegExpBuiltinExec(urlPattern 的 哈希组件 的 正则表达式，hash）。

如果 protocolExecResult、usernameExecResult、passwordExecResult、hostnameExecResult、portExecResult、pathnameExecResult、searchExecResult 或 hashExecResult 为 null，则返回 null。

将 result 设为一个新的 URLPatternResult。

将 result["inputs"] 设置为 inputs。

将 result["protocol"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 协议组件、protocol 和 protocolExecResult。

将 result["username"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 用户名组件、username 和 usernameExecResult。

将 result["password"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 密码组件、password 和 passwordExecResult。

将 result["hostname"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 主机名组件、hostname 和 hostnameExecResult。

将 result["port"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 端口组件、port 和 portExecResult。

将 result["pathname"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 路径名组件、pathname 和 pathnameExecResult。

将 result["search"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 查询组件、search 和 searchExecResult。

将 result["hash"] 设置为 创建组件匹配结果 的结果，给定 urlPattern 的 哈希组件、hash 和 hashExecResult。

返回 result。

如果 urlPattern 的 协议组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 用户名组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 密码组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 主机名组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 端口组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 路径名组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 查询组件 具有正则表达式组 为 true，则返回 true。

如果 urlPattern 的 哈希组件 具有正则表达式组 为 true，则返回 true。

返回 false。

将 part list 设为运行 解析模式字符串 的结果，给定 input、options 和 encoding callback。

将 (regular expression string, name list) 设为运行 生成正则表达式和名称列表 的结果，给定 part list 和 options。

将 flags 设为空字符串。

如果 options 的 忽略大小写 为 true，则将 flags 设为 "vi"。

否则将 flags 设为 "v"

将 regular expression 设为 RegExpCreate(regular expression string, flags)。如果抛出异常，捕获它并抛出 TypeError。

该规范使用正则表达式执行所有匹配，但这不是强制性的。实现可以在可能的情况下直接对 部分列表 进行匹配；例如，当没有自定义正则表达式匹配组时。然而，如果存在自定义正则表达式，则必须立即在 编译组件 算法中评估它们，以便在它们无效时抛出错误。

将 pattern string 设为运行 生成模式字符串 的结果，给定 part list 和 options。

将 has regexp groups 设为 false。

遍历 part list 中的每个 part：

1. 如果 part 的 类型 是 "regexp"，则将 has regexp groups 设为 true。

返回一个新的 组件，其 模式字符串 为 pattern string，正则表达式 为 regular expression，组名称列表 为 name list，且 具有正则表达式组 为 has regexp groups。

将 result 设为一个新的 URLPatternComponentResult。

将 result["input"] 设为 input。

将 groups 设为一个 记录<USVString, (USVString 或 undefined)>。

将 index 设为 1。

当 index 小于 获取(execResult, "length") 时：

1. 将 name 设为 component 的 组名称列表[index − 1]。

2. 将 value 设为 获取(execResult, ToString(index))。

3. 将 groups[name] 设为 value。

4. 将 index 增加 1。

将 result["groups"] 设为 groups。

返回 result。

将 special scheme list 设为包含所有 特殊方案 的 列表。

遍历 special scheme list 中的每个 scheme：

1. 将 test result 设为 RegExpBuiltinExec(protocol component 的 正则表达式，scheme)。

2. 如果 test result 不为 null，则返回 true。

返回 false。

如果 input 的 代码点长度 小于 2，则返回 false。

将 input code points 设为 input 解释为 代码点列表。

如果 input code points[0] 是 U+005B ([)，则返回 true。

如果 input code points[0] 是 U+007B ({) 且 input code points[1] 是 U+005B ([)，则返回 true。

如果 input code points[0] 是 U+005C (\) 且 input code points[1] 是 U+005B ([)，则返回 true。

返回 false。

令 parser 为一个新的 构造函数字符串解析器，其 输入 为 input，并且 token 列表 是运行 tokenize 得到的，给定 input 和 "lenient"。

当 parser 的 token 索引 小于 parser 的 token 列表 的 大小时：

1. 设置 parser 的 token 增量 为 1。

   在解析循环的每次迭代中，parser 的 token 索引 将按其 token 增量 进行递增。通常情况下，递增量为 1，但在某些情况下会设置为 0。然后每次循环的顶部，token 增量 总是重置为 1。

2. 如果 parser 的 token 列表[parser 的 token 索引] 的 类型 为 "end"，则：

   1. 如果 parser 的 状态 是 "init"：

      如果我们在 "init" 状态下到达字符串末尾，那么我们未能找到协议终止符，这必须是一个相对的 URLPattern 构造函数字符串。

      1. 运行 回退，给定 parser。

         接下来我们确定相对模式从哪个组件开始。相对路径名最为常见，但 URL 和 URLPattern 构造函数字符串也可以从 search 或 hash 组件开始。

      2. 如果运行 是否为 hash 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hash" 和 1。

      3. 否则，如果运行 是否为 search 前缀，给定 parser 的结果为 true：

         1. 运行 更改状态，给定 parser，"search" 和 1。

      4. 否则：

         1. 运行 更改状态，给定 parser，"pathname" 和 0。

      5. 将 parser 的 token 索引 增加 parser 的 token 增量。

      6. 继续。

   2. 如果 parser 的 状态 是 "authority"：

      如果我们在 "authority" 状态下到达字符串末尾，那么我们未能找到 "@"。因此没有用户名或密码。

      1. 运行 回退并设置状态，给定 parser 和 "hostname"。

      2. 将 parser 的 token 索引 增加 parser 的 token 增量。

      3. 继续。

   3. 运行 更改状态，给定 parser，"done" 和 0。

   4. 中断。

3. 如果运行 是否为组开启符，给定 parser 的结果为 true：

   我们忽略 "{ ... }" 模式分组中的所有代码点。允许 URL 组件边界位于分组内是没有意义的；例如 "https://example.c{om/fo}o"。虽然在格式良好的 模式字符串中不支持这种分组，我们在这里处理嵌套分组以避免解析器混乱。

   对于正则表达式或命名组，无需执行此逻辑，因为这些值在 tokenize 算法中被折叠为单个token。

   1. 将 parser 的 组深度 增加 1。

   2. 将 parser 的 token 索引 增加 parser 的 token 增量。

   3. 继续。

4. 如果 parser 的 组深度 大于 0：

   1. 如果运行 是否为组关闭符，给定 parser 的结果为 true，则将 parser 的 组深度 减少 1。

   2. 否则：

      1. 将 parser 的 token 索引 增加 parser 的 token 增量。

      2. 继续。

5. 切换 parser 的 状态，并运行相关步骤：

   "init"

   1. 如果运行 是否为协议后缀，给定 parser 的结果为 true：

      1. 运行 回退并设置状态，给定 parser 和 "protocol"。

   "protocol"

   1. 如果运行 是否为协议后缀，给定 parser 的结果为 true：

      1. 运行 计算协议是否匹配特殊方案标志，给定 parser。

         我们需要尽早编译协议组件，以确定它是否匹配任何 特殊方案。如果匹配，则某些特殊规则将适用。它决定了路径名是否默认值为 "/"，以及我们是否会查找用户名、密码、主机名和端口组件。权限斜线也可能导致我们查找这些组件。否则，我们将其视为 "不透明路径 URL"，直接进入路径名组件。

      2. 设置 next state 为 "pathname"。

      3. 设置 skip 为 1。

      4. 如果运行 下一个是权限斜线，给定 parser 的结果为 true：

         1. 设置 next state 为 "authority"。

         2. 设置 skip 为 3。

      5. 否则，如果 parser 的 协议匹配特殊方案标志 为 true，则将 next state 设置为 "authority"。

      6. 运行 更改状态，给定 parser、next state 和 skip。

   "authority"

   1. 如果运行 是否为身份终止符，给定 parser 的结果为 true，则运行 回退并设置状态，给定 parser 和 "username"。

   2. 否则，如果以下任意一个为 true：

      • 运行 是否为路径名开始符，给定 parser；
      • 运行 是否为 search 前缀，给定 parser；或
      • 运行 是否为 hash 前缀，给定 parser，

      则运行 回退并设置状态，给定 parser 和 "hostname"。

   "username"

   1. 如果运行 是否为密码前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"password" 和 1。

   2. 否则，如果运行 是否为身份终止符，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hostname" 和 1。

   "password"

   1. 如果运行 是否为身份终止符，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hostname" 和 1。

   "hostname"

   1. 如果运行 是否为 IPv6 开启符，给定 parser 的结果为 true，则将 parser 的 主机名 IPv6 括号深度 增加 1。

   2. 否则，如果运行 是否为 IPv6 关闭符，给定 parser 的结果为 true，则将 parser 的 主机名 IPv6 括号深度 减少 1。

   3. 否则，如果运行 是否为端口前缀，给定 parser 的结果为 true，且 parser 的 主机名 IPv6 括号深度 为 0，则运行 更改状态，给定 parser，"port" 和 1。

   4. 否则，如果运行 是否为路径名开始符，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"pathname" 和 0。

   5. 否则，如果运行 是否为 search 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"search" 和 1。

   6. 否则，如果运行 是否为 hash 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hash" 和 1。

   "port"

   1. 如果运行 是否为路径名开始符，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"pathname" 和 0。

   2. 否则，如果运行 是否为 search 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"search" 和 1。

   3. 否则，如果运行 是否为 hash 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hash" 和 1。

   "pathname"

   1. 如果运行 是否为 search 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"search" 和 1。

   2. 否则，如果运行 是否为 hash 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hash" 和 1。

   "search"

   1. 如果运行 是否为 hash 前缀，给定 parser 的结果为 true，则运行 更改状态，给定 parser，"hash" 和 1。

   "hash"

   1. 什么都不做。

   "done"

   1. 断言：此步骤从未到达。

6. 将 parser 的 token 索引 增加 parser 的 token 增量。

如果 parser 的 结果 包含 "主机名" 且不包含 "端口"，则将 parser 的 结果["端口"] 设置为空字符串。

返回 parser 的 结果。

如果 parser 的 状态 不是 "init"，不是 "authority"，也不是 "done"，那么将 parser 的 结果[parser 的 状态] 设置为运行 生成组件字符串 给定 parser 的结果。

如果 parser 的 状态 不是 "init" 且 new state 不是 "done"，那么：

1. 如果 parser 的 状态 是 "protocol"，"authority"，"username" 或 "password"；new state 是 "port"，"pathname"，"search" 或 "hash"；并且 parser 的 结果["hostname"] 不 存在，那么将 parser 的 结果["hostname"] 设置为空字符串。

2. 如果 parser 的 状态 是 "protocol"，"authority"，"username"，"password"，"hostname" 或 "port"；new state 是 "search" 或 "hash"；并且 parser 的 结果["pathname"] 不 存在，那么：

   1. 如果 parser 的 协议匹配特殊方案标志 为真，则将 parser 的 结果["pathname"] 设置为 "/"。

   2. 否则，将 parser 的 结果["pathname"] 设置为空字符串。

3. 如果 parser 的 状态 是 "protocol"，"authority"，"username"，"password"，"hostname"，"port" 或 "pathname"；new state 是 "hash"；并且 parser 的 结果["search"] 不 存在，那么将 parser 的 结果["search"] 设置为空字符串。

将 parser 的 状态 设置为 new state。

将 parser 的 token 索引 增加 skip。

将 parser 的 组件开始 设置为 parser 的 token 索引。

将 parser 的 token 增量 设置为 0。

将parser的token 索引设置为parser的组件开始位置。

将parser的token 增量设置为0。

执行 回退，并传入 parser。

将parser的状态设置为state。

如果index 小于parser的 令牌列表的大小，则返回parser的令牌列表[index]。

断言: parser的令牌列表的大小大于等于1。

让last index等于parser的令牌列表的大小减去1。

让token等于parser的令牌列表[last index]。

断言: token的类型为"end"。

返回token。

让token成为运行获取安全令牌的结果，并传入parser和index。

如果token的值不是value，则返回false。

如果以下任一项为true：

• token的类型是"char"；
• token的类型是"escaped-char"；
• token的类型是"invalid-char"，

则返回true。

返回false。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和":"。

如果运行is a non-special pattern char的结果为false，传入parser、parser的token index + 1 和"/"，则返回false。

如果运行is a non-special pattern char的结果为false，传入parser、parser的token index + 2 和"/"，则返回false。

返回true。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和"@"。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和":"。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和":"。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和"/"。

如果运行is a non-special pattern char的结果为true，传入parser、parser的token index和"?"，则返回true。

如果parser的令牌列表[parser的token index]的值不是"?"，则返回false。

让previous index等于parser的token index − 1。

如果previous index小于0，则返回true。

让previous token成为运行获取安全令牌的结果，并传入parser和previous index。

如果以下任一项为true，则返回false：

• previous token的类型是"name"。
• previous token的类型是"regexp"。
• previous token的类型是"close"。
• previous token的类型是"asterisk"。

返回true。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和"#"。

如果parser的令牌列表[parser的token index]的类型是"open"，则返回true。

否则返回false。

如果parser的令牌列表[parser的token index]的类型是"close"，则返回true。

否则返回false。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和"["。

返回运行is a non-special pattern char的结果，传入parser、parser的token index和"]"。

断言：parser的token index小于parser的令牌列表的大小。

设token为parser的令牌列表[parser的token index]。

设component start token为运行获取安全令牌的结果，并传入parser和parser的component start。

设component start input index为component start token的索引。

设end index为token的索引。

返回parser的输入中从component start input index到end index的码点子字符串。

设protocol string为运行make a component string的结果，并传入parser。

设protocol component为运行编译组件的结果，并传入protocol string、规范化协议和默认选项。

如果运行协议组件与特殊方案匹配的结果为true，设置parser的protocol matches a special scheme flag为true。

让tokenizer成为一个新的令牌化器。

将tokenizer的输入设置为input。

将tokenizer的策略设置为policy。

当tokenizer的索引小于tokenizer的输入的码点长度时：

1. 运行查找并获取下一个码点，给定tokenizer和tokenizer的索引。

2. 如果tokenizer的码点是 U+002A (*)：

   1. 运行添加一个带有默认位置和长度的令牌，给定tokenizer和"asterisk"。

   2. 继续。

3. 如果tokenizer的码点是 U+002B (+) 或 U+003F (?)：

   1. 运行添加一个带有默认位置和长度的令牌，给定tokenizer和"other-modifier"。

   2. 继续。

4. 如果tokenizer的码点是 U+005C (\)：

   1. 如果tokenizer的索引等于tokenizer的输入的码点长度 − 1：

      1. 运行处理令牌化错误，给定tokenizer，tokenizer的下一个索引和tokenizer的索引。

      2. 继续。

   2. 将转义索引设置为tokenizer的下一个索引。

   3. 运行获取下一个码点，给定tokenizer。

   4. 运行添加一个带有默认长度的令牌，给定tokenizer，"escaped-char"，tokenizer的下一个索引和转义索引。

   5. 继续。

5. 如果tokenizer的码点是 U+007B ({)：

   1. 运行添加一个带有默认位置和长度的令牌，给定tokenizer和"open"。

   2. 继续。

6. 如果tokenizer的码点是 U+007D (})：

   1. 运行添加一个带有默认位置和长度的令牌，给定tokenizer和"close"。

   2. 继续。

7. 如果tokenizer的码点是 U+003A (:)：

   1. 让name position成为tokenizer的下一个索引。

   2. 让name start成为name position。

   3. 当name position小于tokenizer的输入的码点长度时：

      1. 运行查找并获取下一个码点，给定tokenizer和name position。

      2. 如果name position等于name start，则first code point为true，否则为false。

      3. 运行检查是否为有效名称码点，给定tokenizer的码点和first code point。

      4. 如果valid code point为false，则跳出。

      5. 将name position设置为tokenizer的下一个索引。

   4. 如果name position小于或等于name start：

      1. 运行处理令牌化错误，给定tokenizer，name start和tokenizer的索引。

      2. 继续。

   5. 运行添加一个带有默认长度的令牌，给定tokenizer，"name"，name position和name start。

   6. 继续。

8. 如果tokenizer的码点是 U+0028 (()：

   1. 设depth为 1。

   2. 设regexp position为tokenizer的下一个索引。

   3. 设regexp start为regexp position。

   4. 设error为 false。

   5. 当regexp position小于tokenizer的输入的码点长度时：

      1. 运行查找并获取下一个码点，给定tokenizer和regexp position。

      2. 如果运行检查是否为 ASCII的结果表明tokenizer的码点为 false：

         1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

         2. 设error为 true。

         3. 跳出。

      3. 如果regexp position等于regexp start，并且tokenizer的码点是 U+003F (?)：

         1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

         2. 设error为 true。

         3. 跳出。

      4. 如果tokenizer的码点是 U+005C (\)：

         1. 如果regexp position等于tokenizer的输入的码点长度 − 1：

            1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

            2. 设error为 true。

            3. 跳出

         2. 运行获取下一个码点，给定tokenizer。

         3. 如果运行检查是否为 ASCII的结果为 false，给定tokenizer的码点：

            1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

            2. 设error为 true。

            3. 跳出。

         4. 将regexp position设为tokenizer的下一个索引。

         5. 继续。

      5. 如果tokenizer的码点是 U+0029 ())：

         1. 将depth减 1。

         2. 如果depth为 0：

            1. 将regexp position设为tokenizer的下一个索引。

            2. 跳出。

      6. 否则如果tokenizer的码点是 U+0028 (()：

         1. 将depth加 1。

         2. 如果regexp position等于tokenizer的输入的码点长度 − 1：

            1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

            2. 设error为 true。

            3. 跳出

         3. 设temporary position为tokenizer的下一个索引。

         4. 运行获取下一个码点，给定tokenizer。

         5. 如果tokenizer的码点不是 U+003F (?)：

            1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

            2. 设error为 true。

            3. 跳出。

         6. 将tokenizer的下一个索引设为temporary position。

      7. 将regexp position设为tokenizer的下一个索引。

   6. 如果error为 true，继续。

   7. 如果depth不为零：

      1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

      2. 继续。

   8. 设regexp length为regexp position减去regexp start再减 1。

   9. 如果regexp length为零：

      1. 运行处理令牌化错误，给定tokenizer，regexp start，以及tokenizer的索引。

      2. 继续。

   10. 运行添加一个令牌，给定tokenizer，"regexp"，regexp position，regexp start，以及regexp length。

   11. 继续。

9. 运行添加一个带有默认位置和长度的令牌，给定tokenizer和"char"。

运行添加一个默认长度的令牌，给定tokenizer，"end"，tokenizer的索引，以及tokenizer的索引。

返回tokenizer的令牌列表。

将tokenizer的码点设置为tokenizer的输入中由tokenizer的下一个索引指示的位置的 Unicode 码点。

将tokenizer的下一个索引增加 1。

将tokenizer的下一个索引设置为index。

运行获取下一个码点，给定tokenizer。

创建一个新的token，作为令牌。

将token的类型设置为type。

将token的索引设置为tokenizer的索引。

将token的值设置为从value position到value length的码点子串，位于tokenizer的输入中。

将 token附加到tokenizer的令牌列表的末尾。

将tokenizer的索引设置为next position。

设computed length为next position减去value position。

运行添加令牌，给定tokenizer，type，next position，value position，以及computed length。

运行添加一个默认长度的令牌，给定tokenizer，type，tokenizer的下一个索引，以及tokenizer的索引。

如果tokenizer的策略是"strict"，则抛出TypeError。

断言：tokenizer的策略是"lenient"。

运行添加一个默认长度的令牌，给定tokenizer，"invalid-char"，next position，以及value position。

如果first为 true，返回检查码点是否包含在IdentifierStart码点集中的结果。

否则，返回检查码点是否包含在IdentifierPart码点集中的结果。

如果码点在 U+0000 到 U+007F 之间（含），则返回 true。

否则返回 false。

设parser为一个新的模式解析器，其编码回调为encoding callback，且段通配符正则表达式是运行生成段通配符正则表达式给定的options的结果。

将parser的令牌列表设置为运行标记化给定input和"strict"的结果。

当parser的索引小于parser的令牌列表的大小时：

1. 设char token为运行尝试消费令牌，给定parser和"char"的结果。

2. 设name token为运行尝试消费令牌，给定parser和"name"的结果。

3. 设regexp or wildcard token为运行尝试消费正则或通配符令牌，给定parser和name token的结果。

4. 如果name token不为null或regexp or wildcard token不为null：

   如果有一个匹配组，我们需要立即添加部分。

   1. 设prefix为空字符串。

   2. 如果char token不为null，则将prefix设置为char token的值。

   3. 如果prefix不是空字符串且不是options的前缀码点：

      1. 将prefix追加到parser的待处理固定值的末尾。

      2. 将prefix设置为空字符串。

   4. 运行从待处理固定值中可能添加部分，给定parser。

   5. 设modifier token为运行尝试消费修饰符令牌给定的parser的结果。

   6. 运行添加部分，给定parser、prefix、name token、regexp or wildcard token、空字符串和modifier token。

   7. 继续。

5. 设fixed token为char token。

   如果没有匹配组，那么我们需要缓冲任何固定文本。在将其作为"fixed-text"部分添加之前，我们希望收集尽可能多的文本。

6. 如果fixed token为null，则将fixed token设置为运行尝试消费令牌给定的parser和"escaped-char"的结果。

7. 如果fixed token不为null：

   1. 将fixed token的值追加到parser的待处理固定值中。

   2. 继续。

8. 设open token为运行尝试消费令牌给定的parser和"open"的结果。

   接下来我们寻找序列<open><char prefix><name><regexp><char suffix><close><modifier>。open和close是必须的，但其他令牌不是。

   "{a:foo(bar)b}?"

   所有令牌都存在。

   "{:foo}?"

   "open"、"name"、"close"和"other-modifier"令牌。

   "{(bar)}?"

   "open"、"regexp"、"close"和"other-modifier"令牌。

   "{ab}?"

   "open"、"char"、"close"和"other-modifier"令牌。

9. 如果open token不为null：

   1. 设prefix为运行消费文本，给定parser的结果。

   2. 将name token设置为运行尝试消费令牌给定的parser和"name"的结果。

   3. 将regexp or wildcard token设置为运行尝试消费正则或通配符令牌，给定parser和name token的结果。

   4. 设suffix为运行消费文本，给定parser的结果。

   5. 运行消费必需令牌，给定parser和"close"。

   6. 将modifier token设置为运行尝试消费修饰符令牌，给定parser的结果。

   7. 运行添加部分，给定parser、prefix、name token、regexp or wildcard token、suffix和modifier token。

   8. 继续。

10. 运行从待处理固定值中可能添加部分，给定parser。

11. 运行消费必需令牌，给定parser和"end"。

返回parser的部分列表。

将result设为"[^"。

将运行转义正则表达式字符串给定的options的分隔符码点的结果追加到result的末尾。

将"]+?"追加到result的末尾。

返回result。

断言：parser的索引小于parser的令牌列表的大小。

设next token为parser的令牌列表[parser的索引]。

如果next token的类型不是type，则返回null。

将parser的索引加1。

返回next token。

令结果为"^"。

令名称列表为一个新的列表。

对每个部分的部分列表：

1. 如果部分的类型是"固定文本"：

   1. 如果部分的修饰符是"无"，则将运行转义正则表达式字符串后的结果附加到结果的末尾。

   2. 否则：

      带有修饰符的"固定文本"部分使用非捕获组。其形式如下。

      (?:<固定文本>)<修饰符>

      1. 将"(?:"附加到结果的末尾。

      2. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

      3. 将")"附加到结果的末尾。

      4. 将运行将修饰符转换为字符串后的结果附加到结果的末尾。

   3. 继续。

2. 断言：部分的名称不是空字符串。

3. 附加部分的名称到名称列表。

   我们在并行列表中收集匹配组名称。这主要是为了与path-to-regexp保持一致。尽管可以尝试转换为使用正则表达式命名捕获组，但考虑到算法的复杂性，存在引入意外错误的风险。此外，如果我们最终向网页暴露生成的正则表达式，我们希望与path-to-regexp保持兼容，它表明不太可能切换到使用命名捕获组。

4. 令正则表达式值为部分的值。

5. 如果部分的类型是"段通配符"，则将正则表达式值设置为运行生成段通配符正则表达式后的结果。

6. 否则，如果部分的类型是"全通配符"，则将正则表达式值设置为全通配符正则表达式值。

7. 如果部分的前缀是空字符串，且部分的后缀是空字符串：

   如果没有前缀或后缀，则生成依赖于修饰符。如果没有修饰符或只有可选修饰符，它将使用以下简单形式：

   (<正则表达式值>)<修饰符>

   然而，如果存在重复修饰符，我们将使用更复杂的形式：

   ((?:<正则表达式值>)<修饰符>)

   1. 如果部分的修饰符是"无"或"可 选"，则：

      1. 将"("附加到结果的末尾。

      2. 将正则表达式值附加到结果的末尾。

      3. 将")"附加到结果的末尾。

      4. 将运行将修饰符转换为字符串后的结果附加到结果的末尾。

   2. 否则：

      1. 将"((?:"附加到结果的末尾。

      2. 将正则表达式值附加到结果的末尾。

      3. 将")"附加到结果的末尾。

      4. 将运行将修饰符转换为字符串后的结果附加到结果的末尾。

      5. 将")"附加到结果的末尾。

   3. 继续。

8. 如果部分的修饰符是"无"或"可选"：

   本节处理带有前缀或后缀的非重复部分。内部捕获组包含主要的正则表达式值。然后，内部组与前缀或后缀结合在一个外部非捕获组中。最后，应用修饰符。结果形式如下。

   (?:<前缀>(<正则表达式值>)<后缀>)<修饰符>

   1. 将"(?:"附加到结果的末尾。

   2. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

   3. 将"("附加到结果的末尾。

   4. 将正则表达式值附加到结果的末尾。

   5. 将")"附加到结果的末尾。

   6. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

   7. 将")"附加到结果的末尾。

   8. 将运行将修饰符转换为字符串后的结果附加到结果的末尾。

   9. 继续。

9. 断言：部分的修饰符是"零或更多"或"一个或更多"。

10. 断言：部分的前缀不是空字符串，或部分的后缀不是空字符串。

    带有前缀或后缀的重复部分更加复杂。我们希望排除初始的前缀和最终的后缀，但要在重复元素之间包含它们。为此，我们提供一个单独的初始表达式，排除了前缀。然后，表达式被重复，前缀/后缀值包含在一个可选的重复元素中。如果允许零值，则可以附加一个最终的可选修饰符。结果形式如下。

    (?:<前缀>((?:<正则表达式值>)(?:<后缀><前缀>(?:<正则表达式值>))*)<后缀>)?

11. 将"(?:"附加到结果的末尾。

12. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

13. 将"((?:"附加到结果的末尾。

14. 将正则表达式值附加到结果的末尾。

15. 将")(?:"附加到结果的末尾。

16. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

17. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

18. 将"(?:"附加到结果的末尾。

19. 将正则表达式值附加到结果的末尾。

20. 将"))*)"附加到结果的末尾。

21. 将运行转义正则表达式字符串后的结果附加到结果的末尾。

22. 将")"附加到结果的末尾。

23. 如果部分的修饰符是"零或更多"，则将"?"附加到结果的末尾。

将"$"附加到结果的末尾。

返回 (结果, 名称列表)。

断言：输入是ASCII字符串。

令结果为空字符串。

令索引为0。

当索引小于输入的长度时：

1. 令c为输入[索引]。

2. 将索引加1。

3. 如果c是以下之一：

   • U+002E (.);
   • U+002B (+);
   • U+002A (*);
   • U+003F (?);
   • U+005E (^);
   • U+0024 ($);
   • U+007B ({);
   • U+007D (});
   • U+0028 (();
   • U+0029 ());
   • U+005B ([);
   • U+005D (]);
   • U+007C (|);
   • U+002F (/); 或
   • U+005C (\),

   则将"\"附加到结果的末尾。

4. 将c附加到结果的末尾。

返回结果。

令result为空字符串。

令index list为获取部分列表的索引后的结果。

对每个index的index list：

1. 令part为part list[index]。

2. 如果index大于0，则令previous part为part list[index - 1]，否则令其为null。

3. 如果index小于index list的大小 - 1，则令next part为part list[index + 1]，否则令其为null。

4. 如果part的类型是"fixed-text"：

   1. 如果part的修饰符是"none"，则：

      1. 将运行转义模式字符串后的结果附加到result的末尾。

      2. 继续。

   2. 将"{"附加到result的末尾。

   3. 将运行转义模式字符串后的结果附加到result的末尾。

   4. 将"}"附加到result的末尾。

   5. 将运行将修饰符转换为字符串后的结果附加到result的末尾。

   6. 继续。

5. 令custom name为true，如果part的name[0]不是ASCII数字，否则为false。

6. 令needs grouping为true，如果以下条件中至少有一个为真，否则为false：

   • part的后缀不是空字符串。
   • part的前缀不是空字符串，并且不是options的前缀码点。

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

   • needs grouping为false；且
   • custom name为true；且
   • part的类型是"segment-wildcard"；且
   • part的修饰符是"none"；且
   • next part不为null；且
   • next part的前缀为空字符串；且
   • next part的后缀为空字符串
   则：

   1. 如果next part的类型是"fixed-text"：

      1. 如果运行是有效名称码点给定next part的值的第一个码点和布尔值false为真，则设置needs grouping为true。

   2. 否则：

      1. 如果next part的name[0]是ASCII数字，则设置needs grouping为true。

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

   • needs grouping为false；且
   • part的前缀为空字符串；且
   • previous part不为null；且
   • previous part的类型是"fixed-text"；且
   • previous part的值的最后一个码点是options的前缀码点。
   则设置needs grouping为true。

9. 断言：part的name不是空字符串或null。

10. 如果needs grouping为true，则将"{"附加到result的末尾。

11. 将运行转义模式字符串给定part的前缀附加到result的末尾。

12. 如果custom name为true：

    1. 将":"附加到result的末尾。

    2. 将part的name附加到result的末尾。

13. 如果part的类型是"regexp"，则：

    1. 将"("附加到result的末尾。

    2. 将part的value附加到result的末尾。

    3. 将")"附加到result的末尾。

14. 否则，如果part的类型是"segment-wildcard"，且custom name为false：

    1. 将"("附加到result的末尾。

    2. 将运行生成段通配符正则表达式给定options附加到result的末尾。

    3. 将")"附加到result的末尾。

15. 否则，如果part的类型是"full-wildcard"：

    1. 如果custom name为false，并且以下条件之一为真：

       • previous part为null；或
       • previous part的类型是"fixed-text"；或
       • previous part的修饰符不是"none"；或
       • needs grouping为true；或
       • part的前缀不是空字符串
       则将"*"附加到result的末尾。

    2. 否则：

       1. 将"("附加到result的末尾。

       2. 将全通配符正则表达式值附加到result的末尾。

       3. 将")"附加到result的末尾。

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

    • part的类型是"segment-wildcard"；且
    • custom name为true；且
    • part的后缀不是空字符串；且
    • 运行是有效名称码点给定part的后缀的第一个码点和布尔值false为真
    则将U+005C (\)附加到result的末尾。

17. 将运行转义模式字符串给定part的后缀附加到result的末尾。

18. 如果needs grouping为true，则将"}"附加到result的末尾。

19. 将运行将修饰符转换为字符串给定part的修饰符附加到result的末尾。

返回result。

断言：input是ASCII字符串。

令result为空字符串。

令index为0。

当index小于input的长度时：

1. 令c为input[index]。

2. 将index加1。

3. 如果c是以下之一：

   • U+002B (+);
   • U+002A (*);
   • U+003F (?);
   • U+003A (:);
   • U+007B ({);
   • U+007D (});
   • U+0028 (();
   • U+0029 ()); 或
   • U+005C (\),

   则将U+005C (\)附加到result的末尾。

4. 将c附加到result的末尾。

返回result。

如果modifier是"zero-or-more"，则返回"*"。

如果modifier是"optional"，则返回"?"。

如果modifier是"one-or-more"，则返回"+"。

返回空字符串。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

令parseResult为运行基本URL解析器给定value后跟"://dummy.test"，并以dummyURL为url后的结果。

注意，这里不使用状态重写，因为它强加了只适用于协议设置器的限制。相反，我们使用协议解析一个虚拟URL，使用正常的解析入口点。

如果parseResult失败，则抛出TypeError。

返回dummyURL的方案。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

设置用户名给定dummyURL和value。

返回dummyURL的用户名。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

设置密码给定dummyURL和value。

返回dummyURL的密码。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

令parseResult为运行基本URL解析器给定value并以dummyURL为url且主机名状态为状态重写后的结果。

如果parseResult失败，则抛出TypeError。

返回dummyURL的主机，序列化的结果，或者如果为null则返回空字符串。

令result为空字符串。

对每个被解释为码点列表的value中的码点：

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

   • 码点不是ASCII十六进制数字；
   • 码点不是U+005B ([)；
   • 码点不是U+005D (])；且
   • 码点不是U+003A (:)，

   则抛出TypeError。

2. 将运行ASCII小写给定码点的结果附加到result的末尾。

返回result。

如果portValue为空字符串，则返回portValue。

令dummyURL为一个新的URL记录。

如果给定了protocolValue，则将dummyURL的方案设置为protocolValue。

注意，我们设置URL记录的方案，以便基本URL解析器能够识别和规范化默认端口值。

令parseResult为运行基本URL解析器的结果，传入portValue，并使用dummyURL作为URL，并使用端口状态作为状态覆盖。

如果parseResult为失败，则抛出TypeError。

返回dummyURL的端口，序列化后的值，或者如果为空则返回空字符串。

如果value为空字符串，则返回value。

如果value的第一个码点是U+002F（/），则leading slash为true，否则为false。

如果leading slash为false，则modified value为"/-"，否则为空字符串。

将value附加到modified value的末尾。

令dummyURL为一个新的URL记录。

令parseResult为运行基本URL解析器的结果，传入modified value，并使用dummyURL作为URL，并使用路径开始状态作为状态覆盖。

如果parseResult为失败，则抛出TypeError。

令result为dummyURL的URL路径序列化结果。

如果leading slash为false，则将result设置为从2到字符串末尾的码点子字符串。

返回result。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

将dummyURL的路径设置为空字符串。

令parseResult为运行URL解析的结果，传入value，并使用dummyURL作为URL，以及使用不透明路径状态作为状态覆盖。

如果parseResult为失败，则抛出TypeError。

返回URL路径序列化后的dummyURL结果。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

将dummyURL的查询设置为空字符串。

令parseResult为运行基本URL解析器的结果，传入value，并使用dummyURL作为URL，以及使用查询状态作为状态覆盖。

如果parseResult为失败，则抛出TypeError。

返回dummyURL的查询。

如果value为空字符串，则返回value。

令dummyURL为一个新的URL记录。

将dummyURL的片段设置为空字符串。

令parseResult为运行基本URL解析器的结果，传入value，并使用dummyURL作为URL，以及使用片段状态作为状态覆盖。

如果parseResult为失败，则抛出TypeError。

返回dummyURL的片段。

令result为创建一个新的URLPatternInit的结果。

如果protocol不为null，设置result["protocol"]为protocol。

如果username不为null，设置result["username"]为username。

如果password不为null，设置result["password"]为password。

如果hostname不为null，设置result["hostname"]为hostname。

如果port不为null，设置result["port"]为port。

如果pathname不为null，设置result["pathname"]为pathname。

如果search不为null，设置result["search"]为search。

如果hash不为null，设置result["hash"]为hash。

令baseURL为null。

如果init["baseURL"]存在：

1. 将baseURL设置为解析init["baseURL"]的结果。

2. 如果baseURL为失败，则抛出TypeError。

3. 如果init["protocol"]不存在，则将result["protocol"]设置为处理base URL字符串的结果，传入baseURL的scheme和type。

4. 如果type不是"pattern"，并且init不包含"protocol"、"hostname"、"port"和"username"，则将result["username"]设置为处理base URL字符串的结果，传入baseURL的username和type。

5. 如果type不是"pattern"，并且init不包含"protocol"、"hostname"、"port"、"username"和"password"，则将result["password"]设置为处理base URL字符串的结果，传入baseURL的password和type。

6. 如果init不包含"protocol"或"hostname"，则：

   1. 令baseHost为baseURL的主机。

   2. 如果baseHost为null，则将baseHost设置为空字符串。

   3. 将result["hostname"]设置为处理base URL字符串的结果，传入baseHost和type。

7. 如果init不包含"protocol"、"hostname"、"port"，则：

   1. 如果baseURL的端口为null，则将result["port"]设置为空字符串。

   2. 否则，将result["port"]设置为baseURL的端口，序列化。

8. 如果init不包含"protocol"、"hostname"、"port"、"pathname"，则将result["pathname"]设置为处理base URL字符串的结果，传入URL路径序列化baseURL和type。

9. 如果init不包含"protocol"、"hostname"、"port"、"pathname"和"search"，则：

   1. 令baseQuery为baseURL的查询。

   2. 如果baseQuery为null，则将baseQuery设置为空字符串。

   3. 将result["search"]设置为处理base URL字符串的结果，传入baseQuery和type。

10. 如果init不包含"protocol"、"hostname"、"port"、"pathname"、"search"和"hash"，则：

    1. 令baseFragment为baseURL的片段。

    2. 如果baseFragment为null，则将baseFragment设置为空字符串。

    3. 将result["hash"]设置为处理base URL字符串的结果，传入baseFragment和type。

如果init["protocol"]存在，则将result["protocol"]设置为处理init协议的结果，传入init["protocol"]和type。

如果init["username"]存在，则将result["username"]设置为处理init用户名的结果，传入init["username"]和type。

如果init["password"]存在，则将result["password"]设置为处理init密码的结果，传入init["password"]和type。

如果init["hostname"]存在，则将result["hostname"]设置为处理init主机名的结果，传入init["hostname"]和type。

如果init["port"]存在，则将result["port"]设置为处理init端口的结果，传入init["port"]、result["protocol"]和type。

如果init["pathname"]存在：

1. 将result["pathname"]设置为init["pathname"]。

2. 如果以下条件全部为真：

   • baseURL不为null；
   • baseURL有不透明路径；并且
   • 运行判断是否为绝对路径名的结果，传入result["pathname"]和type为false，

   则：

   1. 令baseURLPath为运行处理base URL字符串的结果，传入URL路径序列化baseURL和type。

   2. 令slash index为在baseURLPath中找到的最后一个U+002F(/)代码点的索引，按代码点序列解释，或为null，如果没有找到代码点。

   3. 如果slash index不为null：

      1. 令new pathname为baseURLPath中从0到slash index + 1的代码点子字符串。

      2. 将result["pathname"]附加到new pathname的末尾。

      3. 将result["pathname"]设置为new pathname。

3. 将result["pathname"]设置为处理init路径名的结果，传入result["pathname"]、result["protocol"]和type。

如果init["search"]存在，则将result["search"]设置为处理init查询的结果，传入init["search"]和type。

如果init["hash"]存在，则将result["hash"]设置为处理init哈希的结果，传入init["hash"]和type。

返回result。

断言：input不为null。

如果type不是"pattern"，则返回input。

返回运行转义模式字符串的结果，传入input。

如果input为空字符串，则返回false。

如果input[0]是U+002F(/)，则返回true。

如果type是"url"，则返回false。

如果input的代码点长度小于2，则返回false。

如果input[0]是U+005C(\)，并且input[1]是U+002F(/)，则返回true。

如果input[0]是U+007B({)，并且input[1]是U+002F(/)，则返回true。

返回false。

令strippedValue为给定的value，去掉一个结尾的U+003A(:)，如果有的话。

如果type是"pattern"，则返回strippedValue。

返回运行规范化协议的结果，传入strippedValue。

如果type是"pattern"，则返回value。

返回运行规范化用户名的结果，传入value。

如果type是"pattern"，则返回value。

返回运行规范化密码的结果，传入value。

如果type是"pattern"，则返回value。

返回运行规范化主机名的结果，传入value。

如果type是"pattern"，则返回portValue。

返回运行规范化端口的结果，传入portValue和protocolValue。

如果type是"pattern"，则返回pathnameValue。

如果protocolValue是特殊方案或为空字符串，则返回运行规范化路径名的结果，传入pathnameValue。

如果protocolValue为空字符串，则表示在构造函数字典中没有为协议提供值。通常我们不会对空字符串字典值进行特殊处理，但在这种情况下，我们将其视为特殊方案，以便默认使用最常见的路径名规范化。

返回运行规范化不透明路径名的结果，传入pathnameValue。

令strippedValue为给定的value，去掉一个开头的U+003F(?)，如果有的话。

如果type是"pattern"，则返回strippedValue。

返回运行规范化搜索的结果，传入strippedValue。

令strippedValue为给定的value，去掉一个开头的U+0023(#)，如果有的话。

如果type是"pattern"，则返回strippedValue。

返回运行规范化哈希的结果，传入strippedValue。

如果input的特定类型是URLPattern：

1. 返回input。

否则：

1. 令pattern为新的URLPattern，带有realm。

2. 将pattern的关联URL模式设置为运行从Web IDL值构建URL模式的结果，传入input和baseURL。

3. 返回pattern。

如果input的特定类型是URLPattern：

1. 返回input的关联URL模式。

否则，如果input的特定类型是URLPatternInit：

1. 令init为input的克隆。

2. 如果init["baseURL"]不存在，设置它为baseURL的序列化。

3. 返回运行创建URL模式的结果，传入init、null和一个空的有序映射。

否则：

1. 断言：input的特定类型是USVString。

2. 返回运行创建URL模式的结果，传入input、baseURL的序列化，以及一个空的有序映射。

令serializedBaseURL为baseURL的序列化。

如果rawPattern是字符串，则：

1. 返回运行创建URL模式的结果，传入rawPattern、serializedBaseURL和一个空的映射。

   将来可能需要在此传递非空选项。

否则，如果rawPattern是映射，则：

1. 令init为«[ "baseURL" → serializedBaseURL ]»，表示一个类型为URLPatternInit的字典。

2. 对于每个 key → value的rawPattern：

   1. 如果key不是URLPatternInit或其继承字典的标识符，value不是字符串，或者该成员的类型未声明为USVString，则返回null。

      如果URLPatternInit增加了其他类型的成员，这将需要更新。
      如果对其他规范有用，将来的规范版本可能还会有一种不那么严格的模式。

   2. 将init[key]设置为value。

3. 返回运行创建URL模式的结果，传入init、null和一个空的映射。

   将来可能需要在此传递非空选项。

否则，返回null。