feedkeeper 0.28.12 → 0.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feedkeeper",
-  "version": "0.28.12",
+  "version": "0.29.0",
   "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/embeds/consent.js

@@ -0,0 +1,88 @@
+import { CONSENT_WRAPPER } from "../patterns/consent/wrappers.js";
+import { count, flat, linkParagraph, pruneEmpty } from "../shared.js";
+import { embedTarget } from "./video.js";
+import { socialFrameTarget } from "./social.js";
+function decodeEmbedText(text) {
+    let decoded = text.replace(/\\+\//g, "/");
+    for (let pass = 0; pass < 2; pass++) {
+        decoded = decoded.replace(/&quot;|&#0?34;/g, '"').replace(/&#0?39;|&#x27;|&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+    }
+    return decoded;
+}
+/** The text of a wrapper as far as the reader can look into it: attributes, scripts and the contents consent plugins keep encoded. */
+function embedSource(wrapper) {
+    let source = wrapper.outerHTML;
+    for (const element of [wrapper, ...wrapper.querySelectorAll("*")]) {
+        for (const attribute of [...element.attributes]) {
+            if (!/^[A-Za-z0-9+/=\s]{80,}$/.test(attribute.value))
+                continue;
+            // Plugins keep the embed as base64 in an attribute of their own choosing; only what decodes to markup or an address counts.
+            const decoded = Buffer.from(attribute.value, "base64").toString("utf8");
+            if (/<[a-z]|https?:\/\//i.test(decoded))
+                source += ` ${decoded}`;
+        }
+    }
+    return decodeEmbedText(source);
+}
+/**
+ * Consent plugins (Embed Privacy, Borlabs, Complianz, Real Cookie Banner, …) replace an embed with a notice and a
+ * switch, and keep the embed itself in a script or an attribute until the reader agrees. A reader has nobody to ask:
+ * the notice and its legal text are noise, while the video behind them is the content. The address is looked up
+ * wherever it is kept; what is found stays as one marked link, a wrapper with nothing behind it goes. The same
+ * wrapper around a plain WordPress embed block (`wp-block-embed`) only matters when an address can be found.
+ */
+function resolveConsentEmbeds(root, stats) {
+    const links = [];
+    let changed = false;
+    for (const wrapper of [...root.querySelectorAll(`${CONSENT_WRAPPER}, figure.wp-block-embed`)]) {
+        if (!root.contains(wrapper))
+            continue;
+        const isConsent = wrapper.matches(CONSENT_WRAPPER);
+        const source = embedSource(wrapper);
+        const addresses = source.match(/(?:https?:)?\/\/[^\s"'<>\\)]+/g) ?? [];
+        let found = null;
+        for (const address of addresses) {
+            const video = embedTarget(address);
+            if (video) {
+                found = { ...video, kind: "video" };
+                break;
+            }
+            const post = socialFrameTarget(address);
+            if (post) {
+                found = { url: post.url, name: post.platform.name, kind: post.platform.kind };
+                break;
+            }
+        }
+        if (!found && !isConsent)
+            continue;
+        // The title of the embed's own iframe names the video; the plugin's notice would only say "external content".
+        const title = flat(/\btitle="([^"]{1,200})"/.exec(source.slice(Math.max(0, source.indexOf("<iframe"))))?.[1] ?? "");
+        const parent = wrapper.parentNode;
+        if (found) {
+            const replacement = linkParagraph(wrapper.ownerDocument, found.url, (source.includes("<iframe") ? title : "") || found.name);
+            wrapper.replaceWith(replacement);
+            links.push({ link: replacement.querySelector("a"), kind: found.kind, source: found.name });
+        }
+        else {
+            wrapper.remove();
+        }
+        pruneEmpty(parent);
+        count(stats, "consent-embed");
+        changed = true;
+    }
+    return { changed, links };
+}
+/** Embeds held back by a consent plugin become a link to the embed, or go. */
+export const consentEmbeds = {
+    name: "consent-embeds",
+    description: "Consent plugins' notices around videos and posts are replaced by one marked link, or removed without an address.",
+    apply(root, stats) {
+        const { changed, links } = resolveConsentEmbeds(root, stats);
+        links.forEach(({ link, kind, source }) => {
+            link.setAttribute("data-media", kind);
+            link.setAttribute("data-source", source);
+        });
+        return changed;
+    },
+};
+//# sourceMappingURL=consent.js.map

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

@@ -0,0 +1,16 @@
+import { consentEmbeds } from "./consent.js";
+import { socialEmbeds } from "./social.js";
+import { videoPlayers } from "./video.js";
+/**
+ * Embeds, in the order they must run: consent plugins first, because the address of the embed sits inside their
+ * notice, then the video players and iframes, then the social posts.
+ */
+export const EMBED_RULES = [consentEmbeds, videoPlayers, socialEmbeds];
+/**
+ * Turns every embed of a page into the marked link a reader shows as a card. A fetched page must go through this
+ * before its scripts, frames and `noscript` blocks are removed: that is where consent plugins and players keep the address.
+ */
+export function resolveEmbeds(root, stats = {}) {
+    return EMBED_RULES.map(rule => rule.apply(root, stats)).some(Boolean);
+}
+//# sourceMappingURL=index.js.map

package/server/dist/feeds/content/embeds/social.js

@@ -0,0 +1,103 @@
+import { MASTODON_EMBED_PATH, SOCIAL_PLATFORMS, SOCIAL_QUOTE } from "../patterns/social-platforms.js";
+import { flat, linkParagraph, parseAddress, pruneEmpty } from "../shared.js";
+/** The platform and the address of the single post an address points at, without tracking parameters. */
+export function socialPost(source) {
+    const address = parseAddress(source.trim());
+    if (!address || !/^https?:$/.test(address.protocol))
+        return null;
+    const host = address.hostname.replace(/^(?:www|m|mobile)\./, "");
+    const platform = SOCIAL_PLATFORMS.find(candidate => candidate.host.test(host));
+    if (!platform || !platform.post.test(`${address.pathname}${address.search}`))
+        return null;
+    const keepsQuery = platform.name === "Facebook";
+    return { platform, url: `${address.origin}${address.pathname.replace(/\/embed\/?$/, "/")}${keepsQuery ? address.search : ""}` };
+}
+/** The post behind an embed iframe, which usually names it in the path or in a parameter. */
+export function socialFrameTarget(source) {
+    const address = parseAddress(source.trim());
+    if (!address)
+        return null;
+    const host = address.hostname.replace(/^www\./, "");
+    const find = (name) => SOCIAL_PLATFORMS.find(platform => platform.name === name);
+    if (host === "platform.twitter.com" && address.searchParams.get("id")) {
+        return { platform: find("X"), url: `https://x.com/i/status/${address.searchParams.get("id")}` };
+    }
+    if (host === "tiktok.com" && /^\/embed\/(?:v\d\/)?(\d+)/.test(address.pathname)) {
+        return { platform: find("TikTok"), url: `https://www.tiktok.com/video/${/(\d+)/.exec(address.pathname)?.[1]}` };
+    }
+    if (host === "open.spotify.com")
+        return socialPost(source.replace("/embed/", "/"));
+    if (host === "w.soundcloud.com") {
+        const inner = address.searchParams.get("url");
+        return inner ? socialPost(inner) : null;
+    }
+    if (host === "facebook.com" && /\/plugins\/(?:post|video)\.php$/.test(address.pathname)) {
+        const inner = address.searchParams.get("href");
+        return inner ? socialPost(inner) : null;
+    }
+    if (MASTODON_EMBED_PATH.test(address.pathname) && /^https?:$/.test(address.protocol)) {
+        return { platform: { name: "Mastodon", host: /.*/, post: MASTODON_EMBED_PATH, kind: "social" }, url: `${address.origin}${address.pathname.replace(/\/embed\/?$/, "")}` };
+    }
+    return socialPost(source);
+}
+function excerpt(element) {
+    const text = flat(element.querySelector("p")?.textContent ?? "");
+    return text.length > 160 ? `${text.slice(0, 157).trimEnd()}…` : text;
+}
+/**
+ * Posts of social platforms arrive as a placeholder (`<blockquote class="instagram-media">`, `twitter-tweet`, …) that the
+ * platform's script fills in, or as an iframe. Without the script the placeholder shows its scaffolding: the platform's
+ * logo as a large picture, empty frames and the bar of a quotation. What can be reached stays as one plain link to the
+ * post (`data-media="social"`, or `"audio"` for music and podcast players, with `data-source` naming the platform) and
+ * what cannot is left out. The post itself is never embedded here: that is for the client to decide.
+ */
+function resolveSocialEmbeds(root, stats) {
+    const links = [];
+    let changed = false;
+    const count = () => { stats["social"] = (stats["social"] ?? 0) + 1; changed = true; };
+    for (const quote of [...root.querySelectorAll(SOCIAL_QUOTE)]) {
+        if (!root.contains(quote))
+            continue;
+        const candidates = [quote.getAttribute("cite") ?? "", ...[...quote.querySelectorAll("a[href]")].map(anchor => anchor.getAttribute("href") ?? "")];
+        // A tweet names its author's profile before the post: the last address that is a post wins.
+        const target = candidates.map(socialPost).filter((found) => found !== null).pop();
+        const parent = quote.parentNode;
+        if (!target) {
+            quote.remove();
+            pruneEmpty(parent);
+            count();
+            continue;
+        }
+        const replacement = linkParagraph(quote.ownerDocument, target.url, excerpt(quote) || target.platform.name);
+        quote.replaceWith(replacement);
+        pruneEmpty(parent);
+        links.push({ link: replacement.querySelector("a"), kind: target.platform.kind, source: target.platform.name });
+        count();
+    }
+    for (const frame of [...root.querySelectorAll("iframe")]) {
+        const target = socialFrameTarget(frame.getAttribute("src") ?? frame.getAttribute("data-src") ?? "");
+        if (!target)
+            continue;
+        const parent = frame.parentNode;
+        const replacement = linkParagraph(frame.ownerDocument, target.url, flat(frame.getAttribute("title")) || target.platform.name);
+        frame.replaceWith(replacement);
+        pruneEmpty(parent);
+        links.push({ link: replacement.querySelector("a"), kind: target.platform.kind, source: target.platform.name });
+        count();
+    }
+    return { changed, links };
+}
+/** Posts of social platforms and audio players become one link to the post. */
+export const socialEmbeds = {
+    name: "social-embeds",
+    description: "Instagram, X, TikTok, Bluesky, Threads, Reddit, Facebook posts and Spotify/SoundCloud players become one marked link.",
+    apply(root, stats) {
+        const { changed, links } = resolveSocialEmbeds(root, stats);
+        links.forEach(({ link, kind, source }) => {
+            link.setAttribute("data-media", kind);
+            link.setAttribute("data-source", source);
+        });
+        return changed;
+    },
+};
+//# sourceMappingURL=social.js.map

package/server/dist/feeds/content/embeds/video.js

@@ -0,0 +1,113 @@
+import { PLAY_LABEL } from "../patterns/play-labels/index.js";
+import { flat, linkParagraph, parseAddress, pruneEmpty } from "../shared.js";
+const PLAY_SOURCE = /(?:^|[/_.-])play[-_]?(?:icon|button|btn)?\.(?:svg|png|webp|gif)(?:[?#]|$)/i;
+const DURATION = /^\d{1,2}:\d{2}(:\d{2})?$/;
+const PLAYER_BLOCK_LIMIT = 120;
+function isPlayOverlay(image) {
+    return PLAY_LABEL.test(flat(image.getAttribute("alt"))) || PLAY_SOURCE.test((image.getAttribute("src") ?? "").trim());
+}
+/** Direct video URL of the embeds that are common enough to be worth a link. Anything else is not turned into a link. */
+export function embedTarget(source) {
+    const parsed = parseAddress(source);
+    if (!parsed)
+        return null;
+    const address = parsed;
+    const host = address.hostname.replace(/^www\./, "");
+    const segments = address.pathname.split("/").filter(Boolean);
+    if (/^youtube(-nocookie)?\.com$/.test(host) && segments[0] === "embed" && /^[\w-]{6,}$/.test(segments[1] ?? "")) {
+        return { url: `https://www.youtube.com/watch?v=${segments[1]}`, name: "YouTube" };
+    }
+    if (/^(?:m\.)?youtube\.com$/.test(host) && segments[0] === "watch" && /^[\w-]{6,}$/.test(address.searchParams.get("v") ?? "")) {
+        return { url: `https://www.youtube.com/watch?v=${address.searchParams.get("v")}`, name: "YouTube" };
+    }
+    if (host === "youtu.be" && /^[\w-]{6,}$/.test(segments[0] ?? "")) {
+        return { url: `https://www.youtube.com/watch?v=${segments[0]}`, name: "YouTube" };
+    }
+    if (host === "player.vimeo.com" && segments[0] === "video" && /^\d+$/.test(segments[1] ?? "")) {
+        return { url: `https://vimeo.com/${segments[1]}`, name: "Vimeo" };
+    }
+    if (host === "dailymotion.com" && segments[0] === "embed" && segments[1] === "video" && /^\w+$/.test(segments[2] ?? "")) {
+        return { url: `https://www.dailymotion.com/video/${segments[2]}`, name: "Dailymotion" };
+    }
+    return null;
+}
+/**
+ * Players need the publisher's script: a reader without it shows their play-button picture as a broken image and
+ * leaves a dead block. What can be reached stays as one plain link to the video (`data-media="video"` tells a client
+ * that the target is a video page); what cannot, because the player is a script-driven button without an address,
+ * is left out. The video itself is never embedded here: that is for the client to decide.
+ */
+function resolveVideoPlayers(root, stats) {
+    const links = [];
+    let changed = false;
+    const count = () => { stats["video"] = (stats["video"] ?? 0) + 1; changed = true; };
+    for (const image of [...root.querySelectorAll("img")].filter(isPlayOverlay)) {
+        if (!root.contains(image))
+            continue;
+        const anchor = image.closest("a[href]");
+        if (anchor) {
+            const parent = anchor.parentNode;
+            image.remove();
+            const href = anchor.getAttribute("href");
+            const scope = anchor.closest("p, div, figure, li") ?? anchor.parentElement;
+            const twin = scope ? [...scope.querySelectorAll("a[href]")].find(other => other !== anchor && other.getAttribute("href") === href) : undefined;
+            const label = flat(anchor.textContent);
+            if (twin) {
+                anchor.remove();
+                pruneEmpty(parent);
+                links.push(twin);
+            }
+            else {
+                if (label === "" || DURATION.test(label))
+                    anchor.textContent = flat(anchor.getAttribute("title")) || "Video";
+                links.push(anchor);
+            }
+            count();
+            continue;
+        }
+        // The player block is the widest wrapper that holds nothing but the label, the picture and no link to follow.
+        let block = image;
+        while (block.parentElement) {
+            const parent = block.parentElement;
+            if (flat(parent.textContent).length > PLAYER_BLOCK_LIMIT || parent.querySelector("a[href]") || parent.querySelectorAll("img").length > 1)
+                break;
+            block = parent;
+        }
+        const parent = block.parentNode;
+        block.remove();
+        pruneEmpty(parent);
+        count();
+    }
+    for (const frame of [...root.querySelectorAll("iframe")]) {
+        const target = embedTarget(frame.getAttribute("src") ?? frame.getAttribute("data-src") ?? "");
+        if (!target)
+            continue;
+        const parent = frame.parentNode;
+        const replacement = linkParagraph(frame.ownerDocument, target.url, flat(frame.getAttribute("title")) || target.name);
+        frame.replaceWith(replacement);
+        pruneEmpty(parent);
+        links.push(replacement.querySelector("a"));
+        count();
+    }
+    for (const video of [...root.querySelectorAll("video")]) {
+        const source = (video.getAttribute("src") ?? video.querySelector("source[src]")?.getAttribute("src") ?? "").trim();
+        if (!/^https?:\/\//i.test(source))
+            continue;
+        const replacement = linkParagraph(video.ownerDocument, source, flat(video.getAttribute("title")) || "Video");
+        video.replaceWith(replacement);
+        links.push(replacement.querySelector("a"));
+        count();
+    }
+    return { changed, links };
+}
+/** Players and video embeds of the common video sites become one link to the video. */
+export const videoPlayers = {
+    name: "video-players",
+    description: "Play-button pictures, players and video iframes become one marked link to the video page.",
+    apply(root, stats) {
+        const { changed, links } = resolveVideoPlayers(root, stats);
+        links.forEach(link => link.setAttribute("data-media", "video"));
+        return changed;
+    },
+};
+//# sourceMappingURL=video.js.map

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

@@ -0,0 +1,14 @@
+import { EMBED_RULES, resolveEmbeds } from "./embeds/index.js";
+import { sidebars } from "./noise/sidebars.js";
+/**
+ * Every rule of the content pipeline, in the order they run on a fetched page: embeds first (their address sits in
+ * 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 = [...EMBED_RULES, sidebars];
+export { resolveEmbeds };
+/** What a fetched page goes through before its scripts, frames and `noscript` blocks are removed. */
+export function cleanPage(root, stats = {}) {
+    return PAGE_RULES.map(rule => rule.apply(root, stats)).some(Boolean);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,67 @@
+import { SIDEBAR_HEADINGS, SIDEBAR_SELECTORS } from "../patterns/sidebars/index.js";
+import { count, flat, pruneEmpty } from "../shared.js";
+const HEADINGS = "h2, h3, h4";
+/** Only the second half of the text can hold a list of other articles: before it, the same title is part of the story. */
+const AFTER_SHARE = 0.5;
+const MIN_LINKS = 2;
+function level(heading) {
+    return Number(heading.tagName.slice(1));
+}
+function textBefore(root, node) {
+    const range = root.ownerDocument?.createRange() ?? root.createRange();
+    range.setStart(root, 0);
+    range.setEndBefore(node);
+    return flat(range.toString()).length;
+}
+/** The elements that follow a heading up to the next heading of the same or a higher level. */
+function sectionOf(heading) {
+    const section = [];
+    for (let sibling = heading.nextElementSibling; sibling; sibling = sibling.nextElementSibling) {
+        if (/^H[1-6]$/.test(sibling.tagName) && level(sibling) <= level(heading))
+            break;
+        section.push(sibling);
+    }
+    return section;
+}
+function removeBlock(element, stats) {
+    const parent = element.parentNode;
+    element.remove();
+    pruneEmpty(parent);
+    count(stats, "sidebar");
+}
+/**
+ * Lists of other articles ("Popular Stories", "Related articles", "Mehr zum Thema") sit inside the article's container
+ * on many sites, so a reader that picks the container takes them along as if they were the story. They go by their
+ * markup, or by a heading that names them, when it stands in the second half of the text and is followed by links.
+ */
+export const sidebars = {
+    name: "sidebars",
+    description: "Lists of recommended, related or popular articles inside the article's container are removed.",
+    apply(root, stats) {
+        let changed = false;
+        for (const selector of SIDEBAR_SELECTORS) {
+            for (const element of [...root.querySelectorAll(selector)]) {
+                if (!root.contains(element))
+                    continue;
+                removeBlock(element, stats);
+                changed = true;
+            }
+        }
+        const total = flat(root.textContent).length;
+        if (total === 0)
+            return changed;
+        for (const heading of [...root.querySelectorAll(HEADINGS)]) {
+            if (!root.contains(heading) || !SIDEBAR_HEADINGS.some(pattern => pattern.test(flat(heading.textContent))))
+                continue;
+            const section = sectionOf(heading);
+            const links = section.reduce((sum, element) => sum + element.querySelectorAll("a[href]").length + (element.matches("a[href]") ? 1 : 0), 0);
+            if (links < MIN_LINKS || textBefore(root, heading) / total < AFTER_SHARE)
+                continue;
+            section.forEach(element => element.remove());
+            removeBlock(heading, stats);
+            changed = true;
+        }
+        return changed;
+    },
+};
+//# sourceMappingURL=sidebars.js.map

package/server/dist/feeds/content/patterns/consent/de.js

@@ -0,0 +1,27 @@
+/**
+ * Consent notices that sit where an embed would be, in German. `anchors` start a notice (a block matching one is
+ * removed), `companions` are the lines of the same notice that follow and go with it. A pattern belongs here only
+ * when more than one site uses the wording; a single word like "Datenschutz" would also hit articles about it.
+ */
+export default {
+    anchors: [
+        /^Empfohlene[rn]? redaktionelle[rn]? Inhalte?\b/i,
+        /^Ein Klick für den Datenschutz$/i,
+        /An dieser Stelle (?:finden Sie|befindet sich) einen? .{0,60}externen? Inhalt/i,
+        /Hier findest du externe Inhalte von/i,
+        /An dieser Stelle findest du einen externen Inhalt/i,
+        /Du kannst ihn dir mit einem Klick anzeigen lassen/i,
+    ],
+    companions: [
+        /\bInhalte? (von \S+ )?erlauben\b/i,
+        /-Inhalte erlauben\b/i,
+        /^Ich bin damit einverstanden, dass mir .+ angezeigt (?:wird|werden)/i,
+        /Erst wenn Sie (?:hier )?klicken, werden .{0,60}nachgeladen/i,
+        /^Externen? Inhalt(?:e)? anzeigen$/i,
+        /^Inhalte? (?:ansehen|anzeigen)$/i,
+        /Personenbezogene Daten können an Drittplattformen/i,
+        /^Link zum .+-Inhalt$/i,
+        /^Mehr dazu in unserer Datenschutzerklärung/i,
+    ],
+};
+//# sourceMappingURL=de.js.map

package/server/dist/feeds/content/patterns/consent/en.js

@@ -0,0 +1,15 @@
+/** Consent notices that sit where an embed would be, in English. See `de.ts` for what the two lists mean. */
+export default {
+    anchors: [
+        /^(?:Recommended|Featured) editorial content$/i,
+        /^External content$/i,
+        /^Content from (?:YouTube|Vimeo|Instagram|X|Twitter|TikTok|Spotify|Facebook)$/i,
+        /^(?:Show|Load|Allow) external content$/i,
+    ],
+    companions: [
+        /^I agree (?:to|that) .{0,80}(?:external|third[- ]party) content/i,
+        /^Personal data (?:may|can) be (?:transmitted|transferred|shared) to third[- ]party/i,
+        /^(?:Show|Load|Allow|Display) content$/i,
+    ],
+};
+//# sourceMappingURL=en.js.map

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

@@ -0,0 +1,10 @@
+import de from "./de.js";
+import en from "./en.js";
+/**
+ * One file per language. A notice is looked for in every language at once, because an article in one language can
+ * sit on a site in another. To add a language, add a file next to these and list it here.
+ */
+const LANGUAGES = [de, en];
+export const CONSENT_ANCHORS = LANGUAGES.flatMap(language => language.anchors);
+export const CONSENT_COMPANIONS = LANGUAGES.flatMap(language => language.companions);
+//# sourceMappingURL=index.js.map

package/server/dist/feeds/content/patterns/consent/wrappers.js

@@ -0,0 +1,4 @@
+/** Wrappers of the consent plugins that hold back an embed until the reader agrees. The embed itself sits inside, escaped. */
+export const CONSENT_WRAPPER = ".embed-privacy-container, [data-embed-provider], .cmplz-blocked-content-container, .borlabs-cookie, " +
+    "[data-borlabs-cookie-content], .rcb-content-blocker, [data-rcb-blocker-id]";
+//# sourceMappingURL=wrappers.js.map

package/server/dist/feeds/content/patterns/play-labels/de.js

@@ -0,0 +1,3 @@
+/** Labels, in German, that a player's play-button picture carries as its alt text. See `en.ts`. */
+export default ["video starten", "video abspielen", "abspielen", "wiedergabe", "wiedergabe starten"];
+//# sourceMappingURL=de.js.map

package/server/dist/feeds/content/patterns/play-labels/en.js

@@ -0,0 +1,6 @@
+/**
+ * Alt texts of play-button pictures. A picture with one of them is the button of a player, not an illustration, and goes
+ * with the player. Whole texts only: a sentence that merely contains "play" is never a label.
+ */
+export default ["play", "play video", "watch", "watch video", "start video"];
+//# sourceMappingURL=en.js.map

package/server/dist/feeds/content/patterns/play-labels/index.js

@@ -0,0 +1,5 @@
+import de from "./de.js";
+import en from "./en.js";
+/** One file per language, searched all at once. To add a language, add a file next to these and list it here. */
+export const PLAY_LABEL = new RegExp(`^(?:${[de, en].flat().map(label => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`, "i");
+//# sourceMappingURL=index.js.map

package/server/dist/feeds/content/patterns/sidebars/de.js

@@ -0,0 +1,5 @@
+/** Headings, in German, that start a list of other articles. See `en.ts` for how they are used. */
+export default [
+    /^(?:Mehr zum Thema|Weitere Artikel|Weitere Meldungen|Ähnliche Artikel|Verwandte Artikel|Auch interessant|Das könnte (?:dich|Sie|euch) (?:auch )?interessieren|Meistgelesen(?:e Artikel)?|Beliebte Artikel|Lesen Sie auch|Lies auch|Empfehlungen)$/i,
+];
+//# sourceMappingURL=de.js.map

package/server/dist/feeds/content/patterns/sidebars/en.js

@@ -0,0 +1,8 @@
+/**
+ * Headings that start a list of other articles. A heading counts only when it is followed by links and stands in the
+ * second half of the text (see `noise/sidebars.ts`), so a section of the story with the same title stays.
+ */
+export default [
+    /^(?:Popular (?:Stories|Articles|Posts)|Most (?:Read|Popular)|Trending(?: Now| Stories)?|Related (?:Articles|Stories|Posts|Reading|Content)|You (?:might|may) also like|More (?:from|stories|articles)\b.*|Read (?:more|next)|Further reading|Top Stories|Recommended(?: for you)?|Latest (?:Stories|News))$/i,
+];
+//# sourceMappingURL=en.js.map

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

@@ -0,0 +1,6 @@
+import de from "./de.js";
+import en from "./en.js";
+/** One file per language, searched all at once. To add a language, add a file next to these and list it here. */
+export const SIDEBAR_HEADINGS = [de, en].flat();
+export { SIDEBAR_SELECTORS } from "./selectors.js";
+//# sourceMappingURL=index.js.map

package/server/dist/feeds/content/patterns/sidebars/selectors.js

@@ -0,0 +1,15 @@
+/**
+ * Blocks that recommend other articles, named by the markup of well-known plugins and sites. They are never part of
+ * the story. Add a selector only when a plugin or theme is widespread or a site's block is specific enough that it
+ * cannot hit an article; a fixture in `test/fixtures/content/sidebars` shows the expected result.
+ */
+export const SIDEBAR_SELECTORS = [
+    // WordPress plugins and themes for related and popular posts.
+    ".yarpp-related", "#jp-relatedposts", ".jp-relatedposts", ".related-posts", ".related_posts", ".relatedposts",
+    ".wp-block-latest-posts", ".post-navigation", ".crp_related",
+    // Sites that mark the block with an analytics label.
+    "[data-track='popular-stories']", "[data-track='related-stories']", "[data-track='related-articles']",
+    // Broadcasters' "this topic in our programme" teasers.
+    ".relatedbroadcast",
+];
+//# sourceMappingURL=selectors.js.map

package/server/dist/feeds/content/patterns/social-platforms.js

@@ -0,0 +1,20 @@
+export const SOCIAL_PLATFORMS = [
+    { name: "Instagram", host: /^instagram\.com$/, post: /^\/(?:[\w.]+\/)?(?:p|reel|reels|tv)\/[\w-]+/, kind: "social" },
+    { name: "X", host: /^(?:twitter|x)\.com$/, post: /^\/(?:i\/|[\w]+\/)(?:web\/)?status\/\d+/, kind: "social" },
+    { name: "TikTok", host: /^tiktok\.com$/, post: /\/(?:video|photo)\/\d+/, kind: "social" },
+    { name: "Bluesky", host: /^bsky\.app$/, post: /^\/profile\/[^/]+\/post\/[\w]+/, kind: "social" },
+    { name: "Threads", host: /^threads\.(?:net|com)$/, post: /^\/@[\w.]+\/post\/[\w-]+/, kind: "social" },
+    { name: "Reddit", host: /^reddit\.com$/, post: /^\/r\/\w+\/comments\//, kind: "social" },
+    { name: "Facebook", host: /^facebook\.com$/, post: /\/(?:posts|videos|photos|permalink|watch|reel|share)\b|[?&](?:story_fbid|v)=/, kind: "social" },
+    { name: "Spotify", host: /^open\.spotify\.com$/, post: /^\/(?:track|album|playlist|episode|show|artist)\/\w+/, kind: "audio" },
+    { name: "SoundCloud", host: /^soundcloud\.com$/, post: /^\/[^/]+\/[^/]+/, kind: "audio" },
+];
+/** Classes of the blockquote placeholders that the platforms' scripts turn into the real post. */
+export const SOCIAL_QUOTE = "blockquote.instagram-media, blockquote.twitter-tweet, blockquote.tiktok-embed, blockquote.bluesky-embed, " +
+    "blockquote.reddit-embed-bq, blockquote.text-post-media, blockquote.fb-xfbml-parse-ignore";
+/**
+ * Mastodon has no fixed host: any instance embeds a post as an iframe whose address ends in `/@user/<id>/embed`. The
+ * path alone identifies it, so it is matched on every host, for frames only.
+ */
+export const MASTODON_EMBED_PATH = /^\/@[\w.]+\/\d{5,}\/embed\/?$/;
+//# sourceMappingURL=social-platforms.js.map

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

@@ -0,0 +1,35 @@
+export function flat(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}
+/** Takes away what is left empty once an element is gone, up to (not including) the fragment itself. */
+export function pruneEmpty(node) {
+    while (node && node.parentNode && node.nodeType === 1) {
+        const element = node;
+        if (flat(element.textContent) !== "" || element.querySelector("img, picture, video, iframe, a[href]"))
+            return;
+        const parent = element.parentNode;
+        element.remove();
+        node = parent;
+    }
+}
+/** A paragraph holding one plain link: what an embed becomes. Clients turn marked links into cards. */
+export function linkParagraph(document, url, text) {
+    const paragraph = document.createElement("p");
+    const link = document.createElement("a");
+    link.setAttribute("href", url);
+    link.textContent = text;
+    paragraph.append(link);
+    return paragraph;
+}
+export function parseAddress(source) {
+    try {
+        return new URL(source.startsWith("//") ? `https:${source}` : source);
+    }
+    catch {
+        return null;
+    }
+}
+export function count(stats, name) {
+    stats[name] = (stats[name] ?? 0) + 1;
+}
+//# sourceMappingURL=shared.js.map