URL Pattern

`~URL~patternを作成する@ ときは、 所与の ( `URLPatternInput$I %入力, ［ 文字列／~NULL ］ %基底~URL, `URLPatternOptions$I %~option群 ) に対し： ◎ To create a URL pattern given a URLPatternInput input, string or null baseURL, and URLPatternOptions options:

1. %~init ~LET ~NULL ◎ Let init be null.

2. ~IF［ %入力 は `USVString$I 【！`~scalar値~文字列$】である ］： ◎ If input is a scalar value string then:

   1. %~init ~SET `構築子~文字列を構文解析する$( %入力 ) ◎ Set init to the result of running parse a constructor string given input.
   2. ~IF［ %基底~URL ~EQ ~NULL ］ ⇒ ~IF［ %~init[ "`protocol$upI" ] ~EQ ε ］ ⇒ ~THROW `TypeError$E ◎ If baseURL is null and init["protocol"] does not exist, then throw a TypeError.
   3. ~ELSE ⇒ %~init[ "`baseURL$upI" ] ~SET %基底~URL ◎ If baseURL is not null, set init["baseURL"] to baseURL.

3. ~ELSE： ◎ Otherwise:

   1. ~Assert： %入力 は `URLPatternInit$I である ◎ Assert: input is a URLPatternInit.
   2. ~IF［ %基底~URL ~NEQ ~NULL ］ ⇒ ~THROW `TypeError$E ◎ If baseURL is not null, then throw a TypeError.
   3. %~init ~SET %入力 ◎ Set init to input.
4. %処理-済み~init ~LET `~URLPatternInitを処理する$( ↓ ) ⇒＃ %~init, `pattern^l, ~NULL, ~NULL, ~NULL, ~NULL, ~NULL, ~NULL, ~NULL, ~NULL ◎ Let processedInit be the result of process a URLPatternInit given init, "pattern", null, null, null, null, null, null, null, and null.
5. « "`protocol$upI", "`username$upI", "`password$upI", "`hostname$upI", "`port$upI", "`pathname$upI", "`search$upI", "`hash$upI" » を成す ~EACH( %成分~名 ) に対し ⇒ ~IF［ %処理-済み~init[ %成分~名 ] ~EQ ε ］ ⇒ %処理-済み~init[ %成分~名 ] ~SET `*^l ◎ For each componentName of « "protocol", "username", "password", "hostname", "port", "pathname", "search", "hash" »: • If processedInit[componentName] does not exist, then set processedInit[componentName] to "*".
6. ~IF［ %処理-済み~init[ "`protocol$upI" ] は`特別~scheme$である ］~AND［ %処理-済み~init[ "`port$upI" ] ~EQ `整数を直列化する$( %処理-済み~init[ "`protocol$upI" ] 用の`既定~port$ )【！in radix-10 using ASCII digits】 ］ ⇒ %処理-済み~init[ "`port$upI" ] ~SET 空~文字列 ◎ If processedInit["protocol"] is a special scheme and processedInit["port"] is a string which represents its corresponding default port in radix-10 using ASCII digits then set processedInit["port"] to the empty string.
7. %~URL~pattern ~LET 新たな`~URL~pattern$ ◎ Let urlPattern be a new URL pattern.
8. %~URL~pattern の`~protocol成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`protocol$upI" ], `~protocolを正準-化する$, `既定の~option群$ ◎ Set urlPattern’s protocol component to the result of compiling a component given processedInit["protocol"], canonicalize a protocol, and default options.
9. %~URL~pattern の`~username成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`username$upI" ], `~usernameを正準-化する$, `既定の~option群$ ◎ Set urlPattern’s username component to the result of compiling a component given processedInit["username"], canonicalize a username, and default options.
10. %~URL~pattern の`~password成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`password$upI" ], `~passwordを正準-化する$, `既定の~option群$ ◎ Set urlPattern’s password component to the result of compiling a component given processedInit["password"], canonicalize a password, and default options.
11. %~hostname ~LET %処理-済み~init[ "`hostname$upI" ] ◎ ↓
12. ~IF［ `~hostname~patternは~IPv6~addressか否か$( %~hostname ) ~EQ ~T ］ ⇒ %~URL~pattern の`~hostname成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %~hostname, `~IPv6~hostnameを正準-化する$, `~hostname~option群$ ◎ If the result running hostname pattern is an IPv6 address given processedInit["hostname"] is true, then set urlPattern’s hostname component to the result of compiling a component given processedInit["hostname"], canonicalize an IPv6 hostname, and hostname options.
13. ~ELSE ⇒ %~URL~pattern の`~hostname成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %~hostname, `~hostnameを正準-化する$, `~hostname~option群$ ◎ Otherwise, set urlPattern’s hostname component to the result of compiling a component given processedInit["hostname"], canonicalize a hostname, and hostname options.
14. %~URL~pattern の`~port成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`port$upI" ], `~portを正準-化する$, `既定の~option群$ ◎ Set urlPattern’s port component to the result of compiling a component given processedInit["port"], canonicalize a port, and default options.
15. %~compile~option群 ~LET `既定の~option群$の複製 ◎ Let compileOptions be a copy of the default options＼
16. %~compile~option群 の`文字大小を無視するか$opt ~SET %~option群[ "`ignoreCase$upO" ] ◎ with the ignore case property set to options["ignoreCase"].

17. ~IF［ `~protocol成分は特別~schemeに合致しているか否か$( %~URL~pattern の`~protocol成分$ ) ~EQ ~T ］： ◎ If the result of running protocol component matches a special scheme given urlPattern’s protocol component is true, then:

    1. %~path~compile~option群 ~LET `~pathname~option群$の複製 ◎ Let pathCompileOptions be copy of the pathname options＼
    2. %~path~compile~option群 の`文字大小を無視するか$opt ~SET %~option群[ "`ignoreCase$upO" ] ◎ with the ignore case property set to options["ignoreCase"].
    3. %~URL~pattern の`~pathname成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`pathname$upI" ], `~pathnameを正準-化する$, %~path~compile~option群 ◎ Set urlPattern’s pathname component to the result of compiling a component given processedInit["pathname"], canonicalize a pathname, and pathCompileOptions.
18. ~ELSE ⇒ %~URL~pattern の`~pathname成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`pathname$upI" ], `不透明な~pathnameを正準-化する$, %~compile~option群 ◎ Otherwise set urlPattern’s pathname component to the result of compiling a component given processedInit["pathname"], canonicalize an opaque pathname, and compileOptions.
19. %~URL~pattern の`~search成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`search$upI" ], `~searchを正準-化する$, %~compile~option群 ◎ Set urlPattern’s search component to the result of compiling a component given processedInit["search"], canonicalize a search, and compileOptions.
20. %~URL~pattern の`~hash成分$ ~SET `成分を~compileする$( ↓ ) ⇒＃ %処理-済み~init[ "`hash$upI" ], `~hashを正準-化する$, %~compile~option群 ◎ Set urlPattern’s hash component to the result of compiling a component given processedInit["hash"], canonicalize a hash, and compileOptions.
21. ~RET %~URL~pattern ◎ Return urlPattern.

`~URL~patternを照合する@ ときは、 所与の ( `~URL~pattern$ %~URL~pattern, ［ `URLPatternInput$I ／ `~URL$ ］ %入力, 文字列 %基底~URL文字列（省略時は ε ） ) に対し： ◎ To perform a match given a URL pattern urlPattern, a URLPatternInput or URL input, and an optional string baseURLString:

1. %~protocol ~LET 空~文字列 ◎ Let protocol be the empty string.
2. %~username ~LET 空~文字列 ◎ Let username be the empty string.
3. %~password ~LET 空~文字列 ◎ Let password be the empty string.
4. %~hostname ~LET 空~文字列 ◎ Let hostname be the empty string.
5. %~port ~LET 空~文字列 ◎ Let port be the empty string.
6. %~pathname ~LET 空~文字列 ◎ Let pathname be the empty string.
7. %~search ~LET 空~文字列 ◎ Let search be the empty string.
8. %~hash ~LET 空~文字列 ◎ Let hash be the empty string.
9. %入力~群 ~LET 新たな`~list$ ◎ Let inputs be an empty list.
10. %入力~群 に %入力 を`付加する$ ◎ Append input to inputs.

11. ~IF［ %入力 は `URLPatternInit$I である ］： ◎ If input is a URLPatternInit then:

    1. ~IF［ %基底~URL文字列 ~NEQ ε ］ ⇒ ~THROW `TypeError$E ◎ If baseURLString was given, throw a TypeError.
    2. %適用-結果 ~LET `~URLPatternInitを処理する$( ↓ ) ⇒＃ %入力, `url^l, %~protocol, %~username, %~password, %~hostname, %~port, %~pathname, %~search, %~hash ◎終 例外が投出されたときは、 ~catchして ⇒ ~RET ~NULL ◎ Let applyResult be the result of process a URLPatternInit given input, "url", protocol, username, password, hostname, port, pathname, search, and hash. If this throws an exception, catch it, and return null.
    3. %~protocol ~SET %適用-結果[ "`protocol$upI" ] ◎ Set protocol to applyResult["protocol"].
    4. %~username ~SET %適用-結果[ "`username$upI" ] ◎ Set username to applyResult["username"].
    5. %~password ~SET %適用-結果[ "`password$upI" ] ◎ Set password to applyResult["password"].
    6. %~hostname ~SET %適用-結果[ "`hostname$upI" ] ◎ Set hostname to applyResult["hostname"].
    7. %~port ~SET %適用-結果[ "`port$upI" ] ◎ Set port to applyResult["port"].
    8. %~pathname ~SET %適用-結果[ "`pathname$upI" ] ◎ Set pathname to applyResult["pathname"].
    9. %~search ~SET %適用-結果[ "`search$upI" ] ◎ Set search to applyResult["search"].
    10. %~hash ~SET %適用-結果[ "`hash$upI" ] ◎ Set hash to applyResult["hash"].

12. ~ELSE： ◎ Otherwise:

    1. %~URL ~LET %入力 ◎ Let url be input.

    2. ~IF［ %入力 は `USVString$I である ］： ◎ If input is a USVString:

       1. %基底~URL ~LET ~NULL ◎ Let baseURL be null.

       2. ~IF［ %基底~URL文字列 ~NEQ ε ］： ◎ If baseURLString was given, then:

          1. %基底~URL ~SET `~URL構文解析する$( %基底~URL文字列 ) ◎ Set baseURL to the result of parsing baseURLString.
          2. ~IF［ %基底~URL ~EQ `失敗^i ］ ⇒ ~RET ~NULL ◎ If baseURL is failure, return null.
          3. %入力~群 に %基底~URL文字列 を`付加する$ ◎ Append baseURLString to inputs.
       3. %~URL ~SET `~URL構文解析する$( %入力, %基底~URL ) ◎ Set url to the result of parsing input given baseURL.
       4. ~IF［ %~URL ~EQ `失敗^i ］ ⇒ ~RET ~NULL ◎ If url is failure, return null.
    3. ~Assert： %~URL は`~URL$である ◎ Assert: url is a URL.
    4. %~protocol ~SET %~URL の`~scheme$url ◎ Set protocol to url’s scheme.
    5. %~username ~SET %~URL の`~username$url ◎ Set username to url’s username.
    6. %~password ~SET %~URL の`~password$url ◎ Set password to url’s password.
    7. %~hostname ~SET %~URL の`~host$url ◎ Set hostname to url’s host＼
    8. %~hostname ~SET %~hostname に応じて ⇒＃ ~NULL ならば 空~文字列 ／ ~ELSE_ `~hostを直列化する$( %~hostname ) ◎ serialized, or the empty string if the value is null.
    9. %~port ~SET %~URL の`~port$url ◎ Set port to url’s port＼
    10. %~port ~SET %~port に応じて ⇒＃ ~NULL ならば 空~文字列 ／ ~ELSE_ `整数を直列化する$( %~port ) ◎ serialized, or the empty string if the value is null.
    11. %~pathname ~SET `~URL~pathを直列化する$( %~URL ) ◎ Set pathname to the result of URL path serializing url.
    12. %~search ~SET %~URL の`~query$url ◎ Set search to url’s query＼
    13. ~IF［ %~search ~EQ ~NULL ］ ⇒ %~search ~SET 空~文字列 ◎ or the empty string if the value is null.
    14. %~hash ~SET %~URL の`素片$url ◎ Set hash to url’s fragment＼
    15. ~IF［ %~hash ~EQ ~NULL ］ ⇒ %~hash ~SET 空~文字列 ◎ or the empty string if the value is null.
13. %~protocol実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~protocol成分$の`正規表現$cP, %~protocol ) ◎ Let protocolExecResult be RegExpBuiltinExec(urlPattern’s protocol component's regular expression, protocol).
14. %~username実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~username成分$の`正規表現$cP, %~username ) ◎ Let usernameExecResult be RegExpBuiltinExec(urlPattern’s username component's regular expression, username).
15. %~password実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~password成分$の`正規表現$cP, %~password ) ◎ Let passwordExecResult be RegExpBuiltinExec(urlPattern’s password component's regular expression, password).
16. %~hostname実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~hostname成分$の`正規表現$cP, %~hostname ) ◎ Let hostnameExecResult be RegExpBuiltinExec(urlPattern’s hostname component's regular expression, hostname).
17. %~port実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~port成分$の`正規表現$cP, %~port ) ◎ Let portExecResult be RegExpBuiltinExec(urlPattern’s port component's regular expression, port).
18. %~pathname実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~pathname成分$の`正規表現$cP, %~pathname ) ◎ Let pathnameExecResult be RegExpBuiltinExec(urlPattern’s pathname component's regular expression, pathname).
19. %~search実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~search成分$の`正規表現$cP, %~search ) ◎ Let searchExecResult be RegExpBuiltinExec(urlPattern’s search component's regular expression, search).
20. %~hash実行-結果 ~LET `RegExpBuiltinExec$A( %~URL~pattern の`~hash成分$の`正規表現$cP, %~hash ) ◎ Let hashExecResult be RegExpBuiltinExec(urlPattern’s hash component's regular expression, hash).
21. ~IF［ ~NULL ~IN { %~protocol実行-結果, %~username実行-結果, %~password実行-結果, %~hostname実行-結果, %~port実行-結果, %~pathname実行-結果, %~search実行-結果, %~hash実行-結果 } ］ ⇒ ~RET ~NULL ◎ If protocolExecResult, usernameExecResult, passwordExecResult, hostnameExecResult, portExecResult, pathnameExecResult, searchExecResult, or hashExecResult are null then return null.
22. %結果 ~LET 新たな `URLPatternResult$I ◎ Let result be a new URLPatternResult.
23. %結果[ "`inputs$upR" ] ~SET %入力~群 ◎ Set result["inputs"] to inputs.
24. %結果[ "`protocol$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~protocol成分$, %~protocol, %~protocol実行-結果 ◎ Set result["protocol"] to the result of creating a component match result given urlPattern’s protocol component, protocol, and protocolExecResult.
25. %結果[ "`username$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~username成分$, %~username, %~username実行-結果 ◎ Set result["username"] to the result of creating a component match result given urlPattern’s username component, username, and usernameExecResult.
26. %結果[ "`password$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~password成分$, %~password, %~password実行-結果 ◎ Set result["password"] to the result of creating a component match result given urlPattern’s password component, password, and passwordExecResult.
27. %結果[ "`hostname$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~hostname成分$, %~hostname, %~hostname実行-結果 ◎ Set result["hostname"] to the result of creating a component match result given urlPattern’s hostname component, hostname, and hostnameExecResult.
28. %結果[ "`port$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~port成分$, %~port, %~port実行-結果 ◎ Set result["port"] to the result of creating a component match result given urlPattern’s port component, port, and portExecResult.
29. %結果[ "`pathname$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~pathname成分$, %~pathname, %~pathname実行-結果 ◎ Set result["pathname"] to the result of creating a component match result given urlPattern’s pathname component, pathname, and pathnameExecResult.
30. %結果[ "`search$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~search成分$, %~search, %~search実行-結果 ◎ Set result["search"] to the result of creating a component match result given urlPattern’s search component, search, and searchExecResult.
31. %結果[ "`hash$upR" ] ~SET `成分~照合-結果を作成する$( ↓ ) ⇒＃ %~URL~pattern の`~hash成分$, %~hash, %~hash実行-結果 ◎ Set result["hash"] to the result of creating a component match result given urlPattern’s hash component, hash, and hashExecResult.
32. ~RET %結果 ◎ Return result.

`~URL~pattern$ %~URL~pattern は `~regexp~groupを有して@ いるとは、 次の手続きが ~T を返すことをいう： ◎ A URL pattern urlPattern has regexp groups if the following steps return true:

1. %成分~群 ~LET 順に %~URL~pattern を成す次に挙げる`成分$たちが成す~list ⇒＃ `~protocol成分$, `~username成分$, `~password成分$, `~hostname成分$, `~port成分$, `~pathname成分$, `~search成分$, `~hash成分$ ◎ ↓
2. %成分~群 を成す ~EACH( %成分 ) に対し ⇒ ~IF［ %成分 の`~regexp~groupを有するか$cP ~EQ ~T ］ ⇒ ~RET ~T ◎ If urlPattern’s protocol component has regexp groups is true, then return true. ◎ If urlPattern’s username component has regexp groups is true, then return true. ◎ If urlPattern’s password component has regexp groups is true, then return true. ◎ If urlPattern’s hostname component has regexp groups is true, then return true. ◎ If urlPattern’s port component has regexp groups is true, then return true. ◎ If urlPattern’s pathname component has regexp groups is true, then return true. ◎ If urlPattern’s search component has regexp groups is true, then return true. ◎ If urlPattern’s hash component has regexp groups is true, then return true.
3. ~RET ~F ◎ Return false.

`成分を~compileする@ ときは、 所与の ⇒＃ 文字列 %入力, `符号化~callback$ %符号化~callback, `~option群$ %~option群 ◎終 に対し： ◎ To compile a component given a string input, encoding callback encoding callback, and options options:

1. %~part~list ~LET `~pattern文字列を構文解析する$( %入力, %~option群, %符号化~callback ) ◎ Let part list be the result of running parse a pattern string given input, options, and encoding callback.
2. ( %正規表現~文字列, %名前~list ) ~LET `正規表現と名前~listを生成する$( %~part~list, %~option群 ) ◎ Let (regular expression string, name list) be the result of running generate a regular expression and name list given part list and options.
3. %~flag群 ~LET %~option群 の`文字大小を無視するか$optに応じて ⇒＃ ~T ならば `vi^l ／ ~F ならば `v^l ◎ Let flags be an empty string. ◎ If options’s ignore case is true then set flags to "vi". ◎ Otherwise set flags to "v"

4. %正規表現 ~LET `RegExpCreate$A( %正規表現~文字列, %~flag群 ) ⇒ 例外が投出されたときは、 ~catchして ⇒ ~THROW `TypeError$E ◎ Let regular expression be RegExpCreate(regular expression string, flags). If this throws an exception, catch it, and throw a TypeError.

   注記： この仕様は， 遂行するすべての照合に正規表現を利用するが、 このことは義務付けられない。 実装は、 アリなときは，`~part~list$に対し直に照合を遂行してもかまわない （例： ~customな~regexp照合~groupは無いとき）。 しかしながら，~customな正規表現が在る場合、 それらは`成分を~compileする$ときに即時に評価されるので， それらいずれかが妥当でない場合には~errorが投出され得ることに注意。 ◎ The specification uses regular expressions to perform all matching, but this is not mandated. Implementations are free to perform matching directly against the part list when possible; e.g. when there are no custom regexp matching groups. If there are custom regular expressions, however, its important that they be immediately evaluated in the compile a component algorithm so an error can be thrown if they are invalid.

5. %~pattern文字列 ~LET `~pattern文字列を生成する$( %~part~list, %~option群 ) ◎ Let pattern string be the result of running generate a pattern string given part list and options.
6. %~regexp~groupを有するか ~LET ~F ◎ Let has regexp groups be false.
7. %~part~list を成す ~EACH( %~part ) に対し ⇒ ~IF［ %~part の`種別$pt ~EQ `~regexp0$l ］ ⇒ %~regexp~groupを有するか ~SET ~T ◎ For each part of part list: • If part’s type is "regexp", then set has regexp groups to true.
8. ~RET 新たな`成分$ — その ⇒＃ `~pattern文字列$cP ~SET %~pattern文字列, `正規表現$cP ~SET %正規表現, `~group名~list$cP ~SET %名前~list, `~regexp~groupを有するか$cP ~SET %~regexp~groupを有するか ◎ Return a new component whose pattern string is pattern string, regular expression is regular expression, group name list is name list, and has regexp groups is has regexp groups.

`成分~照合-結果を作成する@ ときは、 所与の ( `成分$ %成分, 文字列 %入力, `RegExpBuiltinExec$A の出力を表現している配列 %実行-結果 ) に対し： ◎ To create a component match result given a component component, a string input, and an array representing the output of RegExpBuiltinExec execResult:

1. %結果 ~LET 新たな `URLPatternComponentResult$I ◎ Let result be a new URLPatternComponentResult.
2. %結果[ "`input$upC" ] ~SET %入力 ◎ Set result["input"] to input.
3. %~group群 ~LET 新たな `record$<`USVString$, (`USVString$ or `undefined$)> 型の値 ◎ Let groups be a record<USVString, (USVString or undefined)>.
4. %~index ~LET 1 ◎ Let index be 1.

5. ~WHILE［ %~index ~LT `Get$A( %実行-結果, `length^l ) ］： ◎ While index is less than Get(execResult, "length"):

   1. %名前 ~LET %成分 の`~group名~list$cP[ %~index ~MINUS 1 ] ◎ Let name be component’s group name list[index − 1].
   2. %値 ~LET `Get$A( %実行-結果, `ToString$A( %~index ) ) ◎ Let value be Get(execResult, ToString(index)).
   3. %~group群[ %名前 ] ~SET %値 ◎ Set groups[name] to value.
   4. %~index ~INCBY 1 ◎ Increment index by 1.
6. %結果[ "`groups$upC" ] ~SET %~group群 ◎ Set result["groups"] to groups.
7. ~RET %結果 ◎ Return result.

`~protocol成分は特別~schemeに合致しているか否か@ は、 所与の ( `成分$ %~protocol成分 ) に対し： ◎ To determine if a protocol component matches a special scheme given a component protocol component:

1. ~EACH( `特別~scheme$ %~scheme ) に対し ⇒ ~IF［ `RegExpBuiltinExec$A( %~protocol成分 の`正規表現$cP, %~scheme ) ~NEQ ~NULL ］ ⇒ ~RET ~T ◎ Let special scheme list be a list populated with all of the special schemes. ◎ For each scheme of special scheme list: • Let test result be RegExpBuiltinExec(protocol component’s regular expression, scheme). • If test result is not null, then return true.
2. ~RET ~F ◎ Return false.

`~hostname~patternは~IPv6~addressか否か@ は、 所与の ( `~pattern文字列$ %入力 ) に対し： ◎ To determine if a hostname pattern is an IPv6 address given a pattern string input:

1. ~IF［ %入力 の`符号位置~長さ$ ~LT 2 ］ ⇒ ~RET ~F ◎ If input’s code point length is less than 2, then return false.
2. ( %一個目, %二個目 ) ~LET %入力 を成す ( 0 番, 1番 ) の`文字$ ◎ Let input code points be input interpreted as a list of code points.

3. ~RET ~IS ~OR↓：

   • %一個目 ~EQ `005B^U
   • ［ %一個目 ~EQ `007B^U ］~AND［ %二個目 ~EQ `005B^U ］
   • ［ %一個目 ~EQ `005C^U ］~AND［ %二個目 ~EQ `005B^U ］
   ◎ If input code points[0] is U+005B ([), then return true. ◎ If input code points[0] is U+007B ({) and input code points[1] is U+005B ([), then return true. ◎ If input code points[0] is U+005C (\) and input code points[1] is U+005B ([), then return true. ◎ Return false.

`構築子~文字列を構文解析する@ ときは、 所与の ( 文字列 %入力 ) に対し： ◎ To parse a constructor string given a string input:

1. %構文解析器 ~LET 新たな`構築子~文字列~構文解析器$ — その ⇒＃ `入力$csP ~SET %入力, `~token~list$csP ~SET `~token化する$( %入力, `lenient$l ) ◎ Let parser be a new constructor string parser whose input is input and token list is the result of running tokenize given input and "lenient".

2. ~WHILE［ %構文解析器 の`~token~index$csP ~LT %構文解析器 の`~token~list$csPの`~size$ ］： ◎ While parser’s token index is less than parser’s token list size:

   1. %構文解析器 の`~token増分$csP ~SET 1 ◎ Set parser’s token increment to 1.

      注記： この~loopを成す各~反復においては、 %構文解析器 の`~token~index$csPは， %構文解析器 の`~token増分$csP値により増分されることになる。 この増分は、 概して 1 に設定されるが，ある種の回では 0 に設定される。 `~token増分$csPは、 この~loopを成す先頭にて，常に 1 に設定し直される。 ◎ On every iteration of the parse loop the parser’s token index will be incremented by its token increment value. Typically this means incrementing by 1, but at certain times it is set to zero. The token increment is then always reset back to 1 at the top of the loop.

   2. ~IF［ %構文解析器 の`~token~list$csP[ %構文解析器 の`~token~index$csP ] の`種別$tK ~EQ `end$l ］： ◎ If parser’s token list[parser’s token index]'s type is "end" then:

      1. ~IF［ %構文解析器 の`状態$csP ~EQ `init$l ］： ◎ If parser’s state is "init":

         注記： `init$l `状態$csPにおいて文字列の終端に達した場合、 ~protocol終了子を見出すのに失敗したことになり， %入力 を相対的な~URLPattern構築子~文字列とみなす必要がある。 ◎ If we reached the end of the string in the "init" state, then we failed to find a protocol terminator and this has to be a relative URLPattern constructor string.

         1. `構文解析器を巻戻す$( %構文解析器 ) ◎ Run rewind given parser.

            注記： 次に，相対~patternが どの成分から始まるかを決定する。 相対~pathnameが最も共通的にあるが、 ~URLや~URLPattern構築子~文字列は，［ ~search／~hash ］成分から始まることもある。 ◎ We next determine at which component the relative pattern begins. Relative pathnames are most common, but URLs and URLPattern constructor strings can begin with the search or hash components as well.

         2. ~IF［ `~hash接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hash$l, 1 ) ◎ If the result of running is a hash prefix given parser is true, then run change state given parser, "hash" and 1.

         3. ~ELIF［ `~search接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `search$l, 1 ) ◎ Otherwise if the result of running is a search prefix given parser is true: • Run change state given parser, "search" and 1.

         4. ~ELSE ⇒ `状態を変更する$( %構文解析器, `pathname$l, 0 ) ◎ Otherwise: • Run change state given parser, "pathname" and 0.
         5. %構文解析器 の`~token~index$csP ~INCBY %構文解析器 の`~token増分$csP ◎ Increment parser’s token index by parser’s token increment.
         6. ~CONTINUE ◎ Continue.

      2. ~IF［ %構文解析器 の`状態$csP ~EQ `authority$l ］： ◎ If parser’s state is "authority":

         注記： `authority$l `状態$csPにおいて文字列の終端に達した場合、 `@^l を見出すことに失敗したことになる。 したがって、 ~usernameや~passwordは無い。 ◎ If we reached the end of the string in the "authority" state, then we failed to find an "@". Therefore there is no username or password.

         1. `構文解析器を巻戻す$( %構文解析器, `hostname$l ) ◎ Run rewind and set state given parser, and "hostname".
         2. %構文解析器 の`~token~index$csP ~INCBY %構文解析器 の`~token増分$csP ◎ Increment parser’s token index by parser’s token increment.
         3. ~CONTINUE ◎ Continue.
      3. `状態を変更する$( %構文解析器, `done$l, 0 ) ◎ Run change state given parser, "done" and 0.
      4. ~BREAK ◎ Break.

   3. ~IF［ `~groupを開くか否か$( %構文解析器 ) ~EQ ~T ］： ◎ If the result of running is a group open given parser is true:

      注記： `{ ... }^l で~group化された~patternの中の符号位置は、 すべて無視する。 ~group化の中に~URL成分の境界を許容することは （例： `https://example.c{om/fo}o^l ）、 イミを成さないので。 入子な~group化は，`整形式$な`~pattern文字列$の中では~supportされないが、 構文解析器による混同を避けるため，ここで取扱う。 ◎ We ignore all code points within "{ ... }" pattern groupings. It would not make sense to allow a URL component boundary to lie within a grouping; e.g. "https://example.c{om/fo}o". While not supported within well formed pattern strings, we handle nested groupings here to avoid parser confusion.

      ［ ~regexp／有名~group ］用には、 この~logicを遂行することは必要yでない — それらの値は、 `~token化する$~algoにより，個々の`~token$の中へ縮約されるので。 ◎ It is not necessary to perform this logic for regexp or named groups since those values are collapsed into individual tokens by the tokenize algorithm.

      1. %構文解析器 の`~group深さ$csP ~INCBY 1 ◎ Increment parser’s group depth by 1.
      2. %構文解析器 の`~token~index$csP ~INCBY %構文解析器 の`~token増分$csP ◎ Increment parser’s token index by parser’s token increment.
      3. ~CONTINUE ◎ Continue.

   4. ~IF［ %構文解析器 の`~group深さ$csP ~GT 0 ］： ◎ If parser’s group depth is greater than 0:

      1. ~IF［ `~groupを閉じるか否か$( %構文解析器 ) ~EQ ~T ］ ⇒ %構文解析器 の`~group深さ$csP ~DECBY 1 ◎ If the result of running is a group close given parser is true, then decrement parser’s group depth by 1.

      2. ~ELSE： ◎ Otherwise:

         1. %構文解析器 の`~token~index$csP ~INCBY %構文解析器 の`~token増分$csP ◎ Increment parser’s token index by parser’s token increment.
         2. ~CONTINUE ◎ Continue.

   5. %構文解析器 の`状態$csPに応じて： ◎ Switch on parser’s state and run the associated steps:

      • `init$l ⇒ ~IF［ `~protocol接尾辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `構文解析器を巻戻す$( %構文解析器, `protocol$l ) ◎ "init" • If the result of running is a protocol suffix given parser is true: •• Run rewind and set state given parser and "protocol".

      • `protocol$l： ◎ "protocol"

        1. ~IF［ `~protocol接尾辞か否か$( %構文解析器 ) ~EQ ~T ］： ◎ If the result of running is a protocol suffix given parser is true:

           1. `~protocolは特別~schemeに合致するかを算出する$( %構文解析器 ) ◎ Run compute protocol matches a special scheme flag given parser.

              注記： ~protocol成分は、 `特別~scheme$に合致するか否かを決定するため， 早急に~compileする必要がある。 合致した場合、 ある種の特別な規則が適用される。 それは、［ ~pathnameが既定では `/^l になるか否か ］および［［ ~username, ~password, ~hostname, ~port ］成分を探すことにするか否か ］を決定する。 ~authority~slash列も，これらの成分を探すようにし得る。 他の場合、 これを “不透明な~path~URL” として扱って，~pathname成分へ直行する。 ◎ We need to eagerly compile the protocol component to determine if it matches any special schemes. If it does then certain special rules apply. It determines if the pathname defaults to a "/" and also whether we will look for the username, password, hostname, and port components. Authority slashes can also cause us to look for these components as well. Otherwise we treat this as an "opaque path URL" and go straight to the pathname component.

           2. %次回の状態 ~LET `pathname$l ◎ Let next state be "pathname".
           3. %歩数 ~LET 1 ◎ Let skip be 1.

           4. ~IF［ `次回は~authority~slash列か否か$( %構文解析器 ) ~EQ ~T ］： ◎ If the result of running next is authority slashes given parser is true:

              1. %次回の状態 ~SET `authority$l ◎ Set next state to "authority".
              2. %歩数 ~SET 3 ◎ Set skip to 3.
           5. ~ELIF［ %構文解析器 の`~protocolは特別~schemeに合致するか$csP ~EQ ~T ］ ⇒ %次回の状態 ~SET `authority$l ◎ Otherwise if parser’s protocol matches a special scheme flag is true, then set next state to "authority".
           6. `状態を変更する$( %構文解析器, %次回の状態, %歩数 ) ◎ Run change state given parser, next state, and skip.

      • `authority$l： ◎ "authority"

        1. ~IF［ `識別情報~終了子か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `構文解析器を巻戻す$( %構文解析器, `username$l ) ◎ If the result of running is an identity terminator given parser is true, then run rewind and set state given parser and "username".

        2. ~ELIF［ ~OR↓ ］… ◎ Otherwise if any of the following are true:

           • `~pathname始端か否か$( %構文解析器 ) ~EQ ~T ◎ the result of running is a pathname start given parser;
           • `~search接頭辞か否か$( %構文解析器 ) ~EQ ~T ◎ the result of running is a search prefix given parser; or
           • `~hash接頭辞か否か$( %構文解析器 ) ~EQ ~T ◎ the result of running is a hash prefix given parser,

           …ならば ⇒ `構文解析器を巻戻す$( %構文解析器, `hostname$l ) ◎ then run rewind and set state given parser and "hostname".

      • `username$l： ◎ "username"

        1. ~IF［ `~password接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `password$l, 1 ) ◎ If the result of running is a password prefix given parser is true, then run change state given parser, "password", and 1.
        2. ~ELIF［ `識別情報~終了子か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hostname$l, 1 ) ◎ Otherwise if the result of running is an identity terminator given parser is true, then run change state given parser, "hostname", and 1.
      • `password$l ⇒ ~IF［ `識別情報~終了子か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hostname$l, 1 ) ◎ "password" • If the result of running is an identity terminator given parser is true, then run change state given parser, "hostname", and 1.

      • `hostname$l： ◎ "hostname"

        1. ~IF［ `~IPv6を開くか否か$( %構文解析器 ) ~EQ ~T ］ ⇒ %構文解析器 の`~hostname~IPv6角括弧~深さ$csP ~INCBY 1 ◎ If the result of running is an IPv6 open given parser is true, then increment parser’s hostname IPv6 bracket depth by 1.
        2. ~ELIF［ `~IPv6を閉じるか否か$( %構文解析器 ) ~EQ ~T ］ ⇒ %構文解析器 の`~hostname~IPv6角括弧~深さ$csP ~DECBY 1 ◎ Otherwise if the result of running is an IPv6 close given parser is true, then decrement parser’s hostname IPv6 bracket depth by 1.
        3. ~ELIF［ `~port接頭辞か否か$( %構文解析器 ) ~EQ ~T ］~AND［ %構文解析器 の`~hostname~IPv6角括弧~深さ$csP ~EQ 0 ］ ⇒ `状態を変更する$( %構文解析器, `port$l, 1 ) ◎ Otherwise if the result of running is a port prefix given parser is true and parser’s hostname IPv6 bracket depth is zero, then run change state given parser, "port", and 1.
        4. ~ELIF［ `~pathname始端か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `pathname$l, 0 ) ◎ Otherwise if the result of running is a pathname start given parser is true, then run change state given parser, "pathname", and 0.
        5. ~ELIF［ `~search接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `search$l, 1 ) ◎ Otherwise if the result of running is a search prefix given parser is true, then run change state given parser, "search", and 1.
        6. ~ELIF［ `~hash接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hash$l, 1 ) ◎ Otherwise if the result of running is a hash prefix given parser is true, then run change state given parser, "hash", and 1.

      • `port$l： ◎ "port"

        1. ~IF［ `~pathname始端か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `pathname$l, 0 ) ◎ If the result of running is a pathname start given parser is true, then run change state given parser, "pathname", and 0.
        2. ~ELIF［ `~search接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `search$l, 1 ) ◎ Otherwise if the result of running is a search prefix given parser is true, then run change state given parser, "search", and 1.
        3. ~ELIF［ `~hash接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hash$l, 1 ) ◎ Otherwise if the result of running is a hash prefix given parser is true, then run change state given parser, "hash", and 1.

      • `pathname$l： ◎ "pathname"

        1. ~IF［ `~search接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `search$l, 1 ) ◎ If the result of running is a search prefix given parser is true, then run change state given parser, "search", and 1.
        2. ~ELIF［ `~hash接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hash$l, 1 ) ◎ Otherwise if the result of running is a hash prefix given parser is true, then run change state given parser, "hash", and 1.
      • `search$l ⇒ ~IF［ `~hash接頭辞か否か$( %構文解析器 ) ~EQ ~T ］ ⇒ `状態を変更する$( %構文解析器, `hash$l, 1 ) ◎ "search" • If the result of running is a hash prefix given parser is true, then run change state given parser, "hash", and 1.
      • `hash$l ⇒ 何もしない ◎ "hash" • Do nothing.
      • `done$l ⇒ ~Assert： この段には決して到達しない ◎ "done" • Assert: This step is never reached.
   6. %構文解析器 の`~token~index$csP ~INCBY %構文解析器 の`~token増分$csP ◎ Increment parser’s token index by parser’s token increment.
3. %結果 ~LET %構文解析器 の`結果$csP ◎ ↓

4. ~IF［ %結果[ "`hostname$upI" ] ~NEQ ε ］~AND［ %結果[ "`port$upI" ] ~EQ ε ］ ⇒ %結果[ "`port$upI" ] ~SET 空~文字列 ◎ If parser’s result contains "hostname" and not "port", then set parser’s result["port"] to the empty string.

   注記： この事例は特別に扱われる — ~portを指定しない作者は、 通例的に，`既定~port$を意図するので。 どの~portも受容-可能である場合、 作者は，それを明示的に~wildcardとして指定できる。 例えば， `https://example.com/*^l は、 `https://example.com:8443/^l で始まる~URL （それは、異なる生成元に属する） には，合致しない。 ◎ This is special-cased because when an author does not specify a port, they usually intend the default port. If any port is acceptable, the author can specify it as a wildcard explicitly. For example, "https://example.com/*" does not match URLs beginning with "https://example.com:8443/", which is a different origin.

5. ~RET %結果 ◎ Return parser’s result.

`状態を変更する@ ときは、 所与の ( `構築子~文字列~構文解析器$ %構文解析器, `状態$csP %新たな状態, ~number %歩数 ) に対し： ◎ To change state given a constructor string parser parser, a state new state, and a number skip:

1. %状態 ~LET %構文解析器 の`状態$csP ◎ ↓
2. %結果 ~LET %構文解析器 の`結果$csP ◎ ↓
3. ~IF［ %状態 ~NIN { `init$l, `authority$l, `done$l } ］ ⇒ %結果[ %状態 ] ~SET `成分~文字列を抽出する$( %構文解析器 ) ◎ If parser’s state is not "init", not "authority", and not "done", then set parser’s result[parser’s state] to the result of running make a component string given parser.

4. ~IF［ %状態 ~NEQ `init$l ］~AND［ %新たな状態 ~NEQ `done$l ］： ◎ If parser’s state is not "init" and new state is not "done", then:

   1. ~IF［ ~AND↓ ］…

      • %状態 ~IN { `protocol$l, `authority$l, `username$l, `password$l }
      • %新たな状態 ~IN { `port$l, `pathname$l, `search$l, `hash$l };
      • %結果[ "`hostname$upI" ] ~EQ ε

      …ならば ⇒ %結果[ "`hostname$upI" ] ~SET 空~文字列

      ◎ If parser’s state is "protocol", "authority", "username", or "password"; new state is "port", "pathname", "search", or "hash"; and parser’s result["hostname"] does not exist, then set parser’s result["hostname"] to the empty string.

   2. ~IF［ ~AND↓ ］…

      • %状態 ~IN { `protocol$l, `authority$l, `username$l, `password$l, `hostname$l, `port$l }
      • %新たな状態 ~IN { `search$l, `hash$l }
      • %結果[ "`pathname$upI" ] ~EQ ε

      …ならば ⇒ %結果[ "`pathname$upI" ] ~SET ［ 次が満たされるならば `/^l ／ ~ELSE_ 空~文字列 ］ ⇒ %構文解析器 の`~protocolは特別~schemeに合致するか$csP ~EQ ~T

      ◎ If parser’s state is "protocol", "authority", "username", "password", "hostname", or "port"; new state is "search" or "hash"; and parser’s result["pathname"] does not exist, then: • If parser’s protocol matches a special scheme flag is true, then set parser’s result["pathname"] to "/". • Otherwise, set parser’s result["pathname"] to the empty string.

   3. ~IF［ ~AND↓ ］…

      • %状態 ~IN { `protocol$l, `authority$l, `username$l, `password$l, `hostname$l, `port$l, `pathname$l }
      • %新たな状態 ~EQ `hash$l
      • %結果[ "`search$upI" ] ~EQ ε

      …ならば ⇒ %結果[ "`search$upI" ] ~SET 空~文字列

      ◎ If parser’s state is "protocol", "authority", "username", "password", "hostname", "port", or "pathname"; new state is "hash"; and parser’s result["search"] does not exist, then set parser’s result["search"] to the empty string.
5. %構文解析器 の ⇒＃ `状態$csP ~SET %新たな状態 `~token~index$csP ~INCBY %歩数 `成分~始端$csP ~SET %構文解析器 の`~token~index$csP `~token増分$csP ~SET 0 ◎ Set parser’s state to new state. ◎ Increment parser’s token index by skip. ◎ Set parser’s component start to parser’s token index. ◎ Set parser’s token increment to 0.

`構文解析器を巻戻す@ ときは、 所与の ( `構築子~文字列~構文解析器$ %構文解析器, `状態$csP %状態（省略時は ε ） ) に対し：

1. %構文解析器 の`~token~index$csP ~SET %構文解析器 の`成分~始端$csP
2. %構文解析器 の`~token増分$csP ~SET 0
3. ~IF［ %状態 ~NEQ ε ］ ⇒ %構文解析器 の`状態$csP ~SET %状態

`安全な~tokenを取得する@ ときは、 所与の ( `構築子~文字列~構文解析器$ %構文解析器, ~number %~index ) に対し： ◎ To get a safe token given a constructor string parser parser and a number index:

1. %最後の~index ~LET %構文解析器 の`~token~list$csPの`~size$ ~MINUS 1 ◎ ↓
2. ~IF［ %~index ~LTE %最後の~index ］ ⇒ ~RET %構文解析器 の`~token~list$csP[ %~index ] ◎ If index is less than parser’s token list's size, then return parser’s token list[index].
3. ~Assert： %最後の~index ~GTE 0 ◎ Assert: parser’s token list's size is greater than or equal to 1.
4. %~token ~LET %構文解析器 の`~token~list$csP[ %最後の~index ] ◎ Let last index be parser’s token list's size − 1. ◎ Let token be parser’s token list[last index].
5. ~Assert： %~token の`種別$tK ~EQ `end$l ◎ Assert: token’s type is "end".
6. ~RET %~token ◎ Return token.

`非-特別~pattern文字か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器, ~number %~index, 文字列 %値 ) に対し： ◎ To run is a non-special pattern char given a constructor string parser parser, a number index, and a string value:

1. %~token ~LET `安全な~tokenを取得する$( %構文解析器, %~index ) ◎ Let token be the result of running get a safe token given parser and index.

2. ~RET ~IS ~AND↓：

   • %~token の`値$tK ~EQ %値
   • %~token の`種別$tK ~IN { `char$l, `escaped-char$l, `invalid-char$l }
   ◎ If token’s value is not value, then return false. ◎ If any of the following are true: • token’s type is "char"; • token’s type is "escaped-char"; or • token’s type is "invalid-char", ◎ then return true. ◎ Return false.

`~protocol接尾辞か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run is a protocol suffix given a constructor string parser parser:

1. ~RET `非-特別~pattern文字か否か$( %構文解析器, %構文解析器 の`~token~index$csP, `:^l ) ◎ Return the result of running is a non-special pattern char given parser, parser’s token index, and ":".

`次回は~authority~slash列か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run next is authority slashes given a constructor string parser parser:

1. ~EACH( %n ~IN « 1, 2 » ) に対し ⇒ ~IF［ `非-特別~pattern文字か否か$( %構文解析器, %構文解析器 の`~token~index$csP ~PLUS %n, `/^l ) ~EQ ~F ］ ⇒ ~RET ~F ◎ If the result of running is a non-special pattern char given parser, parser’s token index + 1, and "/" is false, then return false. ◎ If the result of running is a non-special pattern char given parser, parser’s token index + 2, and "/" is false, then return false.
2. ~RET ~T ◎ Return true.

`識別情報~終了子か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run is an identity terminator given a constructor string parser parser:

1. ~RET `非-特別~pattern文字か否か$( %構文解析器, %構文解析器 の`~token~index$csP, `@^l ) ◎ Return the result of running is a non-special pattern char given parser, parser’s token index, and "@".

`~password接頭辞か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run is a password prefix given a constructor string parser parser:

1. ~RET `非-特別~pattern文字か否か$( %構文解析器, %構文解析器 の`~token~index$csP, `:^l ) ◎ Return the result of running is a non-special pattern char given parser, parser’s token index, and ":".

`~port接頭辞か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run is a port prefix given a constructor string parser parser:

1. ~RET `非-特別~pattern文字か否か$( %構文解析器, %構文解析器 の`~token~index$csP, `:^l ) ◎ Return the result of running is a non-special pattern char given parser, parser’s token index, and ":".

`~pathname始端か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run is a pathname start given a constructor string parser parser:

1. ~RET `非-特別~pattern文字か否か$( %構文解析器, %構文解析器 の`~token~index$csP, `/^l ) ◎ Return the result of running is a non-special pattern char given parser, parser’s token index, and "/".

`~search接頭辞か否か@ は、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run is a search prefix given a constructor string parser parser:

1. %~token~index ~LET %構文解析器 の`~token~index$csP ◎ ↓
2. ~IF［ `非-特別~pattern文字か否か$( %構文解析器, %~token~index, `?^l ) ~EQ ~T ］ ⇒ ~RET ~T ◎ If result of running is a non-special pattern char given parser, parser’s token index and "?" is true, then return true.
3. ~IF［ %構文解析器 の`~token~list$csP[ %~token~index ] の`値$tK ~NEQ `?^l ］ ⇒ ~RET ~F ◎ If parser’s token list[parser’s token index]'s value is not "?", then return false.
4. ~IF［ %~token~index ~LT 1 ］ ⇒ ~RET ~T ◎ Let previous index be parser’s token index − 1. ◎ If previous index is less than 0, then return true.
5. %直前の~token ~LET `安全な~tokenを取得する$( %構文解析器, %~token~index ~MINUS 1 ) ◎ Let previous token be the result of running get a safe token given parser and previous index.
6. ~RET ~IS［ %直前の~token の`種別$tK ~NIN { `name$l, `regexp$l, `close$l, `asterisk$l } ］ ◎ If any of the following are true, then return false: • previous token’s type is "name". • previous token’s type is "regexp". • previous token’s type is "close". • previous token’s type is "asterisk". ◎ Return true.

`成分~文字列を抽出する@ ときは、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To run make a component string given a constructor string parser parser:

1. ~Assert： %構文解析器 の`~token~index$csP ~LT %構文解析器 の`~token~list$csPの`~size$ ◎ Assert: parser’s token index is less than parser’s token list's size.
2. %~token ~LET %構文解析器 の`~token~list$csP[ %構文解析器 の`~token~index$csP ] ◎ Let token be parser’s token list[parser’s token index].
3. %成分~始端~token ~LET `安全な~tokenを取得する$( %構文解析器, %構文解析器 の`成分~始端$csP ) ◎ Let component start token be the result of running get a safe token given parser and parser’s component start.
4. ~RET %構文解析器 の`入力$csPの中の［ %成分~始端~token の`~index$tK ］から［ %~token の`~index$tK ］までを`成す符号位置~部分文字列$ ◎ Let component start input index be component start token’s index. ◎ Let end index be token’s index. ◎ Return the code point substring from component start input index to end index within parser’s input.

`~protocolは特別~schemeに合致するかを算出する@ ときは、 所与の ( `構築子~文字列~構文解析器$ %構文解析器 ) に対し： ◎ To compute protocol matches a special scheme flag given a constructor string parser parser:

1. %~protocol文字列 ~LET `成分~文字列を抽出する$( %構文解析器 ) ◎ Let protocol string be the result of running make a component string given parser.
2. %~protocol成分 ~LET `成分を~compileする$( ↓ ) ⇒＃ %~protocol文字列, `~protocolを正準-化する$, `既定の~option群$ ◎ Let protocol component be the result of compiling a component given protocol string, canonicalize a protocol, and default options.
3. ~IF［ `~protocol成分は特別~schemeに合致しているか否か$( %~protocol成分 ) ~EQ ~T ］ ⇒ %構文解析器 の`~protocolは特別~schemeに合致するか$csP ~SET ~T ◎ If the result of running protocol component matches a special scheme given protocol component is true, then set parser’s protocol matches a special scheme flag to true.

`正規表現と名前~listを生成する@ ときは、 所与の ( `~part~list$ %~part~list, `~option群$ %~option群 ) に対し： ◎ To generate a regular expression and name list from a given part list part list and options options:

1. %結果 ~LET `^^l ◎ Let result be "^".
2. %名前~list ~LET 新たな`~list$ ◎ Let name list be a new list.

3. %~part~list を成す ~EACH( %~part ) に対し： ◎ For each part of part list:

   1. ~IF［ %~part の`種別$pt ~EQ `fixed-text$l ］： ◎ If part’s type is "fixed-text":

      1. ~IF［ %~part の`改変子$pt ~EQ `none$l ］ ⇒ %結果 に次の結果を付加する ⇒ `~regexp文字列を~escapeする$( %~part の`値$pt ) ◎ If part’s modifier is "none", then append the result of running escape a regexp string given part’s value to the end of result.

      2. ~ELSE： ◎ Otherwise:

         注記： 改変子を伴う `fixed-text$l %~part は、 ある捕捉なしな~groupを利用する。 それは、 次の形を利用する ⇒ "(?:`固定的な~text^t)`改変子^t" ◎ A "fixed-text" part with a modifier uses a non capturing group. It uses the following form. ◎ (?:<fixed text>)<modifier>

         %結果 に次を順に付加する ⇒＃ `(?:^l, `~regexp文字列を~escapeする$( %~part の`値$pt ), `)^l, `文字列を改変子へ変換する$( %~part の`改変子$pt ) ◎ Append "(?:" to the end of result. ◎ Append the result of running escape a regexp string given part’s value to the end of result. ◎ Append ")" to the end of result. ◎ Append the result of running convert a modifier to a string given part’s modifier to the end of result.

      3. ~CONTINUE ◎ Continue.
   2. ~Assert： %~part の`名前$pt ~NEQ 空~文字列 ◎ Assert: part’s name is not the empty string.

   3. %名前~list に %~part の`名前$ptを`付加する$ ◎ Append part’s name to name list.

      注記： 各~照合~group名を別に用意された~list内に収集する。 これは、 主に旧来の — `path-to-regexp$cite と合致させるための — 理由から行われる。 これを［ 正規表現の捕捉ありな有名~groupを利用するよう変換する ］よう試みることもできたが、 この~algoの複階性から，意図されない~bugを導入する~riskが本当にある。 加えて，生成された正規表現が~webに公開される結果になる場合には、 `path-to-regexp$cite との互換性【！compability】を保守したい — そのことから、 捕捉ありな有名~groupを利用するよう切替えることは， ほぼ見込まれない。 ◎ We collect the list of matching group names in a parallel list. This is largely done for legacy reasons to match path-to-regexp. We could attempt to convert this to use regular expression named captured groups, but given the complexity of this algorithm there is a real risk of introducing unintended bugs. In addition, if we ever end up exposing the generated regular expressions to the web we would like to maintain compability with path-to-regexp which has indicated its unlikely to switch to using named capture groups.

   4. %~regexp値 ~LET %~part の`値$pt ◎ Let regexp value be part’s value.
   5. ~IF［ %~part の`種別$pt ~EQ `segment-wildcard$l ］ ⇒ %~regexp値 ~SET `区分~wildcard~regexpを生成する$( %~option群 ) ◎ If part’s type is "segment-wildcard", then set regexp value to the result of running generate a segment wildcard regexp given options.
   6. ~ELIF［ %~part の`種別$pt ~EQ `full-wildcard$l ］ ⇒ %~regexp値 ~SET `全部的~wildcard~regexp値$ ◎ Otherwise if part’s type is "full-wildcard", then set regexp value to full wildcard regexp value.

   7. ~IF［ %~part の`接頭辞$pt ~EQ 空~文字列 ］~AND［ %~part の`接尾辞$pt ~EQ 空~文字列 ］： ◎ If part’s prefix is the empty string and part’s suffix is the empty string:

      注記： ［ `接頭辞$pt／`接尾辞$pt ］は無い場合、 生成は，改変子に依存する。 ［ 改変子は無い ／ 省略可能にする改変子だけが在る ］場合、 それは，単純な形を利用する — 次のような ⇒ "(`~regexp値^t)`改変子^t" ◎ If there is no prefix or suffix then generation depends on the modifier. If there is no modifier or just the optional modifier, it uses the following simple form: ◎ (<regexp value>)<modifier>

      しかしながら， 繰返可能にする改変子が在る場合、 もっと複階的な形を利用することになる — 次のような ⇒ "((?:`~regexp値^t)`改変子^t)" ◎ If there is a repeating modifier, however, we will use the more complex form: ◎ ((?:<regexp value>)<modifier>)

      1. ~IF［ %~part の`改変子$pt ~IN { `none$l, `optional$l } ］ ⇒ %結果 に次を順に付加する ⇒＃ `(^l, %~regexp値, `)^l, `文字列を改変子へ変換する$( %~part の`改変子$pt ) ◎ If part’s modifier is "none" or "optional", then: • Append "(" to the end of result. • Append regexp value to the end of result. • Append ")" to the end of result. • Append the result of running convert a modifier to a string given part’s modifier to the end of result.
      2. ~ELSE ⇒ %結果 に次を順に付加する ⇒＃ `((?:^l, %~regexp値, `)^l, `文字列を改変子へ変換する$( %~part の`改変子$pt ), `)^l ◎ Otherwise: • Append "((?:" to the end of result. • Append regexp value to the end of result. • Append ")" to the end of result. • Append the result of running convert a modifier to a string given part’s modifier to the end of result. • Append ")" to the end of result.
      3. ~CONTINUE ◎ Continue.

   8. ~IF［ %~part の`改変子$pt ~IN { `none$l, `optional$l } ］： ◎ If part’s modifier is "none" or "optional":

      注記： この段は、 繰返可能にされない~partを — ［ `接頭辞$pt, `接尾辞$pt ］と伴に — 取扱う。 内縁な捕捉ありな~groupとして，首な %~regexp値 を包含するものが在る — この~groupは、 外縁な捕捉なしな~group内で［ `接頭辞$pt, `接尾辞$pt ］と結合される。 最後に，改変子が適用される。 結果の形は ⇒ "(?:`接頭辞^t(`~regexp値^t)`接尾辞^t)`改変子^t" ◎ This section handles non-repeating parts with a prefix or suffix. There is an inner capturing group that contains the primary regexp value. The inner group is then combined with the prefix or suffix in an outer non-capturing group. Finally the modifier is applied. The resulting form is as follows. ◎ (?:<prefix>(<regexp value>)<suffix>)<modifier>

      1. %結果 に次を順に付加する ⇒＃ `(?:^l, `~regexp文字列を~escapeする$( %~part の`接頭辞$pt ), `(^l, %~regexp値, `)^l, `~regexp文字列を~escapeする$( %~part の`接尾辞$pt ), `)^l, `文字列を改変子へ変換する$( %~part の`改変子$pt ), ◎ • Append "(?:" to the end of result. • Append the result of running escape a regexp string given part’s prefix to the end of result. • Append "(" to the end of result. • Append regexp value to the end of result. • Append ")" to the end of result. • Append the result of running escape a regexp string given part’s suffix to the end of result. • Append ")" to the end of result. • Append the result of running convert a modifier to a string given part’s modifier to the end of result.
      2. ~CONTINUE ◎ Continue.
   9. ~Assert： %~part の`改変子$pt ~IN { `zero-or-more$l, `one-or-more$l } ◎ Assert: part’s modifier is "zero-or-more" or "one-or-more".

   10. ~Assert： ［ %~part の`接頭辞$pt ~NEQ 空~文字列 ］~OR［ %~part の`接尾辞$pt ~NEQ 空~文字列 ］ ◎ Assert: part’s prefix is not the empty string or part’s suffix is not the empty string.

       注記： ［ `接頭辞$pt／`接尾辞$pt ］を伴う繰返可能にされた~partは、 ずっと複雑である。 繰返される要素たちに対し、［ `接頭辞$pt／`接尾辞$pt ］を［ 先頭／末尾 ］の要素からは除外する一方で， 各~要素の合間には【逆順に】含めることが求まれる。 これを達成するため、［ `接頭辞$ptが除外された別々な初期~regexp【！expression】 ］が供される。 この~regexp【！expression】は、 省略可能かつ繰返可能にされた要素~内でも — ［ `接頭辞$pt, `接尾辞$pt ］の値を含めた上で — 重複される。 0 個の値が許可される場合、 末尾に省略可能にする改変子が付加される。 結果の形は ⇒ "(?:`接頭辞^t((?:`~regexp値^t)(?:`接尾辞^t`接頭辞^t(?:`~regexp値^t))*)`接尾辞^t)?" ◎ Repeating parts with a prefix or suffix are dramatically more complicated. We want to exclude the initial prefix and the final suffix, but include them between any repeated elements. To achieve this we provide a separate initial expression that excludes the prefix. Then the expression is duplicated with the prefix/suffix values included in an optional repeating element. If zero values are permitted then a final optional modifier can be appended. The resulting form is as follows. • (?:<prefix>((?:<regexp value>)(?:<suffix><prefix>(?:<regexp value>))*)<suffix>)?

   11. %結果 に次を順に付加する ⇒＃ `(?:^l, `~regexp文字列を~escapeする$( %~part の`接頭辞$pt ), `((?:^l, %~regexp値, `)(?:^l, `~regexp文字列を~escapeする$( %~part の`接尾辞$pt ), `~regexp文字列を~escapeする$( %~part の`接頭辞$pt ), `(?:^l, %~regexp値, `))*)^l, `~regexp文字列を~escapeする$( %~part の`接尾辞$pt ), `)^l, ◎ Append "(?:" to the end of result. ◎ Append the result of running escape a regexp string given part’s prefix to the end of result. ◎ Append "((?:" to the end of result. ◎ Append regexp value to the end of result. ◎ Append ")(?:" to the end of result. ◎ Append the result of running escape a regexp string given part’s suffix to the end of result. ◎ Append the result of running escape a regexp string given part’s prefix to the end of result. ◎ Append "(?:" to the end of result. ◎ Append regexp value to the end of result. ◎ Append "))*)" to the end of result. ◎ Append the result of running escape a regexp string given part’s suffix to the end of result. ◎ Append ")" to the end of result.
   12. ~IF［ %~part の`改変子$pt ~EQ `zero-or-more$l ］ ⇒ %結果 に `?^l を付加する ◎ If part’s modifier is "zero-or-more" then append "?" to the end of result.
4. %結果 に `$^l を付加する ◎ Append "$" to the end of result.
5. ~RET ( %結果, %名前~list ) ◎ Return (result, name list).

`~regexp文字列を~escapeする@ ときは、 所与の ( 文字列 %入力 ) に対し： ◎ To escape a regexp string given a string input:

1. ~Assert： %入力 は`~ASCII文字列$である ◎ Assert: input is an ASCII string.
2. %結果 ~LET 空~文字列 ◎ Let result be the empty string.

3. %入力 を成す ~EACH( 文字 %c ) に対し，順に： ◎ Let index be 0. ◎ While index is less than input’s length: • Let c be input[index]. • Increment index by 1.

   1. ~IF［ %c ~IN { `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^U } ］ ⇒ %結果 に `\^l を付加する ◎ If c is one of: • 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 (/); or • U+005C (\), ◎ then append "\" to the end of result.
   2. %結果 に %c を付加する ◎ Append c to the end of result.
4. ~RET %結果 ◎ Return result.

`~pattern文字列を生成する@ ときは、 所与の ( `~part~list$ %~part~list, `~option群$ %~option群 ) に対し： ◎ To generate a pattern string from a given part list part list and options options:

1. %結果 ~LET 空~文字列 ◎ Let result be the empty string.
2. %~index~list ~LET %~part~list の`~index群$ ◎ Let index list be the result of getting the indices for part list.

3. %~index~list を成す ~EACH( %~index ) に対し： ◎ For each index of index list:

   1. %~part ~LET %~part~list[ %~index ] ◎ Let part be part list[index].
   2. %前回の~part ~LET ~NULL ◎ ↓
   3. ~IF［ %~index ~GT 0 ］ ⇒ %前回の~part ~SET %~part~list[ %~index ~MINUS 1 ] ◎ Let previous part be part list[index - 1] if index is greater than 0, otherwise let it be null.
   4. %次回の~part ~LET ~NULL ◎ ↓
   5. ~IF［ %~index ~LT %~index~list の`~size$ ~MINUS 1 ］ ⇒ %次回の~part ~SET %~part~list[ %~index ~PLUS 1] ◎ Let next part be part list[index + 1] if index is less than index list’s size - 1, otherwise let it be null.

   6. ~IF［ %~part の`種別$pt ~EQ `fixed-text$l ］： ◎ If part’s type is "fixed-text" then:

      1. ~IF［ %~part の`改変子$pt ~EQ `none$l ］： ◎ If part’s modifier is "none" then:

         1. %結果 に次を付加する ⇒ `~pattern文字列を~escapeする$( %~part の`値$pt ) ◎ Append the result of running escape a pattern string given part’s value to the end of result.
         2. ~CONTINUE ◎ Continue.
      2. %結果 に次を順に付加する ⇒＃ `{^l, `~pattern文字列を~escapeする$( %~part の`値$pt ), `}^l, `文字列を改変子へ変換する$( %~part の`改変子$pt ), ◎ Append "{" to the end of result. ◎ Append the result of running escape a pattern string given part’s value to the end of result. ◎ Append "}" to the end of result. ◎ Append the result of running convert a modifier to a string given part’s modifier to the end of result.
      3. ~CONTINUE ◎ Continue.
   7. %~custom名か ~LET ~IS［ %~part の`名前$pt[ 0 ] は`~ASCII数字$でない ］ ◎ Let custom name be true if part’s name[0] is not an ASCII digit; otherwise false.

   8. %~group化は必要か ~LET ~IS ~OR↓： ◎ Let needs grouping be true if at least one of the following are true, otherwise let it be false:

      • %~part の`接尾辞$pt ~NEQ 空~文字列 ◎ part’s suffix is not the empty string.
      • ［ %~part の`接頭辞$pt ~NEQ 空~文字列 ］~AND［ %~part の`接頭辞$pt は %~option群 の`接頭辞~符号位置$optでない ］ ◎ part’s prefix is not the empty string and is not options’s prefix code point.

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

      • %~group化は必要か ~EQ ~F ◎ needs grouping is false; and
      • %~custom名か ~EQ ~T ◎ custom name is true; and
      • %~part の`種別$pt ~EQ `segment-wildcard$l ◎ part’s type is "segment-wildcard"; and
      • %~part の`改変子$pt ~EQ `none$l ◎ part’s modifier is "none"; and
      • %次回の~part ~NEQ ~NULL ◎ next part is not null; and
      • %次回の~part の`接頭辞$pt ~EQ 空~文字列 ◎ next part’s prefix is the empty string; and
      • %次回の~part の`接尾辞$pt ~EQ 空~文字列 ◎ next part’s suffix is the empty string

      …ならば： ◎ then:

      1. ~IF［ %次回の~part の`種別$pt ~EQ `fixed-text$l ］： ◎ If next part’s type is "fixed-text":

         1. ~IF［ %次回の~part の`値$ptを成す最初の`文字$は`妥当な名前~符号位置$である ］ ⇒ %~group化は必要か ~SET ~T ◎ Set needs grouping to true if the result of running is a valid name code point given next part’s value's first code point and the boolean false is true.
      2. ~ELIF［ %次回の~part の`名前$pt[0] は`~ASCII数字$である ］ ⇒ %~group化は必要か ~SET ~T ◎ Otherwise: • Set needs grouping to true if next part’s name[0] is an ASCII digit.

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

       • %~group化は必要か ~EQ ~F ◎ needs grouping is false; and
       • %~part の`接頭辞$pt ~EQ 空~文字列 ◎ part’s prefix is the empty string; and
       • %前回の~part ~NEQ ~NULL ◎ previous part is not null; and
       • %前回の~part の`種別$pt ~EQ `fixed-text$l ◎ previous part’s type is "fixed-text"; and
       • %前回の~part の`値$ptを成す最後の`文字$ ~EQ %~option群 の`接頭辞~符号位置$opt ◎ previous part’s value's last code point is options’s prefix code point.

       …ならば ⇒ %~group化は必要か ~SET ~T ◎ then set needs grouping to true.

   11. ~Assert： %~part の`名前$pt ~NIN { 空~文字列, ~NULL } ◎ Assert: part’s name is not the empty string or null.
   12. ~IF［ %~group化は必要か ~EQ ~T ］ ⇒ %結果 に `{^l を付加する ◎ If needs grouping is true, then append "{" to the end of result.
   13. %結果 に次を付加する ⇒ `~pattern文字列を~escapeする$( %~part の`接頭辞$pt ) ◎ Append the result of running escape a pattern string given part’s prefix to the end of result.
   14. ~IF［ %~custom名か ~EQ ~T ］ ⇒ %結果 に次を順に付加する ⇒＃ `:^l, %~part の`名前$pt ◎ If custom name is true: • Append ":" to the end of result. • Append part’s name to the end of result.
   15. ~IF［ %~part の`種別$pt ~EQ `~regexp0$l ］ ⇒ %結果 に次を順に付加する ⇒＃ `(^l, %~part の`値$pt, `)^l ◎ If part’s type is "regexp" then: • Append "(" to the end of result. • Append part’s value to the end of result. • Append ")" to the end of result.
   16. ~ELIF［ %~part の`種別$pt ~EQ `segment-wildcard$l ］~AND［ %~custom名か ~EQ ~F ］ ⇒ %結果 に次を順に付加する ⇒＃ `(^l, `区分~wildcard~regexpを生成する$( %~option群 ), `)^l ◎ Otherwise if part’s type is "segment-wildcard" and custom name is false: • Append "(" to the end of result. • Append the result of running generate a segment wildcard regexp given options to the end of result. • Append ")" to the end of result.

   17. ~ELIF［ %~part の`種別$pt ~EQ `full-wildcard$l ］： ◎ Otherwise if part’s type is "full-wildcard":

       1. ~IF［ %~custom名か ~EQ ~F ］~AND［ ~OR↓ ］… ◎ If custom name is false and one of the following is true:

          • %前回の~part ~EQ ~NULL ◎ previous part is null; or
          • %前回の~part の`種別$pt ~EQ `fixed-text$l ◎ previous part’s type is "fixed-text"; or
          • %前回の~part の`改変子$pt ~NEQ `none$l ◎ previous part’s modifier is not "none"; or
          • %~group化は必要か ~EQ ~T ◎ needs grouping is true; or
          • %~part の`接頭辞$pt ~NEQ 空~文字列 ◎ part’s prefix is not the empty string

          …ならば ⇒ %結果 に `*^l を付加する ◎ then append "*" to the end of result.

       2. ~ELSE ⇒ %結果 に次を順に付加する ⇒＃ `(^l, `全部的~wildcard~regexp値$, `)^l ◎ Otherwise: • Append "(" to the end of result. • Append full wildcard regexp value to the end of result. • Append ")" to the end of result.

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

       • %~part の`種別$pt ~EQ `segment-wildcard$l ◎ part’s type is "segment-wildcard"; and
       • %~custom名か ~EQ ~T ◎ custom name is true; and
       • %~part の`接尾辞$pt ~NEQ 空~文字列 ◎ part’s suffix is not the empty string; and
       • %~part の`接尾辞$ptを成す最初の`文字$は`妥当な名前~符号位置$である ◎ The result of running is a valid name code point given part’s suffix's first code point and the boolean false is true

       …ならば ⇒ %結果 に `005C^U を付加する ◎ then append U+005C (\) to the end of result.

   19. %結果 に次を付加する ⇒ `~pattern文字列を~escapeする$( %~part の`接尾辞$pt ) ◎ Append the result of running escape a pattern string given part’s suffix to the end of result.
   20. ~IF［ %~group化は必要か ~EQ ~T ］ ⇒ %結果 に `}^l を付加する ◎ If needs grouping is true, then append "}" to the end of result.
   21. %結果 に次を付加する ⇒ `文字列を改変子へ変換する$( %~part の`改変子$pt ) ◎ Append the result of running convert a modifier to a string given part’s modifier to the end of result.
4. ~RET %結果 ◎ Return result.

`~pattern文字列を~escapeする@ ときは、 所与の ( 文字列 %入力 ) に対し： ◎ To escape a pattern string given a string input:

1. ~Assert： %入力 は`~ASCII文字列$である ◎ Assert: input is an ASCII string.
2. %結果 ~LET 空~文字列 ◎ Let result be the empty string.

3. %入力 を成す ~EACH( 文字 %c ) に対し，順に： ◎ Let index be 0. ◎ While index is less than input’s length: • Let c be input[index]. • Increment index by 1.

   1. ~IF［ %c ~IN { `002B^U, `002A^U, `003F^U, `003A^U, `007B^U, `007D^U, `0028^U, `0029^U, `005C^U, } ］ ⇒ %結果 に `005C^U を付加する ◎ If c is one of: • U+002B (+); • U+002A (*); • U+003F (?); • U+003A (:); • U+007B ({); • U+007D (}); • U+0028 ((); • U+0029 ()); or • U+005C (\), ◎ then append U+005C (\) to the end of result.
   2. %結果 に %c を付加する ◎ Append c to the end of result.
4. ~RET %結果 ◎ Return result.

`~protocolを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a protocol given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. %値 に `://dummy.test^l を付加する ◎ ↓

4. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %値, %~dummy~URL, ε ) ◎ Let parseResult be the result of running the basic URL parser given value followed by "://dummy.test", with dummyURL as url.

   注記： ここでは、 3 個目の引数（ `上書き state^i ）を利用しない — それが施行する制約が適切になるのは、 `protocol＠~URL1#dom-url-protocol$m 設定子~用に限られるので。 代わりに，［ %値 に与えられた~protocol ］および［ 通常の構文解析の入口† ］を利用して， %~dummy~URL を構文解析する。 【†この訳では、 ε を与えることにより，それを利用する】 ◎ Note, state override is not used here because it enforces restrictions that are only appropriate for the protocol setter. Instead we use the protocol to parse a dummy URL using the normal parsing entry point.

5. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
6. ~RET %~dummy~URL の`~scheme$url ◎ Return dummyURL’s scheme.

`~usernameを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a username given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. `~URLの~usernameを設定する$( %~dummy~URL, %値 ) ◎ Set the username given dummyURL and value.
4. ~RET %~dummy~URL の`~username$url ◎ Return dummyURL’s username.

`~passwordを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a password given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. `~URLの~passwordを設定する$( %~dummy~URL, %値 ) ◎ Set the password given dummyURL and value.
4. ~RET %~dummy~URL の`~password$url ◎ Return dummyURL’s password.

`~hostnameを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a hostname given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %値, %~dummy~URL, `~hostname$st ) ◎ Let parseResult be the result of running the basic URL parser given value with dummyURL as url and hostname state as state override.
4. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
5. %~host ~LET %~dummy~URL の`~host$url ◎ ↓
6. ~RET %~host に応じて ⇒＃ ~NULL ならば 空~文字列／ ~ELSE_ `~hostを直列化する$( %~host ) ◎ Return dummyURL’s host, serialized, or empty string if it is null.

`~IPv6~hostnameを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize an IPv6 hostname given a string value:

1. %結果 ~LET 空~文字列 ◎ Let result be the empty string.

2. %値 を成す ~EACH( %符号位置 ) に対し，順に： ◎ For each code point in value interpreted as a list of code points:

   1. ~IF［ %符号位置 は`~ASCII~hex数字$でない ］~AND［ %符号位置 ~NIN { `005B^U, `005D^U, `003A^U } ］ ⇒ ~THROW `TypeError$E ◎ If all of the following are true: • code point is not an ASCII hex digit; • code point is not U+005B ([); • code point is not U+005D (]); and • code point is not U+003A (:), ◎ then throw a TypeError.

   2. %結果 に次を付加する ⇒ `~ASCII小文字~化する$( %符号位置 ) ◎ Append the result of running ASCII lowercase given code point to the end of result.
3. ~RET %結果 ◎ Return result.

`~portを正準-化する@ ときは、 所与の ( 文字列 %~port値, 文字列 %~protocol値（省略時は ε ） ) に対し： ◎ To canonicalize a port given a string portValue and optionally a string protocolValue:

1. ~IF［ %~port値 ~EQ 空~文字列 ］ ⇒ ~RET %~port値 ◎ If portValue is the empty string, return portValue.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.

3. ~IF［ %~protocol値 ~NEQ ε ］ ⇒ %~dummy~URL の`~scheme$url ~SET %~protocol値 ◎ If protocolValue was given, then set dummyURL’s scheme to protocolValue.

   注記： ここで`~scheme$urlを設定するのは、［ `基本~URL構文解析器$が`既定~port$を認識して正規化する ］ようにするためである。 ◎ Note, we set the URL record's scheme in order for the basic URL parser to recognize and normalize default port values.

4. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %~port値, %~dummy~URL, `~port$st ) ◎ Let parseResult be the result of running basic URL parser given portValue with dummyURL as url and port state as state override.
5. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
6. %~port ~LET %~dummy~URL の`~port$url ◎ ↓
7. ~RET %~port に応じて ⇒＃ ~NULL ならば 空~文字列 ／ ~ELSE_ `整数を直列化する$( %~port ) ◎ Return dummyURL’s port, serialized, or empty string if it is null.

`~pathnameを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a pathname given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, then return value.
2. %先頭は~slashか ~LET ~IS［ %値 を成す最初の`文字$ ~EQ `002F^U ］ ◎ Let leading slash be true if the first code point in value is U+002F (/) and otherwise false.

3. %改変-済み値 ~LET %先頭は~slashか に応じて ⇒＃ ~T ならば 空~文字列 ／ ~F ならば `/-^l ◎ Let modified value be "/-" if leading slash is false and otherwise the empty string.

   注記： ~URL構文解析器は，正準-化される~pathnameに自動的に~slashを接頭する【！prepend】が、 あいにく，ここでは働かない。 この~algoは、 符号化~callbackとして利用されるときには［ ~pathname全体ではなく，~pathnameを成す各~piece ］用に~callされるので。 したがって，ここでは、 自前の~slashを挿入して，この接頭-法【！prepending】を不能化する。 ここでは、 追加的な文字【 `-^l 】も挿入する — 先頭に~dotがあった場合に［ 捏造な~slashと伴に `/.^l 連列として解釈されることに因り，不作為に縮約される ］ことを避けるため。 ここで挿入した これらの文字は、 後で結果から除去される。 ◎ The URL parser will automatically prepend a leading slash to the canonicalized pathname. This does not work here unfortunately. This algorithm is called for pieces of the pathname, instead of the entire pathname, when used as an encoding callback. Therefore we disable the prepending of the slash by inserting our own. An additional character is also inserted here in order to avoid inadvertantly collapsing a leading dot due to the fake leading slash being interpreted as a "/." sequence. These inserted characters are then removed from the result below.

   実装は、 各自の~URL構文解析~codeにおいては， ~slashの接頭-法【！prepending】を単純に不能化してもかまわない — ［ この~algo内で文字たちを挿入してから除去する ］ことによる処理能の代償を払う代わりに。 ◎ Note, implementations are free to simply disable slash prepending in their URL parsing code instead of paying the performance penalty of inserting and removing characters in this algorithm.

4. %改変-済み値 に %値 を付加する ◎ Append value to the end of modified value.
5. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
6. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %改変-済み値, %~dummy~URL, `~path開始$st ) ◎ Let parseResult be the result of running basic URL parser given modified value with dummyURL as url and path start state as state override.
7. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
8. %結果 ~LET `~URL~pathを直列化する$( %~dummy~URL ) ◎ Let result be the result of URL path serializing dummyURL.
9. ~IF［ %先頭は~slashか ~EQ ~F ］ ⇒ %結果 ~SET %結果 の中の 2 から`終端までを成す符号位置~部分文字列$ ◎ If leading slash is false, then set result to the code point substring from 2 to the end of the string within result.
10. ~RET %結果 ◎ Return result.

`不透明な~pathnameを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize an opaque pathname given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. %~dummy~URL の`~path$url ~SET 空~文字列 ◎ Set dummyURL’s path to the empty string.
4. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %値, %~dummy~URL, `不透明~path$st ) ◎ Let parseResult be the result of running URL parsing given value with dummyURL as url and opaque path state as state override.
5. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
6. ~RET `~URL~pathを直列化する$( %~dummy~URL ) ◎ Return the result of URL path serializing dummyURL.

`~searchを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a search given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. %~dummy~URL の`~query$url ~SET 空~文字列 ◎ Set dummyURL’s query to the empty string.
4. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %値, %~dummy~URL, `~query$st ) ◎ Let parseResult be the result of running basic URL parser given value with dummyURL as url and query state as state override.
5. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
6. ~RET %~dummy~URL の`~query$url ◎ Return dummyURL’s query.

`~hashを正準-化する@ ときは、 所与の ( 文字列 %値 ) に対し： ◎ To canonicalize a hash given a string value:

1. ~IF［ %値 ~EQ 空~文字列 ］ ⇒ ~RET %値 ◎ If value is the empty string, return value.
2. %~dummy~URL ~LET 新たな`~URL~record$ ◎ Let dummyURL be a new URL record.
3. %~dummy~URL の`素片$url ~SET 空~文字列 ◎ Set dummyURL’s fragment to the empty string.
4. %構文解析-結果 ~LET `~API用に~URL構文解析する$( %値, %~dummy~URL, `素片$st ) ◎ Let parseResult be the result of running basic URL parser given value with dummyURL as url and fragment state as state override.
5. ~IF［ %構文解析-結果 ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If parseResult is failure, then throw a TypeError.
6. ~RET %~dummy~URL の`素片$url ◎ Return dummyURL’s fragment.

`~URLPatternInitを処理する@ ときは、 所与の ⇒＃ `URLPatternInit$I %~init, 文字列 %種別, ［文字列／~NULL］ %~protocol, ［文字列／~NULL］ %~username, ［文字列／~NULL］ %~password, ［文字列／~NULL］ %~hostname, ［文字列／~NULL］ %~port, ［文字列／~NULL］ %~pathname, ［文字列／~NULL］ %~search, ［文字列／~NULL］ %~hash ◎終 に対し： ◎ To process a URLPatternInit given a URLPatternInit init, a string type, a string or null protocol, a string or null username, a string or null password, a string or null hostname, a string or null port, a string or null pathname, a string or null search, and a string or null hash:

1. %結果 ~LET 新たな `URLPatternInit$I ◎ Let result be the result of creating a new URLPatternInit.
2. ~IF［ %~protocol ~NEQ ~NULL ］ ⇒ %結果[ "`protocol$upI" ] ~SET %~protocol ◎ If protocol is not null, set result["protocol"] to protocol.
3. ~IF［ %~username ~NEQ ~NULL ］ ⇒ %結果[ "`username$upI" ] ~SET %~username ◎ If username is not null, set result["username"] to username.
4. ~IF［ %~password ~NEQ ~NULL ］ ⇒ %結果[ "`password$upI" ] ~SET %~password ◎ If password is not null, set result["password"] to password.
5. ~IF［ %~hostname ~NEQ ~NULL ］ ⇒ %結果[ "`hostname$upI" ] ~SET %~hostname ◎ If hostname is not null, set result["hostname"] to hostname.
6. ~IF［ %~port ~NEQ ~NULL ］ ⇒ %結果[ "`port$upI" ] ~SET %~port ◎ If port is not null, set result["port"] to port.
7. ~IF［ %~pathname ~NEQ ~NULL ］ ⇒ %結果[ "`pathname$upI" ] ~SET %~pathname ◎ If pathname is not null, set result["pathname"] to pathname.
8. ~IF［ %~search ~NEQ ~NULL ］ ⇒ %結果[ "`search$upI" ] ~SET %~search ◎ If search is not null, set result["search"] to search.
9. ~IF［ %~hash ~NEQ ~NULL ］ ⇒ %結果[ "`hash$upI" ] ~SET %~hash ◎ If hash is not null, set result["hash"] to hash.
10. %基底~URL文字列 ~LET %~init[ "`baseURL$upI" ] ◎ Let baseURL be null.
11. `(A)^i

    ~IF［ %基底~URL文字列 ~NEQ ε ］： ◎ If init["baseURL"] exists:

    注記： 基底~URLは，追加的な文脈を給するために利用され得るが、 各~成分に対し ⇒ 基底~URLを成す当の成分は、 %~init が［ 当の成分か それより特有な成分 ］を含む場合には，継承されない 【すなわち，結果に影響しない】。 ◎ The base URL can be used to supply additional context, but for each component, if init includes a component which is at least as specific as one in the base URL, none is inherited.

    成分どうしは、［ 次に挙げる 2 つの~list （それは、 ~URL構文~内に現れる順序と ごく類似する） いずれかにおいて，後に現れるもの ］ほど，より特有であるとされる： ◎ A component is more specific if it appears later in one of the following two lists (which are very similar to the order they appear in the URL syntax):

    • ~protocol, ~hostname, ~port, ~pathname, ~search, ~hash ◎ protocol, hostname, port, pathname, search, hash
    • ~protocol, ~hostname, ~port, ~username, ~password ◎ protocol, hostname, port, username, password

    `URLPattern$I を構築するときには、［ ~username, ~password ］も，基底~URLからは決して継承されない （しかしながら，それらは、［ `test()$m ／ `exec()$m ］に対する引数として給された~URLを構文解析するときには， 基底~URLから継承される）。 ◎ Username and password are also never inherited from a base URL when constructing a URLPattern. (They are, however, inherited from the base URL when parsing a URL supplied as an argument to test() or exec().)

    1. %基底~URL ~SET `~URL構文解析する$( %基底~URL文字列 ) ◎ Set baseURL to the result of parsing init["baseURL"].
    2. ~IF［ %基底~URL ~EQ `失敗^i ］ ⇒ ~THROW `TypeError$E ◎ If baseURL is failure, then throw a TypeError.
    3. ~IF［ %~init[ "`protocol$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(A)^i ◎ ↓
    4. %結果[ "`protocol$upI" ] ~SET `基底~URL文字列を処理する$( %基底~URL の`~scheme$url, %種別 ) ◎ If init["protocol"] does not exist, then set result["protocol"] to the result of processing a base URL string given baseURL’s scheme and type. ◎ ↓ If type is not "pattern" and init contains none of "protocol", "hostname", "port" and "username", then set result["username"] to the result of processing a base URL string given baseURL’s username and type. ◎ ↓ If type is not "pattern" and init contains none of "protocol", "hostname", "port", "username" and "password", then set result["password"] to the result of processing a base URL string given baseURL’s password and type.
    5. ~IF［ %~init[ "`hostname$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(A)^i ◎ ↓
    6. %基底~host ~LET %基底~URL の`~host$url ◎ If init contains neither "protocol" nor "hostname", then: • Let baseHost be baseURL’s host.
    7. ~IF［ %基底~host ~EQ ~NULL ］ ⇒ %基底~host ~SET 空~文字列 ◎ • If baseHost is null, then set baseHost to the empty string.
    8. %結果[ "`hostname$upI" ] ~SET `基底~URL文字列を処理する$( %基底~host, %種別 ) ◎ • Set result["hostname"] to the result of processing a base URL string given baseHost and type.
    9. ~IF［ %~init[ "`port$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(A)^i ◎ ↓
    10. `(B)^i

        ~IF［ %種別 ~NEQ `pattern^l ］：

        1. ~IF［ %~init[ "`username$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(B)^i
        2. %結果[ "`username$upI" ] ~SET `基底~URL文字列を処理する$( %基底~URL の`~username$url, %種別 )
        3. ~IF［ %~init[ "`password$upI" ] ~EQ ε ］ ⇒ ~BREAK `(B)^i
        4. %結果[ "`password$upI" ] ~SET `基底~URL文字列を処理する$( %基底~URL の`~password$url, %種別 )
        ◎ ↑↑
    11. %基底~port ~LET %基底~URL の`~port$url ◎ ↓
    12. %結果[ "`port$upI" ] ~SET %基底~port に応じて ⇒＃ ~NULL ならば 空~文字列 ／ ~ELSE_ `整数を直列化する$( %基底~port ) ◎ If init contains none of "protocol", "hostname", and "port", then: • If baseURL’s port is null, then set result["port"] to the empty string. • Otherwise, set result["port"] to baseURL’s port, serialized.
    13. ~IF［ %~init[ "`pathname$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(A)^i ◎ ↓
    14. %結果[ "`pathname$upI" ] ~SET `基底~URL文字列を処理する$( `~URL~pathを直列化する$( %基底~URL, %種別 ) ) ◎ If init contains none of "protocol", "hostname", "port", and "pathname", then set result["pathname"] to the result of processing a base URL string given the result of URL path serializing baseURL and type.
    15. ~IF［ %~init[ "`search$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(A)^i ◎ ↓
    16. %基底~query ~LET %基底~URL の`~query$url ◎ If init contains none of "protocol", "hostname", "port", "pathname", and "search", then: • Let baseQuery be baseURL’s query.
    17. ~IF［ %基底~query ~EQ ~NULL ］ ⇒ %基底~query ~SET 空~文字列 ◎ • If baseQuery is null, then set baseQuery to the empty string.
    18. %結果[ "`search$upI" ] ~SET `基底~URL文字列を処理する$( %基底~query, %種別 ) ◎ • Set result["search"] to the result of processing a base URL string given baseQuery and type.
    19. ~IF［ %~init[ "`hash$upI" ] ~NEQ ε ］ ⇒ ~BREAK `(A)^i ◎ ↓
    20. %基底~素片 ~LET %基底~URL の`素片$url ◎ If init contains none of "protocol", "hostname", "port", "pathname", "search", and "hash", then: • Let baseFragment be baseURL’s fragment.
    21. ~IF［ %基底~素片 ~EQ ~NULL ］ ⇒ %基底~素片 ~SET 空~文字列 ◎ • If baseFragment is null, then set baseFragment to the empty string.
    22. %結果[ "`hash$upI" ] ~SET `基底~URL文字列を処理する$( %基底~素片, %種別 ) ◎ • Set result["hash"] to the result of processing a base URL string given baseFragment and type.
12. ~IF［ %~init[ "`protocol$upI" ] ~NEQ ε ］ ⇒ %結果[ "`protocol$upI" ] ~SET `~init用に~protocolを処理する$( %~init[ "`protocol$upI" ], %種別 ) ◎ If init["protocol"] exists, then set result["protocol"] to the result of process protocol for init given init["protocol"] and type.
13. ~IF［ %~init[ "`username$upI" ] ~NEQ ε ］ ⇒ %結果[ "`username$upI" ] ~SET `~init用に~usernameを処理する$( %~init[ "`username$upI" ], %種別 ) ◎ If init["username"] exists, then set result["username"] to the result of process username for init given init["username"] and type.
14. ~IF［ %~init[ "`password$upI" ] ~NEQ ε ］ ⇒ %結果[ "`password$upI" ] ~SET `~init用に~passwordを処理する$( %~init[ "`password$upI" ], %種別 ) ◎ If init["password"] exists, then set result["password"] to the result of process password for init given init["password"] and type.
15. ~IF［ %~init[ "`hostname$upI" ] ~NEQ ε ］ ⇒ %結果[ "`hostname$upI" ] ~SET `~init用に~hostnameを処理する$( %~init[ "`hostname$upI" ], %種別 ) ◎ If init["hostname"] exists, then set result["hostname"] to the result of process hostname for init given init["hostname"] and type.

16. ~IF［ %~init[ "`port$upI" ] ~NEQ ε ］ ⇒ %結果[ "`port$upI" ] ~SET `~init用に~portを処理する$( %~init[ "`port$upI" ], %結果[ "`protocol$upI" ], %種別 ) ◎ If init["port"] exists, then set result["port"] to the result of process port for init given init["port"], result["protocol"], and type.

17. ~IF［ %~init[ "`pathname$upI" ] ~NEQ ε ］： ◎ If init["pathname"] exists:

    1. %結果[ "`pathname$upI" ] ~SET %~init[ "`pathname$upI" ] ◎ Set result["pathname"] to init["pathname"].

    2. ~IF［ ~AND↓ ］… ◎ If the following are all true:

       • %基底~URL ~NEQ ε ◎ baseURL is not null;
       • %基底~URL は`不透明な~path$を持つ ◎ baseURL has an opaque path; and
       • `絶対~pathnameか否か$( %結果[ "`pathname$upI" ], %種別 ) ~EQ ~F ◎ the result of running is an absolute pathname given result["pathname"] and type is false,

       …ならば： ◎ then:

       1. %基底~URL~path ~LET `基底~URL文字列を処理する$( `~URL~pathを直列化する$( %基底~URL, %種別 ) ) ◎ Let baseURLPath be the result of running process a base URL string given the result of URL path serializing baseURL and type.
       2. %~slash~index ~LET %基底~URL~path の`符号位置~長さ$ ~MINUS 1 ◎ ↓

       3. ~WHILE［ %~slash~index ~GTE 0 ］：

          1. ~IF［ %基底~URL~path を成す %~slash~index 番の符号位置 ~EQ `002F^U ］ ⇒ ~BREAK
          2. %~slash~index ~DECBY 1
          ◎ Let slash index be the index of the last U+002F (/) code point found in baseURLPath, interpreted as a sequence of code points, or null if there are no instances of the code point.

       4. ~IF［ %~slash~index ~GTE 0 ］： ◎ If slash index is not null:

          1. %新たな~pathname ~LET %基底~URL~path の中の 0 から［ %~slash~index ~PLUS 1 ］までを`成す符号位置~部分文字列$ ◎ Let new pathname be the code point substring from 0 to slash index + 1 within baseURLPath.
          2. %新たな~pathname に %結果[ "`pathname$upI" ] を付加する ◎ Append result["pathname"] to the end of new pathname.
          3. %結果[ "`pathname$upI" ] ~SET %新たな~pathname ◎ Set result["pathname"] to new pathname.
    3. %結果[ "`pathname$upI" ] ~SET `~init用に~pathnameを処理する$( %結果[ "`pathname$upI" ], %結果[ "`protocol$upI" ], %種別 ) ◎ Set result["pathname"] to the result of process pathname for init given result["pathname"], result["protocol"], and type.
18. ~IF［ %~init[ "`search$upI" ] ~NEQ ε ］ ⇒ %結果[ "`search$upI" ] ~SET `~init用に~searchを処理する$( %~init[ "`search$upI" ], %種別 ) ◎ If init["search"] exists then set result["search"] to the result of process search for init given init["search"] and type.
19. ~IF［ %~init[ "`hash$upI" ] ~NEQ ε ］ ⇒ %結果[ "`hash$upI" ] ~SET `~init用に~hashを処理する$( %~init[ "`hash$upI" ], %種別 ) ◎ If init["hash"] exists then set result["hash"] to the result of process hash for init given init["hash"] and type.
20. ~RET %結果 ◎ Return result.

`基底~URL文字列を処理する@ ときは、 所与の ( 文字列 %入力, 文字列 %種別 ) に対し： ◎ To process a base URL string given a string input and a string type:

1. ~Assert： %入力 ~NEQ ~NULL ◎ Assert: input is not null.
2. ~IF［ %種別 ~NEQ `pattern^l ］ ⇒ ~RET %入力 ◎ If type is not "pattern" return input.
3. ~RET `~pattern文字列を~escapeする$( %入力 ) ◎ Return the result of escaping a pattern string given input.

`絶対~pathnameか否か@ は、 所与の ( `~pattern文字列$ %入力, 文字列 %種別 ) に対し：

1. %長さ ~LET %入力 の`符号位置~長さ$

2. ~RET ~IS ~OR↓：

   • ~AND↓：

     • %長さ ~GTE 1
     • `符号位置~部分文字列$( %入力, 0, 1 ) ~EQ `/^l

   • ~AND↓：

     • %種別 ~NEQ `url^l
     • %長さ ~GTE 2
     • `符号位置~部分文字列$( %入力, 0, 2 ) ~IN { `\/^l, `{/^l }

`~init用に~protocolを処理する@ ときは、 所与の ( 文字列 %値, 文字列 %種別 ) に対し： ◎ To process protocol for init given a string value and a string type:

1. ~IF［ %値 を成す最初の`文字$ ~EQ `003A^U ］ ⇒ %値 ~SET %値 の中の 1 から`終端までを成す符号位置~部分文字列$ ◎ Let strippedValue be the given value with a single trailing U+003A (:) removed, if any.
2. ~RET %種別 に応じて ⇒＃ `pattern^l ならば %値 ／ ~ELSE_ `~protocolを正準-化する$( %値 ) ◎ If type is "pattern" then return strippedValue. ◎ Return the result of running canonicalize a protocol given strippedValue.

`~init用に~pathnameを処理する@ ときは、 所与の ( 文字列 %~pathname値, 文字列 %~protocol値, 文字列 %種別 ) に対し： ◎ To process pathname for init given a string pathnameValue, a string protocolValue, and a string type:

1. ~IF［ %種別 ~EQ `pattern^l ］ ⇒ ~RET %~pathname値 ◎ If type is "pattern" then return pathnameValue.

2. ~IF［ %~protocol値 は`特別~scheme$である ］~OR［ %~protocol値 ~EQ 空~文字列 ］ ⇒ ~RET `~pathnameを正準-化する$( %~pathname値 ) ◎ If protocolValue is a special scheme or the empty string, then return the result of running canonicalize a pathname given pathnameValue.

   注記： ［ %~protocol値 ~EQ 空~文字列 ］の場合、 構築子に渡された辞書には `protocol$upI 用の値は供されなかったことになる。 通常は，空~文字列をとる辞書~値は特別に扱われないが、 この事例では，［ 最も共通的な~pathnameの正準-化を既定とする ］ために，それを`特別~scheme$と同じに扱う。 ◎ If the protocolValue is the empty string then no value was provided for protocol in the constructor dictionary. Normally we do not special case empty string dictionary values, but in this case we treat it as a special scheme in order to default to the most common pathname canonicalization.

3. ~RET `不透明な~pathnameを正準-化する$( %~pathname値 ) ◎ Return the result of running canonicalize an opaque pathname given pathnameValue.

`~init用に~searchを処理する@ ときは、 所与の ( 文字列 %値, 文字列 %種別 ) に対し： ◎ To process search for init given a string value and a string type:

1. ~IF［ %値 を成す最初の`文字$ ~EQ `003F^U ］ ⇒ %値 ~SET %値 の中の 1 から`終端までを成す符号位置~部分文字列$ ◎ Let strippedValue be the given value with a single leading U+003F (?) removed, if any.
2. ~RET %種別 に応じて ⇒＃ `pattern^l ならば %値 ／ ~ELSE_ `~searchを正準-化する$( %値 ) ◎ If type is "pattern" then return strippedValue. ◎ Return the result of running canonicalize a search given strippedValue.

`~init用に~hashを処理する@ ときは、 所与の ( 文字列 %値, 文字列 %種別 ) に対し： ◎ To process hash for init given a string value and a string type:

1. ~IF［ %値 を成す最初の文字 ~EQ `0023^U ］ ⇒ %値 ~SET %値 の中の 1 から`終端までを成す符号位置~部分文字列$ ◎ Let strippedValue be the given value with a single leading U+0023 (#) removed, if any.
2. ~RET %種別 に応じて ⇒＃ `pattern^l ならば %値 ／ ~ELSE_ `~hashを正準-化する$( %値 ) ◎ If type is "pattern" then return strippedValue. ◎ Return the result of running canonicalize a hash given strippedValue.

`~Web~IDL値から~URLPattern~objを築く@ ときは、 所与の ( `URLPatternCompatible$I %入力, `~URL~record$ %基底~URL, `~realm$ %~realm ) に対し，次の手続きを遂行する： ◎ To build a URLPattern object from a Web IDL value URLPatternCompatible input given URL baseURL and realm realm, perform the following steps:

1. ~IF［ %入力 の`特有~型$ ~EQ `URLPattern$I ］ ⇒ ~RET %入力 ◎ If the specific type of input is URLPattern: • Return input. ◎ Otherwise:
2. %~pattern ~LET `新たな~obj$( `URLPattern$I, %~realm ) ◎ Let pattern be a new URLPattern with realm.
3. %~pattern に`結付けられた~URL~pattern$ ~SET `~Web~IDL値から~URL~patternを築く$( %入力, %基底~URL ) ◎ Set pattern’s associated URL pattern to the result of building a URL pattern from a Web IDL value given input and baseURL.
4. ~RET %~pattern ◎ Return pattern.

`~Web~IDL値から~URL~patternを築く@ ときは、 所与の ( `URLPatternCompatible$I %入力, `~URL~record$ %基底~URL ) に対し， 次の手続きを遂行する： ◎ To build a URL pattern from a Web IDL value URLPatternCompatible input given URL baseURL, perform the following steps:

1. %型 ~LET %入力 の`特有~型$ ◎ ↓
2. ~IF［ %型 ~EQ `URLPattern$I ］ ⇒ ~RET %入力 に`結付けられた~URL~pattern$ ◎ If the specific type of input is URLPattern: • Return input’s associated URL pattern.
3. %基底~URL文字列 ~LET `~URLを直列化する$( %基底~URL ) ◎ ↓

4. ~IF［ %型 ~EQ `URLPatternInit$I ］： ◎ Otherwise, if the specific type of input is URLPatternInit:

   1. %~init ~LET %入力 を`~cloneする$map ◎ Let init be a clone of input.
   2. ~IF［ %~init[ "`baseURL$upI" ] ~EQ ε ］ ⇒ %~init[ "`baseURL$upI" ] ~SET %基底~URL文字列 ◎ If init["baseURL"] does not exist, set it to the serialization of baseURL.
   3. ~RET `~URL~patternを作成する$( %~init, ~NULL, 新たな`~map$ ) ◎ Return the result of creating a URL pattern given init, null, and an empty map.
5. ~Assert： %型 ~EQ `USVString$I ◎ Otherwise: ◎ • Assert: The specific type of input is USVString.
6. ~RET `~URL~patternを作成する$( %入力, %基底~URL文字列, 新たな`~map$ ) ◎ Return the result of creating a URL pattern given input, the serialization of baseURL, and an empty map.

`~Infra値から~URL~patternを築く@ ときは、 所与の ( ~Infra値 %生な~pattern, `~URL~record$ %基底~URL ) に対し， 次の手続きを遂行する： ◎ To build a URL pattern from an Infra value rawPattern given URL baseURL, perform the following steps.

1. %直列化-済み基底~URL ~LET `~URLを直列化する$( %基底~URL ) ◎ Let serializedBaseURL be the serialization of baseURL.

2. ~IF［ %生な~pattern は`文字列$である ］ ⇒ ~RET `~URL~patternを作成する$( %生な~pattern, %直列化-済み基底~URL, 新たな`~map$ ) ◎ If rawPattern is a string, then: • Return the result of creating a URL pattern given rawPattern, serializedBaseURL, and an empty map.

   注記： 将来には、 ここで，空でない~option群を `plumb^en する【？】ことが必要yあるかもしれない。 ◎ • It might become necessary in the future to plumb non-empty options here.

3. ~ELIF［ %生な~pattern は`~map$である ］： ◎ Otherwise, if rawPattern is a map, then:

   1. %~init ~LET «[ "`baseURL$upI" → %直列化-済み基底~URL ] » （ `URLPatternInit$I 型の辞書を表現する~map） ◎ Let init be «[ "baseURL" → serializedBaseURL ]», representing a dictionary of type URLPatternInit.

   2. %生な~pattern を成す ~EACH( %~key → %値 ) に対し： ◎ For each key → value of rawPattern:

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

         • %値 は`文字列$である

         • ［ `URLPatternInit$I, およびそれが`継承した辞書~群$ ］を成す辞書として［ ~AND↓ を満たす`辞書~member$ ］を有するものが在る：

           • その`識別子$ ~EQ %~key
           • それに宣言された型は `USVString$I である

         …ならば ⇒ ~RET ~NULL

         ◎ If key is not the identifier of a dictionary member of URLPatternInit or one of its inherited dictionaries, value is not a string, or the member’s type is not declared to be USVString, then return null.

         注記： 最後に挙げた条件は、 `URLPatternInit$I に他の型の~memberが加わった場合には，更新する必要がある。 ◎ This will need to be updated if URLPatternInit gains members of other types.

         注記： この仕様の将来の~versionは、 より厳密でない~modeも有するかもしれない — それが，他の仕様に有用になるものと立証されたなら。 ◎ A future version of this specification might also have a less strict mode, if that proves useful to other specifications.

      2. %~init[ %~key ] ~SET %値 ◎ Set init[key] to value.

   3. ~RET `~URL~patternを作成する$( %~init, ~NULL, 新たな`~map$ ) ◎ Return the result of creating a URL pattern given init, null, and an empty map.

      注記： 将来には、 ここで，空でない~option群を `plumb^en する【？】ことが必要yあるかもしれない。 ◎ • It might become necessary in the future to plumb non-empty options here.

4. ~RET ~NULL ◎ Otherwise, return null.

`~HTTP有構造~field値から~URL~patternを築く@ ときは、 所与の ( 有構造~field値 %生な~pattern `~URL~record$ %基底~URL ) に対し： ◎ To build a URL pattern from an HTTP structured field value rawPattern given URL baseURL:

1. %直列化-済み基底~URL ~LET `~URLを直列化する$( %基底~URL ) ◎ Let serializedBaseURL be the serialization of baseURL.
2. ~Assert： %生な~pattern は`~sf文字列$である。 ◎ Assert: rawPattern is a string.
3. ~RET `~URL~patternを作成する$( %生な~pattern, %直列化-済み基底~URL, 新たな`~map$ ) ◎ Return the result of creating a URL pattern given rawPattern, serializedBaseURL, and an empty map.