feedcanon 0.9.0

package/dist/index.js

@@ -0,0 +1,131 @@
+import { defaultPlatforms, defaultTiers } from "./defaults.js";
+import { applyPlatformHandlers, feedsmithParser, nativeFetch, normalizeUrl, resolveUrl } from "./utils.js";
+
+//#region src/index.ts
+const findCanonical = async (inputUrl, options) => {
+	const { fetchFn = nativeFetch, existsFn, parser = feedsmithParser, tiers = defaultTiers, platforms = defaultPlatforms, onFetch, onMatch, onExists } = options ?? {};
+	const resolveAndApplyPlatformHandlers = (url, baseUrl) => {
+		const resolved = resolveUrl(url, baseUrl);
+		return resolved ? applyPlatformHandlers(resolved, platforms) : void 0;
+	};
+	const initialRequestUrl = resolveAndApplyPlatformHandlers(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 initialResponseUrl = resolveAndApplyPlatformHandlers(initialResponse.url);
+	if (!initialResponseUrl) return;
+	const initialResponseBody = initialResponse.body;
+	if (!initialResponseBody) return;
+	let initialResponseSignature;
+	let selfRequestUrl;
+	const initialResponseFeed = parser.parse(initialResponseBody);
+	if (!initialResponseFeed) return;
+	onMatch?.({
+		url: initialRequestUrl,
+		response: initialResponse,
+		feed: initialResponseFeed
+	});
+	const selfRequestUrlRaw = parser.getSelfUrl(initialResponseFeed);
+	if (selfRequestUrlRaw) selfRequestUrl = resolveAndApplyPlatformHandlers(selfRequestUrlRaw, initialResponseUrl);
+	const compareWithInitialResponse = (comparedResponseBody) => {
+		if (!comparedResponseBody) return false;
+		if (initialResponseBody === comparedResponseBody) return true;
+		const comparedResponseFeed = parser.parse(comparedResponseBody);
+		if (comparedResponseFeed) {
+			initialResponseSignature ||= JSON.stringify(parser.getSignature(initialResponseFeed));
+			const comparedResponseSignature = JSON.stringify(parser.getSignature(comparedResponseFeed));
+			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 (!compareWithInitialResponse(response.body)) return;
+		return response;
+	};
+	let variantSource = 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
+				});
+				variantSource = resolveAndApplyPlatformHandlers(response.url) ?? initialResponseUrl;
+				break;
+			}
+		}
+	}
+	const variants = new Set(tiers.map((tier) => resolveAndApplyPlatformHandlers(normalizeUrl(variantSource, tier))).filter((url) => url !== void 0));
+	variants.add(variantSource);
+	let winningUrl = variantSource;
+	for (const variant of variants) {
+		if (existsFn) {
+			const data = await existsFn(variant);
+			if (data !== void 0) {
+				onExists?.({
+					url: variant,
+					data
+				});
+				return variant;
+			}
+		}
+		if (variant === variantSource) continue;
+		if (variant === initialResponseUrl) {
+			winningUrl = initialResponseUrl;
+			break;
+		}
+		const response = await fetchAndCompare(variant);
+		if (response) {
+			const preparedResponseUrl = resolveAndApplyPlatformHandlers(response.url);
+			if (preparedResponseUrl === variantSource || preparedResponseUrl === initialResponseUrl) continue;
+			onMatch?.({
+				url: variant,
+				response,
+				feed: initialResponseFeed
+			});
+			winningUrl = variant;
+			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
+export { findCanonical };

package/dist/platforms/feedburner.cjs

@@ -0,0 +1,21 @@
+
+//#region src/platforms/feedburner.ts
+const hosts = new Set([
+	"feeds.feedburner.com",
+	"feeds2.feedburner.com",
+	"feedproxy.google.com"
+]);
+const feedburnerHandler = {
+	match: (url) => {
+		return hosts.has(url.hostname);
+	},
+	normalize: (url) => {
+		const normalized = new URL(url);
+		normalized.hostname = "feeds.feedburner.com";
+		normalized.search = "";
+		return normalized;
+	}
+};
+
+//#endregion
+exports.feedburnerHandler = feedburnerHandler;

package/dist/platforms/feedburner.d.cts

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

package/dist/platforms/feedburner.d.ts

@@ -0,0 +1,6 @@
+import { PlatformHandler } from "../types.js";
+
+//#region src/platforms/feedburner.d.ts
+declare const feedburnerHandler: PlatformHandler;
+//#endregion
+export { feedburnerHandler };

package/dist/platforms/feedburner.js

@@ -0,0 +1,20 @@
+//#region src/platforms/feedburner.ts
+const hosts = new Set([
+	"feeds.feedburner.com",
+	"feeds2.feedburner.com",
+	"feedproxy.google.com"
+]);
+const feedburnerHandler = {
+	match: (url) => {
+		return hosts.has(url.hostname);
+	},
+	normalize: (url) => {
+		const normalized = new URL(url);
+		normalized.hostname = "feeds.feedburner.com";
+		normalized.search = "";
+		return normalized;
+	}
+};
+
+//#endregion
+export { feedburnerHandler };

package/dist/types.d.cts

@@ -0,0 +1,64 @@
+//#region src/types.d.ts
+type ParserAdapter<T> = {
+  parse: (body: string) => T | undefined;
+  getSelfUrl: (parsed: T) => string | undefined;
+  getSignature: (parsed: T) => object;
+};
+type PlatformHandler = {
+  match: (url: URL) => boolean;
+  normalize: (url: URL) => URL;
+};
+type NormalizeOptions = {
+  stripProtocol?: boolean;
+  stripAuthentication?: boolean;
+  stripWww?: boolean;
+  stripTrailingSlash?: boolean;
+  stripRootSlash?: boolean;
+  collapseSlashes?: boolean;
+  stripHash?: boolean;
+  stripTextFragment?: boolean;
+  sortQueryParams?: boolean;
+  stripQueryParams?: Array<string>;
+  stripEmptyQuery?: boolean;
+  normalizeEncoding?: boolean;
+  lowercaseHostname?: boolean;
+  normalizeUnicode?: boolean;
+  convertToPunycode?: boolean;
+};
+type OnFetchFn = (data: {
+  url: string;
+  response: FetchFnResponse;
+}) => void;
+type OnMatchFn<TFeed = unknown> = (data: {
+  url: string;
+  response: FetchFnResponse;
+  feed: TFeed;
+}) => void;
+type OnExistsFn<T> = (data: {
+  url: string;
+  data: T;
+}) => void;
+type ExistsFn<T = unknown> = (url: string) => Promise<T | undefined>;
+type FindCanonicalOptions<TFeed = unknown, TExisting = unknown> = {
+  parser?: ParserAdapter<TFeed>;
+  fetchFn?: FetchFn;
+  existsFn?: ExistsFn<TExisting>;
+  tiers?: Array<NormalizeOptions>;
+  platforms?: Array<PlatformHandler>;
+  onFetch?: OnFetchFn;
+  onMatch?: OnMatchFn<TFeed>;
+  onExists?: OnExistsFn<TExisting>;
+};
+type FetchFnOptions = {
+  method?: 'GET' | 'HEAD';
+  headers?: Record<string, string>;
+};
+type FetchFnResponse = {
+  headers: Headers;
+  body: string;
+  url: string;
+  status: number;
+};
+type FetchFn = (url: string, options?: FetchFnOptions) => Promise<FetchFnResponse>;
+//#endregion
+export { ExistsFn, FetchFn, FetchFnOptions, FetchFnResponse, FindCanonicalOptions, NormalizeOptions, OnExistsFn, OnFetchFn, OnMatchFn, ParserAdapter, PlatformHandler };

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+//#region src/types.d.ts
+type ParserAdapter<T> = {
+  parse: (body: string) => T | undefined;
+  getSelfUrl: (parsed: T) => string | undefined;
+  getSignature: (parsed: T) => object;
+};
+type PlatformHandler = {
+  match: (url: URL) => boolean;
+  normalize: (url: URL) => URL;
+};
+type NormalizeOptions = {
+  stripProtocol?: boolean;
+  stripAuthentication?: boolean;
+  stripWww?: boolean;
+  stripTrailingSlash?: boolean;
+  stripRootSlash?: boolean;
+  collapseSlashes?: boolean;
+  stripHash?: boolean;
+  stripTextFragment?: boolean;
+  sortQueryParams?: boolean;
+  stripQueryParams?: Array<string>;
+  stripEmptyQuery?: boolean;
+  normalizeEncoding?: boolean;
+  lowercaseHostname?: boolean;
+  normalizeUnicode?: boolean;
+  convertToPunycode?: boolean;
+};
+type OnFetchFn = (data: {
+  url: string;
+  response: FetchFnResponse;
+}) => void;
+type OnMatchFn<TFeed = unknown> = (data: {
+  url: string;
+  response: FetchFnResponse;
+  feed: TFeed;
+}) => void;
+type OnExistsFn<T> = (data: {
+  url: string;
+  data: T;
+}) => void;
+type ExistsFn<T = unknown> = (url: string) => Promise<T | undefined>;
+type FindCanonicalOptions<TFeed = unknown, TExisting = unknown> = {
+  parser?: ParserAdapter<TFeed>;
+  fetchFn?: FetchFn;
+  existsFn?: ExistsFn<TExisting>;
+  tiers?: Array<NormalizeOptions>;
+  platforms?: Array<PlatformHandler>;
+  onFetch?: OnFetchFn;
+  onMatch?: OnMatchFn<TFeed>;
+  onExists?: OnExistsFn<TExisting>;
+};
+type FetchFnOptions = {
+  method?: 'GET' | 'HEAD';
+  headers?: Record<string, string>;
+};
+type FetchFnResponse = {
+  headers: Headers;
+  body: string;
+  url: string;
+  status: number;
+};
+type FetchFn = (url: string, options?: FetchFnOptions) => Promise<FetchFnResponse>;
+//#endregion
+export { ExistsFn, FetchFn, FetchFnOptions, FetchFnResponse, FindCanonicalOptions, NormalizeOptions, OnExistsFn, OnFetchFn, OnMatchFn, ParserAdapter, PlatformHandler };

package/dist/utils.cjs

@@ -0,0 +1,163 @@
+const require_defaults = require('./defaults.cjs');
+let node_url = require("node:url");
+let entities = require("entities");
+let feedsmith = require("feedsmith");
+
+//#region src/utils.ts
+const ipv4Pattern = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const ipv6Pattern = /^([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$/i;
+const safePathChars = /[a-zA-Z0-9._~!$&'()*+,;=:@-]/;
+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") => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.protocol.includes(".") && parsed.protocol !== "localhost:") return url;
+	} catch {}
+	if (url.startsWith("//") && !url.startsWith("///")) try {
+		const parsed = new URL(`${protocol}:${url}`);
+		const hostname = parsed.hostname;
+		if (hostname.includes(".") || hostname === "localhost" || ipv4Pattern.test(hostname) || ipv6Pattern.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) => {
+	let resolvedUrl;
+	resolvedUrl = url.includes("&") ? (0, entities.decodeHTML)(url) : url;
+	resolvedUrl = resolveFeedProtocol(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 (safePathChars.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.convertToPunycode) {
+			const ascii = (0, node_url.domainToASCII)(parsed.hostname);
+			if (ascii) parsed.hostname = ascii;
+		}
+		if (options.lowercaseHostname) parsed.hostname = parsed.hostname.toLowerCase();
+		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 = "";
+		if (options.stripTextFragment && parsed.hash.startsWith("#:~:")) 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.stripQueryParams && parsed.search) for (const param of options.stripQueryParams) parsed.searchParams.delete(param);
+		if (options.sortQueryParams) parsed.searchParams.sort();
+		if (options.stripEmptyQuery && parsed.search === "?") parsed.search = "";
+		let result = parsed.href;
+		if (options.stripProtocol) result = result.replace(/^https?:\/\//, "");
+		return result;
+	} catch {
+		return url;
+	}
+};
+const nativeFetch = 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 applyPlatformHandlers = (url, platforms) => {
+	try {
+		let parsed = new URL(url);
+		for (const handler of platforms) if (handler.match(parsed)) {
+			parsed = handler.normalize(parsed);
+			break;
+		}
+		return parsed.href;
+	} catch {
+		return url;
+	}
+};
+const feedsmithParser = {
+	parse: (body) => {
+		try {
+			return (0, feedsmith.parseFeed)(body);
+		} catch {
+			return;
+		}
+	},
+	getSelfUrl: (parsed) => {
+		switch (parsed.format) {
+			case "atom": return parsed.feed.links?.find((link) => link.rel === "self")?.href;
+			case "rss":
+			case "rdf": return parsed.feed.atom?.links?.find((link) => link.rel === "self")?.href;
+			case "json": return parsed.feed.feed_url;
+		}
+	},
+	getSignature: (parsed) => {
+		return parsed.feed;
+	}
+};
+
+//#endregion
+exports.addMissingProtocol = addMissingProtocol;
+exports.applyPlatformHandlers = applyPlatformHandlers;
+exports.feedsmithParser = feedsmithParser;
+exports.nativeFetch = nativeFetch;
+exports.normalizeUrl = normalizeUrl;
+exports.resolveFeedProtocol = resolveFeedProtocol;
+exports.resolveUrl = resolveUrl;

package/dist/utils.d.cts

@@ -0,0 +1,11 @@
+import { NormalizeOptions, ParserAdapter } from "./types.cjs";
+import { parseFeed } from "feedsmith";
+
+//#region src/utils.d.ts
+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;
+declare const feedsmithParser: ParserAdapter<ReturnType<typeof parseFeed>>;
+//#endregion
+export { addMissingProtocol, feedsmithParser, normalizeUrl, resolveFeedProtocol, resolveUrl };

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+import { NormalizeOptions, ParserAdapter } from "./types.js";
+import { parseFeed } from "feedsmith";
+
+//#region src/utils.d.ts
+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;
+declare const feedsmithParser: ParserAdapter<ReturnType<typeof parseFeed>>;
+//#endregion
+export { addMissingProtocol, feedsmithParser, normalizeUrl, resolveFeedProtocol, resolveUrl };

package/dist/utils.js

@@ -0,0 +1,157 @@
+import { defaultNormalizeOptions } from "./defaults.js";
+import { domainToASCII } from "node:url";
+import { decodeHTML } from "entities";
+import { parseFeed } from "feedsmith";
+
+//#region src/utils.ts
+const ipv4Pattern = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const ipv6Pattern = /^([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}$/i;
+const safePathChars = /[a-zA-Z0-9._~!$&'()*+,;=:@-]/;
+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") => {
+	try {
+		const parsed = new URL(url);
+		if (!parsed.protocol.includes(".") && parsed.protocol !== "localhost:") return url;
+	} catch {}
+	if (url.startsWith("//") && !url.startsWith("///")) try {
+		const parsed = new URL(`${protocol}:${url}`);
+		const hostname = parsed.hostname;
+		if (hostname.includes(".") || hostname === "localhost" || ipv4Pattern.test(hostname) || ipv6Pattern.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) => {
+	let resolvedUrl;
+	resolvedUrl = url.includes("&") ? decodeHTML(url) : url;
+	resolvedUrl = resolveFeedProtocol(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 (safePathChars.test(char)) return char;
+		return `%${hex.toUpperCase()}`;
+	});
+};
+const normalizeUrl = (url, options = defaultNormalizeOptions) => {
+	try {
+		const parsed = new URL(url);
+		if (options.normalizeUnicode) {
+			parsed.hostname = parsed.hostname.normalize("NFC");
+			parsed.pathname = parsed.pathname.normalize("NFC");
+		}
+		if (options.convertToPunycode) {
+			const ascii = domainToASCII(parsed.hostname);
+			if (ascii) parsed.hostname = ascii;
+		}
+		if (options.lowercaseHostname) parsed.hostname = parsed.hostname.toLowerCase();
+		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 = "";
+		if (options.stripTextFragment && parsed.hash.startsWith("#:~:")) 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.stripQueryParams && parsed.search) for (const param of options.stripQueryParams) parsed.searchParams.delete(param);
+		if (options.sortQueryParams) parsed.searchParams.sort();
+		if (options.stripEmptyQuery && parsed.search === "?") parsed.search = "";
+		let result = parsed.href;
+		if (options.stripProtocol) result = result.replace(/^https?:\/\//, "");
+		return result;
+	} catch {
+		return url;
+	}
+};
+const nativeFetch = 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 applyPlatformHandlers = (url, platforms) => {
+	try {
+		let parsed = new URL(url);
+		for (const handler of platforms) if (handler.match(parsed)) {
+			parsed = handler.normalize(parsed);
+			break;
+		}
+		return parsed.href;
+	} catch {
+		return url;
+	}
+};
+const feedsmithParser = {
+	parse: (body) => {
+		try {
+			return parseFeed(body);
+		} catch {
+			return;
+		}
+	},
+	getSelfUrl: (parsed) => {
+		switch (parsed.format) {
+			case "atom": return parsed.feed.links?.find((link) => link.rel === "self")?.href;
+			case "rss":
+			case "rdf": return parsed.feed.atom?.links?.find((link) => link.rel === "self")?.href;
+			case "json": return parsed.feed.feed_url;
+		}
+	},
+	getSignature: (parsed) => {
+		return parsed.feed;
+	}
+};
+
+//#endregion
+export { addMissingProtocol, applyPlatformHandlers, feedsmithParser, nativeFetch, normalizeUrl, resolveFeedProtocol, resolveUrl };