webforai 3.0.0 → 4.1.0

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

@@ -0,0 +1,168 @@
+// src/extractors/lib/code-tabs.ts
+import { isElement, stringProperty } from "../../utils/hast-fast.js";
+var MAX_LABEL_LENGTH = 80;
+var CodeTabCollector = class {
+  #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) => 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 = 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));
+      }
+    }
+  }
+};
+var 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 (isElement(sibling)) {
+      return sibling.children.filter(isElement);
+    }
+  }
+  return void 0;
+};
+var isRadioTabStrip = (element) => {
+  const first = element.children.find(isElement);
+  if (!(first?.tagName === "input" && stringProperty(first, "type") === "radio")) {
+    return false;
+  }
+  let labels = 0;
+  for (const child of element.children) {
+    if (!isElement(child)) {
+      continue;
+    }
+    if (child.tagName === "label") {
+      labels += 1;
+    } else if (!(child.tagName === "input" && stringProperty(child, "type") === "radio")) {
+      return false;
+    }
+  }
+  return labels >= 2;
+};
+var indexById = (elements) => {
+  const byId = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    const id = stringProperty(element, "id");
+    if (id) {
+      byId.set(id, element);
+    }
+  }
+  return byId;
+};
+var 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(stringProperty(panel, "ariaLabelledBy") ?? "");
+    if (tab) {
+      tabOf.set(panel, tab);
+    }
+  }
+  for (const tab of tabs) {
+    const panel = panelById.get(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;
+};
+var tabLabel = (tab, isHidden) => {
+  const label = (textOf(tab, isHidden) || stringProperty(tab, "dataTitle") || "").replace(/\s+/g, " ").trim();
+  return label.length > 0 && label.length <= MAX_LABEL_LENGTH ? label : void 0;
+};
+var labelCode = (panel, label) => {
+  if (!label) {
+    return;
+  }
+  const blocks = [];
+  collectPre(panel, blocks);
+  if (blocks.length === 1 && stringProperty(blocks[0], "dataTitle") === void 0) {
+    blocks[0].properties.dataTitle = label;
+  }
+};
+var collectPre = (element, into) => {
+  for (const child of element.children) {
+    if (!isElement(child) || into.length > 1) {
+      continue;
+    }
+    if (child.tagName === "pre") {
+      into.push(child);
+      continue;
+    }
+    collectPre(child, into);
+  }
+};
+var textOf = (element, isHidden) => {
+  let text = "";
+  for (const child of element.children) {
+    if (child.type === "text") {
+      text += child.value;
+    } else if (isElement(child) && !isHidden(child)) {
+      text += textOf(child, isHidden);
+    }
+  }
+  return text;
+};
+export {
+  CodeTabCollector
+};

package/dist/extractors/lib/constants.js

@@ -8,7 +8,7 @@ var 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/extractors/lib/layout-tables.js

@@ -0,0 +1,99 @@
+// src/extractors/lib/layout-tables.ts
+import { isElement, stringProperty } from "../../utils/hast-fast.js";
+var DATA_MARKERS = /* @__PURE__ */ new Set(["caption", "thead", "tfoot", "th", "col", "colgroup"]);
+var BLOCK_IN_CELL = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6", "table", "form"]);
+var TABLE_PARTS = /* @__PURE__ */ new Set(["tbody", "thead", "tfoot", "tr", "td", "th"]);
+var TABLE_CONTEXT = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]);
+var shapeOf = (table) => {
+  const shape = { rows: 0, columns: 0, dataMarker: false, blockInCell: false };
+  const visit = (node, inCell) => {
+    for (const child of node.children) {
+      if (!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) => 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;
+};
+var isLayoutTable = (table) => {
+  const role = stringProperty(table, "role");
+  if (role === "presentation" || role === "none" || 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;
+};
+var unwrap = (table) => {
+  const cells = [];
+  const collect = (node) => {
+    for (const child of node.children) {
+      if (!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 };
+};
+var unwrapLayoutTables = (root) => {
+  const visit = (parent) => {
+    const parentTag = isElement(parent) ? parent.tagName : "";
+    for (let index = 0; index < parent.children.length; index++) {
+      const child = parent.children[index];
+      if (!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);
+  }
+};
+export {
+  isLayoutTable,
+  unwrapLayoutTables
+};

package/dist/extractors/lib/sanitize.js

@@ -10,6 +10,7 @@ import {
   stringProperty,
   walk
 } from "../../utils/hast-fast.js";
+import { CodeTabCollector } from "./code-tabs.js";
 import {
   CHROME_TAGS,
   CONTEXTUAL_LANDMARK_TAGS,
@@ -21,25 +22,39 @@ import {
   RESPONSIVE_DISPLAY_OVERRIDE,
   UNLIKELY_ROLES
 } from "./constants.js";
-import { isUiChromeText } from "./ui-chrome.js";
+import { MAX_CONSENT_PLACEHOLDER_LENGTH, isConsentPlaceholderText, 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) => REGEXPS.hidden.test(name) || isScreenReaderOnlyClass(name));
   }
   return !classes.some((name) => RESPONSIVE_DISPLAY_OVERRIDE.test(name));
 };
+var SCREEN_READER_ONLY = /^(sronly|visuallyhidden|screenreader(only|text))(focusable|styles\w*)?$/;
+var isScreenReaderOnlyClass = (name) => {
+  const first = name.charCodeAt(0) | 32;
+  if (first !== 115 && first !== 118) {
+    return false;
+  }
+  return SCREEN_READER_ONLY.test(name.toLowerCase().replace(/[-_]/g, ""));
+};
 var isNonContent = (node) => {
   if (node.type === "comment" || node.type === "doctype") {
     return true;
   }
   return isElement(node) && NON_CONTENT_TAGS.has(node.tagName);
 };
-var isHidden = (element) => {
+var isHidden = (element, parent, siblingCode) => {
+  if (!looksHidden(element)) {
+    return false;
+  }
   if (containsMath(element)) {
     return false;
   }
+  return !isHiddenCodePanel(element, parent, siblingCode);
+};
+var looksHidden = (element) => {
   if (isTruthyAttribute(element, "hidden")) {
     return true;
   }
@@ -52,10 +67,57 @@ var isHidden = (element) => {
   }
   const width = numericProperty(element, "data-rwidth");
   const height = numericProperty(element, "data-rheight");
-  if (width === 0 && height === 0) {
+  return width === 0 && height === 0;
+};
+var MAX_CODE_PANEL_PROSE = 200;
+var 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 (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;
+};
+var visibleSiblingCode = (parent, cache) => {
+  let codes = cache.get(parent);
+  if (!codes) {
+    codes = /* @__PURE__ */ new Set();
+    for (const child of parent.children) {
+      if (isElement(child) && !looksHidden(child)) {
+        const code = panelCode(child);
+        if (code !== void 0) {
+          codes.add(code);
+        }
+      }
+    }
+    cache.set(parent, codes);
   }
-  return false;
+  return codes;
+};
+var 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 stringProperty(element, "role") === "tabpanel" || siblings.size > 0;
 };
 var PLACEHOLDER_IMAGE_SRC = /^data:image\/|^about:blank$|spacer\.gif$|blank\.(gif|png)$/i;
 var isPlaceholderImage = (element) => {
@@ -73,15 +135,16 @@ var isPlaceholderImage = (element) => {
   }
   return false;
 };
-var hoistNoscriptImages = (tree) => {
-  const visit = (parent) => {
+var hoistNoscriptImages = (tree, onElement) => {
+  const visit = (parent, depth) => {
     for (let index = 0; index < parent.children.length; index++) {
       const child = parent.children[index];
       if (!isElement(child)) {
         continue;
       }
       if (child.tagName !== "noscript") {
-        visit(child);
+        onElement?.(child, depth, parent);
+        visit(child, depth + 1);
         continue;
       }
       const hasImage = child.children.some(
@@ -101,7 +164,7 @@ var hoistNoscriptImages = (tree) => {
     }
   };
   if ("children" in tree) {
-    visit(tree);
+    visit(tree, 0);
   }
 };
 var containsMath = (element) => {
@@ -116,12 +179,15 @@ var containsMath = (element) => {
   return false;
 };
 var stripNonContent = (tree) => {
-  hoistNoscriptImages(tree);
-  return pruneInPlace(tree, (node) => {
+  const tabs = new CodeTabCollector((element) => looksHidden(element) || NON_CONTENT_TAGS.has(element.tagName));
+  hoistNoscriptImages(tree, (element, depth, parent) => tabs.visit(element, depth, parent));
+  tabs.apply();
+  const siblingCode = /* @__PURE__ */ new WeakMap();
+  return pruneInPlace(tree, (node, parent) => {
     if (isNonContent(node)) {
       return false;
     }
-    if (isElement(node) && isHidden(node)) {
+    if (isElement(node) && isHidden(node, parent, siblingCode)) {
       return false;
     }
     return true;
@@ -148,32 +214,32 @@ var findLandmarkChrome = (tree) => {
   visit(tree, 0, false);
   return chrome;
 };
-var isUnlikelyCandidate = (element) => {
+var unlikelyTier = (element) => {
   if (element.tagName === "article" || element.tagName === "main" || element.tagName === "body") {
-    return false;
+    return void 0;
   }
   const role = stringProperty(element, "role");
   if (role && UNLIKELY_ROLES.has(role)) {
-    return true;
+    return "strong";
   }
   if (CHROME_TAGS.has(element.tagName)) {
-    return true;
+    return "strong";
   }
   const match = matchString(element);
   if (REGEXPS.specialUnlikelyCandidates.test(match)) {
-    return true;
+    return "strong";
   }
   for (const name of [...classList(element), stringProperty(element, "id") ?? ""]) {
     if (REGEXPS.stronglyUnlikely.test(name)) {
-      return true;
+      return "strong";
     }
   }
   if (REGEXPS.unlikelyCandidates.test(match) && !REGEXPS.okMaybeItsaCandidate.test(match)) {
-    return true;
+    return "weak";
   }
-  return false;
+  return void 0;
 };
-var findUnlikelyElements = (tree) => {
+var findUnlikelyElements = (tree, spareWeak) => {
   const landmarks = findLandmarkChrome(tree);
   const doomed = [];
   const visit = (node) => {
@@ -184,7 +250,15 @@ var findUnlikelyElements = (tree) => {
       if (!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;
       }
@@ -329,11 +403,15 @@ var 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;
       }
@@ -374,15 +452,53 @@ var countAnchors = (element) => {
   }
   return count;
 };
-var isMidArticleWidget = (element) => {
+var LITERAL_TEXT_TAGS = /* @__PURE__ */ new Set(["code", "kbd", "samp", "var", "pre"]);
+var PREFORMATTED_TAGS = /* @__PURE__ */ new Set(["pre", "code"]);
+var collectButtons = (element, into) => {
+  for (const child of element.children) {
+    if (!isElement(child)) {
+      continue;
+    }
+    if (child.tagName === "button") {
+      into.push(child);
+      continue;
+    }
+    collectButtons(child, into);
+  }
+};
+var isMidArticleWidget = (element, collector) => {
   if (element.tagName === "form" || element.tagName === "fieldset") {
     return true;
   }
   if (element.tagName === "button") {
     return true;
   }
-  return isUiChromeText(elementText(element));
+  if (collector.metrics(element).text > MAX_CONSENT_PLACEHOLDER_LENGTH) {
+    return false;
+  }
+  const text = elementText(element);
+  return isUiChromeText(text) || isConsentPlaceholderText(text) && !hasBlockDescendant(element);
 };
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "div",
+  "section",
+  "article",
+  "figure",
+  "figcaption",
+  "blockquote",
+  "ul",
+  "ol",
+  "table",
+  "pre",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6"
+]);
+var hasBlockDescendant = (element) => element.children.some((child) => isElement(child) && (BLOCK_TAGS.has(child.tagName) || hasBlockDescendant(child)));
 var cleanContent = (tree, collector) => {
   const doomed = new Set(findCleanupTargets(tree, collector));
   if (doomed.size > 0) {
@@ -404,6 +520,7 @@ var elementText = (node) => {
   return text;
 };
 export {
+  REFERENCE_HEADING,
   cleanContent,
   dropEmptyElements,
   findCleanupTargets,
@@ -411,5 +528,6 @@ export {
   findUnlikelyElements,
   hoistNoscriptImages,
   stripNonContent,
-  stripUnlikely
+  stripUnlikely,
+  unlikelyTier
 };

package/dist/extractors/lib/takumi-signal.js

@@ -0,0 +1,53 @@
+// src/extractors/lib/takumi-signal.ts
+import { isElement, walk } from "../../utils/hast-fast.js";
+import { takumiExtractor } from "../presets/takumi.js";
+var MARK = "dataWebforaiIndex";
+var cloneElements = (root) => {
+  const copyOf = (node) => "children" in node ? {
+    ...node,
+    ...isElement(node) ? { properties: { ...node.properties } } : {},
+    children: [...node.children]
+  } : node;
+  const copy = copyOf(root);
+  const stack = [copy];
+  while (stack.length > 0) {
+    const parent = stack.pop();
+    if (!("children" in parent)) {
+      continue;
+    }
+    const children = parent.children;
+    for (let index = 0; index < children.length; index++) {
+      if ("children" in children[index]) {
+        children[index] = copyOf(children[index]);
+        stack.push(children[index]);
+      }
+    }
+  }
+  return copy;
+};
+var takumiSelection = (root, lang, url) => {
+  const elements = [];
+  walk(root, (node) => {
+    if (isElement(node)) {
+      node.properties[MARK] = elements.length;
+      elements.push(node);
+    }
+  });
+  const copy = cloneElements(root);
+  for (const element of elements) {
+    delete element.properties[MARK];
+  }
+  const kept = /* @__PURE__ */ new Set();
+  walk(takumiExtractor({ hast: copy, lang, url, owned: true }), (node) => {
+    if (isElement(node)) {
+      const index = node.properties[MARK];
+      if (typeof index === "number" && elements[index]) {
+        kept.add(elements[index]);
+      }
+    }
+  });
+  return kept;
+};
+export {
+  takumiSelection
+};

package/dist/extractors/lib/ui-chrome.js

@@ -91,6 +91,11 @@ var isUiChromeText = (text) => {
   }
   return UI_PHRASES.has(normalized);
 };
+var CONSENT_PLACEHOLDER = /^(this content (isn['’]?t|is not) (visible|available) (due to|because of) your (cookie|privacy) (preferences|settings)|we need your (consent|permission) to load|to (view|see|load) this (content|embed|video|post)[, ]+(please )?(enable|accept|allow|update)|(please )?(accept|allow|enable) (all |marketing |functional )?cookies to (view|see|load|watch)|このコンテンツを表示するには.{0,30}(cookie|クッキー|同意|許可))/i;
+var MAX_CONSENT_PLACEHOLDER_LENGTH = 400;
+var isConsentPlaceholderText = (text) => text.length <= MAX_CONSENT_PLACEHOLDER_LENGTH && CONSENT_PLACEHOLDER.test(text.trimStart());
 export {
+  MAX_CONSENT_PLACEHOLDER_LENGTH,
+  isConsentPlaceholderText,
   isUiChromeText
 };

package/dist/extractors/presets/auto.js

@@ -1,8 +1,8 @@
 // src/extractors/presets/auto.ts
 import { runAdapters } from "../../adapters/index.js";
-import { takumiExtractor } from "./takumi.js";
+import { kiwameExtractor } from "./kiwame.js";
 var createAutoExtractor = (options = {}) => {
-  const { adapters } = options;
+  const { adapters, fallback = kiwameExtractor } = options;
   return (params) => {
     if (adapters !== false) {
       const extracted = runAdapters({ hast: params.hast, url: params.url, lang: params.lang }, adapters ?? void 0);
@@ -10,7 +10,7 @@ var createAutoExtractor = (options = {}) => {
         return extracted;
       }
     }
-    return takumiExtractor(params);
+    return fallback(params);
   };
 };
 var autoExtractor = createAutoExtractor();