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

package/dist/src/common/locales.js

@@ -0,0 +1,337 @@
+//#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:discussion-category": "Discussion category",
+	"github:branch-commits": "Branch commits",
+	"github:file-history": "File history",
+	"reddit:posts": "Posts",
+	"reddit:post-comments": "Post comments",
+	"reddit:comments": "Comments",
+	"reddit:multireddit": "Multireddit",
+	"reddit:user-submitted": "Submitted",
+	"reddit:user-comments": "Comments",
+	"reddit:search": "Search",
+	"reddit:wiki": "Wiki",
+	"reddit:subreddits": "Subreddits",
+	"gitlab:activity": "Activity",
+	"gitlab:releases": "Releases",
+	"gitlab:tags": "Tags",
+	"gitlab:issues": "Issues",
+	"gitlab:merge-requests": "Merge requests",
+	"gitlab:branch-commits": "Branch commits",
+	"codeberg:activity": "Activity",
+	"codeberg:releases": "Releases",
+	"codeberg:tags": "Tags",
+	"codeberg:branch-commits": "Branch commits",
+	"codeberg:file-history": "File history",
+	"wordpress:category-rss": "Category (RSS)",
+	"wordpress:category-atom": "Category (Atom)",
+	"wordpress:category-rdf": "Category (RDF)",
+	"wordpress:tag-rss": "Tag (RSS)",
+	"wordpress:tag-atom": "Tag (Atom)",
+	"wordpress:tag-rdf": "Tag (RDF)",
+	"wordpress:author-rss": "Author (RSS)",
+	"wordpress:author-atom": "Author (Atom)",
+	"wordpress:author-rdf": "Author (RDF)",
+	"wordpress:date-archive-rss": "Date archive (RSS)",
+	"wordpress:date-archive-atom": "Date archive (Atom)",
+	"wordpress:date-archive-rdf": "Date archive (RDF)",
+	"wordpress:posts-rss": "Posts (RSS)",
+	"wordpress:posts-rdf": "Posts (RDF)",
+	"wordpress:posts-atom": "Posts (Atom)",
+	"wordpress:comments-rss": "Comments (RSS)",
+	"wordpress:comments-rdf": "Comments (RDF)",
+	"wordpress:comments-atom": "Comments (Atom)",
+	"wordpress:post-comments-rss": "Post comments (RSS)",
+	"wordpress:post-comments-rdf": "Post comments (RDF)",
+	"wordpress:post-comments-atom": "Post comments (Atom)",
+	"blogspot:posts-atom": "Posts (Atom)",
+	"blogspot:posts-rss": "Posts (RSS)",
+	"blogspot:posts-summary-atom": "Posts summary (Atom)",
+	"blogspot:posts-summary-rss": "Posts summary (RSS)",
+	"blogspot:comments-atom": "Comments (Atom)",
+	"blogspot:comments-rss": "Comments (RSS)",
+	"blogspot:label-atom": "Label (Atom)",
+	"blogspot:label-rss": "Label (RSS)",
+	"blogspot:post-comments-atom": "Post comments (Atom)",
+	"blogspot:post-comments-rss": "Post comments (RSS)",
+	"behance:portfolio": "Portfolio",
+	"behance:appreciated": "Appreciated",
+	"behance:projects": "Featured projects",
+	"behance:featured": "Featured by Adobe",
+	"bluesky:posts": "Posts",
+	"dailymotion:videos": "Videos",
+	"dailymotion:playlist": "Playlist",
+	"dailymotion:channel": "Channel",
+	"dailymotion:trending": "Trending",
+	"dailymotion:search": "Search",
+	"deviantart:tag": "Tag",
+	"deviantart:favorites": "Favorites",
+	"deviantart:gallery": "Gallery",
+	"deviantart:deviations": "Deviations",
+	"deviantart:journal": "Journal",
+	"deviantart:daily-deviations": "Daily Deviations",
+	"deviantart:popular": "Popular",
+	"devto:posts": "Posts",
+	"devto:tag": "Tag",
+	"devto:community": "Community",
+	"devto:latest": "Latest",
+	"github-gist:gists": "Gists",
+	"github-gist:starred": "Starred",
+	"github-gist:forks": "Forks",
+	"github-gist:discover": "Discover",
+	"kickstarter:updates": "Updates",
+	"kickstarter:projects": "Projects",
+	"letterboxd:diary": "Diary",
+	"letterboxd:journal": "Journal",
+	"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",
+	"mastodon:tagged": "Tagged",
+	"mastodon:replies": "Posts with replies",
+	"mastodon:media": "Media",
+	"medium:posts": "Posts",
+	"medium:tag": "Tag",
+	"medium:tagged": "Tagged",
+	"medium:publication": "Publication",
+	"pinterest:pins": "Pins",
+	"pinterest:board": "Board",
+	"producthunt:topic": "Topic",
+	"producthunt:category": "Category",
+	"producthunt:products": "Products",
+	"soundcloud:tracks": "Tracks",
+	"stackexchange:tag": "Tag",
+	"stackexchange:question": "Question",
+	"stackexchange:user": "User",
+	"stackexchange:newest": "Newest questions",
+	"stackexchange:collective": "Collective",
+	"steam:news": "News",
+	"steam:news-global": "News (global)",
+	"steam:daily-deals": "Daily deals",
+	"steam:group": "Group",
+	"substack:newsletter": "Newsletter",
+	"tumblr:posts": "Posts",
+	"tumblr:tag": "Tag",
+	"goodreads:updates": "Updates",
+	"goodreads:reviews": "Reviews",
+	"goodreads:shelf": "Shelf",
+	"sourceforge:activity": "Recent activity",
+	"sourceforge:files": "File releases",
+	"sourceforge:news-rss": "News (RSS)",
+	"sourceforge:news-atom": "News (Atom)",
+	"sourceforge:discussion": "Discussion",
+	"sourceforge:discussion-atom": "Discussion (Atom)",
+	"sourceforge:project-feed": "Project feed",
+	"sourceforge:bugs": "Bugs",
+	"velog:posts": "Posts",
+	"velog:trending": "Trending",
+	"vimeo:videos": "Videos",
+	"vimeo:likes": "Likes",
+	"vimeo:channel": "Channel",
+	"vimeo:group": "Group",
+	"vimeo:album": "Album",
+	"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:platform": "Platform",
+	"itchio:genre": "Genre",
+	"itchio:made-with": "Made with",
+	"itchio:section": "Section",
+	"itchio:featured": "Featured",
+	"itchio:new": "New",
+	"itchio:sales": "Sales",
+	"itchio:blog": "Blog",
+	"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",
+	"lemmy:all": "All",
+	"lemmy:local": "Local",
+	"apple-podcasts:podcast": "Podcast",
+	"writeas:blog": "Blog",
+	"writeas:tag": "Tag",
+	"prose:blog": "Blog",
+	"prose:tag": "Tag",
+	"prose:discovery": "Discovery",
+	"pagecord:blog": "Blog",
+	"listed:blog": "Blog",
+	"fireside:podcast-rss": "Podcast (RSS)",
+	"fireside:podcast-json": "Podcast (JSON)",
+	"exblog:posts-rss": "Posts (RSS)",
+	"exblog:posts-atom": "Posts (Atom)",
+	"exblog:category-rss": "Category (RSS)",
+	"exblog:category-atom": "Category (Atom)",
+	"dreamwidth:posts-rss": "Posts (RSS)",
+	"dreamwidth:posts-atom": "Posts (Atom)",
+	"dreamwidth:posts-tag-rss": "Tag (RSS)",
+	"dreamwidth:posts-tag-atom": "Tag (Atom)",
+	"dreamwidth:userpics-atom": "Userpics (Atom)",
+	"buttondown:newsletter": "Newsletter",
+	"bearblog:posts-atom": "Posts (Atom)",
+	"bearblog:posts-rss": "Posts (RSS)",
+	"bearblog:tag-atom": "Tag (Atom)",
+	"bearblog:tag-rss": "Tag (RSS)",
+	"bearblog:discover-atom": "Trending (Atom)",
+	"bearblog:discover-rss": "Trending (RSS)",
+	"transistor:podcast": "Podcast",
+	"odysee:videos": "Videos",
+	"myanimelist:anime": "Anime list",
+	"myanimelist:manga": "Manga list",
+	"myanimelist:recently-watched": "Recently watched",
+	"myanimelist:recently-read": "Recently read",
+	"myanimelist:news": "News",
+	"myanimelist:featured": "Featured",
+	"hackernews:front": "Front page",
+	"hackernews:show": "Show HN",
+	"tistory:blog": "Blog",
+	"note:blog": "Blog",
+	"note:hashtag": "Hashtag",
+	"note:magazine": "Magazine",
+	"note:featured": "Featured",
+	"artstation:portfolio": "Portfolio",
+	"artstation:artwork": "Artwork",
+	"artstation:artwork-trending": "Artwork (Trending)",
+	"nebula:videos": "Videos",
+	"nebula:videos-plus": "Videos (Plus)",
+	"nebula:videos-all": "All Videos",
+	"nebula:videos-all-plus": "All Videos (Plus)",
+	"nebula:category": "Category",
+	"nebula:category-plus": "Category (Plus)",
+	"nebula:channels": "Recently Added Channels",
+	"acast:podcast": "Podcast",
+	"ameblo:posts-rss": "Posts (RSS)",
+	"ameblo:posts-atom": "Posts (Atom)",
+	"ameblo:posts-rdf": "Posts (RDF)",
+	"arena:profile": "Profile",
+	"arena:channel": "Channel",
+	"arena:editorial": "Editorial",
+	"audioboom:podcast": "Podcast",
+	"bookwyrm:activity": "Activity",
+	"bookwyrm:reviews": "Reviews",
+	"bookwyrm:quotes": "Quotes",
+	"bookwyrm:comments": "Comments",
+	"bookwyrm:shelf": "Shelf",
+	"buzzsprout:podcast": "Podcast",
+	"discourse:latest": "Latest",
+	"discourse:posts": "Latest posts",
+	"discourse:top": "Top",
+	"discourse:category": "Category",
+	"discourse:topic": "Topic",
+	"discourse:activity": "Activity",
+	"friendica:posts": "Posts",
+	"friendica:comments": "Comments",
+	"friendica:replies": "Replies",
+	"friendica:activity": "Activity",
+	"ghost:blog": "Blog",
+	"ghost:tag": "Tag",
+	"ghost:author": "Author",
+	"hearthis:tracks": "Tracks",
+	"hey-world:blog": "Blog",
+	"insanejournal:posts-rss": "Posts (RSS)",
+	"insanejournal:posts-atom": "Posts (Atom)",
+	"insanejournal:posts-tag-rss": "Tag (RSS)",
+	"insanejournal:posts-tag-atom": "Tag (Atom)",
+	"insanejournal:userpics-atom": "Userpics (Atom)",
+	"libsyn:podcast": "Podcast",
+	"livejournal:posts-rss": "Posts (RSS)",
+	"livejournal:posts-atom": "Posts (Atom)",
+	"livejournal:posts-tag-rss": "Tag (RSS)",
+	"livejournal:posts-tag-atom": "Tag (Atom)",
+	"livejournal:userpics-atom": "Userpics (Atom)",
+	"mataroa:blog": "Blog",
+	"microblog:posts-rss": "Posts (RSS)",
+	"microblog:posts-json": "Posts (JSON)",
+	"microblog:podcast": "Podcast",
+	"microblog:podcast-json": "Podcast (JSON)",
+	"microblog:category-rss": "Category (RSS)",
+	"microblog:category-json": "Category (JSON)",
+	"microblog:archive": "Archive",
+	"microblog:photos": "Photos",
+	"microblog:replies": "Replies",
+	"misskey:posts-atom": "Posts (Atom)",
+	"misskey:posts-rss": "Posts (RSS)",
+	"misskey:posts-json": "Posts (JSON)",
+	"naver-blog:blog": "Blog",
+	"observable:notebooks": "Notebooks",
+	"observable:collection": "Collection",
+	"observable:recent": "Recent",
+	"observable:trending": "Trending",
+	"pika:posts-atom": "Posts (Atom)",
+	"pika:posts-rss": "Posts (RSS)",
+	"pika:tag-atom": "Tag (Atom)",
+	"pika:tag-rss": "Tag (RSS)",
+	"pixelfed:posts": "Posts",
+	"pleroma:posts": "Posts",
+	"pleroma:posts-rss": "Posts (RSS)",
+	"podbean:podcast": "Podcast",
+	"podigee:podcast": "Podcast",
+	"posthaven:posts": "Posts",
+	"posthaven:tag": "Tag",
+	"qiita:posts": "Posts",
+	"qiita:tag": "Tag",
+	"qiita:organization": "Organization",
+	"qiita:popular": "Popular items",
+	"qiita:zine": "Qiita Zine",
+	"rss-com:podcast": "Podcast",
+	"seesaa:posts-rss2": "Posts (RSS 2.0)",
+	"seesaa:posts-rdf": "Posts (RDF)",
+	"spreaker:podcast": "Podcast",
+	"tildes:topics-rss": "Topics (RSS)",
+	"tildes:topics-atom": "Topics (Atom)",
+	"tildes:group-rss": "Group (RSS)",
+	"tildes:group-atom": "Group (Atom)",
+	"weblog-lol:posts-rss": "Posts (RSS)",
+	"weblog-lol:posts-atom": "Posts (Atom)",
+	"weblog-lol:posts-json": "Posts (JSON)",
+	"weebly:blog": "Blog",
+	"zenn:posts": "Posts",
+	"zenn:topic": "Topic",
+	"zenn:publication": "Publication",
+	"zenn:trending": "Trending"
+};
+//#endregion
+export { errors, hints };

package/dist/{common → src/common}/types.d.ts

@@ -6,6 +6,7 @@ import { PlatformMethodOptions } from "./uris/platform/types.js";
 
 //#region src/common/types.d.ts
 type MaybePromise<T> = T | Promise<T>;
+type Pattern = string | RegExp;
 type UriEntry = string | Array<string>;
 type DiscoverUriHint = {
   key: string;
@@ -42,6 +43,11 @@ type DiscoverProgress = {
   current: string;
 };
 type DiscoverOnProgressFn = (progress: DiscoverProgress) => void;
+type DiscoverErrorContext = {
+  phase: 'fetchInput' | 'resolveSiteUrl';
+  url?: string;
+};
+type DiscoverOnErrorFn = (error: unknown, context: DiscoverErrorContext) => void;
 type DiscoverResult<TValid = object> = ({
   url: string;
   isValid: true;
@@ -82,8 +88,10 @@ type DiscoverOptions<TValid, TMethods extends DiscoverMethod = DiscoverMethod> =
   stopOnFirstMethod?: boolean;
   stopOnFirstResult?: boolean;
   concurrency?: number;
+  maxUris?: number;
   onProgress?: DiscoverOnProgressFn;
+  onError?: DiscoverOnErrorFn;
   includeInvalid?: boolean;
 };
 //#endregion
-export { DiscoverExtractFn, DiscoverFetchFn, DiscoverFetchFnOptions, DiscoverFetchFnResponse, DiscoverInput, DiscoverInputObject, DiscoverMethod, DiscoverMethodsConfig, DiscoverOnProgressFn, DiscoverOptions, DiscoverProgress, DiscoverResolveSiteUrlFn, DiscoverResolveUrlFn, DiscoverResult, DiscoverUriEntry, DiscoverUriHint, LinkSelector, MaybePromise, UriEntry };
+export { DiscoverExtractFn, DiscoverFetchFn, DiscoverFetchFnOptions, DiscoverFetchFnResponse, DiscoverInput, DiscoverInputObject, DiscoverMethod, DiscoverMethodsConfig, DiscoverOnProgressFn, DiscoverOptions, DiscoverProgress, DiscoverResolveSiteUrlFn, DiscoverResolveUrlFn, DiscoverResult, DiscoverUriEntry, DiscoverUriHint, LinkSelector, MaybePromise, Pattern, UriEntry };

package/dist/{common → src/common}/uris/feed/index.js

@@ -1,4 +1,4 @@
-import { omitEmpty } from "../../utils.js";
+import { omitEmpty } from "../../../../node_modules/trousse/dist/arrays.js";
 import { parseFeed } from "feedsmith";
 //#region src/common/uris/feed/index.ts
 const discoverUrisFromFeed = (content, options) => {

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

@@ -0,0 +1,16 @@
+import { extractSectionBaseUrls, generatePathUrlCombinations, generateUrlCombinations, getAncestorPathBases } from "./utils.js";
+//#region src/common/uris/guess/index.ts
+const discoverUrisFromGuess = (options) => {
+	const { baseUrl, uris, additionalBaseUrls = [], maxAncestorDepth = 0 } = options;
+	const { content, sectionNames } = options;
+	const combinations = generateUrlCombinations([baseUrl, ...additionalBaseUrls], uris);
+	const pathBases = [];
+	if (maxAncestorDepth > 0) pathBases.push(...getAncestorPathBases(baseUrl, maxAncestorDepth));
+	if (content && sectionNames && sectionNames.length > 0) {
+		for (const sectionBase of extractSectionBaseUrls(content, baseUrl, sectionNames)) if (!pathBases.includes(sectionBase)) pathBases.push(sectionBase);
+	}
+	if (pathBases.length > 0) combinations.push(...generatePathUrlCombinations(pathBases, uris));
+	return combinations;
+};
+//#endregion
+export { discoverUrisFromGuess };

package/dist/{common → src/common}/uris/guess/types.d.ts

@@ -5,6 +5,9 @@ type GuessMethodOptions = {
   baseUrl: string;
   uris: Array<UriEntry>;
   additionalBaseUrls?: Array<string>;
+  maxAncestorDepth?: number;
+  content?: string;
+  sectionNames?: Array<string>;
 };
 //#endregion
 export { GuessMethodOptions };

package/dist/{common → src/common}/uris/guess/utils.d.ts

@@ -2,7 +2,8 @@ import { UriEntry } from "../../types.js";
 
 //#region src/common/uris/guess/utils.d.ts
 declare const generateUrlCombinations: (baseUrls: Array<string>, uris: Array<UriEntry>) => Array<UriEntry>;
+declare const extractSectionBaseUrls: (content: string, baseUrl: string, sectionNames: Array<string>) => Array<string>;
 declare const getWwwCounterpart: (baseUrl: string) => string;
 declare const getSubdomainVariants: (baseUrl: string, prefixes: Array<string>) => Array<string>;
 //#endregion
-export { generateUrlCombinations, getSubdomainVariants, getWwwCounterpart };
+export { extractSectionBaseUrls, generateUrlCombinations, getSubdomainVariants, getWwwCounterpart };

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

@@ -0,0 +1,83 @@
+import { getPathSegments, parseUrl } from "../../../../node_modules/trousse/dist/urls.js";
+import { Parser } from "htmlparser2";
+//#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 resolvePathUri = (uri, base) => {
+	if (uri.startsWith("/")) return new URL(uri.slice(1), base).href;
+	return new URL(uri, base).href;
+};
+const generatePathUrlCombinations = (pathBases, uris) => {
+	return pathBases.flatMap((base) => {
+		const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+		return uris.map((uri) => {
+			if (typeof uri === "string") return resolvePathUri(uri, normalizedBase);
+			return uri.map((alternative) => resolvePathUri(alternative, normalizedBase));
+		});
+	});
+};
+const getAncestorPathBases = (baseUrl, maxDepth) => {
+	const url = parseUrl(baseUrl);
+	if (!url) return [];
+	const segments = url.pathname.split("/").slice(1, -1).filter((segment) => segment !== "");
+	const bases = [];
+	let base = `${url.origin}/`;
+	for (const segment of segments.slice(0, maxDepth)) {
+		base += `${segment}/`;
+		bases.push(base);
+	}
+	return bases;
+};
+const extractSectionBaseUrls = (content, baseUrl, sectionNames) => {
+	const base = parseUrl(baseUrl);
+	if (!base) return [];
+	const bases = /* @__PURE__ */ new Set();
+	const parser = new Parser({ onopentag: (name, attributes) => {
+		if (name !== "a" || !attributes.href) return;
+		const url = parseUrl(attributes.href, base);
+		if (!url || url.origin !== base.origin) return;
+		const segments = getPathSegments(url);
+		const segment = segments.length === 1 ? segments[0] : void 0;
+		if (segment && sectionNames.includes(segment.toLowerCase())) bases.add(`${url.origin}/${segment}/`);
+	} }, { decodeEntities: true });
+	parser.write(content);
+	parser.end();
+	return [...bases];
+};
+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 { extractSectionBaseUrls, generatePathUrlCombinations, generateUrlCombinations, getAncestorPathBases, getSubdomainVariants, getWwwCounterpart };

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

@@ -0,0 +1,14 @@
+import { matchesAnyOfLinkSelectors } from "../../utils.js";
+import LinkHeader from "http-link-header";
+//#region src/common/uris/headers/index.ts
+const discoverUrisFromHeaders = (headers, options) => {
+	const linkHeader = headers.get("link");
+	if (!linkHeader) return [];
+	const uris = /* @__PURE__ */ new Set();
+	try {
+		for (const ref of LinkHeader.parse(linkHeader).refs) if (ref.rel && matchesAnyOfLinkSelectors(ref.rel, ref.type, options.linkSelectors)) uris.add(ref.uri);
+	} catch {}
+	return [...uris];
+};
+//#endregion
+export { discoverUrisFromHeaders };

package/dist/{common → src/common}/uris/html/handlers.js

@@ -1,6 +1,12 @@
-import { endsWithAnyOf, includesAnyOf, matchesAnyOfLinkSelectors } from "../../utils.js";
+import { endsWithAnyOf, includesAnyOf } from "../../../../node_modules/trousse/dist/matching.js";
+import { parseUrl } from "../../../../node_modules/trousse/dist/urls.js";
+import { matchesAnyOfLinkSelectors } from "../../utils.js";
 //#region src/common/uris/html/handlers.ts
 const handleOpenTag = (context, name, attribs, _isImplied) => {
+	if (name === "base" && context.baseHref === void 0) {
+		const href = attribs.href?.trim();
+		if (href) context.baseHref = href;
+	}
 	if (name === "link" && attribs.href) {
 		const rel = attribs.rel?.toLowerCase();
 		if (!rel) return;
@@ -16,6 +22,17 @@ const handleOpenTag = (context, name, attribs, _isImplied) => {
 		context.currentAnchor.href = attribs.href;
 		context.currentAnchor.text = "";
 		if (endsWithAnyOf(lowerHref, context.options.anchorUris)) context.discoveredUris.add(attribs.href);
+		if (context.options.anchorPathSegments?.length) {
+			const pathname = parseUrl(attribs.href, "https://feedscout.invalid")?.pathname;
+			if (pathname && includesAnyOf(pathname, context.options.anchorPathSegments)) context.discoveredUris.add(attribs.href);
+		}
+	}
+	if (context.currentAnchor.href && context.options.anchorAttributes?.length) for (const attribute of context.options.anchorAttributes) {
+		const value = attribs[attribute];
+		if (value && includesAnyOf(value, context.options.anchorLabels)) {
+			context.discoveredUris.add(context.currentAnchor.href);
+			break;
+		}
 	}
 };
 const handleText = (context, text) => {

package/dist/{common → src/common}/uris/html/index.js

@@ -13,7 +13,23 @@ const discoverUrisFromHtml = (html, options) => {
 	const parser = new Parser(createHtmlUrisHandlers(context), { decodeEntities: true });
 	parser.write(html);
 	parser.end();
-	return [...context.discoveredUris];
+	const uris = [...context.discoveredUris];
+	if (context.baseHref) {
+		let base;
+		try {
+			base = options.baseUrl ? new URL(context.baseHref, options.baseUrl).href : context.baseHref;
+		} catch {
+			base = options.baseUrl;
+		}
+		return uris.map((uri) => {
+			try {
+				return new URL(uri, base).href;
+			} catch {
+				return uri;
+			}
+		});
+	}
+	return uris;
 };
 //#endregion
 export { discoverUrisFromHtml };

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

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

package/dist/src/common/utils.js

@@ -0,0 +1,51 @@
+import { anyWordMatchesAnyOf, isAnyOf } from "../../node_modules/trousse/dist/matching.js";
+import { hints } from "./locales.js";
+//#region src/common/utils.ts
+const composeHint = (key) => ({
+	key,
+	label: hints[key]
+});
+const isSuccessfulStatus = (status) => {
+	return status === void 0 || status >= 200 && status < 300;
+};
+const toPositiveInteger = (value, fallback) => {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : fallback;
+};
+const normalizeMimeType = (type) => {
+	return type.split(";")[0].trim().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 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 { composeHint, hasMetaContent, isSuccessfulStatus, matchesAnyOfLinkSelectors, processConcurrently, toPositiveInteger };

package/dist/{favicons → src/favicons}/defaults.js

@@ -1,4 +1,4 @@
-import { omitEmpty } from "../common/utils.js";
+import { omitEmpty } from "../../node_modules/trousse/dist/arrays.js";
 import { blueskyHandler } from "./platform/handlers/bluesky.js";
 import { codebergHandler } from "./platform/handlers/codeberg.js";
 import { deviantartHandler } from "./platform/handlers/deviantart.js";