urlpurify 2.2.0 → 2.3.0

package/dist/node_modules/trousse/dist/urls.mjs

@@ -1,5 +1,5 @@
-import { isNullish } from "./is.mjs";
-import { endsWithAnyOf, isAnyOf } from "./matching.mjs";
+import { isFunction, isNullish, isString } from "./is.mjs";
+import { isAnyOf, toPatternList } from "./matching.mjs";
 import { decodeHTMLStrict } from "../../entities/dist/decode.mjs";
 // node_modules/trousse/dist/urls.js
 const httpSchemes = ["http:", "https:"];
@@ -11,6 +11,9 @@ const parseUrl = (value, base) => {
 		return new URL(value, base);
 	} catch {}
 };
+const getPathSegments = (value) => {
+	return parseUrl(value)?.pathname.split("/").filter(Boolean) ?? [];
+};
 const getHostname = (url) => {
 	const hostname = parseUrl(url)?.hostname;
 	if (!hostname) return;
@@ -19,19 +22,48 @@ const getHostname = (url) => {
 const nonAsciiRegex = /[\u0080-\uffff]/;
 const normalizeDomain = (domain) => {
 	const trimmed = domain.trim();
-	const bare = trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+	const bare = trimmed.endsWith(".") ? trimmed.slice(0, -1).trimEnd() : trimmed;
 	if (!nonAsciiRegex.test(bare)) return bare;
 	return parseUrl(`http://${bare}`)?.hostname ?? bare;
 };
+const getParentDomains = (hostname) => {
+	const parents = [];
+	for (let index = hostname.indexOf("."); index !== -1; index = hostname.indexOf(".", index + 1)) parents.push(hostname.slice(index + 1));
+	return parents;
+};
+const keepValue = (value) => value;
+const endsWithDomain = (lowerHostname, domain) => {
+	const lowerDomain = domain.toLowerCase();
+	if (lowerHostname.at(-lowerDomain.length - 1) !== ".") return false;
+	return !lowerDomain || isAnyOf(lowerHostname.slice(-lowerDomain.length), lowerDomain, keepValue);
+};
 const isHostOf = (url, hosts) => {
 	const hostname = getHostname(url);
 	if (!hostname) return false;
-	return isAnyOf(hostname, (typeof hosts === "string" ? [hosts] : hosts).map(normalizeDomain));
+	const lowerHostname = hostname.toLowerCase();
+	for (const host of toPatternList(hosts)) {
+		if (host instanceof RegExp) {
+			if (isAnyOf(hostname, host)) return true;
+			continue;
+		}
+		if (isAnyOf(lowerHostname, normalizeDomain(host).toLowerCase(), keepValue)) return true;
+	}
+	return false;
 };
 const isSubdomainOf = (url, domains) => {
 	const hostname = getHostname(url);
 	if (!hostname) return false;
-	return endsWithAnyOf(hostname, (typeof domains === "string" ? [domains] : domains).map((domain) => `.${normalizeDomain(domain)}`));
+	const lowerHostname = hostname.toLowerCase();
+	const patterns = [];
+	for (const domain of toPatternList(domains)) {
+		if (domain instanceof RegExp) {
+			patterns.push(domain);
+			continue;
+		}
+		if (endsWithDomain(lowerHostname, normalizeDomain(domain))) return true;
+	}
+	if (patterns.length === 0) return false;
+	return getParentDomains(hostname).some((parent) => isAnyOf(parent, patterns));
 };
 const isHttpUrl = (url) => {
 	const scheme = parseUrl(url)?.protocol;
@@ -41,6 +73,21 @@ const isHttpUrl = (url) => {
 const isHostOrSubdomainOf = (url, domains) => {
 	return isHostOf(url, domains) || isSubdomainOf(url, domains);
 };
+const getSubdomain = (url, domains) => {
+	const hostname = getHostname(url)?.toLowerCase();
+	if (!hostname) return;
+	let parents;
+	for (const domain of toPatternList(domains)) {
+		if (isString(domain)) {
+			const name = normalizeDomain(domain);
+			if (name && endsWithDomain(hostname, name)) return hostname.slice(0, -name.length - 1);
+			continue;
+		}
+		if (!parents) parents = getParentDomains(hostname);
+		const parent = parents.find((candidate) => isAnyOf(candidate, domain));
+		if (parent) return hostname.slice(0, -parent.length - 1);
+	}
+};
 const escapeRunRegex = /(?:%[0-9A-Fa-f]{2})+/g;
 const getSequenceLength = (byte) => {
 	if (byte < 128) return 1;
@@ -72,6 +119,43 @@ const decodeEscapeRun = (run) => {
 const decodePercent = (value) => {
 	return value.replace(escapeRunRegex, decodeEscapeRun);
 };
+const decodeBase64Binary = (value) => {
+	try {
+		return atob(value);
+	} catch {}
+};
+const utf8Decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+const isUtf8Binary = (binary) => {
+	try {
+		utf8Decoder.decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+		return true;
+	} catch {
+		return false;
+	}
+};
+const decodeBase64 = (value) => {
+	const binary = decodeBase64Binary(value);
+	if (binary === void 0) return;
+	let encoded = "";
+	for (let index = 0; index < binary.length; index++) {
+		const byte = binary.charCodeAt(index);
+		if (byte < 128 && binary[index] !== "%") {
+			encoded += binary[index];
+			continue;
+		}
+		encoded += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	}
+	return decodePercent(encoded);
+};
+const toBase64 = (base64Url) => {
+	return base64Url.replaceAll("-", "+").replaceAll("_", "/");
+};
+const decodeBase64Url = (value) => {
+	return decodeBase64(toBase64(value));
+};
+const decodeBase64UrlBinary = (value) => {
+	return decodeBase64Binary(toBase64(value));
+};
 const readRawPairs = (text, prefix) => {
 	if (text === void 0) return;
 	const pairs = [];
@@ -91,7 +175,7 @@ const readRawPairs = (text, prefix) => {
 const readQuerySource = (source, options) => {
 	if (options?.decodeValues === false) return readRawPairs(source instanceof URL ? source.search : source?.toString(), "?");
 	if (source instanceof URL) return source.searchParams;
-	if (typeof source === "string") return new URLSearchParams(source);
+	if (isString(source)) return new URLSearchParams(source);
 	return source;
 };
 const readParamValues = (params, name, options) => {
@@ -105,9 +189,21 @@ const readParamValues = (params, name, options) => {
 	}
 	return values;
 };
+const hasParam = (params, name) => {
+	if (!params) return false;
+	const lowercaseName = name.toLowerCase();
+	for (const [key] of params) if (key.toLowerCase() === lowercaseName) return true;
+	return false;
+};
+const hasQueryParam = (source, name) => {
+	return hasParam(readQuerySource(source), name);
+};
 const getQueryParamValues = (source, name, options) => {
 	return readParamValues(readQuerySource(source, options), name, options);
 };
+const getQueryParam = (source, name, options) => {
+	return getQueryParamValues(source, name, options)[0];
+};
 const strippedParamsCache = /* @__PURE__ */ new WeakMap();
 const getStrippedParamsSet = (params) => {
 	let cached = strippedParamsCache.get(params);
@@ -121,6 +217,7 @@ 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 hostnameLabelRegex = /^[a-z0-9_-]+$/i;
 const unreservedCharsRegex = /[a-zA-Z0-9._~-]/;
 const httpsLetterRegex = /s/i;
 const schemePrefixRegex = /^https?:\/\//;
@@ -145,12 +242,13 @@ const validUrlRegex = /^https?:\/\/(?:www\.|[a-vx-z0-9])/i;
 const schemeSeparator = String.raw`\.*[:\s=\\/][:\s=.\\/]*`;
 const separatorChar = String.raw`(?:[:\s=.\\/]|%20|%c2%a0)`;
 const leadingSchemeSeparator = String.raw`\.*(?::${separatorChar}*|[\s=\\/]${separatorChar}+)`;
-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 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 brokenSlashEscapeRegex = /^[^/]*\/[,.]/;
 const fixMalformedScheme = (url) => {
 	if (validUrlRegex.test(url) && !doubledSchemeRegex.test(url)) return url;
 	const doubledMatch = doubledSchemeRegex.exec(url);
@@ -158,6 +256,7 @@ const fixMalformedScheme = (url) => {
 		const inner = doubledMatch[1];
 		const www = doubledMatch[3];
 		const rest = url.slice(doubledMatch[0].length);
+		if (brokenSlashEscapeRegex.test(`${doubledMatch[2]}${rest}`)) return url;
 		return `${httpsLetterRegex.test(inner) ? "https://" : "http://"}${www ? "www." : ""}${rest}`;
 	}
 	const singleMatch = singleMalformedRegex.exec(url);
@@ -165,10 +264,32 @@ const fixMalformedScheme = (url) => {
 		const fullMatch = singleMatch[0];
 		const www = singleMatch[3];
 		const rest = url.slice(fullMatch.length);
+		if (brokenSlashEscapeRegex.test(`${singleMatch[2]}${rest}`)) return url;
 		return `${httpsLetterRegex.test(fullMatch) ? "https://" : "http://"}${www ? "www." : ""}${rest}`;
 	}
 	return url;
 };
+const authorityRegex = /^(?:[a-z][a-z\d+.-]*:)?\/\/[^/?#\\]*/i;
+const doubledDotRegex = /(?<!\.)\.\.(?!\.)/g;
+const trailingHostJunkChars = [
+	")",
+	",",
+	"'",
+	"&"
+];
+const fixMalformedHost = (url) => {
+	const authority = authorityRegex.exec(url)?.[0];
+	if (!authority) return url;
+	const hostStart = Math.max(authority.indexOf("//") + 2, authority.lastIndexOf("@") + 1);
+	const host = authority.slice(hostStart);
+	let hostEnd = host.length;
+	while (hostEnd > 0 && trailingHostJunkChars.includes(host.charAt(hostEnd - 1))) hostEnd--;
+	let fixedHost = host.slice(0, hostEnd).replace(doubledDotRegex, ".");
+	if (fixedHost.startsWith(".") && !fixedHost.startsWith("..")) fixedHost = fixedHost.slice(1);
+	if (fixedHost.endsWith(".")) return url;
+	if (!fixedHost || fixedHost.startsWith(",")) return url;
+	return `${url.slice(0, hostStart)}${fixedHost}${url.slice(authority.length)}`;
+};
 const segmentEdgeSpace = "(?:\\s|%(?:09|0A|0D|20))";
 const valueEdgeSpace = "(?:\\s|\\+|%(?:09|0A|0D|20))";
 new RegExp(`^${segmentEdgeSpace}+|(?<!${segmentEdgeSpace})${segmentEdgeSpace}+$`, "gi");
@@ -227,6 +348,7 @@ const resolveUrl = (url, base) => {
 	resolvedUrl = trimmedUrl.includes("&") ? decodeHTMLStrict(trimmedUrl) : trimmedUrl;
 	resolvedUrl = resolveFeedScheme(resolvedUrl);
 	if (!base || schemeColonRegex.test(resolvedUrl) || missingColonSchemeRegex.test(resolvedUrl)) resolvedUrl = fixMalformedScheme(resolvedUrl);
+	resolvedUrl = fixMalformedHost(resolvedUrl);
 	if (base) {
 		const resolved = parseUrl(resolvedUrl, base) ?? parseUrl(resolvedUrl);
 		if (!resolved) return;
@@ -238,23 +360,43 @@ const resolveUrl = (url, base) => {
 	if (!parsed || !isHttpUrl(parsed)) return;
 	return parsed.href;
 };
+const valueShapeEscapeRegex = /(%(?:26|23|25|2B|3B))/gi;
+const nameShapeEscapeRegex = /(%(?:26|23|25|2B|3B|3D))/gi;
+const decodeQueryPart = (part, shapeRegex) => {
+	return part.replace(plusRegex, "%20").split(shapeRegex).map((chunk, index) => index % 2 ? chunk.toUpperCase() : decodePercent(chunk)).join("");
+};
+const canonicalizeQuery = (search) => {
+	return `?${search.slice(1).split("&").map((pair) => {
+		const at = pair.indexOf("=");
+		if (at === -1) return decodeQueryPart(pair, nameShapeEscapeRegex);
+		return `${decodeQueryPart(pair.slice(0, at), nameShapeEscapeRegex)}=${decodeQueryPart(pair.slice(at + 1), valueShapeEscapeRegex)}`;
+	}).join("&")}`;
+};
 const decodeAndNormalizeEncoding = (value) => {
 	if (!value.includes("%")) return value;
-	return value.replace(/%([0-9A-Fa-f]{2})/g, (_match, hex) => {
-		const charCode = Number.parseInt(hex, 16);
+	return value.replace(percentEscapeRegex, (hex) => {
+		const charCode = Number.parseInt(hex.slice(1), 16);
 		const char = String.fromCharCode(charCode);
 		if (unreservedCharsRegex.test(char)) return char;
-		return `%${hex.toUpperCase()}`;
+		return hex.toUpperCase();
 	});
 };
-const decodeQueryKey = (pair) => {
-	const key = pair.split("=")[0].replace(plusRegex, " ");
+const decodeQueryComponent = (component) => {
+	const spaced = component.replace(plusRegex, " ");
 	try {
-		return decodeURIComponent(key);
+		return decodeURIComponent(spaced);
 	} catch {
-		return key;
+		return spaced;
 	}
 };
+const decodeQueryKey = (pair) => {
+	return decodeQueryComponent(pair.split("=")[0]);
+};
+const decodeQueryValue = (pair) => {
+	const separatorIndex = pair.indexOf("=");
+	if (separatorIndex === -1) return;
+	return decodeQueryComponent(pair.slice(separatorIndex + 1));
+};
 const compareQueryPairs = (a, b) => {
 	const keyA = decodeQueryKey(a);
 	const keyB = decodeQueryKey(b);
@@ -268,41 +410,46 @@ const lowercaseQueryPair = (pair) => {
 	});
 };
 const normalizeUrl = (url, options) => {
-	try {
-		const parsed = new URL(options.normalizeUnicode ? url.normalize("NFC") : url);
-		if (options.stripHostTrailingDot && parsed.hostname.endsWith(".")) parsed.hostname = parsed.hostname.slice(0, -1);
-		if (options.stripAuthentication) {
-			parsed.username = "";
-			parsed.password = "";
-		}
-		if (options.stripWww) parsed.hostname = stripWww(parsed.hostname);
-		if (options.stripHash) parsed.hash = "";
-		let pathname = parsed.pathname;
-		if (options.normalizeEncoding) pathname = decodeAndNormalizeEncoding(pathname);
-		if (options.collapseSlashes) pathname = pathname.replace(repeatedSlashesRegex, "/");
-		if (options.stripTrailingSlash && pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
-		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) => pair && !strippedSet.has(decodeQueryKey(pair).toLowerCase()));
-			}
-			if (options.lowercaseQuery) pairs = pairs.map(lowercaseQueryPair);
-			parsed.search = pairs.join("&");
+	const parsed = parseUrl(options.normalizeUnicode ? url.normalize("NFC") : url);
+	if (!parsed) return url;
+	if (options.stripHostTrailingDot && parsed.hostname.endsWith(".")) parsed.hostname = parsed.hostname.slice(0, -1);
+	if (options.stripAuthentication) {
+		parsed.username = "";
+		parsed.password = "";
+	}
+	if (options.stripWww) parsed.hostname = stripWww(parsed.hostname);
+	if (options.stripHash) parsed.hash = "";
+	let pathname = parsed.pathname;
+	if (options.normalizeEncoding) pathname = decodeAndNormalizeEncoding(pathname);
+	if (options.collapseSlashes) pathname = pathname.replace(repeatedSlashesRegex, "/");
+	if (options.stripTrailingSlash && pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+	parsed.pathname = pathname;
+	if (options.normalizeEncoding && parsed.search.length > 1) {
+		parsed.search = canonicalizeQuery(parsed.search);
+		parsed.search = parsed.search.replace(percentEscapeRegex, (hex) => hex.toUpperCase());
+	}
+	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 (isFunction(options.stripQueryParams)) {
+			const isStripped = options.stripQueryParams;
+			pairs = pairs.filter((pair) => {
+				return pair && !isStripped(decodeQueryKey(pair), decodeQueryValue(pair), parsed);
+			});
+		} else if (options.stripQueryParams) {
+			const strippedSet = getStrippedParamsSet(options.stripQueryParams);
+			pairs = pairs.filter((pair) => pair && !strippedSet.has(decodeQueryKey(pair).toLowerCase()));
 		}
-		if (options.sortQueryParams && parsed.search.includes("&")) parsed.search = parsed.search.slice(1).split("&").filter(Boolean).sort(compareQueryPairs).join("&");
-		if (options.stripEmptyQuery && !parsed.search) parsed.search = "";
-		let result = parsed.href;
-		if (options.stripRootSlash && result === `${parsed.origin}/`) result = parsed.origin;
-		if (options.stripScheme ?? options.stripProtocol) result = result.replace(schemePrefixRegex, "");
-		return result;
-	} catch {
-		return url;
+		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.search) parsed.search = "";
+	let result = parsed.href;
+	if (options.stripRootSlash && result === `${parsed.origin}/`) result = parsed.origin;
+	if (options.stripScheme ?? options.stripProtocol) result = result.replace(schemePrefixRegex, "");
+	return result;
 };
 const stripWww = (hostname) => {
 	return hostname.replace(wwwPrefixRegex, "");
@@ -310,6 +457,11 @@ const stripWww = (hostname) => {
 const isIpAddress = (hostname) => {
 	return ipv4Regex.test(hostname) || ipv6Regex.test(hostname.replace(ipv6BracketsRegex, ""));
 };
-/** @deprecated Use `addMissingScheme` instead. */
-const addMissingProtocol = addMissingScheme;
-export { addMissingProtocol, addMissingScheme, decodePercent, fixMalformedScheme, getQueryParamValues, isHostOf, isHostOrSubdomainOf, isHttpUrl, isIpAddress, isSubdomainOf, normalizeUrl, parseUrl, resolveFeedScheme, resolveUrl, stripWww };
+const isHostname = (host) => {
+	if (isIpAddress(host)) return true;
+	return (host.endsWith(".") ? host.slice(0, -1) : host).split(".").every((label) => {
+		return label.length <= 63 && hostnameLabelRegex.test(label);
+	});
+};
+const percentEscapeRegex = /%[0-9a-f]{2}/gi;
+export { addMissingScheme, decodeBase64, decodeBase64Binary, decodeBase64Url, decodeBase64UrlBinary, decodePercent, fixMalformedHost, fixMalformedScheme, getPathSegments, getQueryParam, getQueryParamValues, getSubdomain, hasQueryParam, isHostOf, isHostOrSubdomainOf, isHostname, isHttpUrl, isIpAddress, isSubdomainOf, isUtf8Binary, normalizeUrl, parseUrl, resolveFeedScheme, resolveUrl, stripWww };

package/dist/pathTarget.mjs

@@ -1,12 +1,12 @@
 // src/pathTarget.ts
 const leadingSlashesRegex = /^\/+/;
 const schemeRegex = /^https?:/i;
-const getPathTarget = (url, prefixRegex, scheme = "https:") => {
+const getPathTarget = (url, prefixRegex, scheme = "https:", suffix = `${url.search}${url.hash}`) => {
 	const match = url.pathname.match(prefixRegex);
 	if (!match) return;
 	const path = url.pathname.slice(match[0].length).replace(leadingSlashesRegex, "");
 	if (!path) return;
-	const target = `${path}${url.search}${url.hash}`;
+	const target = `${path}${suffix}`;
 	if (schemeRegex.test(target)) return target;
 	return `${scheme}//${target}`;
 };

package/dist/tracking/clickAttribution.mjs

@@ -1,4 +1,5 @@
 // src/tracking/clickAttribution.ts
+const everyNameRegex = /^/;
 const clickAttributionParams = [
 	"gclid",
 	"dclid",
@@ -47,6 +48,30 @@ const clickAttributionParams = [
 	"spm",
 	"trk",
 	"wickedid",
-	/^hsa_[a-z0-9_]+$/
+	/^hsa_[a-z0-9_]+$/,
+	{
+		name: /^(?!(?:modal_id|vid)$)/,
+		hosts: /(?:^|\.)(?:douyin|iesdouyin)\.com$/
+	},
+	{
+		name: everyNameRegex,
+		hosts: /(?:^|\.)(?:kuaishou\.com|m\.chenzhongtech\.com)$|^m\.gifshow\.com$/
+	},
+	{
+		name: everyNameRegex,
+		hosts: ["post.smzdm.com", "smzdm.com"]
+	},
+	{
+		name: /^(?!(?:id|shopid|skuids|suitid|wareid)$)/,
+		hosts: ["item.jd.com", "item.m.jd.com"]
+	},
+	{
+		name: /^(?!id$)/,
+		hosts: ["y.music.163.com"]
+	},
+	{
+		name: /^(?!xsec_token$)/,
+		hosts: /(?:^|\.)xiaohongshu\.com$/
+	}
 ];
 export { clickAttributionParams };

package/dist/tracking/housekeeping.mjs

@@ -1,4 +1,12 @@
+import { parseUrl, stripWww } from "../node_modules/trousse/dist/urls.mjs";
 // src/tracking/housekeeping.ts
+const refDelimitersRegex = /[\s/?#\\:@]/;
+const isSelfReferral = (value, host) => {
+	if (refDelimitersRegex.test(value)) return false;
+	const refUrl = parseUrl(`http://${value}`);
+	if (!refUrl) return false;
+	return stripWww(refUrl.hostname) === host;
+};
 const housekeepingParams = [
 	"usqp",
 	"guccounter",
@@ -24,6 +32,10 @@ const housekeepingParams = [
 	"rebuildcache",
 	"kontrol_health_check_timestamp",
 	"at_preview_index",
-	"__readwiseLocation"
+	"__readwiseLocation",
+	{
+		name: "ref",
+		value: isSelfReferral
+	}
 ];
 export { housekeepingParams };

package/dist/tracking/session.d.mts

@@ -0,0 +1,2 @@
+import { TrackingParam } from "../types.mjs";
+export declare const sessionParams: Array<TrackingParam>;

package/dist/tracking/session.mjs

@@ -0,0 +1,12 @@
+const sessionParams = [
+	"phpsessid",
+	"jsessionid",
+	/^aspsessionid[a-z]{8}$/,
+	"cfid",
+	"cftoken",
+	{
+		name: "sid",
+		value: /^(?=[a-z]*\d)[0-9a-z]{26,}(?:\?|$)/i
+	}
+];
+export { sessionParams };

package/dist/types.d.mts

@@ -1,5 +1,11 @@
 export type UrlUnwrapper = (url: URL) => string | undefined;
-export type TrackingParam = string | RegExp;
+export type TrackingValueTest = (value: string, host: string) => boolean;
+export type TrackingEntry = {
+  name: string | RegExp;
+  value?: RegExp | TrackingValueTest;
+  hosts?: Array<string> | RegExp;
+};
+export type TrackingParam = string | RegExp | TrackingEntry;
 export type CleanUrlOptions = {
   unwrappers?: Array<UrlUnwrapper>;
   trackingParams?: Array<TrackingParam>;

package/dist/unwraps/a8Net.mjs

@@ -14,7 +14,7 @@ const extractDeeplinkTarget = createParamExtractor({
 	hosts: "ow.a8.net",
 	params: ["url"]
 });
-const deeplinkPathRegex = /^\/s\d+\/redirect_v2\.php$/;
+const deeplinkPathRegex = /^\/s\d+\/redirect_v2\.php$/i;
 const unwrapA8Net = (url) => {
 	if (deeplinkPathRegex.test(url.pathname)) return extractDeeplinkTarget(url);
 	return extractRedirectTarget(url);

package/dist/unwraps/acast.mjs

@@ -1,7 +1,7 @@
 import { isHostOf } from "../node_modules/trousse/dist/urls.mjs";
 import { getPathTarget } from "../pathTarget.mjs";
 // src/unwraps/acast.ts
-const flexPrefixRegex = /^\/s\/[^/]+\/u\//;
+const flexPrefixRegex = /^\/s\/[^/]+\/u\//i;
 const unwrapAcast = (url) => {
 	if (!isHostOf(url, "flex2.acast.com")) return;
 	return getPathTarget(url, flexPrefixRegex, url.protocol);

package/dist/unwraps/accesstrade.mjs

@@ -9,7 +9,7 @@ const hosts = [
 	"pub.accesstrade.vn",
 	"click.accesstrade.in.th"
 ];
-const pathRegex = /^\/(?:sp\/cc|at\/c\.html|adv\.php|deep_link\/\d+(?:\/\d+)?)$/;
+const pathRegex = /^\/(?:sp\/cc|at\/c\.html|adv\.php|deep_link\/\d+(?:\/\d+)?)$/i;
 const unwrapAccesstrade = (url) => {
 	if (!isHostOf(url, hosts) || !pathRegex.test(url.pathname)) return;
 	return getParamTarget(url, "url");

package/dist/unwraps/aceml.mjs

@@ -1,5 +1,5 @@
-import { decodePercent, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
-import { createParamExtractor, decodeBase64 } from "../utils.mjs";
+import { decodeBase64, decodePercent, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/aceml.ts
 const encodedSchemeRegex = /^https?%3A/i;
 const baseExtractor = createParamExtractor({

package/dist/unwraps/adcell.mjs

@@ -1,6 +1,6 @@
 import { createParamExtractor } from "../utils.mjs";
 // src/unwraps/adcell.ts
-const clickPathRegex = /^\/(?:p\/click|click\.php|promotion\/click\/promoId\/\d+\/slotId\/\d+)$/;
+const clickPathRegex = /^\/(?:p\/click|click\.php|promotion\/click\/promoId\/\d+\/slotId\/\d+)$/i;
 const extractTarget = createParamExtractor({
 	hosts: ["t.adcell.com", "www.adcell.de"],
 	params: ["param0"]

package/dist/unwraps/addThis.d.mts

@@ -0,0 +1,2 @@
+import { UrlUnwrapper } from "../types.mjs";
+export declare const unwrapAddThis: UrlUnwrapper;

package/dist/unwraps/addThis.mjs

@@ -0,0 +1,17 @@
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
+import { isHostOf } from "../node_modules/trousse/dist/urls.mjs";
+import { getParamTarget } from "../utils.mjs";
+// src/unwraps/addThis.ts
+const bookmarkHosts = ["www.addthis.com"];
+const apiHosts = ["api.addthis.com"];
+const offerPathRegex = /^\/oexchange\/0\.8\/(?:forward\/[^/]+\/)?offer$/i;
+const isCarrierPath = (url) => {
+	if (isHostOf(url, bookmarkHosts)) return isAnyOf(url.pathname, "/bookmark.php");
+	if (isHostOf(url, apiHosts)) return offerPathRegex.test(url.pathname);
+	return false;
+};
+const unwrapAddThis = (url) => {
+	if (!isCarrierPath(url)) return;
+	return getParamTarget(url, "url");
+};
+export { unwrapAddThis };

package/dist/unwraps/addToAny.d.mts

@@ -0,0 +1,2 @@
+import { UrlUnwrapper } from "../types.mjs";
+export declare const unwrapAddToAny: UrlUnwrapper;

package/dist/unwraps/addToAny.mjs

@@ -0,0 +1,21 @@
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
+import { isHostOf, isHttpUrl, parseUrl } from "../node_modules/trousse/dist/urls.mjs";
+import { getParamTarget } from "../utils.mjs";
+// src/unwraps/addToAny.ts
+const hosts = ["www.addtoany.com", "addtoany.com"];
+const servicePathRegex = /^\/add_to\/[^/]+$/i;
+const menuPaths = ["/share", "/share_save"];
+const getMenuTarget = (url) => {
+	const target = getParamTarget(url, "linkurl");
+	if (target) return target;
+	const fragment = parseUrl(`?${url.hash.slice(1)}`, url);
+	return fragment && getParamTarget(fragment, "url");
+};
+const unwrapAddToAny = (url) => {
+	if (!isHostOf(url, hosts)) return;
+	let target;
+	if (servicePathRegex.test(url.pathname) || isAnyOf(url.pathname, "/email")) target = getParamTarget(url, "linkurl");
+	else if (isAnyOf(url.pathname, menuPaths)) target = getMenuTarget(url);
+	if (target && isHttpUrl(target)) return target;
+};
+export { unwrapAddToAny };

package/dist/unwraps/addToAnySubscribe.d.mts

@@ -0,0 +1,2 @@
+import { UrlUnwrapper } from "../types.mjs";
+export declare const unwrapAddToAnySubscribe: UrlUnwrapper;

package/dist/unwraps/addToAnySubscribe.mjs

@@ -0,0 +1,8 @@
+import { createParamExtractor } from "../utils.mjs";
+// src/unwraps/addToAnySubscribe.ts
+const unwrapAddToAnySubscribe = createParamExtractor({
+	hosts: ["addtoany.com", "www.addtoany.com"],
+	path: "/subscribe",
+	params: ["linkurl", "url"]
+});
+export { unwrapAddToAnySubscribe };

package/dist/unwraps/addToMyYahoo.d.mts

@@ -0,0 +1,2 @@
+import { UrlUnwrapper } from "../types.mjs";
+export declare const unwrapAddToMyYahoo: UrlUnwrapper;

package/dist/unwraps/addToMyYahoo.mjs

@@ -0,0 +1,29 @@
+import { isAnyOf } from "../node_modules/trousse/dist/matching.mjs";
+import { isHostOf } from "../node_modules/trousse/dist/urls.mjs";
+import { createParamExtractor, getParamTarget } from "../utils.mjs";
+// src/unwraps/addToMyYahoo.ts
+const hosts = ["add.my.yahoo.com", "add.my.yahoo.co.jp"];
+const usRedirectPathRegex = /^\/my\/[^*]*\*https?:\/\/add\.my\.yahoo\.(?:com\/(?:rss|content)|co\.jp\/rss)$/i;
+const jpRedirectPathRegex = /^\/myyahoo\/[^*]*\*https?:\/\/add\.my\.yahoo\.(?:com\/(?:rss|content)|co\.jp\/rss)$/i;
+const unwrapRss = createParamExtractor({
+	hosts,
+	path: "/rss",
+	params: ["url"]
+});
+const unwrapContent = createParamExtractor({
+	hosts: "add.my.yahoo.com",
+	path: "/content",
+	params: ["url"]
+});
+const unwrapAddToMyYahoo = (url) => {
+	if (isHostOf(url, "us.rd.yahoo.com")) {
+		if (!isAnyOf(url.pathname, usRedirectPathRegex)) return;
+		return getParamTarget(url, "url");
+	}
+	if (isHostOf(url, "rd.yahoo.co.jp")) {
+		if (!isAnyOf(url.pathname, jpRedirectPathRegex)) return;
+		return getParamTarget(url, "url");
+	}
+	return unwrapRss(url) ?? unwrapContent(url);
+};
+export { unwrapAddToMyYahoo };

package/dist/unwraps/adfly.mjs

@@ -1,6 +1,6 @@
 import { isHostOf, isHttpUrl } from "../node_modules/trousse/dist/urls.mjs";
 // src/unwraps/adfly.ts
-const pathRegex = /^\/\d+\/(?:banner\/|int\/)?(.+)$/;
+const pathRegex = /^\/\d+\/(?:banner\/|int\/)?(.+)$/i;
 const schemeRegex = /^https?:/i;
 const hostRegex = /^[\da-z-]+(?:\.[\da-z-]+)+(?:[/:]|$)/i;
 const unwrapAdfly = (url) => {