webforai 2.1.1 → 4.0.0

package/dist/detect-client-shell.js

@@ -0,0 +1,53 @@
+// src/detect-client-shell.ts
+var SHELL_SUSPICION_THRESHOLD = 300;
+var SHELL_EMPTY_THRESHOLD = 50;
+var BODY_PATTERN = /<body[^>]*>([\s\S]*?)<\/body>/i;
+var HEAD_PATTERN = /<head[^>]*>[\s\S]*?<\/head>/gi;
+var NOSCRIPT_PATTERN = /<noscript[^>]*>([\s\S]*?)<\/noscript>/gi;
+var INVISIBLE_ELEMENT_PATTERN = /<(script|style|template|svg|noscript)[^>]*>[\s\S]*?<\/\1>/gi;
+var COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
+var TAG_PATTERN = /<[^>]+>/g;
+var MOUNT_POINT_PATTERN = /<[a-z][^>]*\sid=["'](?:root|app|__next|___gatsby|__nuxt|q-app|svelte|react-root)["']|<app-root[\s>]|\sdata-reactroot[\s>=]/i;
+var CHALLENGE_PATTERN = /cf-chl|challenge-platform|cf_chl_opt|just a moment|attention required|checking your browser|_incapsula_|px-captcha|datadome/i;
+var ENTITIES = {
+  "&nbsp;": " ",
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'"
+};
+var visibleTextOf = (markup) => markup.replace(COMMENT_PATTERN, " ").replace(INVISIBLE_ELEMENT_PATTERN, " ").replace(TAG_PATTERN, " ").replace(/&(?:nbsp|amp|lt|gt|quot|#39);/g, (entity) => ENTITIES[entity] ?? " ").replace(/\s+/g, " ").trim();
+var noscriptMentionsJavascript = (html) => {
+  for (const match of html.matchAll(NOSCRIPT_PATTERN)) {
+    if (/javascript/i.test(match[1] ?? "")) {
+      return true;
+    }
+  }
+  return false;
+};
+var detectClientShell = (html) => {
+  const body = BODY_PATTERN.exec(html)?.[1] ?? html.replace(HEAD_PATTERN, " ");
+  const visibleTextLength = visibleTextOf(body).length;
+  if (visibleTextLength >= SHELL_SUSPICION_THRESHOLD) {
+    return { isShell: false, visibleTextLength };
+  }
+  if (CHALLENGE_PATTERN.test(html)) {
+    return { isShell: true, reason: "anti-bot-challenge", visibleTextLength };
+  }
+  if (MOUNT_POINT_PATTERN.test(body)) {
+    return { isShell: true, reason: "spa-shell", visibleTextLength };
+  }
+  if (noscriptMentionsJavascript(html)) {
+    return { isShell: true, reason: "noscript-only", visibleTextLength };
+  }
+  if (visibleTextLength < SHELL_EMPTY_THRESHOLD) {
+    return { isShell: true, reason: "empty-body", visibleTextLength };
+  }
+  return { isShell: false, visibleTextLength };
+};
+export {
+  SHELL_EMPTY_THRESHOLD,
+  SHELL_SUSPICION_THRESHOLD,
+  detectClientShell
+};

package/dist/extract-meta-refresh.js

@@ -0,0 +1,47 @@
+// src/extract-meta-refresh.ts
+var MAX_META_REFRESH_DELAY_SECONDS = 10;
+var META_TAG_PATTERN = /<meta\b[^>]*>/gi;
+var HTTP_EQUIV_REFRESH_PATTERN = /\bhttp-equiv\s*=\s*("\s*refresh\s*"|'\s*refresh\s*'|refresh\b)/i;
+var CONTENT_ATTR_PATTERN = /\bcontent\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i;
+var CONTENT_VALUE_PATTERN = /^\s*(\d+(?:\.\d+)?)\s*[;,]\s*url\s*=\s*(?:"([^"]*)"|'([^']*)'|(.+?))\s*$/i;
+var resolveTarget = (raw, baseUrl) => {
+  try {
+    return baseUrl === void 0 ? new URL(raw) : new URL(raw, baseUrl);
+  } catch {
+    return void 0;
+  }
+};
+var extractMetaRefresh = (html, baseUrl) => {
+  for (const [tag] of html.matchAll(META_TAG_PATTERN)) {
+    if (!HTTP_EQUIV_REFRESH_PATTERN.test(tag)) {
+      continue;
+    }
+    const contentMatch = CONTENT_ATTR_PATTERN.exec(tag);
+    const content = contentMatch?.[1] ?? contentMatch?.[2] ?? contentMatch?.[3];
+    if (!content) {
+      continue;
+    }
+    const value = CONTENT_VALUE_PATTERN.exec(content);
+    if (!value) {
+      continue;
+    }
+    const delaySeconds = Number.parseFloat(value[1] ?? "");
+    const raw = (value[2] ?? value[3] ?? value[4] ?? "").trim();
+    if (!raw || delaySeconds > MAX_META_REFRESH_DELAY_SECONDS) {
+      continue;
+    }
+    const target = resolveTarget(raw, baseUrl);
+    if (!target || target.protocol !== "http:" && target.protocol !== "https:") {
+      continue;
+    }
+    if (baseUrl !== void 0 && resolveTarget(baseUrl, void 0)?.href === target.href) {
+      continue;
+    }
+    return { url: target.href, delaySeconds };
+  }
+  return void 0;
+};
+export {
+  MAX_META_REFRESH_DELAY_SECONDS,
+  extractMetaRefresh
+};

package/dist/extractors/index.js

@@ -4,7 +4,10 @@ import {
 } from "./pipeExtractors.js";
 import { takumiExtractor } from "./presets/takumi.js";
 import { minimalFilter } from "./presets/minimal-filter.js";
+import { autoExtractor, createAutoExtractor } from "./presets/auto.js";
 export {
+  autoExtractor,
+  createAutoExtractor,
   minimalFilter,
   pipeExtractors,
   takumiExtractor

package/dist/extractors/lib/constants.js

@@ -0,0 +1,150 @@
+// src/extractors/lib/constants.ts
+var REGEXPS = {
+  /**
+   * Containers that almost never hold the article body.
+   *
+   * Note the words that are deliberately *absent*. `header` and `footer` match the heading
+   * anchors and article furniture that documentation generators emit (`<a class="header">`,
+   * `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,
+  /** 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. */
+  stronglyUnlikely: /^(nav|navbar|breadcrumbs?|cookie-?(banner|consent|notice)|consent-?(banner|manager)|skip-?link|site-?header|site-?footer|global-?(header|footer)|social-?(share|links?)|share-?(bar|buttons?)|related-?(posts?|articles?)|newsletter-?(signup|form)|comment-?(form|list)|toc-?sidebar)$/i,
+  /** Class/id fragments that mark real article content. */
+  positive: /article|body|content|entry|hentry|h-entry|main|page|pagination|post|text|blog|story|markdown|prose|documentation|doc-?content|readme/i,
+  /** Class/id fragments that mark furniture. */
+  negative: /-ad-|hidden|^hid$| hid$|^hid |banner|combx|comment|com-|contact|foot|footer|footnote|gdpr|masthead|media|meta|outbrain|promo|related|scroll|share|shoutbox|sidebar|skyscraper|sponsor|shopping|tags|widget|toolbar|nav|menu|cookie|consent|subscribe|newsletter|popup|modal|overlay|breadcrumb|pagination|social/i,
+  /** Placeholder imagery that should never reach the output. */
+  hidden: /fallback-image/i,
+  byline: /byline|author|dateline|writtenby|p-author|c-author|post-meta|entry-meta/i,
+  /** Wiki/CMS chrome that generic scoring alone tends to keep. */
+  specialUnlikelyCandidates: /frb-|uls-menu|language-link|mw-editsection|noprint|navbox|metadata|catlinks|printfooter/i
+};
+var NON_CONTENT_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "link",
+  "meta",
+  "noscript",
+  "template",
+  "base",
+  "param",
+  "source",
+  "track",
+  "title"
+]);
+var CHROME_TAGS = /* @__PURE__ */ new Set(["nav", "aside", "dialog", "menu"]);
+var CONTEXTUAL_LANDMARK_TAGS = /* @__PURE__ */ new Set(["header", "footer"]);
+var HIDDEN_CLASS_NAMES = /* @__PURE__ */ new Set([
+  "hidden",
+  "invisible",
+  "is-hidden",
+  "d-none",
+  "display-none",
+  "hide",
+  "is-invisible"
+]);
+var RESPONSIVE_DISPLAY_OVERRIDE = /^(sm|md|lg|xl|2xl|print):(block|flex|grid|inline|inline-block|inline-flex|table|contents|list-item)$/;
+var UNLIKELY_ROLES = /* @__PURE__ */ new Set([
+  "menu",
+  "menubar",
+  "menuitem",
+  "complementary",
+  "navigation",
+  "alert",
+  "alertdialog",
+  "dialog",
+  "banner",
+  "contentinfo",
+  "search",
+  "searchbox",
+  "toolbar",
+  "tablist",
+  "tooltip"
+  // `presentation` is deliberately absent. It marks an element as decorative *structure* — a
+  // layout table, a wrapper — while the content inside it is usually real. Treating it as
+  // chrome deletes article text.
+]);
+var CONTENT_ROLES = /* @__PURE__ */ new Set(["main", "article", "document"]);
+var SCOREABLE_TAGS = /* @__PURE__ */ new Set(["p", "td", "pre", "blockquote", "dd", "li", "figure", "section", "div"]);
+var CANDIDATE_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "section",
+  "article",
+  "main",
+  "td",
+  "pre",
+  "blockquote",
+  "form",
+  "ul",
+  "ol",
+  "dl"
+]);
+var EMBEDDED_CONTENT_TAGS = /* @__PURE__ */ new Set([
+  "img",
+  "picture",
+  "video",
+  "audio",
+  "iframe",
+  "embed",
+  "object",
+  "svg",
+  // Formulae hold no text of their own, so an empty-wrapper rule would otherwise delete them.
+  "math",
+  "mjx-container",
+  "canvas"
+]);
+var DROP_WHEN_EMPTY_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "li",
+  "td",
+  "th",
+  "blockquote",
+  "figcaption",
+  "dd",
+  "dt",
+  "a",
+  "span",
+  "div",
+  "section",
+  "article"
+]);
+var MIN_CONTENT_LENGTH = {
+  ja: 140,
+  zh: 140,
+  ko: 160,
+  th: 160,
+  default: 400
+};
+var minContentLength = (lang) => {
+  if (!lang) {
+    return MIN_CONTENT_LENGTH.default;
+  }
+  const primary = lang.toLowerCase().split("-")[0];
+  return MIN_CONTENT_LENGTH[primary] ?? MIN_CONTENT_LENGTH.default;
+};
+export {
+  CANDIDATE_TAGS,
+  CHROME_TAGS,
+  CONTENT_ROLES,
+  CONTEXTUAL_LANDMARK_TAGS,
+  DROP_WHEN_EMPTY_TAGS,
+  EMBEDDED_CONTENT_TAGS,
+  HIDDEN_CLASS_NAMES,
+  MIN_CONTENT_LENGTH,
+  NON_CONTENT_TAGS,
+  REGEXPS,
+  RESPONSIVE_DISPLAY_OVERRIDE,
+  SCOREABLE_TAGS,
+  UNLIKELY_ROLES,
+  minContentLength
+};

package/dist/extractors/lib/sanitize.js

@@ -0,0 +1,419 @@
+// src/extractors/lib/sanitize.ts
+import {
+  MetricsCollector as MetricsCollectorCtor,
+  classList,
+  isElement,
+  isTruthyAttribute,
+  matchString,
+  numericProperty,
+  pruneInPlace,
+  stringProperty,
+  walk
+} from "../../utils/hast-fast.js";
+import {
+  CHROME_TAGS,
+  CONTEXTUAL_LANDMARK_TAGS,
+  DROP_WHEN_EMPTY_TAGS,
+  EMBEDDED_CONTENT_TAGS,
+  HIDDEN_CLASS_NAMES,
+  NON_CONTENT_TAGS,
+  REGEXPS,
+  RESPONSIVE_DISPLAY_OVERRIDE,
+  UNLIKELY_ROLES
+} from "./constants.js";
+import { isUiChromeText } from "./ui-chrome.js";
+var INVISIBLE_STYLE = /(^|;)\s*(display\s*:\s*none|visibility\s*:\s*hidden)\s*(;|$)/i;
+var hasHiddenClass = (element) => {
+  const classes = classList(element);
+  if (!classes.some((name) => HIDDEN_CLASS_NAMES.has(name))) {
+    return classes.some((name) => REGEXPS.hidden.test(name));
+  }
+  return !classes.some((name) => RESPONSIVE_DISPLAY_OVERRIDE.test(name));
+};
+var isNonContent = (node) => {
+  if (node.type === "comment" || node.type === "doctype") {
+    return true;
+  }
+  return isElement(node) && NON_CONTENT_TAGS.has(node.tagName);
+};
+var isHidden = (element) => {
+  if (containsMath(element)) {
+    return false;
+  }
+  if (isTruthyAttribute(element, "hidden")) {
+    return true;
+  }
+  const style = stringProperty(element, "style");
+  if (style && INVISIBLE_STYLE.test(style)) {
+    return true;
+  }
+  if (hasHiddenClass(element)) {
+    return true;
+  }
+  const width = numericProperty(element, "data-rwidth");
+  const height = numericProperty(element, "data-rheight");
+  if (width === 0 && height === 0) {
+    return true;
+  }
+  return false;
+};
+var PLACEHOLDER_IMAGE_SRC = /^data:image\/|^about:blank$|spacer\.gif$|blank\.(gif|png)$/i;
+var isPlaceholderImage = (element) => {
+  if (element.tagName === "img") {
+    const src = stringProperty(element, "src");
+    return src !== void 0 && PLACEHOLDER_IMAGE_SRC.test(src);
+  }
+  if (element.tagName !== "picture") {
+    return false;
+  }
+  for (const child of element.children) {
+    if (isElement(child) && child.tagName === "img") {
+      return isPlaceholderImage(child);
+    }
+  }
+  return false;
+};
+var hoistNoscriptImages = (tree) => {
+  const visit = (parent) => {
+    for (let index = 0; index < parent.children.length; index++) {
+      const child = parent.children[index];
+      if (!isElement(child)) {
+        continue;
+      }
+      if (child.tagName !== "noscript") {
+        visit(child);
+        continue;
+      }
+      const hasImage = child.children.some(
+        (node) => isElement(node) && (node.tagName === "img" || node.tagName === "picture")
+      );
+      if (!hasImage) {
+        continue;
+      }
+      const rescued = child.children;
+      parent.children.splice(index, 1, ...rescued);
+      const previous = parent.children[index - 1];
+      if (index > 0 && isElement(previous) && isPlaceholderImage(previous)) {
+        parent.children.splice(index - 1, 1);
+        index -= 1;
+      }
+      index += rescued.length - 1;
+    }
+  };
+  if ("children" in tree) {
+    visit(tree);
+  }
+};
+var containsMath = (element) => {
+  if (element.tagName === "math") {
+    return true;
+  }
+  for (const child of element.children) {
+    if (isElement(child) && containsMath(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+var stripNonContent = (tree) => {
+  hoistNoscriptImages(tree);
+  return pruneInPlace(tree, (node) => {
+    if (isNonContent(node)) {
+      return false;
+    }
+    if (isElement(node) && isHidden(node)) {
+      return false;
+    }
+    return true;
+  });
+};
+var findLandmarkChrome = (tree) => {
+  const chrome = /* @__PURE__ */ new Set();
+  const visit = (node, depth, insideContent) => {
+    if (!("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if (!isElement(child)) {
+        continue;
+      }
+      const nowInsideContent = insideContent || child.tagName === "article" || child.tagName === "main" || stringProperty(child, "role") === "main";
+      if (CONTEXTUAL_LANDMARK_TAGS.has(child.tagName) && !insideContent && depth <= 3) {
+        chrome.add(child);
+        continue;
+      }
+      visit(child, depth + 1, nowInsideContent);
+    }
+  };
+  visit(tree, 0, false);
+  return chrome;
+};
+var isUnlikelyCandidate = (element) => {
+  if (element.tagName === "article" || element.tagName === "main" || element.tagName === "body") {
+    return false;
+  }
+  const role = stringProperty(element, "role");
+  if (role && UNLIKELY_ROLES.has(role)) {
+    return true;
+  }
+  if (CHROME_TAGS.has(element.tagName)) {
+    return true;
+  }
+  const match = matchString(element);
+  if (REGEXPS.specialUnlikelyCandidates.test(match)) {
+    return true;
+  }
+  for (const name of [...classList(element), stringProperty(element, "id") ?? ""]) {
+    if (REGEXPS.stronglyUnlikely.test(name)) {
+      return true;
+    }
+  }
+  if (REGEXPS.unlikelyCandidates.test(match) && !REGEXPS.okMaybeItsaCandidate.test(match)) {
+    return true;
+  }
+  return false;
+};
+var findUnlikelyElements = (tree) => {
+  const landmarks = findLandmarkChrome(tree);
+  const doomed = [];
+  const visit = (node) => {
+    if (!("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if (!isElement(child)) {
+        continue;
+      }
+      if (landmarks.has(child) || isUnlikelyCandidate(child)) {
+        doomed.push(child);
+        continue;
+      }
+      visit(child);
+    }
+  };
+  visit(tree);
+  return doomed;
+};
+var stripUnlikely = (tree) => {
+  const doomed = new Set(findUnlikelyElements(tree));
+  return pruneInPlace(tree, (node) => !(isElement(node) && doomed.has(node)));
+};
+var isEmbeddedContent = (element) => {
+  if (EMBEDDED_CONTENT_TAGS.has(element.tagName)) {
+    return true;
+  }
+  return element.tagName === "br" || element.tagName === "hr" || element.tagName === "input";
+};
+var collectPreformattedElements = (tree) => {
+  const protectedElements = /* @__PURE__ */ new Set();
+  const markSubtree = (node) => {
+    if (!("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if (isElement(child)) {
+        protectedElements.add(child);
+        markSubtree(child);
+      }
+    }
+  };
+  walk(tree, (node) => {
+    if (isElement(node) && (node.tagName === "pre" || node.tagName === "code")) {
+      protectedElements.add(node);
+      markSubtree(node);
+      return false;
+    }
+  });
+  return protectedElements;
+};
+var dropEmptyElements = (tree, collector) => {
+  const preformatted = collectPreformattedElements(tree);
+  const visit = (parent) => {
+    for (let index = 0; index < parent.children.length; index++) {
+      const child = parent.children[index];
+      if (!isElement(child)) {
+        continue;
+      }
+      if (preformatted.has(child) || !DROP_WHEN_EMPTY_TAGS.has(child.tagName)) {
+        visit(child);
+        continue;
+      }
+      if (collector.metrics(child).text > 0 || hasEmbeddedDescendant(child)) {
+        visit(child);
+        continue;
+      }
+      if (holdsWhitespace(child)) {
+        parent.children[index] = { type: "text", value: " " };
+        continue;
+      }
+      parent.children.splice(index, 1);
+      index -= 1;
+    }
+  };
+  if ("children" in tree) {
+    visit(tree);
+  }
+  return tree;
+};
+var holdsWhitespace = (element) => {
+  for (const child of element.children) {
+    if (child.type === "text" && /\s/.test(child.value)) {
+      return true;
+    }
+    if (isElement(child) && holdsWhitespace(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+var hasEmbeddedDescendant = (element) => {
+  for (const child of element.children) {
+    if (!isElement(child)) {
+      continue;
+    }
+    if (isEmbeddedContent(child) || hasEmbeddedDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+var REFERENCE_HEADING = /^(see also|references?|further reading|external links?|bibliography|sources|footnotes|citations|関連項目|参考文献|外部リンク|脚注|出典|参考リンク|参考資料)$/i;
+var MAX_DANGLING_HEADING_LENGTH = 60;
+var isHeadingTag = (element) => /^h[1-6]$/.test(element.tagName);
+var previousElement = (siblings, index) => {
+  for (let cursor = index - 1; cursor >= 0; cursor--) {
+    const sibling = siblings[cursor];
+    if (isElement(sibling)) {
+      return sibling;
+    }
+    if (sibling.type === "text" && sibling.value.trim().length > 0) {
+      return void 0;
+    }
+  }
+  return void 0;
+};
+var condemnLinkBlock = (block, siblings, index, collector, doomed) => {
+  const heading = previousElement(siblings, index);
+  const isHeading = heading !== void 0 && isHeadingTag(heading);
+  if (isHeading && REFERENCE_HEADING.test(elementText(heading).trim())) {
+    return;
+  }
+  if (introducedByColon(siblings, index, collector)) {
+    return;
+  }
+  doomed.push(block);
+  if (isHeading && elementText(heading).trim().length <= MAX_DANGLING_HEADING_LENGTH) {
+    doomed.push(heading);
+  }
+};
+var introducedByColon = (siblings, index, collector) => {
+  const before = previousElement(siblings, index);
+  if (!before || collector.metrics(before).text === 0) {
+    return false;
+  }
+  return /[:：]\s*$/.test(elementText(before).trim());
+};
+var findCleanupTargets = (tree, collector) => {
+  const doomed = [];
+  const visit = (node) => {
+    if (!("children" in node)) {
+      return;
+    }
+    const siblings = node.children;
+    for (let index = 0; index < siblings.length; index++) {
+      const child = siblings[index];
+      if (!isElement(child)) {
+        continue;
+      }
+      if (child.tagName === "article" || child.tagName === "main") {
+        visit(child);
+        continue;
+      }
+      if (isLinkOnlyBlock(child, collector)) {
+        condemnLinkBlock(child, siblings, index, collector, doomed);
+        continue;
+      }
+      if (isMidArticleWidget(child)) {
+        doomed.push(child);
+        continue;
+      }
+      visit(child);
+    }
+  };
+  visit(tree);
+  return doomed;
+};
+var LINK_BLOCK_TAGS = /* @__PURE__ */ new Set(["ul", "ol", "nav", "div", "p"]);
+var MIN_LINK_BLOCK_ANCHORS = 3;
+var isLinkOnlyBlock = (element, collector) => {
+  if (!LINK_BLOCK_TAGS.has(element.tagName)) {
+    return false;
+  }
+  const metrics = collector.metrics(element);
+  if (metrics.text === 0 || metrics.commas > 0) {
+    return false;
+  }
+  if (metrics.link / metrics.text <= 0.9) {
+    return false;
+  }
+  return countAnchors(element) >= MIN_LINK_BLOCK_ANCHORS;
+};
+var countAnchors = (element) => {
+  let count = 0;
+  const stack = [element];
+  while (stack.length > 0 && count < MIN_LINK_BLOCK_ANCHORS) {
+    const node = stack.pop();
+    if (isElement(node) && node.tagName === "a") {
+      count += 1;
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        stack.push(child);
+      }
+    }
+  }
+  return count;
+};
+var LITERAL_TEXT_TAGS = /* @__PURE__ */ new Set(["code", "kbd", "samp", "var", "pre"]);
+var isMidArticleWidget = (element) => {
+  if (LITERAL_TEXT_TAGS.has(element.tagName)) {
+    return false;
+  }
+  if (element.tagName === "form" || element.tagName === "fieldset") {
+    return true;
+  }
+  if (element.tagName === "button") {
+    return true;
+  }
+  return isUiChromeText(elementText(element));
+};
+var cleanContent = (tree, collector) => {
+  const doomed = new Set(findCleanupTargets(tree, collector));
+  if (doomed.size > 0) {
+    pruneInPlace(tree, (node) => !(isElement(node) && doomed.has(node)));
+  }
+  return dropEmptyElements(tree, new MetricsCollectorCtor());
+};
+var elementText = (node) => {
+  if (node.type === "text") {
+    return node.value;
+  }
+  if (!("children" in node)) {
+    return "";
+  }
+  let text = "";
+  for (const child of node.children) {
+    text += elementText(child);
+  }
+  return text;
+};
+export {
+  cleanContent,
+  dropEmptyElements,
+  findCleanupTargets,
+  findLandmarkChrome,
+  findUnlikelyElements,
+  hoistNoscriptImages,
+  stripNonContent,
+  stripUnlikely
+};