feedsweep 1.0.0 → 1.1.0

package/dist/transforms/dom/resolveRelativeUrls.js

@@ -1,40 +1,54 @@
 import { resolveUrl } from "feedcanon";
 import { parseSrcset, stringifySrcset } from "srcset";
 //#region src/transforms/dom/resolveRelativeUrls.ts
+const absoluteOrOpaqueUrl = /^(?:https?:|data:|mailto:|tel:|javascript:)/i;
+const srcsetSeparator = /,\s+/;
 const resolveRelativeUrls = ({ baseUrl }) => {
 	return (document) => {
 		if (!baseUrl) return;
-		const anchors = document.querySelectorAll("a[href]");
-		for (const anchor of anchors) {
-			const href = anchor.getAttribute("href");
-			if (!href) continue;
-			const resolved = resolveUrl(href, baseUrl);
-			if (resolved) anchor.setAttribute("href", resolved);
-		}
-		const elementsWithSrc = document.querySelectorAll("[src]");
-		for (const element of elementsWithSrc) {
-			const src = element.getAttribute("src");
-			if (!src) continue;
-			const resolved = resolveUrl(src, baseUrl);
-			if (resolved) element.setAttribute("src", resolved);
-		}
-		const videos = document.querySelectorAll("video[poster]");
-		for (const video of videos) {
-			const poster = video.getAttribute("poster");
-			if (!poster) continue;
-			const resolved = resolveUrl(poster, baseUrl);
-			if (resolved) video.setAttribute("poster", resolved);
-		}
-		const elements = document.querySelectorAll("img, source");
+		const elements = document.querySelectorAll("a[href], [src], video[poster], img[srcset], source[srcset]");
 		for (const element of elements) {
-			const srcset = element.getAttribute("srcset") ?? element.getAttribute("srcSet");
-			if (!srcset) continue;
-			const resolved = parseSrcset(srcset).map((entry) => ({
-				...entry,
-				url: resolveUrl(entry.url, baseUrl) ?? entry.url
-			}));
-			element.removeAttribute("srcSet");
-			element.setAttribute("srcset", stringifySrcset(resolved));
+			const localName = element.localName;
+			if (localName === "a") {
+				const href = element.getAttribute("href");
+				if (href && !href.startsWith("#") && !absoluteOrOpaqueUrl.test(href)) {
+					const resolved = resolveUrl(href, baseUrl);
+					if (resolved) element.setAttribute("href", resolved);
+				}
+			}
+			const src = element.getAttribute("src");
+			if (src && !absoluteOrOpaqueUrl.test(src)) {
+				const resolved = resolveUrl(src, baseUrl);
+				if (resolved) element.setAttribute("src", resolved);
+			}
+			if (localName === "video") {
+				const poster = element.getAttribute("poster");
+				if (poster && !absoluteOrOpaqueUrl.test(poster)) {
+					const resolved = resolveUrl(poster, baseUrl);
+					if (resolved) element.setAttribute("poster", resolved);
+				}
+			}
+			if (localName === "img" || localName === "source") {
+				const srcset = element.getAttribute("srcset");
+				if (srcset) {
+					let needsResolution = false;
+					const candidates = srcset.split(srcsetSeparator);
+					for (const candidate of candidates) {
+						const trimmed = candidate.trimStart();
+						if (trimmed && !absoluteOrOpaqueUrl.test(trimmed)) {
+							needsResolution = true;
+							break;
+						}
+					}
+					if (needsResolution) {
+						const resolved = parseSrcset(srcset).map((entry) => ({
+							...entry,
+							url: resolveUrl(entry.url, baseUrl) ?? entry.url
+						}));
+						element.setAttribute("srcset", stringifySrcset(resolved));
+					}
+				}
+			}
 		}
 	};
 };

package/dist/transforms/dom/stripComments.js

@@ -1,22 +1,12 @@
-import { Node } from "../../common.js";
+import { NodeFilter, hasAncestorWithTagName } from "../../common.js";
 //#region src/transforms/dom/stripComments.ts
 const codeBlockTags = new Set(["pre", "code"]);
 const stripComments = () => {
 	return (document) => {
-		const visit = (node, inCodeBlock) => {
-			const children = Array.from(node.childNodes);
-			for (const child of children) {
-				if (child.nodeType === Node.COMMENT_NODE) {
-					if (!inCodeBlock) child.remove();
-					continue;
-				}
-				if (child.nodeType === Node.ELEMENT_NODE) {
-					const element = child;
-					visit(element, inCodeBlock || codeBlockTags.has(element.tagName.toLowerCase()));
-				}
-			}
-		};
-		visit(document.body, false);
+		const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT);
+		const comments = [];
+		for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) comments.push(node);
+		for (const comment of comments) if (!hasAncestorWithTagName(comment, codeBlockTags, document.body)) comment.remove();
 	};
 };
 //#endregion

package/dist/transforms/dom/stripDeadAnchors.d.ts

@@ -0,0 +1,6 @@
+import { DomTransform } from "../../types.js";
+
+//#region src/transforms/dom/stripDeadAnchors.d.ts
+declare const stripDeadAnchors: DomTransform;
+//#endregion
+export { stripDeadAnchors };

package/dist/transforms/dom/stripDeadAnchors.js

@@ -0,0 +1,20 @@
+//#region src/transforms/dom/stripDeadAnchors.ts
+const javascriptSchemeRegex = /^javascript:/i;
+const stripDeadAnchors = () => {
+	return (document) => {
+		const anchors = document.querySelectorAll("a");
+		for (const anchor of anchors) {
+			const href = anchor.getAttribute("href");
+			if (href === null) continue;
+			const trimmed = href.trim();
+			if (!(trimmed === "" || trimmed === "#" || javascriptSchemeRegex.test(trimmed))) continue;
+			if (anchor.hasAttribute("id") || anchor.hasAttribute("name")) continue;
+			const parent = anchor.parentNode;
+			if (!parent) continue;
+			while (anchor.firstChild) parent.insertBefore(anchor.firstChild, anchor);
+			anchor.remove();
+		}
+	};
+};
+//#endregion
+export { stripDeadAnchors };

package/dist/transforms/dom/stripDuplicateTitleHeading.d.ts

@@ -0,0 +1,6 @@
+import { DomTransform } from "../../types.js";
+
+//#region src/transforms/dom/stripDuplicateTitleHeading.d.ts
+declare const stripDuplicateTitleHeading: DomTransform;
+//#endregion
+export { stripDuplicateTitleHeading };

package/dist/transforms/dom/stripDuplicateTitleHeading.js

@@ -0,0 +1,31 @@
+//#region src/transforms/dom/stripDuplicateTitleHeading.ts
+const headingSelector = "h1, h2, h3, h4, h5, h6";
+const mediaSelector = "img, picture, video, audio, iframe, svg";
+const normalize = (value) => value.trim().toLowerCase().replace(/\s+/g, " ");
+const stripDuplicateTitleHeading = (context) => {
+	const articleTitle = context.articleTitle;
+	const title = articleTitle && articleTitle.trim().length > 0 ? normalize(articleTitle) : "";
+	if (!title) return () => {};
+	return (document) => {
+		let heading = document.querySelector(headingSelector);
+		let text = heading?.textContent?.trim() ?? "";
+		if (heading && text.length === 0) {
+			heading = null;
+			for (const candidate of document.querySelectorAll(headingSelector)) {
+				const candidateText = candidate.textContent?.trim() ?? "";
+				if (candidateText.length > 0) {
+					heading = candidate;
+					text = candidateText;
+					break;
+				}
+			}
+		}
+		if (!heading) return;
+		if (text.toLowerCase().replace(/\s+/g, " ") !== title) return;
+		if (heading.querySelector(headingSelector)) return;
+		if (heading.querySelector(mediaSelector)) return;
+		heading.remove();
+	};
+};
+//#endregion
+export { stripDuplicateTitleHeading };

package/dist/transforms/dom/stripEmptyTags.d.ts

@@ -0,0 +1,6 @@
+import { DomTransform } from "../../types.js";
+
+//#region src/transforms/dom/stripEmptyTags.d.ts
+declare const stripEmptyTags: DomTransform;
+//#endregion
+export { stripEmptyTags };

package/dist/transforms/dom/stripEmptyTags.js

@@ -0,0 +1,53 @@
+import { Node } from "../../common.js";
+//#region src/transforms/dom/stripEmptyTags.ts
+const preserveWhenEmpty = new Set([
+	"iframe",
+	"video",
+	"audio",
+	"img",
+	"source",
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"track",
+	"wbr"
+]);
+const stripEmptyTags = () => {
+	return (document) => {
+		const all = document.body.querySelectorAll("*");
+		for (let i = all.length - 1; i >= 0; i--) {
+			const element = all[i];
+			if (!element.parentNode) continue;
+			const tagName = element.localName;
+			if (preserveWhenEmpty.has(tagName)) continue;
+			if (tagName.includes("-")) continue;
+			const childNodes = element.childNodes;
+			const childCount = childNodes.length;
+			let hasContent = false;
+			for (let j = 0; j < childCount; j++) {
+				const child = childNodes[j];
+				const nodeType = child.nodeType;
+				if (nodeType === Node.ELEMENT_NODE) {
+					hasContent = true;
+					break;
+				}
+				if (nodeType === Node.TEXT_NODE && child.data.trim().length > 0) {
+					hasContent = true;
+					break;
+				}
+			}
+			if (hasContent) continue;
+			if (childCount > 0) element.replaceWith(" ");
+			else element.remove();
+		}
+	};
+};
+//#endregion
+export { stripEmptyTags };

package/dist/transforms/dom/stripInterBlockBreaks.js

@@ -1,16 +1,36 @@
-import { isBlockElement, isSkippable } from "../../common.js";
+import { isBlockElement, isBr, isSkippable } from "../../common.js";
 //#region src/transforms/dom/stripInterBlockBreaks.ts
 const stripInterBlockBreaks = () => {
 	return (document) => {
 		const brs = document.querySelectorAll("br");
+		const parents = /* @__PURE__ */ new Set();
 		for (const br of brs) {
-			let previous = br.previousSibling;
-			while (previous && isSkippable(previous)) previous = previous.previousSibling;
-			let next = br.nextSibling;
-			while (next && isSkippable(next)) next = next.nextSibling;
-			const previousIsBlock = !previous || isBlockElement(previous);
-			const nextIsBlock = !next || isBlockElement(next);
-			if (previousIsBlock && nextIsBlock) br.remove();
+			const parent = br.parentNode;
+			if (parent) parents.add(parent);
+		}
+		for (const parent of parents) {
+			let runBrs = null;
+			let previousBoundary = null;
+			let child = parent.firstChild;
+			while (child !== null) {
+				const nextChild = child.nextSibling;
+				if (isSkippable(child)) {
+					if (isBr(child)) if (runBrs === null) runBrs = [child];
+					else runBrs.push(child);
+				} else {
+					if (runBrs !== null) {
+						const previousIsBlock = !previousBoundary || isBlockElement(previousBoundary);
+						const nextIsBlock = isBlockElement(child);
+						if (previousIsBlock && nextIsBlock) for (const br of runBrs) br.remove();
+						runBrs = null;
+					}
+					previousBoundary = child;
+				}
+				child = nextChild;
+			}
+			if (runBrs !== null) {
+				if (!previousBoundary || isBlockElement(previousBoundary)) for (const br of runBrs) br.remove();
+			}
 		}
 	};
 };

package/dist/transforms/dom/stripParagraphBoundaryBreaks.js

@@ -4,20 +4,40 @@ const stripParagraphBoundaryBreaks = () => {
 	return (document) => {
 		const paragraphs = document.querySelectorAll("p");
 		for (const paragraph of paragraphs) {
-			const leading = [];
 			let cursor = paragraph.firstChild;
+			let leadingHasBr = false;
+			let leadingEnd = null;
 			while (cursor && isSkippable(cursor)) {
-				leading.push(cursor);
+				if (!leadingHasBr && isBr(cursor)) leadingHasBr = true;
+				leadingEnd = cursor;
 				cursor = cursor.nextSibling;
 			}
-			if (leading.some(isBr)) for (const node of leading) node.remove();
-			const trailing = [];
+			if (leadingHasBr) {
+				let node = paragraph.firstChild;
+				while (node) {
+					const next = node.nextSibling;
+					node.remove();
+					if (node === leadingEnd) break;
+					node = next;
+				}
+			}
 			cursor = paragraph.lastChild;
+			let trailingHasBr = false;
+			let trailingEnd = null;
 			while (cursor && isSkippable(cursor)) {
-				trailing.push(cursor);
+				if (!trailingHasBr && isBr(cursor)) trailingHasBr = true;
+				trailingEnd = cursor;
 				cursor = cursor.previousSibling;
 			}
-			if (trailing.some(isBr)) for (const node of trailing) node.remove();
+			if (trailingHasBr) {
+				let node = paragraph.lastChild;
+				while (node) {
+					const prev = node.previousSibling;
+					node.remove();
+					if (node === trailingEnd) break;
+					node = prev;
+				}
+			}
 		}
 	};
 };

package/dist/transforms/dom/stripTrackingParams.js

@@ -1,19 +1,20 @@
 import { defaultStrippedParams } from "feedcanon";
 //#region src/transforms/dom/stripTrackingParams.ts
+const strippedParamSet = new Set(defaultStrippedParams);
 const stripTrackingParams = () => {
 	return (document) => {
 		const anchors = document.querySelectorAll("a[href]");
 		for (const anchor of anchors) {
 			const href = anchor.getAttribute("href");
-			if (!href) continue;
+			if (!href || href.indexOf("?") === -1) continue;
 			try {
 				const url = new URL(href);
-				let changed = false;
-				for (const param of defaultStrippedParams) if (url.searchParams.has(param)) {
-					url.searchParams.delete(param);
-					changed = true;
+				const toDelete = [];
+				for (const key of url.searchParams.keys()) if (strippedParamSet.has(key)) toDelete.push(key);
+				if (toDelete.length > 0) {
+					for (const key of toDelete) url.searchParams.delete(key);
+					anchor.setAttribute("href", url.toString());
 				}
-				if (changed) anchor.setAttribute("href", url.toString());
 			} catch {}
 		}
 	};

package/dist/transforms/dom/trimPreWhitespace.js

@@ -7,12 +7,13 @@ const trimPreWhitespace = () => {
 		const pres = document.querySelectorAll("pre");
 		for (const pre of pres) {
 			const target = pre.querySelector("code") ?? pre;
-			const trimmed = target.innerHTML.replace(trailingWhitespaceRegex, "").replace(leadingBlankLinesRegex, "");
+			const original = target.innerHTML;
+			const trimmed = original.replace(trailingWhitespaceRegex, "").replace(leadingBlankLinesRegex, "");
 			const lines = trimmed.split("\n");
 			const indents = lines.filter((line) => line.trim().length > 0).map((line) => line.match(leadingIndentRegex)?.[1].length ?? 0);
 			const common = Math.min(...indents);
-			if (common > 0) target.innerHTML = lines.map((line) => line.slice(common)).join("\n");
-			else target.innerHTML = trimmed;
+			const result = common > 0 ? lines.map((line) => line.slice(common)).join("\n") : trimmed;
+			if (result !== original) target.innerHTML = result;
 		}
 	};
 };

package/dist/transforms/dom/unwrapDoublyNestedLists.d.ts

@@ -0,0 +1,6 @@
+import { DomTransform } from "../../types.js";
+
+//#region src/transforms/dom/unwrapDoublyNestedLists.d.ts
+declare const unwrapDoublyNestedLists: DomTransform;
+//#endregion
+export { unwrapDoublyNestedLists };

package/dist/transforms/dom/unwrapDoublyNestedLists.js

@@ -0,0 +1,41 @@
+import { Node } from "../../common.js";
+//#region src/transforms/dom/unwrapDoublyNestedLists.ts
+const unwrapDoublyNestedLists = () => {
+	return (document) => {
+		const lists = document.querySelectorAll("ul, ol");
+		for (const outer of lists) {
+			const wrapper = outer.firstElementChild;
+			if (wrapper === null || wrapper.nextElementSibling !== null) continue;
+			if (wrapper.localName !== "li") continue;
+			const outerTag = outer.localName;
+			let inner = null;
+			let elementDisqualified = false;
+			for (let element = wrapper.firstElementChild; element !== null; element = element.nextElementSibling) {
+				const localName = element.localName;
+				if (localName === "br") continue;
+				if (inner !== null || localName !== outerTag) {
+					elementDisqualified = true;
+					break;
+				}
+				inner = element;
+			}
+			if (elementDisqualified || inner === null) continue;
+			let textDisqualified = false;
+			for (let node = wrapper.firstChild; node !== null; node = node.nextSibling) if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim()) {
+				textDisqualified = true;
+				break;
+			}
+			if (textDisqualified) continue;
+			const parent = outer.parentNode;
+			if (parent === null) continue;
+			for (let node = wrapper.firstChild; node !== null;) {
+				const next = node.nextSibling;
+				if (node.nodeType === Node.TEXT_NODE || node === inner) parent.insertBefore(node, outer);
+				node = next;
+			}
+			outer.remove();
+		}
+	};
+};
+//#endregion
+export { unwrapDoublyNestedLists };

package/dist/transforms/dom/unwrapRedirectUrls.js

@@ -8,13 +8,15 @@ const extractRedirectTarget = (url, extractors) => {
 const unwrapRedirectUrls = (context) => {
 	return (document) => {
 		const anchors = document.querySelectorAll("a[href]");
+		const unwrappers = context.urlUnwrappers;
+		if (unwrappers.length === 0) return;
 		for (const anchor of anchors) {
 			const href = anchor.getAttribute("href");
 			if (!href) continue;
 			try {
 				const url = new URL(href);
-				for (const extractor of context.urlUnwrappers) {
-					const target = extractor(url);
+				for (const unwrap of unwrappers) {
+					const target = unwrap(url);
 					if (target) {
 						anchor.setAttribute("href", target);
 						break;

package/dist/transforms/dom/unwrapWrappers.d.ts

@@ -0,0 +1,6 @@
+import { DomTransform } from "../../types.js";
+
+//#region src/transforms/dom/unwrapWrappers.d.ts
+declare const unwrapWrappers: DomTransform;
+//#endregion
+export { unwrapWrappers };

package/dist/transforms/dom/unwrapWrappers.js

@@ -0,0 +1,30 @@
+//#region src/transforms/dom/unwrapWrappers.ts
+const wrapperTags = new Set([
+	"div",
+	"article",
+	"section",
+	"main",
+	"header",
+	"footer"
+]);
+const hasEmbedAttribute = (element) => {
+	const attributes = element.attributes;
+	for (let i = 0, n = attributes.length; i < n; i++) if (attributes[i].name.startsWith("data-embed")) return true;
+	return false;
+};
+const unwrapWrappers = () => {
+	return (document) => {
+		const candidates = document.body.querySelectorAll("*");
+		for (let i = 0, n = candidates.length; i < n; i++) {
+			const element = candidates[i];
+			if (!wrapperTags.has(element.localName)) continue;
+			const parent = element.parentNode;
+			if (!parent) continue;
+			if (hasEmbedAttribute(element)) continue;
+			while (element.firstChild) parent.insertBefore(element.firstChild, element);
+			element.remove();
+		}
+	};
+};
+//#endregion
+export { unwrapWrappers };

package/dist/transforms/string/paragraphizePlainText.js

@@ -1,6 +1,6 @@
 import { autop } from "@wordpress/autop";
 //#region src/transforms/string/paragraphizePlainText.ts
-const hasHtmlRegex = /<[a-z][a-z0-9]*[\s>]/i;
+const hasHtmlRegex = /<[a-z][a-z0-9]*[\s/>]/i;
 const paragraphizePlainText = () => {
 	return (html) => {
 		return hasHtmlRegex.test(html) ? html : autop(html);

package/dist/transforms/string/unwrapCdataComments.d.ts

@@ -0,0 +1,6 @@
+import { StringTransform } from "../../types.js";
+
+//#region src/transforms/string/unwrapCdataComments.d.ts
+declare const unwrapCdataComments: StringTransform;
+//#endregion
+export { unwrapCdataComments };

package/dist/transforms/string/unwrapCdataComments.js

@@ -0,0 +1,10 @@
+//#region src/transforms/string/unwrapCdataComments.ts
+const cdataWrapperRegex = /<!--\s*\[CDATA\[([\s\S]*?)\]\]\s*-->/g;
+const unwrapCdataComments = () => {
+	return (html) => {
+		if (!html.includes("[CDATA[")) return html;
+		return html.replace(cdataWrapperRegex, (_match, inner) => inner);
+	};
+};
+//#endregion
+export { unwrapCdataComments };

package/dist/types.d.ts

@@ -1,52 +1,81 @@
 import { DiscoverResolveUrlFn } from "feedscout";
 
 //#region src/types.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type EnclosureThumbnail = {
+  url: string;
+  width?: number;
+  height?: number;
+};
 type Enclosure = {
   url: string;
   type?: string;
   medium?: string;
+  width?: number;
+  height?: number;
+  duration?: number;
+  title?: string;
+  description?: string;
+  thumbnails?: Array<EnclosureThumbnail>;
 };
 type ResolveUrlFn = DiscoverResolveUrlFn;
 type EmbedResolverResult = {
   provider: string;
+  id?: string;
   src: string;
   url?: string;
   thumbnail?: string;
-  type?: 'video' | 'audio' | 'iframe';
   width?: number;
   height?: number;
+  title?: string;
+  description?: string;
   author?: string;
-  text?: string;
+  avatar?: string;
+  duration?: number;
 };
+type EnrichEmbedFn = (embeds: Array<{
+  provider: string;
+  id: string;
+}>) => MaybePromise<Map<string, Partial<EmbedResolverResult>>>;
 type EmbedResolver = {
   selector: string;
-  extract: (element: Element) => EmbedResolverResult | undefined;
+  extract: (element: Element) => MaybePromise<EmbedResolverResult | undefined>;
 };
 type UrlUnwrapper = (url: URL) => string | undefined;
+type AssetType = 'image' | 'video' | 'audio';
+type AssetProxyFn = (url: string, type: AssetType) => string | undefined;
 type TransformContext = {
   baseUrl?: string;
   enclosures?: Array<Enclosure>;
   embedResolvers: Array<EmbedResolver>;
   lazySrcAttributes: Array<string>;
+  lazySrcsetAttributes: Array<string>;
   trackingHosts: Array<string>;
   trackingPathSegments: Array<string>;
   urlUnwrappers: Array<UrlUnwrapper>;
   resolveUrlFn: ResolveUrlFn;
+  assetProxyFn?: AssetProxyFn;
+  enrichEmbedFn?: EnrichEmbedFn;
+  articleTitle?: string;
 };
-type DomTransform = (context: TransformContext) => (document: Document) => void;
-type StringTransform = (context: TransformContext) => (html: string) => string;
+type DomTransform = (context: TransformContext) => (document: Document) => MaybePromise<void>;
+type StringTransform = (context: TransformContext) => (html: string) => MaybePromise<string>;
 type TransformContentOptions = {
   baseUrl?: string;
   enclosures?: Array<Enclosure>;
   embedResolvers?: Array<EmbedResolver>;
   lazySrcAttributes?: Array<string>;
+  lazySrcsetAttributes?: Array<string>;
   trackingHosts?: Array<string>;
   trackingPathSegments?: Array<string>;
   urlUnwrappers?: Array<UrlUnwrapper>;
   resolveUrlFn?: ResolveUrlFn;
+  assetProxyFn?: AssetProxyFn;
+  enrichEmbedFn?: EnrichEmbedFn;
+  articleTitle?: string;
   stringTransforms?: Array<StringTransform>;
   domTransforms?: Array<DomTransform>;
   finalStringTransforms?: Array<StringTransform>;
 };
 //#endregion
-export { DomTransform, EmbedResolver, EmbedResolverResult, Enclosure, ResolveUrlFn, StringTransform, TransformContentOptions, TransformContext, UrlUnwrapper };
+export { AssetProxyFn, AssetType, DomTransform, EmbedResolver, EmbedResolverResult, Enclosure, EnrichEmbedFn, MaybePromise, ResolveUrlFn, StringTransform, TransformContentOptions, TransformContext, UrlUnwrapper };

package/dist/unwraps/google.js

@@ -1,6 +1,6 @@
 import { createParamExtractor } from "../utils.js";
 const unwrapGoogle = createParamExtractor({
-	hosts: /^(?:www\.)?google\.(?:com|[a-z]{2,3}(?:\.[a-z]{2,3})?)$/,
+	hosts: /^(?:[a-z0-9-]+\.)*google\.(?:com|[a-z]{2,3}(?:\.[a-z]{2,3})?)$/,
 	path: "/url",
 	params: ["url", "q"]
 });

package/dist/unwraps/googleNewsModern.js

@@ -1,11 +1,15 @@
 import { isHostOf } from "feedscout/utils";
 //#region src/unwraps/googleNewsModern.ts
+const articleIdRegex = /^\/(?:rss\/)?articles\/([\w-]+)/;
+const base64UrlMinusRegex = /-/g;
+const base64UrlUnderscoreRegex = /_/g;
+const protobufFramingRegex = /\x08\x13".+?(https?:\/\/[^\xd2]+)\xd2\x01/;
 const unwrapGoogleNewsModern = (url) => {
 	if (!isHostOf(url.href, "news.google.com")) return;
-	const match = url.pathname.match(/^\/(?:rss\/)?articles\/([\w-]+)/);
+	const match = url.pathname.match(articleIdRegex);
 	if (!match) return;
-	const padded = match[1].replace(/-/g, "+").replace(/_/g, "/");
-	return Buffer.from(padded, "base64").toString("latin1").match(/\x08\x13".+?(https?:\/\/[^\xd2]+)\xd2\x01/)?.[1];
+	const padded = match[1].replace(base64UrlMinusRegex, "+").replace(base64UrlUnderscoreRegex, "/");
+	return Buffer.from(padded, "base64").toString("latin1").match(protobufFramingRegex)?.[1];
 };
 //#endregion
 export { unwrapGoogleNewsModern };

package/package.json

@@ -39,7 +39,7 @@
     "build": "tsdown src/index.ts src/defaults.ts --format esm --dts --clean --unbundle --no-fixed-extension"
   },
   "dependencies": {
-    "@wordpress/autop": "^4.45.0",
+    "@wordpress/autop": "^4.46.0",
     "highlight.js": "^11.11.1",
     "linkedom": "^0.18.12",
     "linkifyjs": "^4.3.2",
@@ -54,5 +54,5 @@
     "kvalita": "^1.13.0",
     "tsdown": "^0.22.0"
   },
-  "version": "1.0.0"
+  "version": "1.1.0"
 }