defuddle-js 0.1.0

package/dist/defuddle.umd.js

@@ -0,0 +1,1968 @@
+var DefuddleLib = (() => {
+  var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    Defuddle: () => Defuddle,
+    DefuddleResult: () => DefuddleResult
+  });
+
+  // src/schema-org.js
+  function extractSchemaOrg(doc) {
+    const scripts = doc.querySelectorAll('script[type="application/ld+json"]');
+    if (!scripts.length) return null;
+    const items = [];
+    for (const script of scripts) {
+      const content = script.textContent || "";
+      if (!content.trim()) continue;
+      const parsed = parseJsonLd(content);
+      if (!parsed) continue;
+      if (parsed["@graph"] && Array.isArray(parsed["@graph"])) {
+        parsed["@graph"].forEach((item) => items.push(decodeStrings(item)));
+      } else if (Array.isArray(parsed)) {
+        parsed.forEach((item) => items.push(decodeStrings(item)));
+      } else {
+        items.push(decodeStrings(parsed));
+      }
+    }
+    return items.length > 0 ? items : null;
+  }
+  function parseJsonLd(content) {
+    content = content.replace(/\/\*[\s\S]*?\*\//g, "");
+    content = content.replace(/^\s*\/\/.*$/gm, "");
+    content = content.replace(/^\s*\/\/<!\[CDATA\[|\]\]>\/\/\s*$/gm, "");
+    content = content.replace(/^\s*<!\[CDATA\[([\s\S]*?)\]\]>\s*$/, "$1");
+    content = content.trim();
+    if (!content) return null;
+    try {
+      return JSON.parse(content);
+    } catch (e) {
+      return null;
+    }
+  }
+  function decodeStrings(item) {
+    if (typeof item === "string") {
+      return item.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+    }
+    if (Array.isArray(item)) return item.map(decodeStrings);
+    if (item && typeof item === "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(item)) {
+        result[key] = decodeStrings(val);
+      }
+      return result;
+    }
+    return item;
+  }
+  function getSchemaProperty(items, types, property) {
+    if (!items) return null;
+    for (const item of items) {
+      if (!item || typeof item !== "object") continue;
+      const itemType = item["@type"] || "";
+      if (types.length > 0 && !types.includes(itemType) && itemType !== "") continue;
+      const val = item[property];
+      if (val !== void 0 && val !== null && val !== "") return val;
+    }
+    return null;
+  }
+
+  // src/url-resolver.js
+  function resolveUrls(root, doc, url) {
+    if (!url) return;
+    let baseUrl = url;
+    const baseEl = doc.querySelector("base[href]");
+    if (baseEl) {
+      const baseHref = baseEl.getAttribute("href");
+      if (baseHref) {
+        const resolved = resolveUrl(baseHref, url);
+        if (resolved) baseUrl = resolved;
+      }
+    }
+    for (const el of root.querySelectorAll("[href]")) {
+      const href = el.getAttribute("href");
+      if (href && !href.startsWith("#")) {
+        el.setAttribute("href", resolveUrl(href, baseUrl));
+      }
+    }
+    for (const el of root.querySelectorAll("[src]")) {
+      const src = el.getAttribute("src");
+      if (src) el.setAttribute("src", resolveUrl(src, baseUrl));
+    }
+    for (const el of root.querySelectorAll("[srcset]")) {
+      const srcset = el.getAttribute("srcset");
+      if (srcset) el.setAttribute("srcset", resolveSrcset(srcset, baseUrl));
+    }
+    for (const el of root.querySelectorAll("[poster]")) {
+      const poster = el.getAttribute("poster");
+      if (poster) el.setAttribute("poster", resolveUrl(poster, baseUrl));
+    }
+  }
+  function resolveUrl(url, base) {
+    url = url.trim();
+    if (/^(javascript|data|vbscript):/i.test(url)) return url;
+    if (/^[a-z][a-z0-9+\-.]*:\/\//i.test(url)) return url;
+    if (url.startsWith("#")) return url;
+    try {
+      return new URL(url, base).href;
+    } catch (e) {
+      return url;
+    }
+  }
+  function resolveSrcset(srcset, base) {
+    const entryPattern = /(.+?)\s+(\d+(?:\.\d+)?[wx])(?:,|$)/g;
+    const entries = [];
+    let match;
+    while ((match = entryPattern.exec(srcset)) !== null) {
+      const rawUrl = match[1].trim().replace(/^,\s*/, "");
+      const descriptor = match[2];
+      entries.push(`${resolveUrl(rawUrl, base)} ${descriptor}`);
+    }
+    if (entries.length > 0) return entries.join(", ");
+    return srcset.split(",").map((entry) => {
+      const parts = entry.trim().split(/\s+/);
+      if (parts[0]) parts[0] = resolveUrl(parts[0], base);
+      return parts.join(" ");
+    }).join(", ");
+  }
+
+  // src/metadata.js
+  var ARTICLE_TYPES = ["Article", "NewsArticle", "BlogPosting", "WebPage"];
+  var DATE_RE = /\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\b/i;
+  function collectMetaTags(doc) {
+    const tags = [];
+    for (const meta of doc.querySelectorAll("meta")) {
+      const content = meta.getAttribute("content");
+      if (!content) continue;
+      tags.push({
+        name: meta.getAttribute("name") || null,
+        property: meta.getAttribute("property") || null,
+        content: decodeHtmlEntities(content)
+      });
+    }
+    return tags;
+  }
+  function extractMetadata(doc, url, schemaOrgData, metaTags) {
+    const getMeta = (value, attr) => {
+      for (const tag of metaTags) {
+        if (tag[attr] && tag[attr].toLowerCase() === value.toLowerCase()) {
+          return tag.content || null;
+        }
+      }
+      return null;
+    };
+    const getSchema = (property) => getSchemaProperty(schemaOrgData, ARTICLE_TYPES, property);
+    const site = extractSiteName(doc, metaTags, schemaOrgData, getMeta);
+    const title = extractTitle(doc, metaTags, schemaOrgData, getMeta, getSchema, site);
+    return {
+      title,
+      description: extractDescription(metaTags, getSchema, getMeta),
+      author: extractAuthor(doc, metaTags, schemaOrgData, getMeta),
+      published: extractPublished(doc, metaTags, schemaOrgData, getMeta, getSchema),
+      site,
+      domain: extractDomain(doc, url, getMeta),
+      favicon: extractFavicon(doc, url),
+      image: extractImage(doc, metaTags, getSchema, getMeta),
+      language: extractLanguage(doc, metaTags, getMeta)
+    };
+  }
+  function extractTitle(doc, metaTags, schemaOrgData, getMeta, getSchema, siteName) {
+    const raw = getMeta("og:title", "property") || getMeta("twitter:title", "name") || getSchema("headline") || getMeta("title", "name") || (doc.querySelector("title") ? doc.querySelector("title").textContent.trim() : "") || "";
+    return cleanTitle(raw, siteName);
+  }
+  function cleanTitle(title, siteName) {
+    if (!title || !siteName) return title;
+    const separators = ["|", " / ", " \xB7 ", " \u2013 ", " \u2014 ", " - ", ": "];
+    for (const sep of separators) {
+      if (!title.includes(sep)) continue;
+      const idx = title.indexOf(sep);
+      const left = title.slice(0, idx).trim();
+      const right = title.slice(idx + sep.length).trim();
+      if (fuzzyMatch(right, siteName)) return left;
+      if (fuzzyMatch(left, siteName)) return right;
+    }
+    return title;
+  }
+  function fuzzyMatch(a, b) {
+    const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const na = norm(a), nb = norm(b);
+    if (na === nb) return true;
+    if (nb.length > 2 && (na.includes(nb) || nb.includes(na))) return true;
+    return false;
+  }
+  function extractDescription(metaTags, getSchema, getMeta) {
+    return getMeta("og:description", "property") || getMeta("twitter:description", "name") || getMeta("description", "name") || getSchema("description") || "";
+  }
+  function extractAuthor(doc, metaTags, schemaOrgData, getMeta) {
+    for (const name of ["author", "sailthru.author", "citation_author", "dc.creator", "byl"]) {
+      const val = getMeta(name, "name");
+      if (val) return val;
+    }
+    const schemaAuthor = getSchemaAuthor(schemaOrgData);
+    if (schemaAuthor) return schemaAuthor;
+    const selectors = [
+      '[class*="author"]:not([class*="author-bio"])',
+      '[rel="author"]',
+      '[class*="byline"]',
+      '[itemprop="author"]'
+    ];
+    for (const sel of selectors) {
+      const el = doc.querySelector(sel);
+      if (el) {
+        const text = (el.textContent || "").trim();
+        const words = text.split(/\s+/).filter(Boolean).length;
+        if (text && words <= 6) return stripByPrefix(text);
+      }
+    }
+    return extractBylineNearH1(doc);
+  }
+  function getSchemaAuthor(schemaOrgData) {
+    var _a;
+    if (!schemaOrgData) return "";
+    for (const item of schemaOrgData) {
+      if (!item || typeof item !== "object") continue;
+      const author = item.author;
+      if (!author) continue;
+      if (typeof author === "string") return author;
+      if (typeof author === "object") {
+        if (author.name) return String(author.name);
+        if (Array.isArray(author) && ((_a = author[0]) == null ? void 0 : _a.name)) return String(author[0].name);
+      }
+    }
+    return "";
+  }
+  function extractBylineNearH1(doc) {
+    const h1 = doc.querySelector("h1");
+    if (!h1 || !h1.parentElement) return "";
+    let checked = 0;
+    for (const sibling of h1.parentElement.children) {
+      if (sibling === h1) continue;
+      const text = (sibling.textContent || "").trim();
+      const match = text.match(/^by\s+(.+)/i);
+      if (match) {
+        const words = text.split(/\s+/).filter(Boolean).length;
+        if (words <= 8) return match[1].trim();
+      }
+      if (++checked >= 5) break;
+    }
+    return "";
+  }
+  function stripByPrefix(text) {
+    const m = text.match(/^by\s+(.+)/i);
+    return m ? m[1].trim() : text;
+  }
+  function extractPublished(doc, metaTags, schemaOrgData, getMeta, getSchema) {
+    const raw = getMeta("article:published_time", "property") || getMeta("article:published", "property") || getMeta("date", "name") || getMeta("citation_date", "name") || getMeta("DC.date", "name") || getMeta("pubdate", "name") || null;
+    if (raw) return normalizeDate(raw);
+    const schemaDate = getSchema("datePublished");
+    if (schemaDate) return normalizeDate(String(schemaDate));
+    const timeEl = doc.querySelector("time[datetime]");
+    if (timeEl) {
+      const dt = timeEl.getAttribute("datetime");
+      if (dt) return normalizeDate(dt);
+    }
+    for (const tag of metaTags) {
+      if (tag.content && DATE_RE.test(tag.content)) {
+        const parsed = parseNaturalDate(tag.content);
+        if (parsed) return parsed;
+      }
+    }
+    return "";
+  }
+  function normalizeDate(raw) {
+    raw = raw.trim();
+    if (!raw) return "";
+    if (/^\d{4}-\d{2}-\d{2}/.test(raw)) {
+      try {
+        return new Date(raw).toISOString();
+      } catch (e) {
+        return raw;
+      }
+    }
+    return parseNaturalDate(raw) || raw;
+  }
+  function parseNaturalDate(input) {
+    input = input.trim();
+    const d = new Date(input);
+    if (!isNaN(d.getTime()) && d.getFullYear() > 1900) {
+      return d.toISOString();
+    }
+    return null;
+  }
+  function extractImage(doc, metaTags, getSchema, getMeta) {
+    const url = getMeta("og:image", "property") || getMeta("og:image:url", "property") || getMeta("twitter:image", "name") || getMeta("twitter:image:src", "name") || null;
+    if (url) return url;
+    const schemaImage = getSchema("image");
+    if (schemaImage) {
+      if (typeof schemaImage === "string") return schemaImage;
+      if (schemaImage.url) return String(schemaImage.url);
+    }
+    const imgs = doc.querySelectorAll("body img[src]");
+    for (const img of imgs) {
+      const w = parseInt(img.getAttribute("width") || "0");
+      const h = parseInt(img.getAttribute("height") || "0");
+      if (w >= 200 && h >= 100 || !w && !h) {
+        return img.getAttribute("src") || "";
+      }
+    }
+    return "";
+  }
+  function extractSiteName(doc, metaTags, schemaOrgData, getMeta) {
+    const og = getMeta("og:site_name", "property");
+    if (og) return og;
+    const publisher = getSchemaProperty(schemaOrgData, ARTICLE_TYPES, "publisher");
+    if (publisher) {
+      if (typeof publisher === "string") return publisher;
+      if (publisher.name) return String(publisher.name);
+    }
+    const titleEl = doc.querySelector("title");
+    if (titleEl) {
+      const title = titleEl.textContent || "";
+      for (const sep of ["|", " / ", " \xB7 ", " \u2013 ", " \u2014 "]) {
+        if (title.includes(sep)) {
+          const parts = title.split(sep);
+          const last = parts[parts.length - 1].trim();
+          if (last && last.split(/\s+/).length <= 4) return last;
+        }
+      }
+    }
+    return "";
+  }
+  function extractDomain(doc, url, getMeta) {
+    let pageUrl = url;
+    if (!pageUrl) {
+      pageUrl = getMeta("og:url", "property");
+    }
+    if (!pageUrl) {
+      const canonical = doc.querySelector('link[rel="canonical"][href]');
+      if (canonical) pageUrl = canonical.getAttribute("href");
+    }
+    if (!pageUrl) return "";
+    try {
+      let host = new URL(pageUrl).hostname;
+      if (host.startsWith("www.")) host = host.slice(4);
+      return host;
+    } catch (e) {
+      return "";
+    }
+  }
+  function extractFavicon(doc, url) {
+    for (const rel of ["shortcut icon", "icon"]) {
+      const el = doc.querySelector(`link[rel="${rel}"][href]`);
+      if (el) {
+        const href = el.getAttribute("href");
+        if (href) return url ? resolveUrl(href, url) : href;
+      }
+    }
+    if (url) {
+      try {
+        const u = new URL(url);
+        return u.origin + "/favicon.ico";
+      } catch (e) {
+      }
+    }
+    return "";
+  }
+  function extractLanguage(doc, metaTags, getMeta) {
+    const htmlEl = doc.documentElement;
+    if (htmlEl && htmlEl.getAttribute("lang")) {
+      return htmlEl.getAttribute("lang");
+    }
+    const locale = getMeta("og:locale", "property");
+    if (locale) return locale.replace("_", "-");
+    const contentLang = doc.querySelector('meta[http-equiv="Content-Language"]');
+    if (contentLang) return contentLang.getAttribute("content") || "";
+    return "";
+  }
+  function decodeHtmlEntities(text) {
+    return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+  }
+
+  // src/constants.js
+  var ENTRY_POINT_SELECTORS = [
+    "#post",
+    ".post-content",
+    ".post-body",
+    ".article-content",
+    "#article-content",
+    ".article_post",
+    ".article-wrapper",
+    ".entry-content",
+    ".content-article",
+    ".instapaper_body",
+    ".post",
+    ".markdown-body",
+    "article",
+    '[role="article"]',
+    "main",
+    '[role="main"]',
+    "#content",
+    "body"
+  ];
+  var BLOCK_ELEMENTS_SELECTOR = "div,section,article,main,aside,header,footer,nav";
+  var CONTENT_INDICATORS = /* @__PURE__ */ new Set([
+    "article",
+    "body",
+    "content",
+    "entry",
+    "hentry",
+    "main",
+    "page",
+    "post",
+    "text",
+    "blog",
+    "story"
+  ]);
+  var NAV_INDICATORS = [
+    "nav",
+    "navigation",
+    "menu",
+    "sidebar",
+    "header",
+    "footer",
+    "breadcrumb",
+    "pagination",
+    "pager",
+    "tags",
+    "categories"
+  ];
+  var SOCIAL_MEDIA_PATTERNS = [
+    "twitter.com/",
+    "facebook.com/",
+    "instagram.com/",
+    "linkedin.com/",
+    "youtube.com/",
+    "tiktok.com/",
+    "pinterest.com/",
+    "reddit.com/"
+  ];
+  var MIN_IMAGE_DIMENSION = 33;
+  var EXACT_SELECTORS = [
+    "noscript",
+    "style",
+    "meta",
+    "link",
+    ".promo",
+    ".Promo",
+    ".alert",
+    "#barrier-page",
+    '[id="comments"]',
+    '[id="comment"]',
+    'div[class*="cover-"]',
+    'div[id*="cover-"]',
+    "header",
+    ".header",
+    "#header",
+    "#Header",
+    "#banner",
+    "#Banner",
+    "nav",
+    ".navigation",
+    "#navigation",
+    '[role="navigation"]',
+    '[role="dialog"]',
+    '[role="complementary"]',
+    '[class*="pagination"]',
+    ".menu",
+    "#siteSub",
+    ".previous",
+    ".Author",
+    '[class$="_bio"]',
+    "#categories",
+    ".contributor",
+    ".date",
+    "#date",
+    "[data-date]",
+    ".entry-meta",
+    ".meta",
+    ".tags",
+    "#tags",
+    '[rel="tag"]',
+    ".toc",
+    ".Toc",
+    "#toc",
+    ".headline",
+    "#headline",
+    "#title",
+    "#Title",
+    "#articleTag",
+    '[href*="/tag/"]',
+    '[href*="/tags/"]',
+    '[href*="/author/"]',
+    '[href*="/author?"]',
+    '[href$="/author"]',
+    'a[href*="copyright.com"]',
+    'a[href*="google.com/preferences"]',
+    '[href*="#toc"]',
+    '[href="#top"]',
+    '[href="#Top"]',
+    '[href="#page-header"]',
+    '[href="#content"]',
+    '[href="#site-content"]',
+    '[href="#main-content"]',
+    '[href^="#main"]',
+    '[src*="author"]',
+    "footer",
+    ".aside",
+    "button",
+    "canvas",
+    "dialog",
+    "fieldset",
+    "form",
+    "label",
+    "option",
+    "select",
+    '[role="listbox"]',
+    '[role="option"]',
+    "textarea",
+    "[hidden]",
+    '[aria-hidden="true"]',
+    ".hidden",
+    ".invisible",
+    "#logo",
+    "#Logo",
+    "#newsletter",
+    "#Newsletter",
+    ".subscribe",
+    ".noprint",
+    '[data-print-layout="hide"]',
+    '[data-block="donotprint"]',
+    ".sidebar",
+    ".Sidebar",
+    "#sidebar",
+    "#Sidebar",
+    "#side-bar",
+    "#sitesub",
+    ".copyright",
+    "#copyright",
+    ".licensebox",
+    "#page-info",
+    "#rss",
+    "#feed",
+    ".gutter",
+    "#primaryaudio",
+    "table.infobox",
+    ".gh-header-sticky"
+  ];
+  var PARTIAL_SELECTORS = [
+    "a-statement",
+    "access-wall",
+    "activitypub",
+    "actioncall",
+    "addcomment",
+    "addtoany",
+    "advert",
+    "adlayout",
+    "ad-tldr",
+    "ad-placement",
+    "ads-container",
+    "_ad_",
+    "AdBlock_",
+    "AdUnit",
+    "after_content",
+    "after_main_article",
+    "afterpost",
+    "allterms",
+    "-alert-",
+    "alert-box",
+    "_archive",
+    "around-the-web",
+    "aroundpages",
+    "article-author",
+    "article-badges",
+    "article-banner",
+    "article-bottom-section",
+    "article-bottom",
+    "article-category",
+    "article-card",
+    "article-citation",
+    "article__copy",
+    "article_date",
+    "article-date",
+    "article-end ",
+    "article_header",
+    "article-header",
+    "article__header",
+    "article__hero",
+    "article__info",
+    "article-info",
+    "article-meta",
+    "article_meta",
+    "article__meta",
+    "articlename",
+    "article-subject",
+    "article_subject",
+    "article-snippet",
+    "article-separator",
+    "article--share",
+    "article--topics",
+    "articletags",
+    "article-tags",
+    "article_tags",
+    "articletitle",
+    "article-title",
+    "article_title",
+    "articletopics",
+    "article-topics",
+    "article-actions",
+    "article--lede",
+    "articlewell",
+    "associated-people",
+    "audio-card",
+    "author-bio",
+    "author-box",
+    "author-info",
+    "author_info",
+    "authorm",
+    "author-mini-bio",
+    "author-name",
+    "author-publish-info",
+    "authored-by",
+    "avatar",
+    "back-to-top",
+    "backlink_container",
+    "backlinks-section",
+    "bio-block",
+    "biobox",
+    "blog-pager",
+    "bookmark-",
+    "-bookmark",
+    "bottominfo",
+    "bottomnav",
+    "bottom-of-article",
+    "bottom-wrapper",
+    "brand-bar",
+    "bcrumb",
+    "breadcrumb",
+    "brdcrumb",
+    "button-wrapper",
+    "buttons-container",
+    "btn-",
+    "-btn",
+    "byline",
+    "captcha",
+    "card-text",
+    "card-media",
+    "card-post",
+    "carouselcontainer",
+    "carousel-container",
+    "cat_header",
+    "catlinks",
+    "_categories",
+    "card-author",
+    "card-content",
+    "chapter-list",
+    "collections",
+    "comments",
+    "-comment",
+    "commentbox",
+    "comment-button",
+    "commentcomp",
+    "comment-content",
+    "comment-count",
+    "comment-form",
+    "comment-number",
+    "comment-respond",
+    "comment-thread",
+    "comment-wrap",
+    "complementary",
+    "consent",
+    "contact-",
+    "content-card",
+    "copycontent",
+    "content-topics",
+    "contentpromo",
+    "context-bar",
+    "context-widget",
+    "core-collateral",
+    "cover-image",
+    "cover-photo",
+    "cover-wrap",
+    "created-date",
+    "creative-commons_",
+    "c-subscribe",
+    "_cta",
+    "-cta",
+    "cta-",
+    "cta_",
+    "current-issue",
+    "custom-list-number",
+    "dateline",
+    "dateheader",
+    "date-header",
+    "date-pub",
+    "disclaimer",
+    "disclosure",
+    "discussion",
+    "discuss_",
+    "-dismiss",
+    "disqus",
+    "donate",
+    "donation",
+    "dropdown",
+    "editorial_contact",
+    "editorial-contact",
+    "element-invisible",
+    "eletters",
+    "emailsignup",
+    "emoji-bar",
+    "engagement-widget",
+    "enhancement-",
+    "entry-author-info",
+    "entry-categories",
+    "entry-date",
+    "entry-title",
+    "entry-utility",
+    "-error",
+    "error-",
+    "eyebrow",
+    "expand-reduce",
+    "external-anchor",
+    "externallinkembedwrapper",
+    "extra-services",
+    "extra-title",
+    "facebook",
+    "fancy-box",
+    "favorite",
+    "featured-content",
+    "feature_feed",
+    "feedback",
+    "feed-links",
+    "field-site-sections",
+    "fixheader",
+    "floating-vid",
+    "follower",
+    "footer",
+    "footnote-back",
+    "footnoteback",
+    "form-group",
+    "for-you",
+    "frontmatter",
+    "further-reading",
+    "fullbleedheader",
+    "gallery-count",
+    "gated-",
+    "gh-feed",
+    "gist-meta",
+    "goog-",
+    "graph-view",
+    "hamburger",
+    "header_logo",
+    "header-logo",
+    "header-pattern",
+    "hero-list",
+    "hide-for-print",
+    "hide-print",
+    "hide-when-no-script",
+    "hidden-print",
+    "hidden-sidenote",
+    "hidden-accessibility",
+    "infoline",
+    "inline-topic",
+    "instacartIntegration",
+    "interlude",
+    "interaction",
+    "itemendrow",
+    "intro-date",
+    "invisible",
+    "jp-no-solution",
+    "jp-relatedposts",
+    "jswarning",
+    "js-warning",
+    "jumplink",
+    "jumpto",
+    "jump-to-",
+    "js-skip-to-content",
+    "keepreading",
+    "keep-reading",
+    "keep_reading",
+    "keyword_wrap",
+    "kicker",
+    "labstab",
+    "-labels",
+    "language-name",
+    "lastupdated",
+    "latest-content",
+    "-ledes-",
+    "-license",
+    "license-",
+    "lightbox-popup",
+    "like-button",
+    "link-box",
+    "links-grid",
+    "links-title",
+    "listing-dynamic-terms",
+    "list-tags",
+    "listinks",
+    "loading",
+    "loa-info",
+    "logo_container",
+    "masthead",
+    "marketing",
+    "media-inquiry",
+    "-menu",
+    "menu-",
+    "metadata",
+    "meta-date",
+    "meta-row",
+    "might-like",
+    "minibio",
+    "more-about",
+    "mod-paywall",
+    "_modal",
+    "-modal",
+    "more-",
+    "morenews",
+    "morestories",
+    "more_wrapper",
+    "most-read",
+    "mw-editsection",
+    "mw-cite-backlink",
+    "mw-indicators",
+    "mw-jump-link",
+    "nav-",
+    "nav_",
+    "navigation-post",
+    "next-",
+    "newsgallery",
+    "news-story-title",
+    "newsletter_",
+    "newsletterbanner",
+    "newslettercontainer",
+    "newsletter-form",
+    "newsletter-signup",
+    "newslettersignup",
+    "newsletterwidget",
+    "newsletterwrapper",
+    "not-found",
+    "notessection",
+    "nomobile",
+    "noprint",
+    "open-slideshow",
+    "originally-published",
+    "other-blogs",
+    "outline-view",
+    "pagehead",
+    "page-header",
+    "page-title",
+    "paywall_message",
+    "-partners",
+    "permission-",
+    "plea",
+    "popular",
+    "popup_links",
+    "pop_stories",
+    "pop-up",
+    "post__author",
+    "post-author",
+    "post-bottom",
+    "post__category",
+    "postcomment",
+    "postdate",
+    "post-date",
+    "post_date",
+    "post-details",
+    "post-feeds",
+    "postinfo",
+    "post-info",
+    "post_info",
+    "post-inline-date",
+    "post-links",
+    "postlist",
+    "post_list",
+    "post_meta",
+    "post-meta",
+    "postmeta",
+    "post_more",
+    "postnavi",
+    "post-navigation",
+    "postpath",
+    "post-preview",
+    "postsnippet",
+    "post_snippet",
+    "post-snippet",
+    "post-subject",
+    "posttax",
+    "post-tax",
+    "post_tax",
+    "posttag",
+    "post_tag",
+    "post-tag",
+    "post_time",
+    "posttitle",
+    "post-title",
+    "post_title",
+    "post__title",
+    "post-ufi-button",
+    "prev-post",
+    "prevnext",
+    "prev_next",
+    "prev-next",
+    "previousnext",
+    "press-inquiries",
+    "print-none",
+    "print-header",
+    "privacy-notice",
+    "privacy-settings",
+    "profile",
+    "promo_article",
+    "promo-bar",
+    "promo-box",
+    "pubdate",
+    "pub_date",
+    "pub-date",
+    "publish_date",
+    "publish-date",
+    "publication-date",
+    "publicationName",
+    "qr-code",
+    "qr_code",
+    "quick_up",
+    "_rail",
+    "ratingssection",
+    "read_also",
+    "readmore",
+    "read-next",
+    "read_next",
+    "read_time",
+    "read-time",
+    "reading_time",
+    "reading-time",
+    "reading-list",
+    "recent-",
+    "recent-articles",
+    "recentpost",
+    "recent_post",
+    "recent-post",
+    "recommend",
+    "redirectedfrom",
+    "recirc",
+    "register",
+    "related",
+    "relevant",
+    "reversefootnote",
+    "robots-nocontent",
+    "_rss",
+    "rss-link",
+    "screen-reader-text",
+    "scroll_to",
+    "scroll-to",
+    "_search",
+    "-search",
+    "section-nav",
+    "series-banner",
+    "share-box",
+    "sharedaddy",
+    "share-icons",
+    "sharelinks",
+    "share-post",
+    "share-print",
+    "share-section",
+    "sharing_",
+    "shariff-",
+    "show-for-print",
+    "sidebartitle",
+    "sidebar-content",
+    "sidebar-wrapper",
+    "sideitems",
+    "sidebar-author",
+    "sidebar-item",
+    "side-box",
+    "side-logo",
+    "sign-in-gate",
+    "similar-",
+    "similar_",
+    "similars-",
+    "site-index",
+    "site-header",
+    "siteheader",
+    "site-logo",
+    "site-name",
+    "site-wordpress",
+    "skip-content",
+    "skip-to-content",
+    "skip-link",
+    "c-skip-link",
+    "_skip-link",
+    "-slider",
+    "slug-wrap",
+    "social-author",
+    "social-shar",
+    "social-date",
+    "speechify-ignore",
+    "speedbump",
+    "sponsor",
+    "springercitation",
+    "sr-only",
+    "_stats",
+    "story-date",
+    "story-navigation",
+    "storyreadtime",
+    "storysmall",
+    "storypublishdate",
+    "subject-label",
+    "subhead",
+    "submenu",
+    "-subscribe-",
+    "subscriber-drive",
+    "subscription-",
+    "_tags",
+    "tags__item",
+    "tag_list",
+    "taxonomy",
+    "table-of-contents",
+    "tabs-",
+    "terminaltout",
+    "time-rubric",
+    "timestamp",
+    "time-read",
+    "time-to-read",
+    "tip_off",
+    "tiptout",
+    "-tout-",
+    "toc-container",
+    "toggle-caption",
+    "tooltip-content",
+    "topbar",
+    "topic-authors",
+    "topic-footer",
+    "topic-list",
+    "topic-subnav",
+    "top-wrapper",
+    "tree-item",
+    "trending",
+    "trust-feat",
+    "trust-badge",
+    "trust-project",
+    "twitter",
+    "twiblock",
+    "u-hide",
+    "upsell",
+    "viewbottom",
+    "yarpp-related",
+    "visually-hidden",
+    "welcomebox",
+    "widget_pages"
+  ];
+  var PARTIAL_SELECTORS_REGEX = new RegExp(
+    "(?:" + PARTIAL_SELECTORS.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|") + ")",
+    "i"
+  );
+  var FOOTNOTE_SELECTORS = [
+    "div.footnote ol",
+    "div.footnotes ol",
+    'div[role="doc-endnotes"]',
+    'div[role="doc-footnotes"]',
+    "ol.footnotes-list",
+    "ol.footnotes",
+    "ol.references",
+    "section.footnotes ol",
+    'section[role="doc-endnotes"]',
+    'section[role="doc-footnotes"]',
+    'section[role="doc-bibliography"]',
+    "ul.footnotes-list",
+    "#footnotes"
+  ];
+  var PARTIAL_MATCH_ATTRIBUTES = [
+    "class",
+    "id",
+    "data-test",
+    "data-testid",
+    "data-test-id",
+    "data-qa",
+    "data-cy"
+  ];
+  var VIDEO_EMBED_PATTERNS = [
+    "youtube.com",
+    "youtu.be",
+    "vimeo.com",
+    "twitter.com",
+    "x.com",
+    "datawrapper.de"
+  ];
+  var ALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set([
+    "alt",
+    "allow",
+    "allowfullscreen",
+    "aria-label",
+    "checked",
+    "colspan",
+    "controls",
+    "data-latex",
+    "data-src",
+    "data-srcset",
+    "data-callout",
+    "data-callout-title",
+    "data-lang",
+    "dir",
+    "frameborder",
+    "headers",
+    "height",
+    "href",
+    "kind",
+    "label",
+    "lang",
+    "role",
+    "rowspan",
+    "src",
+    "srclang",
+    "srcset",
+    "title",
+    "type",
+    "width",
+    "datetime"
+  ]);
+  var ALLOWED_EMPTY_TAGS = /* @__PURE__ */ new Set([
+    "area",
+    "audio",
+    "br",
+    "col",
+    "embed",
+    "figure",
+    "hr",
+    "iframe",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "picture",
+    "source",
+    "svg",
+    "td",
+    "th",
+    "track",
+    "video",
+    "wbr"
+  ]);
+
+  // src/utils.js
+  function countWords(text) {
+    if (!text || !text.trim()) return 0;
+    const cjkMatches = text.match(
+      /[\u3040-\u309F\u30A0-\u30FF\uAC00-\uD7FF\u4E00-\u9FFF]/g
+    );
+    const cjkCount = cjkMatches ? cjkMatches.length : 0;
+    const nonCjk = text.replace(/[\u3040-\u309F\u30A0-\u30FF\uAC00-\uD7FF\u4E00-\u9FFF]/g, " ");
+    const nonCjkWords = nonCjk.trim().split(/\s+/).filter((w) => w.length > 0).length;
+    return cjkCount + nonCjkWords;
+  }
+  function countHtmlWords(html) {
+    const text = html.replace(/<[^>]*>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#\d+;/g, " ").replace(/&\w+;/g, " ");
+    return countWords(text);
+  }
+  function getClassId(el) {
+    return (el.getAttribute("class") || "") + " " + (el.getAttribute("id") || "");
+  }
+  function isAncestorOrSelf(el, target) {
+    let node = target;
+    while (node) {
+      if (node === el) return true;
+      node = node.parentElement;
+    }
+    return false;
+  }
+  function removeNode(el) {
+    if (el && el.parentNode) {
+      el.parentNode.removeChild(el);
+    }
+  }
+  function removeAll(nodes) {
+    Array.from(nodes).forEach((n) => removeNode(n));
+  }
+
+  // src/content-scorer.js
+  function scoreElement(el) {
+    const text = el.textContent || "";
+    const words = countWords(text);
+    let score = words;
+    score += el.getElementsByTagName("p").length * 10;
+    score += (text.match(/,/g) || []).length;
+    const classId = getClassId(el).toLowerCase();
+    for (const indicator of CONTENT_INDICATORS) {
+      if (classId.includes(indicator)) {
+        score += 15;
+        break;
+      }
+    }
+    const linkDensity = getLinkDensity(el);
+    score *= Math.max(0.5, 1 - linkDensity);
+    return score;
+  }
+  function scoreNonContentBlock(el) {
+    let score = 0;
+    const classId = getClassId(el).toLowerCase();
+    for (const indicator of NAV_INDICATORS) {
+      if (classId.includes(indicator)) score -= 10;
+    }
+    if (getLinkDensity(el) > 0.5) score -= 15;
+    if (hasSocialMediaLinks(el)) score -= 15;
+    if (isAuthorDateByline(el)) score -= 10;
+    if (isCardGrid(el)) score -= 15;
+    return score;
+  }
+  function scoreAndRemove(doc, mainContent, debug = false) {
+    const removed = [];
+    const body = doc.body || doc.documentElement;
+    if (!body) return removed;
+    const tags = ["div", "section", "article", "main", "aside", "header", "footer", "nav"];
+    const candidates = [];
+    for (const tag of tags) {
+      candidates.push(...Array.from(body.getElementsByTagName(tag)));
+    }
+    const toRemove = [];
+    for (const el of candidates) {
+      if (isAncestorOrSelf(el, mainContent)) continue;
+      const score = scoreNonContentBlock(el);
+      if (score < 0) {
+        toRemove.push(el);
+        if (debug) {
+          removed.push({ step: "scoreAndRemove", score, tag: el.tagName, class: el.className });
+        }
+      }
+    }
+    for (const el of toRemove) {
+      if (el.parentNode) el.parentNode.removeChild(el);
+    }
+    return removed;
+  }
+  function findBestElement(elements) {
+    let best = null;
+    let bestScore = -Infinity;
+    for (const el of elements) {
+      const score = scoreElement(el);
+      if (score > bestScore) {
+        bestScore = score;
+        best = el;
+      }
+    }
+    return best;
+  }
+  function getLinkDensity(el) {
+    const totalText = (el.textContent || "").trim().length;
+    if (totalText === 0) return 0;
+    let linkText = 0;
+    for (const a of el.getElementsByTagName("a")) {
+      linkText += (a.textContent || "").trim().length;
+    }
+    return Math.min(1, linkText / totalText);
+  }
+  function isCardGrid(el) {
+    const headings = el.querySelectorAll("h2,h3,h4").length;
+    if (headings < 3) return false;
+    const images = el.getElementsByTagName("img").length;
+    if (images < 2) return false;
+    const words = countWords(el.textContent || "");
+    if (words >= 500) return false;
+    return headings > 0 && words / headings < 20;
+  }
+  function isAuthorDateByline(el) {
+    const text = (el.textContent || "").trim();
+    const words = countWords(text);
+    if (words >= 15) return false;
+    const hasDate = /\b(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\.?\s+\d{1,2}|\d{4}|\b\d{1,2}\/\d{1,2}/i.test(text);
+    const hasByline = /^by\s+/i.test(text);
+    return hasDate || hasByline;
+  }
+  function hasSocialMediaLinks(el) {
+    const links = Array.from(el.getElementsByTagName("a"));
+    if (links.length === 0) return false;
+    const socialLinks = links.filter((a) => {
+      const href = (a.getAttribute("href") || "").toLowerCase();
+      return SOCIAL_MEDIA_PATTERNS.some((p) => href.includes(p));
+    });
+    return socialLinks.length > 0 && socialLinks.length / links.length > 0.5;
+  }
+
+  // src/content-finder.js
+  function findMainContent(doc) {
+    const selectorCount = ENTRY_POINT_SELECTORS.length;
+    const candidates = [];
+    for (let index = 0; index < selectorCount; index++) {
+      const selector = ENTRY_POINT_SELECTORS[index];
+      let elements;
+      try {
+        elements = doc.querySelectorAll(selector);
+      } catch (e) {
+        continue;
+      }
+      for (const el of elements) {
+        const baseScore = (selectorCount - index) * 40;
+        const contentScore = scoreElement(el);
+        candidates.push({
+          element: el,
+          score: baseScore + contentScore,
+          selectorIndex: index
+        });
+      }
+    }
+    if (candidates.length === 0) {
+      return findByScoring(doc);
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    const top = candidates[0];
+    if (candidates.length === 1 && top.element.tagName.toLowerCase() === "body") {
+      const tableContent = findTableBasedContent(doc);
+      if (tableContent) return tableContent;
+    }
+    let best = top;
+    for (const child of candidates) {
+      if (child === top) continue;
+      if (child.selectorIndex >= best.selectorIndex) continue;
+      if (!top.element.contains(child.element)) continue;
+      const childWords = countWords(child.element.textContent || "");
+      if (childWords <= 50) continue;
+      const siblingsAtIndex = candidates.filter(
+        (c) => c.selectorIndex === child.selectorIndex && top.element.contains(c.element)
+      ).length;
+      if (siblingsAtIndex > 1) continue;
+      best = child;
+    }
+    return best.element;
+  }
+  function findByScoring(doc) {
+    const elements = Array.from(doc.querySelectorAll(BLOCK_ELEMENTS_SELECTOR)).filter((el) => scoreElement(el) > 0);
+    if (elements.length === 0) {
+      return doc.body || null;
+    }
+    return elements.reduce(
+      (best, el) => scoreElement(el) > scoreElement(best) ? el : best
+    );
+  }
+  function findTableBasedContent(doc) {
+    const tables = Array.from(doc.getElementsByTagName("table"));
+    const hasTableLayout = tables.some((table) => {
+      const width = parseInt(table.getAttribute("width") || "0");
+      const cls = (table.className || "").toLowerCase();
+      return width > 400 || cls.includes("content") || cls.includes("article") || table.getAttribute("align") === "center";
+    });
+    if (!hasTableLayout) return null;
+    const cells = Array.from(doc.getElementsByTagName("td"));
+    return findBestElement(cells);
+  }
+
+  // src/removals/hidden.js
+  function removeHiddenElements(doc, debug = false) {
+    const removed = [];
+    const all = Array.from(doc.querySelectorAll("*"));
+    const toRemove = [];
+    for (const el of all) {
+      if (isHidden(el) && !containsMath(el)) {
+        toRemove.push(el);
+        if (debug) removed.push({ step: "removeHidden", tag: el.tagName, class: el.className });
+      }
+    }
+    removeAll(toRemove);
+    return removed;
+  }
+  function isHidden(el) {
+    if (el.hasAttribute("hidden")) return true;
+    if (el.getAttribute("aria-hidden") === "true") return true;
+    const style = el.getAttribute("style") || "";
+    if (style && /(?:^|;)\s*(?:display\s*:\s*none|visibility\s*:\s*hidden|opacity\s*:\s*0)\s*(?:;|$)/i.test(style)) {
+      return true;
+    }
+    const cls = el.getAttribute("class") || "";
+    if (cls) {
+      const tokens = cls.trim().split(/\s+/);
+      if (tokens.includes("hidden") || tokens.includes("invisible")) return true;
+    }
+    return false;
+  }
+  function containsMath(el) {
+    const cls = (el.getAttribute("class") || "").toLowerCase();
+    if (cls.includes("katex-mathml") || cls.includes("math")) return true;
+    return el.querySelector("math") !== null;
+  }
+
+  // src/removals/selector-remover.js
+  function removeExact(doc, mainContent = null, debug = false) {
+    const removed = [];
+    const toRemove = /* @__PURE__ */ new Set();
+    for (const selector of EXACT_SELECTORS) {
+      try {
+        for (const el of doc.querySelectorAll(selector)) {
+          if (mainContent && isAncestorOrSelf(el, mainContent)) continue;
+          if (isInsideCodeBlock(el)) continue;
+          if (isFootnoteContainer(doc, el)) continue;
+          toRemove.add(el);
+        }
+      } catch (e) {
+      }
+    }
+    for (const el of doc.querySelectorAll("script")) {
+      const type = (el.getAttribute("type") || "").toLowerCase();
+      if (type.startsWith("math/")) continue;
+      if (mainContent && isAncestorOrSelf(el, mainContent)) continue;
+      toRemove.add(el);
+    }
+    for (const el of doc.querySelectorAll("iframe")) {
+      const src = (el.getAttribute("src") || "").toLowerCase();
+      if (VIDEO_EMBED_PATTERNS.some((p) => src.includes(p))) continue;
+      if (mainContent && isAncestorOrSelf(el, mainContent)) continue;
+      toRemove.add(el);
+    }
+    for (const el of doc.querySelectorAll("aside")) {
+      const cls = (el.getAttribute("class") || "").toLowerCase();
+      if (cls.includes("callout")) continue;
+      if (mainContent && isAncestorOrSelf(el, mainContent)) continue;
+      toRemove.add(el);
+    }
+    for (const el of toRemove) {
+      if (el.parentNode) {
+        if (debug) removed.push({ step: "removeExact", tag: el.tagName, class: el.className });
+        el.parentNode.removeChild(el);
+      }
+    }
+    return removed;
+  }
+  function removePartial(doc, mainContent = null, debug = false) {
+    const removed = [];
+    const attrSelector = PARTIAL_MATCH_ATTRIBUTES.map((a) => `[${a}]`).join(",");
+    let elements;
+    try {
+      elements = Array.from(doc.querySelectorAll(attrSelector));
+    } catch (e) {
+      return removed;
+    }
+    const toRemove = [];
+    for (const el of elements) {
+      const tag = el.tagName.toLowerCase();
+      if (tag === "code" || tag === "pre") continue;
+      if (isInsideCodeBlock(el)) continue;
+      const combined = PARTIAL_MATCH_ATTRIBUTES.map((a) => el.getAttribute(a) || "").join(" ");
+      if (!PARTIAL_SELECTORS_REGEX.test(combined)) continue;
+      if (mainContent && isAncestorOrSelf(el, mainContent)) continue;
+      if (isFootnoteContainer(doc, el)) continue;
+      toRemove.push(el);
+    }
+    for (const el of toRemove) {
+      if (el.parentNode) {
+        if (debug) removed.push({ step: "removePartial", tag: el.tagName, class: el.className });
+        el.parentNode.removeChild(el);
+      }
+    }
+    return removed;
+  }
+  function isInsideCodeBlock(el) {
+    let parent = el.parentElement;
+    while (parent) {
+      const tag = parent.tagName.toLowerCase();
+      if (tag === "code" || tag === "pre") return true;
+      parent = parent.parentElement;
+    }
+    return false;
+  }
+  function isFootnoteContainer(doc, el) {
+    for (const sel of FOOTNOTE_SELECTORS) {
+      try {
+        const matches = doc.querySelectorAll(sel);
+        for (const m of matches) {
+          if (m === el) return true;
+        }
+      } catch (e) {
+      }
+    }
+    return false;
+  }
+
+  // src/removals/small-images.js
+  function removeSmallImages(doc, debug = false) {
+    const toRemove = [];
+    for (const img of doc.querySelectorAll("img, svg")) {
+      const [w, h] = getDimensions(img);
+      if (w !== null && w < MIN_IMAGE_DIMENSION || h !== null && h < MIN_IMAGE_DIMENSION) {
+        toRemove.push(img);
+      }
+    }
+    for (const img of toRemove) {
+      if (img.parentNode) img.parentNode.removeChild(img);
+    }
+    return toRemove.length;
+  }
+  function getDimensions(el) {
+    let w = null, h = null;
+    const wAttr = el.getAttribute("width");
+    const hAttr = el.getAttribute("height");
+    if (wAttr && /^\d+$/.test(wAttr)) w = parseInt(wAttr);
+    if (hAttr && /^\d+$/.test(hAttr)) h = parseInt(hAttr);
+    const style = el.getAttribute("style") || "";
+    if (style) {
+      const wm = style.match(/\bwidth\s*:\s*(\d+)px/i);
+      const hm = style.match(/\bheight\s*:\s*(\d+)px/i);
+      if (wm) w = parseInt(wm[1]);
+      if (hm) h = parseInt(hm[1]);
+    }
+    return [w, h];
+  }
+
+  // src/removals/content-patterns.js
+  var READ_TIME_PATTERN = /\d+\s*min(?:ute)?s?\s+read\b/i;
+  var STARTS_WITH_BY = /^by\s+\S/i;
+  var BOILERPLATE_PATTERNS = [
+    /^This (?:article|story|piece) (?:appeared|was published|originally appeared) in\b/i,
+    /^A version of this (?:article|story) (?:appeared|was published) in\b/i,
+    /^Originally (?:published|appeared) (?:in|on|at)\b/i,
+    /^Any re-?use permitted\b/i
+  ];
+  function removeByContentPattern(root, debug = false, url = "") {
+    const removed = [];
+    removeHeroHeader(root, debug, removed);
+    removeBreadcrumbs(root, debug, removed);
+    removeAuthorBylines(root, debug, removed);
+    removeReadTimeBlocks(root, debug, removed);
+    removeBoilerplateSentences(root, debug, removed);
+    removeTrailingThinSections(root, debug, removed);
+    return removed;
+  }
+  function removeHeroHeader(root, debug, removed) {
+    const timeNodes = Array.from(root.querySelectorAll("time"));
+    for (const time of timeNodes) {
+      const textBefore = getTextBefore(root, time);
+      if (textBefore.length > 400) continue;
+      let container = time.parentElement;
+      let depth = 0;
+      while (container && container !== root && depth < 4) {
+        const headings = container.querySelectorAll("h1,h2,h3").length;
+        if (headings > 0) {
+          const proseWords = countProseWords(container);
+          if (proseWords < 30) {
+            safeRemove(container, root, debug, removed, "removeHeroHeader");
+            break;
+          }
+        }
+        container = container.parentElement;
+        depth++;
+      }
+    }
+  }
+  function removeBreadcrumbs(root, debug, removed) {
+    for (const tag of ["ul", "ol", "nav"]) {
+      for (const list of Array.from(root.querySelectorAll(tag))) {
+        const textBefore = getTextBefore(root, list);
+        if (textBefore.length > 600) continue;
+        if (isBreadcrumbList(list)) {
+          safeRemove(list, root, debug, removed, "removeBreadcrumbs");
+        }
+      }
+    }
+    for (const el of Array.from(root.querySelectorAll('[aria-label*="breadcrumb"],[class*="breadcrumb"]'))) {
+      safeRemove(el, root, debug, removed, "removeBreadcrumbs");
+    }
+  }
+  function isBreadcrumbList(list) {
+    const children = Array.from(list.children).filter(
+      (el) => ["li", "a"].includes(el.tagName.toLowerCase())
+    );
+    if (children.length < 2 || children.length > 8) return false;
+    const linkOnly = children.filter((item) => {
+      const text = (item.textContent || "").trim();
+      const words = countWords(text);
+      if (words > 4) return false;
+      return item.querySelector("a") !== null || item.tagName.toLowerCase() === "a";
+    });
+    return linkOnly.length >= children.length * 0.5;
+  }
+  function removeAuthorBylines(root, debug, removed) {
+    const candidates = Array.from(root.querySelectorAll("*:not(p *)"));
+    for (const el of candidates) {
+      const textBefore = getTextBefore(root, el);
+      if (textBefore.length > 600) continue;
+      const text = (el.textContent || "").trim();
+      const words = countWords(text);
+      if (words < 2 || words > 15) continue;
+      if (STARTS_WITH_BY.test(text)) {
+        safeRemove(el, root, debug, removed, "removeAuthorBylines");
+      }
+    }
+  }
+  function removeReadTimeBlocks(root, debug, removed) {
+    for (const el of Array.from(root.querySelectorAll("*"))) {
+      if (el.children.length > 0) continue;
+      const textBefore = getTextBefore(root, el);
+      if (textBefore.length > 400) continue;
+      const text = (el.textContent || "").trim();
+      if (countWords(text) > 10) continue;
+      if (READ_TIME_PATTERN.test(text)) {
+        safeRemove(el, root, debug, removed, "removeReadTimeBlocks");
+      }
+    }
+  }
+  function removeBoilerplateSentences(root, debug, removed) {
+    for (const p of Array.from(root.querySelectorAll("p"))) {
+      const text = (p.textContent || "").trim();
+      for (const pattern of BOILERPLATE_PATTERNS) {
+        if (pattern.test(text)) {
+          safeRemove(p, root, debug, removed, "removeBoilerplateSentences");
+          break;
+        }
+      }
+    }
+  }
+  function removeTrailingThinSections(root, debug, removed) {
+    const totalWords = countWords(root.textContent || "");
+    if (totalWords < 100) return;
+    const threshold = totalWords * 0.15;
+    const children = Array.from(root.children);
+    const lastChildren = children.slice(-3);
+    for (const child of lastChildren.reverse()) {
+      const tag = child.tagName.toLowerCase();
+      if (!["div", "section", "aside"].includes(tag)) continue;
+      const words = countWords(child.textContent || "");
+      if (words < threshold && child.querySelectorAll("h2,h3,h4").length > 0) {
+        safeRemove(child, root, debug, removed, "removeTrailingThinSections");
+      }
+    }
+  }
+  function safeRemove(el, root, debug, removed, step) {
+    if (el === root || !el.parentNode) return;
+    if (debug) removed.push({ step, tag: el.tagName, text: (el.textContent || "").slice(0, 80) });
+    el.parentNode.removeChild(el);
+  }
+  function getTextBefore(root, target) {
+    const rootText = root.textContent || "";
+    const targetText = (target.textContent || "").trim().slice(0, 30);
+    const pos = rootText.indexOf(targetText);
+    return pos === -1 ? "" : rootText.slice(0, pos);
+  }
+  function countProseWords(el) {
+    let text = "";
+    for (const tag of ["p", "li", "dd"]) {
+      for (const node of el.getElementsByTagName(tag)) {
+        text += " " + (node.textContent || "");
+      }
+    }
+    return countWords(text);
+  }
+
+  // src/standardizer.js
+  function standardize(root) {
+    removeComments(root);
+    normalizeNbsp(root);
+    convertH1ToH2(root);
+    stripAttributes(root);
+    removeEmptyElements(root);
+  }
+  function removeComments(root) {
+    const walker = document.createTreeWalker ? createTreeWalker(root) : null;
+    const comments = [];
+    const iter = (node) => {
+      for (const child of Array.from(node.childNodes)) {
+        if (child.nodeType === 8) {
+          comments.push(child);
+        } else if (child.childNodes && child.childNodes.length) {
+          iter(child);
+        }
+      }
+    };
+    iter(root);
+    for (const c of comments) {
+      if (c.parentNode) c.parentNode.removeChild(c);
+    }
+  }
+  function normalizeNbsp(root) {
+    const iter = (node) => {
+      for (const child of Array.from(node.childNodes)) {
+        if (child.nodeType === 3) {
+          if (child.nodeValue && child.nodeValue.includes("\xA0")) {
+            child.nodeValue = child.nodeValue.replace(/\u00A0/g, " ");
+          }
+        } else if (child.childNodes && child.childNodes.length) {
+          iter(child);
+        }
+      }
+    };
+    iter(root);
+  }
+  function convertH1ToH2(root) {
+    const h1s = Array.from(root.querySelectorAll("h1"));
+    for (const h1 of h1s) {
+      const h2 = root.ownerDocument ? root.ownerDocument.createElement("h2") : h1.cloneNode(false);
+      h2.innerHTML = h1.innerHTML;
+      for (const attr of Array.from(h1.attributes)) {
+        h2.setAttribute(attr.name, attr.value);
+      }
+      if (h1.parentNode) h1.parentNode.replaceChild(h2, h1);
+    }
+  }
+  function stripAttributes(root) {
+    for (const el of root.querySelectorAll("*")) {
+      const toRemove = [];
+      for (const attr of Array.from(el.attributes)) {
+        const name = attr.name.toLowerCase();
+        if (name.startsWith("aria-")) continue;
+        if (ALLOWED_ATTRIBUTES.has(name)) continue;
+        if (name === "id") {
+          const id = (attr.value || "").toLowerCase();
+          if (id.startsWith("fn") || id.startsWith("ref") || id.startsWith("footnote")) continue;
+        }
+        toRemove.push(attr.name);
+      }
+      for (const name of toRemove) el.removeAttribute(name);
+    }
+  }
+  function removeEmptyElements(root) {
+    const emptyTags = ["p", "div", "span", "section", "aside", "li"];
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const tag of emptyTags) {
+        for (const el of Array.from(root.getElementsByTagName(tag))) {
+          if (el === root) continue;
+          if (ALLOWED_EMPTY_TAGS.has(tag)) continue;
+          if (isEffectivelyEmpty(el)) {
+            if (el.parentNode) {
+              el.parentNode.removeChild(el);
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+  }
+  function isEffectivelyEmpty(el) {
+    if ((el.textContent || "").trim()) return false;
+    const MEDIA = ["img", "video", "audio", "iframe", "svg", "picture", "canvas"];
+    return !MEDIA.some((tag) => el.getElementsByTagName(tag).length > 0);
+  }
+  function createTreeWalker(root) {
+    return null;
+  }
+
+  // src/defuddle.js
+  var Defuddle = class _Defuddle {
+    /**
+     * @param {Document} doc  A parsed DOM Document
+     * @param {object} [options]
+     * @param {string} [options.url]  Page URL for relative URL resolution and domain extraction
+     * @param {boolean} [options.debug]
+     */
+    constructor(doc, options = {}) {
+      this.doc = doc;
+      this.url = options.url || null;
+      this.options = options;
+      this._schemaOrgData = void 0;
+      this._metaTags = void 0;
+      this._metadata = void 0;
+    }
+    /**
+     * Parse the document and return a DefuddleResult.
+     * @param {object} [opts]  Override default options for this parse call
+     * @returns {DefuddleResult}
+     */
+    parse(opts = {}) {
+      const options = __spreadValues(__spreadValues({}, this.options), opts);
+      let result = this._parseInternal(options);
+      if (result.wordCount < 200) {
+        const retry = this._parseInternal(__spreadProps(__spreadValues({}, options), { removePartialSelectors: false }));
+        if (retry.wordCount > result.wordCount * 2) result = retry;
+      }
+      if (result.wordCount < 50) {
+        const retry = this._parseInternal(__spreadProps(__spreadValues({}, options), { removeHidden: false }));
+        if (retry.wordCount > result.wordCount * 2) result = retry;
+      }
+      if (result.wordCount < 50) {
+        const retry = this._parseInternal(__spreadProps(__spreadValues({}, options), {
+          scoreContent: false,
+          removePartialSelectors: false,
+          removeContentPatterns: false
+        }));
+        if (retry.wordCount > result.wordCount) result = retry;
+      }
+      return result;
+    }
+    /**
+     * Internal parse — clones the document for each attempt.
+     * @private
+     */
+    _parseInternal(opts = {}) {
+      const startTime = Date.now();
+      const {
+        removeExactSelectors = true,
+        removePartialSelectors = true,
+        removeHidden = true,
+        removeSmallImages: doSmallImages = true,
+        scoreContent = true,
+        removeContentPatterns = true,
+        standardizeContent = true,
+        debug = false
+      } = opts;
+      const doc = this.doc;
+      if (!doc || !doc.documentElement) {
+        return this._emptyResult(startTime);
+      }
+      if (this._schemaOrgData === void 0) {
+        this._schemaOrgData = extractSchemaOrg(doc);
+      }
+      if (this._metaTags === void 0) {
+        this._metaTags = collectMetaTags(doc);
+      }
+      if (this._metadata === void 0) {
+        this._metadata = extractMetadata(doc, this.url, this._schemaOrgData, this._metaTags);
+      }
+      const clone = doc.cloneNode(true);
+      let mainContent = null;
+      if (opts.contentSelector) {
+        try {
+          mainContent = clone.querySelector(opts.contentSelector);
+        } catch (e) {
+        }
+      }
+      if (!mainContent) {
+        mainContent = findMainContent(clone);
+      }
+      if (!mainContent) {
+        return this._buildResult(clone.body ? clone.body.innerHTML : "", startTime);
+      }
+      if (doSmallImages) removeSmallImages(clone, debug);
+      if (removeHidden) removeHiddenElements(clone, debug);
+      if (removeExactSelectors) removeExact(clone, mainContent, debug);
+      if (removePartialSelectors) removePartial(clone, mainContent, debug);
+      if (scoreContent) scoreAndRemove(clone, mainContent, debug);
+      if (removeContentPatterns) removeByContentPattern(mainContent, debug, this.url || "");
+      if (standardizeContent) standardize(mainContent);
+      if (this.url) resolveUrls(mainContent, clone, this.url);
+      return this._buildResult(mainContent.outerHTML, startTime);
+    }
+    _buildResult(content, startTime) {
+      const meta = this._metadata || {};
+      return new DefuddleResult(__spreadProps(__spreadValues({
+        content
+      }, meta), {
+        schemaOrgData: this._schemaOrgData || null,
+        metaTags: this._metaTags || [],
+        wordCount: countHtmlWords(content),
+        parseTime: Date.now() - startTime
+      }));
+    }
+    _emptyResult(startTime) {
+      let domain = "";
+      if (this.url) {
+        try {
+          let host = new URL(this.url).hostname;
+          if (host.startsWith("www.")) host = host.slice(4);
+          domain = host;
+        } catch (e) {
+        }
+      }
+      return new DefuddleResult({
+        content: "",
+        title: "",
+        description: "",
+        author: "",
+        published: "",
+        site: "",
+        domain,
+        favicon: "",
+        image: "",
+        language: "",
+        schemaOrgData: null,
+        metaTags: [],
+        wordCount: 0,
+        parseTime: Date.now() - startTime
+      });
+    }
+    /**
+     * Convenience static method: parse an HTML string.
+     * In browser: uses DOMParser automatically.
+     * In Node.js: requires passing a `parseHtml` function that returns a Document.
+     *
+     * @param {string|Document} input  HTML string or existing Document
+     * @param {object} [options]
+     * @param {string} [options.url]
+     * @param {Function} [options.parseHtml]  Custom HTML parser: (html) => Document
+     * @returns {DefuddleResult}
+     */
+    static parse(input, options = {}) {
+      let doc;
+      if (typeof input === "string") {
+        if (options.parseHtml) {
+          doc = options.parseHtml(input);
+        } else if (typeof DOMParser !== "undefined") {
+          doc = new DOMParser().parseFromString(input, "text/html");
+        } else {
+          throw new Error(
+            'Defuddle.parse() requires a DOM environment. In Node.js, pass a parseHtml function: Defuddle.parse(html, { parseHtml: html => require("linkedom").parseHTML(html).document })'
+          );
+        }
+      } else {
+        doc = input;
+      }
+      return new _Defuddle(doc, options).parse();
+    }
+  };
+  var DefuddleResult = class {
+    constructor(data) {
+      this.content = data.content || "";
+      this.title = data.title || "";
+      this.description = data.description || "";
+      this.author = data.author || "";
+      this.published = data.published || "";
+      this.site = data.site || "";
+      this.domain = data.domain || "";
+      this.favicon = data.favicon || "";
+      this.image = data.image || "";
+      this.language = data.language || "";
+      this.wordCount = data.wordCount || 0;
+      this.parseTime = data.parseTime || 0;
+      this.schemaOrgData = data.schemaOrgData || null;
+      this.metaTags = data.metaTags || [];
+    }
+    toJSON() {
+      return {
+        content: this.content,
+        title: this.title,
+        description: this.description,
+        author: this.author,
+        published: this.published,
+        site: this.site,
+        domain: this.domain,
+        favicon: this.favicon,
+        image: this.image,
+        language: this.language,
+        wordCount: this.wordCount,
+        parseTime: this.parseTime,
+        schemaOrgData: this.schemaOrgData,
+        metaTags: this.metaTags
+      };
+    }
+  };
+  return __toCommonJS(index_exports);
+})();
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = DefuddleLib;
+} else if (typeof define === "function" && define.amd) {
+  define(function() { return DefuddleLib; });
+}