@j0hanz/superfetch 2.5.2 → 2.6.0

package/dist/dom-noise-removal.js

@@ -1,117 +1,32 @@
-/**
- * DOM noise removal utilities for cleaning HTML before markdown conversion.
- * Removes navigation, ads, popups, and other non-content elements.
- */
 import { parseHTML } from 'linkedom';
 import { config } from './config.js';
-import { isObject } from './type-guards.js';
-/* -------------------------------------------------------------------------------------------------
- * DOM guards & small helpers
- * ------------------------------------------------------------------------------------------------- */
-function isElement(node) {
-    return (isObject(node) &&
-        'getAttribute' in node &&
-        typeof node.getAttribute === 'function');
-}
-function isNodeListLike(value) {
-    return (isObject(value) &&
-        typeof value.length === 'number');
-}
-function getNodeListItem(nodes, index) {
-    if ('item' in nodes && typeof nodes.item === 'function') {
-        return nodes.item(index);
-    }
-    return nodes[index] ?? null;
-}
-/**
- * Remove nodes from a list/iterable.
- * - For NodeList-like collections we iterate backwards to be safe with live collections.
- * - For iterables we snapshot into an array first.
- */
-function removeNodes(nodes, shouldRemove) {
-    if (isNodeListLike(nodes)) {
-        for (let i = nodes.length - 1; i >= 0; i -= 1) {
-            const node = getNodeListItem(nodes, i);
-            if (node && shouldRemove(node))
-                node.remove();
-        }
-        return;
-    }
-    for (const node of nodes) {
-        if (shouldRemove(node))
-            node.remove();
-    }
-}
-/* -------------------------------------------------------------------------------------------------
- * Fast-path parsing heuristics
- * ------------------------------------------------------------------------------------------------- */
-const HTML_DOCUMENT_MARKERS = /<\s*(?:!doctype|html|head|body)\b/i;
-function isFullDocumentHtml(html) {
-    return HTML_DOCUMENT_MARKERS.test(html);
-}
+import { logDebug } from './observability.js';
+// --- Constants & Pre-compiled Regex ---
 const NOISE_SCAN_LIMIT = 50_000;
-const NOISE_MARKERS = [
-    '<script',
-    '<style',
-    '<noscript',
-    '<iframe',
-    '<nav',
-    '<footer',
-    '<header',
-    '<form',
-    '<button',
-    '<input',
-    '<select',
-    '<textarea',
-    '<svg',
-    '<canvas',
-    ' aria-hidden="true"',
-    " aria-hidden='true'",
-    ' hidden',
-    ' role="navigation"',
-    " role='navigation'",
-    ' role="banner"',
-    " role='banner'",
-    ' role="complementary"',
-    " role='complementary'",
-    ' role="contentinfo"',
-    " role='contentinfo'",
-    ' role="tree"',
-    " role='tree'",
-    ' role="menubar"',
-    " role='menubar'",
-    ' role="menu"',
-    " role='menu'",
-    ' banner',
-    ' promo',
-    ' announcement',
-    ' cta',
-    ' advert',
-    ' newsletter',
-    ' subscribe',
-    ' cookie',
-    ' consent',
-    ' popup',
-    ' modal',
-    ' overlay',
-    ' toast',
-    ' fixed',
-    ' sticky',
-    ' z-50',
-    ' z-4',
-    ' isolate',
-    ' breadcrumb',
-    ' pagination',
+const MIN_BODY_CONTENT_LENGTH = 100;
+const DIALOG_MIN_CHARS_FOR_PRESERVATION = 500;
+const NAV_FOOTER_MIN_CHARS_FOR_PRESERVATION = 500;
+// Merged markers for fast rejection
+const HTML_DOCUMENT_MARKERS = /<\s*(?:!doctype|html|head|body)\b/i;
+// Split into smaller regexes to stay within sonarjs/regex-complexity limit
+const NOISE_PATTERNS = [
+    /<\s*(?:script|style|noscript|iframe|nav|footer|header|form|button|input|select|textarea|svg|canvas)\b/i,
+    /[\s"']role\s*=\s*['"]?(?:navigation|banner|complementary|contentinfo|tree|menubar|menu)['"]?/i,
+    /[\s"'](?:aria-hidden\s*=\s*['"]?true['"]?|hidden)/i,
+    /[\s"'](?:banner|promo|announcement|cta|advert|newsletter|subscribe|cookie|consent|popup|modal|overlay|toast)\b/i,
+    /[\s"'](?:fixed|sticky|z-50|z-4|isolate|breadcrumb|pagination)\b/i,
 ];
-function mayContainNoise(html) {
-    const sample = html.length > NOISE_SCAN_LIMIT ? html.slice(0, NOISE_SCAN_LIMIT) : html;
-    const haystack = sample.toLowerCase();
-    return NOISE_MARKERS.some((marker) => haystack.includes(marker));
-}
-/* -------------------------------------------------------------------------------------------------
- * Noise selectors & classification
- * ------------------------------------------------------------------------------------------------- */
-const STRUCTURAL_TAGS = new Set([
+const HEADER_NOISE_PATTERN = /\b(site-header|masthead|topbar|navbar|nav(?:bar)?|menu|header-nav)\b/i;
+const FIXED_OR_HIGH_Z_PATTERN = /\b(?:fixed|sticky|z-(?:4\d|50)|isolate)\b/;
+const SKIP_URL_PREFIXES = [
+    '#',
+    'java' + 'script:',
+    'mailto:',
+    'tel:',
+    'data:',
+    'blob:',
+];
+const BASE_STRUCTURAL_TAGS = new Set([
     'script',
     'style',
     'noscript',
@@ -121,41 +36,8 @@ const STRUCTURAL_TAGS = new Set([
     'input',
     'select',
     'textarea',
-    'svg',
-    'canvas',
 ]);
 const ALWAYS_NOISE_TAGS = new Set(['nav', 'footer']);
-const BASE_NOISE_SELECTORS = [
-    'nav',
-    'footer',
-    'header[class*="site"]',
-    'header[class*="nav"]',
-    'header[class*="menu"]',
-    '[role="banner"]',
-    '[role="navigation"]',
-    '[role="dialog"]',
-    '[style*="display: none"]',
-    '[style*="display:none"]',
-    '[hidden]',
-    '[aria-hidden="true"]',
-];
-const BASE_NOISE_SELECTOR = BASE_NOISE_SELECTORS.join(',');
-const CANDIDATE_NOISE_SELECTOR = [
-    ...STRUCTURAL_TAGS,
-    ...ALWAYS_NOISE_TAGS,
-    'aside',
-    'header',
-    '[class]',
-    '[id]',
-    '[role]',
-    '[style]',
-].join(',');
-function buildNoiseSelector(extraSelectors) {
-    const extra = extraSelectors.filter((s) => s.trim().length > 0);
-    return extra.length === 0
-        ? BASE_NOISE_SELECTOR
-        : `${BASE_NOISE_SELECTOR},${extra.join(',')}`;
-}
 const NAVIGATION_ROLES = new Set([
     'navigation',
     'banner',
@@ -182,334 +64,410 @@ const INTERACTIVE_CONTENT_ROLES = new Set([
     'tooltip',
     'alert',
 ]);
-const BASE_PROMO_TOKENS = [
+const PROMO_TOKENS_ALWAYS = [
     'banner',
     'promo',
     'announcement',
     'cta',
     'advert',
-    'ad',
     'ads',
     'sponsor',
-    'newsletter',
-    'subscribe',
-    'cookie',
-    'consent',
-    'popup',
-    'modal',
-    'overlay',
-    'toast',
-    'share',
-    'social',
-    'related',
     'recommend',
-    'comment',
     'breadcrumb',
     'pagination',
     'pager',
     'taglist',
 ];
-const HEADER_NOISE_PATTERN = /\b(site-header|masthead|topbar|navbar|nav(?:bar)?|menu|header-nav)\b/i;
-const FIXED_PATTERN = /\b(fixed|sticky)\b/;
-const HIGH_Z_PATTERN = /\bz-(?:4\d|50)\b/;
-const ISOLATE_PATTERN = /\bisolate\b/;
-class PromoDetector {
-    tokenCache = null;
-    regexCache = null;
-    matches(className, id) {
-        const regex = this.getRegex();
-        return regex.test(className) || regex.test(id);
-    }
-    getTokens() {
-        if (this.tokenCache)
-            return this.tokenCache;
-        const tokens = new Set(BASE_PROMO_TOKENS);
-        for (const token of config.noiseRemoval.extraTokens) {
-            const normalized = token.toLowerCase().trim();
-            if (normalized)
-                tokens.add(normalized);
-        }
-        this.tokenCache = tokens;
-        return tokens;
+const PROMO_TOKENS_AGGRESSIVE = ['ad', 'related', 'comment'];
+const PROMO_TOKENS_BY_CATEGORY = {
+    'cookie-banners': ['cookie', 'consent', 'popup', 'modal', 'overlay', 'toast'],
+    newsletters: ['newsletter', 'subscribe'],
+    'social-share': ['share', 'social'],
+};
+const BASE_NOISE_SELECTORS = {
+    navFooter: 'nav,footer,header[class*="site"],header[class*="nav"],header[class*="menu"],[role="banner"],[role="navigation"]',
+    cookieBanners: '[role="dialog"]',
+    hidden: '[style*="display: none"],[style*="display:none"],[hidden],[aria-hidden="true"]',
+};
+const NO_MATCH_REGEX = /a^/i;
+// --- State Cache ---
+let cachedContext;
+let lastConfigRef;
+// --- Helpers Inlined/Optimized ---
+function escapeRegexLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildTokenRegex(tokens) {
+    if (tokens.size === 0)
+        return NO_MATCH_REGEX;
+    return new RegExp(`(?:^|[^a-z0-9])(?:${[...tokens].map(escapeRegexLiteral).join('|')})(?:$|[^a-z0-9])`, 'i');
+}
+function getPromoMatchers(currentConfig, flags) {
+    const baseTokens = new Set(PROMO_TOKENS_ALWAYS);
+    const aggressiveTokens = new Set();
+    if (currentConfig.aggressiveMode) {
+        for (const t of PROMO_TOKENS_AGGRESSIVE)
+            aggressiveTokens.add(t);
     }
-    getRegex() {
-        if (this.regexCache)
-            return this.regexCache;
-        const tokens = [...this.getTokens()];
-        const escaped = tokens.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-        const pattern = `(?:^|[^a-z0-9])(?:${escaped.join('|')})(?:$|[^a-z0-9])`;
-        this.regexCache = new RegExp(pattern, 'i');
-        return this.regexCache;
+    if (flags.cookieBanners)
+        for (const t of PROMO_TOKENS_BY_CATEGORY['cookie-banners'])
+            baseTokens.add(t);
+    if (flags.newsletters)
+        for (const t of PROMO_TOKENS_BY_CATEGORY['newsletters'])
+            baseTokens.add(t);
+    if (flags.socialShare)
+        for (const t of PROMO_TOKENS_BY_CATEGORY['social-share'])
+            baseTokens.add(t);
+    for (const t of currentConfig.extraTokens) {
+        const n = t.toLowerCase().trim();
+        if (n)
+            baseTokens.add(n);
     }
+    return {
+        base: buildTokenRegex(baseTokens),
+        aggressive: buildTokenRegex(aggressiveTokens),
+    };
 }
-class NoiseClassifier {
-    promo;
-    constructor(promo) {
-        this.promo = promo;
+function getContext() {
+    const currentConfig = config.noiseRemoval;
+    if (cachedContext && lastConfigRef === currentConfig) {
+        return cachedContext;
     }
-    isNoise(element) {
-        const meta = this.readMetadata(element);
-        if (this.isStructuralNoise(meta, element))
-            return true;
-        if (ALWAYS_NOISE_TAGS.has(meta.tagName))
-            return true;
-        if (this.isHeaderBoilerplate(meta))
-            return true;
-        if (this.isHiddenNoise(meta, element))
+    const enabled = new Set(currentConfig.enabledCategories
+        .map((c) => {
+        const s = c.toLowerCase().trim();
+        const { locale } = config.i18n;
+        return locale ? s.toLocaleLowerCase(locale) : s;
+    })
+        .filter(Boolean));
+    const isEnabled = (cat) => enabled.has(cat);
+    const flags = {
+        navFooter: isEnabled('nav-footer'),
+        cookieBanners: isEnabled('cookie-banners'),
+        newsletters: isEnabled('newsletters'),
+        socialShare: isEnabled('social-share'),
+    };
+    const structuralTags = new Set(BASE_STRUCTURAL_TAGS);
+    if (!currentConfig.preserveSvgCanvas) {
+        structuralTags.add('svg');
+        structuralTags.add('canvas');
+    }
+    const promoMatchers = getPromoMatchers(currentConfig, flags);
+    const extraSelectors = currentConfig.extraSelectors
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    // Pre-build selectors
+    const selectors = [BASE_NOISE_SELECTORS.hidden];
+    if (flags.navFooter)
+        selectors.push(BASE_NOISE_SELECTORS.navFooter);
+    if (flags.cookieBanners)
+        selectors.push(BASE_NOISE_SELECTORS.cookieBanners);
+    const baseSelector = selectors.join(',');
+    const candidateSelector = [
+        ...structuralTags,
+        ...ALWAYS_NOISE_TAGS,
+        'aside',
+        'header',
+        '[class]',
+        '[id]',
+        '[role]',
+        '[style]',
+    ].join(',');
+    cachedContext = {
+        flags,
+        structuralTags,
+        weights: currentConfig.weights,
+        promoMatchers,
+        promoEnabled: flags.cookieBanners || flags.newsletters || flags.socialShare,
+        extraSelectors,
+        baseSelector,
+        candidateSelector,
+    };
+    lastConfigRef = currentConfig;
+    return cachedContext;
+}
+// --- Hot Path Logic ---
+function isInteractive(element, role) {
+    if (role && INTERACTIVE_CONTENT_ROLES.has(role))
+        return true;
+    const ds = element.getAttribute('data-state');
+    if (ds === 'inactive' || ds === 'closed')
+        return true;
+    const dataOrientation = element.getAttribute('data-orientation');
+    if (dataOrientation === 'horizontal' || dataOrientation === 'vertical')
+        return true;
+    return (element.hasAttribute('data-accordion-item') ||
+        element.hasAttribute('data-radix-collection-item'));
+}
+function isWithinPrimaryContent(element) {
+    let current = element;
+    while (current) {
+        const tagName = current.tagName.toLowerCase();
+        if (tagName === 'article' || tagName === 'main')
             return true;
-        if (this.isRoleNoise(meta))
+        if (current.getAttribute('role') === 'main')
             return true;
-        if (this.matchesFixedOrHighZIsolate(meta.className))
+        current = current.parentElement;
+    }
+    return false;
+}
+function shouldPreserve(element, tagName) {
+    // Check Dialog
+    const role = element.getAttribute('role');
+    if (role === 'dialog' || role === 'alertdialog') {
+        if (isWithinPrimaryContent(element))
             return true;
-        if (this.promo.matches(meta.className, meta.id))
+        const textLen = (element.textContent || '').length;
+        if (textLen > DIALOG_MIN_CHARS_FOR_PRESERVATION)
             return true;
-        return false;
-    }
-    readMetadata(element) {
-        return {
-            tagName: element.tagName.toLowerCase(),
-            className: element.getAttribute('class') ?? '',
-            id: element.getAttribute('id') ?? '',
-            role: element.getAttribute('role'),
-            isHidden: this.isHidden(element),
-        };
-    }
-    isStructuralNoise(meta, element) {
-        if (!STRUCTURAL_TAGS.has(meta.tagName))
-            return false;
-        // Interactive structural components (dialogs, menus) are handled elsewhere.
-        return !this.isInteractiveComponent(element);
+        return element.querySelector('h1,h2,h3,h4,h5,h6') !== null;
     }
-    isHeaderBoilerplate(meta) {
-        if (meta.tagName !== 'header')
-            return false;
-        if (this.hasNoiseRole(meta.role))
+    // Check Nav/Footer
+    if (tagName === 'nav' || tagName === 'footer') {
+        if (element.querySelector('article,main,section,[role="main"]'))
             return true;
-        const combined = `${meta.className} ${meta.id}`.toLowerCase();
-        return HEADER_NOISE_PATTERN.test(combined);
-    }
-    isHiddenNoise(meta, element) {
-        if (!meta.isHidden)
-            return false;
-        // Don't remove hidden interactive components (they may be managed by UI framework state).
-        return !this.isInteractiveComponent(element);
-    }
-    isRoleNoise(meta) {
-        const isComplementaryAside = meta.tagName === 'aside' && meta.role === 'complementary';
-        if (isComplementaryAside)
-            return false;
-        return this.hasNoiseRole(meta.role);
-    }
-    hasNoiseRole(role) {
-        return role !== null && NAVIGATION_ROLES.has(role);
+        return ((element.textContent || '').trim().length >=
+            NAV_FOOTER_MIN_CHARS_FOR_PRESERVATION);
     }
-    matchesFixedOrHighZIsolate(className) {
-        return (FIXED_PATTERN.test(className) ||
-            (HIGH_Z_PATTERN.test(className) && ISOLATE_PATTERN.test(className)));
+    return false;
+}
+function removeNodes(nodes) {
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        const node = nodes[i];
+        if (node?.parentNode && !shouldPreserve(node, node.tagName.toLowerCase())) {
+            node.remove();
+        }
     }
-    isHidden(element) {
-        const style = element.getAttribute('style') ?? '';
-        return (element.getAttribute('hidden') !== null ||
-            element.getAttribute('aria-hidden') === 'true' ||
-            /\bdisplay\s*:\s*none\b/i.test(style) ||
-            /\bvisibility\s*:\s*hidden\b/i.test(style));
+}
+function scoreNavFooter(tagName, role, className, id, weights) {
+    let score = 0;
+    if (ALWAYS_NOISE_TAGS.has(tagName))
+        score += weights.structural;
+    // Header Boilerplate
+    if (tagName === 'header') {
+        if ((role && NAVIGATION_ROLES.has(role)) ||
+            HEADER_NOISE_PATTERN.test(`${className} ${id}`)) {
+            score += weights.structural;
+        }
     }
-    isInteractiveComponent(element) {
-        const role = element.getAttribute('role');
-        if (role && INTERACTIVE_CONTENT_ROLES.has(role))
-            return true;
-        const dataState = element.getAttribute('data-state');
-        if (dataState === 'inactive' || dataState === 'closed')
-            return true;
-        const dataOrientation = element.getAttribute('data-orientation');
-        if (dataOrientation === 'horizontal' || dataOrientation === 'vertical')
-            return true;
-        if (element.getAttribute('data-accordion-item') !== null)
-            return true;
-        if (element.getAttribute('data-radix-collection-item') !== null)
-            return true;
-        return false;
+    // Role Noise
+    if (role && NAVIGATION_ROLES.has(role)) {
+        if (tagName !== 'aside' || role !== 'complementary') {
+            score += weights.structural;
+        }
     }
+    return score;
 }
-class NoiseStripper {
-    classifier;
-    constructor(classifier) {
-        this.classifier = classifier;
+function isNoiseElement(element, context) {
+    const tagName = element.tagName.toLowerCase();
+    const className = element.getAttribute('class') ?? '';
+    const id = element.getAttribute('id') ?? '';
+    const role = element.getAttribute('role');
+    const _isInteractive = isInteractive(element, role);
+    const style = element.getAttribute('style');
+    const isHidden = element.hasAttribute('hidden') ||
+        element.getAttribute('aria-hidden') === 'true' ||
+        (style !== null &&
+            /\b(?:display\s*:\s*none|visibility\s*:\s*hidden)\b/i.test(style));
+    let score = 0;
+    const { weights } = context;
+    // Structural
+    if (context.structuralTags.has(tagName) && !_isInteractive) {
+        score += weights.structural;
     }
-    strip(document) {
-        this.removeBySelector(document, buildNoiseSelector(config.noiseRemoval.extraSelectors), 
-        /* checkNoise */ false);
-        this.removeBySelector(document, CANDIDATE_NOISE_SELECTOR, 
-        /* checkNoise */ true);
+    // Nav/Footer Scoring
+    if (context.flags.navFooter) {
+        score += scoreNavFooter(tagName, role, className, id, weights);
     }
-    removeBySelector(document, selector, checkNoise) {
-        const nodes = document.querySelectorAll(selector);
-        removeNodes(nodes, (node) => {
-            if (!isElement(node))
-                return false;
-            return checkNoise ? this.classifier.isNoise(node) : true;
-        });
+    // Hidden
+    if (isHidden && !_isInteractive) {
+        score += weights.hidden;
     }
-}
-/* -------------------------------------------------------------------------------------------------
- * Relative URL resolution
- * ------------------------------------------------------------------------------------------------- */
-const SKIP_URL_PREFIXES = [
-    '#',
-    'java' + 'script:',
-    'mailto:',
-    'tel:',
-    'data:',
-    'blob:',
-];
-function shouldSkipUrlResolution(url) {
-    const normalized = url.trim().toLowerCase();
-    return SKIP_URL_PREFIXES.some((prefix) => normalized.startsWith(prefix));
-}
-function tryResolveUrl(relativeUrl, baseUrl) {
-    try {
-        return new URL(relativeUrl, baseUrl).href;
+    // Sticky/Fixed
+    if (FIXED_OR_HIGH_Z_PATTERN.test(className)) {
+        score += weights.stickyFixed;
     }
-    catch {
-        return null;
+    // Promo
+    if (context.promoEnabled) {
+        const aggTest = context.promoMatchers.aggressive.test(className) ||
+            context.promoMatchers.aggressive.test(id);
+        const isAggressiveMatch = aggTest && !isWithinPrimaryContent(element);
+        const isBaseMatch = !aggTest &&
+            (context.promoMatchers.base.test(className) ||
+                context.promoMatchers.base.test(id));
+        if (isAggressiveMatch || isBaseMatch) {
+            score += weights.promo;
+        }
     }
+    return score >= weights.threshold;
 }
-class RelativeUrlResolver {
-    resolve(document, baseUrl) {
-        let base;
-        try {
-            base = new URL(baseUrl);
-        }
-        catch {
-            // invalid base URL - skip resolution
-            return;
-        }
-        for (const element of document.querySelectorAll('a[href], img[src], source[srcset]')) {
-            const tag = element.tagName.toLowerCase();
-            if (tag === 'a')
-                this.resolveAnchor(element, base);
-            else if (tag === 'img')
-                this.resolveImage(element, base);
-            else if (tag === 'source')
-                this.resolveSource(element, base);
+function cleanHeadingWrapperDivs(h) {
+    const divs = h.querySelectorAll('div');
+    for (let j = divs.length - 1; j >= 0; j--) {
+        const d = divs[j];
+        if (!d?.parentNode)
+            continue;
+        const cls = d.getAttribute('class') ?? '';
+        const stl = d.getAttribute('style') ?? '';
+        if (cls.includes('absolute') ||
+            stl.includes('position') ||
+            d.getAttribute('tabindex') === '-1') {
+            d.remove();
         }
     }
-    resolveAnchor(element, base) {
-        const href = element.getAttribute('href');
-        if (!href || shouldSkipUrlResolution(href))
-            return;
-        const resolved = tryResolveUrl(href, base);
-        if (resolved)
-            element.setAttribute('href', resolved);
+}
+function cleanHeadingAnchors(h) {
+    const anchors = h.querySelectorAll('a');
+    for (let j = anchors.length - 1; j >= 0; j--) {
+        const a = anchors[j];
+        if (!a?.parentNode)
+            continue;
+        const href = a.getAttribute('href') ?? '';
+        const txt = (a.textContent || '').replace(/[\u200B\s]/g, '');
+        if (href.startsWith('#') && txt.length === 0) {
+            a.remove();
+        }
     }
-    resolveImage(element, base) {
-        const src = element.getAttribute('src');
-        if (!src || shouldSkipUrlResolution(src))
-            return;
-        const resolved = tryResolveUrl(src, base);
-        if (resolved)
-            element.setAttribute('src', resolved);
+}
+function cleanHeadingZeroWidth(h, document) {
+    const walker = document.createTreeWalker(h, 4); // SHOW_TEXT
+    let node;
+    while ((node = walker.nextNode())) {
+        if (node.textContent?.includes('\u200B')) {
+            node.textContent = node.textContent.replace(/\u200B/g, '');
+        }
     }
-    /**
-     * Keep original behavior: srcset entries are always attempted to be resolved (no prefix skipping).
-     */
-    resolveSource(element, base) {
-        const srcset = element.getAttribute('srcset');
-        if (!srcset)
-            return;
-        const resolved = srcset
-            .split(',')
-            .map((entry) => {
-            const parts = entry.trim().split(/\s+/);
-            const url = parts[0];
-            if (url) {
-                const resolvedUrl = tryResolveUrl(url, base);
-                if (resolvedUrl)
-                    parts[0] = resolvedUrl;
-            }
-            return parts.join(' ');
-        })
-            .join(', ');
-        element.setAttribute('srcset', resolved);
+}
+function cleanHeadings(document) {
+    // Clean Heading Anchors
+    const headings = document.querySelectorAll('h1,h2,h3,h4,h5,h6');
+    for (const h of headings) {
+        if (!h.parentNode)
+            continue;
+        cleanHeadingWrapperDivs(h);
+        cleanHeadingAnchors(h);
+        cleanHeadingZeroWidth(h, document);
     }
 }
-/* -------------------------------------------------------------------------------------------------
- * Serialization
- * ------------------------------------------------------------------------------------------------- */
-class DocumentSerializer {
-    /**
-     * Preserve existing behavior:
-     * - Prefer body.innerHTML only if it has "substantial" content (> 100 chars).
-     * - Otherwise fall back to document.toString(), then documentElement.outerHTML, then original HTML.
-     */
-    serialize(document, fallbackHtml) {
-        const bodyInner = this.getBodyInnerHtml(document);
-        if (bodyInner && bodyInner.trim().length > 100)
-            return bodyInner;
-        const toStringFn = this.getDocumentToString(document);
-        if (toStringFn)
-            return toStringFn();
-        const outer = this.getDocumentElementOuterHtml(document);
-        if (outer)
-            return outer;
-        return fallbackHtml;
+function stripNoise(document, context) {
+    cleanHeadings(document);
+    // Remove Base & Extra
+    const { baseSelector, extraSelectors } = context;
+    // Base
+    const baseNodes = document.querySelectorAll(baseSelector);
+    removeNodes(baseNodes);
+    // Extra
+    if (extraSelectors.length > 0) {
+        const combinedExtra = extraSelectors.join(',');
+        const extraNodes = document.querySelectorAll(combinedExtra);
+        removeNodes(extraNodes);
     }
-    getBodyInnerHtml(document) {
-        if (!isObject(document))
-            return undefined;
-        const { body } = document;
-        if (isObject(body) &&
-            typeof body.innerHTML === 'string') {
-            return body.innerHTML;
+    // Candidates
+    const candidates = document.querySelectorAll(context.candidateSelector);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const node = candidates[i];
+        if (!node)
+            continue;
+        if (!node.parentNode)
+            continue;
+        if (shouldPreserve(node, node.tagName.toLowerCase()))
+            continue;
+        if (isNoiseElement(node, context)) {
+            node.remove();
         }
-        return undefined;
     }
-    getDocumentToString(document) {
-        if (!isObject(document))
-            return undefined;
-        const fn = document.toString;
-        if (typeof fn === 'function')
-            return fn.bind(document);
-        return undefined;
-    }
-    getDocumentElementOuterHtml(document) {
-        if (!isObject(document))
-            return undefined;
-        const docEl = document.documentElement;
-        if (isObject(docEl) &&
-            typeof docEl.outerHTML === 'string') {
-            return docEl.outerHTML;
+}
+function processUrlElement(el, attr, base, isSrcset) {
+    if (!el.parentNode)
+        return;
+    if (isSrcset) {
+        const val = el.getAttribute(attr);
+        if (val) {
+            const newVal = val
+                .split(',')
+                .map((entry) => {
+                const parts = entry.trim().split(/\s+/);
+                if (!parts[0])
+                    return entry;
+                try {
+                    parts[0] = new URL(parts[0], base).href;
+                }
+                catch {
+                    /* ignore */
+                }
+                return parts.join(' ');
+            })
+                .join(', ');
+            el.setAttribute(attr, newVal);
         }
-        return undefined;
+        return;
     }
-}
-/* -------------------------------------------------------------------------------------------------
- * Public pipeline
- * ------------------------------------------------------------------------------------------------- */
-class HtmlNoiseRemovalPipeline {
-    promo = new PromoDetector();
-    classifier = new NoiseClassifier(this.promo);
-    stripper = new NoiseStripper(this.classifier);
-    urlResolver = new RelativeUrlResolver();
-    serializer = new DocumentSerializer();
-    removeNoise(html, document, baseUrl) {
-        const shouldParse = isFullDocumentHtml(html) || mayContainNoise(html);
-        if (!shouldParse)
-            return html;
+    const val = el.getAttribute(attr);
+    if (val &&
+        !SKIP_URL_PREFIXES.some((p) => val.trim().toLowerCase().startsWith(p))) {
         try {
-            const resolvedDocument = document ?? parseHTML(html).document;
-            this.stripper.strip(resolvedDocument);
-            if (baseUrl) {
-                this.urlResolver.resolve(resolvedDocument, baseUrl);
-            }
-            return this.serializer.serialize(resolvedDocument, html);
+            el.setAttribute(attr, new URL(val, base).href);
         }
         catch {
-            return html;
+            /* ignore */
         }
     }
 }
-const pipeline = new HtmlNoiseRemovalPipeline();
+function resolveUrls(document, baseUrlStr) {
+    let base;
+    try {
+        base = new URL(baseUrlStr);
+    }
+    catch {
+        return;
+    }
+    const elements = document.querySelectorAll('a[href],img[src],source[srcset]');
+    for (const el of Array.from(elements)) {
+        const tag = el.tagName.toLowerCase();
+        if (tag === 'a')
+            processUrlElement(el, 'href', base, false);
+        else if (tag === 'img')
+            processUrlElement(el, 'src', base, false);
+        else if (tag === 'source')
+            processUrlElement(el, 'srcset', base, true);
+    }
+}
+function serialize(document, fallback) {
+    const bodyHtml = document.body.innerHTML;
+    if (bodyHtml.trim().length > MIN_BODY_CONTENT_LENGTH)
+        return bodyHtml;
+    const outerHtml = document.documentElement.outerHTML;
+    if (outerHtml.trim().length > MIN_BODY_CONTENT_LENGTH)
+        return outerHtml;
+    return fallback;
+}
+function isFullDocumentHtml(html) {
+    return HTML_DOCUMENT_MARKERS.test(html);
+}
+function mayContainNoise(html) {
+    const sample = html.length <= NOISE_SCAN_LIMIT
+        ? html
+        : `${html.substring(0, NOISE_SCAN_LIMIT)}\n${html.substring(html.length - NOISE_SCAN_LIMIT)}`;
+    return NOISE_PATTERNS.some((re) => re.test(sample));
+}
 export function removeNoiseFromHtml(html, document, baseUrl) {
-    return pipeline.removeNoise(html, document, baseUrl);
+    const shouldParse = isFullDocumentHtml(html) || mayContainNoise(html);
+    if (!shouldParse)
+        return html;
+    try {
+        const context = getContext();
+        if (config.noiseRemoval.debug) {
+            logDebug('Noise removal audit enabled', {
+                categories: [...(context.flags.navFooter ? ['nav-footer'] : [])],
+            });
+        }
+        const doc = document ?? parseHTML(html).document;
+        stripNoise(doc, context);
+        if (baseUrl)
+            resolveUrls(doc, baseUrl);
+        return serialize(doc, html);
+    }
+    catch {
+        return html;
+    }
 }