feedscout 1.8.1 → 2.0.0-beta.1

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

@@ -0,0 +1,26 @@
+import { composeHint, isSubdomainOf } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/weblogLol.ts
+const weblogLolHandler = {
+	match: (url) => {
+		return isSubdomainOf(url, "weblog.lol");
+	},
+	resolve: (url) => {
+		const { origin } = new URL(url);
+		const uris = [];
+		uris.push({
+			uri: `${origin}/rss.xml`,
+			hint: composeHint("weblog-lol:posts-rss")
+		});
+		uris.push({
+			uri: `${origin}/atom.xml`,
+			hint: composeHint("weblog-lol:posts-atom")
+		});
+		uris.push({
+			uri: `${origin}/feed.json`,
+			hint: composeHint("weblog-lol:posts-json")
+		});
+		return uris;
+	}
+};
+//#endregion
+export { weblogLolHandler };

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

@@ -0,0 +1,25 @@
+import { composeHint, isSubdomainOf } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/weebly.ts
+const numericRegex = /^\d+$/;
+const weeblyHandler = {
+	match: (url) => {
+		return isSubdomainOf(url, "weebly.com");
+	},
+	resolve: (url) => {
+		const { origin, pathname } = new URL(url);
+		const pathSegments = pathname.split("/").filter(Boolean);
+		const uris = [];
+		const firstSegment = pathSegments[0];
+		if (firstSegment && !numericRegex.test(firstSegment)) uris.push({
+			uri: `${origin}/${firstSegment}/feed`,
+			hint: composeHint("weebly:blog")
+		});
+		uris.push({
+			uri: `${origin}/blog/feed`,
+			hint: composeHint("weebly:blog")
+		});
+		return uris;
+	}
+};
+//#endregion
+export { weeblyHandler };

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

@@ -3,6 +3,10 @@ import { composeHint, isSubdomainOf } from "../../../common/utils.js";
 const categoryRegex = /^\/category\/([^/]+)/;
 const tagRegex = /^\/tag\/([^/]+)/;
 const authorRegex = /^\/author\/([^/]+)/;
+const yearRegex = /^\/(\d{4})\/?$/;
+const yearMonthRegex = /^\/(\d{4})\/(\d{2})\/?$/;
+const dayRegex = /^\/(\d{4})\/(\d{2})\/(\d{2})\/?$/;
+const trailingSlashRegex = /\/$/;
 const wordpressHandler = {
 	match: (url) => {
 		return isSubdomainOf(url, "wordpress.com");
@@ -10,53 +14,194 @@ const wordpressHandler = {
 	resolve: (url) => {
 		const { origin, pathname } = new URL(url);
 		const uris = [];
+		let archiveMatched = false;
 		const categoryMatch = pathname.match(categoryRegex);
-		if (categoryMatch?.[1]) uris.push({
-			uri: [`${origin}/category/${categoryMatch[1]}/feed/`, `${origin}/category/${categoryMatch[1]}/?feed=rss`],
-			hint: composeHint("wordpress:category")
-		});
+		if (categoryMatch?.[1]) {
+			archiveMatched = true;
+			const base = `${origin}/category/${categoryMatch[1]}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:category-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:category-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:category-rdf")
+			});
+		}
 		const tagMatch = pathname.match(tagRegex);
-		if (tagMatch?.[1]) uris.push({
-			uri: [`${origin}/tag/${tagMatch[1]}/feed/`, `${origin}/tag/${tagMatch[1]}/?feed=rss`],
-			hint: composeHint("wordpress:tag")
-		});
+		if (tagMatch?.[1]) {
+			archiveMatched = true;
+			const base = `${origin}/tag/${tagMatch[1]}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:tag-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:tag-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:tag-rdf")
+			});
+		}
 		const authorMatch = pathname.match(authorRegex);
-		if (authorMatch?.[1]) uris.push({
-			uri: [`${origin}/author/${authorMatch[1]}/feed/`, `${origin}/author/${authorMatch[1]}/?feed=rss`],
-			hint: composeHint("wordpress:author")
-		});
+		if (authorMatch?.[1]) {
+			archiveMatched = true;
+			const base = `${origin}/author/${authorMatch[1]}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:author-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:author-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:author-rdf")
+			});
+		}
+		const dayMatch = pathname.match(dayRegex);
+		if (dayMatch?.[1] && dayMatch?.[2] && dayMatch?.[3]) {
+			archiveMatched = true;
+			const base = `${origin}/${dayMatch[1]}/${dayMatch[2]}/${dayMatch[3]}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:date-archive-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:date-archive-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:date-archive-rdf")
+			});
+		}
+		const yearMonthMatch = pathname.match(yearMonthRegex);
+		if (yearMonthMatch?.[1] && yearMonthMatch?.[2]) {
+			archiveMatched = true;
+			const base = `${origin}/${yearMonthMatch[1]}/${yearMonthMatch[2]}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:date-archive-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:date-archive-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:date-archive-rdf")
+			});
+		}
+		const yearMatch = pathname.match(yearRegex);
+		if (yearMatch?.[1]) {
+			archiveMatched = true;
+			const base = `${origin}/${yearMatch[1]}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:date-archive-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:date-archive-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:date-archive-rdf")
+			});
+		}
+		const segments = pathname.split("/").filter(Boolean);
+		if (!archiveMatched && segments.length > 0 && !segments.includes("feed")) {
+			const base = `${origin}${pathname.replace(trailingSlashRegex, "")}`;
+			uris.push({
+				uri: [
+					`${base}/feed/`,
+					`${base}/?feed=rss`,
+					`${base}/feed/rss2/`,
+					`${base}/?feed=rss2`
+				],
+				hint: composeHint("wordpress:post-comments-rss")
+			});
+			uris.push({
+				uri: [`${base}/feed/atom/`, `${base}/?feed=atom`],
+				hint: composeHint("wordpress:post-comments-atom")
+			});
+			uris.push({
+				uri: [`${base}/feed/rdf/`, `${base}/?feed=rdf`],
+				hint: composeHint("wordpress:post-comments-rdf")
+			});
+		}
 		uris.push({
-			uri: [`${origin}/feed/`, `${origin}/?feed=rss`],
-			hint: composeHint("wordpress:posts-rss2")
+			uri: [
+				`${origin}/feed/`,
+				`${origin}/?feed=rss`,
+				`${origin}/feed/rss2/`,
+				`${origin}/?feed=rss2`
+			],
+			hint: composeHint("wordpress:posts-rss")
 		});
 		uris.push({
-			uri: [`${origin}/feed/rss2/`, `${origin}/?feed=rss2`],
-			hint: composeHint("wordpress:posts-rss2-alt")
+			uri: [`${origin}/feed/atom/`, `${origin}/?feed=atom`],
+			hint: composeHint("wordpress:posts-atom")
 		});
 		uris.push({
 			uri: [`${origin}/feed/rdf/`, `${origin}/?feed=rdf`],
 			hint: composeHint("wordpress:posts-rdf")
 		});
 		uris.push({
-			uri: [`${origin}/feed/atom/`, `${origin}/?feed=atom`],
-			hint: composeHint("wordpress:posts-atom")
+			uri: [
+				`${origin}/comments/feed/`,
+				`${origin}/?feed=comments-rss`,
+				`${origin}/comments/feed/rss2/`,
+				`${origin}/?feed=comments-rss2`
+			],
+			hint: composeHint("wordpress:comments-rss")
 		});
 		uris.push({
-			uri: [`${origin}/comments/feed/`, `${origin}/?feed=comments-rss2`],
-			hint: composeHint("wordpress:comments")
-		});
-		uris.push({
-			uri: [`${origin}/comments/feed/rss2/`, `${origin}/?feed=comments-rss2`],
-			hint: composeHint("wordpress:comments-rss2")
+			uri: [`${origin}/comments/feed/atom/`, `${origin}/?feed=comments-atom`],
+			hint: composeHint("wordpress:comments-atom")
 		});
 		uris.push({
 			uri: [`${origin}/comments/feed/rdf/`, `${origin}/?feed=comments-rdf`],
 			hint: composeHint("wordpress:comments-rdf")
 		});
-		uris.push({
-			uri: [`${origin}/comments/feed/atom/`, `${origin}/?feed=comments-atom`],
-			hint: composeHint("wordpress:comments-atom")
-		});
 		return uris;
 	}
 };

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

@@ -0,0 +1,51 @@
+import { composeHint, isAnyOf, isHostOf } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/writeas.ts
+const hosts = ["write.as", "www.write.as"];
+const excludedPaths = [
+	"about",
+	"api",
+	"blog",
+	"docs",
+	"legal",
+	"login",
+	"me",
+	"pricing",
+	"privacy",
+	"settings",
+	"signup",
+	"terms"
+];
+const tagRegex = /^\/([^/]+)\/tag:([^/]+)/;
+const writeasHandler = {
+	match: (url) => {
+		return isHostOf(url, hosts);
+	},
+	resolve: (url) => {
+		const { pathname } = new URL(url);
+		const uris = [];
+		const tagMatch = pathname.match(tagRegex);
+		if (tagMatch?.[1] && tagMatch?.[2]) {
+			const username = tagMatch[1];
+			const tag = tagMatch[2];
+			uris.push({
+				uri: `https://write.as/${username}/tag:${tag}/feed/`,
+				hint: composeHint("writeas:tag")
+			});
+			uris.push({
+				uri: `https://write.as/${username}/feed/`,
+				hint: composeHint("writeas:blog")
+			});
+			return uris;
+		}
+		const pathSegments = pathname.split("/").filter(Boolean);
+		if (pathSegments.length === 0) return [];
+		const username = pathSegments[0];
+		if (isAnyOf(username, excludedPaths)) return [];
+		return [{
+			uri: `https://write.as/${username}/feed/`,
+			hint: composeHint("writeas:blog")
+		}];
+	}
+};
+//#endregion
+export { writeasHandler };

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

@@ -1,6 +1,6 @@
 import { composeHint, isHostOf } from "../../../common/utils.js";
 //#region src/feeds/platform/handlers/ximalaya.ts
-const albumRegex = /^\/album\/(\d+)/;
+const albumRegex = /(?:^|\/)album\/(\d+)/;
 const hosts = ["www.ximalaya.com", "ximalaya.com"];
 const ximalayaHandler = {
 	match: (url) => {

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

@@ -5,11 +5,14 @@ const channelRegex = /^\/channel\/(UC[a-zA-Z0-9_-]+)/;
 const handleRegex = /^\/@([^/]+)/;
 const userRegex = /^\/user\/([^/]+)/;
 const customRegex = /^\/c\/([^/]+)/;
+const shortsRegex = /^\/shorts\/[\w-]+/;
+const liveRegex = /^\/live\/[\w-]+/;
 const channelPrefixRegex = /^UC/;
 const hosts = [
 	"youtube.com",
 	"www.youtube.com",
 	"m.youtube.com",
+	"music.youtube.com",
 	"youtu.be",
 	"www.youtu.be"
 ];
@@ -82,7 +85,7 @@ const youtubeHandler = {
 			hint: composeHint("youtube:playlist")
 		});
 		if (uris.length === 0 && content) {
-			if (parsedUrl.searchParams.has("v") || parsedUrl.hostname.includes("youtu.be") && parsedUrl.pathname.length > 1 || parsedUrl.pathname.match(handleRegex) || parsedUrl.pathname.match(userRegex) || parsedUrl.pathname.match(customRegex)) {
+			if (parsedUrl.searchParams.has("v") || parsedUrl.hostname.includes("youtu.be") && parsedUrl.pathname.length > 1 || shortsRegex.test(parsedUrl.pathname) || liveRegex.test(parsedUrl.pathname) || parsedUrl.pathname.match(handleRegex) || parsedUrl.pathname.match(userRegex) || parsedUrl.pathname.match(customRegex)) {
 				const channelId = extractChannelIdFromContent(content);
 				if (channelId) pushChannelUris(uris, channelId);
 			}

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

@@ -0,0 +1,54 @@
+import { composeHint, isAnyOf, isHostOf } from "../../../common/utils.js";
+//#region src/feeds/platform/handlers/zenn.ts
+const hosts = ["zenn.dev", "www.zenn.dev"];
+const excludedPaths = [
+	"about",
+	"api",
+	"articles",
+	"books",
+	"login",
+	"notifications",
+	"p",
+	"privacy",
+	"publications",
+	"scraps",
+	"search",
+	"settings",
+	"signup",
+	"terms",
+	"topics"
+];
+const topicRegex = /^\/topics\/([^/]+)/;
+const publicationShortRegex = /^\/p\/([^/]+)/;
+const publicationLongRegex = /^\/publications\/([^/]+)/;
+const zennHandler = {
+	match: (url) => {
+		return isHostOf(url, hosts);
+	},
+	resolve: (url) => {
+		const { pathname } = new URL(url);
+		const topicMatch = pathname.match(topicRegex);
+		if (topicMatch?.[1]) return [{
+			uri: `https://zenn.dev/topics/${topicMatch[1]}/feed`,
+			hint: composeHint("zenn:topic")
+		}];
+		const pubMatch = pathname.match(publicationShortRegex) ?? pathname.match(publicationLongRegex);
+		if (pubMatch?.[1]) return [{
+			uri: `https://zenn.dev/p/${pubMatch[1]}/feed`,
+			hint: composeHint("zenn:publication")
+		}];
+		const pathSegments = pathname.split("/").filter(Boolean);
+		if (pathSegments.length === 0) return [{
+			uri: "https://zenn.dev/feed",
+			hint: composeHint("zenn:trending")
+		}];
+		const username = pathSegments[0];
+		if (isAnyOf(username, excludedPaths)) return [];
+		return [{
+			uri: `https://zenn.dev/${username}/feed`,
+			hint: composeHint("zenn:posts")
+		}];
+	}
+};
+//#endregion
+export { zennHandler };

package/dist/feeds.d.ts

@@ -1,4 +1,4 @@
-import { anchorLabels, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal } from "./feeds/defaults.js";
+import { anchorLabels, anchorPathSegments, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal } from "./feeds/defaults.js";
 import { FeedResult } from "./feeds/types.js";
 import { defaultExtractFn } from "./feeds/extractors.js";
-export { FeedResult, anchorLabels, defaultExtractFn, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal };
+export { FeedResult, anchorLabels, anchorPathSegments, defaultExtractFn, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal };

package/dist/feeds.js

@@ -1,3 +1,3 @@
-import { anchorLabels, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal } from "./feeds/defaults.js";
+import { anchorLabels, anchorPathSegments, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal } from "./feeds/defaults.js";
 import { defaultExtractFn } from "./feeds/extractors.js";
-export { anchorLabels, defaultExtractFn, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal };
+export { anchorLabels, anchorPathSegments, defaultExtractFn, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, defaultPlatformOptions, ignoredUris, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal };

package/dist/utils.d.ts

@@ -1,2 +1,3 @@
+import { Pattern } from "./common/types.js";
 import { anyWordMatchesAnyOf, endsWithAnyOf, includesAnyOf, isAnyOf, isHostOf, isSubdomainOf, omitEmpty } from "./common/utils.js";
-export { anyWordMatchesAnyOf, endsWithAnyOf, includesAnyOf, isAnyOf, isHostOf, isSubdomainOf, omitEmpty };
+export { type Pattern, anyWordMatchesAnyOf, endsWithAnyOf, includesAnyOf, isAnyOf, isHostOf, isSubdomainOf, omitEmpty };

package/package.json

@@ -26,74 +26,32 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./feeds": {
-      "import": {
-        "types": "./dist/feeds.d.ts",
-        "default": "./dist/feeds.js"
-      },
-      "require": {
-        "types": "./dist/feeds.d.cts",
-        "default": "./dist/feeds.cjs"
-      }
+      "types": "./dist/feeds.d.ts",
+      "default": "./dist/feeds.js"
     },
     "./blogrolls": {
-      "import": {
-        "types": "./dist/blogrolls.d.ts",
-        "default": "./dist/blogrolls.js"
-      },
-      "require": {
-        "types": "./dist/blogrolls.d.cts",
-        "default": "./dist/blogrolls.cjs"
-      }
+      "types": "./dist/blogrolls.d.ts",
+      "default": "./dist/blogrolls.js"
     },
     "./favicons": {
-      "import": {
-        "types": "./dist/favicons.d.ts",
-        "default": "./dist/favicons.js"
-      },
-      "require": {
-        "types": "./dist/favicons.d.cts",
-        "default": "./dist/favicons.cjs"
-      }
+      "types": "./dist/favicons.d.ts",
+      "default": "./dist/favicons.js"
     },
     "./hubs": {
-      "import": {
-        "types": "./dist/hubs.d.ts",
-        "default": "./dist/hubs.js"
-      },
-      "require": {
-        "types": "./dist/hubs.d.cts",
-        "default": "./dist/hubs.cjs"
-      }
+      "types": "./dist/hubs.d.ts",
+      "default": "./dist/hubs.js"
     },
     "./methods": {
-      "import": {
-        "types": "./dist/methods.d.ts",
-        "default": "./dist/methods.js"
-      },
-      "require": {
-        "types": "./dist/methods.d.cts",
-        "default": "./dist/methods.cjs"
-      }
+      "types": "./dist/methods.d.ts",
+      "default": "./dist/methods.js"
     },
     "./utils": {
-      "import": {
-        "types": "./dist/utils.d.ts",
-        "default": "./dist/utils.js"
-      },
-      "require": {
-        "types": "./dist/utils.d.cts",
-        "default": "./dist/utils.cjs"
-      }
+      "types": "./dist/utils.d.ts",
+      "default": "./dist/utils.js"
     },
     "./package.json": "./package.json"
   },
@@ -102,20 +60,22 @@
   ],
   "scripts": {
     "prepare": "lefthook install",
-    "build": "tsdown src/exports/index.ts src/exports/feeds.ts src/exports/blogrolls.ts src/exports/favicons.ts src/exports/hubs.ts src/exports/methods.ts src/exports/utils.ts --format cjs,esm --dts --clean --unbundle --no-fixed-extension",
+    "build": "tsdown src/exports/index.ts src/exports/feeds.ts src/exports/blogrolls.ts src/exports/favicons.ts src/exports/hubs.ts src/exports/methods.ts src/exports/utils.ts --format esm --dts --clean --unbundle --no-fixed-extension",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs"
   },
   "dependencies": {
-    "feedsmith": "^2.9.1",
-    "htmlparser2": "^10.1.0",
-    "typescript": "^6.0.2"
+    "htmlparser2": "^12.0.0"
+  },
+  "peerDependencies": {
+    "feedsmith": "^3.0.0-beta.4"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.11",
-    "kvalita": "1.12.4",
-    "tsdown": "^0.21.7",
+    "@types/bun": "^1.3.13",
+    "feedsmith": "^3.0.0-beta.4",
+    "kvalita": "^1.13.0",
+    "tsdown": "^0.22.2",
     "vitepress": "^2.0.0-alpha.17"
   },
-  "version": "1.8.1"
+  "version": "2.0.0-beta.1"
 }

package/dist/blogrolls/defaults.cjs

@@ -1,51 +0,0 @@
-//#region src/blogrolls/defaults.ts
-const mimeTypes = [
-	"text/x-opml",
-	"application/xml",
-	"text/xml"
-];
-const urisMinimal = [
-	"/.well-known/recommendations.opml",
-	"/blogroll.opml",
-	"/opml.xml"
-];
-const urisBalanced = [
-	...urisMinimal,
-	"/blogroll.xml",
-	"/subscriptions.opml",
-	"/recommendations.opml"
-];
-const urisComprehensive = [
-	...urisBalanced,
-	"/links.opml",
-	"/feeds.opml",
-	"/subscriptions.xml"
-];
-const anchorLabels = [
-	"blogroll",
-	"opml",
-	"subscriptions",
-	"reading list"
-];
-const linkSelectors = [{ rel: "blogroll" }, {
-	rel: "outline",
-	types: mimeTypes
-}];
-const defaultHtmlOptions = {
-	linkSelectors,
-	anchorUris: urisComprehensive,
-	anchorIgnoredUris: [],
-	anchorLabels
-};
-const defaultHeadersOptions = { linkSelectors };
-const defaultGuessOptions = { uris: urisBalanced };
-//#endregion
-exports.anchorLabels = anchorLabels;
-exports.defaultGuessOptions = defaultGuessOptions;
-exports.defaultHeadersOptions = defaultHeadersOptions;
-exports.defaultHtmlOptions = defaultHtmlOptions;
-exports.linkSelectors = linkSelectors;
-exports.mimeTypes = mimeTypes;
-exports.urisBalanced = urisBalanced;
-exports.urisComprehensive = urisComprehensive;
-exports.urisMinimal = urisMinimal;

package/dist/blogrolls/defaults.d.cts

@@ -1,17 +0,0 @@
-import { GuessMethodOptions } from "../common/uris/guess/types.cjs";
-import { HeadersMethodOptions } from "../common/uris/headers/types.cjs";
-import { HtmlMethodOptions } from "../common/uris/html/types.cjs";
-import { LinkSelector } from "../common/types.cjs";
-
-//#region src/blogrolls/defaults.d.ts
-declare const mimeTypes: string[];
-declare const urisMinimal: string[];
-declare const urisBalanced: string[];
-declare const urisComprehensive: string[];
-declare const anchorLabels: string[];
-declare const linkSelectors: Array<LinkSelector>;
-declare const defaultHtmlOptions: Omit<HtmlMethodOptions, 'baseUrl'>;
-declare const defaultHeadersOptions: Omit<HeadersMethodOptions, 'baseUrl'>;
-declare const defaultGuessOptions: Omit<GuessMethodOptions, 'baseUrl'>;
-//#endregion
-export { anchorLabels, defaultGuessOptions, defaultHeadersOptions, defaultHtmlOptions, linkSelectors, mimeTypes, urisBalanced, urisComprehensive, urisMinimal };

package/dist/blogrolls/extractors.cjs

@@ -1,21 +0,0 @@
-let feedsmith = require("feedsmith");
-//#region src/blogrolls/extractors.ts
-const defaultExtractFn = ({ content, url }) => {
-	if (!content) return {
-		url,
-		isValid: false
-	};
-	try {
-		return {
-			url,
-			isValid: true,
-			title: (0, feedsmith.parseOpml)(content).head?.title
-		};
-	} catch {}
-	return {
-		url,
-		isValid: false
-	};
-};
-//#endregion
-exports.defaultExtractFn = defaultExtractFn;

package/dist/blogrolls/extractors.d.cts

@@ -1,7 +0,0 @@
-import { DiscoverExtractFn } from "../common/types.cjs";
-import { BlogrollResult } from "./types.cjs";
-
-//#region src/blogrolls/extractors.d.ts
-declare const defaultExtractFn: DiscoverExtractFn<BlogrollResult>;
-//#endregion
-export { defaultExtractFn };