webforai 4.0.0 → 4.1.0

package/dist/extractors/presets/kiwame.js

@@ -0,0 +1,206 @@
+// src/extractors/presets/kiwame.ts
+import { MetricsCollector, cloneHast, findElement, isElement, walk } from "../../utils/hast-fast.js";
+import { FEATURE_COUNT, STACKED_FEATURE_COUNT, blockFeatures, stackedFeatures } from "../lib/block-features.js";
+import { isUsableModel, scoreBlocks } from "../lib/block-model.js";
+import { BLOCK_MODEL, BLOCK_STACK_MODEL } from "../lib/block-model.generated.js";
+import { BLOCK_TAGS, segmentBlocks } from "../lib/blocks.js";
+import { unwrapLayoutTables } from "../lib/layout-tables.js";
+import { REFERENCE_HEADING, cleanContent, stripNonContent } from "../lib/sanitize.js";
+import { takumiSelection } from "../lib/takumi-signal.js";
+import { takumiExtractor } from "./takumi.js";
+var DEFAULT_THRESHOLD = 0.47;
+var findBody = (hast) => findElement(hast, (element) => element.tagName === "body") ?? hast;
+var completeTables = (kept, blocks) => {
+  const rows = /* @__PURE__ */ new Set();
+  const tables = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if (!kept.has(block.owner)) {
+      continue;
+    }
+    const { row, table } = enclosingTable(block.frame);
+    if (row) {
+      rows.add(row);
+    }
+    if (table) {
+      tables.add(table);
+    }
+  }
+  for (const table of tables) {
+    const first = findElement(table, (element) => element.tagName === "tr");
+    if (first) {
+      rows.add(first);
+    }
+  }
+  for (const block of blocks) {
+    const { row } = enclosingTable(block.frame);
+    if (row && rows.has(row)) {
+      kept.add(block.owner);
+    }
+  }
+};
+var enclosingTable = (start) => {
+  let row;
+  for (let frame = start; frame; frame = frame.parent) {
+    const tag = frame.element.tagName;
+    if (tag === "tr" && !row) {
+      row = frame.element;
+    } else if (tag === "table") {
+      return { row, table: frame.element };
+    }
+  }
+  return { row };
+};
+var HEADING_LOOKAHEAD = 3;
+var keepSectionHeadings = (kept, blocks) => {
+  let seenKept = false;
+  for (let index = 0; index < blocks.length; index++) {
+    const block = blocks[index];
+    if (kept.has(block.owner)) {
+      seenKept = true;
+      continue;
+    }
+    if (!(seenKept && /^h[1-6]$/.test(block.owner.tagName))) {
+      continue;
+    }
+    for (let next = index + 1; next < Math.min(blocks.length, index + 1 + HEADING_LOOKAHEAD); next++) {
+      if (/^h[1-6]$/.test(blocks[next].owner.tagName)) {
+        break;
+      }
+      if (kept.has(blocks[next].owner)) {
+        kept.add(block.owner);
+        break;
+      }
+    }
+  }
+};
+var CODE_IN_CONTENT_THRESHOLD = 0.2;
+var CODE_CONTEXT = 6;
+var keepCodeInContent = (kept, blocks, probabilities) => {
+  const keptIndex = blocks.map((block) => kept.has(block.owner));
+  const near = (from, step) => {
+    for (let distance = 1; distance <= CODE_CONTEXT; distance++) {
+      const index = from + step * distance;
+      if (index < 0 || index >= blocks.length) {
+        return false;
+      }
+      if (keptIndex[index]) {
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const block of blocks) {
+    if (block.owner.tagName === "pre" && !keptIndex[block.index] && probabilities[block.index] >= CODE_IN_CONTENT_THRESHOLD && near(block.index, -1) && near(block.index, 1)) {
+      kept.add(block.owner);
+    }
+  }
+};
+var listOf = (block) => {
+  if (block.owner.tagName !== "li") {
+    return void 0;
+  }
+  for (let frame = block.frame.parent; frame; frame = frame.parent) {
+    const tag = frame.element.tagName;
+    if (tag === "ul" || tag === "ol") {
+      return frame.element;
+    }
+  }
+  return void 0;
+};
+var keepAuthoredLists = (kept, blocks) => {
+  let seenKept = false;
+  for (let index = 0; index < blocks.length - 1; index++) {
+    const block = blocks[index];
+    const introducesList = kept.has(block.owner) && /[:：]\s*$/.test(block.text) || seenKept && /^h[1-6]$/.test(block.owner.tagName) && REFERENCE_HEADING.test(block.text.trim());
+    seenKept ||= kept.has(block.owner);
+    const list = listOf(blocks[index + 1]);
+    if (!(introducesList && list)) {
+      continue;
+    }
+    kept.add(block.owner);
+    for (let next = index + 1; next < blocks.length && listOf(blocks[next]) === list; next++) {
+      kept.add(blocks[next].owner);
+    }
+  }
+};
+var pruneToBlocks = (element, kept, ownerKept) => {
+  const isBlock = element.type === "element" && (BLOCK_TAGS.has(element.tagName) || element.tagName === "pre");
+  const selfKept = isBlock ? kept.has(element) : ownerKept;
+  if (element.type === "element" && element.tagName === "pre") {
+    return selfKept;
+  }
+  let keepChildren = false;
+  const children = [];
+  for (const child of element.children) {
+    if (child.type === "element") {
+      if (pruneToBlocks(child, kept, selfKept)) {
+        children.push(child);
+        keepChildren = true;
+      }
+    } else if (child.type === "text") {
+      if (selfKept) {
+        children.push(child);
+      }
+    } else {
+      children.push(child);
+    }
+  }
+  element.children = children;
+  return selfKept || keepChildren;
+};
+var createKiwameExtractor = (options = {}) => {
+  const { threshold = DEFAULT_THRESHOLD, model = BLOCK_MODEL, cleanup = true } = options;
+  const stackModel = options.stackModel === void 0 ? BLOCK_STACK_MODEL : options.stackModel;
+  const usable = isUsableModel(model);
+  const stackUsable = stackModel ? isUsableModel(stackModel, STACKED_FEATURE_COUNT) : false;
+  return (params) => {
+    if (!usable) {
+      return takumiExtractor(params);
+    }
+    const { hast, lang, owned } = params;
+    const body = owned ? findBody(hast) : cloneHast(findBody(hast));
+    stripNonContent(body);
+    const blocks = segmentBlocks(body);
+    if (blocks.length === 0 || !(isElement(body) || body.type === "root")) {
+      return body;
+    }
+    const collector = new MetricsCollector();
+    const takumiKept = takumiSelection(body, lang, params.url);
+    const features = blockFeatures({ root: body, blocks, collector, lang, takumiKept });
+    let probabilities = scoreBlocks(features, blocks.length, model, FEATURE_COUNT);
+    if (stackModel && stackUsable) {
+      const stacked = stackedFeatures(blocks, features, probabilities);
+      probabilities = scoreBlocks(stacked, blocks.length, stackModel, STACKED_FEATURE_COUNT);
+    }
+    const kept = /* @__PURE__ */ new Set();
+    for (const block of blocks) {
+      if (probabilities[block.index] >= threshold) {
+        kept.add(block.owner);
+      }
+    }
+    if (kept.size === 0) {
+      return takumiExtractor({ hast: body, lang, url: params.url, owned: true });
+    }
+    keepCodeInContent(kept, blocks, probabilities);
+    keepSectionHeadings(kept, blocks);
+    keepAuthoredLists(kept, blocks);
+    completeTables(kept, blocks);
+    pruneToBlocks(body, kept, false);
+    unwrapLayoutTables(body);
+    if (!cleanup) {
+      return body;
+    }
+    walk(body, (node) => {
+      if (isElement(node) && (node.tagName === "form" || node.tagName === "fieldset")) {
+        node.tagName = "div";
+      }
+    });
+    return cleanContent(body, new MetricsCollector());
+  };
+};
+var kiwameExtractor = createKiwameExtractor();
+export {
+  DEFAULT_THRESHOLD,
+  createKiwameExtractor,
+  kiwameExtractor
+};

package/dist/extractors/presets/takumi.js

@@ -12,6 +12,7 @@ import { cleanContent, findCleanupTargets, findUnlikelyElements, stripNonContent
 import { buildScoringContext, climbToArticleBoundary, collectArticleNodes, scoreCandidates } from "../lib/score.js";
 import { truncateTrailingBoilerplate } from "../lib/terminators.js";
 var MIN_RETAINED_FRACTION = 0.25;
+var FURNITURE_LINK_DENSITY = 0.5;
 var SEMANTIC_SELECTORS = [
   (element) => stringProperty(element, "itemprop")?.includes("articleBody") ?? false,
   (element) => element.tagName === "article",
@@ -49,6 +50,31 @@ var collectMatching = (tree, matches, into) => {
     }
   }
 };
+var containsTag = (element, tagName) => element.children.some((child) => isElement(child) && (child.tagName === tagName || containsTag(child, tagName)));
+var removesEveryTitle = (root, doomed) => {
+  if (!doomed.some((element) => containsTag(element, "h1"))) {
+    return false;
+  }
+  const doomedSet = new Set(doomed);
+  let survivor = false;
+  const visit = (node) => {
+    if (survivor || !("children" in node)) {
+      return;
+    }
+    for (const child of node.children) {
+      if (!isElement(child) || doomedSet.has(child)) {
+        continue;
+      }
+      if (child.tagName === "h1") {
+        survivor = true;
+        return;
+      }
+      visit(child);
+    }
+  };
+  visit(root);
+  return !survivor;
+};
 var asRootOf = (nodes) => ({ type: "root", children: nodes });
 var scoredSelection = (tree, collector, lang) => {
   const context = buildScoringContext(tree, collector, lang);
@@ -75,9 +101,14 @@ var takumiExtractor = (params) => {
   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)) {
+  let doomed = findUnlikelyElements(searchRoot);
+  const textOf = (elements) => elements.reduce((sum, element) => sum + collector.metrics(element).text, 0);
+  let acceptable = searchText - textOf(doomed) > Math.max(minLength, searchText * MIN_RETAINED_FRACTION);
+  if (!acceptable) {
+    doomed = findUnlikelyElements(searchRoot, (element) => collector.linkDensity(element) < FURNITURE_LINK_DENSITY);
+    acceptable = doomed.length > 0 && searchText - textOf(doomed) >= minLength && !removesEveryTitle(searchRoot, doomed);
+  }
+  if (acceptable) {
     const doomedSet = new Set(doomed);
     pruneInPlace(searchRoot, (node) => !(isElement(node) && doomedSet.has(node)));
     collector = new MetricsCollector();

package/dist/html-to-markdown.js

@@ -1,12 +1,12 @@
 // src/html-to-markdown.ts
-import { fromHtml } from "hast-util-from-html";
+import { parseHtml } from "./utils/parse-html.js";
 import { htmlToMdast } from "./html-to-mdast.js";
 import { mdastToMarkdown } from "./mdast-to-markdown.js";
 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 hast = typeof htmlOrHast === "string" ? parseHtml(htmlOrHast, { fragment: true }) : htmlOrHast;
   const isOwned = typeof htmlOrHast === "string";
   const declaredLang = typeof htmlOrHast === "string" ? getLangFromStr(htmlOrHast) : void 0;
   const metadata = extractMetadata(hast);
@@ -20,10 +20,54 @@ var htmlToMarkdownWithMetadata = (htmlOrHast, options) => {
     url: toMdastOptions.url ?? metadata.canonicalUrl
   });
   const body = mdastToMarkdown(mdast, { baseUrl, ...toMarkdownOptions });
-  const titled = title === false ? body : withTitle(body, metadata.title);
+  const pageUrl = toMdastOptions.url ?? metadata.canonicalUrl;
+  const titled = title === false ? body : withTitle(body, headingTitle(metadata.title, metadata.siteName, pageUrl));
   const markdown = frontmatter ? `${toFrontmatter(metadata)}${titled}` : titled;
   return { markdown, metadata };
 };
+var TITLE_SEPARATOR = /\s+[-|–—·•:]\s+|\s*[｜|]\s*/;
+var SITE_SECTION = /^(docs|documentation|blog|news|wiki|developers?|devblog|help|support|reference)$/;
+var compact = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+var siteNames = (siteName, url) => {
+  const names = siteName ? siteName.split(TITLE_SEPARATOR).map(compact) : [];
+  try {
+    const labels = url ? new URL(url).hostname.split(".") : [];
+    const meaningful = labels.slice(0, -1).filter((label) => label !== "www");
+    names.push(...meaningful.map(compact), compact(meaningful.join("")), compact(labels.join("").replace(/^www/, "")));
+  } catch {
+  }
+  return names.filter((name) => name.length >= 3);
+};
+var headingTitle = (title, siteName, url) => {
+  if (!title) {
+    return title;
+  }
+  const segments = title.split(TITLE_SEPARATOR);
+  if (segments.length < 2) {
+    return title;
+  }
+  const names = siteNames(siteName, url);
+  if (names.length === 0) {
+    return title;
+  }
+  const isSite = (segment) => {
+    const value = compact(segment);
+    return value.length > 0 && names.some((name) => value === name || value.startsWith(name) && SITE_SECTION.test(value.slice(name.length)));
+  };
+  const last = segments[segments.length - 1];
+  if (isSite(last)) {
+    return stripSegment(title, last, "end");
+  }
+  if (siteName && compact(segments[0]) === compact(siteName)) {
+    return stripSegment(title, segments[0], "start");
+  }
+  return title;
+};
+var stripSegment = (title, segment, edge) => {
+  const rest = edge === "end" ? title.slice(0, title.lastIndexOf(segment)) : title.slice(segment.length);
+  const trimmed = rest.replace(edge === "end" ? /[\s\-|–—·•:｜]+$/ : /^[\s\-|–—·•:｜]+/, "");
+  return trimmed.length > 0 ? trimmed : title;
+};
 var TITLE_LOOKAHEAD = 400;
 var withTitle = (body, title) => {
   if (!title) {
@@ -33,16 +77,25 @@ var withTitle = (body, title) => {
   if (/^#\s+\S/m.test(opening)) {
     return body;
   }
-  if (normalizeForCompare(opening).includes(normalizeForCompare(title))) {
+  if (mentionsTitle(opening, title)) {
     return body;
   }
   return `# ${title}
 
 ${body}`;
 };
+var MIN_EMBEDDED_TITLE_LENGTH = 24;
+var mentionsTitle = (opening, title) => {
+  const wanted = normalizeForCompare(title);
+  if (wanted.length >= MIN_EMBEDDED_TITLE_LENGTH) {
+    return normalizeForCompare(opening).includes(wanted);
+  }
+  return opening.split("\n").some((line) => normalizeForCompare(line.replace(/[#*_`>]/g, "")) === wanted);
+};
 var normalizeForCompare = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
 var htmlToMarkdown = (htmlOrHast, options) => htmlToMarkdownWithMetadata(htmlOrHast, options).markdown;
 export {
+  headingTitle,
   htmlToMarkdown,
   htmlToMarkdownWithMetadata
 };

package/dist/html-to-mdast.js

@@ -1,6 +1,6 @@
 // src/html-to-mdast.ts
-import { fromHtml } from "hast-util-from-html";
 import { toMdast } from "hast-util-to-mdast";
+import { parseHtml } from "./utils/parse-html.js";
 import { extractMdast } from "./extract-mdast.js";
 import { pipeExtractors } from "./extractors/index.js";
 import { customAHandler } from "./mdast-handlers/custom-a-handler.js";
@@ -16,7 +16,7 @@ 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 [lang, hast] = typeof htmlOrHast === "string" ? [defaultLang || getLangFromStr(htmlOrHast), parseHtml(htmlOrHast, { fragment: true })] : [defaultLang || getLangFromHast(htmlOrHast), htmlOrHast];
   const isOwned = typeof htmlOrHast === "string" || (options?.owned ?? false);
   const url = defaultUrl || getUrlFromHast(hast);
   const extractedHast = pipeExtractors({ hast: isOwned ? hast : cloneHast(hast), lang, url, owned: true }, extractors);

package/dist/index.js

@@ -11,6 +11,8 @@ import {
   autoExtractor,
   createAutoExtractor,
   takumiExtractor,
+  kiwameExtractor,
+  createKiwameExtractor,
   minimalFilter
 } from "./extractors/index.js";
 import {
@@ -42,6 +44,7 @@ export {
   autoExtractor,
   buildPageSignature,
   createAutoExtractor,
+  createKiwameExtractor,
   defineSelectorAdapter,
   detectClientShell,
   extractMetaRefresh,
@@ -49,6 +52,7 @@ export {
   htmlToMarkdown,
   htmlToMarkdownWithMetadata,
   htmlToMdast,
+  kiwameExtractor,
   mdastSplitter,
   mdastToMarkdown,
   minimalFilter,

package/dist/mdast-handlers/custom-code-handler.js

@@ -1,8 +1,9 @@
 // src/mdast-handlers/custom-code-handler.ts
-import { toText } from "hast-util-to-text";
 import { trimTrailingLines } from "trim-trailing-lines";
 import { detectLanguage } from "../utils/detect-code-lang.js";
 import { classList, isElement } from "../utils/hast-fast.js";
+import { preText } from "../utils/pre-text.js";
+import { cleanTwoslash } from "./twoslash.js";
 var LANGUAGE_MATCH_REGEX = [/^language-(\S+)$/, /^highlight-source-(\S+)$/, /^CodeBlock--language-(\S+)$/];
 var LANGUAGE_ATTRIBUTES = ["dataLanguage", "dataLang"];
 var attributeLanguage = (element) => {
@@ -15,16 +16,26 @@ var attributeLanguage = (element) => {
   return void 0;
 };
 var codeLanguage = (...elements) => elements.flatMap(classList).map((className) => LANGUAGE_MATCH_REGEX.map((regex) => className.match(regex)).find(Boolean)?.[1]).find(Boolean) ?? elements.map(attributeLanguage).find(Boolean);
+var codeMeta = (pre) => {
+  const title = pre.properties?.dataTitle;
+  if (typeof title !== "string") {
+    return null;
+  }
+  const clean = title.replace(/["\r\n]+/g, " ").trim();
+  return clean ? `title="${clean}"` : null;
+};
 var customCodeHandler = (state, node) => {
+  const twoslashLang = cleanTwoslash(node);
   const code = node.children.find((child) => isElement(child) && child.tagName === "code");
-  const codeValue = trimTrailingLines(toText(node));
-  const classLang = codeLanguage(...isElement(code) ? [code, node] : [node]);
+  const codeValue = trimTrailingLines(preText(node));
+  const classLang = twoslashLang || codeLanguage(...isElement(code) ? [code, node] : [node]);
   const lang = classLang || detectLanguage(codeValue) || null;
-  const result = { type: "code", lang, meta: null, value: codeValue };
+  const result = { type: "code", lang, meta: codeMeta(node), value: codeValue };
   state.patch(node, result);
   return result;
 };
 export {
   codeLanguage,
+  codeMeta,
   customCodeHandler
 };

package/dist/mdast-handlers/custom-div-handler.js

@@ -2,11 +2,11 @@
 import { select } from "hast-util-select";
 import { defaultHandlers } from "hast-util-to-mdast";
 import { toString as hastToString } from "hast-util-to-string";
-import { toText } from "hast-util-to-text";
 import { trimTrailingLines } from "trim-trailing-lines";
 import { detectLanguage } from "../utils/detect-code-lang.js";
 import { classList, collectElements, isElement } from "../utils/hast-fast.js";
-import { codeLanguage } from "./custom-code-handler.js";
+import { preText } from "../utils/pre-text.js";
+import { codeLanguage, codeMeta } from "./custom-code-handler.js";
 var CODE_BLOCK_REGEX = /highlight-source|language-|codegroup|codeblock|code-block/i;
 var CODE_FILENAME_SELECTORS = "[class*='fileName'],[class*='fileName'],[class*='title'],[class*='Title']";
 var customDivHandler = (state, node) => {
@@ -17,13 +17,13 @@ var customDivHandler = (state, node) => {
   const codeBlocks = collectElements(node, (element) => element.tagName === "pre");
   const codeBlock = codeBlocks.length === 1 ? codeBlocks[0] : void 0;
   if (codeBlock) {
-    const codeValue = trimTrailingLines(toText(codeBlock));
+    const codeValue = trimTrailingLines(preText(codeBlock));
     const filenameElement = select(CODE_FILENAME_SELECTORS, node);
     const fileLang = filenameElement ? hastToString(filenameElement).match(/\.(\w+)$/)?.[1] : null;
     const code = codeBlock.children.find((child) => isElement(child) && child.tagName === "code");
     const classLang = codeLanguage(...isElement(code) ? [code, codeBlock, node] : [codeBlock, node]);
     const lang = fileLang || classLang || detectLanguage(codeValue) || null;
-    const result = { type: "code", lang, meta: null, value: codeValue };
+    const result = { type: "code", lang, meta: codeMeta(codeBlock), value: codeValue };
     state.patch(node, result);
     return result;
   }

package/dist/mdast-handlers/custom-img-handler.js

@@ -12,11 +12,20 @@ var hasNoUsableSource = (node) => {
   }
   return false;
 };
+var PLACEHOLDER_FILE = /^(?:[\w-]*[-_.])?placeholder[\w-]*\.(?:gif|png|svg|webp|jpe?g)$|^(?:spacer|blank|transparent|pixel)\.(?:gif|png)$/i;
+var isUndescribedPlaceholder = (node) => {
+  if (stringProperty(node, "alt")?.trim() || stringProperty(node, "title")?.trim()) {
+    return false;
+  }
+  const src = stringProperty(node, "src") ?? "";
+  const file = src.split(/[?#]/)[0].split("/").pop() ?? "";
+  return PLACEHOLDER_FILE.test(file);
+};
 var customImgHandler = (options) => (state, node) => {
   if (options?.hideImage) {
     return void 0;
   }
-  if (hasNoUsableSource(node)) {
+  if (hasNoUsableSource(node) || isUndescribedPlaceholder(node)) {
     return void 0;
   }
   const image = defaultHandlers.image(state, node);

package/dist/mdast-handlers/custom-table-handler.js

@@ -1,7 +1,8 @@
 // src/mdast-handlers/custom-table-handler.ts
 import { defaultHandlers } from "hast-util-to-mdast";
 import { toText } from "hast-util-to-text";
-import { isElement, numericProperty, walk } from "../utils/hast-fast.js";
+import { findElement, isElement, numericProperty, walk } from "../utils/hast-fast.js";
+import { flattenTableCells, tableHasCodeSamples, unfoldTable } from "./table-cell-flatten.js";
 var MAX_SPAN = 1e3;
 var clampSpans = (node) => {
   walk(node, (candidate) => {
@@ -16,6 +17,14 @@ var clampSpans = (node) => {
     }
   });
 };
+var startsWithHeaderRow = (table) => {
+  const row = findElement(table, (element) => element.tagName === "tr");
+  if (!row) {
+    return false;
+  }
+  const cells = row.children.filter(isElement);
+  return cells.length > 0 && cells.every((cell) => cell.tagName === "th");
+};
 var customTableHandler = (options) => (state, node) => {
   if (options?.asText) {
     const paragraph = { type: "paragraph", children: [{ type: "text", value: toText(node) }] };
@@ -23,7 +32,15 @@ var customTableHandler = (options) => (state, node) => {
     return paragraph;
   }
   clampSpans(node);
-  return defaultHandlers.table(state, node);
+  const result = defaultHandlers.table(state, node);
+  if (!result || Array.isArray(result) || result.type !== "table") {
+    return result;
+  }
+  if (tableHasCodeSamples(result)) {
+    return unfoldTable(result, startsWithHeaderRow(node));
+  }
+  flattenTableCells(result);
+  return result;
 };
 export {
   customTableHandler