webforai 2.1.1 → 3.0.0

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

@@ -0,0 +1,425 @@
+"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 sanitize_exports = {};
+__export(sanitize_exports, {
+  cleanContent: () => cleanContent,
+  dropEmptyElements: () => dropEmptyElements,
+  findCleanupTargets: () => findCleanupTargets,
+  findLandmarkChrome: () => findLandmarkChrome,
+  findUnlikelyElements: () => findUnlikelyElements,
+  hoistNoscriptImages: () => hoistNoscriptImages,
+  stripNonContent: () => stripNonContent,
+  stripUnlikely: () => stripUnlikely
+});
+module.exports = __toCommonJS(sanitize_exports);
+var import_hast_fast = require("../../utils/hast-fast");
+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.RESPONSIVE_DISPLAY_OVERRIDE.test(name));
+};
+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) => {
+  if (containsMath(element)) {
+    return false;
+  }
+  if ((0, import_hast_fast.isTruthyAttribute)(element, "hidden")) {
+    return true;
+  }
+  const style = (0, import_hast_fast.stringProperty)(element, "style");
+  if (style && INVISIBLE_STYLE.test(style)) {
+    return true;
+  }
+  if (hasHiddenClass(element)) {
+    return true;
+  }
+  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 true;
+  }
+  return false;
+};
+const PLACEHOLDER_IMAGE_SRC = /^data:image\/|^about:blank$|spacer\.gif$|blank\.(gif|png)$/i;
+const isPlaceholderImage = (element) => {
+  if (element.tagName === "img") {
+    const src = (0, import_hast_fast.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 ((0, import_hast_fast.isElement)(child) && child.tagName === "img") {
+      return isPlaceholderImage(child);
+    }
+  }
+  return false;
+};
+const hoistNoscriptImages = (tree) => {
+  const visit = (parent) => {
+    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);
+        continue;
+      }
+      const hasImage = child.children.some(
+        (node) => (0, import_hast_fast.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 && (0, import_hast_fast.isElement)(previous) && isPlaceholderImage(previous)) {
+        parent.children.splice(index - 1, 1);
+        index -= 1;
+      }
+      index += rescued.length - 1;
+    }
+  };
+  if ("children" in tree) {
+    visit(tree);
+  }
+};
+const containsMath = (element) => {
+  if (element.tagName === "math") {
+    return true;
+  }
+  for (const child of element.children) {
+    if ((0, import_hast_fast.isElement)(child) && containsMath(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+const stripNonContent = (tree) => {
+  hoistNoscriptImages(tree);
+  return (0, import_hast_fast.pruneInPlace)(tree, (node) => {
+    if (isNonContent(node)) {
+      return false;
+    }
+    if ((0, import_hast_fast.isElement)(node) && isHidden(node)) {
+      return false;
+    }
+    return true;
+  });
+};
+const findLandmarkChrome = (tree) => {
+  const chrome = /* @__PURE__ */ new Set();
+  const visit = (node, depth, insideContent) => {
+    if (!("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if (!(0, import_hast_fast.isElement)(child)) {
+        continue;
+      }
+      const nowInsideContent = insideContent || child.tagName === "article" || child.tagName === "main" || (0, import_hast_fast.stringProperty)(child, "role") === "main";
+      if (import_constants.CONTEXTUAL_LANDMARK_TAGS.has(child.tagName) && !insideContent && depth <= 3) {
+        chrome.add(child);
+        continue;
+      }
+      visit(child, depth + 1, nowInsideContent);
+    }
+  };
+  visit(tree, 0, false);
+  return chrome;
+};
+const isUnlikelyCandidate = (element) => {
+  if (element.tagName === "article" || element.tagName === "main" || element.tagName === "body") {
+    return false;
+  }
+  const role = (0, import_hast_fast.stringProperty)(element, "role");
+  if (role && import_constants.UNLIKELY_ROLES.has(role)) {
+    return true;
+  }
+  if (import_constants.CHROME_TAGS.has(element.tagName)) {
+    return true;
+  }
+  const match = (0, import_hast_fast.matchString)(element);
+  if (import_constants.REGEXPS.specialUnlikelyCandidates.test(match)) {
+    return true;
+  }
+  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;
+    }
+  }
+  if (import_constants.REGEXPS.unlikelyCandidates.test(match) && !import_constants.REGEXPS.okMaybeItsaCandidate.test(match)) {
+    return true;
+  }
+  return false;
+};
+const findUnlikelyElements = (tree) => {
+  const landmarks = findLandmarkChrome(tree);
+  const doomed = [];
+  const visit = (node) => {
+    if (!("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if (!(0, import_hast_fast.isElement)(child)) {
+        continue;
+      }
+      if (landmarks.has(child) || isUnlikelyCandidate(child)) {
+        doomed.push(child);
+        continue;
+      }
+      visit(child);
+    }
+  };
+  visit(tree);
+  return doomed;
+};
+const stripUnlikely = (tree) => {
+  const doomed = new Set(findUnlikelyElements(tree));
+  return (0, import_hast_fast.pruneInPlace)(tree, (node) => !((0, import_hast_fast.isElement)(node) && doomed.has(node)));
+};
+const isEmbeddedContent = (element) => {
+  if (import_constants.EMBEDDED_CONTENT_TAGS.has(element.tagName)) {
+    return true;
+  }
+  return element.tagName === "br" || element.tagName === "hr" || element.tagName === "input";
+};
+const collectPreformattedElements = (tree) => {
+  const protectedElements = /* @__PURE__ */ new Set();
+  const markSubtree = (node) => {
+    if (!("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if ((0, import_hast_fast.isElement)(child)) {
+        protectedElements.add(child);
+        markSubtree(child);
+      }
+    }
+  };
+  (0, import_hast_fast.walk)(tree, (node) => {
+    if ((0, import_hast_fast.isElement)(node) && (node.tagName === "pre" || node.tagName === "code")) {
+      protectedElements.add(node);
+      markSubtree(node);
+      return false;
+    }
+  });
+  return protectedElements;
+};
+const 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 (!(0, import_hast_fast.isElement)(child)) {
+        continue;
+      }
+      if (preformatted.has(child) || !import_constants.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;
+};
+const holdsWhitespace = (element) => {
+  for (const child of element.children) {
+    if (child.type === "text" && /\s/.test(child.value)) {
+      return true;
+    }
+    if ((0, import_hast_fast.isElement)(child) && holdsWhitespace(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+const hasEmbeddedDescendant = (element) => {
+  for (const child of element.children) {
+    if (!(0, import_hast_fast.isElement)(child)) {
+      continue;
+    }
+    if (isEmbeddedContent(child) || hasEmbeddedDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+const REFERENCE_HEADING = /^(see also|references?|further reading|external links?|bibliography|sources|footnotes|citations|関連項目|参考文献|外部リンク|脚注|出典|参考リンク|参考資料)$/i;
+const MAX_DANGLING_HEADING_LENGTH = 60;
+const isHeadingTag = (element) => /^h[1-6]$/.test(element.tagName);
+const previousElement = (siblings, index) => {
+  for (let cursor = index - 1; cursor >= 0; cursor--) {
+    const sibling = siblings[cursor];
+    if ((0, import_hast_fast.isElement)(sibling)) {
+      return sibling;
+    }
+    if (sibling.type === "text" && sibling.value.trim().length > 0) {
+      return void 0;
+    }
+  }
+  return void 0;
+};
+const 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);
+  }
+};
+const introducedByColon = (siblings, index, collector) => {
+  const before = previousElement(siblings, index);
+  if (!before || collector.metrics(before).text === 0) {
+    return false;
+  }
+  return /[:：]\s*$/.test(elementText(before).trim());
+};
+const 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 (!(0, import_hast_fast.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;
+};
+const LINK_BLOCK_TAGS = /* @__PURE__ */ new Set(["ul", "ol", "nav", "div", "p"]);
+const MIN_LINK_BLOCK_ANCHORS = 3;
+const 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;
+};
+const countAnchors = (element) => {
+  let count = 0;
+  const stack = [element];
+  while (stack.length > 0 && count < MIN_LINK_BLOCK_ANCHORS) {
+    const node = stack.pop();
+    if ((0, import_hast_fast.isElement)(node) && node.tagName === "a") {
+      count += 1;
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        stack.push(child);
+      }
+    }
+  }
+  return count;
+};
+const isMidArticleWidget = (element) => {
+  if (element.tagName === "form" || element.tagName === "fieldset") {
+    return true;
+  }
+  if (element.tagName === "button") {
+    return true;
+  }
+  return (0, import_ui_chrome.isUiChromeText)(elementText(element));
+};
+const cleanContent = (tree, collector) => {
+  const doomed = new Set(findCleanupTargets(tree, collector));
+  if (doomed.size > 0) {
+    (0, import_hast_fast.pruneInPlace)(tree, (node) => !((0, import_hast_fast.isElement)(node) && doomed.has(node)));
+  }
+  return dropEmptyElements(tree, new import_hast_fast.MetricsCollector());
+};
+const 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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanContent,
+  dropEmptyElements,
+  findCleanupTargets,
+  findLandmarkChrome,
+  findUnlikelyElements,
+  hoistNoscriptImages,
+  stripNonContent,
+  stripUnlikely
+});

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

@@ -0,0 +1,264 @@
+"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 score_exports = {};
+__export(score_exports, {
+  buildScoringContext: () => buildScoringContext,
+  classWeight: () => classWeight,
+  climbToArticleBoundary: () => climbToArticleBoundary,
+  collectArticleNodes: () => collectArticleNodes,
+  geometryMultiplier: () => geometryMultiplier,
+  scoreCandidates: () => scoreCandidates,
+  semanticBonus: () => semanticBonus
+});
+module.exports = __toCommonJS(score_exports);
+var import_hast_fast = require("../../utils/hast-fast");
+var import_constants = require("./constants");
+const TAG_BASE_SCORE = {
+  div: 5,
+  pre: 3,
+  td: 3,
+  blockquote: 3,
+  article: 10,
+  main: 10,
+  section: 5,
+  address: -3,
+  ol: -3,
+  ul: -3,
+  dl: -3,
+  dd: -3,
+  dt: -3,
+  li: -3,
+  form: -3,
+  h1: -5,
+  h2: -5,
+  h3: -5,
+  h4: -5,
+  h5: -5,
+  h6: -5,
+  th: -5
+};
+const MAX_ANCESTOR_DEPTH = 5;
+const MIN_SCOREABLE_TEXT = 25;
+const buildScoringContext = (root, collector, lang) => {
+  const parents = /* @__PURE__ */ new WeakMap();
+  const scoreable = [];
+  let hasGeometry = false;
+  (0, import_hast_fast.walk)(root, (node, parent) => {
+    if (parent) {
+      parents.set(node, parent);
+    }
+    if (!(0, import_hast_fast.isElement)(node)) {
+      return;
+    }
+    if (!hasGeometry && (0, import_hast_fast.numericProperty)(node, "data-rheight") !== void 0) {
+      hasGeometry = true;
+    }
+    if (isParagraphLike(node)) {
+      scoreable.push(node);
+    }
+  });
+  return { collector, parents, lang, hasGeometry, scoreable };
+};
+const classWeight = (element) => {
+  let weight = 0;
+  const id = (0, import_hast_fast.stringProperty)(element, "id") ?? "";
+  const classes = (0, import_hast_fast.classList)(element).join(" ");
+  if (import_constants.REGEXPS.negative.test(classes)) {
+    weight -= 25;
+  }
+  if (import_constants.REGEXPS.positive.test(classes)) {
+    weight += 25;
+  }
+  if (import_constants.REGEXPS.negative.test(id)) {
+    weight -= 25;
+  }
+  if (import_constants.REGEXPS.positive.test(id)) {
+    weight += 25;
+  }
+  return weight;
+};
+const semanticBonus = (element) => {
+  let bonus = 0;
+  if (element.tagName === "article") {
+    bonus += 60;
+  }
+  if (element.tagName === "main") {
+    bonus += 50;
+  }
+  const role = (0, import_hast_fast.stringProperty)(element, "role");
+  if (role && import_constants.CONTENT_ROLES.has(role)) {
+    bonus += 40;
+  }
+  const itemprop = (0, import_hast_fast.stringProperty)(element, "itemprop");
+  if (itemprop?.includes("articleBody")) {
+    bonus += 80;
+  }
+  const match = (0, import_hast_fast.matchString)(element);
+  if (/(^|[\s_-])(markdown|prose|article-?content|post-?content|entry-?content|doc-?content|md-?content)([\s_-]|$)/i.test(
+    match
+  )) {
+    bonus += 35;
+  }
+  return bonus;
+};
+const geometryMultiplier = (element, context) => {
+  if (!context.hasGeometry) {
+    return 1;
+  }
+  const height = (0, import_hast_fast.numericProperty)(element, "data-rheight");
+  const width = (0, import_hast_fast.numericProperty)(element, "data-rwidth");
+  if (height === void 0 || width === void 0) {
+    return 1;
+  }
+  if (height === 0 || width === 0) {
+    return 0;
+  }
+  if (width < 220) {
+    return 0.35;
+  }
+  return 1;
+};
+const paragraphScore = (textLength, commas, densityDivisor) => 1 + commas + Math.min(Math.floor(textLength / densityDivisor), 3);
+const ancestorWeight = (level) => {
+  if (level === 0) {
+    return 1;
+  }
+  if (level === 1) {
+    return 2;
+  }
+  return level * 3;
+};
+const isParagraphLike = (element) => {
+  if (!import_constants.SCOREABLE_TAGS.has(element.tagName)) {
+    return false;
+  }
+  if (element.tagName !== "div" && element.tagName !== "section") {
+    return true;
+  }
+  return !element.children.some((child) => (0, import_hast_fast.isElement)(child) && import_constants.CANDIDATE_TAGS.has(child.tagName));
+};
+const scoreCandidates = (_root, context) => {
+  const { collector, parents } = context;
+  const scores = /* @__PURE__ */ new Map();
+  const densityDivisor = (0, import_constants.minContentLength)(context.lang) / 4;
+  for (const node of context.scoreable) {
+    const metrics = collector.metrics(node);
+    if (metrics.text < MIN_SCOREABLE_TEXT) {
+      continue;
+    }
+    const contribution = paragraphScore(metrics.text, metrics.commas, densityDivisor);
+    let current = node;
+    for (let level = 0; level < MAX_ANCESTOR_DEPTH && current; level++) {
+      const parent = parents.get(current);
+      if (!(parent && (0, import_hast_fast.isElement)(parent))) {
+        break;
+      }
+      if (import_constants.CANDIDATE_TAGS.has(parent.tagName) || parent.tagName === "article" || parent.tagName === "main") {
+        const base = scores.get(parent) ?? (TAG_BASE_SCORE[parent.tagName] ?? 0) + classWeight(parent) + semanticBonus(parent);
+        scores.set(parent, base + contribution / ancestorWeight(level));
+      }
+      current = parent;
+    }
+  }
+  const candidates = [];
+  for (const [element, rawScore] of scores) {
+    const density = collector.linkDensity(element);
+    const score = rawScore * (1 - density) * geometryMultiplier(element, context);
+    if (score > 0) {
+      candidates.push({ element, score });
+    }
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates;
+};
+const collectArticleNodes = (top, candidates, context) => {
+  const { collector, parents } = context;
+  const parent = parents.get(top.element);
+  if (!(parent && (0, import_hast_fast.isElement)(parent))) {
+    return [top.element];
+  }
+  const scoreOf = new Map(candidates.map((candidate) => [candidate.element, candidate.score]));
+  const threshold = Math.max(10, top.score * 0.2);
+  const selected = [];
+  for (const child of parent.children) {
+    if (!(0, import_hast_fast.isElement)(child)) {
+      continue;
+    }
+    if (child === top.element) {
+      selected.push(child);
+      continue;
+    }
+    const siblingScore = scoreOf.get(child) ?? 0;
+    if (siblingScore >= threshold) {
+      selected.push(child);
+      continue;
+    }
+    if (child.tagName === "p" || child.tagName === "section") {
+      const metrics = collector.metrics(child);
+      const density = collector.linkDensity(child);
+      if (metrics.text > 80 && density < 0.25) {
+        selected.push(child);
+      }
+    }
+  }
+  return selected.length > 0 ? selected : [top.element];
+};
+const MAX_CLIMB_HOPS = 5;
+const MIN_CLIMB_RELATIVE_GAIN = 0.08;
+const MIN_CLIMB_ABSOLUTE_GAIN = 500;
+const MAX_CLIMB_GAIN_LINK_DENSITY = 1 / 3;
+const CLIMB_SCORE_FLOOR = 1 / 3;
+const climbToArticleBoundary = (top, candidates, context) => {
+  const { collector, parents } = context;
+  const scoreOf = new Map(candidates.map((candidate) => [candidate.element, candidate.score]));
+  const scoreFloor = top.score * CLIMB_SCORE_FLOOR;
+  let current = top.element;
+  for (let hop = 0; hop < MAX_CLIMB_HOPS; hop++) {
+    const parent = parents.get(current);
+    if (!(parent && (0, import_hast_fast.isElement)(parent))) {
+      break;
+    }
+    const parentScore = scoreOf.get(parent);
+    if (parentScore === void 0 || parentScore < scoreFloor) {
+      break;
+    }
+    const currentMetrics = collector.metrics(current);
+    const parentMetrics = collector.metrics(parent);
+    const gainedText = parentMetrics.text - currentMetrics.text;
+    if (gainedText < Math.max(MIN_CLIMB_ABSOLUTE_GAIN, currentMetrics.text * MIN_CLIMB_RELATIVE_GAIN)) {
+      break;
+    }
+    const gainedLink = parentMetrics.link - currentMetrics.link;
+    if (gainedLink / gainedText > MAX_CLIMB_GAIN_LINK_DENSITY) {
+      break;
+    }
+    current = parent;
+  }
+  return current;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildScoringContext,
+  classWeight,
+  climbToArticleBoundary,
+  collectArticleNodes,
+  geometryMultiplier,
+  scoreCandidates,
+  semanticBonus
+});