@coroboros/uri 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1665 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_url = require("node:url");
+//#region src/config/index.ts
+/**
+* config module
+*/
+const maxLengthURL = 2048;
+const maxPortInteger = 65535;
+//#endregion
+//#region src/helpers/object.ts
+/**
+* Internal type guards.
+*
+* - exists(thing) -> boolean
+* - is(Type, thing) -> boolean
+*/
+/**
+* Whether the specified value is not null, undefined or NaN.
+*/
+const exists = function exists(thing) {
+	return !(thing === void 0 || thing === null || Number.isNaN(thing));
+};
+function is(Type, thing) {
+	return exists(Type) && exists(thing) && (thing.constructor === Type || thing instanceof Type);
+}
+//#endregion
+//#region src/checkers/chars.ts
+/**
+* chars checkers
+*
+* - isSchemeChar(char, { start } = {}) -> Boolean
+* - isUserinfoChar(char, encode) -> Boolean
+* - isSitemapUserinfoChar(char, encode) -> Boolean
+* - isDomainChar(char, { start, end } = {}) -> Boolean
+* - isPathChar(char, encode) -> Boolean
+* - isSitemapPathChar(char, encode) -> Boolean
+* - isQueryOrFragmentChar(char, encode) -> Boolean
+* - isSitemapQueryOrFragmentChar(char, encode) -> Boolean
+* - isPercentEncodingChar(char) -> Boolean
+*/
+/**
+* @func isSchemeChar
+*
+* Check scheme legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.1.
+*
+* Scheme must start with a letter and be followed by any combination of
+* letters, digits, plus ("+"), period ("."), or hyphen ("-").
+*
+* Letters must be in lowercase.
+*
+* 43             +
+* 45             -
+* 46             .
+* 48 to 57       0-9
+* 97 to 122      a-z
+*/
+const isSchemeChar = function isSchemeChar(char, { start } = {}) {
+	if (!is(String, char)) return false;
+	const code = char.charCodeAt(0);
+	if (start) return code >= 97 && code <= 122;
+	return code >= 48 && code <= 57 || code >= 97 && code <= 122 || code === 43 || code === 45 || code === 46;
+};
+/**
+* @func isUserinfoChar
+*
+* Check userinfo legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.2.1.
+*
+* 33             !
+* 36             $
+* 37             % (not allowed when encoding)
+* 38 to 46       &'()*+,-.
+* 48 to 57       0-9
+* 58             :
+* 59             ;
+* 61             =
+* 65 to 90       A-Z
+* 95             _
+* 97 to 122      a-z
+* 126            ~
+*/
+const isUserinfoChar = function isUserinfoChar(char, encode) {
+	if (!is(String, char)) return false;
+	const encoding = encode === true;
+	const code = char.charCodeAt(0);
+	if (code === 37) return !encoding;
+	return code >= 38 && code <= 46 || code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 33 || code === 36 || code === 58 || code === 59 || code === 61 || code === 95 || code === 126;
+};
+/**
+* @func isSitemapUserinfoChar
+*
+* Check sitemap userinfo legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.2.1;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*
+* Removed AZ ' and *
+*
+* 33             !
+* 36             $
+* 37             % (not allowed when encoding)
+* 38             & (allowed but must be a proper escape code)
+* 40 to 41       ()
+* 43 to 46       +,-.
+* 48 to 57       0-9
+* 58             :
+* 59             ;
+* 61             =
+* 95             _
+* 97 to 122      a-z
+* 126            ~
+*/
+const isSitemapUserinfoChar = function isSitemapUserinfoChar(char, encode) {
+	if (!is(String, char)) return false;
+	const encoding = encode === true;
+	const code = char.charCodeAt(0);
+	if (code === 37) return !encoding;
+	return code >= 40 && code <= 41 || code >= 43 && code <= 46 || code >= 48 && code <= 57 || code >= 97 && code <= 122 || code === 33 || code === 36 || code === 38 || code === 58 || code === 59 || code === 61 || code === 95 || code === 126;
+};
+/**
+* @func isDomainChar
+*
+* Check domain legal codes according to
+* - RFC-1034 https://www.ietf.org/rfc/rfc1034.txt.
+*
+* 45             -
+* 48 to 57       0-9
+* 97 to 122      a-z
+*/
+const isDomainChar = function isDomainChar(char, { start, end } = {}) {
+	if (!is(String, char)) return false;
+	const code = char.charCodeAt(0);
+	if ((start === true || end === true) && code === 45) return false;
+	return code >= 48 && code <= 57 || code >= 97 && code <= 122 || code === 45;
+};
+/**
+* @func isPathChar
+*
+* Check path legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.3.
+*
+* 33             !
+* 36 to 59       $%&'()*+,-./0-9:;
+* 61             =
+* 64 to 90       @A-Z
+* 95             _
+* 97 to 122      a-z
+* 126            ~
+*/
+const isPathChar = function isPathChar(char, encode) {
+	if (!is(String, char)) return false;
+	const encoding = encode === true;
+	const code = char.charCodeAt(0);
+	if (code === 37) return !encoding;
+	return code >= 36 && code <= 59 || code >= 64 && code <= 90 || code >= 97 && code <= 122 || code === 33 || code === 61 || code === 95 || code === 126;
+};
+/**
+* @func isSitemapPathChar
+*
+* Check path legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.3.
+*
+* Removed AZ ' and *
+*
+* 33             !
+* 36 to 38       $%& (& allowed but must be a proper escape code)
+* 40 to 41       ()
+* 43 to 59       +,-./0-9:;
+* 61             =
+* 64             @
+* 95             _
+* 97 to 122      a-z
+* 126            ~
+*/
+const isSitemapPathChar = function isSitemapPathChar(char, encode) {
+	if (!is(String, char)) return false;
+	const encoding = encode === true;
+	const code = char.charCodeAt(0);
+	if (code === 37) return !encoding;
+	return code >= 36 && code <= 38 || code >= 40 && code <= 41 || code >= 43 && code <= 59 || code >= 97 && code <= 122 || code === 33 || code === 61 || code === 64 || code === 95 || code === 126;
+};
+/**
+* @func isQueryOrFragmentChar
+*
+* Check query/fragment legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.4;
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.5.
+*
+* path char
+* 63             ?
+*/
+const isQueryOrFragmentChar = function isQueryOrFragmentChar(char, encode) {
+	if (isPathChar(char, encode)) return true;
+	return is(String, char) && char.charCodeAt(0) === 63;
+};
+/**
+* @func isSitemapQueryOrFragmentChar
+*
+* Check query/fragment legal ascii codes according to
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.4;
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.5.
+*
+* sitemap path char
+* 63             ?
+*/
+const isSitemapQueryOrFragmentChar = function isSitemapQueryOrFragmentChar(char, encode) {
+	if (isSitemapPathChar(char, encode)) return true;
+	return is(String, char) && char.charCodeAt(0) === 63;
+};
+/**
+* @func isPercentEncodingChar
+*
+* Check percent encoding legal ascii codes according to RFC-3986 https://tools.ietf.org/html/rfc3986#section-2.1.
+*
+* HEXDIG is case-insensitive: %3a and %3A are equivalent
+* (RFC-3986 https://tools.ietf.org/html/rfc3986#section-6.2.2.1).
+*
+* 48 to 57       0-9
+* 65 to 70       A-F
+* 97 to 102      a-f
+*/
+const isPercentEncodingChar = function isPercentEncodingChar(char) {
+	if (!is(String, char)) return false;
+	const code = char.charCodeAt(0);
+	return code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
+};
+//#endregion
+//#region src/ip/index.ts
+/**
+* IP validator
+*
+* - isIP(ip) -> Boolean
+* - isIPv4(ip) -> Boolean
+* - isIPv6(ip) -> Boolean
+*/
+const v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+const v6seg = "[a-fA-F\\d]{1,4}";
+const v6 = `
+(
+(?:${v6seg}:){7}(?:${v6seg}|:)|                                // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|                         // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6seg}:){5}(?::${v4}|(:${v6seg}){1,2}|:)|                 // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6seg}:){4}(?:(:${v6seg}){0,1}:${v4}|(:${v6seg}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6seg}:){3}(?:(:${v6seg}){0,2}:${v4}|(:${v6seg}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6seg}:){2}(?:(:${v6seg}){0,3}:${v4}|(:${v6seg}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6seg}:){1}(?:(:${v6seg}){0,4}:${v4}|(:${v6seg}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::((?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))           // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(%[0-9a-zA-Z]{1,})?                                           // %eth0            %1
+`.replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
+const ipv4Regexp = new RegExp(`^${v4}$`);
+const ipv6Regexp$1 = new RegExp(`^${v6}$`);
+const ipRegexp = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+/**
+* @func isIP
+*
+* Test a string is a valid IP.
+*/
+const isIP = function isIP(ip) {
+	if (!is(String, ip)) return false;
+	return ipRegexp.test(ip);
+};
+/**
+* @func isIPv4
+*
+* Test a string is a valid IPv4.
+*/
+const isIPv4 = function isIPv4(ip) {
+	if (!is(String, ip)) return false;
+	return ipv4Regexp.test(ip);
+};
+/**
+* @func isIPv6
+*
+* Test a string is a valid IPv6.
+*/
+const isIPv6 = function isIPv6(ip) {
+	if (!is(String, ip)) return false;
+	return ipv6Regexp$1.test(ip);
+};
+//#endregion
+//#region src/punycode/index.ts
+/**
+* punycode and punydecode
+*
+* - punycode(domain) -> String
+* - punydecode(domain) -> String
+*/
+/**
+* @func punycode
+*
+* Returns the Punycode ASCII serialization of the domain.
+* If domain is an invalid domain, the empty string is returned.
+*
+* Note:
+* - native function url.domainToASCII does not support IPv6 only IPv4;
+* - native function url.domainToASCII throws if no domain is provided or returns
+*   `null`, `undefined`, `nan` for `null`, `undefined` or `NaN` values which is
+*   not what to be expected.
+*/
+const punycode = function punycode(domain) {
+	if (isIPv6(domain)) return domain;
+	return is(String, domain) ? (0, node_url.domainToASCII)(domain) : "";
+};
+/**
+* @func punydecode
+*
+* Returns the Unicode serialization of the domain.
+* If domain is an invalid domain, the empty string is returned.
+*
+* Note:
+* - native function url.domainToUnicode does not support IPv6 only IPv4;
+* - native function url.domainToUnicode throws if no domain is provided or returns
+*   `null`, `undefined`, `nan` for `null`, `undefined` or `NaN` values which is
+*   not what to be expected.
+*/
+const punydecode = function punydecode(domain) {
+	if (isIPv6(domain)) return domain;
+	return is(String, domain) ? (0, node_url.domainToUnicode)(domain) : "";
+};
+//#endregion
+//#region src/domain/index.ts
+/**
+* domain
+*
+* - isDomainLabel(label) -> Boolean
+* - isDomain(name) -> Boolean
+*/
+/**
+* @func isDomainLabel
+*
+* Test a label is a valid domain label according to RFC-1034.
+*
+* "Note that while upper and lower case letters are allowed in domain names,
+* no significance is attached to the case.  That is, two names with the same
+* spelling but different case are to be treated as if identical."
+*
+* By convention uppercased domain label will be considered invalid.
+*
+* Rules:
+* 1. "Labels must be 63 characters or less.";
+* 2. can be minimum one character;
+* 3. must only use lowercase letters, digits or hyphens;
+* 4. must not start or end with a hyphen;
+* 5. must not have consecutive hyphens;
+* 6. can start or end with a digit.
+*
+* Based on:
+* - RFC-1034 https://www.ietf.org/rfc/rfc1034.txt.
+*/
+const isDomainLabel = function isDomainLabel(label) {
+	if (!is(String, label)) return false;
+	const len = label.length;
+	if (len < 1 || len > 63) return false;
+	for (let i = 0; i < len; i += 1) {
+		if (!isDomainChar(label.charAt(i), {
+			start: i === 0,
+			end: i === len - 1
+		})) return false;
+		if (label.charAt(i) === "-" && i + 1 < len && label.charAt(i + 1) === "-") return false;
+	}
+	return true;
+};
+/**
+* @func isDomain
+*
+* Test a name is a valid domain according to RFC-1034.
+*
+* Supports Fully-Qualified Domain Name (FQDN) and Internationalized Domain Name (IDN).
+*
+* Rules:
+* 1. labels rules apply;
+* 2. "[...] the total number of octets that represent a domain name
+*   (i.e., the sum of all label octets and label lengths) is limited to 255.";
+* 3. labels are separated by dots (".");
+* 4. must have at least one extension label;
+* 5. must have labels different from each other;
+* 6. last label can be empty (root label ".");
+* 7. labels can start with `xn--` for IDNs if the ASCII serialization is a valid Punycode;
+* 8. check also Punycodes as ॐ gives xn--'-6xd where ' is not valid.
+*
+* Based on:
+* - RFC-1034 https://www.ietf.org/rfc/rfc1034.txt.
+*/
+const isDomain = function isDomain(name) {
+	if (!is(String, name)) return false;
+	const domain = punycode(name);
+	if (domain === "localhost") return true;
+	const len = domain.length;
+	if (len <= 0 || len > 255) return false;
+	const labels = domain.split(".");
+	const labelsLen = labels.length;
+	if (labelsLen <= 1) return false;
+	const occurences = {};
+	for (const [i, current] of labels.entries()) if (!(i === labelsLen - 1 && current === "")) {
+		if (!isDomainLabel(current.startsWith("xn--") ? current.slice(4) : current)) return false;
+		occurences[current] = (occurences[current] || 0) + 1;
+		if (occurences[current] > 1) return false;
+	}
+	return true;
+};
+//#endregion
+//#region src/helpers/cast.ts
+/**
+* Type casting helpers.
+*
+* Cast a value to a specific primitive type. If the value is
+* not of this type or can not be infer from this type, undefined is returned.
+*
+* undefined is an interesting value. When stringifying an object, an undefined property
+* disappears. Useful to respect data type schemas and where null values are not allowed.
+*
+*    - num(thing, { le, ge } = {}) -> Number or undefined
+*    - int(thing, { le, ge } = {}) -> Integer Number or undefined
+*/
+/**
+* @func number
+*
+* cast to primitive number if possible or returns undefined
+* because Number(null) returns 0 and Number(undefined|NaN) returns NaN
+* beware to call Number.isFinite only on number values
+* NOTE: only finite values
+*/
+const number = function number(thing) {
+	let castNum;
+	if (exists(thing)) {
+		const value = thing.valueOf();
+		if (is(Number, value)) {
+			if (Number.isFinite(value)) castNum = value;
+		} else if (is(String, value) || is(Boolean, value)) {
+			const cast = Number(value);
+			if (Number.isFinite(cast)) castNum = cast;
+		}
+	}
+	return castNum;
+};
+/**
+* @func integer
+*
+* cast to primitive integer number if possible or returns undefined
+* NOTE: based on "number" function, in base 10 only
+*/
+const integer = function integer(thing) {
+	const castNum = number(thing);
+	let castInt;
+	if (castNum !== void 0) {
+		const int = parseInt(String(castNum), 10);
+		/* v8 ignore next -- unreachable: parseInt of a finite number's String is never NaN */
+		if (!Number.isNaN(int)) castInt = int;
+	}
+	return castInt;
+};
+/**
+* @func int
+*
+* cast to primitive integer number, with 'less or equal than'
+* or 'greater or equal than' options, or returns undefined
+* NOTE: based on "integer" function, in base 10 only
+*/
+const int = function int(thing, { ge, le } = {}) {
+	let castInt = integer(thing);
+	if (castInt !== void 0) {
+		const lessThan = integer(le);
+		const greaterThan = integer(ge);
+		if (lessThan !== void 0 && greaterThan !== void 0) {
+			if (castInt < greaterThan || castInt > lessThan) castInt = void 0;
+		} else if (lessThan !== void 0 && castInt > lessThan) castInt = void 0;
+		else if (greaterThan !== void 0 && castInt < greaterThan) castInt = void 0;
+	}
+	return castInt;
+};
+/**
+* @func isPort
+*
+* RFC-3986 §3.2.3: port = *DIGIT. True if the value is absent
+* (null/undefined) or a possibly empty string of ASCII digits.
+* The numeric range is validated separately by `int`.
+*
+* Rejects JS Number coercion artefacts (hex `0x1F`, scientific `1e3`,
+* whitespace) that `Number()` would otherwise accept.
+*/
+const isPort = function isPort(thing) {
+	return thing === null || thing === void 0 || /^[0-9]*$/.test(String(thing));
+};
+//#endregion
+//#region src/helpers/error.ts
+/**
+* @func fail
+*
+* Throw a URIError carrying a stable `code` string. The thrown value is
+* always `instanceof URIError`.
+*/
+const fail = function fail(code, message) {
+	const error = new URIError(message);
+	error.code = code;
+	throw error;
+};
+//#endregion
+//#region src/parser/index.ts
+/**
+* parser
+*
+* - hostToURI(host) -> String
+* - recomposeURI({ scheme, userinfo, host port, path, query, fragment } = {}) -> String
+* - parseURI(uri) -> Object
+*/
+const uriRegexp = /^(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/;
+const ipv6Regexp = /^(?:\[([^\]]+)\]:?)([0-9]+)?$/;
+/**
+* @func hostToURI
+*
+* Format host with special [] for IPv6. The empty string is returned if host
+* is not a string.
+*/
+const hostToURI = function hostToURI(host) {
+	if (!is(String, host)) return "";
+	return isIPv6(host) ? `[${host}]` : host;
+};
+/**
+* @func recomposeURI
+*
+* Recompose an URI from its components with basic URI checking.
+*
+* The empty string is returned if unable to recompose the URI.
+*
+* Rules:
+* 1. scheme is required and must be at least 1 character;
+* 2. path is required and can be empty;
+* 3. if host is present path must be empty or start with /;
+* 4. if host is not present path must not start with //;
+* 5. host, if any, must be at least 3 characters;
+* 6. userinfo will be ignored if empty;
+* 7. port will be ignored if empty or not an integer;
+* 8. query is emitted when defined (a string, including ''); a null
+*    or undefined query is omitted (RFC-3986 §5.3);
+* 9. fragment is emitted when defined (a string, including ''); a null
+*    or undefined fragment is omitted (RFC-3986 §5.3).
+*
+* Support:
+* - IPv4 and IPv6.
+*
+* Note:
+* / is added to any URI with a host and an empty path.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986.
+*/
+const recomposeURI = function recomposeURI(components) {
+	const cpts = components || {};
+	const defaultReturnValue = "";
+	const { scheme, userinfo, host, port, path, query, fragment } = cpts;
+	if (!(is(String, scheme) && scheme.length > 0) || !is(String, path)) return defaultReturnValue;
+	let uri = scheme;
+	if (is(String, host)) {
+		if (!(path === "" || path.startsWith("/"))) return defaultReturnValue;
+		if (host.length <= 2) return defaultReturnValue;
+		uri += "://";
+		if (is(String, userinfo) && userinfo.length > 0) uri += `${userinfo}@`;
+		uri += hostToURI(host);
+		if (exists(port) && isPort(port) && int(port, {
+			ge: 0,
+			le: 65535
+		}) !== void 0) uri += `:${port}`;
+	} else {
+		if (path.startsWith("//")) return defaultReturnValue;
+		uri += ":";
+	}
+	if (path === "" && is(String, host)) uri += "/";
+	else uri += path;
+	if (is(String, query)) uri += `?${query}`;
+	if (is(String, fragment)) uri += `#${fragment}`;
+	return uri;
+};
+/**
+* @func parseURI
+*
+* Parse a string to get URI components.
+*
+* Support:
+* - IPv4 and IPv6 hosts;
+* - Internationalized Domain Name (IDN).
+*
+* Note:
+* - RegExp from RFC-3986 https://tools.ietf.org/html/rfc3986#appendix-B;
+* - scheme and host strings will always be put in lowercase once parsed,
+*   as specified in RFC-3986;
+* - authority and its components will be put at null values if authority
+*   parsed is missing or empty.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986.
+*/
+const parseURI = function parseURI(uri) {
+	const parsed = {
+		scheme: null,
+		authority: null,
+		authorityPunydecoded: null,
+		userinfo: null,
+		host: null,
+		hostPunydecoded: null,
+		port: null,
+		path: null,
+		pathqf: null,
+		query: null,
+		fragment: null,
+		href: null
+	};
+	if (!(is(String, uri) && uri.length > 0)) return parsed;
+	/* v8 ignore next -- unreachable []: the all-optional Appendix-B regexp always matches a non-empty string */
+	const [, scheme, authorityParsed, path, queryParsed, fragmentParsed] = uri.match(uriRegexp) ?? [];
+	if (!(is(String, scheme) && scheme.length > 0)) return parsed;
+	let authority = null;
+	let authorityPunydecoded = null;
+	let userinfo = null;
+	let host = null;
+	let hostPunydecoded = null;
+	let port = null;
+	if (is(String, authorityParsed)) {
+		let hostAndPort = null;
+		const userinfoEnd = authorityParsed.lastIndexOf("@");
+		if (userinfoEnd === -1) hostAndPort = authorityParsed;
+		else {
+			userinfo = authorityParsed.slice(0, userinfoEnd);
+			hostAndPort = authorityParsed.slice(userinfoEnd + 1);
+		}
+		/* v8 ignore next -- unreachable false branch: hostAndPort is always an assigned string after the authority split */
+		if (is(String, hostAndPort)) {
+			const ipv6Match = hostAndPort.match(ipv6Regexp);
+			let hostParsed = null;
+			let portToCast = null;
+			if (Array.isArray(ipv6Match)) [, hostParsed = null, portToCast = null] = ipv6Match;
+			else {
+				const portStart = hostAndPort.lastIndexOf(":");
+				if (portStart === -1) hostParsed = hostAndPort;
+				else {
+					hostParsed = hostAndPort.slice(0, portStart);
+					portToCast = hostAndPort.slice(portStart + 1);
+				}
+			}
+			/* v8 ignore start -- unreachable null branch: the ipv6 regexp's required capture means hostParsed is always a string here */
+			const hostLowerCase = is(String, hostParsed) ? hostParsed.toLowerCase() : null;
+			const toASCII = punycode(hostLowerCase ?? "");
+			const toUnicode = punydecode(hostLowerCase ?? "");
+			/* v8 ignore stop */
+			if (hostLowerCase !== toASCII) {
+				host = toASCII;
+				hostPunydecoded = hostLowerCase;
+			} else if (hostLowerCase !== toUnicode) {
+				host = hostLowerCase;
+				hostPunydecoded = toUnicode;
+			} else {
+				host = hostLowerCase;
+				hostPunydecoded = hostLowerCase;
+			}
+			if (host === "" || hostPunydecoded === "") host = null;
+			port = is(String, portToCast) && portToCast.length > 0 && !isPort(portToCast) ? portToCast : int(portToCast) || portToCast;
+			/* v8 ignore next -- unreachable false branch: hostPunydecoded is always an assigned string in this block */
+			if (exists(hostPunydecoded)) {
+				authorityPunydecoded = "";
+				if (exists(userinfo)) authorityPunydecoded += `${userinfo}@`;
+				authorityPunydecoded += hostToURI(hostPunydecoded);
+				if (exists(port)) authorityPunydecoded += `:${port}`;
+			}
+			if (exists(host)) {
+				authority = "";
+				if (exists(userinfo)) authority += `${userinfo}@`;
+				authority += hostToURI(host);
+				if (exists(port)) authority += `:${port}`;
+			} else {
+				userinfo = null;
+				port = null;
+			}
+		}
+	}
+	const query = is(String, queryParsed) ? queryParsed : null;
+	const fragment = is(String, fragmentParsed) ? fragmentParsed : null;
+	/* v8 ignore next -- unreachable null branch: the Appendix-B regexp always captures a string path */
+	parsed.pathqf = is(String, path) ? path.valueOf() : null;
+	if (is(String, parsed.pathqf)) {
+		if (is(String, query)) parsed.pathqf += `?${query}`;
+		if (is(String, fragment)) parsed.pathqf += `#${fragment}`;
+	}
+	parsed.scheme = scheme.toLowerCase();
+	parsed.authority = authority;
+	parsed.authorityPunydecoded = authorityPunydecoded;
+	parsed.userinfo = userinfo;
+	parsed.host = host;
+	parsed.hostPunydecoded = hostPunydecoded;
+	parsed.port = port;
+	/* v8 ignore next -- unreachable: the Appendix-B regexp always captures a string path */
+	parsed.path = path ?? null;
+	parsed.query = query;
+	parsed.fragment = fragment;
+	const recomposedURI = recomposeURI({
+		scheme: parsed.scheme,
+		userinfo: parsed.userinfo,
+		host: parsed.host,
+		port: parsed.port,
+		path: parsed.path,
+		query: parsed.query,
+		fragment: parsed.fragment
+	});
+	parsed.href = recomposedURI !== "" ? recomposedURI : null;
+	return parsed;
+};
+//#endregion
+//#region src/sitemap/index.ts
+/**
+* sitemap
+*
+* Percent encodings, entities and escape codes.
+*
+* - specialChars
+* - specialCharsKeys
+* - pencodings
+* - pencodingsKeys
+* - entities
+* - entitiesKeys
+* - escapeCodes
+* - escapeCodesKeys
+* - escapeCodesKeysLen
+*/
+const specialChars = { "*": "%2A" };
+const specialCharsKeys = Object.keys(specialChars);
+const pencodings = {};
+specialCharsKeys.forEach((char) => {
+	pencodings[specialChars[char]] = char;
+});
+const pencodingsKeys = Object.keys(pencodings);
+const entities = {
+	"&": "&amp;",
+	"'": "&apos;",
+	"\"": "&quot;",
+	">": "&gt;",
+	"<": "&lt;"
+};
+const entitiesKeys = Object.keys(entities);
+const escapeCodes = {};
+entitiesKeys.forEach((entity) => {
+	escapeCodes[entities[entity]] = entity;
+});
+const escapeCodesKeys = Object.keys(escapeCodes);
+const escapeCodesKeysLen = escapeCodesKeys.length;
+//#endregion
+//#region src/checkers/index.ts
+/**
+* checkers
+*
+* - checkPercentEncoding(string, index, stringLen) -> Number throws URIError
+* - checkSitemapEncoding(string, index, stringLen) -> Number throws URIError
+* - checkComponent({ type, string, sitemap } = {}) -> Boolean throws URIError
+* - checkSchemeChars(scheme, len) -> Boolean throws URIError
+* - checkLowercase(uri) -> Boolean throws URIError
+* - checkURISyntax(uri) -> Object throws URIError
+* - checkURI(uri, { sitemap } = {}) -> Object throws URIError
+* - checkHttpURL(uri, { https, web, sitemap } = {}) -> Object throws URIError
+* - checkHttpsURL(uri) -> Object throws URIError
+* - checkHttpSitemapURL(uri) -> Object throws URIError
+* - checkHttpsSitemapURL(uri) -> Object throws URIError
+* - checkWebURL(uri) -> Object throws URIError
+* - checkSitemapURL(uri) -> Object throws URIError
+*/
+const ipv6ZoneIdRegexp = /^(?:[A-Za-z0-9._~-]|%[0-9A-Fa-f]{2})+$/;
+/**
+* @func checkPercentEncoding
+*
+* Check a % char found from a string at a specific index has a valid
+* percent encoding following this char.
+*/
+const checkPercentEncoding = function checkPercentEncoding(string, index, stringLen) {
+	if (!is(String, string)) fail("URI_INVALID_PERCENT_ENCODING", "a string is required when checking for percent encoding");
+	const len = is(Number, stringLen) && stringLen >= 0 ? stringLen : string.length;
+	const i = is(Number, index) && index < len ? index : 0;
+	let offset = 0;
+	if (len > 0 && string.charAt(i) === "%") if (i + 2 < len) if (!isPercentEncodingChar(string.charAt(i + 1))) fail("URI_INVALID_PERCENT_ENCODING", `invalid percent encoding char '${string.charAt(i + 1)}'`);
+	else if (!isPercentEncodingChar(string.charAt(i + 2))) fail("URI_INVALID_PERCENT_ENCODING", `invalid percent encoding char '${string.charAt(i + 2)}'`);
+	else offset = 2;
+	else fail("URI_INVALID_PERCENT_ENCODING", "incomplete percent encoding found");
+	return offset;
+};
+/**
+* @func checkSitemapEncoding
+*
+* Check an entity in an URL at a specific index has a valid
+* sitemap escape encoding following this char.
+*/
+const checkSitemapEncoding = function checkSitemapEncoding(string, index, stringLen) {
+	if (!is(String, string)) fail("URI_INVALID_SITEMAP_ENCODING", "a string is required when checking for sitemap encoding");
+	const len = is(Number, stringLen) && stringLen >= 0 ? stringLen : string.length;
+	const i = is(Number, index) && index < len ? index : 0;
+	let offset = 0;
+	if (len > 0 && string.charAt(i) === "&") {
+		let escapeOffset;
+		for (let j = 0; j < escapeCodesKeysLen; j += 1) {
+			const code = escapeCodesKeys[j];
+			/* v8 ignore next 3 -- unreachable: j is bounded by escapeCodesKeys.length so the index is always defined */
+			if (code === void 0) break;
+			const codeLen = code.length;
+			if (i + codeLen <= len && code === string.substring(i, i + codeLen)) {
+				escapeOffset = codeLen - 1;
+				break;
+			}
+		}
+		if (!exists(escapeOffset)) fail("URI_INVALID_SITEMAP_ENCODING", `entity '${string.charAt(i)}' is not properly escaped`);
+		else offset = escapeOffset;
+	}
+	return offset;
+};
+/**
+* @func checkComponent
+*
+* Check a string has valid characters regarding userinfo, path, query,
+* or fragment URI component type.
+*
+* NOTE:
+* - check only if string is present as these components are not required;
+* - path is required but is at least empty,
+*   regexp assures that and checkURISyntax verifies that too.
+*/
+const checkComponent = function checkComponent({ type, string, sitemap } = {}) {
+	if (![
+		"userinfo",
+		"path",
+		"query",
+		"fragment"
+	].includes(type)) fail("URI_INVALID_CHECKING_COMPONENT", `unable to check pathqf, got '${type}' component to check`);
+	if (type === "path" && (!exists(string) || string === "") || !exists(string)) return true;
+	const len = string.length;
+	const checkSitemap = sitemap === true;
+	let checkCharFunc;
+	switch (type) {
+		case "userinfo":
+			checkCharFunc = checkSitemap ? isSitemapUserinfoChar : isUserinfoChar;
+			break;
+		case "path":
+			checkCharFunc = checkSitemap ? isSitemapPathChar : isPathChar;
+			break;
+		case "query":
+		case "fragment":
+			checkCharFunc = checkSitemap ? isSitemapQueryOrFragmentChar : isQueryOrFragmentChar;
+			break;
+		/* v8 ignore next -- unreachable: type is validated to one of the four cases before the switch */
+		default:
+	}
+	for (let i = 0; i < len; i += 1) {
+		if (!checkCharFunc(string.charAt(i))) fail(`URI_INVALID_${type.toUpperCase()}_CHAR`, `invalid ${type} char '${string.charAt(i)}'`);
+		i += checkPercentEncoding(string, i, len);
+		if (checkSitemap) i += checkSitemapEncoding(string, i, len);
+	}
+	return true;
+};
+/**
+* @func checkSchemeChars
+*
+* Check scheme characters are valid.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-3.1.
+*/
+const checkSchemeChars = function checkSchemeChars(scheme, len) {
+	if (!is(String, scheme)) fail("URI_INVALID_SCHEME", "scheme must be a string");
+	const schemeLen = is(Number, len) && len > 0 ? len : scheme.length;
+	if (schemeLen <= 0) fail("URI_INVALID_SCHEME", "scheme cannot be empty");
+	for (let i = 0; i < schemeLen; i += 1) if (!isSchemeChar(scheme.charAt(i), { start: i === 0 })) fail("URI_INVALID_SCHEME_CHAR", `invalid scheme char '${scheme.charAt(i)}'`);
+	return true;
+};
+/**
+* @func checkLowercase
+*
+* Check a string has not any uppercase characters.
+*/
+const checkLowercase = function checkLowercase(uri) {
+	if (!is(String, uri)) fail("URI_INVALID_TYPE", "uri must be a string");
+	if (uri.toLowerCase() !== uri) fail("URI_INVALID_CHAR", "uri cannot contain any uppercase characters");
+	return true;
+};
+/**
+* @func checkURISyntax
+*
+* Check an URI syntax is valid according to RFC-3986.
+*
+* Beware this function does not fully check if an URI is valid.
+* Rules:
+* 1. scheme is required and cannot be empty;
+* 2. path is required and can be empty;
+* 3. if authority is present path must be empty or start with /;
+* 4. if authority is not present path must not start with //;
+* 5. check for inconsistent authority (original vs parsed)
+*    which would mean host parsed was actually wrong.
+*/
+const checkURISyntax = function checkURISyntax(uri) {
+	if (!is(String, uri)) fail("URI_INVALID_TYPE", "uri must be a string");
+	const { scheme, authority, authorityPunydecoded, userinfo, host, hostPunydecoded, port, path, pathqf, query, fragment, href } = parseURI(uri);
+	const schemeLen = is(String, scheme) ? scheme.length : 0;
+	if (!is(String, scheme)) fail("URI_MISSING_SCHEME", "uri scheme is required");
+	else if (schemeLen <= 0) fail("URI_EMPTY_SCHEME", "uri scheme must not be empty");
+	/* v8 ignore stop */
+	/* v8 ignore next 3 -- unreachable: the Appendix-B regexp always captures a string path */
+	if (!is(String, path)) fail("URI_MISSING_PATH", "uri path is required");
+	if (is(String, authority) && authority.length > 0) {
+		/* v8 ignore next 3 -- unreachable: when authority is present the Appendix-B regexp makes path empty or '/'-prefixed */
+		if (!(path === "" || path.startsWith("/"))) fail("URI_INVALID_PATH", "path must be empty or start with '/' when authority is present");
+	} else if (path.startsWith("//")) fail("URI_INVALID_PATH", "path must not start with '//' when authority is not present");
+	if (!exists(authority) && exists(authorityPunydecoded)) fail("URI_INVALID_HOST", `host must be a valid ip or domain name, got '${hostPunydecoded}'`);
+	if (is(String, host) && host.includes(":")) {
+		const zoneAt = host.indexOf("%");
+		if (zoneAt !== -1) {
+			const zoneId = host.slice(zoneAt + 3);
+			if (host.slice(zoneAt, zoneAt + 3) !== "%25") fail("URI_INVALID_HOST", `IPv6 zone identifier must use the '%25' delimiter, got '${host}'`);
+			if (zoneId === "" || !ipv6ZoneIdRegexp.test(zoneId)) fail("URI_INVALID_HOST", `IPv6 zone identifier must be a non-empty RFC 6874 ZoneID, got '${host}'`);
+		}
+	}
+	return {
+		scheme,
+		authority,
+		authorityPunydecoded,
+		userinfo,
+		host,
+		hostPunydecoded,
+		port,
+		path,
+		pathqf,
+		query,
+		fragment,
+		href,
+		schemeLen,
+		valid: true
+	};
+};
+/**
+* @func checkURI
+*
+* Check an URI is valid according to RFC-3986.
+*
+* Rules:
+* 1. scheme is required and cannot be empty;
+* 2. path is required and can be empty;
+* 3. if authority is present path must be empty or start with /;
+* 4. if authority is not present path must not start with //;
+* 5. scheme can only have specific characters:
+*    https://tools.ietf.org/html/rfc3986#section-3.1;
+* 6. if authority is present:
+*    1. host must be a valid IP or domain name;
+*    2. userinfo, if any, can only have specific characters:
+*       https://tools.ietf.org/html/rfc3986#section-3.2.1;
+*    3. port, if any, must be an integer in a specific range.
+* 7. path, query and fragment can only have specific characters:
+*    https://tools.ietf.org/html/rfc3986#section-3.3.
+*/
+const checkURI = function checkURI(uri, { sitemap } = {}) {
+	const { scheme, authority, authorityPunydecoded, userinfo, host, hostPunydecoded, port, path, pathqf, query, fragment, href, schemeLen } = checkURISyntax(uri);
+	checkSchemeChars(scheme, schemeLen);
+	if (exists(authority)) {
+		checkComponent({
+			sitemap,
+			type: "userinfo",
+			string: userinfo
+		});
+		if (!isIP(host) && !isDomain(host)) fail("URI_INVALID_HOST", `host must be a valid ip or domain name, got '${host}'`);
+		if (exists(port) && (!isPort(port) || int(port, {
+			ge: 0,
+			le: 65535
+		}) === void 0)) fail("URI_INVALID_PORT", `port must be an integer between 0-${maxPortInteger}, got '${port}'`);
+	}
+	checkComponent({
+		sitemap,
+		type: "path",
+		string: path
+	});
+	checkComponent({
+		sitemap,
+		type: "query",
+		string: query
+	});
+	checkComponent({
+		sitemap,
+		type: "fragment",
+		string: fragment
+	});
+	return {
+		scheme,
+		authority,
+		authorityPunydecoded,
+		userinfo,
+		host,
+		hostPunydecoded,
+		port,
+		path,
+		pathqf,
+		query,
+		fragment,
+		href,
+		valid: true
+	};
+};
+/**
+* @func checkHttpURL
+*
+* Check an URI is a valid HTTP URL (sitemap URLs supported to create aliases).
+*
+* This function uses checkURI to check URI provided is valid.
+*
+* Rules:
+* 1. scheme must be http or HTTP;
+* 2. authority is required;
+* 3. URL must be less than max length.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const checkHttpURL = function checkHttpURL(uri, { https, web, sitemap } = {}) {
+	if (sitemap === true) checkLowercase(uri);
+	const schemesToCheck = [];
+	if (https === true) schemesToCheck.push("https");
+	else if (web === true) schemesToCheck.push("http", "https");
+	else schemesToCheck.push("http");
+	const { scheme, authority, authorityPunydecoded, userinfo, host, hostPunydecoded, port, path, pathqf, query, fragment, href } = checkURI(uri, { sitemap });
+	if (!schemesToCheck.includes(scheme)) fail("URI_INVALID_SCHEME", `scheme must be ${schemesToCheck.join(" or ")}, got '${scheme}'`);
+	if (!is(String, authority)) fail("URI_MISSING_AUTHORITY", "authority is required");
+	if (is(String, href) && href.length >= 2048) fail("URI_MAX_LENGTH_URL", `max URL length of ${maxLengthURL} reached: ${href.length}`);
+	return {
+		scheme,
+		authority,
+		authorityPunydecoded,
+		userinfo,
+		host,
+		hostPunydecoded,
+		port,
+		path,
+		pathqf,
+		query,
+		fragment,
+		href,
+		valid: true
+	};
+};
+/**
+* @func checkHttpsURL
+*
+* Check an URI is a valid HTTPS URL.
+*
+* Same behavior than checkHttpURL except scheme must be https or HTTPS.
+*/
+const checkHttpsURL = function checkHttpsURL(uri) {
+	return checkHttpURL(uri, { https: true });
+};
+/**
+* @func checkHttpSitemapURL
+*
+* Check an URI is a valid HTTP URL to be used in an XML sitemap file.
+*
+* This function uses checkHttpURL to check URI provided is a valid HTTP URL.
+*
+* Rules:
+* 1. scheme must be http;
+* 2. authority is required;
+* 3. specific characters must be escaped;
+* 4. can only contain lowercase characters;
+* 5. URL must be less than max length.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const checkHttpSitemapURL = function checkHttpSitemapURL(uri) {
+	return checkHttpURL(uri, { sitemap: true });
+};
+/**
+* @func checkHttpsSitemapURL
+*
+* Check an URI is a valid HTTPS URL to be used in an XML sitemap file.
+* Same behavior than checkHttpSitemapURL except scheme must be https.
+*/
+const checkHttpsSitemapURL = function checkHttpsSitemapURL(uri) {
+	return checkHttpURL(uri, {
+		https: true,
+		sitemap: true
+	});
+};
+/**
+* @func checkWebURL
+*
+* Check an URI is a valid HTTP or HTTPS URL.
+*
+* Same behavior than checkHttpURL except scheme can be http/HTTP or https/HTTPS.
+*/
+const checkWebURL = function checkWebURL(uri) {
+	return checkHttpURL(uri, { web: true });
+};
+/**
+* @func checkSitemapURL
+*
+* Check an URI is a valid HTTP or HTTPS URL to be used in an XML sitemap file.
+*
+* Same behavior than checkHttpSitemapURL except scheme can be http or https.
+*/
+const checkSitemapURL = function checkSitemapURL(uri) {
+	return checkHttpURL(uri, {
+		web: true,
+		sitemap: true
+	});
+};
+//#endregion
+//#region src/decoders/index.ts
+/**
+* decoders
+*
+* - decodeURIComponentString(component, { sitemap, lowercase } = {}) -> String
+* - decodeURIString(uri, { sitemap, lowercase } = {}) -> String throws URIError
+* - decodeWebURL(uri, { lowercase } = {}) -> String
+* - decodeSitemapURL(uri, { lowercase } = {}) -> String
+*/
+const sitemapDecodeRegexp = new RegExp(escapeCodesKeys.concat(pencodingsKeys).join("|"), "g");
+/**
+* @func decodeURIComponentString
+*
+* Decode an URI component string with Sitemap's escape codes support.
+*
+* Native function decodeURIComponent could throw and to be consistent with
+* encodeURIComponentString the empty string is returned if unable to decode.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const decodeURIComponentString = function decodeURIComponentString(component, { sitemap, lowercase } = {}) {
+	if (!is(String, component)) return "";
+	const componentToDecode = lowercase === true ? component.toLowerCase() : component;
+	if (sitemap === true) {
+		const uriToDecode = componentToDecode.replace(
+			sitemapDecodeRegexp,
+			/* v8 ignore next -- unreachable '': the regexp is built from these keys so every match resolves */
+			(match) => escapeCodes[match] || pencodings[match] || ""
+		);
+		try {
+			return decodeURIComponent(uriToDecode);
+		} catch {
+			return "";
+		}
+	}
+	try {
+		return decodeURIComponent(componentToDecode);
+	} catch {
+		return "";
+	}
+};
+/**
+* @func decodeURIString
+*
+* Decode an URI string according to RFC-3986 with basic checking.
+*
+* Checked:
+* - scheme is required;
+* - path is required, can be empty;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid ip or domain name;
+* - maximum size once encoded for URLs.
+*
+* Support:
+* - IDNs: returns URI with its Punydecoded host (Unicode serialization of the domain), if any;
+* - lower and upper case.
+*
+* Note:
+* - if one of userinfo, path, query or fragment component cannot be decoded, it will be ignored;
+* - native function decodeURI does not support IDNs and cannot properly work
+*   with encodeURI since the function is based on an outdated standard;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase;
+* - to only use with encodeURIString.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const decodeURIString = function decodeURIString(uri, { web, sitemap, lowercase } = {}) {
+	const uriToDecode = is(String, uri) && lowercase === true ? uri.toLowerCase() : uri;
+	const webURL = web === true || sitemap === true;
+	const { scheme, authority, userinfo, host, hostPunydecoded, port, path, query, fragment, schemeLen } = checkURISyntax(uriToDecode);
+	if (webURL) {
+		if (scheme !== "http" && scheme !== "https") fail("URI_INVALID_SCHEME", `scheme must be http or https, got '${scheme}'`);
+	} else checkSchemeChars(scheme, schemeLen);
+	if (webURL && !is(String, authority)) fail("URI_MISSING_AUTHORITY", "authority is required");
+	if (exists(host) && !isIP(host) && !isDomain(host)) fail("URI_INVALID_HOST", `host must be a valid ip or domain name, got '${host}'`);
+	if (exists(port) && (!isPort(port) || int(port, {
+		ge: 0,
+		le: 65535
+	}) === void 0)) fail("URI_INVALID_PORT", `port must be an integer between 0-${maxPortInteger}, got '${port}'`);
+	const userinfoDecoded = decodeURIComponentString(userinfo ?? "", {
+		sitemap,
+		lowercase: false
+	});
+	/* v8 ignore next -- unreachable '': checkURISyntax always yields a string path */
+	const pathDecoded = decodeURIComponentString(path ?? "", {
+		sitemap,
+		lowercase: false
+	});
+	const decodeComponent = (value) => {
+		if (!is(String, value) || value === "") return value;
+		return decodeURIComponentString(value, {
+			sitemap,
+			lowercase: false
+		}) || null;
+	};
+	const uridecoded = recomposeURI({
+		scheme,
+		port,
+		host: hostPunydecoded,
+		userinfo: userinfoDecoded,
+		path: pathDecoded,
+		query: decodeComponent(query),
+		fragment: decodeComponent(fragment)
+	});
+	if (webURL && uridecoded.length >= 2048) fail("URI_MAX_LENGTH_URL", `max URL length of ${maxLengthURL} reached: ${uridecoded.length}`);
+	return uridecoded;
+};
+/**
+* @func decodeWebURL
+*
+* Decode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs.
+*
+* Uses a fixed decodeURI function to be RFC-3986 compliant.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - parseURI prechecked host, will be null if invalid and so does authority.
+*
+* Support:
+* - IDNs: returns URI with its Punydecoded host
+*   (Unicode serialization of the domain), if any;
+* - lower and upper case.
+*
+* Note:
+* - native function decodeURI does not support IDNs and cannot properly work
+*   with encodeURI since the function is based on an outdated standard;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase;
+* - to use only with encodeWebURL.
+*/
+const decodeWebURL = function decodeWebURL(uri, { lowercase } = {}) {
+	return decodeURIString(uri, {
+		lowercase,
+		web: true
+	});
+};
+/**
+* @func decodeSitemapURL
+*
+* Decode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs and sitemap requirements regarding escape codes to decode.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - parseURI prechecked host, will be null if invalid and so does authority.
+*
+* Support:
+* - Sitemap's escape codes;
+* - IDNs: returns URI with its Punydecoded host
+*   (Unicode serialization of the domain), if any;
+* - lower and upper case.
+*
+* Note:
+* - native function decodeURI does not support IDNs and cannot properly work
+*   with encodeURI since the function is based on an outdated standard;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase;
+* - to use only with encodeSitemapURL.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const decodeSitemapURL = function decodeSitemapURL(uri, { lowercase } = {}) {
+	return decodeURIString(uri, {
+		lowercase,
+		sitemap: true
+	});
+};
+//#endregion
+//#region src/encoders/index.ts
+/**
+* encoders
+*
+* - encodeURIComponentString(uri, { sitemap, lowercase } = {}) -> String
+* - encodeURIString(uri, { web, sitemap, lowercase } = {}) -> String throws URIError
+* - encodeWebURL(uri, { lowercase } = {}) -> String
+* - encodeSitemapURL(uri, { lowercase } = {}) -> String
+*/
+/**
+* @func encodeURIComponentString
+*
+* Encode an URI component according to RFC-3986 with Sitemap entities support.
+*
+* Support:
+* - Sitemap's special characters;
+* - lower and upper case.
+*
+* Note:
+* - only userinfo, path, query and fragment components can be encoded;
+* - scheme and authority host+port can never have percent encoded characters;
+* - the empty string is returned if unable to encode;
+* - sitemap characters must be in lowercase and escaped for XML sitemap.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const encodeURIComponentString = function encodeURIComponentString(component, { type, sitemap, lowercase } = {}) {
+	if (!is(String, component)) return "";
+	const componentToEncode = lowercase === true || sitemap === true ? component.toLowerCase() : component;
+	const componentToEncodeLen = componentToEncode.length;
+	let uricomponent = "";
+	for (let i = 0; i < componentToEncodeLen; i += 1) {
+		const char = componentToEncode.charAt(i);
+		let encoded = false;
+		if (sitemap === true) {
+			const entity = entities[char];
+			const special = specialChars[char];
+			if (exists(entity)) {
+				uricomponent += entity;
+				encoded = true;
+			} else if (exists(special)) {
+				uricomponent += special;
+				encoded = true;
+			}
+		}
+		if (!encoded) {
+			let isChar;
+			switch (type) {
+				case "userinfo":
+					isChar = sitemap === true && isSitemapUserinfoChar(char, true) || isUserinfoChar(char, true);
+					break;
+				case "path":
+					isChar = sitemap === true && isSitemapPathChar(char, true) || isPathChar(char, true);
+					break;
+				case "query":
+				case "fragment":
+					isChar = sitemap === true && isSitemapQueryOrFragmentChar(char, true) || isQueryOrFragmentChar(char, true);
+					break;
+				default: isChar = false;
+			}
+			uricomponent += !isChar ? encodeURIComponent(char) : char;
+		}
+	}
+	return uricomponent;
+};
+/**
+* @func encodeURIString
+*
+* Encode an URI string according to RFC-3986 with basic checking.
+*
+* Checked:
+* - scheme is required;
+* - path is required, can be empty;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid ip or domain name;
+* - maximum size once encoded for URLs.
+*
+* Support:
+* - IDNs: returns URI with its Punycode host, if any;
+* - lower and upper case.
+*
+* Note:
+* - only userinfo, path, query and fragment can be percent encoded;
+* - native function encodeURI encodes string according to RFC-2396 which is outdated;
+* - native function encodeURI also encodes scheme and host that cannot have
+*   percend-encoded characters;
+* - characters that should not be percent-encoded in RFC-3986 are [] to represent IPv6 host;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const encodeURIString = function encodeURIString(uri, { web, sitemap, lowercase } = {}) {
+	const uriToEncode = is(String, uri) && lowercase === true ? uri.toLowerCase() : uri;
+	const webURL = web === true || sitemap === true;
+	const { scheme, authority, userinfo, host, port, path, query, fragment, schemeLen } = checkURISyntax(uriToEncode);
+	if (webURL) {
+		if (scheme !== "http" && scheme !== "https") fail("URI_INVALID_SCHEME", `scheme must be http or https, got '${scheme}'`);
+	} else checkSchemeChars(scheme, schemeLen);
+	if (webURL && !is(String, authority)) fail("URI_MISSING_AUTHORITY", "authority is required");
+	if (exists(host) && !isIP(host) && !isDomain(host)) fail("URI_INVALID_HOST", `host must be a valid ip or domain name, got '${host}'`);
+	if (exists(port) && (!isPort(port) || int(port, {
+		ge: 0,
+		le: 65535
+	}) === void 0)) fail("URI_INVALID_PORT", `port must be an integer between 0-${maxPortInteger}, got '${port}'`);
+	const uriencoded = recomposeURI({
+		scheme,
+		host,
+		port,
+		userinfo: encodeURIComponentString(userinfo ?? "", {
+			sitemap,
+			type: "userinfo",
+			lowercase: false
+		}),
+		path: encodeURIComponentString(path ?? "", {
+			sitemap,
+			type: "path",
+			lowercase: false
+		}),
+		query: is(String, query) ? encodeURIComponentString(query, {
+			sitemap,
+			type: "query",
+			lowercase: false
+		}) : query,
+		fragment: is(String, fragment) ? encodeURIComponentString(fragment, {
+			sitemap,
+			type: "fragment",
+			lowercase: false
+		}) : fragment
+	});
+	if (webURL && uriencoded.length >= 2048) fail("URI_MAX_LENGTH_URL", `max URL length of ${maxLengthURL} reached: ${uriencoded.length}`);
+	return uriencoded;
+};
+/**
+* @func encodeWebURL
+*
+* Encode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs.
+*
+* Uses a fixed encodeURI function to be RFC-3986 compliant.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid IP or domain name;
+* - maximum size once encoded.
+*
+* Support:
+* - IDNs: returns URL with its Punycode host, if any;
+* - lower and upper case.
+*
+* Note:
+* - only userinfo, path, query and fragment can be percent encoded;
+* - native function encodeURI encodes string according to RFC-2396 which is outdated;
+* - native function encodes also scheme and host that cannot have percend encoded characters;
+* - characters that should not be percent-encoded in RFC-3986 are [] to represent IPv6 host;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986.
+*/
+const encodeWebURL = function encodeWebURL(uri, { lowercase } = {}) {
+	return encodeURIString(uri, {
+		lowercase,
+		web: true
+	});
+};
+/**
+* @func encodeSitemapURL
+*
+* Encode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs and sitemap requirements regarding special entities to escape.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid IP or domain name;
+* - maximum size once encoded.
+*
+* Support:
+* - Sitemap's special characters;
+* - IDNs: returns URI with its Punycode host, if any;
+* - lower case only.
+*
+* Note:
+* - only userinfo, path, query and fragment can be percent encoded;
+* - native function encodeURI encodes string according to RFC-2396 which is outdated;
+* - native function encodes also scheme and host that cannot have percend encoded characters;
+* - characters that should not be percent-encoded in RFC-3986 are [] to represent IPv6 host;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+const encodeSitemapURL = function encodeSitemapURL(uri) {
+	return encodeURIString(uri, {
+		lowercase: true,
+		sitemap: true
+	});
+};
+//#endregion
+//#region src/resolver/index.ts
+/**
+* reference resolution
+*
+* - removeDotSegments(path) -> String
+* - resolveURI(base, reference) -> String
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-5.
+*/
+const referenceRegexp = /^(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/;
+/**
+* @func parseReference
+*
+* Split a URI-reference into its five RFC-3986 components. A component is
+* null when the delimiter is absent and '' when present but empty, so the
+* defined/undefined distinction §5.2.2 relies on is preserved.
+*/
+const parseReference = function parseReference(reference) {
+	/* v8 ignore next -- unreachable []: the Appendix-B regexp is all-optional and matches any string */
+	const [, scheme, authority, path, query, fragment] = reference.match(referenceRegexp) ?? [];
+	return {
+		scheme: scheme ?? null,
+		authority: authority ?? null,
+		/* v8 ignore next -- unreachable '': the path group [^?#]* always captures a string */
+		path: path ?? "",
+		query: query ?? null,
+		fragment: fragment ?? null
+	};
+};
+/**
+* @func removeDotSegments
+*
+* Remove the special "." and ".." complete path segments from a path,
+* implementing the RFC-3986 §5.2.4 ordered loop verbatim.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-5.2.4.
+*/
+const removeDotSegments = function removeDotSegments(path) {
+	if (!is(String, path)) return "";
+	let input = path;
+	let output = "";
+	while (input.length > 0) if (input.startsWith("../")) input = input.slice(3);
+	else if (input.startsWith("./")) input = input.slice(2);
+	else if (input.startsWith("/./")) input = `/${input.slice(3)}`;
+	else if (input === "/.") input = "/";
+	else if (input.startsWith("/../")) {
+		input = `/${input.slice(4)}`;
+		output = output.slice(0, Math.max(0, output.lastIndexOf("/")));
+	} else if (input === "/..") {
+		input = "/";
+		output = output.slice(0, Math.max(0, output.lastIndexOf("/")));
+	} else if (input === "." || input === "..") input = "";
+	else {
+		const start = input.startsWith("/") ? 1 : 0;
+		const next = input.indexOf("/", start);
+		if (next === -1) {
+			output += input;
+			input = "";
+		} else {
+			output += input.slice(0, next);
+			input = input.slice(next);
+		}
+	}
+	return output;
+};
+/**
+* @func merge
+*
+* Merge a relative reference's path with the base path, per RFC-3986 §5.2.3.
+*/
+const merge = function merge(base, refPath) {
+	if (is(String, base.authority) && base.path === "") return `/${refPath}`;
+	const lastSlash = base.path.lastIndexOf("/");
+	return lastSlash === -1 ? refPath : base.path.slice(0, lastSlash + 1) + refPath;
+};
+/**
+* @func recompose
+*
+* Recompose a resolved target from its components, per RFC-3986 §5.3.
+* A component is emitted whenever it is defined (non-null), including ''.
+*/
+const recompose = function recompose(target) {
+	let result = "";
+	/* v8 ignore next -- unreachable false branch: a resolved target always has a scheme (the base is absolute) */
+	if (is(String, target.scheme)) result += `${target.scheme}:`;
+	if (is(String, target.authority)) result += `//${target.authority}`;
+	result += target.path;
+	if (is(String, target.query)) result += `?${target.query}`;
+	if (is(String, target.fragment)) result += `#${target.fragment}`;
+	return result;
+};
+/**
+* @func resolveURI
+*
+* Resolve a URI reference against a base URI, implementing the RFC-3986
+* §5.2.2 strict transform (with §5.2.3 merge and §5.2.4 remove_dot_segments)
+* and recomposing per §5.3.
+*
+* The base must be an absolute URI (a scheme is required, RFC-3986 §5.2.1);
+* a fragment on the base is ignored (RFC-3986 §5.1: the base is used
+* stripped of any fragment); the empty string is returned if base or
+* reference is invalid.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-5.2.
+*/
+const resolveURI = function resolveURI(base, reference) {
+	if (!(is(String, base) && is(String, reference))) return "";
+	const baseRef = parseReference(base);
+	if (!is(String, baseRef.scheme)) return "";
+	const r = parseReference(reference);
+	const t = {
+		scheme: null,
+		authority: null,
+		path: "",
+		query: null,
+		fragment: null
+	};
+	if (is(String, r.scheme)) {
+		t.scheme = r.scheme;
+		t.authority = r.authority;
+		t.path = removeDotSegments(r.path);
+		t.query = r.query;
+	} else {
+		if (is(String, r.authority)) {
+			t.authority = r.authority;
+			t.path = removeDotSegments(r.path);
+			t.query = r.query;
+		} else {
+			if (r.path === "") {
+				t.path = baseRef.path;
+				t.query = is(String, r.query) ? r.query : baseRef.query;
+			} else {
+				t.path = r.path.startsWith("/") ? removeDotSegments(r.path) : removeDotSegments(merge(baseRef, r.path));
+				t.query = r.query;
+			}
+			t.authority = baseRef.authority;
+		}
+		t.scheme = baseRef.scheme;
+	}
+	t.fragment = r.fragment;
+	return recompose(t);
+};
+//#endregion
+exports.checkHttpSitemapURL = checkHttpSitemapURL;
+exports.checkHttpURL = checkHttpURL;
+exports.checkHttpsSitemapURL = checkHttpsSitemapURL;
+exports.checkHttpsURL = checkHttpsURL;
+exports.checkSitemapURL = checkSitemapURL;
+exports.checkURI = checkURI;
+exports.checkWebURL = checkWebURL;
+exports.decodeSitemapURL = decodeSitemapURL;
+exports.decodeURIComponentString = decodeURIComponentString;
+exports.decodeURIString = decodeURIString;
+exports.decodeWebURL = decodeWebURL;
+exports.encodeSitemapURL = encodeSitemapURL;
+exports.encodeURIComponentString = encodeURIComponentString;
+exports.encodeURIString = encodeURIString;
+exports.encodeWebURL = encodeWebURL;
+exports.isDomain = isDomain;
+exports.isDomainLabel = isDomainLabel;
+exports.isIP = isIP;
+exports.isIPv4 = isIPv4;
+exports.isIPv6 = isIPv6;
+exports.parseURI = parseURI;
+exports.punycode = punycode;
+exports.punydecode = punydecode;
+exports.recomposeURI = recomposeURI;
+exports.removeDotSegments = removeDotSegments;
+exports.resolveURI = resolveURI;
+
+//# sourceMappingURL=index.cjs.map