feedscout 2.0.0-next.2 → 2.0.0-rc.2

package/dist/common/locales.js

@@ -1,133 +0,0 @@
-//#region src/common/locales.json
-var errors = {
-	"platformMethodRequiresUrl": "Platform method requires url to be provided in input",
-	"feedMethodRequiresContent": "Feed method requires content to be provided in input",
-	"htmlMethodRequiresContent": "HTML method requires content to be provided in input",
-	"headersMethodRequiresHeaders": "Headers method requires headers to be provided in input",
-	"guessMethodRequiresUrl": "Guess method requires url to be provided in input"
-};
-var hints = {
-	"youtube:all": "All uploads",
-	"youtube:videos": "Videos",
-	"youtube:shorts": "Shorts",
-	"youtube:live": "Live streams",
-	"youtube:popular-videos": "Popular videos",
-	"youtube:popular-shorts": "Popular shorts",
-	"youtube:popular-live": "Popular live streams",
-	"youtube:member-videos": "Member videos",
-	"youtube:member-shorts": "Member shorts",
-	"youtube:member-live": "Member live streams",
-	"youtube:playlist": "Playlist",
-	"github:activity": "Activity",
-	"github:releases": "Releases",
-	"github:commits": "Commits",
-	"github:tags": "Tags",
-	"github:wiki": "Wiki",
-	"github:discussions": "Discussions",
-	"github:branch-commits": "Branch commits",
-	"github:file-history": "File history",
-	"reddit:posts": "Posts",
-	"reddit:post-comments": "Post comments",
-	"reddit:comments": "Comments",
-	"reddit:multireddit": "Multireddit",
-	"gitlab:activity": "Activity",
-	"gitlab:releases": "Releases",
-	"gitlab:tags": "Tags",
-	"codeberg:activity": "Activity",
-	"codeberg:releases": "Releases",
-	"codeberg:tags": "Tags",
-	"codeberg:branch-commits": "Branch commits",
-	"codeberg:file-history": "File history",
-	"wordpress:category": "Category",
-	"wordpress:tag": "Tag",
-	"wordpress:author": "Author",
-	"wordpress:posts-rss2": "Posts (RSS 2.0)",
-	"wordpress:posts-rss2-alt": "Posts (RSS 2.0)",
-	"wordpress:posts-rdf": "Posts (RDF)",
-	"wordpress:posts-atom": "Posts (Atom)",
-	"wordpress:comments": "Comments",
-	"wordpress:comments-rss2": "Comments (RSS 2.0)",
-	"wordpress:comments-rdf": "Comments (RDF)",
-	"wordpress:comments-atom": "Comments (Atom)",
-	"blogspot:label": "Label",
-	"blogspot:posts-atom": "Posts (Atom)",
-	"blogspot:posts-rss": "Posts (RSS)",
-	"behance:portfolio": "Portfolio",
-	"behance:appreciated": "Appreciated",
-	"bluesky:posts": "Posts",
-	"dailymotion:videos": "Videos",
-	"dailymotion:playlist": "Playlist",
-	"deviantart:tag": "Tag",
-	"deviantart:favorites": "Favorites",
-	"deviantart:gallery": "Gallery",
-	"deviantart:deviations": "Deviations",
-	"devto:posts": "Posts",
-	"devto:tag": "Tag",
-	"github-gist:gists": "Gists",
-	"github-gist:starred": "Starred",
-	"kickstarter:updates": "Updates",
-	"kickstarter:projects": "Projects",
-	"letterboxd:diary": "Diary",
-	"lobsters:tag": "Tag",
-	"lobsters:domain": "Domain",
-	"lobsters:stories": "Stories",
-	"lobsters:top": "Top stories",
-	"lobsters:newest": "Newest",
-	"lobsters:comments": "Comments",
-	"mastodon:posts": "Posts",
-	"mastodon:tag": "Tag",
-	"medium:posts": "Posts",
-	"medium:tag": "Tag",
-	"medium:tagged": "Tagged",
-	"medium:publication": "Publication",
-	"pinterest:pins": "Pins",
-	"producthunt:topic": "Topic",
-	"producthunt:category": "Category",
-	"producthunt:products": "Products",
-	"soundcloud:tracks": "Tracks",
-	"stackexchange:tag": "Tag",
-	"stackexchange:question": "Question",
-	"stackexchange:user": "User",
-	"steam:news": "News",
-	"steam:group": "Group",
-	"substack:newsletter": "Newsletter",
-	"tumblr:posts": "Posts",
-	"tumblr:tag": "Tag",
-	"goodreads:updates": "Updates",
-	"goodreads:reviews": "Reviews",
-	"sourceforge:activity": "Activity",
-	"vimeo:videos": "Videos",
-	"vimeo:likes": "Likes",
-	"vimeo:channel": "Channel",
-	"vimeo:group": "Group",
-	"hashnode:blog": "Blog",
-	"paragraph:blog": "Blog",
-	"hatenablog:posts-rss": "Posts (RSS)",
-	"hatenablog:posts-atom": "Posts (Atom)",
-	"hatenablog:category-rss": "Category (RSS)",
-	"hatenablog:category-atom": "Category (Atom)",
-	"hatenablog:author-rss": "Author (RSS)",
-	"hatenablog:author-atom": "Author (Atom)",
-	"itchio:devlog": "Devlog",
-	"itchio:games": "Games",
-	"itchio:tag": "Tag",
-	"itchio:section": "Section",
-	"itchio:featured": "Featured",
-	"itchio:new": "New",
-	"itchio:sales": "Sales",
-	"csdn:blog": "Blog",
-	"douban:interests": "Interests",
-	"douban:reviews": "Reviews",
-	"douban:notes": "Notes",
-	"douban:subjectReviews": "Subject reviews",
-	"v2ex:index": "Index",
-	"v2ex:node": "Node",
-	"v2ex:member": "Member",
-	"v2ex:tab": "Tab",
-	"ximalaya:album": "Album",
-	"lemmy:community": "Community",
-	"lemmy:user": "User",
-	"apple-podcasts:podcast": "Podcast"
-};
-//#endregion
-export { errors, hints };

package/dist/common/uris/guess/index.js

@@ -1,8 +0,0 @@
-import { generateUrlCombinations } from "./utils.js";
-//#region src/common/uris/guess/index.ts
-const discoverUrisFromGuess = (options) => {
-	const { baseUrl, uris, additionalBaseUrls = [] } = options;
-	return generateUrlCombinations([baseUrl, ...additionalBaseUrls], uris);
-};
-//#endregion
-export { discoverUrisFromGuess };

package/dist/common/uris/guess/utils.js

@@ -1,40 +0,0 @@
-//#region src/common/uris/guess/utils.ts
-const ipAddressRegex = /^\d+\.\d+\.\d+\.\d+$/;
-const resolveUri = (uri, base, origin, pathname) => {
-	if (uri.startsWith("/")) return `${origin}${uri}`;
-	if (uri.startsWith("?")) return `${origin}${pathname}${uri}`;
-	return new URL(uri, base).href;
-};
-const generateUrlCombinations = (baseUrls, uris) => {
-	return baseUrls.flatMap((base) => {
-		const parsed = new URL(base);
-		const origin = parsed.origin;
-		const pathname = parsed.pathname;
-		return uris.map((uri) => {
-			if (typeof uri === "string") return resolveUri(uri, base, origin, pathname);
-			return uri.map((alternative) => resolveUri(alternative, base, origin, pathname));
-		});
-	});
-};
-const getWwwCounterpart = (baseUrl) => {
-	const url = new URL(baseUrl);
-	const port = url.port ? `:${url.port}` : "";
-	if (url.hostname.startsWith("www.")) return `${url.protocol}//${url.hostname.slice(4)}${port}`;
-	return `${url.protocol}//www.${url.hostname}${port}`;
-};
-const getSubdomainVariants = (baseUrl, prefixes) => {
-	const url = new URL(baseUrl);
-	const hostname = url.hostname;
-	const isIpAddress = ipAddressRegex.test(hostname);
-	if (hostname === "localhost" || isIpAddress) return [];
-	const hostnameParts = hostname.split(".");
-	if (hostnameParts.length < 2) return [];
-	const rootDomain = hostnameParts.slice(-2).join(".");
-	const protocol = url.protocol;
-	const port = url.port ? `:${url.port}` : "";
-	return prefixes.map((prefix) => {
-		return `${protocol}//${prefix === "" ? rootDomain : `${prefix}.${rootDomain}`}${port}`;
-	});
-};
-//#endregion
-export { generateUrlCombinations, getSubdomainVariants, getWwwCounterpart };

package/dist/common/uris/headers/index.js

@@ -1,26 +0,0 @@
-import { matchesAnyOfLinkSelectors } from "../../utils.js";
-//#region src/common/uris/headers/index.ts
-const linkSplitRegex = /,(?=\s*<)/;
-const urlRegex = /<([^<>]+)>/;
-const relRegex = /rel\s*=\s*["']?([^"';,]+)["']?/i;
-const typeRegex = /type\s*=\s*["']?([^"';,]+)["']?/i;
-const discoverUrisFromHeaders = (headers, options) => {
-	const uris = /* @__PURE__ */ new Set();
-	const linkHeader = headers.get("link");
-	if (!linkHeader) return [];
-	const links = linkHeader.split(linkSplitRegex);
-	for (const link of links) {
-		const urlMatch = link.match(urlRegex);
-		const relMatch = link.match(relRegex);
-		const typeMatch = link.match(typeRegex);
-		if (!urlMatch) continue;
-		const url = urlMatch[1];
-		const rel = relMatch?.[1]?.toLowerCase();
-		const type = typeMatch?.[1];
-		if (!rel) continue;
-		if (matchesAnyOfLinkSelectors(rel, type, options.linkSelectors)) uris.add(url);
-	}
-	return [...uris];
-};
-//#endregion
-export { discoverUrisFromHeaders };

package/dist/common/uris/html/types.d.ts

@@ -1,12 +0,0 @@
-import { LinkSelector } from "../../types.js";
-
-//#region src/common/uris/html/types.d.ts
-type HtmlMethodOptions = {
-  baseUrl?: string;
-  linkSelectors: Array<LinkSelector>;
-  anchorUris: Array<string>;
-  anchorIgnoredUris: Array<string>;
-  anchorLabels: Array<string>;
-};
-//#endregion
-export { HtmlMethodOptions };

package/dist/common/utils.d.ts

@@ -1,10 +0,0 @@
-//#region src/common/utils.d.ts
-declare const isSubdomainOf: (url: string, domains: string | Array<string>) => boolean;
-declare const isHostOf: (url: string, hosts: string | Array<string>) => boolean;
-declare const includesAnyOf: (value: string, patterns: Array<string>, parser?: (value: string) => string) => boolean;
-declare const isAnyOf: (value: string, patterns: Array<string>, parser?: (value: string) => string) => boolean;
-declare const anyWordMatchesAnyOf: (value: string, patterns: Array<string>) => boolean;
-declare const endsWithAnyOf: (value: string, patterns: Array<string>) => boolean;
-declare const omitEmpty: <T>(array: Array<T | null | undefined>) => Array<T>;
-//#endregion
-export { anyWordMatchesAnyOf, endsWithAnyOf, includesAnyOf, isAnyOf, isHostOf, isSubdomainOf, omitEmpty };

package/dist/common/utils.js

@@ -1,79 +0,0 @@
-import { hints } from "./locales.js";
-//#region src/common/utils.ts
-const whitespaceRegex = /\s+/;
-const composeHint = (key) => ({
-	key,
-	label: hints[key]
-});
-const normalizeMimeType = (type) => {
-	return type.split(";")[0].trim().toLowerCase();
-};
-const isSubdomainOf = (url, domains) => {
-	try {
-		const hostname = new URL(url).hostname.toLowerCase();
-		return (Array.isArray(domains) ? domains : [domains]).some((domain) => hostname.endsWith(`.${domain}`));
-	} catch {}
-	return false;
-};
-const isHostOf = (url, hosts) => {
-	try {
-		const list = Array.isArray(hosts) ? hosts : [hosts];
-		return isAnyOf(new URL(url).hostname, list);
-	} catch {}
-	return false;
-};
-const includesAnyOf = (value, patterns, parser) => {
-	const parsedValue = parser ? parser(value) : value?.toLowerCase();
-	return patterns.some((pattern) => pattern && parsedValue?.includes(pattern.toLowerCase()));
-};
-const isAnyOf = (value, patterns, parser) => {
-	const parsedValue = parser ? parser(value) : value?.toLowerCase()?.trim();
-	return patterns.some((pattern) => parsedValue === pattern.toLowerCase().trim());
-};
-const anyWordMatchesAnyOf = (value, patterns) => {
-	return value.toLowerCase().split(whitespaceRegex).some((word) => isAnyOf(word, patterns));
-};
-const endsWithAnyOf = (value, patterns) => {
-	const lowerValue = value.toLowerCase();
-	return patterns.some((pattern) => pattern && lowerValue.endsWith(pattern.toLowerCase()));
-};
-const isOfAllowedMimeType = (type, allowedTypes) => {
-	if (allowedTypes.length === 0) return true;
-	if (!type) return false;
-	return isAnyOf(type, allowedTypes, normalizeMimeType);
-};
-const hasMetaContent = (content, name, value) => {
-	const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	return new RegExp(`<meta(?=[^>]*(?:name|property)=["']${escapedName}["'])(?=[^>]*content=["']${escapedValue})`, "i").test(content);
-};
-const omitEmpty = (array) => {
-	const result = [];
-	for (const item of array) if (item != null && item !== "") result.push(item);
-	return result;
-};
-const matchesAnyOfLinkSelectors = (rel, type, selectors) => {
-	return selectors.some((selector) => {
-		if (!anyWordMatchesAnyOf(rel, [selector.rel])) return false;
-		if (!selector.types) return true;
-		return isOfAllowedMimeType(type, selector.types);
-	});
-};
-const processConcurrently = async (items, processFn, options) => {
-	if (options.concurrency < 1) return;
-	const active = /* @__PURE__ */ new Set();
-	let index = 0;
-	while (index < items.length || active.size > 0) {
-		if (options.shouldStop?.()) break;
-		while (active.size < options.concurrency && index < items.length) {
-			const item = items[index++];
-			const promise = processFn(item).catch(() => {}).finally(() => {
-				active.delete(promise);
-			});
-			active.add(promise);
-		}
-		if (active.size > 0) await Promise.race(active);
-	}
-};
-//#endregion
-export { anyWordMatchesAnyOf, composeHint, endsWithAnyOf, hasMetaContent, includesAnyOf, isAnyOf, isHostOf, isSubdomainOf, matchesAnyOfLinkSelectors, omitEmpty, processConcurrently };

package/dist/feeds/defaults.js

@@ -1,168 +0,0 @@
-import { codebergHandler } from "./platform/handlers/codeberg.js";
-import { deviantartHandler } from "./platform/handlers/deviantart.js";
-import { devtoHandler } from "./platform/handlers/devto.js";
-import { githubHandler } from "./platform/handlers/github.js";
-import { githubGistHandler } from "./platform/handlers/githubGist.js";
-import { gitlabHandler } from "./platform/handlers/gitlab.js";
-import { lobstersHandler } from "./platform/handlers/lobsters.js";
-import { redditHandler } from "./platform/handlers/reddit.js";
-import { sourceforgeHandler } from "./platform/handlers/sourceforge.js";
-import { tumblrHandler } from "./platform/handlers/tumblr.js";
-import { applePodcastsHandler } from "./platform/handlers/applePodcasts.js";
-import { behanceHandler } from "./platform/handlers/behance.js";
-import { blogspotHandler } from "./platform/handlers/blogspot.js";
-import { blueskyHandler } from "./platform/handlers/bluesky.js";
-import { csdnHandler } from "./platform/handlers/csdn.js";
-import { dailymotionHandler } from "./platform/handlers/dailymotion.js";
-import { doubanHandler } from "./platform/handlers/douban.js";
-import { goodreadsHandler } from "./platform/handlers/goodreads.js";
-import { hashnodeHandler } from "./platform/handlers/hashnode.js";
-import { hatenablogHandler } from "./platform/handlers/hatenablog.js";
-import { itchioHandler } from "./platform/handlers/itchio.js";
-import { kickstarterHandler } from "./platform/handlers/kickstarter.js";
-import { lemmyHandler } from "./platform/handlers/lemmy.js";
-import { letterboxdHandler } from "./platform/handlers/letterboxd.js";
-import { mastodonHandler } from "./platform/handlers/mastodon.js";
-import { mediumHandler } from "./platform/handlers/medium.js";
-import { paragraphHandler } from "./platform/handlers/paragraph.js";
-import { pinterestHandler } from "./platform/handlers/pinterest.js";
-import { producthuntHandler } from "./platform/handlers/producthunt.js";
-import { soundcloudHandler } from "./platform/handlers/soundcloud.js";
-import { stackExchangeHandler } from "./platform/handlers/stackExchange.js";
-import { steamHandler } from "./platform/handlers/steam.js";
-import { substackHandler } from "./platform/handlers/substack.js";
-import { v2exHandler } from "./platform/handlers/v2ex.js";
-import { vimeoHandler } from "./platform/handlers/vimeo.js";
-import { wordpressHandler } from "./platform/handlers/wordpress.js";
-import { wpengineHandler } from "./platform/handlers/wpengine.js";
-import { ximalayaHandler } from "./platform/handlers/ximalaya.js";
-import { youtubeHandler } from "./platform/handlers/youtube.js";
-//#region src/feeds/defaults.ts
-const mimeTypes = [
-	"application/rss+xml",
-	"text/rss+xml",
-	"application/x-rss+xml",
-	"application/rss",
-	"application/atom+xml",
-	"text/atom+xml",
-	"application/feed+json",
-	"application/json",
-	"application/rdf+xml",
-	"text/rdf+xml",
-	"application/atom",
-	"application/xml",
-	"text/xml"
-];
-const urisMinimal = [
-	"/feed",
-	"/rss",
-	"/atom.xml",
-	"/feed.xml",
-	"/rss.xml",
-	"/index.xml"
-];
-const urisBalanced = [
-	...urisMinimal,
-	"/feed/",
-	"/index.atom",
-	"/index.rss",
-	"/feed.json"
-];
-const urisComprehensive = [
-	...urisBalanced,
-	"/atom",
-	"/rss/",
-	"/rss2.xml",
-	"/feed.rss",
-	"/feed.atom",
-	"/feed.rss.xml",
-	"/feed.atom.xml",
-	["/feed/atom/", "?feed=atom"],
-	["/feed/rss/", "?feed=rss"],
-	["/feed/rss2/", "?feed=rss2"],
-	["/feed/rdf", "?feed=rdf"],
-	["/feed/rdf/", "?feed=rdf"],
-	"/index.rss.xml",
-	"/index.atom.xml",
-	"?format=rss",
-	"?format=atom",
-	"?rss=1",
-	"?atom=1",
-	"/.rss",
-	"/f.json",
-	"/f.rss",
-	"/json",
-	"/.feed",
-	["/comments/feed", "?feed=comments-rss2"],
-	["/comments/feed/rss2/", "?feed=comments-rss2"],
-	["/comments/feed/rdf/", "?feed=comments-rdf"],
-	["/comments/feed/atom/", "?feed=comments-atom"],
-	"/feeds/posts/default",
-	"/feeds/posts/default?alt=rss",
-	"/feeds/comments/default"
-];
-const ignoredUris = ["wp-json/oembed/", "wp-json/wp/"];
-const anchorLabels = [
-	"rss",
-	"feed",
-	"atom",
-	"subscribe",
-	"syndicate",
-	"syndication",
-	"json feed"
-];
-const linkSelectors = [{
-	rel: "alternate",
-	types: mimeTypes
-}, { rel: "feed" }];
-const defaultHtmlOptions = {
-	linkSelectors,
-	anchorUris: urisComprehensive.flat(),
-	anchorIgnoredUris: ignoredUris,
-	anchorLabels
-};
-const defaultHeadersOptions = { linkSelectors };
-const defaultGuessOptions = { uris: urisBalanced };
-const defaultPlatformOptions = { handlers: [
-	applePodcastsHandler,
-	behanceHandler,
-	blogspotHandler,
-	blueskyHandler,
-	csdnHandler,
-	codebergHandler,
-	doubanHandler,
-	deviantartHandler,
-	dailymotionHandler,
-	devtoHandler,
-	goodreadsHandler,
-	githubHandler,
-	hashnodeHandler,
-	hatenablogHandler,
-	githubGistHandler,
-	gitlabHandler,
-	itchioHandler,
-	kickstarterHandler,
-	lemmyHandler,
-	letterboxdHandler,
-	lobstersHandler,
-	mastodonHandler,
-	mediumHandler,
-	paragraphHandler,
-	pinterestHandler,
-	producthuntHandler,
-	redditHandler,
-	soundcloudHandler,
-	sourceforgeHandler,
-	stackExchangeHandler,
-	steamHandler,
-	substackHandler,
-	tumblrHandler,
-	v2exHandler,
-	vimeoHandler,
-	wordpressHandler,
-	wpengineHandler,
-	ximalayaHandler,
-	youtubeHandler
-] };
-//#endregion
-export { anchorLabels, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal };

package/dist/feeds/platform/handlers/blogspot.js

@@ -1,36 +0,0 @@
-import { composeHint } from "../../../common/utils.js";
-//#region src/feeds/platform/handlers/blogspot.ts
-const blogspotDomainRegex = /^.+\.blogspot\.(?:com|co\.[a-z]{2}|com\.[a-z]{2}|[a-z]{2,3})$/;
-const labelRegex = /^\/search\/label\/([^/]+)/;
-const blogspotHandler = {
-	match: (url) => {
-		try {
-			const hostname = new URL(url).hostname.toLowerCase();
-			return blogspotDomainRegex.test(hostname);
-		} catch {}
-		return false;
-	},
-	resolve: (url) => {
-		const { origin, pathname } = new URL(url);
-		const uris = [];
-		const labelMatch = pathname.match(labelRegex);
-		if (labelMatch?.[1]) {
-			const label = labelMatch[1];
-			uris.push({
-				uri: `${origin}/feeds/posts/default/-/${label}`,
-				hint: composeHint("blogspot:label")
-			});
-		}
-		uris.push({
-			uri: `${origin}/feeds/posts/default`,
-			hint: composeHint("blogspot:posts-atom")
-		});
-		uris.push({
-			uri: `${origin}/feeds/posts/default?alt=rss`,
-			hint: composeHint("blogspot:posts-rss")
-		});
-		return uris;
-	}
-};
-//#endregion
-export { blogspotHandler };

package/dist/feeds/platform/handlers/lemmy.js

@@ -1,46 +0,0 @@
-import { composeHint, hasMetaContent } from "../../../common/utils.js";
-//#region src/feeds/platform/handlers/lemmy.ts
-const lemmyPoweredByRegex = /lemmy/i;
-const isCommunityPath = (pathname) => {
-	const segments = pathname.split("/").filter(Boolean);
-	return segments.length >= 2 && segments[0] === "c";
-};
-const isUserPath = (pathname) => {
-	const segments = pathname.split("/").filter(Boolean);
-	return segments.length >= 2 && segments[0] === "u";
-};
-const isLemmyHtml = (content) => {
-	return hasMetaContent(content, "generator", "Lemmy");
-};
-const isLemmyHeaders = (headers) => {
-	const poweredBy = headers.get("x-powered-by") ?? "";
-	return lemmyPoweredByRegex.test(poweredBy);
-};
-const lemmyHandler = {
-	match: (url, content, headers) => {
-		try {
-			const { pathname } = new URL(url);
-			if (!isCommunityPath(pathname) && !isUserPath(pathname)) return false;
-			if (content && isLemmyHtml(content)) return true;
-			if (headers && isLemmyHeaders(headers)) return true;
-		} catch {}
-		return false;
-	},
-	resolve: (url) => {
-		try {
-			const { origin, pathname } = new URL(url);
-			const segments = pathname.split("/").filter(Boolean);
-			if (isCommunityPath(pathname) && segments[1]) return [{
-				uri: `${origin}/feeds/c/${segments[1]}.xml`,
-				hint: composeHint("lemmy:community")
-			}];
-			if (isUserPath(pathname) && segments[1]) return [{
-				uri: `${origin}/feeds/u/${segments[1]}.xml`,
-				hint: composeHint("lemmy:user")
-			}];
-		} catch {}
-		return [];
-	}
-};
-//#endregion
-export { lemmyHandler };

package/dist/feeds/platform/handlers/reddit.js

@@ -1,74 +0,0 @@
-import { composeHint, isAnyOf, isHostOf } from "../../../common/utils.js";
-//#region src/feeds/platform/handlers/reddit.ts
-const commentsRegex = /^\/r\/([^/]+)\/comments\/([^/]+)/;
-const subredditRegex = /^\/r\/([^/]+)(?:\/([^/]+))?/;
-const multiredditRegex = /^\/user\/([^/]+)\/m\/([^/]+)/;
-const userRegex = /^\/(u|user)\/([^/]+)/;
-const domainRegex = /^\/domain\/([^/]+)/;
-const hosts = [
-	"reddit.com",
-	"www.reddit.com",
-	"old.reddit.com",
-	"new.reddit.com"
-];
-const sortOptions = [
-	"hot",
-	"new",
-	"rising",
-	"controversial",
-	"top"
-];
-const redditHandler = {
-	match: (url) => {
-		return isHostOf(url, hosts);
-	},
-	resolve: (url) => {
-		const { pathname } = new URL(url);
-		if (pathname.split("/").filter(Boolean).length === 0) return [{
-			uri: "https://www.reddit.com/.rss",
-			hint: composeHint("reddit:posts")
-		}];
-		const commentsMatch = pathname.match(commentsRegex);
-		if (commentsMatch?.[1] && commentsMatch?.[2]) return [{
-			uri: `https://www.reddit.com/r/${commentsMatch[1]}/comments/${commentsMatch[2]}/.rss`,
-			hint: composeHint("reddit:post-comments")
-		}];
-		const subredditMatch = pathname.match(subredditRegex);
-		if (subredditMatch?.[1]) {
-			const subreddit = subredditMatch[1];
-			const sort = subredditMatch[2];
-			const uris = [];
-			if (sort && isAnyOf(sort, sortOptions)) uris.push({
-				uri: `https://www.reddit.com/r/${subreddit}/${sort}/.rss`,
-				hint: composeHint("reddit:posts")
-			});
-			else uris.push({
-				uri: `https://www.reddit.com/r/${subreddit}/.rss`,
-				hint: composeHint("reddit:posts")
-			});
-			uris.push({
-				uri: `https://www.reddit.com/r/${subreddit}/comments/.rss`,
-				hint: composeHint("reddit:comments")
-			});
-			return uris;
-		}
-		const multiredditMatch = pathname.match(multiredditRegex);
-		if (multiredditMatch?.[1] && multiredditMatch?.[2]) return [{
-			uri: `https://www.reddit.com/user/${multiredditMatch[1]}/m/${multiredditMatch[2]}/.rss`,
-			hint: composeHint("reddit:multireddit")
-		}];
-		const userMatch = pathname.match(userRegex);
-		if (userMatch?.[2]) return [{
-			uri: `https://www.reddit.com/user/${userMatch[2]}/.rss`,
-			hint: composeHint("reddit:posts")
-		}];
-		const domainMatch = pathname.match(domainRegex);
-		if (domainMatch?.[1]) return [{
-			uri: `https://www.reddit.com/domain/${domainMatch[1]}/.rss`,
-			hint: composeHint("reddit:posts")
-		}];
-		return [];
-	}
-};
-//#endregion
-export { hosts, redditHandler };

package/dist/feeds/platform/handlers/sourceforge.js

@@ -1,19 +0,0 @@
-import { composeHint, isHostOf } from "../../../common/utils.js";
-//#region src/feeds/platform/handlers/sourceforge.ts
-const hosts = ["sourceforge.net", "www.sourceforge.net"];
-const sourceforgeHandler = {
-	match: (url) => {
-		return isHostOf(url, hosts);
-	},
-	resolve: (url) => {
-		const { origin, pathname } = new URL(url);
-		const pathSegments = pathname.split("/").filter(Boolean);
-		if (pathSegments[0] === "projects" && pathSegments[1]) return [{
-			uri: `${origin}/projects/${pathSegments[1]}/rss`,
-			hint: composeHint("sourceforge:activity")
-		}];
-		return [];
-	}
-};
-//#endregion
-export { hosts, sourceforgeHandler };