URL

To percent-encode a byte byte, return a string consisting of U+0025 (%), followed by two ASCII upper hex digits representing byte.

To percent-decode a byte sequence input, run these steps:

Using anything but UTF-8 decode without BOM when input contains bytes that are not ASCII bytes might be insecure and is not recommended.

1. Let output be an empty byte sequence.

2. For each byte byte in input:

   1. If byte is not 0x25 (%), then append byte to output.

   2. Otherwise, if byte is 0x25 (%) and the next two bytes after byte in input are not in the ranges 0x30 (0) to 0x39 (9), 0x41 (A) to 0x46 (F), and 0x61 (a) to 0x66 (f), all inclusive, append byte to output.

   3. Otherwise:

      1. Let bytePoint be the two bytes after byte in input, decoded, and then interpreted as hexadecimal number.

      2. Append a byte whose value is bytePoint to output.

      3. Skip the next two bytes in input.

3. Return output.

To percent-decode a scalar value string input:

1. Let bytes be the UTF-8 encoding of input.

2. Return the percent-decoding of bytes.

In general, percent-encoding results in a string with more U+0025 (%) code points than the input, and percent-decoding results in a byte sequence with less 0x25 (%) bytes than the input.

To percent-encode after encoding, given an encoding encoding, scalar value string input, a percentEncodeSet, and an optional boolean spaceAsPlus (default false):

1. Let encoder be the result of getting an encoder from encoding.

2. Let inputQueue be input converted to an I/O queue.

3. Let output be the empty string.

4. Let potentialError be 0.

   This needs to be a non-null value to initiate the subsequent while loop.

5. While potentialError is non-null:

   1. Let encodeOutput be an empty I/O queue.

   2. Set potentialError to the result of running encode or fail with inputQueue, encoder, and encodeOutput.

   3. For each byte of encodeOutput converted to a byte sequence:

      1. If spaceAsPlus is true and byte is 0x20 (SP), then append U+002B (+) to output and continue.

      2. Let isomorph be a code point whose value is byte’s value.

      3. Assert: percentEncodeSet includes all non-ASCII code points.

      4. If isomorph is not in percentEncodeSet, then append isomorph to output.

      5. Otherwise, percent-encode byte and append the result to output.

   4. If potentialError is non-null, then append "%26%23", followed by the shortest sequence of ASCII digits representing potentialError in base ten, followed by "%3B", to output.

      This can happen when encoding is not UTF-8.

6. Return output.

Of the possible values for the percentEncodeSet argument only two end up encoding U+0025 (%) and thus give “roundtripable data”: component percent-encode set and application/x-www-form-urlencoded percent-encode set. The other values for the percentEncodeSet argument — which happen to be used by the URL parser — leave U+0025 (%) untouched and as such it needs to be percent-encoded first in order to be properly represented.

To UTF-8 percent-encode a scalar value scalarValue using a percentEncodeSet, return the result of running percent-encode after encoding with UTF-8, scalarValue as a string, and percentEncodeSet.

To UTF-8 percent-encode a scalar value string input using a percentEncodeSet, return the result of running percent-encode after encoding with UTF-8, input, and percentEncodeSet.

To obtain the public suffix of a host host, run these steps. They return null or a domain representing a portion of host that is included on the Public Suffix List. [PSL]

1. If host is not a domain, then return null.

2. Let trailingDot be "." if host ends with "."; otherwise the empty string.

3. Let publicSuffix be the public suffix determined by running the Public Suffix List algorithm with host as domain. [PSL]

4. Assert: publicSuffix is an ASCII string that does not end with ".".

5. Return publicSuffix and trailingDot concatenated.

To obtain the registrable domain of a host host, run these steps. They return null or a domain formed by host’s public suffix and the domain label preceding it, if any.

1. If host’s public suffix is null or host’s public suffix equals host, then return null.

2. Let trailingDot be "." if host ends with "."; otherwise the empty string.

3. Let registrableDomain be the registrable domain determined by running the Public Suffix List algorithm with host as domain. [PSL]

4. Assert: registrableDomain is an ASCII string that does not end with ".".

5. Return registrableDomain and trailingDot concatenated.

The domain to ASCII algorithm, given a string domain and a boolean beStrict, runs these steps:

1. Let result be the result of running Unicode ToASCII with domain_name set to domain, CheckHyphens set to beStrict, CheckBidi set to true, CheckJoiners set to true, UseSTD3ASCIIRules set to beStrict, Transitional_Processing set to false, VerifyDnsLength set to beStrict, and IgnoreInvalidPunycode set to false. [UTS46]

   If beStrict is false, domain is an ASCII string, and strictly splitting domain on U+002E (.) does not produce any item that starts with an ASCII case-insensitive match for "xn--", this step is equivalent to ASCII lowercasing domain.

2. If result is a failure value, domain-to-ASCII validation error, return failure.

3. If beStrict is false:

   1. If result is the empty string, domain-to-ASCII validation error, return failure.

   2. If result contains a forbidden domain code point, domain-invalid-code-point validation error, return failure.

      Due to web compatibility and compatibility with non-DNS-based systems the forbidden domain code points are a subset of those disallowed when UseSTD3ASCIIRules is true. See also issue #397.

4. Assert: result is not the empty string and does not contain a forbidden domain code point.

   Unicode IDNA Compatibility Processing guarantees this holds when beStrict is true. [UTS46]

5. Return result.

This document and the web platform at large use Unicode IDNA Compatibility Processing and not IDNA2008. For instance, ☕.example becomes xn--53h.example and not failure. [UTS46] [RFC5890]

The domain to Unicode algorithm, given a domain domain and a boolean beStrict, runs these steps:

1. Let result be the result of running Unicode ToUnicode with domain_name set to domain, CheckHyphens set to beStrict, CheckBidi set to true, CheckJoiners set to true, UseSTD3ASCIIRules set to beStrict, Transitional_Processing set to false, and IgnoreInvalidPunycode set to false. [UTS46]

2. Signify domain-to-Unicode validation errors for any returned errors, and then, return result.

The host parser takes a scalar value string input with an optional boolean isOpaque (default false), and then runs these steps. They return failure or a host.

1. If input starts with U+005B ([), then:

   1. If input does not end with U+005D (]), IPv6-unclosed validation error, return failure.

   2. Return the result of IPv6 parsing input with its leading U+005B ([) and trailing U+005D (]) removed.

2. If isOpaque is true, then return the result of opaque-host parsing input.

3. Assert: input is not the empty string.

4. Let domain be the result of running UTF-8 decode without BOM on the percent-decoding of input.

   Alternatively UTF-8 decode without BOM or fail can be used, coupled with an early return for failure, as domain to ASCII fails on U+FFFD (�).

5. Let asciiDomain be the result of running domain to ASCII with domain and false.

6. If asciiDomain is failure, then return failure.

7. If asciiDomain ends in a number, then return the result of IPv4 parsing asciiDomain.

8. Return asciiDomain.

The ends in a number checker takes an ASCII string input and then runs these steps. They return a boolean.

1. Let parts be the result of strictly splitting input on U+002E (.).

2. If the last item in parts is the empty string, then:

   1. If parts’s size is 1, then return false.

   2. Remove the last item from parts.

3. Let last be the last item in parts.

4. If last is non-empty and contains only ASCII digits, then return true.

   The erroneous input "09" will be caught by the IPv4 parser at a later stage.

5. If parsing last as an IPv4 number does not return failure, then return true.

   This is equivalent to checking that last is "0X" or "0x", followed by zero or more ASCII hex digits.

6. Return false.

The IPv4 parser takes an ASCII string input and then runs these steps. They return failure or an IPv4 address.

The IPv4 parser is not to be invoked directly. Instead check that the return value of the host parser is an IPv4 address.

1. Let parts be the result of strictly splitting input on U+002E (.).

2. If the last item in parts is the empty string, then:

   1. IPv4-empty-part validation error.

   2. If parts’s size is greater than 1, then remove the last item from parts.

3. If parts’s size is greater than 4, IPv4-too-many-parts validation error, return failure.

4. Let numbers be an empty list.