@url-sanitize/adguard 2.0.4 → 2.0.5

package/data/metadata.json

@@ -1,7 +1,7 @@
 {
-  "version": "a2cb7927b9bd",
-  "hash": "a2cb7927b9bd9902616f8e6d647e0f91ef69009ad58b5ab88f908757dd6937af",
-  "fetchedAt": "2026-10-22T09:28:02.188Z",
+  "version": "f8cc23fb470a",
+  "hash": "f8cc23fb470ad6485331031b567d1a4a0359872e48193104be4645c0e410ec55",
+  "fetchedAt": "2026-10-30T10:54:37.652Z",
   "upstream": "https://raw.githubusercontent.com/AdguardTeam/FiltersRegistry/master/filters/filter_17_TrackParam/filter.txt",
   "license": "LGPL-3.0-only"
 }

package/dist/adapter.d.ts

@@ -1,6 +1,5 @@
-import { SanitizerCatalog } from '@url-sanitize/core';
-import { AdguardData, AdguardMetadata } from './types.js';
-
-declare function adguardToCatalog(data: AdguardData, meta: AdguardMetadata): SanitizerCatalog;
-
-export { adguardToCatalog };
+import { AdguardData, AdguardMetadata } from "./types.js";
+import { SanitizerCatalog } from "@url-sanitize/core";
+//#region src/adapter.d.ts
+export declare function adguardToCatalog(data: AdguardData, meta: AdguardMetadata): SanitizerCatalog;
+//#endregion

package/dist/adapter.js

@@ -1,6 +1,173 @@
-import {
-  adguardToCatalog
-} from "./chunk-4TYKAH2R.js";
-export {
-  adguardToCatalog
-};
+//#region src/adapter.ts
+function adguardToCatalog(data, meta) {
+	const rules = [];
+	const lines = preprocessConditionals(data.text);
+	let index = 0;
+	for (const line of lines) {
+		const parsed = parseLine(line, index);
+		if (!parsed) continue;
+		index++;
+		const rule = {
+			kind: "strip-param",
+			source: "adguard",
+			provider: parsed.provider,
+			paramPattern: parsed.paramPattern,
+			exceptions: parsed.exceptions
+		};
+		if (parsed.urlPattern) rule.urlPattern = parsed.urlPattern;
+		if (parsed.valuePattern) rule.valuePattern = parsed.valuePattern;
+		rules.push(rule);
+	}
+	return {
+		version: meta.version,
+		generatedAt: meta.fetchedAt,
+		sources: [{
+			name: "adguard",
+			version: meta.version,
+			hash: meta.hash,
+			license: meta.license,
+			upstream: meta.upstream
+		}],
+		rules
+	};
+}
+function preprocessConditionals(text) {
+	const activeStack = [true];
+	const out = [];
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		if (line.startsWith("!#if")) {
+			const condition = line.slice(4).trim();
+			activeStack.push(activeStack.at(-1) === true && evalCondition(condition));
+			continue;
+		}
+		if (line.startsWith("!#else")) {
+			if (activeStack.length > 1) {
+				const parentActive = activeStack.at(-2) === true;
+				const branchWasActive = activeStack.at(-1) === true;
+				activeStack[activeStack.length - 1] = parentActive && !branchWasActive;
+			}
+			continue;
+		}
+		if (line.startsWith("!#endif")) {
+			if (activeStack.length > 1) activeStack.pop();
+			continue;
+		}
+		if (line.startsWith("!")) continue;
+		if (activeStack.at(-1) !== true) continue;
+		out.push(line);
+	}
+	return out;
+}
+function evalCondition(condition) {
+	return condition.replace(/\badguard_ext_chromium_mv3\b/g, "false").replace(/\bext_ublock\b/g, "false").split("||").some((orPart) => orPart.split("&&").every((andPart) => {
+		const part = andPart.trim().replace(/^\(|\)$/g, "");
+		if (part.startsWith("!")) return !booleanToken(part.slice(1));
+		return booleanToken(part);
+	}));
+}
+function booleanToken(token) {
+	return token.trim() === "true";
+}
+function parseLine(line, index) {
+	const modifierIndex = modifierStart(line);
+	if (modifierIndex === -1) return null;
+	const prefix = line.slice(0, modifierIndex);
+	const modifiers = parseModifiers(line.slice(modifierIndex + 1));
+	const removeParam = modifiers.get("removeparam") ?? deriveParamFromPrefix(prefix);
+	if (!removeParam) return null;
+	const pattern = parseRemoveParam(removeParam);
+	if (!pattern) return null;
+	const domainModifier = modifiers.get("domain");
+	const denyallow = modifiers.get("denyallow");
+	const positives = domainModifier ? domainModifier.split("|").filter((domain) => domain.length > 0 && !domain.startsWith("~")) : [];
+	const negatives = [...domainModifier ? domainModifier.split("|").filter((domain) => domain.startsWith("~")).map((domain) => domain.slice(1)) : [], ...denyallow ? denyallow.split("|").filter(Boolean) : []];
+	const urlPattern = positives.length > 0 ? domainsPattern(positives) : prefixPattern(prefix);
+	const parsed = {
+		provider: `adguard-${index}`,
+		paramPattern: pattern.paramPattern,
+		exceptions: negatives.map(domainPattern)
+	};
+	if (urlPattern) parsed.urlPattern = urlPattern;
+	if (pattern.valuePattern) parsed.valuePattern = pattern.valuePattern;
+	return parsed;
+}
+function modifierStart(line) {
+	const indexes = ["$removeparam", "$denyallow"].map((candidate) => line.indexOf(candidate)).filter((i) => i >= 0);
+	return indexes.length === 0 ? -1 : Math.min(...indexes);
+}
+function parseModifiers(raw) {
+	const out = /* @__PURE__ */ new Map();
+	for (const part of splitModifiers(raw)) {
+		const eq = part.indexOf("=");
+		if (eq === -1) out.set(part.toLowerCase(), "");
+		else out.set(part.slice(0, eq).toLowerCase(), part.slice(eq + 1).replace(/\\,/g, ","));
+	}
+	return out;
+}
+function splitModifiers(raw) {
+	const out = [];
+	let current = "";
+	let inRegex = false;
+	let escaped = false;
+	for (const char of raw) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+		if (char === "/") inRegex = !inRegex;
+		if (char === "," && !inRegex) {
+			out.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) out.push(current);
+	return out.filter(Boolean);
+}
+function parseRemoveParam(value) {
+	if (value.startsWith("/") && value.lastIndexOf("/") > 0) {
+		const body = value.slice(1, value.lastIndexOf("/")).replace(/\\,/g, ",");
+		const eq = body.indexOf("=");
+		if (eq > 0) return {
+			paramPattern: stripAnchors(body.slice(0, eq)),
+			valuePattern: body.slice(eq + 1)
+		};
+		return { paramPattern: body };
+	}
+	return { paramPattern: escapeRegExp(value) };
+}
+function stripAnchors(value) {
+	return value.replace(/^\^/, "").replace(/\$$/, "");
+}
+function deriveParamFromPrefix(prefix) {
+	const match = /[?&;/]([^?&;/*=]+)=?\*?$/.exec(prefix);
+	return match?.[1] ? escapeRegExp(match[1]) : null;
+}
+function prefixPattern(prefix) {
+	if (!prefix) return void 0;
+	if (prefix.startsWith("||")) return domainPattern(prefix.slice(2).replace(/\^.*$/, ""));
+	return globPattern(prefix.replace(/\^/g, "*"));
+}
+function domainsPattern(domains) {
+	return domains.map(domainPattern).join("|");
+}
+function domainPattern(domain) {
+	return `^https?:\\/\\/([^/?#]+\\.)?${escapeRegExp(domain.replace(/^\|\|/, "").replace(/\^$/, ""))}(?::[0-9]+)?(?:[/?#]|$)`;
+}
+function globPattern(glob) {
+	return escapeRegExp(glob).replace(/\\\*/g, ".*");
+}
+function escapeRegExp(value) {
+	return value.replace(/[|\\{}()[\]^$+?.*]/g, "\\$&");
+}
+//#endregion
+export { adguardToCatalog };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { SanitizerCatalog, Sanitizer } from '@url-sanitize/core';
-export { adguardToCatalog } from './adapter.js';
-export { adguardMetadata, adguardRawData } from './raw.js';
-export { AdguardData, AdguardMetadata } from './types.js';
-
-declare const adguardCatalog: SanitizerCatalog;
-declare const sanitize: Sanitizer;
-
-export { adguardCatalog, sanitize };
+import { AdguardData, AdguardMetadata } from "./types.js";
+import { adguardToCatalog } from "./adapter.js";
+import { adguardMetadata, adguardRawData } from "./raw.js";
+import { Sanitizer, SanitizerCatalog } from "@url-sanitize/core";
+//#region src/index.d.ts
+export declare const adguardCatalog: SanitizerCatalog;
+export declare const sanitize: Sanitizer;
+//#endregion
+export { type AdguardData, type AdguardMetadata, adguardMetadata, adguardRawData, adguardToCatalog };

package/dist/index.js

@@ -1,19 +1,8 @@
-import {
-  adguardToCatalog
-} from "./chunk-4TYKAH2R.js";
-import {
-  adguardMetadata,
-  adguardRawData
-} from "./chunk-ADSSKPI2.js";
-
-// src/index.ts
+import { adguardToCatalog } from "./adapter.js";
+import { n as adguardRawData, t as adguardMetadata } from "./raw-CMXWFj4b.js";
 import { compileSanitizer } from "@url-sanitize/core";
-var adguardCatalog = adguardToCatalog(adguardRawData, adguardMetadata);
-var sanitize = compileSanitizer(adguardCatalog);
-export {
-  adguardCatalog,
-  adguardMetadata,
-  adguardRawData,
-  adguardToCatalog,
-  sanitize
-};
+//#region src/index.ts
+const adguardCatalog = adguardToCatalog(adguardRawData, adguardMetadata);
+const sanitize = compileSanitizer(adguardCatalog);
+//#endregion
+export { adguardCatalog, adguardMetadata, adguardRawData, adguardToCatalog, sanitize };