feedcanon 1.5.2 → 2.0.0-next.2

package/dist/types.d.ts

@@ -2,7 +2,7 @@ import * as _$feedsmith from "feedsmith";
 
 //#region src/types.d.ts
 type MaybePromise<T> = T | Promise<T>;
-type DefaultParserResult = ReturnType<typeof _$feedsmith.parseFeed>;
+type DefaultParserResult = ReturnType<typeof _$feedsmith.parseFeed<string>>;
 type ParserAdapter<T> = {
   parse: (body: string) => MaybePromise<T | undefined>;
   getSelfUrl: (parsed: T) => string | undefined;

package/package.json

@@ -24,24 +24,12 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/exports.d.ts",
-        "default": "./dist/exports.js"
-      },
-      "require": {
-        "types": "./dist/exports.d.cts",
-        "default": "./dist/exports.cjs"
-      }
+      "types": "./dist/exports.d.ts",
+      "default": "./dist/exports.js"
     },
     "./defaults": {
-      "import": {
-        "types": "./dist/defaults.d.ts",
-        "default": "./dist/defaults.js"
-      },
-      "require": {
-        "types": "./dist/defaults.d.cts",
-        "default": "./dist/defaults.cjs"
-      }
+      "types": "./dist/defaults.d.ts",
+      "default": "./dist/defaults.js"
     }
   },
   "files": [
@@ -49,14 +37,13 @@
   ],
   "scripts": {
     "prepare": "lefthook install",
-    "build": "tsdown src/exports.ts src/defaults.ts --format cjs,esm --dts --clean --unbundle --no-fixed-extension",
+    "build": "tsdown src/exports.ts src/defaults.ts --format esm --dts --clean --unbundle --no-fixed-extension",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs"
   },
   "dependencies": {
-    "entities": "^7.0.1",
-    "feedsmith": "^2.9.1",
-    "typescript": "^6.0.2"
+    "entities": "^8.0.0",
+    "feedsmith": "^3.0.0-beta.1"
   },
   "devDependencies": {
     "@types/bun": "^1.3.11",
@@ -64,5 +51,5 @@
     "tsdown": "^0.21.7",
     "vitepress": "^2.0.0-alpha.17"
   },
-  "version": "1.5.2"
+  "version": "2.0.0-next.2"
 }

package/dist/defaults.cjs

@@ -1,293 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils.cjs");
-let feedsmith = require("feedsmith");
-//#region src/defaults.ts
-const defaultStrippedParams = [
-	"utm_source",
-	"utm_medium",
-	"utm_campaign",
-	"utm_term",
-	"utm_content",
-	"utm_reader",
-	"utm_name",
-	"utm_cid",
-	"utm_viz_id",
-	"gclid",
-	"dclid",
-	"gbraid",
-	"wbraid",
-	"gclsrc",
-	"gad_source",
-	"gad_campaignid",
-	"srsltid",
-	"fbclid",
-	"fb_action_ids",
-	"fb_action_types",
-	"fb_source",
-	"fb_ref",
-	"_ga",
-	"_gl",
-	"_bk",
-	"_ke",
-	"mc_cid",
-	"mc_eid",
-	"mc_tc",
-	"mkt_tok",
-	"msclkid",
-	"twclid",
-	"ttclid",
-	"igshid",
-	"mtm_campaign",
-	"mtm_cid",
-	"mtm_content",
-	"mtm_group",
-	"mtm_keyword",
-	"mtm_medium",
-	"mtm_placement",
-	"mtm_source",
-	"pk_campaign",
-	"pk_cid",
-	"pk_content",
-	"pk_keyword",
-	"pk_medium",
-	"pk_source",
-	"ncid",
-	"sr_share",
-	"hsa_acc",
-	"hsa_ad",
-	"hsa_cam",
-	"hsa_grp",
-	"hsa_kw",
-	"hsa_mt",
-	"hsa_net",
-	"hsa_src",
-	"hsa_tgt",
-	"hsa_ver",
-	"hsCtaTracking",
-	"_hsenc",
-	"_hsmi",
-	"__hstc",
-	"__hsfp",
-	"__hssc",
-	"cid",
-	"s_kwcid",
-	"sc_cid",
-	"ef_id",
-	"obOrigUrl",
-	"dicbo",
-	"yclid",
-	"ysclid",
-	"_openstat",
-	"awinaffid",
-	"awinmid",
-	"clickref",
-	"afftrack",
-	"itm_source",
-	"itm_medium",
-	"itm_campaign",
-	"itm_content",
-	"itm_channel",
-	"itm_audience",
-	"int_source",
-	"int_medium",
-	"int_campaign",
-	"int_content",
-	"int_placement",
-	"int_campaign_type",
-	"int_keycode",
-	"g2i_source",
-	"g2i_medium",
-	"g2i_campaign",
-	"g2i_or_o",
-	"g2i_or_p",
-	"doing_wp_cron",
-	"preview",
-	"preview_id",
-	"preview_nonce",
-	"replytocom",
-	"_",
-	"timestamp",
-	"ts",
-	"cb",
-	"cachebuster",
-	"nocache",
-	"rand",
-	"random",
-	"sbdcrw",
-	"forceByPassCache",
-	"sucurianticache",
-	"cleancache",
-	"rebuildcache",
-	"kontrol_health_check_timestamp",
-	"action_object_map",
-	"action_ref_map",
-	"action_type_map",
-	"algo_expid",
-	"algo_pvid",
-	"at_campaign",
-	"at_custom1",
-	"at_custom2",
-	"at_custom3",
-	"at_custom4",
-	"at_medium",
-	"at_preview_index",
-	"_bhlid",
-	"_branch_match_id",
-	"_branch_referrer",
-	"__readwiseLocation",
-	"campaign_id",
-	"click_sum",
-	"fref",
-	"gs_l",
-	"hmb_campaign",
-	"hmb_medium",
-	"hmb_source",
-	"ml_subscriber",
-	"ml_subscriber_hash",
-	"oly_anon_id",
-	"oly_enc_id",
-	"rb_clickid",
-	"referer",
-	"referrer",
-	"spm",
-	"trk",
-	"vero_conv",
-	"vero_id",
-	"wickedid",
-	"xtor"
-];
-const defaultNormalizeOptions = {
-	stripProtocol: true,
-	stripAuthentication: false,
-	stripWww: true,
-	stripTrailingSlash: true,
-	stripRootSlash: true,
-	collapseSlashes: true,
-	stripHash: true,
-	sortQueryParams: true,
-	stripQueryParams: defaultStrippedParams,
-	stripQuery: false,
-	stripEmptyQuery: true,
-	lowercaseQuery: false,
-	normalizeEncoding: true,
-	normalizeUnicode: true
-};
-const defaultFetch = async (url, options) => {
-	const response = await fetch(url, {
-		method: options?.method ?? "GET",
-		headers: options?.headers
-	});
-	return {
-		headers: response.headers,
-		body: await response.text(),
-		url: response.url,
-		status: response.status
-	};
-};
-const retrieveSelfLink = (parsed) => {
-	switch (parsed.format) {
-		case "atom": return parsed.feed.links?.find((link) => link.rel === "self");
-		case "rss":
-		case "rdf": return parsed.feed.atom?.links?.find((link) => link.rel === "self");
-	}
-};
-const defaultParser = {
-	parse: (body) => {
-		try {
-			return (0, feedsmith.parseFeed)(body);
-		} catch {}
-	},
-	getSelfUrl: (parsed) => {
-		return parsed.format === "json" ? parsed.feed.feed_url : retrieveSelfLink(parsed)?.href;
-	},
-	getSignature: (parsed, url) => {
-		let signature;
-		let contentUrl;
-		if (parsed.format === "json") {
-			contentUrl = parsed.feed.home_page_url;
-			signature = require_utils.createSignature(parsed.feed, ["feed_url"]);
-		} else {
-			const selfLink = retrieveSelfLink(parsed);
-			const savedSelfHref = selfLink?.href;
-			if (selfLink) selfLink.href = void 0;
-			if (parsed.format === "rss") {
-				contentUrl = parsed.feed.link;
-				signature = require_utils.createSignature(parsed.feed, [
-					"lastBuildDate",
-					"pubDate",
-					"link",
-					"generator"
-				]);
-			} else if (parsed.format === "rdf") {
-				contentUrl = parsed.feed.link;
-				signature = require_utils.createSignature(parsed.feed, ["link"]);
-			} else signature = require_utils.createSignature(parsed.feed, ["updated", "generator"]);
-			if (selfLink) selfLink.href = savedSelfHref;
-		}
-		return require_utils.neutralizeUrls(signature, contentUrl ? [url, contentUrl] : [url]);
-	}
-};
-const defaultTiers = [
-	{
-		stripProtocol: false,
-		stripAuthentication: false,
-		stripWww: true,
-		stripTrailingSlash: true,
-		stripRootSlash: true,
-		collapseSlashes: true,
-		stripHash: true,
-		sortQueryParams: false,
-		stripQuery: true,
-		stripEmptyQuery: true,
-		normalizeEncoding: true,
-		normalizeUnicode: true
-	},
-	{
-		stripProtocol: false,
-		stripAuthentication: false,
-		stripWww: true,
-		stripTrailingSlash: true,
-		stripRootSlash: true,
-		collapseSlashes: true,
-		stripHash: true,
-		sortQueryParams: true,
-		stripQuery: false,
-		stripEmptyQuery: true,
-		normalizeEncoding: true,
-		normalizeUnicode: true
-	},
-	{
-		stripProtocol: false,
-		stripAuthentication: false,
-		stripWww: false,
-		stripTrailingSlash: true,
-		stripRootSlash: true,
-		collapseSlashes: true,
-		stripHash: true,
-		sortQueryParams: true,
-		stripQuery: false,
-		stripEmptyQuery: true,
-		normalizeEncoding: true,
-		normalizeUnicode: true
-	},
-	{
-		stripProtocol: false,
-		stripAuthentication: false,
-		stripWww: false,
-		stripTrailingSlash: false,
-		stripRootSlash: true,
-		collapseSlashes: true,
-		stripHash: true,
-		sortQueryParams: true,
-		stripQuery: false,
-		stripEmptyQuery: true,
-		normalizeEncoding: true,
-		normalizeUnicode: true
-	}
-];
-//#endregion
-exports.defaultFetch = defaultFetch;
-exports.defaultNormalizeOptions = defaultNormalizeOptions;
-exports.defaultParser = defaultParser;
-exports.defaultStrippedParams = defaultStrippedParams;
-exports.defaultTiers = defaultTiers;

package/dist/defaults.d.cts

@@ -1,10 +0,0 @@
-import { DefaultParserResult, FetchFn, NormalizeOptions, ParserAdapter, Tier } from "./types.cjs";
-
-//#region src/defaults.d.ts
-declare const defaultStrippedParams: string[];
-declare const defaultNormalizeOptions: NormalizeOptions;
-declare const defaultFetch: FetchFn;
-declare const defaultParser: ParserAdapter<DefaultParserResult>;
-declare const defaultTiers: Array<Tier>;
-//#endregion
-export { defaultFetch, defaultNormalizeOptions, defaultParser, defaultStrippedParams, defaultTiers };

package/dist/exports.cjs

@@ -1,20 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils = require("./utils.cjs");
-const require_defaults = require("./defaults.cjs");
-const require_index = require("./index.cjs");
-const require_wordpress = require("./probes/wordpress.cjs");
-const require_blogger = require("./rewrites/blogger.cjs");
-const require_feedburner = require("./rewrites/feedburner.cjs");
-exports.addMissingProtocol = require_utils.addMissingProtocol;
-exports.bloggerRewrite = require_blogger.bloggerRewrite;
-exports.defaultFetch = require_defaults.defaultFetch;
-exports.defaultParser = require_defaults.defaultParser;
-exports.defaultStrippedParams = require_defaults.defaultStrippedParams;
-exports.defaultTiers = require_defaults.defaultTiers;
-exports.feedburnerRewrite = require_feedburner.feedburnerRewrite;
-exports.findCanonical = require_index.findCanonical;
-exports.fixMalformedProtocol = require_utils.fixMalformedProtocol;
-exports.normalizeUrl = require_utils.normalizeUrl;
-exports.resolveFeedProtocol = require_utils.resolveFeedProtocol;
-exports.resolveUrl = require_utils.resolveUrl;
-exports.wordpressProbe = require_wordpress.wordpressProbe;

package/dist/exports.d.cts

@@ -1,8 +0,0 @@
-import { DefaultParserResult, ExistsFn, FetchFn, FetchFnOptions, FetchFnResponse, FindCanonicalOptions, NormalizeOptions, OnExistsFn, OnFetchFn, OnMatchFn, ParserAdapter, Probe, Rewrite, Tier } from "./types.cjs";
-import { defaultFetch, defaultParser, defaultStrippedParams, defaultTiers } from "./defaults.cjs";
-import { findCanonical } from "./index.cjs";
-import { wordpressProbe } from "./probes/wordpress.cjs";
-import { bloggerRewrite } from "./rewrites/blogger.cjs";
-import { feedburnerRewrite } from "./rewrites/feedburner.cjs";
-import { addMissingProtocol, fixMalformedProtocol, normalizeUrl, resolveFeedProtocol, resolveUrl } from "./utils.cjs";
-export { type DefaultParserResult, type ExistsFn, type FetchFn, type FetchFnOptions, type FetchFnResponse, type FindCanonicalOptions, type NormalizeOptions, type OnExistsFn, type OnFetchFn, type OnMatchFn, type ParserAdapter, type Probe, type Rewrite, type Tier, addMissingProtocol, bloggerRewrite, defaultFetch, defaultParser, defaultStrippedParams, defaultTiers, feedburnerRewrite, findCanonical, fixMalformedProtocol, normalizeUrl, resolveFeedProtocol, resolveUrl, wordpressProbe };

package/dist/index.cjs

@@ -1,153 +0,0 @@
-const require_utils = require("./utils.cjs");
-const require_defaults = require("./defaults.cjs");
-//#region src/index.ts
-async function findCanonical(inputUrl, options) {
-	const { parser = require_defaults.defaultParser, fetchFn = require_defaults.defaultFetch, existsFn, tiers = require_defaults.defaultTiers, rewrites, probes, stripQueryParams = require_defaults.defaultStrippedParams, onFetch, onMatch, onExists } = options ?? {};
-	const stripParams = (url) => {
-		return require_utils.normalizeUrl(url, {
-			stripQueryParams,
-			sortQueryParams: true,
-			stripEmptyQuery: true
-		});
-	};
-	const resolveAndApplyRewrites = (url, baseUrl) => {
-		const resolved = require_utils.resolveUrl(url, baseUrl);
-		return resolved && rewrites ? require_utils.applyRewrites(resolved, rewrites) : resolved;
-	};
-	const initialRequestUrl = resolveAndApplyRewrites(inputUrl);
-	if (!initialRequestUrl) return;
-	let initialResponse;
-	try {
-		initialResponse = await fetchFn(initialRequestUrl);
-	} catch {
-		return;
-	}
-	onFetch?.({
-		url: initialRequestUrl,
-		response: initialResponse
-	});
-	if (initialResponse.status < 200 || initialResponse.status >= 300) return;
-	const initialResponseUrlRaw = resolveAndApplyRewrites(initialResponse.url);
-	if (!initialResponseUrlRaw) return;
-	const initialResponseUrl = stripParams(initialResponseUrlRaw);
-	const initialResponseBody = initialResponse.body;
-	if (!initialResponseBody) return;
-	let initialResponseSignature;
-	let selfRequestUrl;
-	const initialResponseFeed = await parser.parse(initialResponseBody);
-	if (!initialResponseFeed) return;
-	onMatch?.({
-		url: initialRequestUrl,
-		response: initialResponse,
-		feed: initialResponseFeed
-	});
-	const selfRequestUrlRaw = parser.getSelfUrl(initialResponseFeed);
-	if (selfRequestUrlRaw) {
-		selfRequestUrl = resolveAndApplyRewrites(selfRequestUrlRaw, initialResponseUrl);
-		selfRequestUrl = selfRequestUrl ? stripParams(selfRequestUrl) : void 0;
-	}
-	const compareWithInitialResponse = async (comparedResponseBody, comparedResponseUrl) => {
-		if (!comparedResponseBody) return false;
-		if (initialResponseBody === comparedResponseBody) return true;
-		const comparedResponseFeed = await parser.parse(comparedResponseBody);
-		if (comparedResponseFeed) {
-			initialResponseSignature ||= parser.getSignature(initialResponseFeed, initialResponseUrl);
-			const comparedResponseSignature = parser.getSignature(comparedResponseFeed, comparedResponseUrl);
-			return initialResponseSignature === comparedResponseSignature;
-		}
-		return false;
-	};
-	const fetchAndCompare = async (url) => {
-		let response;
-		try {
-			response = await fetchFn(url);
-		} catch {
-			return;
-		}
-		onFetch?.({
-			url,
-			response
-		});
-		if (response.status < 200 || response.status >= 300) return;
-		if (!await compareWithInitialResponse(response.body, response.url)) return;
-		return response;
-	};
-	let candidateSourceUrl = initialResponseUrl;
-	if (selfRequestUrl && selfRequestUrl !== initialResponseUrl) {
-		const urlsToTry = [selfRequestUrl];
-		if (selfRequestUrl.startsWith("https://")) urlsToTry.push(selfRequestUrl.replace("https://", "http://"));
-		else if (selfRequestUrl.startsWith("http://")) urlsToTry.push(selfRequestUrl.replace("http://", "https://"));
-		for (const urlToTry of urlsToTry) {
-			const response = await fetchAndCompare(urlToTry);
-			if (response) {
-				onMatch?.({
-					url: urlToTry,
-					response,
-					feed: initialResponseFeed
-				});
-				candidateSourceUrl = resolveAndApplyRewrites(response.url) ?? initialResponseUrl;
-				candidateSourceUrl = stripParams(candidateSourceUrl);
-				break;
-			}
-		}
-	}
-	if (probes && probes?.length > 0) candidateSourceUrl = await require_utils.applyProbes(candidateSourceUrl, probes, async (candidateUrl) => {
-		const response = await fetchAndCompare(candidateUrl);
-		if (response) {
-			onMatch?.({
-				url: candidateUrl,
-				response,
-				feed: initialResponseFeed
-			});
-			return stripParams(resolveAndApplyRewrites(response.url) ?? candidateUrl);
-		}
-	});
-	const candidateUrls = new Set(tiers.map((tier) => resolveAndApplyRewrites(require_utils.normalizeUrl(candidateSourceUrl, tier))).filter((candidateUrl) => !!candidateUrl));
-	candidateUrls.add(candidateSourceUrl);
-	let winningUrl = candidateSourceUrl;
-	for (const candidateUrl of candidateUrls) {
-		if (existsFn) {
-			const data = await existsFn(candidateUrl);
-			if (data !== void 0) {
-				onExists?.({
-					url: candidateUrl,
-					data
-				});
-				return candidateUrl;
-			}
-		}
-		if (candidateUrl === candidateSourceUrl) continue;
-		if (candidateUrl === initialResponseUrl) {
-			winningUrl = initialResponseUrl;
-			break;
-		}
-		const candidateResponse = await fetchAndCompare(candidateUrl);
-		if (candidateResponse) {
-			let candidateResponseUrl = resolveAndApplyRewrites(candidateResponse.url);
-			if (candidateResponseUrl) candidateResponseUrl = stripParams(candidateResponseUrl);
-			if (candidateResponseUrl === candidateSourceUrl || candidateResponseUrl === initialResponseUrl) continue;
-			onMatch?.({
-				url: candidateUrl,
-				response: candidateResponse,
-				feed: initialResponseFeed
-			});
-			winningUrl = candidateUrl;
-			break;
-		}
-	}
-	if (winningUrl.startsWith("http://")) {
-		const httpsUrl = winningUrl.replace("http://", "https://");
-		const response = await fetchAndCompare(httpsUrl);
-		if (response) {
-			onMatch?.({
-				url: httpsUrl,
-				response,
-				feed: initialResponseFeed
-			});
-			return httpsUrl;
-		}
-	}
-	return winningUrl;
-}
-//#endregion
-exports.findCanonical = findCanonical;

package/dist/index.d.cts

@@ -1,9 +0,0 @@
-import { DefaultParserResult, FetchFnResponse, FindCanonicalOptions, ParserAdapter } from "./types.cjs";
-
-//#region src/index.d.ts
-declare function findCanonical<TResponse extends FetchFnResponse = FetchFnResponse, TExisting = unknown>(inputUrl: string, options?: Omit<FindCanonicalOptions<DefaultParserResult, TResponse, TExisting>, 'parser'>): Promise<string | undefined>;
-declare function findCanonical<TFeed, TResponse extends FetchFnResponse = FetchFnResponse, TExisting = unknown>(inputUrl: string, options: FindCanonicalOptions<TFeed, TResponse, TExisting> & {
-  parser: ParserAdapter<TFeed>;
-}): Promise<string | undefined>;
-//#endregion
-export { findCanonical };

package/dist/probes/wordpress.cjs

@@ -1,51 +0,0 @@
-//#region src/probes/wordpress.ts
-const commentsFeedPathRegex = /\/comments\/feed(\/|$)/;
-const feedPathRegex = /\/feed(\/|$)/;
-const trailingSlashRegex = /\/$/;
-const optionalTrailingSlashRegex = /\/?$/;
-const feedTypes = [
-	"atom",
-	"rss2",
-	"rss",
-	"rdf"
-];
-const wordpressProbe = {
-	match: (url) => {
-		const feed = url.searchParams.get("feed")?.toLowerCase();
-		if (!feed) return false;
-		const type = feed.startsWith("comments-") ? feed.slice(9) : feed;
-		return feedTypes.includes(type);
-	},
-	getCandidates: (url) => {
-		const feed = url.searchParams.get("feed")?.toLowerCase();
-		if (!feed) return [];
-		const candidates = [];
-		const isComment = feed.startsWith("comments-");
-		const type = isComment ? feed.slice(9) : feed;
-		if ((isComment ? commentsFeedPathRegex : feedPathRegex).test(url.pathname)) {
-			const withoutSlash = new URL(url);
-			withoutSlash.pathname = url.pathname.replace(trailingSlashRegex, "");
-			withoutSlash.searchParams.delete("feed");
-			candidates.push(withoutSlash.href);
-			const withSlash = new URL(url);
-			withSlash.pathname = url.pathname.replace(optionalTrailingSlashRegex, "/");
-			withSlash.searchParams.delete("feed");
-			candidates.push(withSlash.href);
-			return candidates;
-		}
-		const basePath = url.pathname.replace(trailingSlashRegex, "");
-		const feedSegment = type === "atom" ? "/feed/atom" : "/feed";
-		const feedPath = isComment ? `/comments${feedSegment}` : feedSegment;
-		const primary = new URL(url);
-		primary.pathname = basePath + feedPath;
-		primary.searchParams.delete("feed");
-		candidates.push(primary.href);
-		const withSlash = new URL(url);
-		withSlash.pathname = `${basePath}${feedPath}/`;
-		withSlash.searchParams.delete("feed");
-		candidates.push(withSlash.href);
-		return candidates;
-	}
-};
-//#endregion
-exports.wordpressProbe = wordpressProbe;

package/dist/probes/wordpress.d.cts

@@ -1,6 +0,0 @@
-import { Probe } from "../types.cjs";
-
-//#region src/probes/wordpress.d.ts
-declare const wordpressProbe: Probe;
-//#endregion
-export { wordpressProbe };

package/dist/rewrites/blogger.cjs

@@ -1,47 +0,0 @@
-const require_utils = require("../utils.cjs");
-//#region src/rewrites/blogger.ts
-const bloggerRegex = /^(www\.|beta\.)?blogger\.com$/;
-const blogspotRegex = /\.blogspot\.[a-z]{2,3}(\.[a-z]{2})?$/i;
-const bloggerRewrite = {
-	match: (url) => {
-		return bloggerRegex.test(url.hostname) || blogspotRegex.test(url.hostname);
-	},
-	rewrite: (url) => {
-		const rewritten = new URL(url);
-		const isBlogger = bloggerRegex.test(rewritten.hostname);
-		const isBlogspot = blogspotRegex.test(rewritten.hostname);
-		rewritten.protocol = "https:";
-		if (isBlogger) rewritten.hostname = "www.blogger.com";
-		if (isBlogspot) {
-			rewritten.hostname = rewritten.hostname.replace(blogspotRegex, ".blogspot.com");
-			if (rewritten.pathname === "/atom.xml") rewritten.pathname = "/feeds/posts/default";
-			else if (rewritten.pathname === "/rss.xml") {
-				rewritten.pathname = "/feeds/posts/default";
-				rewritten.searchParams.set("alt", "rss");
-			}
-		}
-		rewritten.searchParams.delete("redirect");
-		const alt = rewritten.searchParams.get("alt");
-		if (alt === "atom" || alt === "json" || alt === "") rewritten.searchParams.delete("alt");
-		rewritten.searchParams.delete("v");
-		rewritten.searchParams.delete("max-results");
-		rewritten.searchParams.delete("start-index");
-		rewritten.searchParams.delete("published-min");
-		rewritten.searchParams.delete("published-max");
-		rewritten.searchParams.delete("updated-min");
-		rewritten.searchParams.delete("updated-max");
-		rewritten.searchParams.delete("orderby");
-		const normalized = require_utils.normalizeUrl(rewritten.href, {
-			stripTrailingSlash: true,
-			collapseSlashes: true,
-			stripHash: true,
-			normalizeEncoding: true,
-			normalizeUnicode: true,
-			stripEmptyQuery: true,
-			sortQueryParams: true
-		});
-		return new URL(normalized);
-	}
-};
-//#endregion
-exports.bloggerRewrite = bloggerRewrite;

package/dist/rewrites/blogger.d.cts

@@ -1,6 +0,0 @@
-import { Rewrite } from "../types.cjs";
-
-//#region src/rewrites/blogger.d.ts
-declare const bloggerRewrite: Rewrite;
-//#endregion
-export { bloggerRewrite };

package/dist/rewrites/feedburner.cjs

@@ -1,27 +0,0 @@
-const require_utils = require("../utils.cjs");
-//#region src/rewrites/feedburner.ts
-const hosts = [
-	"feeds.feedburner.com",
-	"feeds2.feedburner.com",
-	"feedproxy.google.com"
-];
-const feedburnerRewrite = {
-	match: (url) => {
-		return hosts.includes(url.hostname);
-	},
-	rewrite: (url) => {
-		const rewritten = new URL(url);
-		rewritten.hostname = "feeds.feedburner.com";
-		rewritten.search = "";
-		const normalized = require_utils.normalizeUrl(rewritten.href, {
-			stripTrailingSlash: true,
-			collapseSlashes: true,
-			stripHash: true,
-			normalizeEncoding: true,
-			normalizeUnicode: true
-		});
-		return new URL(normalized);
-	}
-};
-//#endregion
-exports.feedburnerRewrite = feedburnerRewrite;

package/dist/rewrites/feedburner.d.cts

@@ -1,6 +0,0 @@
-import { Rewrite } from "../types.cjs";
-
-//#region src/rewrites/feedburner.d.ts
-declare const feedburnerRewrite: Rewrite;
-//#endregion
-export { feedburnerRewrite };

package/dist/types.d.cts

@@ -1,74 +0,0 @@
-import * as _$feedsmith from "feedsmith";
-
-//#region src/types.d.ts
-type MaybePromise<T> = T | Promise<T>;
-type DefaultParserResult = ReturnType<typeof _$feedsmith.parseFeed>;
-type ParserAdapter<T> = {
-  parse: (body: string) => MaybePromise<T | undefined>;
-  getSelfUrl: (parsed: T) => string | undefined;
-  getSignature: (parsed: T, url: string) => string;
-};
-type Rewrite = {
-  match: (url: URL) => boolean;
-  rewrite: (url: URL) => URL;
-};
-type Probe = {
-  match: (url: URL) => boolean;
-  getCandidates: (url: URL) => Array<string>;
-};
-type NormalizeOptions = {
-  stripProtocol?: boolean;
-  stripAuthentication?: boolean;
-  stripWww?: boolean;
-  stripTrailingSlash?: boolean;
-  stripRootSlash?: boolean;
-  collapseSlashes?: boolean;
-  stripHash?: boolean;
-  sortQueryParams?: boolean;
-  stripQueryParams?: Array<string>;
-  stripQuery?: boolean;
-  stripEmptyQuery?: boolean;
-  lowercaseQuery?: boolean;
-  normalizeEncoding?: boolean;
-  normalizeUnicode?: boolean;
-};
-type Tier = Omit<NormalizeOptions, 'stripQueryParams'>;
-type OnFetchFn<TResponse extends FetchFnResponse = FetchFnResponse> = (data: {
-  url: string;
-  response: TResponse;
-}) => void;
-type OnMatchFn<TFeed = unknown, TResponse extends FetchFnResponse = FetchFnResponse> = (data: {
-  url: string;
-  response: TResponse;
-  feed: TFeed;
-}) => void;
-type OnExistsFn<T> = (data: {
-  url: string;
-  data: T;
-}) => void;
-type FindCanonicalOptions<TFeed = DefaultParserResult, TResponse extends FetchFnResponse = FetchFnResponse, TExisting = unknown> = {
-  parser?: ParserAdapter<TFeed>;
-  fetchFn?: FetchFn<TResponse>;
-  existsFn?: ExistsFn<TExisting>;
-  rewrites?: Array<Rewrite>;
-  probes?: Array<Probe>;
-  tiers?: Array<Tier>;
-  stripQueryParams?: Array<string>;
-  onFetch?: OnFetchFn<TResponse>;
-  onMatch?: OnMatchFn<TFeed, TResponse>;
-  onExists?: OnExistsFn<TExisting>;
-};
-type FetchFnOptions = {
-  method?: 'GET' | 'HEAD';
-  headers?: Record<string, string>;
-};
-type ExistsFn<T = unknown> = (url: string) => MaybePromise<T | undefined>;
-type FetchFnResponse = {
-  headers: Headers;
-  body: string;
-  url: string;
-  status: number;
-};
-type FetchFn<TResponse extends FetchFnResponse = FetchFnResponse> = (url: string, options?: FetchFnOptions) => MaybePromise<TResponse>;
-//#endregion
-export { DefaultParserResult, ExistsFn, FetchFn, FetchFnOptions, FetchFnResponse, FindCanonicalOptions, NormalizeOptions, OnExistsFn, OnFetchFn, OnMatchFn, ParserAdapter, Probe, Rewrite, Tier };

package/dist/utils.cjs

@@ -1,208 +0,0 @@
-const require_defaults = require("./defaults.cjs");
-let entities = require("entities");
-//#region src/utils.ts
-const strippedParamsCache = /* @__PURE__ */ new WeakMap();
-const getStrippedParamsSet = (params) => {
-	let cached = strippedParamsCache.get(params);
-	if (!cached) {
-		cached = new Set(params.map((param) => param.toLowerCase()));
-		strippedParamsCache.set(params, cached);
-	}
-	return cached;
-};
-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 safePathCharsRegex = /[a-zA-Z0-9._~!$&'()*+,;=:@-]/;
-const httpsLetterRegex = /s/i;
-const protocolPrefixRegex = /^https?:\/\//;
-const wwwPrefixRegex = /^www\./;
-const validUrlRegex = /^https?:\/\/(?:www\.|[a-vx-z0-9])/i;
-const doubledProtocolRegex = /^\/?[htps]{2,7}[:\s=.\\/]+([htps]{2,7})[:\s=.\\/]+[.,:/]*(www[./]+)?/i;
-const singleMalformedRegex = /^\/?(?:h[htps():]{1,10}|t{1,2}ps?)[:\s=.\\/]+[.,:/]*(www[./]+)?/i;
-const fixMalformedProtocol = (url) => {
-	if (validUrlRegex.test(url) && !doubledProtocolRegex.test(url)) return url;
-	const doubledMatch = doubledProtocolRegex.exec(url);
-	if (doubledMatch) {
-		const inner = doubledMatch[1];
-		const www = doubledMatch[2];
-		const rest = url.slice(doubledMatch[0].length);
-		return (httpsLetterRegex.test(inner) ? "https://" : "http://") + (www ? "www." : "") + rest;
-	}
-	const singleMatch = singleMalformedRegex.exec(url);
-	if (singleMatch) {
-		const fullMatch = singleMatch[0];
-		const www = singleMatch[1];
-		const rest = url.slice(fullMatch.length);
-		return (httpsLetterRegex.test(fullMatch) ? "https://" : "http://") + (www ? "www." : "") + rest;
-	}
-	return url;
-};
-const feedProtocols = [
-	"feed:",
-	"rss:",
-	"podcast:",
-	"pcast:",
-	"itpc:"
-];
-const resolveFeedProtocol = (url, protocol = "https") => {
-	const urlLower = url.toLowerCase();
-	for (const scheme of feedProtocols) {
-		if (!urlLower.startsWith(scheme)) continue;
-		if (urlLower.startsWith(`${scheme}http://`) || urlLower.startsWith(`${scheme}https://`)) return url.slice(scheme.length);
-		if (urlLower.startsWith(`${scheme}//`)) return `${protocol}:${url.slice(scheme.length)}`;
-	}
-	return url;
-};
-const addMissingProtocol = (url, protocol = "https") => {
-	const colonIndex = url.indexOf(":");
-	if (colonIndex > 0) {
-		const beforeColon = url.slice(0, colonIndex);
-		if (!beforeColon.includes(".") && !beforeColon.includes("/") && beforeColon !== "localhost") return url;
-	}
-	if (url.startsWith("//") && !url.startsWith("///")) try {
-		const parsed = new URL(`${protocol}:${url}`);
-		const hostname = parsed.hostname;
-		if (hostname.includes(".") || hostname === "localhost" || ipv4Regex.test(hostname) || ipv6Regex.test(hostname.replace(/^\[|\]$/g, ""))) return parsed.href;
-		return url;
-	} catch {
-		return url;
-	}
-	if (url.startsWith("/") || url.startsWith(".")) return url;
-	const slashIndex = url.indexOf("/");
-	const dotIndex = url.indexOf(".");
-	if (dotIndex === -1 || slashIndex !== -1 && dotIndex > slashIndex) {
-		if (!url.startsWith("localhost")) return url;
-	}
-	const firstChar = url.charAt(0);
-	if (firstChar === " " || firstChar === "	" || firstChar === "\n") return url;
-	return `${protocol}://${url}`;
-};
-const resolveUrl = (url, base) => {
-	if (url.startsWith("#") && !base) return;
-	let resolvedUrl;
-	resolvedUrl = url.includes("&") ? (0, entities.decodeHTML)(url) : url;
-	resolvedUrl = resolveFeedProtocol(resolvedUrl);
-	resolvedUrl = fixMalformedProtocol(resolvedUrl);
-	if (base) try {
-		resolvedUrl = new URL(resolvedUrl, base).href;
-	} catch {
-		return;
-	}
-	resolvedUrl = addMissingProtocol(resolvedUrl);
-	try {
-		const parsed = new URL(resolvedUrl);
-		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
-		return parsed.href;
-	} catch {
-		return;
-	}
-};
-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);
-		const char = String.fromCharCode(charCode);
-		if (safePathCharsRegex.test(char)) return char;
-		return `%${hex.toUpperCase()}`;
-	});
-};
-const normalizeUrl = (url, options = require_defaults.defaultNormalizeOptions) => {
-	try {
-		const parsed = new URL(url);
-		if (options.normalizeUnicode) {
-			parsed.hostname = parsed.hostname.normalize("NFC");
-			parsed.pathname = parsed.pathname.normalize("NFC");
-		}
-		if (options.stripAuthentication) {
-			parsed.username = "";
-			parsed.password = "";
-		}
-		if (options.stripWww && parsed.hostname.startsWith("www.")) parsed.hostname = parsed.hostname.slice(4);
-		if (options.stripHash) parsed.hash = "";
-		let pathname = parsed.pathname;
-		if (options.normalizeEncoding) pathname = decodeAndNormalizeEncoding(pathname);
-		if (options.collapseSlashes) pathname = pathname.replace(/\/+/g, "/");
-		if (options.stripTrailingSlash && pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
-		if (options.stripRootSlash && pathname === "/") pathname = "";
-		parsed.pathname = pathname;
-		if (options.stripQuery) parsed.search = "";
-		if (options.stripQueryParams && parsed.search) {
-			const strippedSet = getStrippedParamsSet(options.stripQueryParams);
-			const paramsToDelete = [];
-			for (const [key] of parsed.searchParams) if (strippedSet.has(key.toLowerCase())) paramsToDelete.push(key);
-			for (const param of paramsToDelete) parsed.searchParams.delete(param);
-		}
-		if (options.lowercaseQuery && parsed.search) {
-			const entries = [...parsed.searchParams.entries()];
-			parsed.search = "";
-			for (const [key, value] of entries) parsed.searchParams.append(key.toLowerCase(), value.toLowerCase());
-		}
-		if (options.sortQueryParams && parsed.search) parsed.searchParams.sort();
-		if (options.stripEmptyQuery && parsed.href.endsWith("?")) parsed.search = "";
-		let result = parsed.href;
-		if (options.stripRootSlash && result === `${parsed.origin}/`) result = parsed.origin;
-		if (options.stripProtocol) result = result.replace(protocolPrefixRegex, "");
-		return result;
-	} catch {
-		return url;
-	}
-};
-const applyRewrites = (url, rewrites) => {
-	try {
-		let parsed = new URL(url);
-		for (const rewrite of rewrites) if (rewrite.match(parsed)) {
-			parsed = rewrite.rewrite(parsed);
-			break;
-		}
-		return parsed.href;
-	} catch {
-		return url;
-	}
-};
-const applyProbes = async (url, probes, testCandidate) => {
-	try {
-		const parsed = new URL(url);
-		for (const probe of probes) {
-			if (!probe.match(parsed)) continue;
-			for (const candidate of probe.getCandidates(parsed)) {
-				const result = await testCandidate(candidate);
-				if (result) return result;
-			}
-			break;
-		}
-		return url;
-	} catch {
-		return url;
-	}
-};
-const createSignature = (object, fields) => {
-	const saved = fields.map((key) => [key, object[key]]);
-	for (const key of fields) object[key] = void 0;
-	const signature = JSON.stringify(object);
-	for (const [key, val] of saved) object[key] = val;
-	return signature;
-};
-const trailingSlashRegex = /("(?:https?:\/\/|\/)[^"]+)\/([?"])/g;
-const neutralizeUrls = (text, urls) => {
-	const escapeHost = (url) => {
-		try {
-			return new URL("/", url).host.replace(wwwPrefixRegex, "").replaceAll(".", "\\.");
-		} catch {
-			return;
-		}
-	};
-	const hosts = urls.map(escapeHost).filter(Boolean);
-	if (hosts.length === 0) return text;
-	const hostPattern = hosts.length === 1 ? hosts[0] : `(?:${hosts.join("|")})`;
-	return text.replace(new RegExp(`https?://(?:www\\.)?${hostPattern}(?=[/"]|\\\\")(/)?`, "g"), "/").replace(trailingSlashRegex, "$1$2");
-};
-//#endregion
-exports.addMissingProtocol = addMissingProtocol;
-exports.applyProbes = applyProbes;
-exports.applyRewrites = applyRewrites;
-exports.createSignature = createSignature;
-exports.fixMalformedProtocol = fixMalformedProtocol;
-exports.neutralizeUrls = neutralizeUrls;
-exports.normalizeUrl = normalizeUrl;
-exports.resolveFeedProtocol = resolveFeedProtocol;
-exports.resolveUrl = resolveUrl;

package/dist/utils.d.cts

@@ -1,10 +0,0 @@
-import { NormalizeOptions } from "./types.cjs";
-
-//#region src/utils.d.ts
-declare const fixMalformedProtocol: (url: string) => string;
-declare const resolveFeedProtocol: (url: string, protocol?: "http" | "https") => string;
-declare const addMissingProtocol: (url: string, protocol?: "http" | "https") => string;
-declare const resolveUrl: (url: string, base?: string) => string | undefined;
-declare const normalizeUrl: (url: string, options?: NormalizeOptions) => string;
-//#endregion
-export { addMissingProtocol, fixMalformedProtocol, normalizeUrl, resolveFeedProtocol, resolveUrl };