trousse 2.6.0 → 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/is.js

@@ -21,7 +21,7 @@ const isObject = (value) => {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 };
 const isPlainObject = (value) => {
-	return isObject(value) && value.constructor === Object;
+	return isObject(value) && Object.getPrototypeOf(value) === Object.prototype;
 };
 const whitespaceOnlyRegex = /^\p{White_Space}*$/u;
 const isNonEmptyString = (value) => {

package/dist/locales.js

@@ -13,10 +13,14 @@ const escapeHtml = (value) => {
 	});
 };
 const t = (template, params) => {
-	return template.replace(placeholderRegex, (_, key) => String(params[key]));
+	return template.replace(placeholderRegex, (placeholder, key) => {
+		return Object.hasOwn(params, key) ? String(params[key]) : placeholder;
+	});
 };
 const tx = (template, params) => {
-	return template.replace(placeholderRegex, (_, key) => escapeHtml(String(params[key])));
+	return template.replace(placeholderRegex, (placeholder, key) => {
+		return Object.hasOwn(params, key) ? escapeHtml(String(params[key])) : placeholder;
+	});
 };
 //#endregion
 export { escapeHtml, t, tx };

package/dist/matching.js

@@ -1,54 +1,76 @@
 import { isNullish } from "./is.js";
 //#region src/matching.ts
 const whitespaceRegex = /\s+/;
-const regexMetaCharsRegex = /[.*+?^${}()|[\]\\-]/g;
+const regexSyntaxCharsRegex = /[.*+?^${}()|[\]\\/]/;
+const regexEscapableCharsRegex = /[.*+?^${}()|[\]\\/&!#%,:;<=>@`~-]/g;
+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(regexMetaCharsRegex, "\\$&");
+	return value.replace(regexEscapableCharsRegex, (char) => {
+		if (regexSyntaxCharsRegex.test(char)) return `\\${char}`;
+		return `\\x${char.charCodeAt(0).toString(16)}`;
+	});
 };
 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 pattern.test(parsedValue);
-		return parsedValue === pattern.toLowerCase().trim();
+		if (pattern instanceof RegExp) return testRegexAnyCase(pattern, parsedValue, originalValue);
+		return parsedValue === (parser ? pattern : pattern.toLowerCase().trim());
 	});
 };
 const getAnyOf = (value, patterns, parser) => {
 	if (isNullish(value)) return;
 	const parsedValue = parser ? parser(value) : value.toLowerCase().trim();
-	return patterns.find((pattern) => parsedValue === pattern.toLowerCase().trim());
+	return patterns.find((pattern) => {
+		return parsedValue === (parser ? pattern : pattern.toLowerCase().trim());
+	});
 };
 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 pattern.test(parsedValue);
-		return pattern && parsedValue.includes(pattern.toLowerCase());
+		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 pattern.test(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 pattern.test(lowerValue);
+		if (pattern instanceof RegExp) return testRegexAnyCase(pattern, lowerValue, value);
 		return pattern && lowerValue.endsWith(pattern.toLowerCase());
 	});
 };
 const anyWordMatchesAnyOf = (value, patterns) => {
 	const stringPatterns = [];
 	const regexPatterns = [];
-	for (const pattern of patterns) if (pattern instanceof RegExp) regexPatterns.push(pattern);
-	else stringPatterns.push(pattern.toLowerCase().trim());
-	const words = value.toLowerCase().split(whitespaceRegex);
+	for (const pattern of patterns) {
+		if (pattern instanceof RegExp) {
+			regexPatterns.push(pattern);
+			continue;
+		}
+		const stringPattern = pattern.toLowerCase().trim();
+		if (stringPattern) stringPatterns.push(stringPattern);
+	}
+	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 (regexPattern.test(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/objects.js

@@ -1,8 +1,20 @@
 import { isPresent } from "./is.js";
 //#region src/objects.ts
+const setKey = (object, key, value) => {
+	if (key === "__proto__") {
+		Object.defineProperty(object, key, {
+			value,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		return;
+	}
+	object[key] = value;
+};
 const pick = (object, keys) => {
 	const result = {};
-	for (const key of keys) if (key in object) result[key] = object[key];
+	for (const key of keys) if (key in object) setKey(result, key, object[key]);
 	return result;
 };
 const omit = (object, keys) => {
@@ -23,7 +35,7 @@ const trimObject = (object, keep = isPresent) => {
 	const result = {};
 	for (const key in object) {
 		const value = object[key];
-		if (keep(value)) result[key] = value;
+		if (keep(value)) setKey(result, key, value);
 	}
 	return result;
 };

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;
@@ -15,7 +20,7 @@ export type NormalizeOptions = {
   collapseSlashes?: boolean;
   stripHash?: boolean;
   sortQueryParams?: boolean;
-  stripQueryParams?: Array<string>;
+  stripQueryParams?: ReadonlyArray<string>;
   stripQuery?: boolean;
   stripEmptyQuery?: boolean;
   lowercaseQuery?: 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,9 +1,10 @@
 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;
 	try {
 		return new URL(value, base);
 	} catch {}
@@ -11,30 +12,42 @@ const parseUrl = (value, base) => {
 const getPathSegments = (value) => {
 	return parseUrl(value)?.pathname.split("/").filter(Boolean) ?? [];
 };
-const isHostOf = (url, hosts) => {
+const getHostname = (url) => {
 	const hostname = parseUrl(url)?.hostname;
+	if (!hostname) return;
+	return hostname.endsWith(".") ? hostname.slice(0, -1) : hostname;
+};
+const nonAsciiRegex = /[\u0080-\uffff]/;
+const normalizeDomain = (domain) => {
+	const trimmed = domain.trim();
+	const bare = trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+	if (!nonAsciiRegex.test(bare)) return bare;
+	return parseUrl(`http://${bare}`)?.hostname ?? bare;
+};
+const isHostOf = (url, hosts) => {
+	const hostname = getHostname(url);
 	if (!hostname) return false;
-	return isAnyOf(hostname, hosts);
+	return isAnyOf(hostname, (typeof hosts === "string" ? [hosts] : hosts).map(normalizeDomain));
 };
 const isSubdomainOf = (url, domains) => {
-	const hostname = parseUrl(url)?.hostname;
+	const hostname = getHostname(url);
 	if (!hostname) return false;
-	return endsWithAnyOf(hostname, (typeof domains === "string" ? [domains] : domains).map((domain) => `.${domain}`));
+	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);
 };
 const getSubdomain = (url, domains) => {
-	const hostname = parseUrl(url)?.hostname.toLowerCase();
+	const hostname = getHostname(url)?.toLowerCase();
 	if (!hostname) return;
 	const list = typeof domains === "string" ? [domains] : domains;
 	for (const domain of list) {
-		const suffix = `.${domain.toLowerCase()}`;
+		const suffix = `.${normalizeDomain(domain).toLowerCase()}`;
 		if (hostname.endsWith(suffix) && hostname.length > suffix.length) return hostname.slice(0, -suffix.length);
 	}
 };
@@ -57,41 +70,55 @@ 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 = [
 	" ",
 	"	",
 	"\n"
 ];
+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 doubledProtocolRegex = new RegExp(String.raw`^\/?[htps]{2,7}${schemeSeparator}([htps]{2,7})${schemeSeparator}[.,:/]*(www[./]+)?`, "i");
-const singleMalformedRegex = new RegExp(String.raw`^\/?(?:h[htps():]{1,10}|t{1,2}ps?)${schemeSeparator}[.,:/]*(www[./]+)?`, "i");
-const fixMalformedProtocol = (url) => {
-	if (validUrlRegex.test(url) && !doubledProtocolRegex.test(url)) return url;
-	const doubledMatch = doubledProtocolRegex.exec(url);
-	if (doubledMatch) {
+const leadingSchemeSeparator = String.raw`\.*(?::[:\s=.\\/]*|[\s=\\/][:\s=.\\/]+)`;
+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:",
@@ -104,57 +131,64 @@ 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") => {
+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("/") && beforeColon !== "localhost") return url;
+		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;
 		return url;
 	}
-	if (url.startsWith("/") || url.startsWith(".")) return url;
+	if (relativeLeadChars.includes(url.charAt(0))) return url;
 	const slashIndex = url.indexOf("/");
 	const dotIndex = url.indexOf(".");
 	if (dotIndex === -1 || slashIndex !== -1 && dotIndex > slashIndex) {
-		if (!url.startsWith("localhost")) return url;
+		if (!localhostRegex.test(url)) return url;
 	}
 	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) => {
-	if (url.startsWith("#") && !base) return;
+	const trimmedUrl = url.trim();
+	if (!trimmedUrl) return;
+	if (trimmedUrl.startsWith("#") && !base) return;
 	let resolvedUrl;
-	resolvedUrl = url.includes("&") ? decodeHTMLStrict(url) : url;
-	resolvedUrl = resolveFeedProtocol(resolvedUrl);
-	resolvedUrl = fixMalformedProtocol(resolvedUrl);
+	resolvedUrl = trimmedUrl.includes("&") ? decodeHTMLStrict(trimmedUrl) : trimmedUrl;
+	resolvedUrl = resolveFeedScheme(resolvedUrl);
+	if (!base || schemeColonRegex.test(resolvedUrl) || missingColonSchemeRegex.test(resolvedUrl)) resolvedUrl = fixMalformedScheme(resolvedUrl);
 	if (base) {
-		const resolved = parseUrl(resolvedUrl, 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;
@@ -164,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()}`;
 	});
 };
@@ -190,11 +224,7 @@ const lowercaseQueryPair = (pair) => {
 };
 const normalizeUrl = (url, options) => {
 	try {
-		const parsed = new URL(url);
-		if (options.normalizeUnicode) {
-			parsed.hostname = parsed.hostname.normalize("NFC");
-			parsed.pathname = parsed.pathname.normalize("NFC");
-		}
+		const parsed = new URL(options.normalizeUnicode ? url.normalize("NFC") : url);
 		if (options.stripAuthentication) {
 			parsed.username = "";
 			parsed.password = "";
@@ -205,30 +235,32 @@ 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("&");
 		}
 		if (options.sortQueryParams && parsed.search.includes("&")) parsed.search = parsed.search.slice(1).split("&").filter(Boolean).sort(compareQueryPairs).join("&");
-		if (options.stripEmptyQuery && parsed.href.endsWith("?")) parsed.search = "";
+		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;
 	}
 };
 const stripWww = (hostname) => {
-	return hostname.replace(wwwPrefixRegex, "");
+	const stripped = hostname.replace(wwwPrefixRegex, "");
+	return stripped.includes(".") ? stripped : hostname;
 };
 const isIpAddress = (hostname) => {
 	return ipv4Regex.test(hostname) || ipv6Regex.test(hostname.replace(ipv6BracketsRegex, ""));
@@ -247,15 +279,59 @@ const genericSecondLevels = [
 	"or",
 	"org"
 ];
-const getRegistrableDomain = (url) => {
-	const hostname = parseUrl(url)?.hostname;
+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.0"
+  "version": "2.7.0"
 }