trousse 2.6.1 → 2.7.0

package/dist/coercions.d.ts

@@ -4,6 +4,6 @@ export declare const coerceString: (value: unknown) => string | undefined;
 export declare const coerceNumber: (value: unknown) => number | undefined;
 export declare const coerceBoolean: (value: unknown) => boolean | undefined;
 export declare const coerceDate: (value: unknown) => Date | undefined;
-export declare const coerceSingular: <T>(value: T | Array<T>) => T;
+export declare const coerceSingular: <T>(value: T | Array<T>) => T | undefined;
 export declare const coerceArray: <T>(value: Nullish<T | Array<T>>) => Array<T>;
 //#endregion

package/dist/coercions.js

@@ -6,7 +6,7 @@ const coerceString = (value) => {
 };
 const coerceNumber = (value) => {
 	if (isNumber(value)) return Number.isNaN(value) ? void 0 : value;
-	if (isNonEmptyString(value)) {
+	if (isString(value) && value.trim()) {
 		const numeric = +value;
 		return Number.isNaN(numeric) ? void 0 : numeric;
 	}
@@ -20,8 +20,10 @@ const coerceBoolean = (value) => {
 		if (falseRegex.test(value)) return false;
 	}
 };
+const nonYearDigitsRegex = /^\s*(\d{1,3}|\d{5,})\s*$/;
 const coerceDate = (value) => {
 	if (isValidDate(value)) return value;
+	if (isString(value) && nonYearDigitsRegex.test(value)) return;
 	if (isNumber(value) || isNonEmptyString(value)) {
 		const date = new Date(value);
 		return Number.isNaN(date.getTime()) ? void 0 : date;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { omitEmpty } from "./arrays.js";
-import { AnyOf, DeepOmit, IsPlainObject, MaybePromise, NormalizeOptions, Nullish, PartialNullish, Pattern } from "./types.js";
+import { AnyOf, DeepOmit, IsPlainObject, MaybePromise, NormalizeOptions, Nullish, PartialNullish, Pattern, RegistrableDomainOptions } from "./types.js";
 import { coerceArray, coerceBoolean, coerceDate, coerceNumber, coerceSingular, coerceString } from "./coercions.js";
 import { archiveExtensions, audioExtensions, codeExtensions, documentExtensions, flashExtensions, fontExtensions, imageExtensions, installerExtensions, subtitleExtensions, videoExtensions } from "./files.js";
 import { isBoolean, isFunction, isNonEmptyString, isNullish, isNumber, isObject, isPlainObject, isPresent, isString, isValidDate } from "./is.js";
@@ -8,5 +8,5 @@ import { escapeHtml, t, tx } from "./locales.js";
 import { anyWordMatchesAnyOf, endsWithAnyOf, escapeRegex, getAnyOf, includesAnyOf, isAnyOf, startsWithAnyOf } from "./matching.js";
 import { omit, pick, toMap, trimObject } from "./objects.js";
 import { sleep } from "./timers.js";
-import { addMissingProtocol, decodeSegment, fixMalformedProtocol, getPathSegments, getRegistrableDomain, getSubdomain, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedProtocol, resolveUrl, stripWww, upgradeProtocol } from "./urls.js";
-export { type AnyOf, type DeepOmit, type IsPlainObject, type MaybePromise, type NormalizeOptions, type Nullish, type PartialNullish, type Pattern, addMissingProtocol, anyWordMatchesAnyOf, archiveExtensions, audioExtensions, codeExtensions, coerceArray, coerceBoolean, coerceDate, coerceNumber, coerceSingular, coerceString, decodeSegment, documentExtensions, endsWithAnyOf, escapeHtml, escapeRegex, fixMalformedProtocol, flashExtensions, fontExtensions, getAnyOf, getPathSegments, getRegistrableDomain, getSubdomain, imageExtensions, includesAnyOf, installerExtensions, isAnyOf, isBoolean, isFunction, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isJsonLike, isNonEmptyString, isNullish, isNumber, isObject, isParseableJson, isPlainObject, isPresent, isString, isSubdomainOf, isValidDate, normalizeUrl, omit, omitEmpty, parseUrl, pick, resolveFeedProtocol, resolveUrl, sleep, startsWithAnyOf, stripWww, subtitleExtensions, t, toMap, trimObject, tx, upgradeProtocol, videoExtensions };
+import { addMissingProtocol, addMissingScheme, decodeSegment, fixMalformedProtocol, fixMalformedScheme, getPathSegments, getRegistrableDomain, getSubdomain, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedProtocol, resolveFeedScheme, resolveUrl, stripWww, upgradeProtocol, upgradeScheme } from "./urls.js";
+export { type AnyOf, type DeepOmit, type IsPlainObject, type MaybePromise, type NormalizeOptions, type Nullish, type PartialNullish, type Pattern, type RegistrableDomainOptions, addMissingProtocol, addMissingScheme, anyWordMatchesAnyOf, archiveExtensions, audioExtensions, codeExtensions, coerceArray, coerceBoolean, coerceDate, coerceNumber, coerceSingular, coerceString, decodeSegment, documentExtensions, endsWithAnyOf, escapeHtml, escapeRegex, fixMalformedProtocol, fixMalformedScheme, flashExtensions, fontExtensions, getAnyOf, getPathSegments, getRegistrableDomain, getSubdomain, imageExtensions, includesAnyOf, installerExtensions, isAnyOf, isBoolean, isFunction, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isJsonLike, isNonEmptyString, isNullish, isNumber, isObject, isParseableJson, isPlainObject, isPresent, isString, isSubdomainOf, isValidDate, normalizeUrl, omit, omitEmpty, parseUrl, pick, resolveFeedProtocol, resolveFeedScheme, resolveUrl, sleep, startsWithAnyOf, stripWww, subtitleExtensions, t, toMap, trimObject, tx, upgradeProtocol, upgradeScheme, videoExtensions };

package/dist/index.js

@@ -7,5 +7,5 @@ import { escapeHtml, t, tx } from "./locales.js";
 import { anyWordMatchesAnyOf, endsWithAnyOf, escapeRegex, getAnyOf, includesAnyOf, isAnyOf, startsWithAnyOf } from "./matching.js";
 import { omit, pick, toMap, trimObject } from "./objects.js";
 import { sleep } from "./timers.js";
-import { addMissingProtocol, decodeSegment, fixMalformedProtocol, getPathSegments, getRegistrableDomain, getSubdomain, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedProtocol, resolveUrl, stripWww, upgradeProtocol } from "./urls.js";
-export { addMissingProtocol, anyWordMatchesAnyOf, archiveExtensions, audioExtensions, codeExtensions, coerceArray, coerceBoolean, coerceDate, coerceNumber, coerceSingular, coerceString, decodeSegment, documentExtensions, endsWithAnyOf, escapeHtml, escapeRegex, fixMalformedProtocol, flashExtensions, fontExtensions, getAnyOf, getPathSegments, getRegistrableDomain, getSubdomain, imageExtensions, includesAnyOf, installerExtensions, isAnyOf, isBoolean, isFunction, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isJsonLike, isNonEmptyString, isNullish, isNumber, isObject, isParseableJson, isPlainObject, isPresent, isString, isSubdomainOf, isValidDate, normalizeUrl, omit, omitEmpty, parseUrl, pick, resolveFeedProtocol, resolveUrl, sleep, startsWithAnyOf, stripWww, subtitleExtensions, t, toMap, trimObject, tx, upgradeProtocol, videoExtensions };
+import { addMissingProtocol, addMissingScheme, decodeSegment, fixMalformedProtocol, fixMalformedScheme, getPathSegments, getRegistrableDomain, getSubdomain, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedProtocol, resolveFeedScheme, resolveUrl, stripWww, upgradeProtocol, upgradeScheme } from "./urls.js";
+export { addMissingProtocol, addMissingScheme, anyWordMatchesAnyOf, archiveExtensions, audioExtensions, codeExtensions, coerceArray, coerceBoolean, coerceDate, coerceNumber, coerceSingular, coerceString, decodeSegment, documentExtensions, endsWithAnyOf, escapeHtml, escapeRegex, fixMalformedProtocol, fixMalformedScheme, flashExtensions, fontExtensions, getAnyOf, getPathSegments, getRegistrableDomain, getSubdomain, imageExtensions, includesAnyOf, installerExtensions, isAnyOf, isBoolean, isFunction, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isJsonLike, isNonEmptyString, isNullish, isNumber, isObject, isParseableJson, isPlainObject, isPresent, isString, isSubdomainOf, isValidDate, normalizeUrl, omit, omitEmpty, parseUrl, pick, resolveFeedProtocol, resolveFeedScheme, resolveUrl, sleep, startsWithAnyOf, stripWww, subtitleExtensions, t, toMap, trimObject, tx, upgradeProtocol, upgradeScheme, videoExtensions };

package/dist/matching.js

@@ -7,6 +7,9 @@ const testRegex = (regex, value) => {
 	regex.lastIndex = 0;
 	return regex.test(value);
 };
+const testRegexAnyCase = (regex, lowerValue, value) => {
+	return testRegex(regex, lowerValue) || lowerValue !== value && testRegex(regex, value);
+};
 const escapeRegex = (value) => {
 	return value.replace(regexEscapableCharsRegex, (char) => {
 		if (regexSyntaxCharsRegex.test(char)) return `\\${char}`;
@@ -16,8 +19,9 @@ const escapeRegex = (value) => {
 const isAnyOf = (value, patterns, parser) => {
 	if (isNullish(value)) return false;
 	const parsedValue = parser ? parser(value) : value.toLowerCase().trim();
+	const originalValue = parser ? parsedValue : value.trim();
 	return (typeof patterns === "string" || patterns instanceof RegExp ? [patterns] : patterns).some((pattern) => {
-		if (pattern instanceof RegExp) return testRegex(pattern, parsedValue);
+		if (pattern instanceof RegExp) return testRegexAnyCase(pattern, parsedValue, originalValue);
 		return parsedValue === (parser ? pattern : pattern.toLowerCase().trim());
 	});
 };
@@ -31,22 +35,23 @@ const getAnyOf = (value, patterns, parser) => {
 const includesAnyOf = (value, patterns, parser) => {
 	if (isNullish(value)) return false;
 	const parsedValue = parser ? parser(value) : value.toLowerCase();
+	const originalValue = parser ? parsedValue : value;
 	return patterns.some((pattern) => {
-		if (pattern instanceof RegExp) return testRegex(pattern, parsedValue);
+		if (pattern instanceof RegExp) return testRegexAnyCase(pattern, parsedValue, originalValue);
 		return pattern && parsedValue.includes(parser ? pattern : pattern.toLowerCase());
 	});
 };
 const startsWithAnyOf = (value, patterns) => {
 	const lowerValue = value.toLowerCase();
 	return patterns.some((pattern) => {
-		if (pattern instanceof RegExp) return testRegex(pattern, lowerValue);
+		if (pattern instanceof RegExp) return testRegexAnyCase(pattern, lowerValue, value);
 		return pattern && lowerValue.startsWith(pattern.toLowerCase());
 	});
 };
 const endsWithAnyOf = (value, patterns) => {
 	const lowerValue = value.toLowerCase();
 	return patterns.some((pattern) => {
-		if (pattern instanceof RegExp) return testRegex(pattern, lowerValue);
+		if (pattern instanceof RegExp) return testRegexAnyCase(pattern, lowerValue, value);
 		return pattern && lowerValue.endsWith(pattern.toLowerCase());
 	});
 };
@@ -61,10 +66,11 @@ const anyWordMatchesAnyOf = (value, patterns) => {
 		const stringPattern = pattern.toLowerCase().trim();
 		if (stringPattern) stringPatterns.push(stringPattern);
 	}
-	const words = value.toLowerCase().split(whitespaceRegex);
+	const words = value.split(whitespaceRegex);
 	for (const word of words) {
-		for (const stringPattern of stringPatterns) if (word === stringPattern) return true;
-		for (const regexPattern of regexPatterns) if (testRegex(regexPattern, word)) return true;
+		const lowerWord = word.toLowerCase();
+		for (const stringPattern of stringPatterns) if (lowerWord === stringPattern) return true;
+		for (const regexPattern of regexPatterns) if (testRegexAnyCase(regexPattern, lowerWord, word)) return true;
 	}
 	return false;
 };

package/dist/timers.js

@@ -1,7 +1,8 @@
 //#region src/timers.ts
+const maxDelay = 2 ** 31 - 1;
 const sleep = (milliseconds) => {
 	return new Promise((resolve) => {
-		setTimeout(resolve, milliseconds);
+		setTimeout(resolve, Math.min(milliseconds, maxDelay));
 	});
 };
 //#endregion

package/dist/types.d.ts

@@ -6,7 +6,12 @@ export type Nullish<T> = T | null | undefined;
 export type PartialNullish<T> = { [Key in keyof T]?: Nullish<T[Key]>; };
 export type MaybePromise<T> = T | Promise<T>;
 export type Pattern = string | RegExp;
+export type RegistrableDomainOptions = {
+  suffixes?: ReadonlyArray<string>;
+};
 export type NormalizeOptions = {
+  stripScheme?: boolean;
+  /** @deprecated Use `stripScheme` instead, which wins when both are set. */
   stripProtocol?: boolean;
   stripAuthentication?: boolean;
   stripWww?: boolean;

package/dist/urls.d.ts

@@ -1,4 +1,4 @@
-import { NormalizeOptions } from "./types.js";
+import { NormalizeOptions, RegistrableDomainOptions } from "./types.js";
 //#region src/urls.d.ts
 export declare const parseUrl: (value: string | URL, base?: string | URL) => URL | undefined;
 export declare const getPathSegments: (value: string | URL) => Array<string>;
@@ -8,13 +8,21 @@ export declare const isHttpUrl: (url: string | URL) => boolean;
 export declare const isHostOrSubdomainOf: (url: string | URL, domains: string | ReadonlyArray<string>) => boolean;
 export declare const getSubdomain: (url: string | URL, domains: string | ReadonlyArray<string>) => string | undefined;
 export declare const decodeSegment: (segment: string | undefined) => string | undefined;
-export declare const fixMalformedProtocol: (url: string) => string;
-export declare const resolveFeedProtocol: (url: string, protocol?: 'http' | 'https') => string;
-export declare const addMissingProtocol: (url: string, protocol?: 'http' | 'https') => string;
-export declare const upgradeProtocol: (url: string, protocol?: 'http' | 'https') => string;
+export declare const fixMalformedScheme: (url: string) => string;
+export declare const resolveFeedScheme: (url: string, scheme?: 'http' | 'https') => string;
+export declare const addMissingScheme: (url: string, scheme?: 'http' | 'https') => string;
+export declare const upgradeScheme: (url: string, scheme?: 'http' | 'https') => string;
 export declare const resolveUrl: (url: string, base?: string) => string | undefined;
 export declare const normalizeUrl: (url: string, options: NormalizeOptions) => string;
 export declare const stripWww: (hostname: string) => string;
 export declare const isIpAddress: (hostname: string) => boolean;
-export declare const getRegistrableDomain: (url: string | URL) => string | undefined;
+export declare const getRegistrableDomain: (url: string | URL, options?: RegistrableDomainOptions) => string | undefined;
+/** @deprecated Use `fixMalformedScheme` instead. */
+export declare const fixMalformedProtocol: typeof fixMalformedScheme;
+/** @deprecated Use `resolveFeedScheme` instead. */
+export declare const resolveFeedProtocol: typeof resolveFeedScheme;
+/** @deprecated Use `addMissingScheme` instead. */
+export declare const addMissingProtocol: typeof addMissingScheme;
+/** @deprecated Use `upgradeScheme` instead. */
+export declare const upgradeProtocol: typeof upgradeScheme;
 //#endregion

package/dist/urls.js

@@ -1,7 +1,7 @@
 import { endsWithAnyOf, isAnyOf } from "./matching.js";
 import { decodeHTMLStrict } from "entities";
 //#region src/urls.ts
-const httpProtocols = ["http:", "https:"];
+const httpSchemes = ["http:", "https:"];
 const parseUrl = (value, base) => {
 	if (value instanceof URL && base === void 0) return value;
 	if (URL.parse) return URL.parse(value, base) ?? void 0;
@@ -35,9 +35,9 @@ const isSubdomainOf = (url, domains) => {
 	return endsWithAnyOf(hostname, (typeof domains === "string" ? [domains] : domains).map((domain) => `.${normalizeDomain(domain)}`));
 };
 const isHttpUrl = (url) => {
-	const protocol = parseUrl(url)?.protocol;
-	if (!protocol) return false;
-	return httpProtocols.includes(protocol);
+	const scheme = parseUrl(url)?.protocol;
+	if (!scheme) return false;
+	return httpSchemes.includes(scheme);
 };
 const isHostOrSubdomainOf = (url, domains) => {
 	return isHostOf(url, domains) || isSubdomainOf(url, domains);
@@ -70,13 +70,13 @@ const ipv4Regex = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
 const ipv6Regex = /^([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$/i;
 const wwwPrefixRegex = /^www\./;
 const ipv6BracketsRegex = /^\[|\]$/g;
-const safePathCharsRegex = /[a-zA-Z0-9._~!$&'()*+,;=:@-]/;
+const unreservedCharsRegex = /[a-zA-Z0-9._~-]/;
 const httpsLetterRegex = /s/i;
-const protocolPrefixRegex = /^https?:\/\//;
+const schemePrefixRegex = /^https?:\/\//;
 const percentEscapeOrLettersRegex = /%[0-9A-Fa-f]{2}|[A-Z]+/g;
 const plusRegex = /\+/g;
-const httpProtocolRegex = /^http:\/\//i;
-const httpsProtocolRegex = /^https:\/\//i;
+const httpSchemeRegex = /^http:\/\//i;
+const httpsSchemeRegex = /^https:\/\//i;
 const leadingWhitespaceChars = [
 	" ",
 	"	",
@@ -89,30 +89,36 @@ const relativeLeadChars = [
 	"#"
 ];
 const localhostRegex = /^localhost(?:[:/?#]|$)/i;
+const schemeColonRegex = /^[^/]*:/;
+const missingColonSchemeRegex = /^https?[\s=.\\]*\/\//i;
 const validUrlRegex = /^https?:\/\/(?:www\.|[a-vx-z0-9])/i;
 const schemeSeparator = String.raw`\.*[:\s=\\/][:\s=.\\/]*`;
 const leadingSchemeSeparator = String.raw`\.*(?::[:\s=.\\/]*|[\s=\\/][:\s=.\\/]+)`;
-const doubledProtocolRegex = /* @__PURE__ */ new RegExp(String.raw`^\/?[htps]{2,7}${leadingSchemeSeparator}([htps]{2,7})(?!:\d)${schemeSeparator}[.,:/]*(www[./]+)?`, "i");
-const singleMalformedRegex = /* @__PURE__ */ new RegExp(String.raw`^\/?(?:h[htps():]{1,10}|t{1,2}ps?)${leadingSchemeSeparator}[.,:/]*(www[./]+)?`, "i");
-const fixMalformedProtocol = (url) => {
-	if (validUrlRegex.test(url) && !doubledProtocolRegex.test(url)) return url;
-	const doubledMatch = doubledProtocolRegex.exec(url);
-	if (doubledMatch) {
+const doubledSchemeRegex = /* @__PURE__ */ new RegExp(String.raw`^\/?[htps]{2,7}${leadingSchemeSeparator}([htps]{2,7})(?!:\d)(${schemeSeparator})[.,:/]*(www[./]+)?`, "i");
+const singleMalformedRegex = /* @__PURE__ */ new RegExp(String.raw`^\/?(h[htps():]{1,10}|t{1,2}ps?)(${leadingSchemeSeparator})[.,:/]*(www[./]+)?`, "i");
+const isSchemeToken = (token, separator) => {
+	const lowered = token.toLowerCase();
+	return `${token}${separator}`.includes(":") || lowered.includes("t") && lowered.includes("p");
+};
+const fixMalformedScheme = (url) => {
+	if (validUrlRegex.test(url) && !doubledSchemeRegex.test(url)) return url;
+	const doubledMatch = doubledSchemeRegex.exec(url);
+	if (doubledMatch && isSchemeToken(doubledMatch[1], doubledMatch[2])) {
 		const inner = doubledMatch[1];
-		const www = doubledMatch[2];
+		const www = doubledMatch[3];
 		const rest = url.slice(doubledMatch[0].length);
-		return (httpsLetterRegex.test(inner) ? "https://" : "http://") + (www ? "www." : "") + rest;
+		return `${httpsLetterRegex.test(inner) ? "https://" : "http://"}${www ? "www." : ""}${rest}`;
 	}
 	const singleMatch = singleMalformedRegex.exec(url);
-	if (singleMatch) {
+	if (singleMatch && isSchemeToken(singleMatch[1], singleMatch[2])) {
 		const fullMatch = singleMatch[0];
-		const www = singleMatch[1];
+		const www = singleMatch[3];
 		const rest = url.slice(fullMatch.length);
-		return (httpsLetterRegex.test(fullMatch) ? "https://" : "http://") + (www ? "www." : "") + rest;
+		return `${httpsLetterRegex.test(fullMatch) ? "https://" : "http://"}${www ? "www." : ""}${rest}`;
 	}
 	return url;
 };
-const feedProtocols = [
+const feedSchemes = [
 	"feed:",
 	"rss:",
 	"podcast:",
@@ -125,26 +131,26 @@ const feedProtocols = [
 	"itms-podcast:",
 	"itms-podcasts:"
 ];
-const resolveFeedProtocol = (url, protocol = "https") => {
+const resolveFeedScheme = (url, scheme = "https") => {
 	const firstCharCode = url.charCodeAt(0) | 32;
 	if (firstCharCode !== 102 && firstCharCode !== 114 && firstCharCode !== 112 && firstCharCode !== 105) return url;
 	const urlLower = url.toLowerCase();
-	for (const scheme of feedProtocols) {
-		if (!urlLower.startsWith(scheme)) continue;
-		if (urlLower.startsWith(`${scheme}http://`) || urlLower.startsWith(`${scheme}https://`)) return url.slice(scheme.length);
-		if (urlLower.startsWith(`${scheme}//`)) return `${protocol}:${url.slice(scheme.length)}`;
+	for (const prefix of feedSchemes) {
+		if (!urlLower.startsWith(prefix)) continue;
+		if (urlLower.startsWith(`${prefix}http://`) || urlLower.startsWith(`${prefix}https://`)) return url.slice(prefix.length);
+		if (urlLower.startsWith(`${prefix}//`)) return `${scheme}:${url.slice(prefix.length)}`;
 	}
 	return url;
 };
-const addMissingProtocol = (url, protocol = "https") => {
-	if (url.startsWith("[")) return parseUrl(`${protocol}://${url}`) ? `${protocol}://${url}` : url;
+const addMissingScheme = (url, scheme = "https") => {
+	if (url.startsWith("[")) return parseUrl(`${scheme}://${url}`) ? `${scheme}://${url}` : url;
 	const colonIndex = url.indexOf(":");
 	if (colonIndex > 0) {
 		const beforeColon = url.slice(0, colonIndex);
 		if (!beforeColon.includes(".") && !beforeColon.includes("/") && !localhostRegex.test(url)) return url;
 	}
 	if (url.startsWith("//") && !url.startsWith("///")) {
-		const parsed = parseUrl(`${protocol}:${url}`);
+		const parsed = parseUrl(`${scheme}:${url}`);
 		if (!parsed) return url;
 		const hostname = parsed.hostname;
 		if (hostname.includes(".") || hostname === "localhost" || isIpAddress(hostname)) return parsed.href;
@@ -158,11 +164,15 @@ const addMissingProtocol = (url, protocol = "https") => {
 	}
 	const firstChar = url.charAt(0);
 	if (leadingWhitespaceChars.includes(firstChar)) return url;
-	return `${protocol}://${url}`;
+	return `${scheme}://${url}`;
 };
-const upgradeProtocol = (url, protocol = "https") => {
-	if (protocol === "https") return url.replace(httpProtocolRegex, "https://");
-	return url.replace(httpsProtocolRegex, "http://");
+const upgradeScheme = (url, scheme = "https") => {
+	const sourceRegex = scheme === "https" ? httpSchemeRegex : httpsSchemeRegex;
+	if (!sourceRegex.test(url)) return url;
+	const parsed = parseUrl(url);
+	if (!parsed) return url.replace(sourceRegex, `${scheme}://`);
+	parsed.protocol = scheme;
+	return parsed.href;
 };
 const resolveUrl = (url, base) => {
 	const trimmedUrl = url.trim();
@@ -170,15 +180,15 @@ const resolveUrl = (url, base) => {
 	if (trimmedUrl.startsWith("#") && !base) return;
 	let resolvedUrl;
 	resolvedUrl = trimmedUrl.includes("&") ? decodeHTMLStrict(trimmedUrl) : trimmedUrl;
-	resolvedUrl = resolveFeedProtocol(resolvedUrl);
-	if (!base || !resolvedUrl.startsWith("/")) resolvedUrl = fixMalformedProtocol(resolvedUrl);
+	resolvedUrl = resolveFeedScheme(resolvedUrl);
+	if (!base || schemeColonRegex.test(resolvedUrl) || missingColonSchemeRegex.test(resolvedUrl)) resolvedUrl = fixMalformedScheme(resolvedUrl);
 	if (base) {
 		const resolved = parseUrl(resolvedUrl, base) ?? parseUrl(resolvedUrl);
 		if (!resolved) return;
 		if (isHttpUrl(resolved)) return resolved.href;
 		resolvedUrl = resolved.href;
 	}
-	resolvedUrl = addMissingProtocol(resolvedUrl);
+	resolvedUrl = addMissingScheme(resolvedUrl);
 	const parsed = parseUrl(resolvedUrl);
 	if (!parsed || !isHttpUrl(parsed)) return;
 	return parsed.href;
@@ -188,7 +198,7 @@ const decodeAndNormalizeEncoding = (value) => {
 	return value.replace(/%([0-9A-Fa-f]{2})/g, (_match, hex) => {
 		const charCode = Number.parseInt(hex, 16);
 		const char = String.fromCharCode(charCode);
-		if (safePathCharsRegex.test(char)) return char;
+		if (unreservedCharsRegex.test(char)) return char;
 		return `%${hex.toUpperCase()}`;
 	});
 };
@@ -225,14 +235,15 @@ const normalizeUrl = (url, options) => {
 		if (options.normalizeEncoding) pathname = decodeAndNormalizeEncoding(pathname);
 		if (options.collapseSlashes) pathname = pathname.replace(/\/+/g, "/");
 		if (options.stripTrailingSlash && pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
-		if (options.stripRootSlash && pathname === "/") pathname = "";
 		parsed.pathname = pathname;
+		if (options.normalizeEncoding && parsed.search.includes("%")) parsed.search = decodeAndNormalizeEncoding(parsed.search);
+		if (options.normalizeEncoding && parsed.hash.includes("%")) parsed.hash = decodeAndNormalizeEncoding(parsed.hash);
 		if (options.stripQuery) parsed.search = "";
 		if (parsed.search && (options.stripQueryParams || options.lowercaseQuery)) {
 			let pairs = parsed.search.slice(1).split("&");
 			if (options.stripQueryParams) {
 				const strippedSet = getStrippedParamsSet(options.stripQueryParams);
-				pairs = pairs.filter((pair) => !strippedSet.has(decodeQueryKey(pair).toLowerCase()));
+				pairs = pairs.filter((pair) => pair && !strippedSet.has(decodeQueryKey(pair).toLowerCase()));
 			}
 			if (options.lowercaseQuery) pairs = pairs.map(lowercaseQueryPair);
 			parsed.search = pairs.join("&");
@@ -241,7 +252,7 @@ const normalizeUrl = (url, options) => {
 		if (options.stripEmptyQuery && parsed.search === "") parsed.search = "";
 		let result = parsed.href;
 		if (options.stripRootSlash && result === `${parsed.origin}/`) result = parsed.origin;
-		if (options.stripProtocol) result = result.replace(protocolPrefixRegex, "");
+		if (options.stripScheme ?? options.stripProtocol) result = result.replace(schemePrefixRegex, "");
 		return result;
 	} catch {
 		return url;
@@ -268,15 +279,59 @@ const genericSecondLevels = [
 	"or",
 	"org"
 ];
-const getRegistrableDomain = (url) => {
+const suffixRulesCache = /* @__PURE__ */ new WeakMap();
+const getSuffixRules = (suffixes) => {
+	let cached = suffixRulesCache.get(suffixes);
+	if (cached) return cached;
+	cached = {
+		names: /* @__PURE__ */ new Set(),
+		wildcards: /* @__PURE__ */ new Set(),
+		exceptions: /* @__PURE__ */ new Set()
+	};
+	for (const entry of suffixes) {
+		const rule = entry.toLowerCase();
+		if (rule.startsWith("!")) {
+			cached.exceptions.add(normalizeDomain(rule.slice(1)));
+			continue;
+		}
+		if (rule.startsWith("*.")) {
+			cached.wildcards.add(normalizeDomain(rule.slice(2)));
+			continue;
+		}
+		cached.names.add(normalizeDomain(rule));
+	}
+	suffixRulesCache.set(suffixes, cached);
+	return cached;
+};
+const getPublicSuffixLength = (labels, rules) => {
+	for (let index = 0; index < labels.length; index++) if (rules.exceptions.has(labels.slice(index).join("."))) return labels.length - index - 1;
+	for (let index = 0; index < labels.length; index++) {
+		if (rules.names.has(labels.slice(index).join("."))) return labels.length - index;
+		if (index + 1 < labels.length && rules.wildcards.has(labels.slice(index + 1).join("."))) return labels.length - index;
+	}
+	return 1;
+};
+const getRegistrableDomain = (url, options) => {
 	const hostname = getHostname(url)?.toLowerCase();
 	if (!hostname) return;
 	if (isIpAddress(hostname)) return hostname;
 	const parts = hostname.split(".");
+	if (options?.suffixes) {
+		const suffixLength = getPublicSuffixLength(parts, getSuffixRules(options.suffixes));
+		return parts.slice(-Math.min(suffixLength + 1, parts.length)).join(".");
+	}
 	if (parts.length <= 2) return hostname;
 	const [secondLevel, topLevel] = parts.slice(-2);
 	const labels = topLevel.length === 2 && genericSecondLevels.includes(secondLevel) ? 3 : 2;
 	return parts.slice(-labels).join(".");
 };
+/** @deprecated Use `fixMalformedScheme` instead. */
+const fixMalformedProtocol = fixMalformedScheme;
+/** @deprecated Use `resolveFeedScheme` instead. */
+const resolveFeedProtocol = resolveFeedScheme;
+/** @deprecated Use `addMissingScheme` instead. */
+const addMissingProtocol = addMissingScheme;
+/** @deprecated Use `upgradeScheme` instead. */
+const upgradeProtocol = upgradeScheme;
 //#endregion
-export { addMissingProtocol, decodeSegment, fixMalformedProtocol, getPathSegments, getRegistrableDomain, getSubdomain, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedProtocol, resolveUrl, stripWww, upgradeProtocol };
+export { addMissingProtocol, addMissingScheme, decodeSegment, fixMalformedProtocol, fixMalformedScheme, getPathSegments, getRegistrableDomain, getSubdomain, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedProtocol, resolveFeedScheme, resolveUrl, stripWww, upgradeProtocol, upgradeScheme };

package/package.json

@@ -40,11 +40,11 @@
   },
   "devDependencies": {
     "@types/bun": "^1.4.2",
-    "kvalita": "^1.24.0",
+    "kvalita": "^1.24.3",
     "tsdown": "^0.23.0"
   },
   "dependencies": {
     "entities": "^8.1.0"
   },
-  "version": "2.6.1"
+  "version": "2.7.0"
 }