@url-sanitize/merged 2.0.4 → 2.0.5

package/dist/index.d.ts

@@ -1,32 +1,26 @@
-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;
+import { Sanitizer, SanitizerCatalog } from "@url-sanitize/core";
+//#region src/index.d.ts
+export 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;
-    };
+export declare function mergeSources(catalogs?: SanitizerCatalog[], options?: MergeSourcesOptions): SanitizerCatalog;
+export declare const mergedCatalog: SanitizerCatalog;
+export declare const mergedMetadata: {
+  readonly version: string;
+  readonly generatedAt: string;
+  readonly sources: {
+    name: import("@url-sanitize/core").RuleSource;
+    version?: string;
+    hash?: string;
+    license?: string;
+    upstream?: string;
+  }[];
+  readonly sourceMetadata: {
+    readonly adguard: import("@url-sanitize/adguard").AdguardMetadata;
+    readonly brave: import("@url-sanitize/brave").BraveMetadata;
+    readonly clearurls: import("@url-sanitize/clearurls").ClearUrlsMetadata;
+    readonly firefox: import("@url-sanitize/firefox").FirefoxMetadata;
+  };
 };
-declare const sanitize: Sanitizer;
-
-export { type MergeSourcesOptions, mergeSources, mergedCatalog, mergedMetadata, sanitize };
+export declare const sanitize: Sanitizer;
+//#endregion

package/dist/index.js

@@ -1,61 +1,59 @@
-// 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 { compileSanitizer } from "@url-sanitize/core";
 import { firefoxCatalog, firefoxMetadata } from "@url-sanitize/firefox";
-var defaultCatalogs = [clearurlsCatalog, adguardCatalog, braveCatalog, firefoxCatalog];
+//#region src/index.ts
+const 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
-  };
+	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
-  }
+const mergedCatalog = mergeSources();
+const mergedMetadata = {
+	version: mergedCatalog.version,
+	generatedAt: mergedCatalog.generatedAt,
+	sources: mergedCatalog.sources,
+	sourceMetadata: {
+		adguard: adguardMetadata,
+		brave: braveMetadata,
+		clearurls: clearurlsMetadata,
+		firefox: firefoxMetadata
+	}
 };
-var sanitize = compileSanitizer(mergedCatalog);
+const sanitize = compileSanitizer(mergedCatalog);
 function semanticRuleKey(rule) {
-  const { provider: _provider, source: _source, ...semantic } = rule;
-  return JSON.stringify(sortValue(semantic));
+	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)])
-  );
+	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 };
+	return rule.exceptions ? {
+		...rule,
+		exceptions: [...rule.exceptions]
+	} : { ...rule };
 }
-export {
-  mergeSources,
-  mergedCatalog,
-  mergedMetadata,
-  sanitize
-};
+//#endregion
+export { mergeSources, mergedCatalog, mergedMetadata, sanitize };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@url-sanitize/merged",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Merged ClearURLs, AdGuard, Brave, and Firefox catalog for @url-sanitize/core.",
   "license": "MIT",
   "type": "module",
@@ -18,11 +18,11 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@url-sanitize/clearurls": "2.0.4",
-    "@url-sanitize/firefox": "2.0.4",
-    "@url-sanitize/brave": "2.0.4",
-    "@url-sanitize/adguard": "2.0.4",
-    "@url-sanitize/core": "2.0.4"
+    "@url-sanitize/adguard": "2.0.5",
+    "@url-sanitize/clearurls": "2.0.5",
+    "@url-sanitize/brave": "2.0.5",
+    "@url-sanitize/firefox": "2.0.5",
+    "@url-sanitize/core": "2.0.5"
   },
   "keywords": [
     "url",
@@ -43,7 +43,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch"
+    "build": "vp pack",
+    "dev": "vp pack --watch"
   }
 }