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

package/dist/{feeds → src/feeds}/platform/handlers/pinterest.js

@@ -1,4 +1,6 @@
-import { composeHint, isAnyOf, isHostOf } from "../../../common/utils.js";
+import { isAnyOf } from "../../../../node_modules/trousse/dist/matching.js";
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/pinterest.ts
 const hosts = [
 	"pinterest.com",
@@ -34,6 +36,19 @@ const pinterestHandler = {
 		if (pathSegments.length === 0) return [];
 		const username = pathSegments[0];
 		if (isAnyOf(username, excludedPaths)) return [];
+		const reservedBoardSlugs = /* @__PURE__ */ new Set([
+			"pins",
+			"boards",
+			"_saved",
+			"_created",
+			"followers",
+			"following"
+		]);
+		const board = pathSegments[1];
+		if (board && !reservedBoardSlugs.has(board)) return [{
+			uri: `https://www.pinterest.com/${username}/${board}.rss`,
+			hint: composeHint("pinterest:board")
+		}];
 		return [{
 			uri: `https://www.pinterest.com/${username}/feed.rss`,
 			hint: composeHint("pinterest:pins")

package/dist/src/feeds/platform/handlers/pixelfed.js

@@ -0,0 +1,46 @@
+import { composeHint, hasMetaContent } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/pixelfed.ts
+const profileRegex = /^\/(?:users\/)?([a-zA-Z0-9_]+)\/?$/;
+const excludedPaths = [
+	"admin",
+	"api",
+	"discover",
+	"i",
+	"login",
+	"notifications",
+	"p",
+	"register",
+	"settings",
+	"site",
+	"storage",
+	"timeline",
+	"users"
+];
+const isPixelfedHtml = (content) => {
+	return hasMetaContent(content, "generator", "pixelfed");
+};
+const pixelfedHandler = {
+	match: (url, content) => {
+		try {
+			if (!content || !isPixelfedHtml(content)) return false;
+			const { pathname } = new URL(url);
+			const match = pathname.match(profileRegex);
+			return Boolean(match?.[1] && !excludedPaths.includes(match[1]));
+		} catch {}
+		return false;
+	},
+	resolve: (url) => {
+		try {
+			const { origin, pathname } = new URL(url);
+			const match = pathname.match(profileRegex);
+			if (!match?.[1] || excludedPaths.includes(match[1])) return [];
+			return [{
+				uri: `${origin}/users/${match[1]}.atom`,
+				hint: composeHint("pixelfed:posts")
+			}];
+		} catch {}
+		return [];
+	}
+};
+//#endregion
+export { pixelfedHandler };

package/dist/src/feeds/platform/handlers/pleroma.js

@@ -0,0 +1,34 @@
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/pleroma.ts
+const profileRegex = /^\/users\/([^/]+)/;
+const pleromaApiRegex = /\/api\/pleroma\//i;
+const isPleromaHtml = (content) => {
+	return pleromaApiRegex.test(content);
+};
+const pleromaHandler = {
+	match: (url, content) => {
+		try {
+			if (!content || !isPleromaHtml(content)) return false;
+			const { pathname } = new URL(url);
+			return profileRegex.test(pathname);
+		} catch {}
+		return false;
+	},
+	resolve: (url) => {
+		try {
+			const { origin, pathname } = new URL(url);
+			const match = pathname.match(profileRegex);
+			if (!match?.[1]) return [];
+			return [{
+				uri: `${origin}/users/${match[1]}/feed.atom`,
+				hint: composeHint("pleroma:posts")
+			}, {
+				uri: `${origin}/users/${match[1]}/feed.rss`,
+				hint: composeHint("pleroma:posts-rss")
+			}];
+		} catch {}
+		return [];
+	}
+};
+//#endregion
+export { pleromaHandler };

package/dist/src/feeds/platform/handlers/podbean.js

@@ -0,0 +1,30 @@
+import { isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/podbean.ts
+const domainSuffixRegex = /\.podbean\.com$/i;
+const reservedSlugs = /* @__PURE__ */ new Set([
+	"www",
+	"feed",
+	"pbcdn1",
+	"sponsorship",
+	"podads",
+	"help",
+	"blog",
+	"support"
+]);
+const podbeanHandler = {
+	match: (url) => {
+		if (!isSubdomainOf(url, "podbean.com")) return false;
+		const slug = new URL(url).hostname.toLowerCase().replace(domainSuffixRegex, "");
+		return !reservedSlugs.has(slug);
+	},
+	resolve: (url) => {
+		const { hostname } = new URL(url);
+		return [{
+			uri: `https://feed.podbean.com/${hostname.replace(domainSuffixRegex, "")}/feed.xml`,
+			hint: composeHint("podbean:podcast")
+		}];
+	}
+};
+//#endregion
+export { podbeanHandler };

package/dist/src/feeds/platform/handlers/podigee.js

@@ -0,0 +1,30 @@
+import { isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/podigee.ts
+const domainSuffixRegex = /\.podigee\.io$/i;
+const reservedSlugs = /* @__PURE__ */ new Set([
+	"www",
+	"app",
+	"help",
+	"hilfe",
+	"blog",
+	"status",
+	"player",
+	"cdn"
+]);
+const podigeeHandler = {
+	match: (url) => {
+		if (!isSubdomainOf(url, "podigee.io")) return false;
+		const slug = new URL(url).hostname.toLowerCase().replace(domainSuffixRegex, "");
+		return !reservedSlugs.has(slug);
+	},
+	resolve: (url) => {
+		const { origin } = new URL(url);
+		return [{
+			uri: `${origin}/feed/mp3`,
+			hint: composeHint("podigee:podcast")
+		}];
+	}
+};
+//#endregion
+export { podigeeHandler };

package/dist/src/feeds/platform/handlers/posthaven.js

@@ -0,0 +1,25 @@
+import { isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/posthaven.ts
+const tagRegex = /^\/tag\/([^/]+)/;
+const posthavenHandler = {
+	match: (url) => {
+		return isSubdomainOf(url, "posthaven.com");
+	},
+	resolve: (url) => {
+		const { origin, pathname } = new URL(url);
+		const uris = [];
+		const tagMatch = pathname.match(tagRegex);
+		if (tagMatch?.[1]) uris.push({
+			uri: `${origin}/tag/${tagMatch[1]}.atom`,
+			hint: composeHint("posthaven:tag")
+		});
+		uris.push({
+			uri: `${origin}/posts.atom`,
+			hint: composeHint("posthaven:posts")
+		});
+		return uris;
+	}
+};
+//#endregion
+export { posthavenHandler };

package/dist/{feeds → src/feeds}/platform/handlers/producthunt.js

@@ -1,4 +1,5 @@
-import { composeHint, isHostOf } from "../../../common/utils.js";
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/producthunt.ts
 const hosts = ["producthunt.com", "www.producthunt.com"];
 const topicRegex = /^\/topics\/([a-zA-Z0-9_-]+)/;

package/dist/src/feeds/platform/handlers/prose.js

@@ -0,0 +1,27 @@
+import { isHostOf, isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/prose.ts
+const apexHosts = ["prose.sh", "www.prose.sh"];
+const proseHandler = {
+	match: (url) => {
+		return isSubdomainOf(url, "prose.sh") || isHostOf(url, apexHosts);
+	},
+	resolve: (url) => {
+		const { origin, searchParams } = new URL(url);
+		if (isHostOf(url, apexHosts)) return [{
+			uri: "https://prose.sh/rss",
+			hint: composeHint("prose:discovery")
+		}];
+		const tag = searchParams.get("tag");
+		if (tag) return [{
+			uri: `${origin}/rss?tag=${encodeURIComponent(tag)}`,
+			hint: composeHint("prose:tag")
+		}];
+		return [{
+			uri: `${origin}/rss`,
+			hint: composeHint("prose:blog")
+		}];
+	}
+};
+//#endregion
+export { proseHandler };

package/dist/src/feeds/platform/handlers/qiita.js

@@ -0,0 +1,60 @@
+import { isAnyOf } from "../../../../node_modules/trousse/dist/matching.js";
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/qiita.ts
+const hosts = ["qiita.com", "www.qiita.com"];
+const excludedPaths = [
+	"about",
+	"api",
+	"login",
+	"official-columns",
+	"organizations",
+	"popular-items",
+	"privacy",
+	"search",
+	"settings",
+	"signup",
+	"tags",
+	"terms",
+	"trend"
+];
+const tagRegex = /^\/tags\/([^/]+)/;
+const organizationRegex = /^\/organizations\/([^/]+)/;
+const popularItemsRegex = /^\/popular-items(\/|$)/;
+const officialColumnsRegex = /^\/official-columns(\/|$)/;
+const qiitaHandler = {
+	match: (url) => {
+		return isHostOf(url, hosts);
+	},
+	resolve: (url) => {
+		const { pathname } = new URL(url);
+		const tagMatch = pathname.match(tagRegex);
+		if (tagMatch?.[1]) return [{
+			uri: `https://qiita.com/tags/${tagMatch[1]}/feed.atom`,
+			hint: composeHint("qiita:tag")
+		}];
+		const orgMatch = pathname.match(organizationRegex);
+		if (orgMatch?.[1]) return [{
+			uri: `https://qiita.com/organizations/${orgMatch[1]}/activities.atom`,
+			hint: composeHint("qiita:organization")
+		}];
+		if (popularItemsRegex.test(pathname)) return [{
+			uri: "https://qiita.com/popular-items/feed.atom",
+			hint: composeHint("qiita:popular")
+		}];
+		if (officialColumnsRegex.test(pathname)) return [{
+			uri: "https://qiita.com/official-columns/feed/",
+			hint: composeHint("qiita:zine")
+		}];
+		const pathSegments = pathname.split("/").filter(Boolean);
+		if (pathSegments.length === 0) return [];
+		const username = pathSegments[0];
+		if (isAnyOf(username, excludedPaths)) return [];
+		return [{
+			uri: `https://qiita.com/${username}/feed.atom`,
+			hint: composeHint("qiita:posts")
+		}];
+	}
+};
+//#endregion
+export { qiitaHandler };

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

@@ -0,0 +1,150 @@
+import { isAnyOf } from "../../../../node_modules/trousse/dist/matching.js";
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/reddit.ts
+const commentsRegex = /^\/r\/([^/]+)\/comments\/([^/]+)/;
+const subredditWikiRegex = /^\/r\/([^/]+)\/wiki/;
+const subredditSearchRegex = /^\/r\/([^/]+)\/search/;
+const subredditRegex = /^\/r\/([^/]+)(?:\/([^/]+))?/;
+const multiredditRegex = /^\/user\/([^/]+)\/m\/([^/]+)/;
+const userRegex = /^\/(?:u|user)\/([^/]+)(?:\/(submitted|comments))?/;
+const domainRegex = /^\/domain\/([^/]+)/;
+const subredditsRegex = /^\/(?:subreddits|reddits)(?:\/(new|popular))?/;
+const hosts = [
+	"reddit.com",
+	"www.reddit.com",
+	"old.reddit.com",
+	"new.reddit.com"
+];
+const sortOptions = [
+	"hot",
+	"new",
+	"rising",
+	"controversial",
+	"top",
+	"best"
+];
+const timeOptions = /* @__PURE__ */ new Set([
+	"hour",
+	"day",
+	"week",
+	"month",
+	"year",
+	"all"
+]);
+const timeFilteredSorts = /* @__PURE__ */ new Set(["top", "controversial"]);
+const getTimeframeSuffix = (sort, searchParams) => {
+	if (!timeFilteredSorts.has(sort)) return "";
+	const timeframe = searchParams.get("t");
+	if (timeframe && timeOptions.has(timeframe)) return `?t=${timeframe}`;
+	return "";
+};
+const redditHandler = {
+	match: (url) => {
+		return isHostOf(url, hosts);
+	},
+	resolve: (url) => {
+		const { pathname, searchParams } = new URL(url);
+		const pathSegments = pathname.split("/").filter(Boolean);
+		if (pathSegments.length === 0) return [{
+			uri: "https://www.reddit.com/.rss",
+			hint: composeHint("reddit:posts")
+		}];
+		if (pathSegments.length === 1 && isAnyOf(pathSegments[0], sortOptions)) {
+			const sort = pathSegments[0];
+			return [{
+				uri: `https://www.reddit.com/${sort}/.rss${getTimeframeSuffix(sort, searchParams)}`,
+				hint: composeHint("reddit:posts")
+			}];
+		}
+		if (pathSegments[0] === "search") {
+			const query = searchParams.get("q");
+			if (query) return [{
+				uri: `https://www.reddit.com/search.rss?q=${encodeURIComponent(query)}`,
+				hint: composeHint("reddit:search")
+			}];
+		}
+		const subredditsMatch = pathname.match(subredditsRegex);
+		if (subredditsMatch) {
+			const sort = subredditsMatch[1];
+			return [{
+				uri: `https://www.reddit.com/${sort ? `subreddits/${sort}` : "subreddits"}/.rss`,
+				hint: composeHint("reddit:subreddits")
+			}];
+		}
+		const subredditSearchMatch = pathname.match(subredditSearchRegex);
+		if (subredditSearchMatch?.[1]) {
+			const subreddit = subredditSearchMatch[1];
+			const query = searchParams.get("q");
+			if (query) return [{
+				uri: `https://www.reddit.com/r/${subreddit}/search.rss?q=${encodeURIComponent(query)}&restrict_sr=on`,
+				hint: composeHint("reddit:search")
+			}];
+		}
+		const subredditWikiMatch = pathname.match(subredditWikiRegex);
+		if (subredditWikiMatch?.[1]) return [{
+			uri: `https://www.reddit.com/r/${subredditWikiMatch[1]}/wiki/index.rss`,
+			hint: composeHint("reddit:wiki")
+		}];
+		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${getTimeframeSuffix(sort, searchParams)}`,
+				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?.[1]) {
+			const username = userMatch[1];
+			const filter = userMatch[2];
+			if (filter === "submitted") return [{
+				uri: `https://www.reddit.com/user/${username}/submitted/.rss`,
+				hint: composeHint("reddit:user-submitted")
+			}, {
+				uri: `https://www.reddit.com/user/${username}/.rss`,
+				hint: composeHint("reddit:posts")
+			}];
+			if (filter === "comments") return [{
+				uri: `https://www.reddit.com/user/${username}/comments/.rss`,
+				hint: composeHint("reddit:user-comments")
+			}, {
+				uri: `https://www.reddit.com/user/${username}/.rss`,
+				hint: composeHint("reddit:posts")
+			}];
+			return [{
+				uri: `https://www.reddit.com/user/${username}/.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/src/feeds/platform/handlers/rssCom.js

@@ -0,0 +1,21 @@
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/rssCom.ts
+const hosts = ["rss.com", "www.rss.com"];
+const podcastRegex = /^\/(?:[a-z]{2}\/)?podcasts\/([^/]+)/;
+const rssComHandler = {
+	match: (url) => {
+		return isHostOf(url, hosts);
+	},
+	resolve: (url) => {
+		const { pathname } = new URL(url);
+		const match = pathname.match(podcastRegex);
+		if (!match?.[1]) return [];
+		return [{
+			uri: `https://media.rss.com/${match[1]}/feed.xml`,
+			hint: composeHint("rss-com:podcast")
+		}];
+	}
+};
+//#endregion
+export { rssComHandler };

package/dist/src/feeds/platform/handlers/seesaa.js

@@ -0,0 +1,23 @@
+import { isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/seesaa.ts
+const seesaaHandler = {
+	match: (url) => {
+		return isSubdomainOf(url, "seesaa.net");
+	},
+	resolve: (url) => {
+		const { origin } = new URL(url);
+		const uris = [];
+		uris.push({
+			uri: `${origin}/index20.rdf`,
+			hint: composeHint("seesaa:posts-rss2")
+		});
+		uris.push({
+			uri: `${origin}/index.rdf`,
+			hint: composeHint("seesaa:posts-rdf")
+		});
+		return uris;
+	}
+};
+//#endregion
+export { seesaaHandler };

package/dist/{feeds → src/feeds}/platform/handlers/soundcloud.js

@@ -1,4 +1,6 @@
-import { composeHint, isAnyOf, isHostOf } from "../../../common/utils.js";
+import { isAnyOf } from "../../../../node_modules/trousse/dist/matching.js";
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/soundcloud.ts
 const userIdRegex = /soundcloud:\/\/users:(\d+)/;
 const hosts = [

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

@@ -0,0 +1,53 @@
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } 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[0] === "p") && pathSegments[1]) {
+			const project = pathSegments[1];
+			return [
+				{
+					uri: `${origin}/p/${project}/activity/feed`,
+					hint: composeHint("sourceforge:activity")
+				},
+				{
+					uri: `${origin}/p/${project}/feed`,
+					hint: composeHint("sourceforge:project-feed")
+				},
+				{
+					uri: `${origin}/projects/${project}/rss`,
+					hint: composeHint("sourceforge:files")
+				},
+				{
+					uri: `${origin}/p/${project}/news/feed.rss`,
+					hint: composeHint("sourceforge:news-rss")
+				},
+				{
+					uri: `${origin}/p/${project}/news/feed.atom`,
+					hint: composeHint("sourceforge:news-atom")
+				},
+				{
+					uri: `${origin}/p/${project}/discussion/feed`,
+					hint: composeHint("sourceforge:discussion")
+				},
+				{
+					uri: `${origin}/p/${project}/discussion/feed.atom`,
+					hint: composeHint("sourceforge:discussion-atom")
+				},
+				{
+					uri: `${origin}/p/${project}/bugs/feed`,
+					hint: composeHint("sourceforge:bugs")
+				}
+			];
+		}
+		return [];
+	}
+};
+//#endregion
+export { hosts, sourceforgeHandler };

package/dist/src/feeds/platform/handlers/spreaker.js

@@ -0,0 +1,22 @@
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/spreaker.ts
+const hosts = ["spreaker.com", "www.spreaker.com"];
+const podcastRegex = /^\/podcast\/[\w-]+--(\d+)/;
+const showRegex = /^\/show\/(\d+)(?:\/|$)/;
+const spreakerHandler = {
+	match: (url) => {
+		return isHostOf(url, hosts);
+	},
+	resolve: (url) => {
+		const { pathname } = new URL(url);
+		const id = pathname.match(podcastRegex)?.[1] ?? pathname.match(showRegex)?.[1];
+		if (!id) return [];
+		return [{
+			uri: `https://www.spreaker.com/show/${id}/episodes/feed`,
+			hint: composeHint("spreaker:podcast")
+		}];
+	}
+};
+//#endregion
+export { spreakerHandler };

package/dist/{feeds → src/feeds}/platform/handlers/stackExchange.js

@@ -1,8 +1,10 @@
-import { composeHint, isHostOf, isSubdomainOf } from "../../../common/utils.js";
+import { isHostOf, isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/stackExchange.ts
 const tagRegex = /^\/questions\/tagged\/([\w.+-]+)/;
 const questionRegex = /^\/questions\/(\d+)/;
 const userRegex = /^\/users\/(\d+)/;
+const collectiveRegex = /^\/collectives\/([^/]+)/;
 const domains = [
 	"stackoverflow.com",
 	"serverfault.com",
@@ -12,15 +14,29 @@ const domains = [
 	"mathoverflow.net",
 	"stackexchange.com"
 ];
+const validSorts = /* @__PURE__ */ new Set([
+	"newest",
+	"active",
+	"votes",
+	"creation",
+	"hot",
+	"week",
+	"month"
+]);
+const getSortSuffix = (searchParams) => {
+	const sort = searchParams.get("sort") ?? searchParams.get("tab")?.toLowerCase();
+	if (sort && validSorts.has(sort)) return `?sort=${sort}`;
+	return "";
+};
 const stackExchangeHandler = {
 	match: (url) => {
 		return isHostOf(url, domains) || isSubdomainOf(url, domains);
 	},
 	resolve: (url) => {
-		const { origin, pathname } = new URL(url);
+		const { origin, pathname, searchParams } = new URL(url);
 		const tagMatch = pathname.match(tagRegex);
 		if (tagMatch?.[1]) return [{
-			uri: `${origin}/feeds/tag/${tagMatch[1]}`,
+			uri: `${origin}/feeds/tag/${tagMatch[1]}${getSortSuffix(searchParams)}`,
 			hint: composeHint("stackexchange:tag")
 		}];
 		const questionMatch = pathname.match(questionRegex);
@@ -33,6 +49,15 @@ const stackExchangeHandler = {
 			uri: `${origin}/feeds/user/${userMatch[1]}`,
 			hint: composeHint("stackexchange:user")
 		}];
+		const collectiveMatch = pathname.match(collectiveRegex);
+		if (collectiveMatch?.[1]) return [{
+			uri: `${origin}/feeds/collectives/${collectiveMatch[1]}`,
+			hint: composeHint("stackexchange:collective")
+		}];
+		if (pathname === "/" || pathname === "") return [{
+			uri: `${origin}/feeds`,
+			hint: composeHint("stackexchange:newest")
+		}];
 		return [];
 	}
 };

package/dist/{feeds → src/feeds}/platform/handlers/steam.js

@@ -1,4 +1,5 @@
-import { composeHint, isHostOf } from "../../../common/utils.js";
+import { isHostOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/steam.ts
 const appRegex = /^\/(?:news\/)?app\/(\d+)/;
 const groupRegex = /^\/groups\/([^/]+)/;
@@ -21,6 +22,13 @@ const steamHandler = {
 				hint: composeHint("steam:group")
 			}];
 		}
+		if (hostname === "store.steampowered.com" && (pathname === "/" || pathname === "" || pathname.startsWith("/news"))) return [{
+			uri: "https://store.steampowered.com/feeds/news.xml",
+			hint: composeHint("steam:news-global")
+		}, {
+			uri: "https://store.steampowered.com/feeds/daily_deals.xml",
+			hint: composeHint("steam:daily-deals")
+		}];
 		return [];
 	}
 };

package/dist/{feeds → src/feeds}/platform/handlers/substack.js

@@ -1,4 +1,5 @@
-import { composeHint, isHostOf, isSubdomainOf } from "../../../common/utils.js";
+import { isHostOf, isSubdomainOf } from "../../../../node_modules/trousse/dist/urls.js";
+import { composeHint } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/substack.ts
 const profileRegex = /^\/@([\w-]+)/;
 const substackHandler = {