feedkeeper 0.35.6 → 0.35.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feedkeeper",
-  "version": "0.35.6",
+  "version": "0.35.8",
   "description": "A lightweight, self-hosted RSS reader and remote MCP server for your news, blogs, and AI workflows.",
   "keywords": [
     "rss",

package/server/dist/feeds/content/index.js

@@ -3,7 +3,9 @@ import { EMBED_RULES, resolveEmbeds } from "./embeds/index.js";
 import { embedHeadings } from "./embeds/headings.js";
 import { boilerplate } from "./noise/boilerplate.js";
 import { loadingPlaceholders } from "./noise/loading.js";
+import { pageChrome } from "./noise/pageChrome.js";
 import { trackingPixels } from "./noise/pixels.js";
+import { permalinkGlyphs } from "./noise/permalinkGlyphs.js";
 import { sidebars } from "./noise/sidebars.js";
 import { teaserLinks } from "./noise/teaserLinks.js";
 /**
@@ -11,7 +13,7 @@ import { teaserLinks } from "./noise/teaserLinks.js";
  * tags that are removed next), then the clutter around the story. The tests check each rule against its fixtures in
  * `test/fixtures/content/<rule name>` and that running it twice changes nothing. See `docs/content-rules.md`.
  */
-export const PAGE_RULES = [lazyImages, ...EMBED_RULES, embedHeadings, sidebars, loadingPlaceholders, trackingPixels, boilerplate, teaserLinks];
+export const PAGE_RULES = [lazyImages, ...EMBED_RULES, embedHeadings, pageChrome, sidebars, loadingPlaceholders, trackingPixels, boilerplate, teaserLinks, permalinkGlyphs];
 export { resolveEmbeds };
 /** What a fetched page goes through before its scripts, frames and `noscript` blocks are removed. */
 export function cleanPage(root, stats = {}) {

package/server/dist/feeds/content/noise/pageChrome.js

@@ -0,0 +1,38 @@
+import { count, flat, pruneEmpty } from "../shared.js";
+/** A paragraph this long is prose, not a menu entry: an element that holds one is never page chrome, whatever it is called. */
+const PROSE_CHARACTERS = 200;
+/** What only a site's own navigation contains. */
+const NAVIGATION = "nav, [role='navigation'], [role='menubar'], menu";
+/** A page header holds the site's navigation, or even the page's main area; an article's own header holds a headline and a byline. */
+const PAGE_HEADER_PARTS = `${NAVIGATION}, main`;
+function holdsProse(element) {
+    return [...element.querySelectorAll("p")].some(paragraph => flat(paragraph.textContent).length >= PROSE_CHARACTERS);
+}
+/**
+ * Some publishers put their whole page header into the text of an article: a menu of magazines with empty entries
+ * (their icons are drawn by a stylesheet), service links, the logo and lists of the publisher's other pages. A reader
+ * shows all of it before the first line of the story. A header that contains navigation, and any navigation of its own, are
+ * the site and not the story: they go, unless prose sits inside, which means the markup is broken and wraps the article.
+ */
+export const pageChrome = {
+    name: "page-chrome",
+    description: "A page header that holds the site's navigation, and any navigation element, are removed from the text of an article.",
+    apply(root, stats) {
+        let changed = false;
+        const remove = (element) => {
+            if (!element.parentNode || holdsProse(element))
+                return;
+            const parent = element.parentNode;
+            element.remove();
+            pruneEmpty(parent);
+            count(stats, "page-chrome");
+            changed = true;
+        };
+        for (const header of [...root.querySelectorAll("header")].filter(candidate => candidate.querySelector(PAGE_HEADER_PARTS)))
+            remove(header);
+        for (const navigation of [...root.querySelectorAll(NAVIGATION)])
+            remove(navigation);
+        return changed;
+    },
+};
+//# sourceMappingURL=pageChrome.js.map

package/server/dist/feeds/content/noise/permalinkGlyphs.js

@@ -0,0 +1,52 @@
+import { count, flat, pruneEmpty } from "../shared.js";
+/** One to three characters that are neither letters nor digits: "★", "∞", "¶", "#", "↩". Non-breaking spaces around them count as blanks. */
+const GLYPH_ONLY = /^[^\p{L}\p{N}]{1,3}$/u;
+/** Whether any text follows the element in the document: only the tail of a story is looked at. */
+function hasTextAfter(root, element) {
+    const document = root.nodeType === 9 ? root : root.ownerDocument;
+    if (!document)
+        return false;
+    const walker = document.createTreeWalker(root, 4);
+    let reached = false;
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+        if (element.contains(node)) {
+            reached = true;
+            continue;
+        }
+        if (reached && flat(node.textContent) !== "")
+            return true;
+    }
+    return false;
+}
+/**
+ * Some blogs end every post with a permanent link that is only a symbol ("★", "∞", "¶"): a link to the post itself, of no use inside a reader.
+ * The block must hold nothing but that one link, come after the text of the story and have nothing after it. A symbol inside a sentence,
+ * a link with a picture and a block with more text stay.
+ */
+export const permalinkGlyphs = {
+    name: "permalink-glyphs",
+    description: "A block at the end of a story that holds only one link made of a single symbol such as \"★\" or \"¶\" is removed.",
+    apply(root, stats) {
+        let changed = false;
+        const total = flat(root.textContent).length;
+        for (const block of [...root.querySelectorAll("p, div")].reverse()) {
+            if (!root.contains(block) || block.querySelector("p, div, img, picture, video, iframe"))
+                continue;
+            const links = block.querySelectorAll("a[href]");
+            if (links.length !== 1)
+                continue;
+            const text = (block.textContent ?? "").replace(/[\s\u00a0]+/g, "");
+            if (!GLYPH_ONLY.test(text) || flat(links[0].textContent).replace(/[\s\u00a0]+/g, "") !== text)
+                continue;
+            if (total - text.length < 120 || hasTextAfter(root, block))
+                continue;
+            const parent = block.parentNode;
+            block.remove();
+            pruneEmpty(parent);
+            count(stats, "permalink-glyphs");
+            changed = true;
+        }
+        return changed;
+    },
+};
+//# sourceMappingURL=permalinkGlyphs.js.map

package/server/dist/feeds/contentNoise.js

@@ -7,6 +7,8 @@ import { SIDEBAR_HEADINGS } from "./content/patterns/sidebars/index.js";
 import { resolveEmbeds } from "./content/embeds/index.js";
 import { loadingPlaceholders } from "./content/noise/loading.js";
 import { trackingPixels } from "./content/noise/pixels.js";
+import { pageChrome } from "./content/noise/pageChrome.js";
+import { permalinkGlyphs } from "./content/noise/permalinkGlyphs.js";
 import { teaserLinks } from "./content/noise/teaserLinks.js";
 import { markVideoTeasers } from "./content/noise/videoTeasers.js";
 import { flat, pruneEmpty } from "./content/shared.js";
@@ -95,10 +97,14 @@ function removeReaderNoise(root, title, stats, author) {
     // A feed's own text ends with "[mehr]": the link to the article is no part of what is read.
     if (teaserLinks.apply(root, stats))
         changed = true;
+    if (permalinkGlyphs.apply(root, stats))
+        changed = true;
     if (loadingPlaceholders.apply(root, stats))
         changed = true;
     if (trackingPixels.apply(root, stats))
         changed = true;
+    if (pageChrome.apply(root, stats))
+        changed = true;
     for (const selector of BREADCRUMB_MARKERS) {
         try {
             root.querySelectorAll(selector).forEach(element => drop(element, "breadcrumb"));

package/server/dist/feeds/imageSources.js

@@ -42,6 +42,8 @@ export function imageSource(attribute) {
     }
     return null;
 }
+/** The body of a tag up to its closing `>`: a `>` inside a quoted value, as in `media="(resolution >= 3x)"`, does not end it. */
+const TAG_BODY = `(?:[^>"']|"[^"]*"|'[^']*')*`;
 function attribute(tag, name) {
     const match = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i").exec(tag);
     return match ? match[1] ?? match[2] ?? match[3] : null;
@@ -56,14 +58,14 @@ export function normalizeImageSources(html) {
         const withoutSources = tag.replace(/\s+(?:(?:data-(?:lazy-)?)?src(?:set)?|sizes|data-sizes|data-original|data-actualsrc)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'>]+)/gi, "");
         return withoutSources.replace(/\s*\/?>$/, (end) => ` src="${escaped}"${end}`);
     };
-    const pictures = html.replace(/<picture\b[^>]*>[\s\S]*?<\/picture\s*>/gi, (picture) => {
+    const pictures = html.replace(new RegExp(`<picture\\b${TAG_BODY}>[\\s\\S]*?<\\/picture\\s*>`, "gi"), (picture) => {
         let fallback = null;
-        const withoutSources = picture.replace(/<source\b[^>]*>/gi, (tag) => {
+        const withoutSources = picture.replace(new RegExp(`<source\\b${TAG_BODY}>`, "gi"), (tag) => {
             fallback ??= firstSrcsetSource(attribute(tag, "data-lazy-srcset") ?? attribute(tag, "data-srcset") ?? attribute(tag, "srcset"));
             return "";
         });
-        return withoutSources.replace(/<img\b[^>]*>/gi, (tag) => normalize(tag, fallback));
+        return withoutSources.replace(new RegExp(`<img\\b${TAG_BODY}>`, "gi"), (tag) => normalize(tag, fallback));
     });
-    return pictures.replace(/<img\b[^>]*>/gi, (tag) => normalize(tag));
+    return pictures.replace(new RegExp(`<img\\b${TAG_BODY}>`, "gi"), (tag) => normalize(tag));
 }
 //# sourceMappingURL=imageSources.js.map

package/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feedkeeper/server",
-  "version": "0.35.6",
+  "version": "0.35.8",
   "private": true,
   "type": "module"
 }