webforai 2.1.1 → 4.0.0

package/dist/extractors/presets/takumi.js

@@ -1,134 +1,103 @@
 // src/extractors/presets/takumi.ts
-import { select, selectAll } from "hast-util-select";
-import { toString as hastToString } from "hast-util-to-string";
-import { filter } from "unist-util-filter";
-import { classnames, isStrInclude, matchString } from "./utils.js";
-var UNLIKELY_ROLES = ["menu", "menubar", "complementary", "navigation", "alert", "alertdialog", "dialog"];
-var REGEXPS = {
-  hidden: /hidden|invisible|fallback-image/i,
-  byline: /byline|author|dateline|writtenby|p-author/i,
-  specialUnlikelyCandidates: /frb-|uls-menu|language-link/i,
-  unlikelyCandidates: /-ad-|ai2html|banner|breadcrumbs|combx|comment|community|cover-wrap|tooltip|disqus|extra|footer|gdpr|legends|menu|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote|speechify-ignore|avatar/i,
-  okMaybeItsaCandidate: /and|article|body|column|content|main|shadow|code/i
-};
-var BODY_SELECTORS = ["article", "#article", ".article_body", ".article-body", "#content", ".entry"];
-var PARAGRAPH_TAGS = ["a", "p", "div", "section", "article", "main", "ul", "ol", "li"];
-var CONTENTABLE_TAGS = ["article", "main", "section", "h1", "h2", "h3", "h4", "h5", "h6", "p"];
-var TEXTABLE_TAGS = ["p", "h1", "h2", "h3", "h4", "h5", "h6", "li", "ul"];
-var BASE_MINIMAL_LENGTH = { ja: 200, en: 500 };
-var metadataFilter = (node) => {
-  return !(["comment", "doctype"].includes(node.type) || node.type === "element" && ["script", "style", "link", "meta", "noscript", "svg", "title"].includes(node.tagName));
-};
-var universalElementFilter = (node) => {
-  if (node.type !== "element") {
-    return true;
-  }
-  const element = node;
-  if (["aside", "nav"].includes(element.tagName)) {
-    return false;
-  }
-  if (["hidden", "aria-hidden"].some((key) => element.properties[key])) {
-    return false;
-  }
-  if (classnames(element).some((classname) => REGEXPS.hidden.test(classname))) {
-    return false;
-  }
-  if (element.tagName === "dialog") {
-    return false;
-  }
-  if (element.properties.role === "dialog" && element.properties["aria-modal"]) {
-    return false;
-  }
-  if (element.properties.rel === "author" && isStrInclude(element.properties.itemprop, "author")) {
-    return false;
-  }
-  if (REGEXPS.byline.test(matchString(element))) {
-    return false;
-  }
-  if (element.properties.role && UNLIKELY_ROLES.includes(element.properties.role)) {
-    return false;
+import {
+  MetricsCollector,
+  cloneHast,
+  findElement,
+  isElement,
+  pruneInPlace,
+  stringProperty
+} from "../../utils/hast-fast.js";
+import { minContentLength } from "../lib/constants.js";
+import { cleanContent, findCleanupTargets, findUnlikelyElements, stripNonContent } from "../lib/sanitize.js";
+import { buildScoringContext, climbToArticleBoundary, collectArticleNodes, scoreCandidates } from "../lib/score.js";
+import { truncateTrailingBoilerplate } from "../lib/terminators.js";
+var MIN_RETAINED_FRACTION = 0.25;
+var SEMANTIC_SELECTORS = [
+  (element) => stringProperty(element, "itemprop")?.includes("articleBody") ?? false,
+  (element) => element.tagName === "article",
+  (element) => element.tagName === "main",
+  (element) => stringProperty(element, "role") === "main"
+];
+var findBody = (hast) => findElement(hast, (element) => element.tagName === "body") ?? hast;
+var semanticShortcut = (tree, collector, minLength) => {
+  for (const matches of SEMANTIC_SELECTORS) {
+    const found = [];
+    collectMatching(tree, matches, found);
+    if (found.length !== 1) {
+      continue;
+    }
+    const candidate = found[0];
+    const metrics = collector.metrics(candidate);
+    if (metrics.text >= minLength && collector.linkDensity(candidate) < 0.5) {
+      return candidate;
+    }
   }
-  return true;
+  return void 0;
 };
-var unlikelyElementFilter = (node) => {
-  if (node.type !== "element") {
-    return true;
-  }
-  const element = node;
-  if (CONTENTABLE_TAGS.includes(element.tagName)) {
-    return true;
-  }
-  const match = matchString(element);
-  if (REGEXPS.specialUnlikelyCandidates.test(match)) {
-    return false;
-  }
-  if (REGEXPS.unlikelyCandidates.test(match) && !REGEXPS.okMaybeItsaCandidate.test(match)) {
-    return false;
+var collectMatching = (tree, matches, into) => {
+  const stack = [tree];
+  while (stack.length > 0 && into.length < 2) {
+    const node = stack.pop();
+    if (isElement(node) && matches(node)) {
+      into.push(node);
+      continue;
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        stack.push(child);
+      }
+    }
   }
-  return true;
 };
-var removeEmptyFilter = (node, _lang) => {
-  if (node.type !== "element") {
-    return true;
-  }
-  const element = node;
-  if (PARAGRAPH_TAGS.includes(element.tagName)) {
-    return true;
-  }
-  if (element.tagName === "img" && !element.properties.src) {
-    return false;
-  }
-  if (TEXTABLE_TAGS.includes(element.tagName) && hastToString(element).length === 0) {
-    return false;
-  }
-  return true;
+var asRootOf = (nodes) => ({ type: "root", children: nodes });
+var scoredSelection = (tree, collector, lang) => {
+  const context = buildScoringContext(tree, collector, lang);
+  const candidates = scoreCandidates(tree, context);
+  const top = candidates[0];
+  if (!top) {
+    return void 0;
+  }
+  const promoted = climbToArticleBoundary(top, candidates, context);
+  const anchor = promoted === top.element ? top : { element: promoted, score: top.score };
+  const selected = collectArticleNodes(anchor, candidates, context);
+  return selected.length === 1 ? selected[0] : asRootOf(selected);
 };
 var takumiExtractor = (params) => {
-  const { hast, lang = "en" } = params;
-  const body = select("body", hast) ?? hast;
-  const metadataFilteredHast = filter(body, (node) => metadataFilter(node));
-  const metadataFilteredHastText = metadataFilteredHast && hastToString(metadataFilteredHast);
-  if (!(metadataFilteredHast && metadataFilteredHastText)) {
+  const { hast, lang, owned } = params;
+  const body = owned ? findBody(hast) : cloneHast(findBody(hast));
+  stripNonContent(body);
+  let collector = new MetricsCollector();
+  const baseText = collector.textLength(body);
+  if (baseText === 0) {
     return body;
   }
-  const baseFilterd = filter(metadataFilteredHast, (node) => universalElementFilter(node));
-  const baseFilterdText = baseFilterd ? hastToString(baseFilterd) : "";
-  const [baseTree, baseText] = baseFilterdText.length > metadataFilteredHastText.length / 3 || baseFilterdText.length > 5e3 ? [baseFilterd, baseFilterdText] : [metadataFilteredHast, metadataFilteredHastText];
-  let minimalLength = lang in BASE_MINIMAL_LENGTH ? BASE_MINIMAL_LENGTH[lang] : 500;
-  if (baseText.length < minimalLength) {
-    minimalLength = Math.max(0, baseText.length - 200);
-  }
-  let extractedTree = baseTree;
-  let extractedText = baseText;
-  for (const selector of BODY_SELECTORS) {
-    const content = { type: "root", children: selectAll(selector, baseFilterd) };
-    const contentText = hastToString(content);
-    if (contentText.length < 25) {
-      continue;
-    }
-    const links = selectAll("a", content);
-    const linkText = links.map((link) => hastToString(link)).join("");
-    const linkDensity = linkText.length / contentText.length;
-    if (linkDensity > 0.4) {
-      continue;
-    }
-    if (contentText.length > minimalLength) {
-      extractedTree = content;
-      extractedText = contentText;
-      break;
-    }
-  }
-  const finalFilteredTree = filter(extractedTree, (node) => {
-    if (!removeEmptyFilter(node, lang)) {
-      return false;
-    }
-    if (!unlikelyElementFilter(node)) {
-      return false;
-    }
-    return true;
-  });
-  const finalTree = hastToString(finalFilteredTree).length > extractedText.length / 3 ? finalFilteredTree : extractedTree;
-  return finalTree;
+  const minLength = Math.min(minContentLength(lang), Math.max(0, baseText - 200));
+  const shortcut = semanticShortcut(body, collector, minLength);
+  const searchRoot = shortcut ?? body;
+  const searchText = collector.textLength(searchRoot);
+  const doomed = findUnlikelyElements(searchRoot);
+  const doomedText = doomed.reduce((sum, element) => sum + collector.metrics(element).text, 0);
+  if (searchText - doomedText > Math.max(minLength, searchText * MIN_RETAINED_FRACTION)) {
+    const doomedSet = new Set(doomed);
+    pruneInPlace(searchRoot, (node) => !(isElement(node) && doomedSet.has(node)));
+    collector = new MetricsCollector();
+  }
+  const scoringRoot = searchRoot;
+  const scoringRootText = collector.textLength(scoringRoot);
+  const selection = shortcut ? scoringRoot : scoredSelection(scoringRoot, collector, lang) ?? scoringRoot;
+  const selectionText = collector.textLength(selection);
+  const selectionIsSound = selectionText >= minLength || selectionText > scoringRootText * MIN_RETAINED_FRACTION;
+  const chosen = selectionIsSound ? selection : scoringRoot;
+  truncateTrailingBoilerplate(chosen);
+  const cleanupCollector = new MetricsCollector();
+  const chosenText = cleanupCollector.textLength(chosen);
+  const widgets = findCleanupTargets(chosen, cleanupCollector);
+  const widgetText = widgets.reduce((sum, element) => sum + cleanupCollector.metrics(element).text, 0);
+  const remainingText = chosenText - widgetText;
+  if (remainingText < chosenText * MIN_RETAINED_FRACTION && remainingText < minLength) {
+    return chosen;
+  }
+  return cleanContent(chosen, cleanupCollector);
 };
 export {
   takumiExtractor

package/dist/html-to-markdown.js

@@ -1,12 +1,48 @@
 // src/html-to-markdown.ts
+import { fromHtml } from "hast-util-from-html";
 import { htmlToMdast } from "./html-to-mdast.js";
 import { mdastToMarkdown } from "./mdast-to-markdown.js";
-var htmlToMarkdown = (htmlOrHast, options) => {
-  const { baseUrl, formatting: toMarkdownOptions, ...toMdastOptions } = options || {};
-  const mdast = htmlToMdast(htmlOrHast, toMdastOptions);
-  const markdown = mdastToMarkdown(mdast, { baseUrl, ...toMarkdownOptions });
-  return markdown;
+import { extractMetadata, toFrontmatter } from "./metadata/index.js";
+import { getLangFromStr } from "./utils/hast-utils.js";
+var htmlToMarkdownWithMetadata = (htmlOrHast, options) => {
+  const { baseUrl, frontmatter, title, formatting: toMarkdownOptions, ...toMdastOptions } = options || {};
+  const hast = typeof htmlOrHast === "string" ? fromHtml(htmlOrHast, { fragment: true }) : htmlOrHast;
+  const isOwned = typeof htmlOrHast === "string";
+  const declaredLang = typeof htmlOrHast === "string" ? getLangFromStr(htmlOrHast) : void 0;
+  const metadata = extractMetadata(hast);
+  if (declaredLang && !metadata.lang) {
+    metadata.lang = declaredLang;
+  }
+  const mdast = htmlToMdast(hast, {
+    ...toMdastOptions,
+    owned: isOwned,
+    lang: toMdastOptions.lang ?? metadata.lang,
+    url: toMdastOptions.url ?? metadata.canonicalUrl
+  });
+  const body = mdastToMarkdown(mdast, { baseUrl, ...toMarkdownOptions });
+  const titled = title === false ? body : withTitle(body, metadata.title);
+  const markdown = frontmatter ? `${toFrontmatter(metadata)}${titled}` : titled;
+  return { markdown, metadata };
 };
+var TITLE_LOOKAHEAD = 400;
+var withTitle = (body, title) => {
+  if (!title) {
+    return body;
+  }
+  const opening = body.slice(0, TITLE_LOOKAHEAD);
+  if (/^#\s+\S/m.test(opening)) {
+    return body;
+  }
+  if (normalizeForCompare(opening).includes(normalizeForCompare(title))) {
+    return body;
+  }
+  return `# ${title}
+
+${body}`;
+};
+var normalizeForCompare = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+var htmlToMarkdown = (htmlOrHast, options) => htmlToMarkdownWithMetadata(htmlOrHast, options).markdown;
 export {
-  htmlToMarkdown
+  htmlToMarkdown,
+  htmlToMarkdownWithMetadata
 };

package/dist/html-to-mdast.js

@@ -8,18 +8,27 @@ import { customCodeHandler } from "./mdast-handlers/custom-code-handler.js";
 import { customDivHandler } from "./mdast-handlers/custom-div-handler.js";
 import { customImgHandler } from "./mdast-handlers/custom-img-handler.js";
 import { customTableHandler } from "./mdast-handlers/custom-table-handler.js";
+import { definitionListHandler } from "./mdast-handlers/definition-list-handler.js";
 import { mathHandler } from "./mdast-handlers/math-handler.js";
+import { supSubHandler } from "./mdast-handlers/sup-sub-handler.js";
+import { normalizeHast } from "./normalize/index.js";
+import { cloneHast } from "./utils/hast-fast.js";
 import { getLangFromHast, getLangFromStr, getUrlFromHast } from "./utils/hast-utils.js";
 var htmlToMdast = (htmlOrHast, options) => {
   const { extractors, url: defaultUrl, lang: defaultLang } = options || {};
   const [lang, hast] = typeof htmlOrHast === "string" ? [defaultLang || getLangFromStr(htmlOrHast), fromHtml(htmlOrHast, { fragment: true })] : [defaultLang || getLangFromHast(htmlOrHast), htmlOrHast];
+  const isOwned = typeof htmlOrHast === "string" || (options?.owned ?? false);
   const url = defaultUrl || getUrlFromHast(hast);
-  const extractedHast = pipeExtractors({ hast, lang, url }, extractors);
+  const extractedHast = pipeExtractors({ hast: isOwned ? hast : cloneHast(hast), lang, url, owned: true }, extractors);
+  normalizeHast(extractedHast, options?.normalize);
   const mdast = toMdast(extractedHast, {
     handlers: {
       math: mathHandler,
       div: customDivHandler,
       pre: customCodeHandler,
+      dl: definitionListHandler,
+      sup: supSubHandler("sup"),
+      sub: supSubHandler("sub"),
       a: customAHandler({ asText: options?.linkAsText }),
       img: customImgHandler({ hideImage: options?.hideImage }),
       table: customTableHandler({ asText: options?.tableAsText })

package/dist/index.js

@@ -1,19 +1,62 @@
 // src/index.ts
-import { htmlToMarkdown } from "./html-to-markdown.js";
+import {
+  htmlToMarkdown,
+  htmlToMarkdownWithMetadata
+} from "./html-to-markdown.js";
 import { mdastSplitter } from "./md-splitter.js";
 import { htmlToMdast } from "./html-to-mdast.js";
 import { mdastToMarkdown } from "./mdast-to-markdown.js";
 import {
   pipeExtractors,
+  autoExtractor,
+  createAutoExtractor,
   takumiExtractor,
   minimalFilter
 } from "./extractors/index.js";
+import {
+  BUILTIN_ADAPTERS,
+  adapterById,
+  buildPageSignature,
+  defineSelectorAdapter,
+  resolveAdapter,
+  runAdapters,
+  youtubeCaptionTracks
+} from "./adapters/index.js";
+import {
+  detectClientShell,
+  SHELL_EMPTY_THRESHOLD,
+  SHELL_SUSPICION_THRESHOLD
+} from "./detect-client-shell.js";
+import {
+  extractMetaRefresh,
+  MAX_META_REFRESH_DELAY_SECONDS
+} from "./extract-meta-refresh.js";
+import { extractMetadata, toFrontmatter } from "./metadata/index.js";
+import { normalizeHast } from "./normalize/index.js";
 export {
+  BUILTIN_ADAPTERS,
+  MAX_META_REFRESH_DELAY_SECONDS,
+  SHELL_EMPTY_THRESHOLD,
+  SHELL_SUSPICION_THRESHOLD,
+  adapterById,
+  autoExtractor,
+  buildPageSignature,
+  createAutoExtractor,
+  defineSelectorAdapter,
+  detectClientShell,
+  extractMetaRefresh,
+  extractMetadata,
   htmlToMarkdown,
+  htmlToMarkdownWithMetadata,
   htmlToMdast,
   mdastSplitter,
   mdastToMarkdown,
   minimalFilter,
+  normalizeHast,
   pipeExtractors,
-  takumiExtractor
+  resolveAdapter,
+  runAdapters,
+  takumiExtractor,
+  toFrontmatter,
+  youtubeCaptionTracks
 };

package/dist/link-replacer.js

@@ -1,17 +1,23 @@
 // src/link-replacer.ts
-var linkReplacer = (markdown, base) => {
-  const regex = /(!?\[.*?\]\()([^)\s]+)(\))/g;
-  return markdown.replace(regex, (match, pre, url, post) => {
-    if (/^(https?:|#)/.test(url)) {
-      return match;
-    }
-    try {
-      const absoluteUrl = new URL(url, base).href;
-      return `${pre}${absoluteUrl}${post}`;
-    } catch {
-      return match;
-    }
-  });
+var absoluteUrl = (url, base) => {
+  if (/^(?:[a-z][a-z\d+.-]*:|#)/i.test(url)) {
+    return url;
+  }
+  try {
+    return new URL(url, base).href;
+  } catch {
+    return url;
+  }
+};
+var linkReplacer = (node, base) => {
+  let result = node;
+  if (node.type === "link" || node.type === "image" || node.type === "definition") {
+    result = { ...node, url: absoluteUrl(node.url, base) };
+  }
+  if ("children" in result) {
+    return { ...result, children: result.children.map((child) => linkReplacer(child, base)) };
+  }
+  return result;
 };
 export {
   linkReplacer

package/dist/loaders/cf-puppeteer.js

@@ -1,14 +1,21 @@
 // src/loaders/cf-puppeteer.ts
-import puppeteer from "@cloudflare/puppeteer";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+import puppeteer, { TimeoutError } from "@cloudflare/puppeteer";
 var loadHtml = async (url, ctx) => {
   const browser = await puppeteer.launch(ctx);
-  const page = await browser.newPage();
-  await page.goto(url);
-  const html = await page.content();
-  await Promise.race([page.waitForNetworkIdle(), sleep(1e4)]);
-  await page.close();
-  return html;
+  try {
+    const page = await browser.newPage();
+    await page.goto(url);
+    try {
+      await page.waitForNetworkIdle({ timeout: 1e4 });
+    } catch (error) {
+      if (!(error instanceof TimeoutError)) {
+        throw error;
+      }
+    }
+    return await page.content();
+  } finally {
+    await browser.close();
+  }
 };
 export {
   loadHtml

package/dist/loaders/fetch.js

@@ -1,8 +1,20 @@
 // src/loaders/fetch.ts
+import { extractMetaRefresh } from "../extract-meta-refresh.js";
 var USER_AGENT = "mozilla/5.0 (windows nt 10.0; win64; x64) applewebkit/537.36 (khtml, like gecko) chrome/125.0.0.0 safari/537.36";
+var MAX_META_REFRESH_HOPS = 3;
 var loadHtml = async (url, userAgent = USER_AGENT) => {
-  const response = await fetch(url, { headers: { "User-Agent": userAgent } });
-  return response.text();
+  let current = url;
+  let html = "";
+  for (let hop = 0; hop <= MAX_META_REFRESH_HOPS; hop++) {
+    const response = await fetch(current, { headers: { "User-Agent": userAgent } });
+    html = await response.text();
+    const refresh = extractMetaRefresh(html, response.url || current);
+    if (!refresh) {
+      break;
+    }
+    current = refresh.url;
+  }
+  return html;
 };
 export {
   USER_AGENT,

package/dist/loaders/playwright.js

@@ -13,40 +13,42 @@ var SUPER_BYPASS_DEVICE = {
 var loadHtml = async (url, options) => {
   const { browser, waitUntil, timeout, superBypassMode } = options ?? {};
   const _browser = browser ?? await chromium.launch({ headless: true });
-  const context = await _browser.newContext(superBypassMode ? SUPER_BYPASS_DEVICE : devices["Desktop Chrome"]);
-  if (superBypassMode) {
-    await context.addInitScript(() => {
-      Object.defineProperty(navigator, "webdriver", { get: () => void 0 });
-      Object.defineProperty(navigator, "languages", { get: () => ["en-US", "en"] });
-      Object.defineProperty(navigator, "plugins", { get: () => [1, 2, 3, 4, 5] });
-    });
-  }
-  const page = await context.newPage();
-  if (superBypassMode) {
-    await page.route("**/*.js", (route) => {
-      if (route.request().url().includes("captcha-delivery")) {
-        return route.abort();
+  let context;
+  try {
+    context = await _browser.newContext(superBypassMode ? SUPER_BYPASS_DEVICE : devices["Desktop Chrome"]);
+    if (superBypassMode) {
+      await context.addInitScript(() => {
+        Object.defineProperty(navigator, "webdriver", { get: () => void 0 });
+        Object.defineProperty(navigator, "languages", { get: () => ["en-US", "en"] });
+        Object.defineProperty(navigator, "plugins", { get: () => [1, 2, 3, 4, 5] });
+      });
+    }
+    const page = await context.newPage();
+    if (superBypassMode) {
+      await page.route("**/*.js", (route) => {
+        if (route.request().url().includes("captcha-delivery")) {
+          return route.abort();
+        }
+        return route.continue();
+      });
+    }
+    await page.goto(url, { waitUntil: waitUntil ?? "load", timeout });
+    await page.evaluate(() => {
+      const elements = document.querySelectorAll("*");
+      for (const element of elements) {
+        const rect = element.getBoundingClientRect();
+        element.setAttribute("data-rwidth", rect.width.toString());
+        element.setAttribute("data-rheight", rect.height.toString());
       }
-      return route.continue();
     });
-  }
-  await page.goto(url, { waitUntil: waitUntil ?? "load", timeout });
-  await page.evaluate(() => {
-    const elements = document.querySelectorAll("*");
-    for (const element of elements) {
-      const rect = element.getBoundingClientRect();
-      element.setAttribute("data-rwidth", rect.width.toString());
-      element.setAttribute("data-rheight", rect.height.toString());
+    return await page.content();
+  } finally {
+    if (browser) {
+      await context?.close();
+    } else {
+      await _browser.close();
     }
-  });
-  const html = await page.content();
-  await page.close();
-  if (browser) {
-    await context.close();
-  } else {
-    await _browser.close();
   }
-  return html;
 };
 export {
   loadHtml

package/dist/loaders/puppeteer.js

@@ -1,6 +1,5 @@
 // src/loaders/puppeteer.ts
-import puppeteer from "puppeteer";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+import puppeteer, { TimeoutError } from "puppeteer";
 var loadHtml = async (url, ctx) => {
   const browser = await puppeteer.launch(
     ctx || {
@@ -8,12 +7,20 @@ var loadHtml = async (url, ctx) => {
       args: ["--no-sandbox", "--disable-setuid-sandbox"]
     }
   );
-  const page = await browser.newPage();
-  await page.goto(url);
-  const html = await page.content();
-  await Promise.race([page.waitForNetworkIdle(), sleep(1e4)]);
-  await browser.close();
-  return html;
+  try {
+    const page = await browser.newPage();
+    await page.goto(url);
+    try {
+      await page.waitForNetworkIdle({ timeout: 1e4 });
+    } catch (error) {
+      if (!(error instanceof TimeoutError)) {
+        throw error;
+      }
+    }
+    return await page.content();
+  } finally {
+    await browser.close();
+  }
 };
 export {
   loadHtml

package/dist/md-splitter.js

@@ -3,15 +3,13 @@ import { mdastToMarkdown } from "./mdast-to-markdown.js";
 import { chunk } from "./utils/common.js";
 import { internalType, unwarpRoot, warpRoot } from "./utils/mdast-utils.js";
 var PRIORITY_SPLITTERS = ["h1", "h2", "h3", "h4", "h5", "h6", "list", "table", "code"];
-var getSplitterGenerator = function* () {
-  for (const splitter of PRIORITY_SPLITTERS) {
-    yield splitter;
-  }
-};
-var _mdastSplitter = async (contents, checker, splitterGenerator) => {
-  const splitter = splitterGenerator.next().value;
+var _mdastSplitter = async (contents, checker, priority, signal) => {
+  signal?.throwIfAborted();
+  const splitter = PRIORITY_SPLITTERS[priority];
   const markdown = mdastToMarkdown(warpRoot(contents));
-  if (await checker(markdown) || contents.length === 1) {
+  const accepted = await checker(markdown);
+  signal?.throwIfAborted();
+  if (accepted || contents.length === 1) {
     return [contents];
   }
   const chunked = splitter ? contents.reduce((acc, content) => {
@@ -22,11 +20,26 @@ var _mdastSplitter = async (contents, checker, splitterGenerator) => {
     acc[acc.length - 1].push(content);
     return acc;
   }, []) : chunk(contents, Math.ceil(contents.length / 2));
-  const splitting = chunked.map((chunk2) => _mdastSplitter(chunk2, checker, splitterGenerator));
+  const splitting = chunked.map((chunk2) => _mdastSplitter(chunk2, checker, priority + 1, signal));
   return Promise.all(splitting).then((chunks) => chunks.flat());
 };
-var mdastSplitter = (mdast, checker, _options) => {
-  return _mdastSplitter(unwarpRoot(mdast), checker, getSplitterGenerator());
+var mdastSplitter = async (mdast, checker, options) => {
+  const signal = options?.signal;
+  if (!signal) {
+    return _mdastSplitter(unwarpRoot(mdast), checker, 0);
+  }
+  signal.throwIfAborted();
+  let onAbort = () => {
+  };
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([_mdastSplitter(unwarpRoot(mdast), checker, 0, signal), aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
 };
 export {
   mdastSplitter