webforai 4.0.0 → 4.1.1

package/dist/cjs/extractors/lib/code-tabs.js

@@ -0,0 +1,191 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var code_tabs_exports = {};
+__export(code_tabs_exports, {
+  CodeTabCollector: () => CodeTabCollector
+});
+module.exports = __toCommonJS(code_tabs_exports);
+var import_hast_fast = require("../../utils/hast-fast");
+const MAX_LABEL_LENGTH = 80;
+class CodeTabCollector {
+  #groups = [];
+  /** Groups whose tab list's parent is still being traversed, innermost last. */
+  #open = [];
+  #isHidden;
+  #radioStrips = [];
+  /** @param isHidden - Elements whose text a reader never sees, excluded from labels. */
+  constructor(isHidden) {
+    this.#isHidden = isHidden;
+  }
+  #applyRadioStrip(strip, parent) {
+    const labels = strip.children.filter((child) => (0, import_hast_fast.isElement)(child) && child.tagName === "label");
+    const panels = radioStripPanels(strip, parent);
+    if (!panels || panels.length !== labels.length) {
+      return;
+    }
+    panels.forEach((panel, index) => labelCode(panel, tabLabel(labels[index], this.#isHidden)));
+    parent.children.splice(parent.children.indexOf(strip), 1);
+  }
+  /**
+   * Call for every element, in document order, with its depth.
+   *
+   * A group only collects panels inside the tab list's parent: a page-level tab strip must not
+   * lend its labels to an unrelated code switcher further down, and an inner group closes before
+   * the outer group's next panel.
+   */
+  visit(element, depth, parent) {
+    if (isRadioTabStrip(element)) {
+      this.#radioStrips.push({ strip: element, parent });
+      return;
+    }
+    while (this.#open.length > 0 && depth < (this.#open.at(-1)?.depth ?? 0)) {
+      this.#open.pop();
+    }
+    const role = (0, import_hast_fast.stringProperty)(element, "role");
+    if (role === "tablist") {
+      const group2 = { tabs: [], panels: [] };
+      this.#groups.push(group2);
+      this.#open.push({ group: group2, depth });
+      return;
+    }
+    const group = this.#open.at(-1)?.group;
+    if (!group) {
+      return;
+    }
+    if (role === "tab") {
+      group.tabs.push(element);
+    } else if (role === "tabpanel") {
+      group.panels.push(element);
+    }
+  }
+  /** Labels the code block of every panel whose tab could be identified. */
+  apply() {
+    for (const { strip, parent } of this.#radioStrips) {
+      this.#applyRadioStrip(strip, parent);
+    }
+    for (const group of this.#groups) {
+      if (group.tabs.length < 2 || group.panels.length === 0) {
+        continue;
+      }
+      for (const [panel, tab] of matchTabs(group)) {
+        labelCode(panel, tabLabel(tab, this.#isHidden));
+      }
+    }
+  }
+}
+const radioStripPanels = (strip, parent) => {
+  const index = parent.children.indexOf(strip);
+  for (let cursor = index + 1; cursor < parent.children.length; cursor++) {
+    const sibling = parent.children[cursor];
+    if ((0, import_hast_fast.isElement)(sibling)) {
+      return sibling.children.filter(import_hast_fast.isElement);
+    }
+  }
+  return void 0;
+};
+const isRadioTabStrip = (element) => {
+  const first = element.children.find(import_hast_fast.isElement);
+  if (!(first?.tagName === "input" && (0, import_hast_fast.stringProperty)(first, "type") === "radio")) {
+    return false;
+  }
+  let labels = 0;
+  for (const child of element.children) {
+    if (!(0, import_hast_fast.isElement)(child)) {
+      continue;
+    }
+    if (child.tagName === "label") {
+      labels += 1;
+    } else if (!(child.tagName === "input" && (0, import_hast_fast.stringProperty)(child, "type") === "radio")) {
+      return false;
+    }
+  }
+  return labels >= 2;
+};
+const indexById = (elements) => {
+  const byId = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    const id = (0, import_hast_fast.stringProperty)(element, "id");
+    if (id) {
+      byId.set(id, element);
+    }
+  }
+  return byId;
+};
+const matchTabs = ({ tabs, panels }) => {
+  const tabById = indexById(tabs);
+  const panelById = indexById(panels);
+  const tabOf = /* @__PURE__ */ new Map();
+  for (const panel of panels) {
+    const tab = tabById.get((0, import_hast_fast.stringProperty)(panel, "ariaLabelledBy") ?? "");
+    if (tab) {
+      tabOf.set(panel, tab);
+    }
+  }
+  for (const tab of tabs) {
+    const panel = panelById.get((0, import_hast_fast.stringProperty)(tab, "ariaControls") ?? "");
+    if (panel && !tabOf.has(panel)) {
+      tabOf.set(panel, tab);
+    }
+  }
+  if (tabOf.size === 0 && tabs.length === panels.length) {
+    panels.forEach((panel, index) => tabOf.set(panel, tabs[index]));
+  }
+  return tabOf;
+};
+const tabLabel = (tab, isHidden) => {
+  const label = (textOf(tab, isHidden) || (0, import_hast_fast.stringProperty)(tab, "dataTitle") || "").replace(/\s+/g, " ").trim();
+  return label.length > 0 && label.length <= MAX_LABEL_LENGTH ? label : void 0;
+};
+const labelCode = (panel, label) => {
+  if (!label) {
+    return;
+  }
+  const blocks = [];
+  collectPre(panel, blocks);
+  if (blocks.length === 1 && (0, import_hast_fast.stringProperty)(blocks[0], "dataTitle") === void 0) {
+    blocks[0].properties.dataTitle = label;
+  }
+};
+const collectPre = (element, into) => {
+  for (const child of element.children) {
+    if (!(0, import_hast_fast.isElement)(child) || into.length > 1) {
+      continue;
+    }
+    if (child.tagName === "pre") {
+      into.push(child);
+      continue;
+    }
+    collectPre(child, into);
+  }
+};
+const textOf = (element, isHidden) => {
+  let text = "";
+  for (const child of element.children) {
+    if (child.type === "text") {
+      text += child.value;
+    } else if ((0, import_hast_fast.isElement)(child) && !isHidden(child)) {
+      text += textOf(child, isHidden);
+    }
+  }
+  return text;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodeTabCollector
+});

package/dist/cjs/extractors/lib/constants.js

@@ -43,7 +43,7 @@ const REGEXPS = {
    * `class="post-header"`), so matching them here deletes the page's headings. The landmark
    * versions of those elements are handled structurally instead.
    */
-  unlikelyCandidates: /-ad-|ai2html|banner|breadcrumb|combx|comment(?!ary)|community|cover-wrap|disqus|gdpr|legends|menu|related|remark|replies|rss|shoutbox|sidebar|site-index|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote|speechify-ignore|avatar|subscribe|newsletter|paywall|consent|cookie|toolbar|masthead|promo|share|sharing|widget|tooltip|dropdown|modal|overlay|backdrop|carousel|announcement|notification|toast|skip-link|screen-reader|visually-hidden|sr-only/i,
+  unlikelyCandidates: /-ad-|ai2html|banner|breadcrumb|combx|comment(?!ary)|community|cover-wrap|disqus|gdpr|legends|menu|related|remark|replies|rss|shoutbox|sidebar|site-index|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote|speechify-ignore|avatar|subscribe|newsletter|paywall|consent|cookie|toolbar|masthead|promo|share|sharing|widget|tooltip|dropdown|modal|overlay|backdrop|carousel|announcement|notification|toast|skip-link|screen-reader|(?<!not-)visually-hidden|(?<!not-)sr-only/i,
   /** Rescues containers whose class merely happens to contain an unlikely substring. */
   okMaybeItsaCandidate: /and|article|body|column|content|main|shadow|code|post|entry|story|markdown|prose|doc/i,
   /** Very high-confidence boilerplate, not rescued by the clause above. */

package/dist/cjs/extractors/lib/layout-tables.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var layout_tables_exports = {};
+__export(layout_tables_exports, {
+  isLayoutTable: () => isLayoutTable,
+  unwrapLayoutTables: () => unwrapLayoutTables
+});
+module.exports = __toCommonJS(layout_tables_exports);
+var import_hast_fast = require("../../utils/hast-fast");
+const DATA_MARKERS = /* @__PURE__ */ new Set(["caption", "thead", "tfoot", "th", "col", "colgroup"]);
+const BLOCK_IN_CELL = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6", "table", "form"]);
+const TABLE_PARTS = /* @__PURE__ */ new Set(["tbody", "thead", "tfoot", "tr", "td", "th"]);
+const TABLE_CONTEXT = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]);
+const shapeOf = (table) => {
+  const shape = { rows: 0, columns: 0, dataMarker: false, blockInCell: false };
+  const visit = (node, inCell) => {
+    for (const child of node.children) {
+      if (!(0, import_hast_fast.isElement)(child)) {
+        continue;
+      }
+      const tag = child.tagName;
+      if (tag === "table") {
+        shape.blockInCell = shape.blockInCell || inCell;
+        continue;
+      }
+      if (DATA_MARKERS.has(tag)) {
+        shape.dataMarker = true;
+      }
+      if (tag === "tr") {
+        shape.rows += 1;
+        const cells = child.children.filter(
+          (cell) => (0, import_hast_fast.isElement)(cell) && (cell.tagName === "td" || cell.tagName === "th")
+        ).length;
+        shape.columns = Math.max(shape.columns, cells);
+      }
+      if (inCell && BLOCK_IN_CELL.has(tag)) {
+        shape.blockInCell = true;
+      }
+      visit(child, inCell || tag === "td" || tag === "th");
+    }
+  };
+  visit(table, false);
+  return shape;
+};
+const isLayoutTable = (table) => {
+  const role = (0, import_hast_fast.stringProperty)(table, "role");
+  if (role === "presentation" || role === "none" || (0, import_hast_fast.stringProperty)(table, "datatable") === "0") {
+    return true;
+  }
+  const shape = shapeOf(table);
+  if (shape.blockInCell) {
+    return true;
+  }
+  if (shape.dataMarker) {
+    return false;
+  }
+  if (shape.rows <= 1 || shape.columns <= 1) {
+    return true;
+  }
+  if (shape.rows >= 10 || shape.columns > 4) {
+    return false;
+  }
+  return shape.rows * shape.columns <= 10;
+};
+const unwrap = (table) => {
+  const cells = [];
+  const collect = (node) => {
+    for (const child of node.children) {
+      if (!(0, import_hast_fast.isElement)(child)) {
+        continue;
+      }
+      if (child.tagName === "td" || child.tagName === "th") {
+        cells.push({ type: "element", tagName: "div", properties: {}, children: child.children });
+      } else if (child.tagName !== "table") {
+        collect(child);
+      }
+    }
+  };
+  collect(table);
+  return { type: "element", tagName: "div", properties: {}, children: cells };
+};
+const unwrapLayoutTables = (root) => {
+  const visit = (parent) => {
+    const parentTag = (0, import_hast_fast.isElement)(parent) ? parent.tagName : "";
+    for (let index = 0; index < parent.children.length; index++) {
+      const child = parent.children[index];
+      if (!(0, import_hast_fast.isElement)(child)) {
+        continue;
+      }
+      if (TABLE_PARTS.has(child.tagName) && !TABLE_CONTEXT.has(parentTag)) {
+        child.tagName = "div";
+      }
+      visit(child);
+      if (child.tagName === "table" && isLayoutTable(child)) {
+        parent.children[index] = unwrap(child);
+      }
+    }
+  };
+  if ("children" in root) {
+    visit(root);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isLayoutTable,
+  unwrapLayoutTables
+});

package/dist/cjs/extractors/lib/sanitize.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sanitize_exports = {};
 __export(sanitize_exports, {
+  REFERENCE_HEADING: () => REFERENCE_HEADING,
   cleanContent: () => cleanContent,
   dropEmptyElements: () => dropEmptyElements,
   findCleanupTargets: () => findCleanupTargets,
@@ -25,30 +26,46 @@ __export(sanitize_exports, {
   findUnlikelyElements: () => findUnlikelyElements,
   hoistNoscriptImages: () => hoistNoscriptImages,
   stripNonContent: () => stripNonContent,
-  stripUnlikely: () => stripUnlikely
+  stripUnlikely: () => stripUnlikely,
+  unlikelyTier: () => unlikelyTier
 });
 module.exports = __toCommonJS(sanitize_exports);
 var import_hast_fast = require("../../utils/hast-fast");
+var import_code_tabs = require("./code-tabs");
 var import_constants = require("./constants");
 var import_ui_chrome = require("./ui-chrome");
 const INVISIBLE_STYLE = /(^|;)\s*(display\s*:\s*none|visibility\s*:\s*hidden)\s*(;|$)/i;
 const hasHiddenClass = (element) => {
   const classes = (0, import_hast_fast.classList)(element);
   if (!classes.some((name) => import_constants.HIDDEN_CLASS_NAMES.has(name))) {
-    return classes.some((name) => import_constants.REGEXPS.hidden.test(name));
+    return classes.some((name) => import_constants.REGEXPS.hidden.test(name) || isScreenReaderOnlyClass(name));
   }
   return !classes.some((name) => import_constants.RESPONSIVE_DISPLAY_OVERRIDE.test(name));
 };
+const SCREEN_READER_ONLY = /^(sronly|visuallyhidden|screenreader(only|text))(focusable|styles\w*)?$/;
+const isScreenReaderOnlyClass = (name) => {
+  const first = name.charCodeAt(0) | 32;
+  if (first !== 115 && first !== 118) {
+    return false;
+  }
+  return SCREEN_READER_ONLY.test(name.toLowerCase().replace(/[-_]/g, ""));
+};
 const isNonContent = (node) => {
   if (node.type === "comment" || node.type === "doctype") {
     return true;
   }
   return (0, import_hast_fast.isElement)(node) && import_constants.NON_CONTENT_TAGS.has(node.tagName);
 };
-const isHidden = (element) => {
+const isHidden = (element, parent, siblingCode) => {
+  if (!looksHidden(element)) {
+    return false;
+  }
   if (containsMath(element)) {
     return false;
   }
+  return !isHiddenCodePanel(element, parent, siblingCode);
+};
+const looksHidden = (element) => {
   if ((0, import_hast_fast.isTruthyAttribute)(element, "hidden")) {
     return true;
   }
@@ -61,10 +78,57 @@ const isHidden = (element) => {
   }
   const width = (0, import_hast_fast.numericProperty)(element, "data-rwidth");
   const height = (0, import_hast_fast.numericProperty)(element, "data-rheight");
-  if (width === 0 && height === 0) {
+  return width === 0 && height === 0;
+};
+const MAX_CODE_PANEL_PROSE = 200;
+const panelCode = (element) => {
+  let code = "";
+  let prose = 0;
+  const visit = (node, insideCode) => {
+    for (const child of node.children) {
+      if (child.type === "text") {
+        if (insideCode) {
+          code += child.value;
+        } else {
+          prose += child.value.trim().length;
+          if (prose > MAX_CODE_PANEL_PROSE) {
+            return false;
+          }
+        }
+      } else if ((0, import_hast_fast.isElement)(child) && !visit(child, insideCode || child.tagName === "pre")) {
+        return false;
+      }
+    }
     return true;
+  };
+  return visit(element, element.tagName === "pre") && code.trim().length > 0 ? code : void 0;
+};
+const visibleSiblingCode = (parent, cache) => {
+  let codes = cache.get(parent);
+  if (!codes) {
+    codes = /* @__PURE__ */ new Set();
+    for (const child of parent.children) {
+      if ((0, import_hast_fast.isElement)(child) && !looksHidden(child)) {
+        const code = panelCode(child);
+        if (code !== void 0) {
+          codes.add(code);
+        }
+      }
+    }
+    cache.set(parent, codes);
   }
-  return false;
+  return codes;
+};
+const isHiddenCodePanel = (element, parent, cache) => {
+  const code = panelCode(element);
+  if (code === void 0) {
+    return false;
+  }
+  const siblings = visibleSiblingCode(parent, cache);
+  if (siblings.has(code)) {
+    return false;
+  }
+  return (0, import_hast_fast.stringProperty)(element, "role") === "tabpanel" || siblings.size > 0;
 };
 const PLACEHOLDER_IMAGE_SRC = /^data:image\/|^about:blank$|spacer\.gif$|blank\.(gif|png)$/i;
 const isPlaceholderImage = (element) => {
@@ -82,15 +146,16 @@ const isPlaceholderImage = (element) => {
   }
   return false;
 };
-const hoistNoscriptImages = (tree) => {
-  const visit = (parent) => {
+const hoistNoscriptImages = (tree, onElement) => {
+  const visit = (parent, depth) => {
     for (let index = 0; index < parent.children.length; index++) {
       const child = parent.children[index];
       if (!(0, import_hast_fast.isElement)(child)) {
         continue;
       }
       if (child.tagName !== "noscript") {
-        visit(child);
+        onElement?.(child, depth, parent);
+        visit(child, depth + 1);
         continue;
       }
       const hasImage = child.children.some(
@@ -110,7 +175,7 @@ const hoistNoscriptImages = (tree) => {
     }
   };
   if ("children" in tree) {
-    visit(tree);
+    visit(tree, 0);
   }
 };
 const containsMath = (element) => {
@@ -125,12 +190,15 @@ const containsMath = (element) => {
   return false;
 };
 const stripNonContent = (tree) => {
-  hoistNoscriptImages(tree);
-  return (0, import_hast_fast.pruneInPlace)(tree, (node) => {
+  const tabs = new import_code_tabs.CodeTabCollector((element) => looksHidden(element) || import_constants.NON_CONTENT_TAGS.has(element.tagName));
+  hoistNoscriptImages(tree, (element, depth, parent) => tabs.visit(element, depth, parent));
+  tabs.apply();
+  const siblingCode = /* @__PURE__ */ new WeakMap();
+  return (0, import_hast_fast.pruneInPlace)(tree, (node, parent) => {
     if (isNonContent(node)) {
       return false;
     }
-    if ((0, import_hast_fast.isElement)(node) && isHidden(node)) {
+    if ((0, import_hast_fast.isElement)(node) && isHidden(node, parent, siblingCode)) {
       return false;
     }
     return true;
@@ -157,32 +225,32 @@ const findLandmarkChrome = (tree) => {
   visit(tree, 0, false);
   return chrome;
 };
-const isUnlikelyCandidate = (element) => {
+const unlikelyTier = (element) => {
   if (element.tagName === "article" || element.tagName === "main" || element.tagName === "body") {
-    return false;
+    return void 0;
   }
   const role = (0, import_hast_fast.stringProperty)(element, "role");
   if (role && import_constants.UNLIKELY_ROLES.has(role)) {
-    return true;
+    return "strong";
   }
   if (import_constants.CHROME_TAGS.has(element.tagName)) {
-    return true;
+    return "strong";
   }
   const match = (0, import_hast_fast.matchString)(element);
   if (import_constants.REGEXPS.specialUnlikelyCandidates.test(match)) {
-    return true;
+    return "strong";
   }
   for (const name of [...(0, import_hast_fast.classList)(element), (0, import_hast_fast.stringProperty)(element, "id") ?? ""]) {
     if (import_constants.REGEXPS.stronglyUnlikely.test(name)) {
-      return true;
+      return "strong";
     }
   }
   if (import_constants.REGEXPS.unlikelyCandidates.test(match) && !import_constants.REGEXPS.okMaybeItsaCandidate.test(match)) {
-    return true;
+    return "weak";
   }
-  return false;
+  return void 0;
 };
-const findUnlikelyElements = (tree) => {
+const findUnlikelyElements = (tree, spareWeak) => {
   const landmarks = findLandmarkChrome(tree);
   const doomed = [];
   const visit = (node) => {
@@ -193,7 +261,15 @@ const findUnlikelyElements = (tree) => {
       if (!(0, import_hast_fast.isElement)(child)) {
         continue;
       }
-      if (landmarks.has(child) || isUnlikelyCandidate(child)) {
+      if (landmarks.has(child)) {
+        doomed.push(child);
+        continue;
+      }
+      if (PREFORMATTED_TAGS.has(child.tagName)) {
+        continue;
+      }
+      const tier = unlikelyTier(child);
+      if (tier === "strong" || tier === "weak" && !spareWeak?.(child)) {
         doomed.push(child);
         continue;
       }
@@ -338,11 +414,15 @@ const findCleanupTargets = (tree, collector) => {
         visit(child);
         continue;
       }
+      if (LITERAL_TEXT_TAGS.has(child.tagName)) {
+        collectButtons(child, doomed);
+        continue;
+      }
       if (isLinkOnlyBlock(child, collector)) {
         condemnLinkBlock(child, siblings, index, collector, doomed);
         continue;
       }
-      if (isMidArticleWidget(child)) {
+      if (isMidArticleWidget(child, collector)) {
         doomed.push(child);
         continue;
       }
@@ -384,18 +464,52 @@ const countAnchors = (element) => {
   return count;
 };
 const LITERAL_TEXT_TAGS = /* @__PURE__ */ new Set(["code", "kbd", "samp", "var", "pre"]);
-const isMidArticleWidget = (element) => {
-  if (LITERAL_TEXT_TAGS.has(element.tagName)) {
-    return false;
+const PREFORMATTED_TAGS = /* @__PURE__ */ new Set(["pre", "code"]);
+const collectButtons = (element, into) => {
+  for (const child of element.children) {
+    if (!(0, import_hast_fast.isElement)(child)) {
+      continue;
+    }
+    if (child.tagName === "button") {
+      into.push(child);
+      continue;
+    }
+    collectButtons(child, into);
   }
+};
+const isMidArticleWidget = (element, collector) => {
   if (element.tagName === "form" || element.tagName === "fieldset") {
     return true;
   }
   if (element.tagName === "button") {
     return true;
   }
-  return (0, import_ui_chrome.isUiChromeText)(elementText(element));
+  if (collector.metrics(element).text > import_ui_chrome.MAX_CONSENT_PLACEHOLDER_LENGTH) {
+    return false;
+  }
+  const text = elementText(element);
+  return (0, import_ui_chrome.isUiChromeText)(text) || (0, import_ui_chrome.isConsentPlaceholderText)(text) && !hasBlockDescendant(element);
 };
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "div",
+  "section",
+  "article",
+  "figure",
+  "figcaption",
+  "blockquote",
+  "ul",
+  "ol",
+  "table",
+  "pre",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6"
+]);
+const hasBlockDescendant = (element) => element.children.some((child) => (0, import_hast_fast.isElement)(child) && (BLOCK_TAGS.has(child.tagName) || hasBlockDescendant(child)));
 const cleanContent = (tree, collector) => {
   const doomed = new Set(findCleanupTargets(tree, collector));
   if (doomed.size > 0) {
@@ -418,6 +532,7 @@ const elementText = (node) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  REFERENCE_HEADING,
   cleanContent,
   dropEmptyElements,
   findCleanupTargets,
@@ -425,5 +540,6 @@ const elementText = (node) => {
   findUnlikelyElements,
   hoistNoscriptImages,
   stripNonContent,
-  stripUnlikely
+  stripUnlikely,
+  unlikelyTier
 });