@url-sanitize/core 0.1.4 → 1.0.0

package/README.md

@@ -42,6 +42,25 @@ type SanitizeResult =
 - Factory pattern (`compileSanitizer(catalog)`) — no module-level cache, no singletons.
 - Discriminated union return type — exhaustive `switch (result.kind)`.
 
+## Custom catalogs
+
+```ts
+import { defineCatalog, mergeCatalogs, sanitizerCatalogJsonSchema } from '@url-sanitize/core';
+
+const custom = defineCatalog({
+  version: 'custom-1',
+  generatedAt: new Date().toISOString(),
+  sources: [{ name: 'custom' }],
+  rules: [{ kind: 'strip-param', source: 'custom', provider: 'local', paramPattern: 'utm_.+' }]
+});
+
+const merged = mergeCatalogs(custom);
+console.log(sanitizerCatalogJsonSchema.$id);
+```
+
+`mergeCatalogs()` preserves input order and concatenates sources/rules. It does
+not dedupe, reorder, or apply source precedence.
+
 ## License
 
 MIT.

package/dist/index.d.ts

@@ -73,7 +73,625 @@ interface SanitizerOptions {
     domainBlocking?: boolean;
 }
 
+declare function defineCatalog(catalog: SanitizerCatalog): SanitizerCatalog;
+declare function mergeCatalogs(first: SanitizerCatalog, ...rest: SanitizerCatalog[]): SanitizerCatalog;
+
 type Sanitizer = (input: string) => SanitizeResult;
 declare function compileSanitizer(catalog: SanitizerCatalog, options?: SanitizerOptions): Sanitizer;
 
-export { type MatchedRule, type RuleSource, type SanitizeResult, type Sanitizer, type SanitizerCatalog, type SanitizerOptions, type SanitizerRule, compileSanitizer };
+declare const sanitizerOptionsJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://url-sanitize.dev/schema/v1/options.json";
+    readonly title: "url-sanitize options";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly stripReferralMarketing: {
+            readonly type: "boolean";
+        };
+        readonly unwrapRedirects: {
+            readonly type: "boolean";
+        };
+        readonly domainBlocking: {
+            readonly type: "boolean";
+        };
+    };
+};
+declare const sanitizerCatalogJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://url-sanitize.dev/schema/v1/catalog.json";
+    readonly title: "url-sanitize catalog";
+    readonly type: "object";
+    readonly required: readonly ["version", "generatedAt", "sources", "rules"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+        };
+        readonly generatedAt: {
+            readonly type: "string";
+        };
+        readonly sources: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["name"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly name: {
+                        readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                    };
+                    readonly version: {
+                        readonly type: "string";
+                    };
+                    readonly hash: {
+                        readonly type: "string";
+                    };
+                    readonly license: {
+                        readonly type: "string";
+                    };
+                    readonly upstream: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly rules: {
+            readonly type: "array";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "object";
+                    readonly required: readonly ["kind", "source", "provider", "paramPattern"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "strip-param";
+                        };
+                        readonly paramPattern: {
+                            readonly type: "string";
+                        };
+                        readonly isReferralMarketing: {
+                            readonly type: "boolean";
+                        };
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly urlPattern: {
+                            readonly type: "string";
+                        };
+                        readonly exceptions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["kind", "source", "provider", "pattern", "replacement"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "raw-replace";
+                        };
+                        readonly pattern: {
+                            readonly type: "string";
+                        };
+                        readonly replacement: {
+                            readonly type: "string";
+                        };
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly urlPattern: {
+                            readonly type: "string";
+                        };
+                        readonly exceptions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["kind", "source", "provider", "pattern", "captureGroup"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "unwrap-redirect";
+                        };
+                        readonly pattern: {
+                            readonly type: "string";
+                        };
+                        readonly captureGroup: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly urlPattern: {
+                            readonly type: "string";
+                        };
+                        readonly exceptions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["kind", "source", "provider", "urlPattern"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "block-domain";
+                        };
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly urlPattern: {
+                            readonly type: "string";
+                        };
+                        readonly exceptions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                }];
+            };
+        };
+    };
+};
+declare const sanitizeResultJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://url-sanitize.dev/schema/v1/result.json";
+    readonly title: "url-sanitize result";
+    readonly oneOf: readonly [{
+        readonly type: "object";
+        readonly required: readonly ["kind", "url"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly kind: {
+                readonly const: "unchanged";
+            };
+            readonly url: {
+                readonly type: "string";
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly required: readonly ["kind", "original", "url", "strippedParams", "matchedRules"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly kind: {
+                readonly const: "cleaned";
+            };
+            readonly original: {
+                readonly type: "string";
+            };
+            readonly url: {
+                readonly type: "string";
+            };
+            readonly strippedParams: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly matchedRules: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["source", "provider", "kind"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly kind: {
+                            readonly enum: readonly ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+                        };
+                        readonly detail: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly required: readonly ["kind", "original", "url", "via"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly kind: {
+                readonly const: "redirected";
+            };
+            readonly original: {
+                readonly type: "string";
+            };
+            readonly url: {
+                readonly type: "string";
+            };
+            readonly via: {
+                readonly type: "object";
+                readonly required: readonly ["source", "provider", "kind"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly source: {
+                        readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                    };
+                    readonly provider: {
+                        readonly type: "string";
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+                    };
+                    readonly detail: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly required: readonly ["kind", "original", "via"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly kind: {
+                readonly const: "blocked";
+            };
+            readonly original: {
+                readonly type: "string";
+            };
+            readonly via: {
+                readonly type: "object";
+                readonly required: readonly ["source", "provider", "kind"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly source: {
+                        readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                    };
+                    readonly provider: {
+                        readonly type: "string";
+                    };
+                    readonly kind: {
+                        readonly enum: readonly ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+                    };
+                    readonly detail: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+    }];
+};
+declare const urlSanitizeJsonSchemas: {
+    readonly catalog: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://url-sanitize.dev/schema/v1/catalog.json";
+        readonly title: "url-sanitize catalog";
+        readonly type: "object";
+        readonly required: readonly ["version", "generatedAt", "sources", "rules"];
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly version: {
+                readonly type: "string";
+            };
+            readonly generatedAt: {
+                readonly type: "string";
+            };
+            readonly sources: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["name"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly name: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly version: {
+                            readonly type: "string";
+                        };
+                        readonly hash: {
+                            readonly type: "string";
+                        };
+                        readonly license: {
+                            readonly type: "string";
+                        };
+                        readonly upstream: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+            readonly rules: {
+                readonly type: "array";
+                readonly items: {
+                    readonly oneOf: readonly [{
+                        readonly type: "object";
+                        readonly required: readonly ["kind", "source", "provider", "paramPattern"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly kind: {
+                                readonly const: "strip-param";
+                            };
+                            readonly paramPattern: {
+                                readonly type: "string";
+                            };
+                            readonly isReferralMarketing: {
+                                readonly type: "boolean";
+                            };
+                            readonly source: {
+                                readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                            };
+                            readonly provider: {
+                                readonly type: "string";
+                            };
+                            readonly urlPattern: {
+                                readonly type: "string";
+                            };
+                            readonly exceptions: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    }, {
+                        readonly type: "object";
+                        readonly required: readonly ["kind", "source", "provider", "pattern", "replacement"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly kind: {
+                                readonly const: "raw-replace";
+                            };
+                            readonly pattern: {
+                                readonly type: "string";
+                            };
+                            readonly replacement: {
+                                readonly type: "string";
+                            };
+                            readonly source: {
+                                readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                            };
+                            readonly provider: {
+                                readonly type: "string";
+                            };
+                            readonly urlPattern: {
+                                readonly type: "string";
+                            };
+                            readonly exceptions: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    }, {
+                        readonly type: "object";
+                        readonly required: readonly ["kind", "source", "provider", "pattern", "captureGroup"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly kind: {
+                                readonly const: "unwrap-redirect";
+                            };
+                            readonly pattern: {
+                                readonly type: "string";
+                            };
+                            readonly captureGroup: {
+                                readonly type: "integer";
+                                readonly minimum: 0;
+                            };
+                            readonly source: {
+                                readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                            };
+                            readonly provider: {
+                                readonly type: "string";
+                            };
+                            readonly urlPattern: {
+                                readonly type: "string";
+                            };
+                            readonly exceptions: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    }, {
+                        readonly type: "object";
+                        readonly required: readonly ["kind", "source", "provider", "urlPattern"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly kind: {
+                                readonly const: "block-domain";
+                            };
+                            readonly source: {
+                                readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                            };
+                            readonly provider: {
+                                readonly type: "string";
+                            };
+                            readonly urlPattern: {
+                                readonly type: "string";
+                            };
+                            readonly exceptions: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    }];
+                };
+            };
+        };
+    };
+    readonly options: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://url-sanitize.dev/schema/v1/options.json";
+        readonly title: "url-sanitize options";
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly stripReferralMarketing: {
+                readonly type: "boolean";
+            };
+            readonly unwrapRedirects: {
+                readonly type: "boolean";
+            };
+            readonly domainBlocking: {
+                readonly type: "boolean";
+            };
+        };
+    };
+    readonly result: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly $id: "https://url-sanitize.dev/schema/v1/result.json";
+        readonly title: "url-sanitize result";
+        readonly oneOf: readonly [{
+            readonly type: "object";
+            readonly required: readonly ["kind", "url"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "unchanged";
+                };
+                readonly url: {
+                    readonly type: "string";
+                };
+            };
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["kind", "original", "url", "strippedParams", "matchedRules"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "cleaned";
+                };
+                readonly original: {
+                    readonly type: "string";
+                };
+                readonly url: {
+                    readonly type: "string";
+                };
+                readonly strippedParams: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly matchedRules: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["source", "provider", "kind"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly source: {
+                                readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                            };
+                            readonly provider: {
+                                readonly type: "string";
+                            };
+                            readonly kind: {
+                                readonly enum: readonly ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+                            };
+                            readonly detail: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+            };
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["kind", "original", "url", "via"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "redirected";
+                };
+                readonly original: {
+                    readonly type: "string";
+                };
+                readonly url: {
+                    readonly type: "string";
+                };
+                readonly via: {
+                    readonly type: "object";
+                    readonly required: readonly ["source", "provider", "kind"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly kind: {
+                            readonly enum: readonly ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+                        };
+                        readonly detail: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["kind", "original", "via"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "blocked";
+                };
+                readonly original: {
+                    readonly type: "string";
+                };
+                readonly via: {
+                    readonly type: "object";
+                    readonly required: readonly ["source", "provider", "kind"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly source: {
+                            readonly enum: readonly ["clearurls", "adguard", "brave", "firefox", "custom"];
+                        };
+                        readonly provider: {
+                            readonly type: "string";
+                        };
+                        readonly kind: {
+                            readonly enum: readonly ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+                        };
+                        readonly detail: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        }];
+    };
+};
+
+export { type MatchedRule, type RuleSource, type SanitizeResult, type Sanitizer, type SanitizerCatalog, type SanitizerOptions, type SanitizerRule, compileSanitizer, defineCatalog, mergeCatalogs, sanitizeResultJsonSchema, sanitizerCatalogJsonSchema, sanitizerOptionsJsonSchema, urlSanitizeJsonSchemas };

package/dist/index.js

@@ -1,3 +1,23 @@
+// src/catalog.ts
+function defineCatalog(catalog) {
+  return catalog;
+}
+function mergeCatalogs(first, ...rest) {
+  const catalogs = [first, ...rest];
+  return {
+    version: catalogs.length === 1 ? first.version : `merged(${catalogs.map((catalog) => catalog.version).join(",")})`,
+    generatedAt: latestGeneratedAt(catalogs),
+    sources: catalogs.flatMap((catalog) => catalog.sources.map((source) => ({ ...source }))),
+    rules: catalogs.flatMap((catalog) => catalog.rules.map(cloneRule))
+  };
+}
+function latestGeneratedAt(catalogs) {
+  return catalogs.map((catalog) => catalog.generatedAt).reduce((latest, generatedAt) => generatedAt > latest ? generatedAt : latest);
+}
+function cloneRule(rule) {
+  return rule.exceptions ? { ...rule, exceptions: [...rule.exceptions] } : { ...rule };
+}
+
 // src/sanitize.ts
 function safeRegex(pattern, flags = "") {
   try {
@@ -214,6 +234,185 @@ function stripFromQueryString(searchOrHash, paramPattern) {
   if (kept.length === 0) return { result: "", removed };
   return { result: prefix + kept.join("&"), removed };
 }
+
+// src/schemas.ts
+var ruleSourceValues = ["clearurls", "adguard", "brave", "firefox", "custom"];
+var ruleKindValues = ["strip-param", "raw-replace", "unwrap-redirect", "block-domain"];
+var catalogSourceSchema = {
+  type: "object",
+  required: ["name"],
+  additionalProperties: false,
+  properties: {
+    name: { enum: ruleSourceValues },
+    version: { type: "string" },
+    hash: { type: "string" },
+    license: { type: "string" },
+    upstream: { type: "string" }
+  }
+};
+var ruleBaseProperties = {
+  source: { enum: ruleSourceValues },
+  provider: { type: "string" },
+  urlPattern: { type: "string" },
+  exceptions: {
+    type: "array",
+    items: { type: "string" }
+  }
+};
+var matchedRuleSchema = {
+  type: "object",
+  required: ["source", "provider", "kind"],
+  additionalProperties: false,
+  properties: {
+    source: { enum: ruleSourceValues },
+    provider: { type: "string" },
+    kind: { enum: ruleKindValues },
+    detail: { type: "string" }
+  }
+};
+var sanitizerOptionsJsonSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://url-sanitize.dev/schema/v1/options.json",
+  title: "url-sanitize options",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    stripReferralMarketing: { type: "boolean" },
+    unwrapRedirects: { type: "boolean" },
+    domainBlocking: { type: "boolean" }
+  }
+};
+var sanitizerCatalogJsonSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://url-sanitize.dev/schema/v1/catalog.json",
+  title: "url-sanitize catalog",
+  type: "object",
+  required: ["version", "generatedAt", "sources", "rules"],
+  additionalProperties: false,
+  properties: {
+    version: { type: "string" },
+    generatedAt: { type: "string" },
+    sources: {
+      type: "array",
+      items: catalogSourceSchema
+    },
+    rules: {
+      type: "array",
+      items: {
+        oneOf: [
+          {
+            type: "object",
+            required: ["kind", "source", "provider", "paramPattern"],
+            additionalProperties: false,
+            properties: {
+              ...ruleBaseProperties,
+              kind: { const: "strip-param" },
+              paramPattern: { type: "string" },
+              isReferralMarketing: { type: "boolean" }
+            }
+          },
+          {
+            type: "object",
+            required: ["kind", "source", "provider", "pattern", "replacement"],
+            additionalProperties: false,
+            properties: {
+              ...ruleBaseProperties,
+              kind: { const: "raw-replace" },
+              pattern: { type: "string" },
+              replacement: { type: "string" }
+            }
+          },
+          {
+            type: "object",
+            required: ["kind", "source", "provider", "pattern", "captureGroup"],
+            additionalProperties: false,
+            properties: {
+              ...ruleBaseProperties,
+              kind: { const: "unwrap-redirect" },
+              pattern: { type: "string" },
+              captureGroup: { type: "integer", minimum: 0 }
+            }
+          },
+          {
+            type: "object",
+            required: ["kind", "source", "provider", "urlPattern"],
+            additionalProperties: false,
+            properties: {
+              ...ruleBaseProperties,
+              kind: { const: "block-domain" }
+            }
+          }
+        ]
+      }
+    }
+  }
+};
+var sanitizeResultJsonSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://url-sanitize.dev/schema/v1/result.json",
+  title: "url-sanitize result",
+  oneOf: [
+    {
+      type: "object",
+      required: ["kind", "url"],
+      additionalProperties: false,
+      properties: {
+        kind: { const: "unchanged" },
+        url: { type: "string" }
+      }
+    },
+    {
+      type: "object",
+      required: ["kind", "original", "url", "strippedParams", "matchedRules"],
+      additionalProperties: false,
+      properties: {
+        kind: { const: "cleaned" },
+        original: { type: "string" },
+        url: { type: "string" },
+        strippedParams: {
+          type: "array",
+          items: { type: "string" }
+        },
+        matchedRules: {
+          type: "array",
+          items: matchedRuleSchema
+        }
+      }
+    },
+    {
+      type: "object",
+      required: ["kind", "original", "url", "via"],
+      additionalProperties: false,
+      properties: {
+        kind: { const: "redirected" },
+        original: { type: "string" },
+        url: { type: "string" },
+        via: matchedRuleSchema
+      }
+    },
+    {
+      type: "object",
+      required: ["kind", "original", "via"],
+      additionalProperties: false,
+      properties: {
+        kind: { const: "blocked" },
+        original: { type: "string" },
+        via: matchedRuleSchema
+      }
+    }
+  ]
+};
+var urlSanitizeJsonSchemas = {
+  catalog: sanitizerCatalogJsonSchema,
+  options: sanitizerOptionsJsonSchema,
+  result: sanitizeResultJsonSchema
+};
 export {
-  compileSanitizer
+  compileSanitizer,
+  defineCatalog,
+  mergeCatalogs,
+  sanitizeResultJsonSchema,
+  sanitizerCatalogJsonSchema,
+  sanitizerOptionsJsonSchema,
+  urlSanitizeJsonSchemas
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@url-sanitize/core",
-  "version": "0.1.4",
+  "version": "1.0.0",
   "description": "Pure TypeScript library for removing tracking parameters and unwrapping tracking redirects.",
   "license": "MIT",
   "type": "module",