@url-sanitize/merged 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antonio Orionus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,8 @@
+This package merges catalogs from:
+
+- @url-sanitize/clearurls: ClearURLs-derived data, LGPL-3.0-only
+- @url-sanitize/adguard: AdGuard URL Tracking Protection data, LGPL-3.0-only
+- @url-sanitize/brave: Brave Debouncer data, MPL-2.0
+- @url-sanitize/firefox: Firefox Query Stripping data, MPL-2.0
+
+The merge adapter code is MIT. Bundled upstream data remains under its source license.

package/README.md

@@ -0,0 +1,50 @@
+# @url-sanitize/merged
+
+Default merged catalog for [`@url-sanitize/core`](../core).
+
+Combines sources in deterministic priority order:
+
+```text
+clearurls → adguard → brave → firefox
+```
+
+Exact semantic duplicate rules are deduped; distinct scoped rules are preserved.
+
+## Install
+
+```sh
+npm install @url-sanitize/core @url-sanitize/merged
+```
+
+## Usage
+
+```ts
+import { sanitize, mergedCatalog, mergedMetadata } from '@url-sanitize/merged';
+import { compileSanitizer } from '@url-sanitize/core';
+
+sanitize('https://example.com/?utm_source=x');
+
+const aggressive = compileSanitizer(mergedCatalog, {
+  stripReferralMarketing: true,
+  domainBlocking: true
+});
+
+console.log(mergedMetadata.sources);
+console.log(aggressive('https://y2u.be/dQw4w9WgXcQ'));
+```
+
+## Custom merge
+
+```ts
+import { clearurlsCatalog } from '@url-sanitize/clearurls';
+import { firefoxCatalog } from '@url-sanitize/firefox';
+import { mergeSources } from '@url-sanitize/merged';
+
+const catalog = mergeSources([clearurlsCatalog, firefoxCatalog]);
+```
+
+## License
+
+Merge adapter code is MIT. Bundled upstream data keeps its source license:
+ClearURLs and AdGuard are LGPL-3.0-only; Brave and Firefox data are MPL-2.0.
+See [NOTICE](NOTICE).

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import * as _url_sanitize_firefox from '@url-sanitize/firefox';
+import * as _url_sanitize_clearurls from '@url-sanitize/clearurls';
+import * as _url_sanitize_brave from '@url-sanitize/brave';
+import * as _url_sanitize_adguard from '@url-sanitize/adguard';
+import * as _url_sanitize_core from '@url-sanitize/core';
+import { SanitizerCatalog, Sanitizer } from '@url-sanitize/core';
+
+interface MergeSourcesOptions {
+    dedupe?: boolean;
+}
+declare function mergeSources(catalogs?: SanitizerCatalog[], options?: MergeSourcesOptions): SanitizerCatalog;
+declare const mergedCatalog: SanitizerCatalog;
+declare const mergedMetadata: {
+    readonly version: string;
+    readonly generatedAt: string;
+    readonly sources: {
+        name: _url_sanitize_core.RuleSource;
+        version?: string;
+        hash?: string;
+        license?: string;
+        upstream?: string;
+    }[];
+    readonly sourceMetadata: {
+        readonly adguard: _url_sanitize_adguard.AdguardMetadata;
+        readonly brave: _url_sanitize_brave.BraveMetadata;
+        readonly clearurls: _url_sanitize_clearurls.ClearUrlsMetadata;
+        readonly firefox: _url_sanitize_firefox.FirefoxMetadata;
+    };
+};
+declare const sanitize: Sanitizer;
+
+export { type MergeSourcesOptions, mergeSources, mergedCatalog, mergedMetadata, sanitize };

package/dist/index.js

@@ -0,0 +1,61 @@
+// src/index.ts
+import { adguardCatalog, adguardMetadata } from "@url-sanitize/adguard";
+import { braveCatalog, braveMetadata } from "@url-sanitize/brave";
+import { clearurlsCatalog, clearurlsMetadata } from "@url-sanitize/clearurls";
+import {
+  compileSanitizer
+} from "@url-sanitize/core";
+import { firefoxCatalog, firefoxMetadata } from "@url-sanitize/firefox";
+var defaultCatalogs = [clearurlsCatalog, adguardCatalog, braveCatalog, firefoxCatalog];
+function mergeSources(catalogs = defaultCatalogs, options = {}) {
+  const dedupe = options.dedupe ?? true;
+  const rules = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const catalog of catalogs) {
+    for (const rule of catalog.rules) {
+      const key = semanticRuleKey(rule);
+      if (dedupe && seen.has(key)) continue;
+      seen.add(key);
+      rules.push(cloneRule(rule));
+    }
+  }
+  return {
+    version: `merged(${catalogs.map((catalog) => catalog.version).join(",")})`,
+    generatedAt: catalogs.map((catalog) => catalog.generatedAt).reduce((latest, generatedAt) => generatedAt > latest ? generatedAt : latest),
+    sources: catalogs.flatMap((catalog) => catalog.sources.map((source) => ({ ...source }))),
+    rules
+  };
+}
+var mergedCatalog = mergeSources();
+var mergedMetadata = {
+  version: mergedCatalog.version,
+  generatedAt: mergedCatalog.generatedAt,
+  sources: mergedCatalog.sources,
+  sourceMetadata: {
+    adguard: adguardMetadata,
+    brave: braveMetadata,
+    clearurls: clearurlsMetadata,
+    firefox: firefoxMetadata
+  }
+};
+var sanitize = compileSanitizer(mergedCatalog);
+function semanticRuleKey(rule) {
+  const { provider: _provider, source: _source, ...semantic } = rule;
+  return JSON.stringify(sortValue(semantic));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (typeof value !== "object" || value === null) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, sortValue(nested)])
+  );
+}
+function cloneRule(rule) {
+  return rule.exceptions ? { ...rule, exceptions: [...rule.exceptions] } : { ...rule };
+}
+export {
+  mergeSources,
+  mergedCatalog,
+  mergedMetadata,
+  sanitize
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@url-sanitize/merged",
+  "version": "2.0.0",
+  "description": "Merged ClearURLs, AdGuard, Brave, and Firefox catalog for @url-sanitize/core.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@url-sanitize/brave": "2.0.0",
+    "@url-sanitize/core": "2.0.0",
+    "@url-sanitize/firefox": "2.0.0",
+    "@url-sanitize/clearurls": "2.0.0",
+    "@url-sanitize/adguard": "2.0.0"
+  },
+  "keywords": [
+    "url",
+    "sanitize",
+    "tracking",
+    "clearurls",
+    "adguard",
+    "brave",
+    "firefox"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/antonio-orionus/url-sanitize.git",
+    "directory": "packages/merged"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch"
+  }
+}